feat(core): allow components to expose an array of bindings

Author: raymondfeng

packages/context/src/binding.ts

@@ -318,7 +318,7 @@ export class Binding<T = BoundValue> {
    *
    * @param provider The value provider to use.
    */
-  public toProvider(providerClass: Constructor<Provider<T>>): this {
+  toProvider(providerClass: Constructor<Provider<T>>): this {
     /* istanbul ignore if */
     if (debug.enabled) {
       debug('Bind %s to provider %s', this.key, providerClass.name);
@@ -375,4 +375,14 @@ export class Binding<T = BoundValue> {
     }
     return json;
   }
+
+  /**
+   * A static method to create a binding so that we can do
+   * `Binding.bind('foo').to('bar');` as `new Binding('foo').to('bar')` is not
+   * easy to read.
+   * @param key Binding key
+   */
+  static bind(key: string): Binding {
+    return new Binding(key);
+  }
 }

packages/context/src/context.ts

@@ -42,21 +42,23 @@ export class Context {
    * Create a binding with the given key in the context. If a locked binding
    * already exists with the same key, an error will be thrown.
    *
-   * @param keyOrBinding Binding key or a binding
+   * @param key Binding key
    */
   bind<ValueType = BoundValue>(
-    keyOrBinding: BindingAddress<ValueType> | Binding,
+    key: BindingAddress<ValueType>,
   ): Binding<ValueType> {
-    let key: string;
-    let binding: Binding<ValueType>;
-    if (keyOrBinding instanceof Binding) {
-      key = keyOrBinding.key;
-      binding = keyOrBinding;
-    } else {
-      key = keyOrBinding.toString();
-      binding = new Binding<ValueType>(key);
-    }
+    const binding = new Binding<ValueType>(key.toString());
+    this.add(binding);
+    return binding;
+  }
 
+  /**
+   * Add a binding to the context. If a locked binding already exists with the
+   * same key, an error will be thrown.
+   * @param binding The configured binding to be added
+   */
+  add<ValueType = BoundValue>(binding: Binding<ValueType>): this {
+    const key = binding.key;
     /* istanbul ignore if */
     if (debug.enabled) {
       debug('Adding binding: %s', key);
@@ -70,7 +72,7 @@ export class Context {
         throw new Error(`Cannot rebind key "${key}" to a locked binding`);
     }
     this.registry.set(key, binding);
-    return binding;
+    return this;
   }
 
   /**

packages/context/test/unit/context.ts

@@ -71,13 +71,6 @@ describe('Context', () => {
       expect(result).to.be.true();
     });
 
-    it('accepts a binding', () => {
-      const binding = new Binding('foo').to('bar');
-      expect(ctx.bind(binding)).to.be.exactly(binding);
-      const result = ctx.contains('foo');
-      expect(result).to.be.true();
-    });
-
     it('returns a binding', () => {
       const binding = ctx.bind('foo');
       expect(binding).to.be.instanceOf(Binding);
@@ -87,6 +80,30 @@ describe('Context', () => {
       const key = 'a' + BindingKey.PROPERTY_SEPARATOR + 'b';
       expect(() => ctx.bind(key)).to.throw(/Binding key .* cannot contain/);
     });
+
+    it('rejects rebinding of a locked key', () => {
+      ctx.bind('foo').lock();
+      expect(() => ctx.bind('foo')).to.throw(
+        'Cannot rebind key "foo" to a locked binding',
+      );
+    });
+  });
+
+  describe('add', () => {
+    it('accepts a binding', () => {
+      const binding = new Binding('foo').to('bar');
+      ctx.add(binding);
+      expect(ctx.getBinding(binding.key)).to.be.exactly(binding);
+      const result = ctx.contains('foo');
+      expect(result).to.be.true();
+    });
+
+    it('rejects rebinding of a locked key', () => {
+      ctx.bind('foo').lock();
+      expect(() => ctx.add(new Binding('foo'))).to.throw(
+        'Cannot rebind key "foo" to a locked binding',
+      );
+    });
   });
 
   describe('contains', () => {

packages/core/src/component.ts

@@ -3,7 +3,7 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {Constructor, Provider, BoundValue} from '@loopback/context';
+import {Constructor, Provider, BoundValue, Binding} from '@loopback/context';
 import {Server} from './server';
 import {Application, ControllerClass} from './application';
 
@@ -14,6 +14,10 @@ export interface ProviderMap {
   [key: string]: Constructor<Provider<BoundValue>>;
 }
 
+export interface ClassMap {
+  [key: string]: Constructor<BoundValue>;
+}
+
 /**
  * A component declares a set of artifacts so that they cane be contributed to
  * an application as a group
@@ -27,13 +31,21 @@ export interface Component {
    * A map of name/class pairs for binding providers
    */
   providers?: ProviderMap;
+
+  classes?: ClassMap;
+
   /**
    * A map of name/class pairs for servers
    */
   servers?: {
     [name: string]: Constructor<Server>;
   };
 
+  /**
+   * An array of bindings
+   */
+  bindings?: Binding[];
+
   /**
    * Other properties
    */
@@ -49,15 +61,33 @@ export interface Component {
  * @param {Component} component
  */
 export function mountComponent(app: Application, component: Component) {
-  if (component.controllers) {
-    for (const controllerCtor of component.controllers) {
-      app.controller(controllerCtor);
+  if (component.classes) {
+    for (const classKey in component.classes) {
+      const binding = Binding.bind(classKey).toClass(
+        component.classes[classKey],
+      );
+      app.add(binding);
     }
   }
 
   if (component.providers) {
     for (const providerKey in component.providers) {
-      app.bind(providerKey).toProvider(component.providers[providerKey]);
+      const binding = Binding.bind(providerKey).toProvider(
+        component.providers[providerKey],
+      );
+      app.add(binding);
+    }
+  }
+
+  if (component.bindings) {
+    for (const binding of component.bindings) {
+      app.add(binding);
+    }
+  }
+
+  if (component.controllers) {
+    for (const controllerCtor of component.controllers) {
+      app.controller(controllerCtor);
     }
   }
 

packages/core/test/unit/application.test.ts

@@ -4,8 +4,14 @@
 // License text available at https://opensource.org/licenses/MIT
 
 import {expect} from '@loopback/testlab';
-import {Application, Server, Component} from '../../index';
-import {Context, Constructor} from '@loopback/context';
+import {Application, Server, Component, CoreBindings} from '../..';
+import {
+  Context,
+  Constructor,
+  Binding,
+  Provider,
+  inject,
+} from '@loopback/context';
 
 describe('Application', () => {
   describe('controller binding', () => {
@@ -35,9 +41,26 @@ describe('Application', () => {
 
   describe('component binding', () => {
     let app: Application;
+    const binding = new Binding('foo');
     class MyController {}
+    class MyClass {}
+    class MyProvider implements Provider<string> {
+      value() {
+        return 'my-str';
+      }
+    }
     class MyComponent implements Component {
       controllers = [MyController];
+      bindings = [binding];
+      classes = {'my-class': MyClass};
+      providers = {'my-provider': MyProvider};
+    }
+
+    class MyComponentWithDI implements Component {
+      constructor(@inject(CoreBindings.APPLICATION_INSTANCE) ctx: Context) {
+        // Porgramatically bind to the context
+        ctx.bind('foo').to('bar');
+      }
     }
 
     beforeEach(givenApp);
@@ -56,6 +79,32 @@ describe('Application', () => {
       );
     });
 
+    it('binds bindings from a component', () => {
+      app.component(MyComponent);
+      expect(app.contains('controllers.MyController')).to.be.true();
+      expect(app.getBinding('foo')).to.be.exactly(binding);
+    });
+
+    it('binds classes from a component', () => {
+      app.component(MyComponent);
+      expect(app.contains('my-class')).to.be.true();
+      expect(app.getBinding('my-class').valueConstructor).to.be.exactly(
+        MyClass,
+      );
+    });
+
+    it('binds providers from a component', () => {
+      app.component(MyComponent);
+      expect(app.contains('my-provider')).to.be.true();
+      expect(app.getSync('my-provider')).to.be.eql('my-str');
+    });
+
+    it('binds from a component constructor', () => {
+      app.component(MyComponentWithDI);
+      expect(app.contains('foo')).to.be.true();
+      expect(app.getSync('foo')).to.be.eql('bar');
+    });
+
     function givenApp() {
       app = new Application();
     }