@e22m4u/ts-rest-router 0.0.6 → 0.1.0

package/src/controller-registry.ts

@@ -4,14 +4,15 @@ import {Errorf} from '@e22m4u/js-format';
 import {TrieRouter} from '@e22m4u/js-trie-router';
 import {RouteHandler} from '@e22m4u/js-trie-router';
 import {DataValidator} from '@e22m4u/ts-data-schema';
+import {AfterReflector} from './decorators/index.js';
 import {DataTypeCaster} from '@e22m4u/ts-data-schema';
 import {ActionReflector} from './decorators/index.js';
+import {BeforeReflector} from './decorators/index.js';
 import {NotAControllerError} from './errors/index.js';
 import {RequestContext} from '@e22m4u/js-trie-router';
 import {RoutePreHandler} from '@e22m4u/js-trie-router';
 import {RoutePostHandler} from '@e22m4u/js-trie-router';
 import {RequestDataSource} from './decorators/index.js';
-import {ControllerMetadata} from './decorators/index.js';
 import {DebuggableService} from './debuggable-service.js';
 import {ControllerReflector} from './decorators/index.js';
 import {RequestDataReflector} from './decorators/index.js';
@@ -45,6 +46,7 @@ export class ControllerRegistry extends DebuggableService {
     ctor: Constructor<T>,
     options?: ControllerRootOptions,
   ): this {
+    const debug = this.debug.bind(this.addController.name);
     // проверка повторной регистрации помогает
     // заметить ошибку в коде, который использует
     // интерфейс данного сервиса
@@ -55,66 +57,66 @@ export class ControllerRegistry extends DebuggableService {
     // метаданных применяемых декоратором
     const controllerMd = ControllerReflector.getMetadata(ctor);
     if (!controllerMd) throw new NotAControllerError(ctor);
-    this.debug('Adding controller %s.', ctor.name);
+    debug('Adding controller %s.', ctor.name);
     // определение префикса применяемого
     // к маршрутам контроллера
-    const pathPrefix = this.getPathPrefixByControllerMetadata(
-      controllerMd,
-      options,
-    );
-    this.debug('Path prefix is %v.', pathPrefix);
+    let pathPrefix = '';
+    pathPrefix += this.getPathPrefixFromControllerRootOptions(options);
+    pathPrefix += '/';
+    pathPrefix += this.getPathPrefixFromControllerMetadata(ctor);
+    pathPrefix = pathPrefix.replace(/\/{2,}/g, '/').replace(/\/$/, '');
+    debug('Controller path prefix is %v.', pathPrefix);
     // подготовка pre-обработчиков
-    const preHandlers = this.getPreHandlersByControllerMetadata(
-      controllerMd,
-      options,
-    );
-    this.debug('%v total pre-handlers found.', preHandlers.length);
+    const preHandlers = [
+      ...this.getPreHandlersFromControllerRootOptions(options),
+      ...this.getPreHandlersFromBeforeMetadata(ctor),
+      ...this.getPreHandlersFromControllerMetadata(ctor),
+    ];
+    debug('Controller has %v pre-handlers.', preHandlers.length);
     // подготовка post-обработчиков
-    const postHandlers = this.getPostHandlersByControllerMetadata(
-      controllerMd,
-      options,
-    );
-    this.debug('%v total post-handlers found.', postHandlers.length);
+    const postHandlers = [
+      ...this.getPostHandlersFromControllerRootOptions(options),
+      ...this.getPostHandlersFromAfterMetadata(ctor),
+      ...this.getPostHandlersFromControllerMetadata(ctor),
+    ];
+    debug('Controller has %v post-handlers.', postHandlers.length);
     // обход всех операций контроллера
     // для определения маршрутов
     const actionsMd = ActionReflector.getMetadata(ctor);
-    this.debug('%v actions found.', actionsMd.size);
+    debug('%v actions found.', actionsMd.size);
     const router = this.getService(TrieRouter);
     actionsMd.forEach((actionMd, actionName) => {
-      this.debug('Adding route for %s.%s.', ctor.name, actionName);
+      debug('Adding route for %s.%s.', ctor.name, actionName);
       // подготовка пути маршрута с префиксом
-      this.debug('Route path is %v.', actionMd.path);
-      const prefixedRoutePath = `${pathPrefix}/${actionMd.path}`.replace(
-        /\/\//g,
-        '/',
-      );
-      this.debug('Prefixed route path is %v.', prefixedRoutePath);
+      debug('Route path is %v.', actionMd.path);
+      const prefixedRoutePath = `${pathPrefix}/${actionMd.path}`
+        .replace(/\/{2,}/g, '/')
+        .replace(/\/$/, '');
+      debug('Prefixed route path is %v.', prefixedRoutePath);
       // подготовка pre-обработчиков операции
-      const actionPreHandlers = Array.isArray(actionMd.before)
-        ? actionMd.before
-        : actionMd.before
-          ? [actionMd.before]
-          : [];
-      this.debug('%v action pre-handlers found.', actionPreHandlers.length);
-      const mergedPreHandlers = [...preHandlers, ...actionPreHandlers];
+      const actionPreHandlers = [
+        ...preHandlers,
+        ...this.getPreHandlersFromBeforeMetadata(ctor, actionName),
+        ...this.getPreHandlersFromActionMetadata(ctor, actionName),
+      ];
+      debug('%v action pre-handlers in total.', actionPreHandlers.length);
       // подготовка post-обработчиков операции
-      const actionPostHandlers = Array.isArray(actionMd.after)
-        ? actionMd.after
-        : actionMd.after
-          ? [actionMd.after]
-          : [];
-      this.debug('%v action post-handlers found.', actionPostHandlers.length);
-      const mergedPostHandlers = [...postHandlers, ...actionPostHandlers];
+      const actionPostHandlers = [
+        ...postHandlers,
+        ...this.getPostHandlersFromAfterMetadata(ctor, actionName),
+        ...this.getPostHandlersFromActionMetadata(ctor, actionName),
+      ];
+      debug('%v action post-handlers in total.', actionPostHandlers.length);
       // подготовка обработчика маршрута
       const routeHandler = this.createRouteHandler(ctor, actionName);
       router.defineRoute({
         method: actionMd.method,
         path: prefixedRoutePath,
-        preHandler: mergedPreHandlers,
+        preHandler: actionPreHandlers,
         handler: routeHandler,
-        postHandler: mergedPostHandlers,
+        postHandler: actionPostHandlers,
       });
-      this.debug(
+      debug(
         'Route %s %v is added.',
         actionMd.method.toUpperCase(),
         prefixedRoutePath,
@@ -134,90 +136,229 @@ export class ControllerRegistry extends DebuggableService {
   }
 
   /**
-   * Get path prefix by controller metadata.
+   * Get path prefix from controller root options.
    *
-   * @param controllerMd
    * @param options
    */
-  getPathPrefixByControllerMetadata(
-    controllerMd: ControllerMetadata,
+  protected getPathPrefixFromControllerRootOptions(
     options?: ControllerRootOptions,
   ) {
-    const rootPathPrefix = options?.pathPrefix || '';
-    this.debug('Root path prefix is %v.', rootPathPrefix);
-    const controllerPathPrefix = controllerMd.path || '';
-    this.debug('Controller path prefix is %v.', controllerPathPrefix);
-    const mergedPathPrefix = `/${rootPathPrefix}/${controllerPathPrefix}`
-      .replace(/\/\//g, '/')
-      .replace(/\/$/, '');
-    this.debug('Merged path prefix is %v.', mergedPathPrefix);
-    return mergedPathPrefix;
+    const debug = this.debug.bind(
+      this.getPathPrefixFromControllerRootOptions.name,
+    );
+    debug('Getting path prefix from controller root options.');
+    const res = options?.pathPrefix || '';
+    debug('Controller path prefix is %v.', res);
+    return res;
+  }
+
+  /**
+   * Get path prefix from controller metadata.
+   *
+   * @param ctor
+   */
+  protected getPathPrefixFromControllerMetadata<T>(ctor: Constructor<T>) {
+    const debug = this.debug.bind(
+      this.getPathPrefixFromControllerMetadata.name,
+    );
+    debug('Getting path prefix from @controller metadata.');
+    debug('Metadata target is %s.', ctor.name);
+    const md = ControllerReflector.getMetadata(ctor);
+    if (!md) throw new Errorf('Controller %v has no metadata.', ctor);
+    const res = md.path || '';
+    debug('Controller path prefix is %v.', res);
+    return md.path || '';
   }
 
   /**
-   * Get pre-handlers by controller metadata.
+   * Getting pre-handlers from controller root options.
    *
-   * @param controllerMd
    * @param options
    */
-  getPreHandlersByControllerMetadata(
-    controllerMd: ControllerMetadata,
+  protected getPreHandlersFromControllerRootOptions(
     options?: ControllerRootOptions,
   ) {
-    // подготовка дополнительных
-    // pre-обработчиков запроса
-    let rootPreHandlers: RoutePreHandler[] = [];
+    const debug = this.debug.bind(
+      this.getPreHandlersFromControllerRootOptions.name,
+    );
+    debug('Getting pre-handlers from controller root options.');
+    let res: RoutePreHandler[] = [];
     if (options?.before)
-      rootPreHandlers = Array.isArray(options?.before)
-        ? options.before
-        : [options.before];
-    this.debug('%v root pre-handlers found.', rootPreHandlers.length);
-    // подготовка pre-обработчиков
-    // запроса контроллера
-    let ctlPreHandlers: RoutePreHandler[] = [];
-    if (controllerMd.before)
-      ctlPreHandlers = Array.isArray(controllerMd.before)
-        ? controllerMd.before
-        : [controllerMd.before];
-    this.debug('%v controller pre-handlers found.', ctlPreHandlers.length);
-    // подготовка объединенного набора
-    // pre-обработчиков запроса
-    const mergedPreHandlers = [...rootPreHandlers, ...ctlPreHandlers];
-    this.debug('%v merged pre-handlers.', mergedPreHandlers.length);
-    return mergedPreHandlers;
+      res = Array.isArray(options.before) ? options.before : [options.before];
+    debug('%v pre-handlers found.', res.length);
+    return res;
   }
 
   /**
-   * Get post-handlers by controller metadata.
+   * Getting post-handlers from controller root options.
    *
-   * @param controllerMd
    * @param options
    */
-  getPostHandlersByControllerMetadata(
-    controllerMd: ControllerMetadata,
+  protected getPostHandlersFromControllerRootOptions(
     options?: ControllerRootOptions,
   ) {
-    // подготовка дополнительных
-    // post-обработчиков запроса
-    let rootPostHandlers: RoutePostHandler[] = [];
+    const debug = this.debug.bind(
+      this.getPostHandlersFromControllerRootOptions.name,
+    );
+    debug('Getting post-handlers from controller root options.');
+    let res: RoutePostHandler[] = [];
     if (options?.after)
-      rootPostHandlers = Array.isArray(options.after)
-        ? options.after
-        : [options.after];
-    this.debug('%v root post-handlers found.', rootPostHandlers.length);
-    // подготовка post-обработчиков
-    // запроса контроллера
-    let ctlPostHandlers: RoutePostHandler[] = [];
-    if (controllerMd.after)
-      ctlPostHandlers = Array.isArray(controllerMd.after)
-        ? controllerMd.after
-        : [controllerMd.after];
-    this.debug('%v controller post-handlers found.', ctlPostHandlers.length);
-    // подготовка объединенного набора
-    // post-обработчиков запроса
-    const mergedPostHandlers = [...rootPostHandlers, ...ctlPostHandlers];
-    this.debug('%v merged post-handlers.', mergedPostHandlers.length);
-    return mergedPostHandlers;
+      res = Array.isArray(options.after) ? options.after : [options.after];
+    debug('%v post-handlers found.', res.length);
+    return res;
+  }
+
+  /**
+   * Get pre-handlers from before metadata.
+   *
+   * @param ctor
+   * @param actionName
+   */
+  protected getPreHandlersFromBeforeMetadata<T>(
+    ctor: Constructor<T>,
+    actionName?: string,
+  ) {
+    const debug = this.debug.bind(this.getPreHandlersFromBeforeMetadata.name);
+    debug('Getting pre-handlers from @before metadata.');
+    if (actionName) {
+      debug('Target is %s.%s.', ctor.name, actionName);
+    } else {
+      debug('Target is %s.', ctor.name);
+    }
+    let preHandlers: RoutePreHandler[] = [];
+    const mdArray = BeforeReflector.getMetadata(ctor, actionName);
+    mdArray.forEach(md => {
+      if (Array.isArray(md.middleware)) {
+        preHandlers = [...preHandlers, ...md.middleware];
+      } else {
+        preHandlers.push(md.middleware);
+      }
+    });
+    if (mdArray.length) {
+      debug('%v pre-handlers found.', mdArray.length);
+    } else {
+      debug('No pre-handlers found.');
+    }
+    return preHandlers;
+  }
+
+  /**
+   * Get post-handlers from after metadata.
+   *
+   * @param ctor
+   * @param actionName
+   */
+  protected getPostHandlersFromAfterMetadata<T>(
+    ctor: Constructor<T>,
+    actionName?: string,
+  ) {
+    const debug = this.debug.bind(this.getPostHandlersFromAfterMetadata.name);
+    debug('Getting post-handlers from @after metadata.');
+    if (actionName) {
+      debug('Target is %s.%s.', ctor.name, actionName);
+    } else {
+      debug('Target is %s.', ctor.name);
+    }
+    let res: RoutePostHandler[] = [];
+    const mdArray = AfterReflector.getMetadata(ctor, actionName);
+    mdArray.forEach(md => {
+      if (Array.isArray(md.middleware)) {
+        res = [...res, ...md.middleware];
+      } else {
+        res.push(md.middleware);
+      }
+    });
+    if (mdArray.length) {
+      debug('%v post-handlers found.', mdArray.length);
+    } else {
+      debug('No post-handlers found.');
+    }
+    return res;
+  }
+
+  /**
+   * Get pre-handlers from controller metadata.
+   *
+   * @param ctor
+   */
+  protected getPreHandlersFromControllerMetadata<T>(ctor: Constructor<T>) {
+    const debug = this.debug.bind(
+      this.getPreHandlersFromControllerMetadata.name,
+    );
+    debug('Getting pre-handlers from @controller metadata.');
+    debug('Target is %s.', ctor.name);
+    const md = ControllerReflector.getMetadata(ctor);
+    if (!md) throw new Errorf('Controller %v has no metadata.', ctor);
+    let res: RoutePreHandler[] = [];
+    if (md.before) res = Array.isArray(md.before) ? md.before : [md.before];
+    debug('%v pre-handlers found.', res.length);
+    return res;
+  }
+
+  /**
+   * Get post-handlers from controller metadata.
+   *
+   * @param ctor
+   */
+  protected getPostHandlersFromControllerMetadata<T>(ctor: Constructor<T>) {
+    const debug = this.debug.bind(
+      this.getPostHandlersFromControllerMetadata.name,
+    );
+    debug('Getting post-handlers from @controller metadata.');
+    const md = ControllerReflector.getMetadata(ctor);
+    if (!md) throw new Errorf('Controller %v has no metadata.', ctor);
+    let res: RoutePostHandler[] = [];
+    if (md.after) res = Array.isArray(md.after) ? md.after : [md.after];
+    debug('%v post-handlers found.', res.length);
+    return res;
+  }
+
+  /**
+   * Get pre-handlers from action metadata.
+   *
+   * @param ctor
+   * @param actionName
+   */
+  protected getPreHandlersFromActionMetadata<T>(
+    ctor: Constructor<T>,
+    actionName: string,
+  ) {
+    const debug = this.debug.bind(this.getPreHandlersFromActionMetadata.name);
+    debug('Getting pre-handlers from @action metadata.');
+    const actionsMd = ActionReflector.getMetadata(ctor);
+    const actionMd = actionsMd.get(actionName);
+    if (!actionMd)
+      throw new Errorf('Action %s.%s has no metadata.', ctor.name, actionName);
+    let res: RoutePreHandler[] = [];
+    if (actionMd.before)
+      res = Array.isArray(actionMd.before)
+        ? actionMd.before
+        : [actionMd.before];
+    debug('%v pre-handlers found.', res.length);
+    return res;
+  }
+
+  /**
+   * Get post-handlers from action metadata.
+   *
+   * @param ctor
+   * @param actionName
+   */
+  protected getPostHandlersFromActionMetadata<T>(
+    ctor: Constructor<T>,
+    actionName: string,
+  ) {
+    const debug = this.debug.bind(this.getPreHandlersFromActionMetadata.name);
+    debug('Getting post-handlers from @action metadata.');
+    const actionsMd = ActionReflector.getMetadata(ctor);
+    const actionMd = actionsMd.get(actionName);
+    if (!actionMd)
+      throw new Errorf('Action %s.%s has no metadata.', ctor.name, actionName);
+    let res: RoutePostHandler[] = [];
+    if (actionMd.after)
+      res = Array.isArray(actionMd.after) ? actionMd.after : [actionMd.after];
+    debug('%v pre-handlers found.', res.length);
+    return res;
   }
 
   /**
@@ -227,15 +368,12 @@ export class ControllerRegistry extends DebuggableService {
    * @param actionName
    * @protected
    */
-  createRouteHandler<T extends object>(
+  protected createRouteHandler<T extends object>(
     controllerCtor: Constructor<T>,
     actionName: string,
   ): RouteHandler {
-    this.debug(
-      'Creating route handler for %s.%s.',
-      controllerCtor.name,
-      actionName,
-    );
+    const debug = this.debug.bind(this.createRouteHandler.name);
+    debug('Creating route handler for %s.%s.', controllerCtor.name, actionName);
     const requestContextMetadataMap = RequestContextReflector.getMetadata(
       controllerCtor,
       actionName,
@@ -248,7 +386,7 @@ export class ControllerRegistry extends DebuggableService {
     const dataTypeCaster = this.getService(DataTypeCaster);
     const dataValidator = this.getService(DataValidator);
     return (requestContext: RequestContext) => {
-      this.debug(
+      debug(
         'Executing route handler for %s.%s.',
         controllerCtor.name,
         actionName,
@@ -260,13 +398,13 @@ export class ControllerRegistry extends DebuggableService {
           // значениями из контекста запроса
           const requestContextMd = requestContextMetadataMap.get(index);
           if (requestContextMd != null) {
-            this.debug('Argument %v has request context metadata.', index);
+            debug('Argument %v has request context metadata.', index);
             // если свойство контекста не определено,
             // то используем весь объект контекста
             // в качестве значения текущего аргумента
             if (requestContextMd.property == null) {
-              this.debug('Request context property is not specified.');
-              this.debug('Argument %v is set to %v.', index, requestContext);
+              debug('Request context property is not specified.');
+              debug('Argument %v is set to %v.', index, requestContext);
               return requestContext;
             }
             // если свойство контекста определено,
@@ -274,11 +412,11 @@ export class ControllerRegistry extends DebuggableService {
             // в качестве текущего аргумента
             const propName = requestContextMd.property;
             const propValue = requestContext[propName];
-            this.debug('Request context property is %v.', propName);
-            this.debug('Argument %v is set to %v.', index, propValue);
+            debug('Request context property is %v.', propName);
+            debug('Argument %v is set to %v.', index, propValue);
             return propValue;
           } else {
-            this.debug(
+            debug(
               'No RequestContextMetadata specified for %v argument.',
               index,
             );
@@ -287,7 +425,7 @@ export class ControllerRegistry extends DebuggableService {
           // значениями из данных запроса
           const requestDataMd = requestDataMetadataMap.get(index);
           if (requestDataMd != null) {
-            this.debug('Argument %v has request data metadata.', index);
+            debug('Argument %v has request data metadata.', index);
             // получение данных
             // согласно источнику
             let data: unknown;
@@ -308,7 +446,7 @@ export class ControllerRegistry extends DebuggableService {
                 data = requestContext.body;
                 break;
             }
-            this.debug('Request data source is %v.', requestDataMd.source);
+            debug('Request data source is %v.', requestDataMd.source);
             // при наличии схемы данных выполняется
             // их конвертация и валидация
             if (requestDataMd.schema) {
@@ -316,20 +454,20 @@ export class ControllerRegistry extends DebuggableService {
                 noTypeCastError: true,
                 sourcePath: requestDataMd.source,
               });
-              this.debug('Data type casting is passed.');
+              debug('Data type casting is passed.');
               dataValidator.validate(
                 data,
                 requestDataMd.schema,
                 requestDataMd.source,
               );
-              this.debug('Data validation is passed.');
+              debug('Data validation is passed.');
             }
             // если свойство данных не определено,
             // то используем весь объекта данных
             // в качестве значения текущего аргумента
             if (requestDataMd.property == null) {
-              this.debug('Request data property is not specified.');
-              this.debug('Argument %v is set to %v.', index, data);
+              debug('Request data property is not specified.');
+              debug('Argument %v is set to %v.', index, data);
               return data;
             }
             // если свойство данных определено,
@@ -338,14 +476,11 @@ export class ControllerRegistry extends DebuggableService {
             const dataAsObject = data as Record<string, unknown>;
             const propName = requestDataMd.property;
             const propValue = dataAsObject[propName];
-            this.debug('Request data property is %v.', propName);
-            this.debug('Argument %v is set to %v.', index, propValue);
+            debug('Request data property is %v.', propName);
+            debug('Argument %v is set to %v.', index, propValue);
             return propValue;
           } else {
-            this.debug(
-              'No RequestDataMetadata specified for %v argument.',
-              index,
-            );
+            debug('No RequestDataMetadata specified for %v argument.', index);
           }
         });
       // выполнение операции контроллера

package/src/debuggable-service.ts

@@ -22,6 +22,6 @@ export class DebuggableService extends Service {
     super(container);
     const serviceName = toCamelCase(this.constructor.name);
     this.debug = createDebugger(serviceName);
-    this.debug('%v is created.', this.constructor);
+    this.debug.bind('constructor')('Service created.');
   }
 }

package/src/decorators/action/action-decorator.spec.ts

@@ -5,38 +5,38 @@ import {ActionReflector} from './action-reflector.js';
 
 describe('action', function () {
   it('sets given options to the target metadata', function () {
-    const method = HttpMethod.GET;
-    const path = 'myPath';
-    const before = () => undefined;
-    const after = () => undefined;
-    const customOption = 'customOption';
+    const options = {
+      method: HttpMethod.GET,
+      path: 'myPath',
+      before: () => undefined,
+      after: () => undefined,
+      customOption: 'customOption',
+    };
     class Target {
-      @action({method, path, before, after, customOption})
+      @action(options)
       method() {}
     }
     const res = ActionReflector.getMetadata(Target);
     expect(res.get('method')).to.be.eql({
+      ...options,
       propertyKey: 'method',
-      method,
-      path,
-      before,
-      after,
-      customOption,
     });
   });
 
   it('overrides a given "propertyKey" option by the target method name', function () {
-    const method = HttpMethod.GET;
-    const path = 'myPath';
+    const options = {
+      propertyKey: 'myMethod',
+      method: HttpMethod.GET,
+      path: 'myPath',
+    };
     class Target {
-      @action({propertyKey: 'myMethod', method, path})
+      @action(options)
       method() {}
     }
     const res = ActionReflector.getMetadata(Target);
     expect(res.get('method')).to.be.eql({
+      ...options,
       propertyKey: 'method',
-      method,
-      path,
     });
   });
 });