@e22m4u/ts-rest-router 0.5.5 → 0.6.1

package/dist/esm/decorators/request-data/request-data-decorator.spec.js

@@ -164,7 +164,7 @@ describe('requestData', function () {
                     schema: { type: DataType.STRING },
                 });
             });
-            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(prop) { }
@@ -181,6 +181,23 @@ describe('requestData', function () {
                     schema,
                 });
             });
+            it('sets a given DataSchemaFactory to the target metadata', function () {
+                const factory = () => ({ type: DataType.STRING, required: true });
+                class Target {
+                    myMethod(prop) { }
+                }
+                __decorate([
+                    __param(0, requestBody(factory)),
+                    __metadata("design:type", Function),
+                    __metadata("design:paramtypes", [Object]),
+                    __metadata("design:returntype", void 0)
+                ], Target.prototype, "myMethod", null);
+                const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+                expect(res.get(0)).to.be.eql({
+                    source: RequestDataSource.BODY,
+                    schema: factory,
+                });
+            });
         });
     });
     describe('request data piece by a given property key', function () {
@@ -263,6 +280,39 @@ describe('requestData', function () {
                     property: propertyKey,
                 });
             });
+            it('sets a given DataSchemaFactory to the target metadata', function () {
+                const container = {};
+                const factory = sc => {
+                    expect(sc).to.be.eq(container);
+                    return { type: DataType.STRING, required: true };
+                };
+                const propertyKey = 'myPropertyKey';
+                class Target {
+                    myMethod(prop) { }
+                }
+                __decorate([
+                    __param(0, requestParam(propertyKey, factory)),
+                    __metadata("design:type", Function),
+                    __metadata("design:paramtypes", [Object]),
+                    __metadata("design:returntype", void 0)
+                ], Target.prototype, "myMethod", null);
+                const mdMap = RequestDataReflector.getMetadata(Target, 'myMethod');
+                const md = mdMap.get(0);
+                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;
+                const res2 = res1(container);
+                expect(res2).to.be.eql({
+                    type: DataType.OBJECT,
+                    properties: {
+                        [propertyKey]: {
+                            type: DataType.STRING,
+                            required: true,
+                        },
+                    },
+                });
+            });
         });
         describe('query', function () {
             it('sets a given "propertyKey" to the target metadata', function () {
@@ -343,6 +393,39 @@ describe('requestData', function () {
                     property: propertyKey,
                 });
             });
+            it('sets a given DataSchemaFactory to the target metadata', function () {
+                const container = {};
+                const factory = sc => {
+                    expect(sc).to.be.eq(container);
+                    return { type: DataType.STRING, required: true };
+                };
+                const propertyKey = 'myPropertyKey';
+                class Target {
+                    myMethod(prop) { }
+                }
+                __decorate([
+                    __param(0, requestQuery(propertyKey, factory)),
+                    __metadata("design:type", Function),
+                    __metadata("design:paramtypes", [Object]),
+                    __metadata("design:returntype", void 0)
+                ], Target.prototype, "myMethod", null);
+                const mdMap = RequestDataReflector.getMetadata(Target, 'myMethod');
+                const md = mdMap.get(0);
+                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;
+                const res2 = res1(container);
+                expect(res2).to.be.eql({
+                    type: DataType.OBJECT,
+                    properties: {
+                        [propertyKey]: {
+                            type: DataType.STRING,
+                            required: true,
+                        },
+                    },
+                });
+            });
         });
         describe('header', function () {
             it('sets a given "propertyKey" to the target metadata', function () {
@@ -423,6 +506,39 @@ describe('requestData', function () {
                     property: propertyKey,
                 });
             });
+            it('sets a given DataSchemaFactory to the target metadata', function () {
+                const container = {};
+                const factory = sc => {
+                    expect(sc).to.be.eq(container);
+                    return { type: DataType.STRING, required: true };
+                };
+                const propertyKey = 'myPropertyKey';
+                class Target {
+                    myMethod(prop) { }
+                }
+                __decorate([
+                    __param(0, requestHeader(propertyKey, factory)),
+                    __metadata("design:type", Function),
+                    __metadata("design:paramtypes", [Object]),
+                    __metadata("design:returntype", void 0)
+                ], Target.prototype, "myMethod", null);
+                const mdMap = RequestDataReflector.getMetadata(Target, 'myMethod');
+                const md = mdMap.get(0);
+                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;
+                const res2 = res1(container);
+                expect(res2).to.be.eql({
+                    type: DataType.OBJECT,
+                    properties: {
+                        [propertyKey]: {
+                            type: DataType.STRING,
+                            required: true,
+                        },
+                    },
+                });
+            });
         });
         describe('cookie', function () {
             it('sets a given "propertyKey" to the target metadata', function () {
@@ -503,6 +619,39 @@ describe('requestData', function () {
                     property: propertyKey,
                 });
             });
+            it('sets a given DataSchemaFactory to the target metadata', function () {
+                const container = {};
+                const factory = sc => {
+                    expect(sc).to.be.eq(container);
+                    return { type: DataType.STRING, required: true };
+                };
+                const propertyKey = 'myPropertyKey';
+                class Target {
+                    myMethod(prop) { }
+                }
+                __decorate([
+                    __param(0, requestCookie(propertyKey, factory)),
+                    __metadata("design:type", Function),
+                    __metadata("design:paramtypes", [Object]),
+                    __metadata("design:returntype", void 0)
+                ], Target.prototype, "myMethod", null);
+                const mdMap = RequestDataReflector.getMetadata(Target, 'myMethod');
+                const md = mdMap.get(0);
+                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;
+                const res2 = res1(container);
+                expect(res2).to.be.eql({
+                    type: DataType.OBJECT,
+                    properties: {
+                        [propertyKey]: {
+                            type: DataType.STRING,
+                            required: true,
+                        },
+                    },
+                });
+            });
         });
         describe('field', function () {
             it('sets a given "propertyKey" to the target metadata', function () {
@@ -583,6 +732,39 @@ describe('requestData', function () {
                     property: propertyKey,
                 });
             });
+            it('sets a given DataSchemaFactory to the target metadata', function () {
+                const container = {};
+                const factory = sc => {
+                    expect(sc).to.be.eq(container);
+                    return { type: DataType.STRING, required: true };
+                };
+                const propertyKey = 'myPropertyKey';
+                class Target {
+                    myMethod(prop) { }
+                }
+                __decorate([
+                    __param(0, requestField(propertyKey, factory)),
+                    __metadata("design:type", Function),
+                    __metadata("design:paramtypes", [Object]),
+                    __metadata("design:returntype", void 0)
+                ], Target.prototype, "myMethod", null);
+                const mdMap = RequestDataReflector.getMetadata(Target, 'myMethod');
+                const md = mdMap.get(0);
+                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;
+                const res2 = res1(container);
+                expect(res2).to.be.eql({
+                    type: DataType.OBJECT,
+                    properties: {
+                        [propertyKey]: {
+                            type: DataType.STRING,
+                            required: true,
+                        },
+                    },
+                });
+            });
         });
     });
 });

package/dist/esm/decorators/request-data/request-data-metadata.d.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.
  */
@@ -15,7 +15,7 @@ export declare enum RequestDataSource {
  */
 export type RequestDataMetadata = {
     source: RequestDataSource;
-    schema?: DataSchema;
+    schema?: DataSchemaOrFactory;
     property?: string;
 };
 /**

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

@@ -1,9 +1,8 @@
 import { Prototype } from '../../types.js';
-import { DataType } from '@e22m4u/ts-data-schema';
-import { DataSchema } from '@e22m4u/ts-data-schema';
+import { DataSchemaInput } from '../../data-schema-types.js';
 /**
  * Response body decorator.
  *
  * @param schemaOrType
  */
-export declare function responseBody<T extends object>(schemaOrType?: DataSchema | DataType): (target: Prototype<T>, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function responseBody<T extends object>(schemaInput?: DataSchemaInput): (target: Prototype<T>, propertyKey: string, descriptor: PropertyDescriptor) => void;

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

@@ -6,18 +6,18 @@ import { ResponseBodyReflector } from './response-body-reflector.js';
  *
  * @param schemaOrType
  */
-export function responseBody(schemaOrType) {
+export function responseBody(schemaInput) {
     return function (target, propertyKey, descriptor) {
         const decoratorType = getDecoratorTargetType(target, propertyKey, descriptor);
         if (decoratorType !== DecoratorTargetType.INSTANCE_METHOD)
             throw new Error('@responseBody decorator is only supported on an instance method.');
-        let schema;
-        if (typeof schemaOrType === 'object') {
-            schema = schemaOrType;
+        let schemaOrFactory;
+        if (typeof schemaInput === 'function' || typeof schemaInput === 'object') {
+            schemaOrFactory = schemaInput;
         }
-        else if (typeof schemaOrType === 'string') {
-            schema = { type: schemaOrType };
+        else if (typeof schemaInput === 'string') {
+            schemaOrFactory = { type: schemaInput };
         }
-        ResponseBodyReflector.setMetadata(schema ? { schema } : {}, target.constructor, propertyKey);
+        ResponseBodyReflector.setMetadata(schemaOrFactory ? { schema: schemaOrFactory } : {}, target.constructor, propertyKey);
     };
 }

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

@@ -1,5 +1,6 @@
-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/dist/esm/index.js

@@ -1,5 +1,6 @@
-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/dist/esm/utils/index.d.ts

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

package/dist/esm/utils/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e22m4u/ts-rest-router",
-  "version": "0.5.5",
+  "version": "0.6.1",
   "description": "Декларативный REST-маршрутизатор на основе контроллеров для TypeScript",
   "author": "Mikhail Evstropov <e22m4u@yandex.ru>",
   "license": "MIT",
@@ -43,34 +43,34 @@
   "dependencies": {
     "@e22m4u/js-debug": "~0.3.1",
     "@e22m4u/js-format": "~0.2.0",
-    "@e22m4u/js-service": "~0.4.0",
+    "@e22m4u/js-service": "~0.4.2",
     "@e22m4u/js-trie-router": "~0.3.1",
-    "@e22m4u/ts-data-schema": "~0.4.3",
-    "@e22m4u/ts-reflector": "~0.1.7",
+    "@e22m4u/ts-data-schema": "~0.4.4",
+    "@e22m4u/ts-reflector": "~0.1.8",
     "http-errors": "~2.0.0"
   },
   "devDependencies": {
     "@commitlint/cli": "~20.1.0",
     "@commitlint/config-conventional": "~20.0.0",
-    "@eslint/js": "~9.36.0",
+    "@eslint/js": "~9.37.0",
     "@types/chai": "~5.2.2",
     "@types/debug": "~4.1.12",
     "@types/http-errors": "~2.0.5",
     "@types/mocha": "~10.0.10",
-    "@types/node": "~24.6.1",
+    "@types/node": "~24.7.0",
     "c8": "~10.1.3",
     "chai": "~6.2.0",
     "esbuild": "~0.25.10",
-    "eslint": "~9.36.0",
+    "eslint": "~9.37.0",
     "eslint-config-prettier": "~10.1.8",
     "eslint-plugin-chai-expect": "~3.1.0",
-    "eslint-plugin-mocha": "~11.1.0",
+    "eslint-plugin-mocha": "~11.2.0",
     "husky": "~9.1.7",
-    "mocha": "~11.7.3",
+    "mocha": "~11.7.4",
     "prettier": "~3.6.2",
     "rimraf": "~6.0.1",
     "tsx": "~4.20.6",
     "typescript": "~5.9.3",
-    "typescript-eslint": "~8.45.0"
+    "typescript-eslint": "~8.46.0"
   }
 }

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;