feat: support constructor @dsource() decorator.

Author: jaywcjlove

core/README.md

@@ -55,13 +55,14 @@ import { User } from '../entities/user.entity';
 
 @Controller('/api/users')
 export class UserController {
+  constructor(@DSource() private dataSource: DataSource) {}
   @Get()          // => GET /api/users
-  public async getAll(@DSource() dataSource: DataSource): Promise<User[]> {
-    return dataSource.manager.find(User);
+  public async getAll(): Promise<User[]> {
+    return this.dataSource.manager.find(User);
   }
   @Get('/:id')    // => GET /api/users/:id
-  public async getById(@Param('id') id: string, @DSource() dataSource: DataSource): Promise<User> {
-    return dataSource.manager.findOne(User, id);
+  public async getById(@Param('id') id: string): Promise<User> {
+    return this.dataSource.manager.findOne(User, id);
   }
   @Post('/:id')   // => POST /api/users/:id
   public async modify(@Body() body: { name: string; }): Promise<{ name: string; }> {
@@ -420,6 +421,26 @@ export class UserController {
 
 **`@DSource()`** decorator injects you a [DataSource](https://typeorm.io/data-source-api) object.
 
+Support constructor **`@DSource()`** decorator
+
+```typescript
+import { Controller, Get, DSource, DataSource } from 'typenexus';
+import { Response, Request }from 'express';
+import { User } from '../entity/User.js';
+
+@Controller('/users')
+export class UserController {
+  constructor(@DSource() private dataSource: DataSource) {}
+  @ContentType('application/json')
+  @Get() // => GET /users
+  public async getUsers(): Promise<User[]> {
+    return this.dataSource.manager.find(User);
+  }
+}
+```
+
+Support parameter **`@DSource()`** decorator
+
 ```typescript
 import { Controller, Get, DSource, DataSource } from 'typenexus';
 import { Response, Request }from 'express';
@@ -719,10 +740,11 @@ import { User } from '../entity/User.js';
 
 @Controller()
 export class UserController {
+  constructor(@DSource() private dataSource: DataSource) {}
   @Delete("/users/:id")
   @OnUndefined(204)
-  async remove(@Param("id") id: string, @DSource() dataSource: DataSource): Promise<void> {
-    return dataSource.manager.findOneBy(User, { id });
+  async remove(@Param("id") id: string): Promise<void> {
+    return this.dataSource.manager.findOneBy(User, { id });
   }
 }
 ```
@@ -735,10 +757,11 @@ import { User } from '../entity/User.js';
 
 @Controller()
 export class UserController {
+  constructor(@DSource() private dataSource: DataSource) {}
   @Delete("/users/:id")
   @OnUndefined(404)
-  async remove(@Param("id") id: string, @DSource() dataSource: DataSource): Promise<void> {
-    return dataSource.manager.findOneBy(User, { id });
+  async remove(@Param("id") id: string): Promise<void> {
+    return this.dataSource.manager.findOneBy(User, { id });
   }
 }
 ```
@@ -761,10 +784,11 @@ import { User } from '../entity/User.js';
 
 @Controller()
 export class UserController {
+  constructor(@DSource() private dataSource: DataSource) {}
   @Get("/users/:id")
   @OnUndefined(UserNotFoundError)
-  async remove(@Param("id") id: string, @DSource() dataSource: DataSource): Promise<void> {
-    return dataSource.manager.findOneBy(User, { id });
+  async remove(@Param("id") id: string): Promise<void> {
+    return this.dataSource.manager.findOneBy(User, { id });
   }
 }
 ```

core/package.json

@@ -46,7 +46,7 @@
   "devDependencies": {
     "nodemon": "^2.0.20",
     "ts-node": "^10.9.1",
-    "tsbb": "^4.1.2"
+    "tsbb": "^4.1.5"
   },
   "dependencies": {
     "@babel/runtime": "^7.21.0",

core/src/ActionParameterHandler.ts

@@ -1,5 +1,7 @@
+import { DataSource } from 'typeorm';
 import { Driver } from './Driver.js'
 import { ParamMetadata } from './metadata/ParamMetadata.js';
+import { ParamConstructorMetadata } from './metadata/ParamConstructorMetadata.js';
 import { Action } from './Action.js';
 import { isPromiseLike } from './utils/isPromiseLike.js';
 import { CurrentUserCheckerNotDefinedError } from './http-error/CurrentUserCheckerNotDefinedError.js';
@@ -10,6 +12,12 @@ import { AuthorizationRequiredError } from './http-error/AuthorizationRequiredEr
  */
 export class ActionParameterHandler<T extends Driver> {
   constructor(private driver: T) {}
+  /**
+   * Handles action constructor parameter.
+   */
+  handleConstructor(action: Action, param: ParamConstructorMetadata): DataSource {
+    if (param.type === 'data-source') return action.dataSource;
+  }
   /**
    * Handles action parameter.
    */

core/src/Controllers.ts

@@ -50,9 +50,14 @@ export class Controllers<T extends Driver> {
       .map(param => {
         return this.parameterHandler.handle(action, param)
       });
+    // compute all constructor parameters
+    const paramsConstructor = actionMetadata.paramsConstructor
+      .sort((param1, param2) => param1.index - param2.index)
+      .map(param => this.parameterHandler.handleConstructor(action, param))
+      .filter(Boolean);
 
     return Promise.all(paramsPromises).then((params) => {
-      const result = actionMetadata.callMethod(params, action);
+      const result = actionMetadata.callMethod(params, paramsConstructor, action);
       return this.handleCallMethodResult(result, actionMetadata, action);
     })
     .catch(error => {

core/src/builder/MetadataBuilder.ts

@@ -2,9 +2,9 @@ import { ControllerMetadata } from '../metadata/ControllerMetadata.js';
 import { MiddlewareMetadata } from '../metadata/MiddlewareMetadata.js';
 import { getMetadataArgsStorage } from '../metadata/MetadataArgsStorage.js';
 import { ActionMetadata } from '../metadata/ActionMetadata.js';
-import { ActionMetadataArgs } from '../metadata/args/ActionMetadataArgs.js';
 import { ResponseHandlerMetadata } from '../metadata/ResponseHandleMetadata.js';
 import { ParamMetadata } from '../metadata/ParamMetadata.js';
+import { ParamConstructorMetadata } from '../metadata/ParamConstructorMetadata.js';
 import { UseMetadata } from '../metadata/UseMetadata.js';
 import { TypeNexusOptions } from '../DriverOptions.js';
 
@@ -55,30 +55,31 @@ export class MetadataBuilder {
    * Creates action metadata.
    */
   protected createActions(controller: ControllerMetadata): ActionMetadata[] {
-    let target = controller.target;
-    const actionsWithTarget: ActionMetadataArgs[] = [];
-    while (target) {
-      const actions = getMetadataArgsStorage()
-        .filterActionsWithTarget(target)
-        .filter(action => {
-          return actionsWithTarget.map(a => a.method).indexOf(action.method) === -1;
+    const actionsWithTarget: ActionMetadata[] = [];
+    for (let target = controller.target; target; target = Object.getPrototypeOf(target)) {
+      const actions = getMetadataArgsStorage().filterActionsWithTarget(target);
+      const methods = actionsWithTarget.map(a => a.method);
+      actions
+        .filter(({ method }) => !methods.includes(method))
+        .forEach(actionArgs => {
+          const action = new ActionMetadata(controller, { ...actionArgs, target: controller.target }, this.options);
+          action.params = this.createParams(action);
+          action.paramsConstructor = this.createParamsConstructor(action);
+          action.uses = this.createActionUses(action);
+          action.build(this.createActionResponseHandlers(action));
+          actionsWithTarget.push(action);
         });
-
-      actions.forEach(a => {
-        a.target = controller.target;
-        actionsWithTarget.push(a);
-      });
-
-      target = Object.getPrototypeOf(target);
     }
+    return actionsWithTarget;
+  }
 
-    return actionsWithTarget.map(actionArgs => {
-      const action = new ActionMetadata(controller, actionArgs, this.options);
-      action.params = this.createParams(action);
-      action.uses = this.createActionUses(action);
-      action.build(this.createActionResponseHandlers(action));
-      return action;
-    });
+  /**
+   * Creates constructor param metadatas.
+   */
+  protected createParamsConstructor(action: ActionMetadata): ParamConstructorMetadata[] {
+    return getMetadataArgsStorage()
+      .filterParamsConstructorWithTargetAndMethod('constructor')
+      .map(paramArgs => new ParamConstructorMetadata(action, paramArgs));
   }
 
   /**

core/src/decorator/DSource.ts

@@ -2,11 +2,22 @@ import { getMetadataArgsStorage } from '../metadata/MetadataArgsStorage.js';
 
 export function DSource(): ParameterDecorator {
   return function (object: Object, methodName: string, index: number) {
-    getMetadataArgsStorage().params.push({
-      type: 'data-source',
-      object: object,
-      method: methodName,
-      index: index,
-    });
+    const storage = getMetadataArgsStorage();
+    // Support `constructor` decorator definition
+    if (!methodName && typeof index === 'number') {
+      storage.paramsConstructor.push({
+        type: 'data-source',
+        object: object,
+        method: 'constructor',
+        index: index,
+      });
+    } else {
+      storage.params.push({
+        type: 'data-source',
+        object: object,
+        method: methodName,
+        index: index,
+      });
+    }
   };
 }

core/src/metadata/ActionMetadata.ts

@@ -4,6 +4,7 @@ import { ActionMetadataArgs } from './args/ActionMetadataArgs.js';
 import { ResponseHandlerMetadata } from './ResponseHandleMetadata.js';
 import { Action } from '../Action.js';
 import { ParamMetadata } from './ParamMetadata.js';
+import { ParamConstructorMetadata } from './ParamConstructorMetadata.js';
 import { UseMetadata } from './UseMetadata.js';
 import { TypeNexusOptions } from '../DriverOptions.js';
 
@@ -41,6 +42,11 @@ export class ActionMetadata {
    */
   params: ParamMetadata[];
 
+  /**
+   * Action's constructor parameters.
+   */
+  paramsConstructor: ParamConstructorMetadata[] = [];
+
   /**
    * Full route to this action (includes controller base route).
    */
@@ -167,8 +173,8 @@ export class ActionMetadata {
    * Calls action method.
    * Action method is an action defined in a user controller.
    */
-  callMethod(params: any[], action: Action) {
-    const controllerInstance = this.controllerMetadata.getInstance(action);
+  callMethod(params: any[], paramsConstructor: any[], action: Action) {
+    const controllerInstance = this.controllerMetadata.getInstance(action, paramsConstructor);
     return controllerInstance[this.method].apply(controllerInstance, params);
   }
 

core/src/metadata/ControllerMetadata.ts

@@ -19,24 +19,25 @@ export interface UseContainerOptions {
   fallbackOnErrors?: boolean;
 }
 
-
-let userContainer: { get<T>(someClass: ClassConstructor<T> | Function, action?: Action): T };
+let userContainer: UserContainer;
 let userContainerOptions: UseContainerOptions;
-export type ClassConstructor<T> = { new (...args: any[]): T };
+export type ClassConstructor<T, K = unknown> = { new (...args: K[]): T };
 
+interface UserContainer {
+  get<T, K = unknown>(someClass: ClassConstructor<T, K> | Function, params?: K[], action?: Action): T
+}
 /**
  * Container to be used by this library for inversion control. If container was not implicitly set then by default
  * container simply creates a new instance of the given class.
  */
-const defaultContainer: { get<T>(someClass: ClassConstructor<T> | Function): T } = new (class {
+const defaultContainer: UserContainer = new (class {
   private instances: { type: Function; object: any }[] = [];
-  get<T>(someClass: ClassConstructor<T>): T {
+  get<T, K = unknown>(someClass: ClassConstructor<T, K>, paramsConstructor: K[] = []): T {
     let instance = this.instances.find(instance => instance.type === someClass);
     if (!instance) {
-      instance = { type: someClass, object: new someClass() };
+      instance = { type: someClass, object: new someClass(...paramsConstructor) };
       this.instances.push(instance);
     }
-
     return instance.object;
   }
 })();
@@ -46,18 +47,18 @@ const defaultContainer: { get<T>(someClass: ClassConstructor<T> | Function): T }
  * @param someClass A class constructor to resolve
  * @param action The request/response context that `someClass` is being resolved for
  */
-export function getFromContainer<T>(someClass: ClassConstructor<T> | Function, action?: Action): T {
+export function getFromContainer<T, K = unknown>(someClass: ClassConstructor<T, K> | Function, action?: Action, paramsConstructor?: any[]): T {
   if (userContainer) {
     try {
-      const instance = userContainer.get(someClass, action);
+      const instance = userContainer.get(someClass, paramsConstructor || [], action);
       if (instance) return instance;
 
       if (!userContainerOptions || !userContainerOptions.fallback) return instance;
     } catch (error) {
       if (!userContainerOptions || !userContainerOptions.fallbackOnErrors) throw error;
     }
   }
-  return defaultContainer.get<T>(someClass);
+  return defaultContainer.get<T, K>(someClass, paramsConstructor || []);
 }
 
 
@@ -104,8 +105,8 @@ export class ControllerMetadata {
    * Gets instance of the controller.
    * @param action Details around the request session
    */
-  getInstance(action: Action): any {
-    return getFromContainer(this.target, action);
+  getInstance(action: Action, paramsConstructor?: any[]): any {
+    return getFromContainer(this.target, action, paramsConstructor);
   }
   /**
    * Builds everything controller metadata needs.

core/src/metadata/MetadataArgsStorage.ts

@@ -3,6 +3,7 @@ import { ActionMetadataArgs } from './args/ActionMetadataArgs.js';
 import { MiddlewareMetadataArgs } from './args/MiddlewareMetadataArgs.js';
 import { ResponseHandlerMetadataArgs } from './args/ResponseHandleMetadataArgs.js';
 import { ParamMetadataArgs } from './args/ParamMetadataArgs.js';
+import { ParamConstructorMetadataArgs } from './args/ParamConstructorMetadataArgs.js';
 import { UseMetadataArgs } from './args/UseMetadataArgs.js';
 
 /**
@@ -33,6 +34,10 @@ export class MetadataArgsStorage {
    * Registered param metadata args.
    */
   params: ParamMetadataArgs[] = [];
+  /**
+   * Registered constructor param metadata args.
+   */
+  paramsConstructor: ParamConstructorMetadataArgs[] = [];
   /**
    * Registered response handler metadata args.
    */
@@ -67,6 +72,14 @@ export class MetadataArgsStorage {
     });
   }
 
+  /**
+   * Filters constructor parameters by a given classes.
+   */
+  filterParamsConstructorWithTargetAndMethod(methodName: string): ParamConstructorMetadataArgs[] {
+    return this.paramsConstructor.filter(param => {
+      return param.method === methodName;
+    });
+  }
   /**
    * Filters parameters by a given classes.
    */