feat(core): add app.service() to register service classes or providers

Author: raymondfeng

packages/core/src/__tests__/unit/application.unit.ts

@@ -229,6 +229,57 @@ describe('Application', () => {
     }
   });
 
+  describe('service binding', () => {
+    let app: Application;
+    class MyService {}
+
+    beforeEach(givenApp);
+
+    it('binds a service', () => {
+      const binding = app.service(MyService);
+      expect(Array.from(binding.tagNames)).to.containEql(CoreTags.SERVICE);
+      expect(binding.key).to.equal('services.MyService');
+      expect(binding.scope).to.equal(BindingScope.TRANSIENT);
+      expect(findKeysByTag(app, CoreTags.SERVICE)).to.containEql(binding.key);
+    });
+
+    it('binds a service with custom name', () => {
+      const binding = app.service(MyService, 'my-service');
+      expect(Array.from(binding.tagNames)).to.containEql(CoreTags.SERVICE);
+      expect(binding.key).to.equal('services.my-service');
+      expect(findKeysByTag(app, CoreTags.SERVICE)).to.containEql(binding.key);
+    });
+
+    it('binds a singleton service', () => {
+      @bind({scope: BindingScope.SINGLETON})
+      class MySingletonService {}
+
+      const binding = app.service(MySingletonService);
+      expect(binding.scope).to.equal(BindingScope.SINGLETON);
+      expect(findKeysByTag(app, 'service')).to.containEql(binding.key);
+    });
+
+    it('binds a service provider', () => {
+      @bind({tags: {date: 'now', namespace: 'localServices'}})
+      class MyServiceProvider implements Provider<Date> {
+        value() {
+          return new Date();
+        }
+      }
+
+      const binding = app.service(MyServiceProvider);
+      expect(Array.from(binding.tagNames)).to.containEql(CoreTags.SERVICE);
+      expect(binding.tagMap.date).to.eql('now');
+      expect(binding.key).to.equal('localServices.MyServiceProvider');
+      expect(binding.scope).to.equal(BindingScope.TRANSIENT);
+      expect(findKeysByTag(app, 'service')).to.containEql(binding.key);
+    });
+
+    function givenApp() {
+      app = new Application();
+    }
+  });
+
   function findKeysByTag(ctx: Context, tag: string | RegExp) {
     return ctx.findByTag(tag).map(binding => binding.key);
   }

packages/core/src/application.ts

@@ -6,9 +6,13 @@
 import {
   Binding,
   BindingScope,
+  bindingTemplateFor,
   Constructor,
   Context,
+  ContextTags,
   createBindingFromClass,
+  isProviderClass,
+  Provider,
 } from '@loopback/context';
 import * as debugFactory from 'debug';
 import {Component, mountComponent} from './component';
@@ -241,6 +245,73 @@ export class Application extends Context implements LifeCycleObserver {
     this.add(binding);
     return binding;
   }
+
+  /**
+   * Add a service to this application.
+   *
+   * @param cls - The service or provider class
+   *
+   * @example
+   *
+   * ```ts
+   * // Define a class to be bound via ctx.toClass()
+   * @bind({scope: BindingScope.SINGLETON})
+   * export class LogService {
+   *   log(msg: string) {
+   *     console.log(msg);
+   *   }
+   * }
+   *
+   * // Define a class to be bound via ctx.toProvider()
+   * const uuidv4 = require('uuid/v4');
+   * export class UuidProvider implements Provider<string> {
+   *   value() {
+   *     return uuidv4();
+   *   }
+   * }
+   *
+   * // Register the local services
+   * app.service(LogService);
+   * app.service(UuidProvider, 'uuid');
+   *
+   * export class MyController {
+   *   constructor(
+   *     @inject('services.uuid') private uuid: string,
+   *     @inject('services.LogService') private log: LogService,
+   *   ) {
+   *   }
+   *
+   *   greet(name: string) {
+   *     this.log(`Greet request ${this.uuid} received: ${name}`);
+   *     return `${this.uuid}: ${name}`;
+   *   }
+   * }
+   * ```
+   */
+  public service<S>(
+    cls: Constructor<S> | Constructor<Provider<S>>,
+    name?: string,
+  ): Binding<S> {
+    if (!name && isProviderClass(cls)) {
+      // Trim `Provider` from the default service name
+      // This is needed to keep backward compatibility
+      const templateFn = bindingTemplateFor(cls);
+      const template = Binding.bind<S>('template').apply(templateFn);
+      if (
+        template.tagMap[ContextTags.PROVIDER] &&
+        !template.tagMap[ContextTags.NAME]
+      ) {
+        // The class is a provider and no `name` tag is found
+        name = cls.name.replace(/Provider$/, '');
+      }
+    }
+    const binding = createBindingFromClass(cls, {
+      name,
+      type: 'service',
+    });
+    this.add(binding);
+    return binding;
+  }
 }
 
 /**

packages/core/src/keys.ts

@@ -111,6 +111,11 @@ export namespace CoreTags {
    */
   export const CONTROLLER = 'controller';
 
+  /**
+   * Binding tag for services
+   */
+  export const SERVICE = 'service';
+
   /**
    * Binding tag for life cycle observers
    */

packages/service-proxy/src/mixins/service.mixin.ts

@@ -3,7 +3,7 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {Binding, createBindingFromClass, Provider} from '@loopback/context';
+import {Binding, Provider} from '@loopback/context';
 import {Application} from '@loopback/core';
 
 /**
@@ -41,6 +41,8 @@ export function ServiceMixin<T extends Class<any>>(superClass: T) {
     /**
      * Add a service to this application.
      *
+     * @deprecated Use app.service() instead
+     *
      * @param provider - The service provider to register.
      *
      * @example
@@ -67,14 +69,7 @@ export function ServiceMixin<T extends Class<any>>(superClass: T) {
       provider: Class<Provider<S>>,
       name?: string,
     ): Binding<S> {
-      const serviceName = name || provider.name.replace(/Provider$/, '');
-      const binding = createBindingFromClass(provider, {
-        name: serviceName,
-        namespace: 'services',
-        type: 'service',
-      });
-      this.add(binding);
-      return binding;
+      return this.service(provider, name);
     }
 
     /**