@e22m4u/ts-rest-router 0.5.4 → 0.6.0

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

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

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

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

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

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

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

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

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

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

package/src/index.ts

@@ -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';