fix(core): get rid of array registration

Author: shimks

packages/authentication/test/acceptance/basic-auth.ts

@@ -90,7 +90,8 @@ describe('Basic Authentication', () => {
 
   async function givenAServer() {
     app = new Application();
-    app.components([AuthenticationComponent, RestComponent]);
+    app.component(AuthenticationComponent);
+    app.component(RestComponent);
     server = await app.getServer(RestServer);
   }
 

packages/cli/generators/extension/templates/src/mixins/README.md

@@ -154,7 +154,6 @@ class LoggingComponent implements Component{
   loggers: [ColorLogger];
 }
 
-const app = new LoggingApplication({
-  components: [LoggingComponent] // Logger from MyComponent will be bound to loggers.ColorLogger
-});
+const app = new LoggingApplication();
+app.component(LoggingComponent); // Logger from MyComponent will be bound to loggers.ColorLogger
 ```

packages/cli/generators/extension/templates/src/providers/README.md

@@ -16,18 +16,18 @@ The logger will log the URL, the parsed request parameters, and the result. The
 
 TimerProvider is automatically bound to your Application's [Context](http://loopback.io/doc/en/lb4/Context.html) using the LogComponent which exports this provider with a binding key of `extension-starter.timer`. You can learn more about components in the [related resources section](#related-resources).
 
-This provider makes availble to your application a timer function which given a start time _(given as an array [seconds, nanoseconds])_ can give you a total time elapsed since the start in milliseconds. The timer can also start timing if no start time is given. This is used by LogComponent to allow a user to time a Sequence. 
+This provider makes availble to your application a timer function which given a start time _(given as an array [seconds, nanoseconds])_ can give you a total time elapsed since the start in milliseconds. The timer can also start timing if no start time is given. This is used by LogComponent to allow a user to time a Sequence.
 
 *NOTE:* _You can get the start time in the required format by using `this.logger.startTimer()`._
 
 You can provide your own implementation of the elapsed time function by binding it to the binding key (accessible via `ExtensionStarterBindings`) as follows:
 ```ts
 app.bind(ExtensionStarterBindings.TIMER).to(timerFn);
-``` 
+```
 
 ### LogProvider
 
-LogProvider can automatically be bound to your Application's Context using the LogComponent which exports the provider with a binding key of `extension-starter.actions.log`. 
+LogProvider can automatically be bound to your Application's Context using the LogComponent which exports the provider with a binding key of `extension-starter.actions.log`.
 
 The key can be accessed by importing `ExtensionStarterBindings` as follows:
 
@@ -38,7 +38,7 @@ import {ExtensionStarterBindings} from 'HelloExtensions';
 const key = ExtensionStarterBindings.LOG_ACTION;
 ```
 
-LogProvider gives us a seuqence action and a `startTimer` function. In order to use the sequence action, you must define your own sequence as shown below. 
+LogProvider gives us a seuqence action and a `startTimer` function. In order to use the sequence action, you must define your own sequence as shown below.
 
 **Example: Sequence**
 ```ts
@@ -85,9 +85,9 @@ Once a sequence has been written, we can just use that in our Application as fol
 **Example: Application**
 ```ts
 const app = new Application({
-  sequence: LogSequence,
-  components: [LogComponent]
+  sequence: LogSequence
 });
+app.component(LogComponent);
 
 // Now all requests handled by our sequence will be logged.
 ```

packages/core/README.md

@@ -46,10 +46,8 @@ const app = new Application({
     port: 3001,
   },
 });
-app.components([
-  RestComponent, // REST Server
-  GrpcComponent, // GRPC Server
-  ]);
+app.component(RestComponent) // REST Server
+app.component(GrpcComponent) // GRPC Server
 
 (async function start() {
   // Let's retrieve the bound instances of our servers.

packages/core/src/application.ts

@@ -48,30 +48,6 @@ export class Application extends Context {
       .tag('controller');
   }
 
-  /**
-   * Bind an array of controllers to the Application's master
-   * context.
-   * Each controller added in this way will automatically be named based on
-   * the class constructor name with the "controllers." prefix.
-   *
-   * If you wish to control the binding keys for particular controller
-   * instances, use the app.controller function instead.
-   * ```ts
-   * app.controllers([
-   *  FooController,
-   *  BarController,
-   * ]);
-   * // Creates a binding for "controllers.FooController" and a binding for
-   * // "controllers.BarController";
-   * ```
-   *
-   * @param ctors Array of controller classes.
-   * @returns {Binding[]} An array of bindings for the registered controllers.
-   */
-  controllers(ctors: ControllerClass[]): Binding[] {
-    return ctors.map(ctor => this.controller(ctor));
-  }
-
   /**
    * Bind a Server constructor to the Application's master context.
    * Each server constructor added in this way must provide a unique prefix
@@ -218,29 +194,6 @@ export class Application extends Context {
     const instance = this.getSync(componentKey);
     mountComponent(this, instance);
   }
-
-  /**
-   * Add multiple components to this application and register their
-   * extensions.
-   *
-   * Each component added in this way will automatically be named based on the
-   * class constructor name with the "components." prefix.
-   *
-   * If you wish to control the binding keys for particular instances,
-   * use the app.component function instead.
-   * ```ts
-   * app.components([
-   *  RestComponent,
-   *  GRPCComponent,
-   * ]);
-   * // Creates a binding for "components.RestComponent" and a binding for
-   * // "components.GRPCComponent";
-   * ```
-   * @param ctors Array of components to add.
-   */
-  public components(ctors: Constructor<Component>[]) {
-    ctors.map(ctor => this.component(ctor));
-  }
 }
 
 /**

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

@@ -93,7 +93,8 @@ describe('Bootstrapping the application', () => {
         }
       }
       const app = new Application();
-      app.components([ConfigComponent, GreetingComponent]);
+      app.component(ConfigComponent);
+      app.component(GreetingComponent);
 
       expect(app.getSync('greeting')).to.equal('Hi!');
     });

packages/core/test/acceptance/application.feature.md

@@ -2,26 +2,24 @@
 
 - In order to initialize my application
 - As an app developer
-- I want to register components and sequences when initalizing the application
+- I want to register components when initalizing the application
 - So that I can use them throughout the application lifecycle
 
 ## Scenario: Basic usage (config provided)
 
 - Given an importable `Application` class
 - When I create an application with user-defined configurations
-- Then the application should register the given components and sequences
+- Then the application should register the given components
 
 ```ts
 import {Application} from '@loopback/core';
 import {Authentication} from '@loopback/authentication';
 import {Authorization} from '@loopback/authorization';
 import {Rejection} from '@loopback/rejection';
 
-const app = new Application({
-  components: [Todo, Authentication, Authorization, Rejection],
-  sequence: [TodoSequence]
-});
-
-// get metadata about the registered components
-console.log(app.find('sequence.*')); // [Bindings] should match the 1 sequence registered above
+const app = new Application();
+app.component(Todo);
+app.component(Authentication);
+app.component(Authorization);
+app.component(Rejection);
 ```

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

@@ -5,13 +5,12 @@
 
 import {expect} from '@loopback/testlab';
 import {Application, Server, Component} from '../../index';
-import {Context} from '@loopback/context';
+import {Context, Constructor} from '@loopback/context';
 
 describe('Application', () => {
   describe('controller binding', () => {
     let app: Application;
     class MyController {}
-    class MySecondController {}
 
     beforeEach(givenApp);
 
@@ -29,21 +28,6 @@ describe('Application', () => {
       expect(findKeysByTag(app, 'controller')).to.containEql(binding.key);
     });
 
-    it('binds multiple controllers passed in as an array', () => {
-      const controllers = [MyController, MySecondController];
-      const bindings = app.controllers(controllers);
-
-      const bindA = bindings[0];
-      expect(Array.from(bindA.tags)).to.containEql('controller');
-      expect(bindA.key).to.equal('controllers.MyController');
-      expect(findKeysByTag(app, 'controller')).to.containEql(bindA.key);
-
-      const bindB = bindings[1];
-      expect(Array.from(bindB.tags)).to.containEql('controller');
-      expect(bindB.key).to.equal('controllers.MySecondController');
-      expect(findKeysByTag(app, 'controller')).to.containEql(bindB.key);
-    });
-
     function givenApp() {
       app = new Application();
     }
@@ -55,9 +39,6 @@ describe('Application', () => {
     class MyComponent implements Component {
       controllers = [MyController];
     }
-    class MySecondComponent implements Component {
-      controllers = [MyController];
-    }
 
     beforeEach(givenApp);
 
@@ -75,16 +56,6 @@ describe('Application', () => {
       );
     });
 
-    it('binds multiple components passed in as an array', () => {
-      app.components([MyComponent, MySecondComponent]);
-      expect(findKeysByTag(app, 'component')).to.containEql(
-        'components.MyComponent',
-      );
-      expect(findKeysByTag(app, 'component')).to.containEql(
-        'components.MySecondComponent',
-      );
-    });
-
     function givenApp() {
       app = new Application();
     }
@@ -119,11 +90,46 @@ describe('Application', () => {
     });
   });
 
+  describe('start', () => {
+    it('starts all injected servers', async () => {
+      const app = new Application();
+      app.component(FakeComponent);
+
+      await app.start();
+      const server = await app.getServer(FakeServer);
+      expect(server).to.not.be.null();
+      expect(server.running).to.equal(true);
+      await app.stop();
+    });
+
+    it('does not attempt to start poorly named bindings', async () => {
+      const app = new Application();
+      app.component(FakeComponent);
+
+      // The app.start should not attempt to start this binding.
+      app.bind('controllers.servers').to({});
+      await app.start();
+      await app.stop();
+    });
+  });
+
   function findKeysByTag(ctx: Context, tag: string | RegExp) {
     return ctx.findByTag(tag).map(binding => binding.key);
   }
 });
 
+class FakeComponent implements Component {
+  servers: {
+    [name: string]: Constructor<Server>;
+  };
+  constructor() {
+    this.servers = {
+      FakeServer,
+      FakeServer2: FakeServer,
+    };
+  }
+}
+
 class FakeServer extends Context implements Server {
   running: boolean = false;
   constructor() {

packages/example-log-extension/README.md

@@ -37,7 +37,7 @@ class LogApp extends LogLevelMixin(RestApplication) {
     super({
       logLevel: LOG_LEVEL.ERROR,
     });
-    this.components(LogComponent);
+    this.component(LogComponent);
     this.controller(MyController);
   };
 }

packages/example-log-extension/test/acceptance/log.extension.acceptance.ts

@@ -3,9 +3,8 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {Application} from '@loopback/core';
 import {
-  RestComponent,
+  RestApplication,
   RestServer,
   get,
   param,
@@ -46,7 +45,7 @@ describe('log extension acceptance test', () => {
   let server: RestServer;
   let spy: SinonSpy;
 
-  class LogApp extends LogLevelMixin(Application) {}
+  class LogApp extends LogLevelMixin(RestApplication) {}
 
   const debugMatch: string = chalk.white(
     'DEBUG: /debug :: MyController.debug() => debug called',
@@ -239,7 +238,7 @@ describe('log extension acceptance test', () => {
 
   async function createApp() {
     app = new LogApp();
-    app.components([RestComponent, LogComponent]);
+    app.component(LogComponent);
 
     app.bind(EXAMPLE_LOG_BINDINGS.TIMER).to(timer);
     server = await app.getServer(RestServer);