@e22m4u/ts-rest-router 0.2.0 → 0.2.2

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

@@ -0,0 +1,23 @@
+import { DecoratorTargetType } from '@e22m4u/ts-reflector';
+import { getDecoratorTargetType } from '@e22m4u/ts-reflector';
+import { ResponseBodyReflector } from './response-body-reflector.js';
+/**
+ * Response body decorator.
+ *
+ * @param schemaOrType
+ */
+export function responseBody(schemaOrType) {
+    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;
+        }
+        else if (typeof schemaOrType === 'string') {
+            schema = { type: schemaOrType };
+        }
+        ResponseBodyReflector.setMetadata(schema ? { schema } : {}, target.constructor, propertyKey);
+    };
+}

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

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

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

@@ -0,0 +1,61 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { expect } from 'chai';
+import { DataType } from '@e22m4u/ts-data-schema';
+import { responseBody } from './response-body-decorator.js';
+import { ResponseBodyReflector } from './response-body-reflector.js';
+describe('responseBody', function () {
+    it('does not require arguments', function () {
+        class Target {
+            myMethod() { }
+        }
+        __decorate([
+            responseBody(),
+            __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({});
+    });
+    it('sets the given DataType to the target metadata', function () {
+        class Target {
+            myMethod() { }
+        }
+        __decorate([
+            responseBody(DataType.STRING),
+            __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: { type: DataType.STRING } });
+    });
+    it('sets the given schema to the target metadata', function () {
+        const schema = {
+            type: DataType.OBJECT,
+            properties: {
+                foo: { type: DataType.STRING },
+                bar: { type: DataType.NUMBER },
+            },
+        };
+        class Target {
+            myMethod() { }
+        }
+        __decorate([
+            responseBody(schema),
+            __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 });
+    });
+});

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

@@ -0,0 +1,16 @@
+import { MetadataKey } from '@e22m4u/ts-reflector';
+import { DataSchema } from '@e22m4u/ts-data-schema';
+/**
+ * Response body metadata.
+ */
+export type ResponseBodyMetadata = {
+    schema?: DataSchema;
+};
+/**
+ * Response body metadata map.
+ */
+export type ResponseBodyMetadataMap = Map<string, ResponseBodyMetadata>;
+/**
+ * Response body metadata key.
+ */
+export declare const RESPONSE_BODY_METADATA_KEY: MetadataKey<ResponseBodyMetadataMap>;

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

@@ -0,0 +1,5 @@
+import { MetadataKey } from '@e22m4u/ts-reflector';
+/**
+ * Response body metadata key.
+ */
+export const RESPONSE_BODY_METADATA_KEY = new MetadataKey('responseBodyMetadataKey');

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

@@ -0,0 +1,22 @@
+import { Constructor } from '../../types.js';
+import { ResponseBodyMetadata } from './response-body-metadata.js';
+import { ResponseBodyMetadataMap } from './response-body-metadata.js';
+/**
+ * Response body reflector.
+ */
+export declare class ResponseBodyReflector {
+    /**
+     * Set metadata.
+     *
+     * @param metadata
+     * @param target
+     * @param propertyKey
+     */
+    static setMetadata(metadata: ResponseBodyMetadata, target: Constructor, propertyKey: string): void;
+    /**
+     * Get metadata.
+     *
+     * @param target
+     */
+    static getMetadata(target: Constructor): ResponseBodyMetadataMap;
+}

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

@@ -0,0 +1,29 @@
+import { Reflector } from '@e22m4u/ts-reflector';
+import { RESPONSE_BODY_METADATA_KEY } from './response-body-metadata.js';
+/**
+ * Response body reflector.
+ */
+export class ResponseBodyReflector {
+    /**
+     * Set metadata.
+     *
+     * @param metadata
+     * @param target
+     * @param propertyKey
+     */
+    static setMetadata(metadata, target, propertyKey) {
+        const oldMap = Reflector.getOwnMetadata(RESPONSE_BODY_METADATA_KEY, target);
+        const newMap = new Map(oldMap);
+        newMap.set(propertyKey, metadata);
+        Reflector.defineMetadata(RESPONSE_BODY_METADATA_KEY, newMap, target);
+    }
+    /**
+     * Get metadata.
+     *
+     * @param target
+     */
+    static getMetadata(target) {
+        const metadata = Reflector.getOwnMetadata(RESPONSE_BODY_METADATA_KEY, target);
+        return metadata ?? new Map();
+    }
+}

package/dist/esm/decorators/response-body/response-body-reflector.spec.d.ts

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

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

@@ -0,0 +1,58 @@
+import { expect } from 'chai';
+import { Reflector } from '@e22m4u/ts-reflector';
+import { ResponseBodyReflector } from './response-body-reflector.js';
+import { RESPONSE_BODY_METADATA_KEY } from './response-body-metadata.js';
+describe('ResponseBodyReflector', function () {
+    describe('setMetadata', function () {
+        it('sets a given value as target metadata', function () {
+            class Target {
+            }
+            const md1 = {};
+            const md2 = {};
+            ResponseBodyReflector.setMetadata(md1, Target, 'propertyKey1');
+            ResponseBodyReflector.setMetadata(md2, Target, 'propertyKey2');
+            const res = Reflector.getOwnMetadata(RESPONSE_BODY_METADATA_KEY, Target);
+            expect(res).to.be.instanceof(Map);
+            expect(res.get('propertyKey1')).to.be.eq(md1);
+            expect(res.get('propertyKey2')).to.be.eq(md2);
+        });
+        it('overrides existing metadata', function () {
+            class Target {
+            }
+            const md1 = {};
+            const md2 = {};
+            ResponseBodyReflector.setMetadata(md1, Target, 'propertyKey');
+            const res1 = Reflector.getOwnMetadata(RESPONSE_BODY_METADATA_KEY, Target);
+            expect(res1).to.be.instanceof(Map);
+            expect(res1.get('propertyKey')).to.be.eq(md1);
+            ResponseBodyReflector.setMetadata(md2, Target, 'propertyKey');
+            const res2 = Reflector.getOwnMetadata(RESPONSE_BODY_METADATA_KEY, Target);
+            expect(res2).to.be.instanceof(Map);
+            expect(res2.get('propertyKey')).to.be.eq(md2);
+        });
+    });
+    describe('getMetadata', function () {
+        it('returns an existing metadata of the target', function () {
+            class Target {
+            }
+            const md1 = {};
+            const md2 = {};
+            const mdMap = new Map([
+                ['propertyKey1', md1],
+                ['propertyKey2', md2],
+            ]);
+            Reflector.defineMetadata(RESPONSE_BODY_METADATA_KEY, mdMap, Target);
+            const res = ResponseBodyReflector.getMetadata(Target);
+            expect(res).to.be.instanceof(Map);
+            expect(res.get('propertyKey1')).to.be.eq(md1);
+            expect(res.get('propertyKey2')).to.be.eq(md2);
+        });
+        it('returns an empty map if no metadata', function () {
+            class Target {
+            }
+            const res = ResponseBodyReflector.getMetadata(Target);
+            expect(res).to.be.instanceof(Map);
+            expect(res).to.be.empty;
+        });
+    });
+});

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

@@ -1,5 +1,4 @@
 import { expect } from 'chai';
-import { describe } from 'mocha';
 import { Reflector } from '@e22m4u/ts-reflector';
 import { HttpMethod } from '@e22m4u/js-trie-router';
 import { RestActionReflector } from './rest-action-reflector.js';

package/dist/esm/decorators/rest-controller/rest-controller-reflector.spec.js

@@ -1,5 +1,4 @@
 import { expect } from 'chai';
-import { describe } from 'mocha';
 import { Reflector } from '@e22m4u/ts-reflector';
 import { RestControllerReflector } from './rest-controller-reflector.js';
 import { REST_CONTROLLER_METADATA_KEY } from './rest-controller-metadata.js';

package/eslint.config.js

@@ -31,7 +31,7 @@ export default [
     rules: {
       ...eslintJs.configs.recommended.rules,
       ...eslintPrettierConfig.rules,
-      ...eslintMochaPlugin.configs.flat.recommended.rules,
+      ...eslintMochaPlugin.configs.recommended.rules,
       ...eslintChaiExpectPlugin.configs['recommended-flat'].rules,
       ...eslintTypescript.configs.recommended.reduce(
         (rules, config) => ({...rules, ...config.rules}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e22m4u/ts-rest-router",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "REST маршрутизатор на основе контроллеров для TypeScript",
   "author": "e22m4u <e22m4u@yandex.ru>",
   "license": "MIT",
@@ -41,36 +41,36 @@
     "prepare": "husky"
   },
   "dependencies": {
-    "@e22m4u/js-debug": "~0.0.6",
+    "@e22m4u/js-debug": "~0.1.0",
     "@e22m4u/js-format": "~0.1.0",
     "@e22m4u/js-service": "~0.2.0",
     "@e22m4u/js-trie-router": "~0.0.1",
-    "@e22m4u/ts-data-schema": "~0.0.1",
+    "@e22m4u/ts-data-schema": "~0.2.1",
     "@e22m4u/ts-reflector": "~0.1.0",
     "http-errors": "~2.0.0"
   },
   "devDependencies": {
-    "@commitlint/cli": "~19.8.0",
-    "@commitlint/config-conventional": "~19.8.0",
-    "@eslint/js": "~9.25.1",
-    "@types/chai": "~5.2.1",
+    "@commitlint/cli": "~19.8.1",
+    "@commitlint/config-conventional": "~19.8.1",
+    "@eslint/js": "~9.28.0",
+    "@types/chai": "~5.2.2",
     "@types/debug": "~4.1.12",
     "@types/http-errors": "~2.0.4",
     "@types/mocha": "~10.0.10",
-    "@types/node": "~22.14.1",
+    "@types/node": "~22.15.29",
     "c8": "~10.1.3",
     "chai": "~5.2.0",
-    "esbuild": "~0.25.3",
-    "eslint": "~9.25.1",
-    "eslint-config-prettier": "~10.1.2",
+    "esbuild": "~0.25.5",
+    "eslint": "~9.28.0",
+    "eslint-config-prettier": "~10.1.5",
     "eslint-plugin-chai-expect": "~3.1.0",
-    "eslint-plugin-mocha": "~10.5.0",
+    "eslint-plugin-mocha": "~11.1.0",
     "husky": "~9.1.7",
-    "mocha": "~11.1.0",
+    "mocha": "~11.5.0",
     "prettier": "~3.5.3",
     "rimraf": "~6.0.1",
-    "tsx": "~4.19.3",
+    "tsx": "~4.19.4",
     "typescript": "~5.8.3",
-    "typescript-eslint": "~8.31.0"
+    "typescript-eslint": "~8.33.0"
   }
 }

package/src/controller-registry.spec.ts

@@ -1,32 +1,38 @@
 /* eslint mocha/no-sibling-hooks: 0 */
+import {
+  createRequestMock,
+  createResponseMock,
+  HookName,
+  HttpMethod,
+  ParsedCookie,
+  ParsedHeaders,
+  ParsedParams,
+  ParsedQuery,
+  RequestContext,
+  RequestParser,
+  RouteRegistry,
+  TrieRouter,
+} from '@e22m4u/js-trie-router';
+import {
+  afterAction,
+  beforeAction,
+  getAction,
+  postAction,
+  requestBody,
+  requestCookie,
+  requestCookies,
+  requestField,
+  requestHeader,
+  requestHeaders,
+  requestParam,
+  requestParams,
+  requestQueries,
+  requestQuery,
+  restController,
+} from './decorators/index.js';
+
 import {expect} from 'chai';
-import {HookName} from '@e22m4u/js-trie-router';
-import {getAction} from './decorators/index.js';
-import {postAction} from './decorators/index.js';
-import {TrieRouter} from '@e22m4u/js-trie-router';
-import {HttpMethod} from '@e22m4u/js-trie-router';
-import {requestBody} from './decorators/index.js';
-import {afterAction} from './decorators/index.js';
-import {requestQuery} from './decorators/index.js';
-import {requestParam} from './decorators/index.js';
-import {requestField} from './decorators/index.js';
-import {beforeAction} from './decorators/index.js';
-import {ParsedQuery} from '@e22m4u/js-trie-router';
-import {ParsedCookie} from '@e22m4u/js-trie-router';
-import {ParsedParams} from '@e22m4u/js-trie-router';
-import {requestCookie} from './decorators/index.js';
-import {requestParams} from './decorators/index.js';
-import {requestHeader} from './decorators/index.js';
-import {requestCookies} from './decorators/index.js';
-import {requestQueries} from './decorators/index.js';
-import {requestHeaders} from './decorators/index.js';
-import {restController} from './decorators/index.js';
-import {ParsedHeaders} from '@e22m4u/js-trie-router';
-import {RouteRegistry} from '@e22m4u/js-trie-router';
-import {RequestParser} from '@e22m4u/js-trie-router';
-import {RequestContext} from '@e22m4u/js-trie-router';
-import {createRequestMock} from '@e22m4u/js-trie-router';
-import {createResponseMock} from '@e22m4u/js-trie-router';
+import {DataType} from '@e22m4u/ts-data-schema';
 import {ControllerRegistry} from './controller-registry.js';
 
 const PRE_HANDLER_1 = () => undefined;
@@ -911,4 +917,56 @@ describe('ControllerRegistry', function () {
       expect(S.hasController(MyController)).to.be.true;
     });
   });
+
+  describe('createRouteHandler', function () {
+    it('uses default values from schema as copy', async function () {
+      let invoked = false;
+      const defaultValue = {foo: 'bar'};
+      class MyController {
+        myAction(
+          @requestBody({
+            type: DataType.OBJECT,
+            default: defaultValue,
+          })
+          body: object,
+        ) {
+          expect(body).to.be.not.eq(defaultValue);
+          expect(body).to.be.eql(defaultValue);
+          invoked = true;
+        }
+      }
+      const S = new ControllerRegistry();
+      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.true;
+    });
+
+    it('uses default values from factory function that defined in schema as copy', async function () {
+      let invoked = false;
+      const defaultValue = {foo: 'bar'};
+      class MyController {
+        myAction(
+          @requestBody({
+            type: DataType.OBJECT,
+            default: () => defaultValue,
+          })
+          body: object,
+        ) {
+          expect(body).to.be.not.eq(defaultValue);
+          expect(body).to.be.eql(defaultValue);
+          invoked = true;
+        }
+      }
+      const S = new ControllerRegistry();
+      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.true;
+    });
+  });
 });

package/src/controller-registry.ts

@@ -14,6 +14,7 @@ import {DebuggableService} from './debuggable-service.js';
 import {RestActionReflector} from './decorators/index.js';
 import {RequestDataReflector} from './decorators/index.js';
 import {AfterActionReflector} from './decorators/index.js';
+import {DefaultValuesApplier} from '@e22m4u/ts-data-schema';
 import {BeforeActionReflector} from './decorators/index.js';
 import {RestControllerReflector} from './decorators/index.js';
 import {RequestContextReflector} from './decorators/index.js';
@@ -381,6 +382,7 @@ export class ControllerRegistry extends DebuggableService {
       actionName,
     );
     const argsNumber = controllerCtor.prototype[actionName].length;
+    const defaultsApplier = this.getService(DefaultValuesApplier);
     const dataTypeCaster = this.getService(DataTypeCaster);
     const dataValidator = this.getService(DataValidator);
     return (requestContext: RequestContext) => {
@@ -445,20 +447,27 @@ export class ControllerRegistry extends DebuggableService {
                 break;
             }
             debug('Request data source is %v.', requestDataMd.source);
-            // при наличии схемы данных выполняется
-            // их конвертация и валидация
+            // при наличии схемы данных применяются значения
+            // по умолчанию, выполняется конвертация входящего
+            // значения и валидация согласно схеме
             if (requestDataMd.schema) {
+              data = defaultsApplier.applyDefaultValuesIfNeeded(
+                data,
+                requestDataMd.schema,
+                requestDataMd.source,
+              );
+              debug('Default values applied.');
               data = dataTypeCaster.cast(data, requestDataMd.schema, {
                 noTypeCastError: true,
                 sourcePath: requestDataMd.source,
               });
-              debug('Data type casting is passed.');
+              debug('Data type casting applied.');
               dataValidator.validate(
                 data,
                 requestDataMd.schema,
                 requestDataMd.source,
               );
-              debug('Data validation is passed.');
+              debug('Data validation passed.');
             }
             // если свойство данных не определено,
             // то используем весь объекта данных

package/src/debuggable-service.spec.ts

@@ -1,5 +1,4 @@
 import {expect} from 'chai';
-import {describe} from 'mocha';
 import {Service} from '@e22m4u/js-service';
 import {DebuggableService} from './debuggable-service.js';
 

package/src/decorators/after-action/after-action-reflector.spec.ts

@@ -1,5 +1,4 @@
 import {expect} from 'chai';
-import {describe} from 'mocha';
 import {Reflector} from '@e22m4u/ts-reflector';
 import {AfterActionReflector} from './after-action-reflector.js';
 import {AFTER_ACTION_METADATA_KEY} from './after-action-metadata.js';

package/src/decorators/before-action/before-action-reflector.spec.ts

@@ -1,5 +1,4 @@
 import {expect} from 'chai';
-import {describe} from 'mocha';
 import {Reflector} from '@e22m4u/ts-reflector';
 import {BeforeActionReflector} from './before-action-reflector.js';
 import {BEFORE_ACTION_METADATA_KEY} from './before-action-metadata.js';

package/src/decorators/index.ts

@@ -2,5 +2,6 @@ export * from './rest-action/index.js';
 export * from './request-data/index.js';
 export * from './after-action/index.js';
 export * from './before-action/index.js';
+export * from './response-body/index.js';
 export * from './rest-controller/index.js';
 export * from './request-context/index.js';

package/src/decorators/request-context/request-context-reflector.spec.ts

@@ -1,5 +1,4 @@
 import {expect} from 'chai';
-import {describe} from 'mocha';
 import {Reflector} from '@e22m4u/ts-reflector';
 import {RequestContextMetadata} from './request-context-metadata.js';
 import {RequestContextReflector} from './request-context-reflector.js';

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

@@ -20,16 +20,8 @@ export type RequestDataOptions = RequestDataMetadata;
  * @param options
  */
 export function requestData<T extends object>(options: RequestDataOptions) {
-  return function (
-    target: Prototype<T>,
-    propertyKey: string,
-    indexOrDescriptor: number,
-  ) {
-    const decoratorType = getDecoratorTargetType(
-      target,
-      propertyKey,
-      indexOrDescriptor,
-    );
+  return function (target: Prototype<T>, propertyKey: string, index: number) {
+    const decoratorType = getDecoratorTargetType(target, propertyKey, index);
     if (decoratorType !== DecoratorTargetType.INSTANCE_METHOD_PARAMETER)
       throw new Error(
         '@requestData decorator is only supported ' +
@@ -38,7 +30,7 @@ export function requestData<T extends object>(options: RequestDataOptions) {
     RequestDataReflector.setMetadata(
       options,
       target.constructor as Constructor<T>,
-      indexOrDescriptor,
+      index,
       propertyKey,
     );
   };

package/src/decorators/request-data/request-data-reflector.spec.ts

@@ -1,5 +1,4 @@
 import {expect} from 'chai';
-import {describe} from 'mocha';
 import {Reflector} from '@e22m4u/ts-reflector';
 import {RequestDataSource} from './request-data-metadata.js';
 import {RequestDataMetadata} from './request-data-metadata.js';

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

@@ -0,0 +1,3 @@
+export * from './response-body-metadata.js';
+export * from './response-body-decorator.js';
+export * from './response-body-reflector.js';

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

@@ -0,0 +1,40 @@
+import {expect} from 'chai';
+import {DataType} from '@e22m4u/ts-data-schema';
+import {responseBody} from './response-body-decorator.js';
+import {ResponseBodyReflector} from './response-body-reflector.js';
+
+describe('responseBody', function () {
+  it('does not require arguments', function () {
+    class Target {
+      @responseBody()
+      myMethod() {}
+    }
+    const res = ResponseBodyReflector.getMetadata(Target);
+    expect(res.get('myMethod')).to.be.eql({});
+  });
+
+  it('sets the given DataType to the target metadata', function () {
+    class Target {
+      @responseBody(DataType.STRING)
+      myMethod() {}
+    }
+    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 () {
+    const schema = {
+      type: DataType.OBJECT,
+      properties: {
+        foo: {type: DataType.STRING},
+        bar: {type: DataType.NUMBER},
+      },
+    };
+    class Target {
+      @responseBody(schema)
+      myMethod() {}
+    }
+    const res = ResponseBodyReflector.getMetadata(Target);
+    expect(res.get('myMethod')).to.be.eql({schema});
+  });
+});

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

@@ -0,0 +1,43 @@
+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 {getDecoratorTargetType} from '@e22m4u/ts-reflector';
+import {ResponseBodyReflector} from './response-body-reflector.js';
+
+/**
+ * Response body decorator.
+ *
+ * @param schemaOrType
+ */
+export function responseBody<T extends object>(
+  schemaOrType?: DataSchema | DataType,
+) {
+  return function (
+    target: Prototype<T>,
+    propertyKey: string,
+    descriptor: PropertyDescriptor,
+  ) {
+    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: DataSchema | undefined;
+    if (typeof schemaOrType === 'object') {
+      schema = schemaOrType;
+    } else if (typeof schemaOrType === 'string') {
+      schema = {type: schemaOrType};
+    }
+    ResponseBodyReflector.setMetadata(
+      schema ? {schema} : {},
+      target.constructor as Constructor<T>,
+      propertyKey,
+    );
+  };
+}