@e22m4u/ts-rest-router 0.5.5 → 0.6.0

package/dist/cjs/index.cjs

@@ -294,12 +294,12 @@ function requestData(options) {
 }
 __name(requestData, "requestData");
 function createRequestDataDecoratorWithSource(source) {
-  return function(schemaOrType) {
+  return function(schemaInput) {
     let schema;
-    if (typeof schemaOrType === "object") {
-      schema = schemaOrType;
-    } else if (typeof schemaOrType === "string") {
-      schema = { type: schemaOrType };
+    if (typeof schemaInput === "function" || typeof schemaInput === "object") {
+      schema = schemaInput;
+    } else if (typeof schemaInput === "string") {
+      schema = { type: schemaInput };
     } else {
       schema = { type: import_ts_data_schema.DataType.ANY };
     }
@@ -308,14 +308,21 @@ function createRequestDataDecoratorWithSource(source) {
 }
 __name(createRequestDataDecoratorWithSource, "createRequestDataDecoratorWithSource");
 function createRequestDataPropertyDecoratorWithSource(source) {
-  return function(propertyKey, schemaOrType) {
-    const properties = {};
+  return function(propertyKey, schemaInput) {
     const rootSchema = { type: import_ts_data_schema.DataType.OBJECT };
-    if (typeof schemaOrType === "object") {
-      properties[propertyKey] = schemaOrType;
+    const properties = {};
+    let schemaOrFactory = rootSchema;
+    if (typeof schemaInput === "function") {
+      schemaOrFactory = /* @__PURE__ */ __name((container) => {
+        properties[propertyKey] = schemaInput(container);
+        rootSchema.properties = properties;
+        return rootSchema;
+      }, "schemaOrFactory");
+    } 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: import_ts_data_schema.DataType.ANY };
@@ -323,7 +330,7 @@ function createRequestDataPropertyDecoratorWithSource(source) {
     }
     return requestData({
       source,
-      schema: rootSchema,
+      schema: schemaOrFactory,
       property: propertyKey
     });
   };
@@ -478,18 +485,18 @@ __name(_ResponseBodyReflector, "ResponseBodyReflector");
 var ResponseBodyReflector = _ResponseBodyReflector;
 
 // dist/esm/decorators/response-body/response-body-decorator.js
-function responseBody(schemaOrType) {
+function responseBody(schemaInput) {
   return function(target, propertyKey, descriptor) {
     const decoratorType = (0, import_ts_reflector20.getDecoratorTargetType)(target, propertyKey, descriptor);
     if (decoratorType !== import_ts_reflector19.DecoratorTargetType.INSTANCE_METHOD)
       throw new Error("@responseBody decorator is only supported on an instance method.");
-    let schema;
-    if (typeof schemaOrType === "object") {
-      schema = schemaOrType;
-    } else if (typeof schemaOrType === "string") {
-      schema = { type: schemaOrType };
+    let schemaOrFactory;
+    if (typeof schemaInput === "function" || typeof schemaInput === "object") {
+      schemaOrFactory = schemaInput;
+    } else if (typeof schemaInput === "string") {
+      schemaOrFactory = { type: schemaInput };
     }
-    ResponseBodyReflector.setMetadata(schema ? { schema } : {}, target.constructor, propertyKey);
+    ResponseBodyReflector.setMetadata(schemaOrFactory ? { schema: schemaOrFactory } : {}, target.constructor, propertyKey);
   };
 }
 __name(responseBody, "responseBody");
@@ -935,14 +942,21 @@ var _ControllerRegistry = class _ControllerRegistry extends DebuggableService {
           }
           debug("Request data source is %v.", requestDataMd.source);
           if (requestDataMd.schema) {
-            data = defaultsApplier.applyDefaultValuesIfNeeded(data, requestDataMd.schema, requestDataMd.source);
+            let 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, 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.");
           }
           if (requestDataMd.property == null) {

package/dist/esm/controller-registry.js

@@ -384,14 +384,22 @@ export class ControllerRegistry extends DebuggableService {
                     // по умолчанию, выполняется конвертация входящего
                     // значения и валидация согласно схеме
                     if (requestDataMd.schema) {
-                        data = defaultsApplier.applyDefaultValuesIfNeeded(data, requestDataMd.schema, requestDataMd.source);
+                        let 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, 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/dist/esm/data-schema-types.d.ts

@@ -0,0 +1,15 @@
+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/dist/esm/data-schema-types.js

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

package/dist/esm/decorators/before-action/before-action-reflector.spec.js

@@ -2,17 +2,17 @@ import { expect } from 'chai';
 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(BEFORE_ACTION_METADATA_KEY, Target);
@@ -29,8 +29,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);
@@ -43,8 +43,8 @@ describe('BeforeActionReflector', 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(BEFORE_ACTION_METADATA_KEY, Target, 'prop');
@@ -61,8 +61,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, 'prop');
                 const res = BeforeActionReflector.getMetadata(Target, 'prop');
@@ -74,8 +74,8 @@ describe('BeforeActionReflector', 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);
@@ -88,8 +88,8 @@ describe('BeforeActionReflector', 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, [md2], Target, 'prop');
             const res1 = BeforeActionReflector.getMetadata(Target);

package/dist/esm/decorators/request-data/request-data-decorator.d.ts

@@ -1,6 +1,5 @@
 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';
 import { RequestDataMetadata } from './request-data-metadata.js';
 /**
  * Request data options.
@@ -15,13 +14,13 @@ export declare function requestData<T extends object>(options: RequestDataOption
 /**
  * Decorator aliases.
  */
-export declare const requestParams: (schemaOrType?: DataSchema | DataType) => (target: Prototype<object>, propertyKey: string, index: number) => void;
-export declare const requestParam: (propertyKey: string, schemaOrType?: DataSchema | DataType) => (target: Prototype<object>, propertyKey: string, index: number) => void;
-export declare const requestQueries: (schemaOrType?: DataSchema | DataType) => (target: Prototype<object>, propertyKey: string, index: number) => void;
-export declare const requestQuery: (propertyKey: string, schemaOrType?: DataSchema | DataType) => (target: Prototype<object>, propertyKey: string, index: number) => void;
-export declare const requestHeaders: (schemaOrType?: DataSchema | DataType) => (target: Prototype<object>, propertyKey: string, index: number) => void;
-export declare const requestHeader: (propertyKey: string, schemaOrType?: DataSchema | DataType) => (target: Prototype<object>, propertyKey: string, index: number) => void;
-export declare const requestCookies: (schemaOrType?: DataSchema | DataType) => (target: Prototype<object>, propertyKey: string, index: number) => void;
-export declare const requestCookie: (propertyKey: string, schemaOrType?: DataSchema | DataType) => (target: Prototype<object>, propertyKey: string, index: number) => void;
-export declare const requestBody: (schemaOrType?: DataSchema | DataType) => (target: Prototype<object>, propertyKey: string, index: number) => void;
-export declare const requestField: (propertyKey: string, schemaOrType?: DataSchema | DataType) => (target: Prototype<object>, propertyKey: string, index: number) => void;
+export declare const requestParams: (schemaInput?: DataSchemaInput) => (target: Prototype<object>, propertyKey: string, index: number) => void;
+export declare const requestParam: (propertyKey: string, schemaInput?: DataSchemaInput) => (target: Prototype<object>, propertyKey: string, index: number) => void;
+export declare const requestQueries: (schemaInput?: DataSchemaInput) => (target: Prototype<object>, propertyKey: string, index: number) => void;
+export declare const requestQuery: (propertyKey: string, schemaInput?: DataSchemaInput) => (target: Prototype<object>, propertyKey: string, index: number) => void;
+export declare const requestHeaders: (schemaInput?: DataSchemaInput) => (target: Prototype<object>, propertyKey: string, index: number) => void;
+export declare const requestHeader: (propertyKey: string, schemaInput?: DataSchemaInput) => (target: Prototype<object>, propertyKey: string, index: number) => void;
+export declare const requestCookies: (schemaInput?: DataSchemaInput) => (target: Prototype<object>, propertyKey: string, index: number) => void;
+export declare const requestCookie: (propertyKey: string, schemaInput?: DataSchemaInput) => (target: Prototype<object>, propertyKey: string, index: number) => void;
+export declare const requestBody: (schemaInput?: DataSchemaInput) => (target: Prototype<object>, propertyKey: string, index: number) => void;
+export declare const requestField: (propertyKey: string, schemaInput?: DataSchemaInput) => (target: Prototype<object>, propertyKey: string, index: number) => void;

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

@@ -23,13 +23,13 @@ export function requestData(options) {
  * @param source
  */
 function createRequestDataDecoratorWithSource(source) {
-    return function (schemaOrType) {
+    return function (schemaInput) {
         let schema;
-        if (typeof schemaOrType === 'object') {
-            schema = schemaOrType;
+        if (typeof schemaInput === 'function' || typeof schemaInput === 'object') {
+            schema = schemaInput;
         }
-        else if (typeof schemaOrType === 'string') {
-            schema = { type: schemaOrType };
+        else if (typeof schemaInput === 'string') {
+            schema = { type: schemaInput };
         }
         else {
             schema = { type: DataType.ANY };
@@ -43,15 +43,23 @@ function createRequestDataDecoratorWithSource(source) {
  * @param source
  */
 function createRequestDataPropertyDecoratorWithSource(source) {
-    return function (propertyKey, schemaOrType) {
-        const properties = {};
+    return function (propertyKey, schemaInput) {
         const rootSchema = { type: DataType.OBJECT };
-        if (typeof schemaOrType === 'object') {
-            properties[propertyKey] = schemaOrType;
+        const properties = {};
+        let schemaOrFactory = 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 {
@@ -60,7 +68,7 @@ function createRequestDataPropertyDecoratorWithSource(source) {
         }
         return requestData({
             source: source,
-            schema: rootSchema,
+            schema: schemaOrFactory,
             property: propertyKey,
         });
     };

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.