@e22m4u/ts-rest-router 0.0.6 → 0.1.0

package/src/decorators/before/before-reflector.ts

@@ -0,0 +1,50 @@
+import {Constructor} from '../../types.js';
+import {Reflector} from '@e22m4u/ts-reflector';
+import {BeforeMetadata} from './before-metadata.js';
+import {BEFORE_METADATA_KEY} from './before-metadata.js';
+
+/**
+ * Before reflector.
+ */
+export class BeforeReflector {
+  /**
+   * Set metadata.
+   *
+   * @param metadata
+   * @param target
+   * @param propertyKey
+   */
+  static addMetadata(
+    metadata: BeforeMetadata,
+    target: Constructor,
+    propertyKey?: string,
+  ) {
+    const oldArray =
+      Reflector.getOwnMetadata(BEFORE_METADATA_KEY, target, propertyKey) ?? [];
+    const newArray = [metadata, ...oldArray];
+    Reflector.defineMetadata(
+      BEFORE_METADATA_KEY,
+      newArray,
+      target,
+      propertyKey,
+    );
+  }
+
+  /**
+   * Get metadata.
+   *
+   * @param target
+   * @param propertyKey
+   */
+  static getMetadata(
+    target: Constructor,
+    propertyKey?: string,
+  ): BeforeMetadata[] {
+    const metadata = Reflector.getOwnMetadata(
+      BEFORE_METADATA_KEY,
+      target,
+      propertyKey,
+    );
+    return metadata ?? [];
+  }
+}

package/src/decorators/before/index.ts

@@ -0,0 +1,3 @@
+export * from './before-metadata.js';
+export * from './before-reflector.js';
+export * from './before-decorator.js';

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

@@ -1,9 +1,10 @@
 import {expect} from 'chai';
 import {controller} from './controller-decorator.js';
+import {ControllerOptions} from './controller-decorator.js';
 import {ControllerReflector} from './controller-reflector.js';
 
 describe('controller', function () {
-  it('does not requires options', function () {
+  it('does not require options', function () {
     @controller()
     class Target {}
     const res = ControllerReflector.getMetadata(Target);
@@ -11,31 +12,47 @@ describe('controller', function () {
   });
 
   it('sets given options to the target metadata', function () {
-    const path = 'myPath';
-    const before = () => undefined;
-    const after = () => undefined;
-    const extraOption = 'extraOption';
-    @controller({
-      path,
-      before,
-      after,
-      extraOption,
-    })
+    const options = {
+      path: 'myPath',
+      before: () => undefined,
+      after: () => undefined,
+      extraOption: 'extraOption',
+    };
+    @controller(options)
     class Target {}
     const res = ControllerReflector.getMetadata(Target);
     expect(res).to.be.eql({
+      ...options,
       className: 'Target',
-      path,
-      before,
-      after,
-      extraOption,
     });
   });
 
   it('overrides given "className" option by the target class name', function () {
-    @controller({className: 'myClassName'})
+    @controller({className: 'myClassName'} as ControllerOptions)
     class Target {}
     const res = ControllerReflector.getMetadata(Target);
     expect(res).to.be.eql({className: 'Target'});
   });
+
+  it('allows to pass the path option to the first parameter', function () {
+    @controller('myPath')
+    class Target {}
+    const res = ControllerReflector.getMetadata(Target);
+    expect(res).to.be.eql({className: 'Target', path: 'myPath'});
+  });
+
+  it('merges two given arguments in the target metadata', function () {
+    const before = () => undefined;
+    @controller('myPath', {before})
+    class Target {}
+    const res = ControllerReflector.getMetadata(Target);
+    expect(res).to.be.eql({className: 'Target', path: 'myPath', before});
+  });
+
+  it('overrides the path option by the first argument', function () {
+    @controller('myPath1', {path: 'myPath2'})
+    class Target {}
+    const res = ControllerReflector.getMetadata(Target);
+    expect(res).to.be.eql({className: 'Target', path: 'myPath1'});
+  });
 });

package/src/decorators/controller/controller-decorator.ts

@@ -13,17 +13,44 @@ export type ControllerOptions = Flatten<Omit<ControllerMetadata, 'className'>>;
 /**
  * Controller decorator.
  *
+ * @param pathOrOptions
  * @param options
  */
-export function controller<T extends object>(options?: ControllerOptions) {
+export function controller<T extends object>(
+  pathOrOptions?: string | ControllerOptions,
+  options?: ControllerOptions,
+) {
   return function (target: Constructor<T>) {
     const decoratorType = getDecoratorTargetType(target);
     if (decoratorType !== DecoratorTargetType.CONSTRUCTOR)
       throw new Error('@controller decorator is only supported on a class.');
-    const metadata = {
-      ...options,
-      className: target.name,
-    };
-    ControllerReflector.setMetadata(metadata, target);
+    // если первый аргумент является строкой,
+    // то значение используется в качестве
+    // базового пути контроллера
+    if (typeof pathOrOptions === 'string') {
+      // если второй аргумент не определен,
+      // то создается новый объект опций,
+      // который включает базовый путь
+      if (!options) {
+        options = {path: pathOrOptions};
+      }
+      // если второй аргумент определен,
+      // то базовый путь из первого аргумента
+      // передается в объект опций декоратора
+      else {
+        options.path = pathOrOptions;
+      }
+    }
+    // если первый аргумент является объектом,
+    // то его значение используется в качестве
+    // объекта опций декоратора, а второй
+    // аргумент игнорируется
+    else if (typeof pathOrOptions === 'object') {
+      options = pathOrOptions;
+    }
+    ControllerReflector.setMetadata(
+      {...options, className: target.name},
+      target,
+    );
   };
 }

package/src/decorators/controller/controller-metadata.ts

@@ -10,7 +10,6 @@ export type ControllerMetadata = {
   path?: string;
   before?: RoutePreHandler | RoutePreHandler[];
   after?: RoutePostHandler | RoutePostHandler[];
-  [option: string]: unknown | undefined;
 };
 
 /**

package/src/decorators/index.ts

@@ -1,3 +1,5 @@
+export * from './after/index.js';
+export * from './before/index.js';
 export * from './action/index.js';
 export * from './controller/index.js';
 export * from './request-data/index.js';

package/src/decorators/request-context/request-context-decorator.spec.ts

@@ -4,7 +4,7 @@ import {requestContext} from './request-context-decorator.js';
 import {RequestContextReflector} from './request-context-reflector.js';
 
 describe('requestContext', function () {
-  it('does not requires options', function () {
+  it('does not require options', function () {
     class Target {
       method(
         @requestContext()
@@ -15,7 +15,7 @@ describe('requestContext', function () {
     expect(res.get(0)).to.be.eql({property: undefined});
   });
 
-  it('sets a given key of RequestContext as "propertyKey" of the target metadata', function () {
+  it('sets a given property to the target metadata', function () {
     class Target {
       method(
         @requestContext('res')
@@ -25,17 +25,4 @@ describe('requestContext', function () {
     const res = RequestContextReflector.getMetadata(Target, 'method');
     expect(res.get(0)).to.be.eql({property: 'res'});
   });
-
-  it('sets a given RequestContextMetadata as the target metadata', function () {
-    const property = 'res';
-    const customOption = 'customOption';
-    class Target {
-      method(
-        @requestContext({property, customOption})
-        prop: unknown,
-      ) {}
-    }
-    const res = RequestContextReflector.getMetadata(Target, 'method');
-    expect(res.get(0)).to.be.eql({property, customOption});
-  });
 });

package/src/decorators/request-context/request-context-decorator.ts

@@ -4,15 +4,14 @@ import {RequestContext} from '@e22m4u/js-trie-router';
 import {DecoratorTargetType} from '@e22m4u/ts-reflector';
 import {getDecoratorTargetType} from '@e22m4u/ts-reflector';
 import {RequestContextReflector} from './request-context-reflector.js';
-import {RequestContextMetadata} from './request-context-metadata.js';
 
 /**
  * Request context decorator.
  *
- * @param propertyOrMetadata
+ * @param propertyName
  */
 export function requestContext<T extends object>(
-  propertyOrMetadata?: keyof RequestContext | RequestContextMetadata,
+  propertyName?: keyof RequestContext,
 ) {
   return function (
     target: Prototype<T>,
@@ -29,12 +28,8 @@ export function requestContext<T extends object>(
         '@requestContext decorator is only supported ' +
           'on an instance method parameter.',
       );
-    const metadata =
-      typeof propertyOrMetadata !== 'object'
-        ? {property: propertyOrMetadata}
-        : propertyOrMetadata;
     RequestContextReflector.setMetadata(
-      metadata,
+      {property: propertyName},
       target.constructor as Constructor<T>,
       indexOrDescriptor,
       propertyKey,

package/src/decorators/request-context/request-context-metadata.ts

@@ -6,7 +6,6 @@ import {RequestContext} from '@e22m4u/js-trie-router';
  */
 export type RequestContextMetadata = {
   property?: keyof RequestContext;
-  [option: string]: unknown | undefined;
 };
 
 /**

package/src/decorators/request-data/request-data-decorator.spec.ts

@@ -10,26 +10,27 @@ import {params} from './request-data-decorator.js';
 import {queries} from './request-data-decorator.js';
 import {cookies} from './request-data-decorator.js';
 import {headers} from './request-data-decorator.js';
-import {bodyParam} from './request-data-decorator.js';
+import {bodyProp} from './request-data-decorator.js';
 import {requestData} from './request-data-decorator.js';
 import {RequestDataSource} from './request-data-metadata.js';
-import {RequestDataMetadata} from './request-data-metadata.js';
 import {RequestDataReflector} from './request-data-reflector.js';
 
 describe('requestData', function () {
-  it('sets a given argument to the target metadata', function () {
-    const md: RequestDataMetadata = {
-      source: RequestDataSource.PARAMS,
+  it('sets given options to the target metadata', function () {
+    const options = {
+      source: RequestDataSource.BODY,
+      schema: {type: DataType.STRING},
+      property: 'prop',
       customOption: 'myOption',
     };
     class Target {
       myMethod(
-        @requestData(md)
+        @requestData(options)
         prop: unknown,
       ) {}
     }
     const res = RequestDataReflector.getMetadata(Target, 'myMethod');
-    expect(res.get(0)).to.be.eql(md);
+    expect(res.get(0)).to.be.eql(options);
   });
 
   describe('request data by a given source', function () {
@@ -408,11 +409,11 @@ describe('requestData', function () {
       });
     });
 
-    describe('bodyParam', function () {
+    describe('bodyProp', function () {
       it('sets a given "propertyKey" to the target metadata', function () {
         class Target {
           myMethod(
-            @bodyParam('myPropertyKey')
+            @bodyProp('myPropertyKey')
             prop: unknown,
           ) {}
         }
@@ -429,7 +430,7 @@ describe('requestData', function () {
         const propertyType = DataType.STRING;
         class Target {
           myMethod(
-            @bodyParam(propertyKey, propertyType)
+            @bodyProp(propertyKey, propertyType)
             prop: unknown,
           ) {}
         }
@@ -456,7 +457,7 @@ describe('requestData', function () {
         const propertyKey = 'myPropertyKey';
         class Target {
           myMethod(
-            @bodyParam(propertyKey, schema)
+            @bodyProp(propertyKey, schema)
             prop: unknown,
           ) {}
         }

package/src/decorators/request-data/request-data-decorator.ts

@@ -9,12 +9,17 @@ import {RequestDataSource} from './request-data-metadata.js';
 import {RequestDataMetadata} from './request-data-metadata.js';
 import {RequestDataReflector} from './request-data-reflector.js';
 
+/**
+ * Request data options.
+ */
+export type RequestDataOptions = RequestDataMetadata;
+
 /**
  * Request data decorator.
  *
- * @param metadata
+ * @param options
  */
-export function requestData<T extends object>(metadata: RequestDataMetadata) {
+export function requestData<T extends object>(options: RequestDataOptions) {
   return function (
     target: Prototype<T>,
     propertyKey: string,
@@ -31,7 +36,7 @@ export function requestData<T extends object>(metadata: RequestDataMetadata) {
           'on an instance method parameter.',
       );
     RequestDataReflector.setMetadata(
-      metadata,
+      options,
       target.constructor as Constructor<T>,
       indexOrDescriptor,
       propertyKey,
@@ -40,11 +45,11 @@ export function requestData<T extends object>(metadata: RequestDataMetadata) {
 }
 
 /**
- * Create data decorator.
+ * Create request data decorator with source.
  *
  * @param source
  */
-function createDataDecorator(source: RequestDataSource) {
+function createRequestDataDecoratorWithSource(source: RequestDataSource) {
   return function () {
     const schema = {type: DataType.OBJECT};
     return requestData({schema, source});
@@ -52,11 +57,13 @@ function createDataDecorator(source: RequestDataSource) {
 }
 
 /**
- * Create property decorator.
+ * Create request data property decorator with source.
  *
  * @param source
  */
-function createPropertyDecorator(source: RequestDataSource) {
+function createRequestDataPropertyDecoratorWithSource(
+  source: RequestDataSource,
+) {
   return function (propertyKey: string, schemaOrType?: DataSchema | DataType) {
     const properties = {} as NoUndef<DataSchema['properties']>;
     const rootSchema: DataSchema = {type: DataType.OBJECT};
@@ -78,15 +85,33 @@ function createPropertyDecorator(source: RequestDataSource) {
 /**
  * Decorator aliases.
  */
-export const params = createDataDecorator(RequestDataSource.PARAMS);
-export const param = createPropertyDecorator(RequestDataSource.PARAMS);
-export const queries = createDataDecorator(RequestDataSource.QUERY);
-export const query = createPropertyDecorator(RequestDataSource.QUERY);
-export const headers = createDataDecorator(RequestDataSource.HEADERS);
-export const header = createPropertyDecorator(RequestDataSource.HEADERS);
-export const cookies = createDataDecorator(RequestDataSource.COOKIE);
-export const cookie = createPropertyDecorator(RequestDataSource.COOKIE);
-export const bodyParam = createPropertyDecorator(RequestDataSource.BODY);
+export const params = createRequestDataDecoratorWithSource(
+  RequestDataSource.PARAMS,
+);
+export const param = createRequestDataPropertyDecoratorWithSource(
+  RequestDataSource.PARAMS,
+);
+export const queries = createRequestDataDecoratorWithSource(
+  RequestDataSource.QUERY,
+);
+export const query = createRequestDataPropertyDecoratorWithSource(
+  RequestDataSource.QUERY,
+);
+export const headers = createRequestDataDecoratorWithSource(
+  RequestDataSource.HEADERS,
+);
+export const header = createRequestDataPropertyDecoratorWithSource(
+  RequestDataSource.HEADERS,
+);
+export const cookies = createRequestDataDecoratorWithSource(
+  RequestDataSource.COOKIE,
+);
+export const cookie = createRequestDataPropertyDecoratorWithSource(
+  RequestDataSource.COOKIE,
+);
+export const bodyProp = createRequestDataPropertyDecoratorWithSource(
+  RequestDataSource.BODY,
+);
 
 /**
  * Request body decorator.

package/src/decorators/request-data/request-data-metadata.ts

@@ -19,7 +19,6 @@ export type RequestDataMetadata = {
   source: RequestDataSource;
   schema?: DataSchema;
   property?: string;
-  [option: string]: unknown | undefined;
 };
 
 /**

package/src/utils/create-debugger.ts

@@ -1,21 +1,98 @@
-import DebugFactory from 'debug';
+import {inspect} from 'util';
+import DebugModule from 'debug';
+import {AnyObject} from '../types.js';
 import {format} from '@e22m4u/js-format';
 
 /**
  * Debugger.
  */
-export type Debugger = (...args: Parameters<typeof format>) => void;
+export type Debugger = (
+  messageOrData: string | unknown,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ...args: any[]
+) => void;
+
+/**
+ * Colorize string.
+ *
+ * @param input
+ */
+function colorizeString(input: string): string {
+  const c = Number(DebugModule['selectColor'](input));
+  const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c);
+  return `${colorCode};1m${input}\u001B[0m`;
+}
 
 /**
  * Create debugger.
  *
+ * Base usage:
+ * ```ts
+ * const debug = createDebugger('myService');
+ * debug('Service created.');
+ * // ujut:myService Service created.
+ * ```
+ *
+ * Nested namespaces:
+ * ```ts
+ * const debug1 = debug.bind('namespace1');
+ * const debug2 = debug.bind('namespace2');
+ * debug1('Application started');    // ujut:myService [namespace1] Application started
+ * debug2('Connection established'); // ujut:myService [namespace2] Connection established
+ * ```
+ *
+ * Value inspection:
+ * ```ts
+ * debug({foo: 'lorem', bar: 'ipsum'})
+ * // ujut:myService {
+ * // ujut:myService   "foo": "lorem",
+ * // ujut:myService   "bar": "ipsum"
+ * // ujut:myService }
+ * ```
+ *
+ * Titled inspection output:
+ * ```ts
+ * debug({foo: 'lorem', bar: 'ipsum'}, 'My awesome output:')
+ * // ujut:myService My awesome output:
+ * // ujut:myService {
+ * // ujut:myService   "foo": "lorem",
+ * // ujut:myService   "bar": "ipsum"
+ * // ujut:myService }
+ * ```
+ *
  * @param name
  */
 export function createDebugger(name: string): Debugger {
-  const debug = DebugFactory(`tsRestRouter:${name}`);
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return function (message: string, ...args: any[]) {
-    const interpolatedMessage = format(message, ...args);
-    return debug(interpolatedMessage);
+  const debuggerName = `tsRestRouter:${name}`;
+  // включить вывод логов можно принудительно
+  // if (!process.env.DEBUG) DebugModule.enable('ujut*');
+  const debug = DebugModule(debuggerName);
+  return function (
+    this: unknown,
+    messageOrData: string | unknown,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ...args: any[]
+  ) {
+    let prefix = '';
+    if (typeof this === 'string') {
+      const isDebugUsesColors = (debug as AnyObject).useColors;
+      prefix = isDebugUsesColors ? colorizeString(`[${this}] `) : `[${this}] `;
+    }
+    if (typeof messageOrData === 'string') {
+      const interpolatedMessage = format(messageOrData, ...args);
+      return debug(prefix + interpolatedMessage);
+    }
+    const inspectOptions = {
+      showHidden: false,
+      depth: null,
+      colors: true,
+      compact: false,
+    };
+    const multiString = inspect(messageOrData, inspectOptions);
+    const rows = multiString.split('\n');
+    const colorizedDebuggerName = colorizeString(debuggerName);
+    [...args, ...rows].forEach(v =>
+      console.log(`  ${colorizedDebuggerName} ${prefix}${v}`),
+    );
   };
 }