@e22m4u/ts-rest-router 0.5.5 → 0.6.1

package/src/debuggable-service.spec.ts

@@ -1,5 +1,4 @@
 import {expect} from 'chai';
-import {Service} from '@e22m4u/js-service';
 import {DebuggableService} from './debuggable-service.js';
 
 describe('DebuggableService', function () {
@@ -7,11 +6,4 @@ describe('DebuggableService', function () {
     const res = new DebuggableService();
     expect(typeof res.debug).to.be.eq('function');
   });
-
-  describe('constructor', function () {
-    it('extends the Service class', function () {
-      const res = new DebuggableService();
-      expect(res).to.be.instanceof(Service);
-    });
-  });
 });

package/src/debuggable-service.ts

@@ -1,40 +1,19 @@
-import {Callable} from './types.js';
-import {Debugger} from '@e22m4u/js-debug';
-import {Service} from '@e22m4u/js-service';
-import {toCamelCase} from './utils/index.js';
-import {createDebugger} from '@e22m4u/js-debug';
 import {ServiceContainer} from '@e22m4u/js-service';
+import {DebuggableService as BaseDebuggableService} from '@e22m4u/js-service';
 
 /**
- * Service.
+ * Base debuggable service.
  */
-export class DebuggableService extends Service {
-  /**
-   * Debug.
-   */
-  debug: Debugger;
-
-  /**
-   * Возвращает функцию-отладчик с сегментом пространства имен
-   * указанного в параметре метода.
-   *
-   * @param method
-   * @protected
-   */
-  protected getDebuggerFor(method: Callable) {
-    return this.debug.withHash().withNs(method.name);
-  }
-
+export class DebuggableService extends BaseDebuggableService {
   /**
    * Constructor.
    *
    * @param container
    */
   constructor(container?: ServiceContainer) {
-    super(container);
-    const serviceName = toCamelCase(this.constructor.name);
-    this.debug = createDebugger('tsRestRouter', serviceName).withoutEnvNs();
-    const debug = this.debug.withNs('constructor').withHash();
-    debug('Service created.');
+    super(container, {
+      namespace: 'tsRestRouter',
+      noEnvironmentNamespace: true,
+    });
   }
 }

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

@@ -3,17 +3,17 @@ import {Reflector} from '@e22m4u/ts-reflector';
 import {BeforeActionReflector} from './before-action-reflector.js';
 import {BEFORE_ACTION_METADATA_KEY} from './before-action-metadata.js';
 
-const hook_1 = () => undefined;
-const hook_2 = () => undefined;
-const hook_3 = () => undefined;
+const HOOK_1 = () => undefined;
+const HOOK_2 = () => undefined;
+const HOOK_3 = () => undefined;
 
 describe('BeforeActionReflector', function () {
   describe('class target', function () {
     describe('addMetadata', function () {
       it('adds a given value to the target metadata', function () {
         class Target {}
-        const md1 = {hook: hook_1};
-        const md2 = {hook: [hook_2, hook_3]};
+        const md1 = {hook: HOOK_1};
+        const md2 = {hook: [HOOK_2, HOOK_3]};
         BeforeActionReflector.addMetadata(md1, Target);
         BeforeActionReflector.addMetadata(md2, Target);
         const res = Reflector.getOwnMetadata(
@@ -33,8 +33,8 @@ describe('BeforeActionReflector', function () {
 
       it('returns existing metadata by the target', function () {
         class Target {}
-        const md1 = {hook: hook_1};
-        const md2 = {hook: [hook_2, hook_3]};
+        const md1 = {hook: HOOK_1};
+        const md2 = {hook: [HOOK_2, HOOK_3]};
         const mdArray = [md1, md2];
         Reflector.defineMetadata(BEFORE_ACTION_METADATA_KEY, mdArray, Target);
         const res = BeforeActionReflector.getMetadata(Target);
@@ -47,8 +47,8 @@ describe('BeforeActionReflector', function () {
     describe('addMetadata', function () {
       it('adds a given value to the target metadata', function () {
         class Target {}
-        const md1 = {hook: hook_1};
-        const md2 = {hook: [hook_2, hook_3]};
+        const md1 = {hook: HOOK_1};
+        const md2 = {hook: [HOOK_2, HOOK_3]};
         BeforeActionReflector.addMetadata(md1, Target, 'prop');
         BeforeActionReflector.addMetadata(md2, Target, 'prop');
         const res = Reflector.getOwnMetadata(
@@ -69,8 +69,8 @@ describe('BeforeActionReflector', function () {
 
       it('returns existing metadata by the target', function () {
         class Target {}
-        const md1 = {hook: hook_1};
-        const md2 = {hook: [hook_2, hook_3]};
+        const md1 = {hook: HOOK_1};
+        const md2 = {hook: [HOOK_2, HOOK_3]};
         const mdArray = [md1, md2];
         Reflector.defineMetadata(
           BEFORE_ACTION_METADATA_KEY,
@@ -87,8 +87,8 @@ describe('BeforeActionReflector', function () {
   describe('addMetadata', function () {
     it('can distinguish class and method metadata', function () {
       class Target {}
-      const md1 = {hook: hook_1};
-      const md2 = {hook: hook_2};
+      const md1 = {hook: HOOK_1};
+      const md2 = {hook: HOOK_2};
       BeforeActionReflector.addMetadata(md1, Target);
       BeforeActionReflector.addMetadata(md2, Target, 'prop');
       const res1 = Reflector.getOwnMetadata(BEFORE_ACTION_METADATA_KEY, Target);
@@ -105,8 +105,8 @@ describe('BeforeActionReflector', function () {
   describe('getMetadata', function () {
     it('can distinguish class and method metadata', function () {
       class Target {}
-      const md1 = {hook: hook_1};
-      const md2 = {hook: hook_2};
+      const md1 = {hook: HOOK_1};
+      const md2 = {hook: HOOK_2};
       Reflector.defineMetadata(BEFORE_ACTION_METADATA_KEY, [md1], Target);
       Reflector.defineMetadata(
         BEFORE_ACTION_METADATA_KEY,

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

@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import {expect} from 'chai';
 import {DataType} from '@e22m4u/ts-data-schema';
+import {ServiceContainer} from '@e22m4u/js-service';
 import {requestData} from './request-data-decorator.js';
 import {requestBody} from './request-data-decorator.js';
 import {requestField} from './request-data-decorator.js';
@@ -13,6 +14,8 @@ import {requestQueries} from './request-data-decorator.js';
 import {requestHeaders} from './request-data-decorator.js';
 import {requestCookies} from './request-data-decorator.js';
 import {RequestDataSource} from './request-data-metadata.js';
+import {DataSchemaFactory} from '../../data-schema-types.js';
+import {RequestDataMetadata} from './request-data-metadata.js';
 import {RequestDataReflector} from './request-data-reflector.js';
 
 describe('requestData', function () {
@@ -140,7 +143,7 @@ describe('requestData', function () {
         });
       });
 
-      it('set a given DataSchema to the target metadata', function () {
+      it('sets a given DataSchema to the target metadata', function () {
         const schema = {type: DataType.STRING, required: true};
         class Target {
           myMethod(
@@ -154,6 +157,21 @@ describe('requestData', function () {
           schema,
         });
       });
+
+      it('sets a given DataSchemaFactory to the target metadata', function () {
+        const factory = () => ({type: DataType.STRING, required: true});
+        class Target {
+          myMethod(
+            @requestBody(factory)
+            prop: unknown,
+          ) {}
+        }
+        const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+        expect(res.get(0)).to.be.eql({
+          source: RequestDataSource.BODY,
+          schema: factory,
+        });
+      });
     });
   });
 
@@ -230,6 +248,37 @@ describe('requestData', function () {
           property: propertyKey,
         });
       });
+
+      it('sets a given DataSchemaFactory to the target metadata', function () {
+        const container = {} as ServiceContainer;
+        const factory: DataSchemaFactory = sc => {
+          expect(sc).to.be.eq(container);
+          return {type: DataType.STRING, required: true};
+        };
+        const propertyKey = 'myPropertyKey';
+        class Target {
+          myMethod(
+            @requestParam(propertyKey, factory)
+            prop: unknown,
+          ) {}
+        }
+        const mdMap = RequestDataReflector.getMetadata(Target, 'myMethod');
+        const md = mdMap.get(0) as RequestDataMetadata;
+        expect(md.source).to.be.eq(RequestDataSource.PARAMS);
+        expect(md.schema).to.be.a('function');
+        expect(md.property).to.be.eq(propertyKey);
+        const res1 = md.schema as DataSchemaFactory;
+        const res2 = res1(container);
+        expect(res2).to.be.eql({
+          type: DataType.OBJECT,
+          properties: {
+            [propertyKey]: {
+              type: DataType.STRING,
+              required: true,
+            },
+          },
+        });
+      });
     });
 
     describe('query', function () {
@@ -304,6 +353,37 @@ describe('requestData', function () {
           property: propertyKey,
         });
       });
+
+      it('sets a given DataSchemaFactory to the target metadata', function () {
+        const container = {} as ServiceContainer;
+        const factory: DataSchemaFactory = sc => {
+          expect(sc).to.be.eq(container);
+          return {type: DataType.STRING, required: true};
+        };
+        const propertyKey = 'myPropertyKey';
+        class Target {
+          myMethod(
+            @requestQuery(propertyKey, factory)
+            prop: unknown,
+          ) {}
+        }
+        const mdMap = RequestDataReflector.getMetadata(Target, 'myMethod');
+        const md = mdMap.get(0) as RequestDataMetadata;
+        expect(md.source).to.be.eq(RequestDataSource.QUERY);
+        expect(md.schema).to.be.a('function');
+        expect(md.property).to.be.eq(propertyKey);
+        const res1 = md.schema as DataSchemaFactory;
+        const res2 = res1(container);
+        expect(res2).to.be.eql({
+          type: DataType.OBJECT,
+          properties: {
+            [propertyKey]: {
+              type: DataType.STRING,
+              required: true,
+            },
+          },
+        });
+      });
     });
 
     describe('header', function () {
@@ -378,6 +458,37 @@ describe('requestData', function () {
           property: propertyKey,
         });
       });
+
+      it('sets a given DataSchemaFactory to the target metadata', function () {
+        const container = {} as ServiceContainer;
+        const factory: DataSchemaFactory = sc => {
+          expect(sc).to.be.eq(container);
+          return {type: DataType.STRING, required: true};
+        };
+        const propertyKey = 'myPropertyKey';
+        class Target {
+          myMethod(
+            @requestHeader(propertyKey, factory)
+            prop: unknown,
+          ) {}
+        }
+        const mdMap = RequestDataReflector.getMetadata(Target, 'myMethod');
+        const md = mdMap.get(0) as RequestDataMetadata;
+        expect(md.source).to.be.eq(RequestDataSource.HEADERS);
+        expect(md.schema).to.be.a('function');
+        expect(md.property).to.be.eq(propertyKey);
+        const res1 = md.schema as DataSchemaFactory;
+        const res2 = res1(container);
+        expect(res2).to.be.eql({
+          type: DataType.OBJECT,
+          properties: {
+            [propertyKey]: {
+              type: DataType.STRING,
+              required: true,
+            },
+          },
+        });
+      });
     });
 
     describe('cookie', function () {
@@ -452,6 +563,37 @@ describe('requestData', function () {
           property: propertyKey,
         });
       });
+
+      it('sets a given DataSchemaFactory to the target metadata', function () {
+        const container = {} as ServiceContainer;
+        const factory: DataSchemaFactory = sc => {
+          expect(sc).to.be.eq(container);
+          return {type: DataType.STRING, required: true};
+        };
+        const propertyKey = 'myPropertyKey';
+        class Target {
+          myMethod(
+            @requestCookie(propertyKey, factory)
+            prop: unknown,
+          ) {}
+        }
+        const mdMap = RequestDataReflector.getMetadata(Target, 'myMethod');
+        const md = mdMap.get(0) as RequestDataMetadata;
+        expect(md.source).to.be.eq(RequestDataSource.COOKIE);
+        expect(md.schema).to.be.a('function');
+        expect(md.property).to.be.eq(propertyKey);
+        const res1 = md.schema as DataSchemaFactory;
+        const res2 = res1(container);
+        expect(res2).to.be.eql({
+          type: DataType.OBJECT,
+          properties: {
+            [propertyKey]: {
+              type: DataType.STRING,
+              required: true,
+            },
+          },
+        });
+      });
     });
 
     describe('field', function () {
@@ -526,6 +668,37 @@ describe('requestData', function () {
           property: propertyKey,
         });
       });
+
+      it('sets a given DataSchemaFactory to the target metadata', function () {
+        const container = {} as ServiceContainer;
+        const factory: DataSchemaFactory = sc => {
+          expect(sc).to.be.eq(container);
+          return {type: DataType.STRING, required: true};
+        };
+        const propertyKey = 'myPropertyKey';
+        class Target {
+          myMethod(
+            @requestField(propertyKey, factory)
+            prop: unknown,
+          ) {}
+        }
+        const mdMap = RequestDataReflector.getMetadata(Target, 'myMethod');
+        const md = mdMap.get(0) as RequestDataMetadata;
+        expect(md.source).to.be.eq(RequestDataSource.BODY);
+        expect(md.schema).to.be.a('function');
+        expect(md.property).to.be.eq(propertyKey);
+        const res1 = md.schema as DataSchemaFactory;
+        const res2 = res1(container);
+        expect(res2).to.be.eql({
+          type: DataType.OBJECT,
+          properties: {
+            [propertyKey]: {
+              type: DataType.STRING,
+              required: true,
+            },
+          },
+        });
+      });
     });
   });
 });

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

@@ -4,9 +4,11 @@ import {Constructor} from '../../types.js';
 import {DataType} from '@e22m4u/ts-data-schema';
 import {DataSchema} from '@e22m4u/ts-data-schema';
 import {DecoratorTargetType} from '@e22m4u/ts-reflector';
+import {DataSchemaInput} from '../../data-schema-types.js';
 import {getDecoratorTargetType} from '@e22m4u/ts-reflector';
 import {RequestDataSource} from './request-data-metadata.js';
 import {RequestDataMetadata} from './request-data-metadata.js';
+import {DataSchemaOrFactory} from '../../data-schema-types.js';
 import {RequestDataReflector} from './request-data-reflector.js';
 
 /**
@@ -42,12 +44,12 @@ export function requestData<T extends object>(options: RequestDataOptions) {
  * @param source
  */
 function createRequestDataDecoratorWithSource(source: RequestDataSource) {
-  return function (schemaOrType?: DataSchema | DataType) {
-    let schema: DataSchema;
-    if (typeof schemaOrType === 'object') {
-      schema = schemaOrType;
-    } else if (typeof schemaOrType === 'string') {
-      schema = {type: schemaOrType};
+  return function (schemaInput?: DataSchemaInput) {
+    let schema: DataSchemaOrFactory;
+    if (typeof schemaInput === 'function' || typeof schemaInput === 'object') {
+      schema = schemaInput;
+    } else if (typeof schemaInput === 'string') {
+      schema = {type: schemaInput};
     } else {
       schema = {type: DataType.ANY};
     }
@@ -63,14 +65,21 @@ function createRequestDataDecoratorWithSource(source: RequestDataSource) {
 function createRequestDataPropertyDecoratorWithSource(
   source: RequestDataSource,
 ) {
-  return function (propertyKey: string, schemaOrType?: DataSchema | DataType) {
-    const properties = {} as NoUndef<DataSchema['properties']>;
+  return function (propertyKey: string, schemaInput?: DataSchemaInput) {
     const rootSchema: DataSchema = {type: DataType.OBJECT};
-    if (typeof schemaOrType === 'object') {
-      properties[propertyKey] = schemaOrType;
+    const properties = {} as NoUndef<DataSchema['properties']>;
+    let schemaOrFactory: DataSchemaOrFactory = rootSchema;
+    if (typeof schemaInput === 'function') {
+      schemaOrFactory = container => {
+        properties[propertyKey] = schemaInput(container);
+        rootSchema.properties = properties;
+        return rootSchema;
+      };
+    } else if (typeof schemaInput === 'object') {
+      properties[propertyKey] = schemaInput;
       rootSchema.properties = properties;
-    } else if (typeof schemaOrType === 'string') {
-      properties[propertyKey] = {type: schemaOrType};
+    } else if (typeof schemaInput === 'string') {
+      properties[propertyKey] = {type: schemaInput};
       rootSchema.properties = properties;
     } else {
       properties[propertyKey] = {type: DataType.ANY};
@@ -78,7 +87,7 @@ function createRequestDataPropertyDecoratorWithSource(
     }
     return requestData({
       source: source,
-      schema: rootSchema,
+      schema: schemaOrFactory,
       property: propertyKey,
     });
   };

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

@@ -1,5 +1,5 @@
 import {MetadataKey} from '@e22m4u/ts-reflector';
-import {DataSchema} from '@e22m4u/ts-data-schema';
+import {DataSchemaOrFactory} from '../../data-schema-types.js';
 
 /**
  * Request data source.
@@ -17,7 +17,7 @@ export enum RequestDataSource {
  */
 export type RequestDataMetadata = {
   source: RequestDataSource;
-  schema?: DataSchema;
+  schema?: DataSchemaOrFactory;
   property?: string;
 };
 

package/src/decorators/response-body/response-body-decorator.spec.ts

@@ -22,7 +22,7 @@ describe('responseBody', function () {
     expect(res.get('myMethod')).to.be.eql({schema: {type: DataType.STRING}});
   });
 
-  it('sets the given schema to the target metadata', function () {
+  it('sets the given DataSchema to the target metadata', function () {
     const schema = {
       type: DataType.OBJECT,
       properties: {
@@ -37,4 +37,20 @@ describe('responseBody', function () {
     const res = ResponseBodyReflector.getMetadata(Target);
     expect(res.get('myMethod')).to.be.eql({schema});
   });
+
+  it('sets the given DataSchemaFactory to the target metadata', function () {
+    const factory = () => ({
+      type: DataType.OBJECT,
+      properties: {
+        foo: {type: DataType.STRING},
+        bar: {type: DataType.NUMBER},
+      },
+    });
+    class Target {
+      @responseBody(factory)
+      myMethod() {}
+    }
+    const res = ResponseBodyReflector.getMetadata(Target);
+    expect(res.get('myMethod')).to.be.eql({schema: factory});
+  });
 });

package/src/decorators/response-body/response-body-decorator.ts

@@ -1,9 +1,9 @@
 import {Prototype} from '../../types.js';
 import {Constructor} from '../../types.js';
-import {DataType} from '@e22m4u/ts-data-schema';
-import {DataSchema} from '@e22m4u/ts-data-schema';
 import {DecoratorTargetType} from '@e22m4u/ts-reflector';
+import {DataSchemaInput} from '../../data-schema-types.js';
 import {getDecoratorTargetType} from '@e22m4u/ts-reflector';
+import {DataSchemaOrFactory} from '../../data-schema-types.js';
 import {ResponseBodyReflector} from './response-body-reflector.js';
 
 /**
@@ -11,9 +11,7 @@ import {ResponseBodyReflector} from './response-body-reflector.js';
  *
  * @param schemaOrType
  */
-export function responseBody<T extends object>(
-  schemaOrType?: DataSchema | DataType,
-) {
+export function responseBody<T extends object>(schemaInput?: DataSchemaInput) {
   return function (
     target: Prototype<T>,
     propertyKey: string,
@@ -28,14 +26,14 @@ export function responseBody<T extends object>(
       throw new Error(
         '@responseBody decorator is only supported on an instance method.',
       );
-    let schema: DataSchema | undefined;
-    if (typeof schemaOrType === 'object') {
-      schema = schemaOrType;
-    } else if (typeof schemaOrType === 'string') {
-      schema = {type: schemaOrType};
+    let schemaOrFactory: DataSchemaOrFactory | undefined;
+    if (typeof schemaInput === 'function' || typeof schemaInput === 'object') {
+      schemaOrFactory = schemaInput;
+    } else if (typeof schemaInput === 'string') {
+      schemaOrFactory = {type: schemaInput};
     }
     ResponseBodyReflector.setMetadata(
-      schema ? {schema} : {},
+      schemaOrFactory ? {schema: schemaOrFactory} : {},
       target.constructor as Constructor<T>,
       propertyKey,
     );

package/src/decorators/response-body/response-body-metadata.ts

@@ -1,11 +1,11 @@
 import {MetadataKey} from '@e22m4u/ts-reflector';
-import {DataSchema} from '@e22m4u/ts-data-schema';
+import {DataSchemaOrFactory} from '../../data-schema-types.js';
 
 /**
  * Response body metadata.
  */
 export type ResponseBodyMetadata = {
-  schema?: DataSchema;
+  schema?: DataSchemaOrFactory;
 };
 
 /**

package/src/index.ts

@@ -1,5 +1,7 @@
-export * from './utils/index.js';
+export * from '@e22m4u/js-trie-router';
+
 export * from './rest-router.js';
 export * from './errors/index.js';
 export * from './decorators/index.js';
+export * from './data-schema-types.js';
 export * from './controller-registry.js';

package/src/utils/index.ts

@@ -1,3 +1 @@
 export * from './capitalize.js';
-export * from './create-error.js';
-export * from './to-camel-case.js';

package/dist/esm/utils/create-error.d.ts

@@ -1,10 +0,0 @@
-import { Constructor } from '../types.js';
-/**
- * Create error.
- *
- * @param {Function} errorCtor
- * @param {string} message
- * @param {*[]|undefined} args
- * @returns {object}
- */
-export declare function createError<T>(errorCtor: Constructor<T>, message: string, ...args: unknown[]): T;

package/dist/esm/utils/create-error.js

@@ -1,13 +0,0 @@
-import { format } from '@e22m4u/js-format';
-/**
- * Create error.
- *
- * @param {Function} errorCtor
- * @param {string} message
- * @param {*[]|undefined} args
- * @returns {object}
- */
-export function createError(errorCtor, message, ...args) {
-    const interpolatedMessage = format(message, ...args);
-    return new errorCtor(interpolatedMessage);
-}

package/dist/esm/utils/create-error.spec.js

@@ -1,8 +0,0 @@
-import { expect } from 'chai';
-import { createError } from './create-error.js';
-describe('createError', function () {
-    it('interpolates the given message with arguments', function () {
-        const res = createError(Error, 'My %s', 'message');
-        expect(res.message).to.be.eq('My message');
-    });
-});

package/dist/esm/utils/to-camel-case.d.ts

@@ -1,6 +0,0 @@
-/**
- * To camel case.
- *
- * @param input
- */
-export declare function toCamelCase(input: string): string;

package/dist/esm/utils/to-camel-case.js

@@ -1,11 +0,0 @@
-/**
- * To camel case.
- *
- * @param input
- */
-export function toCamelCase(input) {
-    return input
-        .replace(/(^\w|[A-Z]|\b\w)/g, c => c.toUpperCase())
-        .replace(/\W+/g, '')
-        .replace(/(^\w)/g, c => c.toLowerCase());
-}

package/dist/esm/utils/to-camel-case.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/esm/utils/to-camel-case.spec.js

@@ -1,10 +0,0 @@
-import { expect } from 'chai';
-import { toCamelCase } from './to-camel-case.js';
-describe('toCamelCase', function () {
-    it('returns a camelCase string', function () {
-        expect(toCamelCase('TestString')).to.be.eq('testString');
-        expect(toCamelCase('test-string')).to.be.eq('testString');
-        expect(toCamelCase('test string')).to.be.eq('testString');
-        expect(toCamelCase('Test string')).to.be.eq('testString');
-    });
-});

package/src/utils/create-error.spec.ts

@@ -1,9 +0,0 @@
-import {expect} from 'chai';
-import {createError} from './create-error.js';
-
-describe('createError', function () {
-  it('interpolates the given message with arguments', function () {
-    const res = createError(Error, 'My %s', 'message');
-    expect(res.message).to.be.eq('My message');
-  });
-});

package/src/utils/create-error.ts

@@ -1,19 +0,0 @@
-import {Constructor} from '../types.js';
-import {format} from '@e22m4u/js-format';
-
-/**
- * Create error.
- *
- * @param {Function} errorCtor
- * @param {string} message
- * @param {*[]|undefined} args
- * @returns {object}
- */
-export function createError<T>(
-  errorCtor: Constructor<T>,
-  message: string,
-  ...args: unknown[]
-): T {
-  const interpolatedMessage = format(message, ...args);
-  return new errorCtor(interpolatedMessage);
-}