fix(rest): use context.get() to resolve current controller

packages/core/src/keys.ts

@@ -53,4 +53,10 @@ export namespace CoreBindings {
    * request context
    */
   export const CONTROLLER_METHOD_META = 'controller.method.meta';
+
+  /**
+   * Binding key for the controller instance resolved in the current request
+   * context
+   */
+  export const CONTROLLER_CURRENT = BindingKey.create('controller.current');
 }

packages/rest/src/http-handler.ts

@@ -15,6 +15,7 @@ import {
   ResolvedRoute,
   RouteEntry,
   ControllerClass,
+  ControllerFactory,
 } from './router/routing-table';
 import {ParsedRequest} from './internal-types';
 
@@ -33,8 +34,12 @@ export class HttpHandler {
     this.handleRequest = (req, res) => this._handleRequest(req, res);
   }
 
-  registerController(name: ControllerClass, spec: ControllerSpec) {
-    this._routes.registerController(name, spec);
+  registerController<T>(
+    spec: ControllerSpec,
+    controllerCtor: ControllerClass<T>,
+    controllerFactory?: ControllerFactory<T>,
+  ) {
+    this._routes.registerController(spec, controllerCtor, controllerFactory);
   }
 
   registerRoute(route: RouteEntry) {

packages/rest/src/index.ts

@@ -14,6 +14,12 @@ export {
   ResolvedRoute,
   createResolvedRoute,
   parseRequestUrl,
+  ControllerClass,
+  ControllerInstance,
+  ControllerFactory,
+  createControllerFactoryForBinding,
+  createControllerFactoryForClass,
+  createControllerFactoryForInstance,
 } from './router/routing-table';
 
 export * from './providers';

packages/rest/src/rest.application.ts

@@ -10,7 +10,11 @@ import {Binding, Constructor} from '@loopback/context';
 import {format} from 'util';
 import {RestBindings} from './keys';
 import {RestServer, HttpRequestListener, HttpServerLike} from './rest.server';
-import {ControllerClass, RouteEntry} from './router/routing-table';
+import {
+  RouteEntry,
+  ControllerClass,
+  ControllerFactory,
+} from './router/routing-table';
 import {OperationObject, OpenApiSpec} from '@loopback/openapi-v3-types';
 
 export const ERR_NO_MULTI_SERVER = format(
@@ -95,14 +99,16 @@ export class RestApplication extends Application implements HttpServerLike {
    * @param verb HTTP verb of the endpoint
    * @param path URL path of the endpoint
    * @param spec The OpenAPI spec describing the endpoint (operation)
-   * @param controller Controller constructor
+   * @param controllerCtor Controller constructor
+   * @param controllerFactory A factory function to create controller instance
    * @param methodName The name of the controller method
    */
-  route(
+  route<T>(
     verb: string,
     path: string,
     spec: OperationObject,
-    controller: ControllerClass,
+    controllerCtor: ControllerClass<T>,
+    controllerFactory: ControllerFactory<T>,
     methodName: string,
   ): Binding;
 
@@ -121,18 +127,26 @@ export class RestApplication extends Application implements HttpServerLike {
    */
   route(route: RouteEntry): Binding;
 
-  route(
+  route<T>(
     routeOrVerb: RouteEntry | string,
     path?: string,
     spec?: OperationObject,
-    controller?: ControllerClass,
+    controllerCtor?: ControllerClass<T>,
+    controllerFactory?: ControllerFactory<T>,
     methodName?: string,
   ): Binding {
     const server = this.restServer;
     if (typeof routeOrVerb === 'object') {
       return server.route(routeOrVerb);
     } else {
-      return server.route(routeOrVerb, path!, spec!, controller!, methodName!);
+      return server.route(
+        routeOrVerb,
+        path!,
+        spec!,
+        controllerCtor!,
+        controllerFactory!,
+        methodName!,
+      );
     }
   }
 

packages/rest/src/rest.server.ts

@@ -10,7 +10,10 @@ import {
   Route,
   ControllerRoute,
   RouteEntry,
+  ControllerFactory,
   ControllerClass,
+  ControllerInstance,
+  createControllerFactoryForBinding,
 } from './router/routing-table';
 import {ParsedRequest} from './internal-types';
 import {OpenApiSpec, OperationObject} from '@loopback/openapi-v3-types';
@@ -243,7 +246,8 @@ export class RestServer extends Context implements Server, HttpServerLike {
       if (apiSpec.components && apiSpec.components.schemas) {
         this._httpHandler.registerApiDefinitions(apiSpec.components.schemas);
       }
-      this._httpHandler.registerController(ctor, apiSpec);
+      const controllerFactory = createControllerFactoryForBinding(b.key);
+      this._httpHandler.registerController(apiSpec, ctor, controllerFactory);
     }
 
     for (const b of this.find('routes.*')) {
@@ -292,7 +296,14 @@ export class RestServer extends Context implements Server, HttpServerLike {
         );
       }
 
-      const route = new ControllerRoute(verb, path, spec, ctor);
+      const controllerFactory = createControllerFactoryForBinding(b.key);
+      const route = new ControllerRoute(
+        verb,
+        path,
+        spec,
+        ctor,
+        controllerFactory,
+      );
       this._httpHandler.registerRoute(route);
       return;
     }
@@ -351,7 +362,7 @@ export class RestServer extends Context implements Server, HttpServerLike {
    * ```
    *
    */
-  controller(controllerCtor: ControllerClass): Binding {
+  controller(controllerCtor: ControllerClass<ControllerInstance>): Binding {
     return this.bind('controllers.' + controllerCtor.name).toClass(
       controllerCtor,
     );
@@ -372,14 +383,16 @@ export class RestServer extends Context implements Server, HttpServerLike {
    * @param verb HTTP verb of the endpoint
    * @param path URL path of the endpoint
    * @param spec The OpenAPI spec describing the endpoint (operation)
-   * @param controller Controller constructor
+   * @param controllerCtor Controller constructor
+   * @param controllerFactory A factory function to create controller instance
    * @param methodName The name of the controller method
    */
-  route(
+  route<I>(
     verb: string,
     path: string,
     spec: OperationObject,
-    controller: ControllerClass,
+    controllerCtor: ControllerClass<I>,
+    controllerFactory: ControllerFactory<I>,
     methodName: string,
   ): Binding;
 
@@ -398,11 +411,12 @@ export class RestServer extends Context implements Server, HttpServerLike {
    */
   route(route: RouteEntry): Binding;
 
-  route(
+  route<I>(
     routeOrVerb: RouteEntry | string,
     path?: string,
     spec?: OperationObject,
-    controller?: ControllerClass,
+    controllerCtor?: ControllerClass<I>,
+    controllerFactory?: ControllerFactory<I>,
     methodName?: string,
   ): Binding {
     if (typeof routeOrVerb === 'object') {
@@ -426,7 +440,7 @@ export class RestServer extends Context implements Server, HttpServerLike {
       });
     }
 
-    if (!controller) {
+    if (!controllerCtor) {
       throw new AssertionError({
         message: 'controller is required for a controller-based route',
       });
@@ -439,7 +453,14 @@ export class RestServer extends Context implements Server, HttpServerLike {
     }
 
     return this.route(
-      new ControllerRoute(routeOrVerb, path, spec, controller, methodName),
+      new ControllerRoute(
+        routeOrVerb,
+        path,
+        spec,
+        controllerCtor,
+        controllerFactory,
+        methodName,
+      ),
     );
   }