feat(context): binding filters

Co-Authored-By: Raymond Feng <raymondfeng@users.noreply.github.com>

Author: bajtos

packages/context/src/binding-filter.ts

@@ -0,0 +1,72 @@
+// Copyright IBM Corp. 2018. All Rights Reserved.
+// Node module: @loopback/context
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {Binding, BindingTag} from './binding';
+
+/**
+ * A function that filters bindings. It returns `true` to select a given
+ * binding.
+ */
+export type BindingFilter<ValueType = unknown> = (
+  binding: Readonly<Binding<ValueType>>,
+) => boolean;
+
+/**
+ * Create a binding filter for the tag pattern
+ * @param tagPattern Binding tag name, regexp, or object
+ */
+export function filterByTag(tagPattern: BindingTag | RegExp): BindingFilter {
+  if (typeof tagPattern === 'string' || tagPattern instanceof RegExp) {
+    const regexp =
+      typeof tagPattern === 'string'
+        ? wildcardToRegExp(tagPattern)
+        : tagPattern;
+    return b => Array.from(b.tagNames).some(t => regexp!.test(t));
+  } else {
+    return b => {
+      for (const t in tagPattern) {
+        // One tag name/value does not match
+        if (b.tagMap[t] !== tagPattern[t]) return false;
+      }
+      // All tag name/value pairs match
+      return true;
+    };
+  }
+}
+
+/**
+ * Create a binding filter from key pattern
+ * @param keyPattern Binding key/wildcard, regexp, or a filter function
+ */
+export function filterByKey(
+  keyPattern?: string | RegExp | BindingFilter,
+): BindingFilter {
+  if (typeof keyPattern === 'string') {
+    const regex = wildcardToRegExp(keyPattern);
+    return binding => regex.test(binding.key);
+  } else if (keyPattern instanceof RegExp) {
+    return binding => keyPattern.test(binding.key);
+  } else if (typeof keyPattern === 'function') {
+    return keyPattern;
+  }
+  return () => true;
+}
+
+/**
+ * Convert a wildcard pattern to RegExp
+ * @param pattern A wildcard string with `*` and `?` as special characters.
+ * - `*` matches zero or more characters except `.` and `:`
+ * - `?` matches exactly one character except `.` and `:`
+ */
+function wildcardToRegExp(pattern: string): RegExp {
+  // Escape reserved chars for RegExp:
+  // `- \ ^ $ + . ( ) | { } [ ] :`
+  let regexp = pattern.replace(/[\-\[\]\/\{\}\(\)\+\.\\\^\$\|\:]/g, '\\$&');
+  // Replace wildcard chars `*` and `?`
+  // `*` matches zero or more characters except `.` and `:`
+  // `?` matches one character except `.` and `:`
+  regexp = regexp.replace(/\*/g, '[^.:]*').replace(/\?/g, '[^.:]');
+  return new RegExp(`^${regexp}$`);
+}

packages/context/src/context.ts

@@ -10,6 +10,7 @@ import {Binding, BindingTag} from './binding';
 import {BindingAddress, BindingKey} from './binding-key';
 import {ResolutionOptions, ResolutionSession} from './resolution-session';
 import {BoundValue, getDeepProperty, isPromiseLike} from './value-promise';
+import {BindingFilter, filterByKey, filterByTag} from './binding-filter';
 
 const debug = debugModule('loopback:context');
 
@@ -21,7 +22,15 @@ export class Context {
    * Name of the context
    */
   readonly name: string;
+
+  /**
+   * Key to binding map as the internal registry
+   */
   protected readonly registry: Map<string, Binding> = new Map();
+
+  /**
+   * Parent context
+   */
   protected _parent?: Context;
 
   /**
@@ -127,61 +136,25 @@ export class Context {
     return undefined;
   }
 
-  /**
-   * Convert a wildcard pattern to RegExp
-   * @param pattern A wildcard string with `*` and `?` as special characters.
-   * - `*` matches zero or more characters except `.` and `:`
-   * - `?` matches exactly one character except `.` and `:`
-   */
-  private wildcardToRegExp(pattern: string): RegExp {
-    // Escape reserved chars for RegExp:
-    // `- \ ^ $ + . ( ) | { } [ ] :`
-    let regexp = pattern.replace(/[\-\[\]\/\{\}\(\)\+\.\\\^\$\|\:]/g, '\\$&');
-    // Replace wildcard chars `*` and `?`
-    // `*` matches zero or more characters except `.` and `:`
-    // `?` matches one character except `.` and `:`
-    regexp = regexp.replace(/\*/g, '[^.:]*').replace(/\?/g, '[^.:]');
-    return new RegExp(`^${regexp}$`);
-  }
-
   /**
    * Find bindings using the key pattern
-   * @param pattern A regexp or wildcard pattern with optional `*` and `?`. If
-   * it matches the binding key, the binding is included. For a wildcard:
+   * @param pattern A filter function, a regexp or a wildcard pattern with
+   * optional `*` and `?`. Find returns such bindings where the key matches
+   * the provided pattern.
+   *
+   * For a wildcard:
    * - `*` matches zero or more characters except `.` and `:`
    * - `?` matches exactly one character except `.` and `:`
+   *
+   * For a filter function:
+   * - return `true` to include the binding in the results
+   * - return `false` to exclude it.
    */
   find<ValueType = BoundValue>(
-    pattern?: string | RegExp,
-  ): Readonly<Binding<ValueType>>[];
-
-  /**
-   * Find bindings using a filter function
-   * @param filter A function to test on the binding. It returns `true` to
-   * include the binding or `false` to exclude the binding.
-   */
-  find<ValueType = BoundValue>(
-    filter: (binding: Readonly<Binding<ValueType>>) => boolean,
-  ): Readonly<Binding<ValueType>>[];
-
-  find<ValueType = BoundValue>(
-    pattern?:
-      | string
-      | RegExp
-      | ((binding: Readonly<Binding<ValueType>>) => boolean),
+    pattern?: string | RegExp | BindingFilter,
   ): Readonly<Binding<ValueType>>[] {
-    let bindings: Readonly<Binding>[] = [];
-    let filter: (binding: Readonly<Binding>) => boolean;
-    if (!pattern) {
-      filter = binding => true;
-    } else if (typeof pattern === 'string') {
-      const regex = this.wildcardToRegExp(pattern);
-      filter = binding => regex.test(binding.key);
-    } else if (pattern instanceof RegExp) {
-      filter = binding => pattern.test(binding.key);
-    } else {
-      filter = pattern;
-    }
+    const bindings: Readonly<Binding>[] = [];
+    const filter = filterByKey(pattern);
 
     for (const b of this.registry.values()) {
       if (filter(b)) bindings.push(b);
@@ -208,22 +181,7 @@ export class Context {
   findByTag<ValueType = BoundValue>(
     tagFilter: BindingTag | RegExp,
   ): Readonly<Binding<ValueType>>[] {
-    if (typeof tagFilter === 'string' || tagFilter instanceof RegExp) {
-      const regexp =
-        typeof tagFilter === 'string'
-          ? this.wildcardToRegExp(tagFilter)
-          : tagFilter;
-      return this.find(b => Array.from(b.tagNames).some(t => regexp!.test(t)));
-    }
-
-    return this.find(b => {
-      for (const t in tagFilter) {
-        // One tag name/value does not match
-        if (b.tagMap[t] !== tagFilter[t]) return false;
-      }
-      // All tag name/value pairs match
-      return true;
-    });
+    return this.find(filterByTag(tagFilter));
   }
 
   protected _mergeWithParent<ValueType>(

packages/context/src/index.ts

@@ -8,6 +8,7 @@ export * from './binding';
 export * from './binding-decorator';
 export * from './binding-inspector';
 export * from './binding-key';
+export * from './binding-filter';
 export * from './context';
 export * from './inject';
 export * from './keys';

packages/context/test/unit/binding-filter.unit.ts

@@ -0,0 +1,48 @@
+// Copyright IBM Corp. 2017,2018. All Rights Reserved.
+// Node module: @loopback/context
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {expect} from '@loopback/testlab';
+import {Binding, filterByKey, filterByTag} from '../..';
+
+const key = 'foo';
+
+describe('BindingFilter', () => {
+  let binding: Binding;
+  beforeEach(givenBinding);
+
+  describe('filterByTag', () => {
+    it('accepts bindings MATCHING the provided tag name', () => {
+      const filter = filterByTag('controller');
+      binding.tag('controller');
+      expect(filter(binding)).to.be.true();
+    });
+
+    it('rejects bindings NOT MATCHING the provided tag name', () => {
+      const filter = filterByTag('controller');
+      binding.tag('dataSource');
+      expect(filter(binding)).to.be.false();
+    });
+
+    // TODO: filter by tag map, filter by regexp
+  });
+
+  describe('filterByKey', () => {
+    it('accepts bindings MATCHING the provided key', () => {
+      const filter = filterByKey(key);
+      expect(filter(binding)).to.be.true();
+    });
+
+    it('rejects bindings NOT MATCHING the provided key', () => {
+      const filter = filterByKey(`another-${key}`);
+      expect(filter(binding)).to.be.false();
+    });
+
+    // TODO: filter by regexp, filter by BindingFunction
+  });
+
+  function givenBinding() {
+    binding = new Binding(key);
+  }
+});