@e22m4u/ts-rest-router 0.5.5 → 0.6.0

package/dist/esm/index.d.ts

@@ -2,4 +2,5 @@ export * from './utils/index.js';
 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/dist/esm/index.js

@@ -2,4 +2,5 @@ export * from './utils/index.js';
 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e22m4u/ts-rest-router",
-  "version": "0.5.5",
+  "version": "0.6.0",
   "description": "Декларативный REST-маршрутизатор на основе контроллеров для TypeScript",
   "author": "Mikhail Evstropov <e22m4u@yandex.ru>",
   "license": "MIT",

package/src/controller-registry.spec.ts

@@ -33,9 +33,11 @@ import {
 } from './decorators/index.js';
 
 import {expect} from 'chai';
+import {Service} from '@e22m4u/js-service';
 import {DataType} from '@e22m4u/ts-data-schema';
+import {ServiceContainer} from '@e22m4u/js-service';
+import {DataSchemaFactory} from './data-schema-types.js';
 import {ControllerRegistry} from './controller-registry.js';
-import {Service, ServiceContainer} from '@e22m4u/js-service';
 
 const PRE_HANDLER_1 = () => undefined;
 const PRE_HANDLER_2 = () => undefined;
@@ -1039,5 +1041,176 @@ describe('ControllerRegistry', function () {
       await handler(ctx1);
       expect(counter).to.be.eq(1);
     });
+
+    describe('data schema', function () {
+      describe('@requestBody', function () {
+        describe('DataType', function () {
+          it('should cast request data by the specified type', async function () {
+            let invoked = 0;
+            class MyController {
+              myAction(
+                @requestBody(DataType.NUMBER)
+                body: number,
+              ) {
+                expect(body).to.be.eq(10);
+                invoked++;
+              }
+            }
+            const req = createRequestMock();
+            const res = createResponseMock();
+            const S = new ControllerRegistry();
+            const ctx = new RequestContext(S.container, req, res);
+            ctx.body = '10';
+            const handler = S['createRouteHandler'](MyController, 'myAction');
+            await handler(ctx);
+            expect(invoked).to.be.eq(1);
+          });
+        });
+
+        describe('DataSchema', function () {
+          it('should apply default value to request data', async function () {
+            let invoked = 0;
+            class MyController {
+              myAction(
+                @requestBody({
+                  type: DataType.STRING,
+                  default: 'OK',
+                })
+                body: string,
+              ) {
+                expect(body).to.be.eq('OK');
+                invoked++;
+              }
+            }
+            const req = createRequestMock();
+            const res = createResponseMock();
+            const S = new ControllerRegistry();
+            const ctx = new RequestContext(S.container, req, res);
+            const handler = S['createRouteHandler'](MyController, 'myAction');
+            await handler(ctx);
+            expect(invoked).to.be.eq(1);
+          });
+
+          it('should cast request data by the specified type', async function () {
+            let invoked = 0;
+            class MyController {
+              myAction(
+                @requestBody({type: DataType.NUMBER})
+                body: number,
+              ) {
+                expect(body).to.be.eq(10);
+                invoked++;
+              }
+            }
+            const req = createRequestMock();
+            const res = createResponseMock();
+            const S = new ControllerRegistry();
+            const ctx = new RequestContext(S.container, req, res);
+            ctx.body = '10';
+            const handler = S['createRouteHandler'](MyController, 'myAction');
+            await handler(ctx);
+            expect(invoked).to.be.eq(1);
+          });
+
+          it('should validate request data by the given schema', async function () {
+            class MyController {
+              myAction(
+                @requestBody({
+                  type: DataType.OBJECT,
+                  required: true,
+                })
+                body: object,
+              ) {
+                throw new Error('Must not to be invoked');
+                return body;
+              }
+            }
+
+            const req = createRequestMock();
+            const res = createResponseMock();
+            const S = new ControllerRegistry();
+            const ctx = new RequestContext(S.container, req, res);
+            const handler = S['createRouteHandler'](MyController, 'myAction');
+            const throwable = () => handler(ctx);
+            expect(throwable).to.throw(/is required, but undefined was given/);
+          });
+        });
+
+        describe('DataSchemaFactory', function () {
+          it('should apply default value to request data', async function () {
+            let invoked = 0;
+            const S = new ControllerRegistry();
+            const factory: DataSchemaFactory = sc => {
+              expect(sc).to.be.eq(S.container);
+              return {type: DataType.STRING, default: 'OK'};
+            };
+            class MyController {
+              myAction(
+                @requestBody(factory)
+                body: string,
+              ) {
+                expect(body).to.be.eq('OK');
+                invoked++;
+              }
+            }
+            const req = createRequestMock();
+            const res = createResponseMock();
+            const ctx = new RequestContext(S.container, req, res);
+            const handler = S['createRouteHandler'](MyController, 'myAction');
+            await handler(ctx);
+            expect(invoked).to.be.eq(1);
+          });
+
+          it('should cast request data by the specified type', async function () {
+            let invoked = 0;
+            const S = new ControllerRegistry();
+            const factory: DataSchemaFactory = sc => {
+              expect(sc).to.be.eq(S.container);
+              return {type: DataType.NUMBER};
+            };
+            class MyController {
+              myAction(
+                @requestBody(factory)
+                body: number,
+              ) {
+                expect(body).to.be.eq(10);
+                invoked++;
+              }
+            }
+            const req = createRequestMock();
+            const res = createResponseMock();
+            const ctx = new RequestContext(S.container, req, res);
+            ctx.body = '10';
+            const handler = S['createRouteHandler'](MyController, 'myAction');
+            await handler(ctx);
+            expect(invoked).to.be.eq(1);
+          });
+
+          it('should validate request data by the given schema', async function () {
+            const S = new ControllerRegistry();
+            const factory: DataSchemaFactory = sc => {
+              expect(sc).to.be.eq(S.container);
+              return {type: DataType.OBJECT, required: true};
+            };
+            class MyController {
+              myAction(
+                @requestBody(factory)
+                body: object,
+              ) {
+                throw new Error('Must not to be invoked');
+                return body;
+              }
+            }
+
+            const req = createRequestMock();
+            const res = createResponseMock();
+            const ctx = new RequestContext(S.container, req, res);
+            const handler = S['createRouteHandler'](MyController, 'myAction');
+            const throwable = () => handler(ctx);
+            expect(throwable).to.throw(/is required, but undefined was given/);
+          });
+        });
+      });
+    });
   });
 });

package/src/controller-registry.ts

@@ -2,6 +2,7 @@ import {AnyObject} from './types.js';
 import {Constructor} from './types.js';
 import {Errorf} from '@e22m4u/js-format';
 import {TrieRouter} from '@e22m4u/js-trie-router';
+import {DataSchema} from '@e22m4u/ts-data-schema';
 import {RouteHandler} from '@e22m4u/js-trie-router';
 import {DataValidator} from '@e22m4u/ts-data-schema';
 import {DataTypeCaster} from '@e22m4u/ts-data-schema';
@@ -461,22 +462,25 @@ export class ControllerRegistry extends DebuggableService {
             // по умолчанию, выполняется конвертация входящего
             // значения и валидация согласно схеме
             if (requestDataMd.schema) {
+              let dataSchema: DataSchema;
+              if (typeof requestDataMd.schema === 'function') {
+                dataSchema = requestDataMd.schema(this.container);
+                debug('Data schema extracted from factory function.');
+              } else {
+                dataSchema = requestDataMd.schema;
+              }
               data = defaultsApplier.applyDefaultValuesIfNeeded(
                 data,
-                requestDataMd.schema,
+                dataSchema,
                 requestDataMd.source,
               );
               debug('Default values applied.');
-              data = dataTypeCaster.cast(data, requestDataMd.schema, {
+              data = dataTypeCaster.cast(data, dataSchema, {
                 noTypeCastError: true,
                 sourcePath: requestDataMd.source,
               });
               debug('Data type casting applied.');
-              dataValidator.validate(
-                data,
-                requestDataMd.schema,
-                requestDataMd.source,
-              );
+              dataValidator.validate(data, dataSchema, requestDataMd.source);
               debug('Data validation passed.');
             }
             // если свойство данных не определено,

package/src/data-schema-types.ts

@@ -0,0 +1,18 @@
+import {DataType} from '@e22m4u/ts-data-schema';
+import {DataSchema} from '@e22m4u/ts-data-schema';
+import {ServiceContainer} from '@e22m4u/js-service';
+
+/**
+ * Data schema factory.
+ */
+export type DataSchemaFactory = (container: ServiceContainer) => DataSchema;
+
+/**
+ * Data schema or factory.
+ */
+export type DataSchemaOrFactory = DataSchema | DataSchemaFactory;
+
+/**
+ * Data schema input.
+ */
+export type DataSchemaInput = DataSchemaOrFactory | DataType;

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;
 };