feat(core): Set tags to group bound artifacts

Author: raymondfeng

packages/core/src/application.ts

@@ -48,6 +48,7 @@ export class Application extends Context {
    *
    * @param controllerCtor {Function} The controller class
    * (constructor function).
+   * @param {string=} name Optional controller name, default to the class name
    * @return {Binding} The newly created binding, you can use the reference to
    * further modify the binding, e.g. lock the value to prevent further
    * modifications.
@@ -58,10 +59,11 @@ export class Application extends Context {
    * app.controller(MyController).lock();
    * ```
    */
-  controller(controllerCtor: ControllerClass): Binding {
-    return this.bind('controllers.' + controllerCtor.name).toClass(
-      controllerCtor,
-    );
+  controller(controllerCtor: ControllerClass, name?: string): Binding {
+    name = name || controllerCtor.name;
+    return this.bind(`controllers.${name}`)
+      .toClass(controllerCtor)
+      .tag('controller');
   }
 
   /**
@@ -89,6 +91,7 @@ export class Application extends Context {
     const key = `${CoreBindings.SERVERS}.${suffix}`;
     return this.bind(key)
       .toClass(ctor)
+      .tag('server')
       .inScope(BindingScope.SINGLETON);
   }
 
@@ -181,7 +184,8 @@ export class Application extends Context {
    * Add a component to this application and register extensions such as
    * controllers, providers, and servers from the component.
    *
-   * @param component The component class to add.
+   * @param componentCtor The component class to add.
+   * @param {string=} name Optional component name, default to the class name
    *
    * ```ts
    *
@@ -197,9 +201,13 @@ export class Application extends Context {
    * app.component(ProductComponent);
    * ```
    */
-  public component(component: Constructor<Component>) {
-    const componentKey = `components.${component.name}`;
-    this.bind(componentKey).toClass(component);
+  public component(componentCtor: Constructor<Component>, name?: string) {
+    name = name || componentCtor.name;
+    const componentKey = `components.${name}`;
+    this.bind(componentKey)
+      .toClass(componentCtor)
+      .inScope(BindingScope.SINGLETON)
+      .tag('component');
     // Assuming components can be synchronously instantiated
     const instance = this.getSync(componentKey);
     mountComponent(this, instance);

packages/core/test/acceptance/application.acceptance.ts

@@ -49,6 +49,10 @@ describe('Bootstrapping the application', () => {
       expect(app.find('controllers.*').map(b => b.key)).to.eql([
         'controllers.ProductController',
       ]);
+
+      expect(app.findByTag('controller').map(b => b.key)).to.eql([
+        'controllers.ProductController',
+      ]);
     });
 
     it('registers all controllers from components', async () => {

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

@@ -8,10 +8,64 @@ import {Application, Server, Component} from '../../index';
 import {Context, Constructor} from '@loopback/context';
 
 describe('Application', () => {
+  describe('controller binding', () => {
+    let app: Application;
+    class MyController {}
+
+    beforeEach(givenApp);
+
+    it('binds a controller', () => {
+      const binding = app.controller(MyController);
+      expect(Array.from(binding.tags)).to.containEql('controller');
+      expect(binding.key).to.equal('controllers.MyController');
+      expect(findKeysByTag(app, 'controller')).to.containEql(binding.key);
+    });
+
+    it('binds a controller with custom name', () => {
+      const binding = app.controller(MyController, 'my-controller');
+      expect(Array.from(binding.tags)).to.containEql('controller');
+      expect(binding.key).to.equal('controllers.my-controller');
+      expect(findKeysByTag(app, 'controller')).to.containEql(binding.key);
+    });
+
+    function givenApp() {
+      app = new Application();
+    }
+  });
+
+  describe('component binding', () => {
+    let app: Application;
+    class MyController {}
+    class MyComponent implements Component {
+      controllers = [MyController];
+    }
+
+    beforeEach(givenApp);
+
+    it('binds a component', () => {
+      app.component(MyComponent);
+      expect(findKeysByTag(app, 'component')).to.containEql(
+        'components.MyComponent',
+      );
+    });
+
+    it('binds a component', () => {
+      app.component(MyComponent, 'my-component');
+      expect(findKeysByTag(app, 'component')).to.containEql(
+        'components.my-component',
+      );
+    });
+
+    function givenApp() {
+      app = new Application();
+    }
+  });
+
   describe('server binding', () => {
     it('defaults to constructor name', async () => {
       const app = new Application();
-      app.server(FakeServer);
+      const binding = app.server(FakeServer);
+      expect(Array.from(binding.tags)).to.containEql('server');
       const result = await app.getServer(FakeServer.name);
       expect(result.constructor.name).to.equal(FakeServer.name);
     });
@@ -62,6 +116,10 @@ describe('Application', () => {
       });
     });
   });
+
+  function findKeysByTag(ctx: Context, tag: string | RegExp) {
+    return ctx.findByTag(tag).map(binding => binding.key);
+  }
 });
 
 class FakeComponent implements Component {