@e22m4u/ts-rest-router 0.5.4 → 0.6.0

package/dist/esm/decorators/response-body/response-body-decorator.spec.js

@@ -38,7 +38,7 @@ describe('responseBody', function () {
         const res = ResponseBodyReflector.getMetadata(Target);
         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: {
@@ -58,4 +58,24 @@ 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 {
+            myMethod() { }
+        }
+        __decorate([
+            responseBody(factory),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], Target.prototype, "myMethod", null);
+        const res = ResponseBodyReflector.getMetadata(Target);
+        expect(res.get('myMethod')).to.be.eql({ schema: factory });
+    });
 });

package/dist/esm/decorators/response-body/response-body-metadata.d.ts

@@ -1,10 +1,10 @@
 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;
 };
 /**
  * Response body metadata map.

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.4",
+  "version": "0.6.0",
   "description": "Декларативный REST-маршрутизатор на основе контроллеров для TypeScript",
   "author": "Mikhail Evstropov <e22m4u@yandex.ru>",
   "license": "MIT",
@@ -44,8 +44,8 @@
     "@e22m4u/js-debug": "~0.3.1",
     "@e22m4u/js-format": "~0.2.0",
     "@e22m4u/js-service": "~0.4.0",
-    "@e22m4u/js-trie-router": "~0.3.0",
-    "@e22m4u/ts-data-schema": "~0.4.2",
+    "@e22m4u/js-trie-router": "~0.3.1",
+    "@e22m4u/ts-data-schema": "~0.4.3",
     "@e22m4u/ts-reflector": "~0.1.7",
     "http-errors": "~2.0.0"
   },
@@ -57,7 +57,7 @@
     "@types/debug": "~4.1.12",
     "@types/http-errors": "~2.0.5",
     "@types/mocha": "~10.0.10",
-    "@types/node": "~24.6.0",
+    "@types/node": "~24.6.1",
     "c8": "~10.1.3",
     "chai": "~6.2.0",
     "esbuild": "~0.25.10",
@@ -70,7 +70,7 @@
     "prettier": "~3.6.2",
     "rimraf": "~6.0.1",
     "tsx": "~4.20.6",
-    "typescript": "~5.9.2",
+    "typescript": "~5.9.3",
     "typescript-eslint": "~8.45.0"
   }
 }

package/src/controller-registry.spec.ts

@@ -20,22 +20,24 @@ import {
   getAction,
   postAction,
   requestBody,
-  requestCookie,
-  requestCookies,
   requestField,
-  requestHeader,
+  requestCookies,
+  requestCookie,
   requestHeaders,
-  requestParam,
+  requestHeader,
   requestParams,
+  requestParam,
   requestQueries,
   requestQuery,
   restController,
 } 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,
+            },
+          },
+        });
+      });
     });
   });
 });