@e22m4u/ts-rest-router 0.0.5 → 0.0.7

package/dist/esm/decorators/controller/controller-decorator.js

@@ -11,10 +11,6 @@ export function controller(options) {
         const decoratorType = getDecoratorTargetType(target);
         if (decoratorType !== DecoratorTargetType.CONSTRUCTOR)
             throw new Error('@controller decorator is only supported on a class.');
-        const metadata = {
-            ...options,
-            className: target.name,
-        };
-        ControllerReflector.setMetadata(metadata, target);
+        ControllerReflector.setMetadata({ ...options, className: target.name }, target);
     };
 }

package/dist/esm/decorators/controller/controller-decorator.spec.js

@@ -8,7 +8,7 @@ import { expect } from 'chai';
 import { controller } from './controller-decorator.js';
 import { ControllerReflector } from './controller-reflector.js';
 describe('controller', function () {
-    it('does not requires options', function () {
+    it('does not require options', function () {
         let Target = class Target {
         };
         Target = __decorate([
@@ -18,27 +18,21 @@ describe('controller', function () {
         expect(res).to.be.eql({ className: 'Target' });
     });
     it('sets given options to the target metadata', function () {
-        const path = 'myPath';
-        const before = () => undefined;
-        const after = () => undefined;
-        const extraOption = 'extraOption';
+        const options = {
+            path: 'myPath',
+            before: () => undefined,
+            after: () => undefined,
+            extraOption: 'extraOption',
+        };
         let Target = class Target {
         };
         Target = __decorate([
-            controller({
-                path,
-                before,
-                after,
-                extraOption,
-            })
+            controller(options)
         ], Target);
         const res = ControllerReflector.getMetadata(Target);
         expect(res).to.be.eql({
+            ...options,
             className: 'Target',
-            path,
-            before,
-            after,
-            extraOption,
         });
     });
     it('overrides given "className" option by the target class name', function () {

package/dist/esm/decorators/controller/controller-metadata.d.ts

@@ -9,7 +9,6 @@ export type ControllerMetadata = {
     path?: string;
     before?: RoutePreHandler | RoutePreHandler[];
     after?: RoutePostHandler | RoutePostHandler[];
-    [option: string]: unknown | undefined;
 };
 /**
  * Controller metadata key.

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

@@ -1,12 +1,11 @@
 import { Prototype } from '../../types.js';
 import { RequestContext } from '@e22m4u/js-trie-router';
-import { RequestContextMetadata } from './request-context-metadata.js';
 /**
  * Request context decorator.
  *
- * @param propertyOrMetadata
+ * @param propertyName
  */
-export declare function requestContext<T extends object>(propertyOrMetadata?: keyof RequestContext | RequestContextMetadata): (target: Prototype<T>, propertyKey: string, indexOrDescriptor: number) => void;
+export declare function requestContext<T extends object>(propertyName?: keyof RequestContext): (target: Prototype<T>, propertyKey: string, indexOrDescriptor: number) => void;
 /**
  * Request decorator.
  */

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

@@ -4,18 +4,15 @@ import { RequestContextReflector } from './request-context-reflector.js';
 /**
  * Request context decorator.
  *
- * @param propertyOrMetadata
+ * @param propertyName
  */
-export function requestContext(propertyOrMetadata) {
+export function requestContext(propertyName) {
     return function (target, propertyKey, indexOrDescriptor) {
         const decoratorType = getDecoratorTargetType(target, propertyKey, indexOrDescriptor);
         if (decoratorType !== DecoratorTargetType.INSTANCE_METHOD_PARAMETER)
             throw new Error('@requestContext decorator is only supported ' +
                 'on an instance method parameter.');
-        const metadata = typeof propertyOrMetadata !== 'object'
-            ? { property: propertyOrMetadata }
-            : propertyOrMetadata;
-        RequestContextReflector.setMetadata(metadata, target.constructor, indexOrDescriptor, propertyKey);
+        RequestContextReflector.setMetadata({ property: propertyName }, target.constructor, indexOrDescriptor, propertyKey);
     };
 }
 /**

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

@@ -15,7 +15,7 @@ import { expect } from 'chai';
 import { requestContext } from './request-context-decorator.js';
 import { RequestContextReflector } from './request-context-reflector.js';
 describe('requestContext', function () {
-    it('does not requires options', function () {
+    it('does not require options', function () {
         class Target {
             method(prop) { }
         }
@@ -28,7 +28,7 @@ describe('requestContext', function () {
         const res = RequestContextReflector.getMetadata(Target, 'method');
         expect(res.get(0)).to.be.eql({ property: undefined });
     });
-    it('sets a given key of RequestContext as "propertyKey" of the target metadata', function () {
+    it('sets a given property to the target metadata', function () {
         class Target {
             method(prop) { }
         }
@@ -41,19 +41,4 @@ describe('requestContext', function () {
         const res = RequestContextReflector.getMetadata(Target, 'method');
         expect(res.get(0)).to.be.eql({ property: 'res' });
     });
-    it('sets a given RequestContextMetadata as the target metadata', function () {
-        const property = 'res';
-        const customOption = 'customOption';
-        class Target {
-            method(prop) { }
-        }
-        __decorate([
-            __param(0, requestContext({ property, customOption })),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", [Object]),
-            __metadata("design:returntype", void 0)
-        ], Target.prototype, "method", null);
-        const res = RequestContextReflector.getMetadata(Target, 'method');
-        expect(res.get(0)).to.be.eql({ property, customOption });
-    });
 });

package/dist/esm/decorators/request-context/request-context-metadata.d.ts

@@ -5,7 +5,6 @@ import { RequestContext } from '@e22m4u/js-trie-router';
  */
 export type RequestContextMetadata = {
     property?: keyof RequestContext;
-    [option: string]: unknown | undefined;
 };
 /**
  * Request context metadata map.

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

@@ -2,12 +2,16 @@ import { Prototype } from '../../types.js';
 import { DataType } from '@e22m4u/ts-data-schema';
 import { DataSchema } from '@e22m4u/ts-data-schema';
 import { RequestDataMetadata } from './request-data-metadata.js';
+/**
+ * Request data options.
+ */
+export type RequestDataOptions = RequestDataMetadata;
 /**
  * Request data decorator.
  *
- * @param metadata
+ * @param options
  */
-export declare function requestData<T extends object>(metadata: RequestDataMetadata): (target: Prototype<T>, propertyKey: string, indexOrDescriptor: number) => void;
+export declare function requestData<T extends object>(options: RequestDataOptions): (target: Prototype<T>, propertyKey: string, indexOrDescriptor: number) => void;
 /**
  * Decorator aliases.
  */

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

@@ -6,34 +6,34 @@ import { RequestDataReflector } from './request-data-reflector.js';
 /**
  * Request data decorator.
  *
- * @param metadata
+ * @param options
  */
-export function requestData(metadata) {
+export function requestData(options) {
     return function (target, propertyKey, indexOrDescriptor) {
         const decoratorType = getDecoratorTargetType(target, propertyKey, indexOrDescriptor);
         if (decoratorType !== DecoratorTargetType.INSTANCE_METHOD_PARAMETER)
             throw new Error('@requestData decorator is only supported ' +
                 'on an instance method parameter.');
-        RequestDataReflector.setMetadata(metadata, target.constructor, indexOrDescriptor, propertyKey);
+        RequestDataReflector.setMetadata(options, target.constructor, indexOrDescriptor, propertyKey);
     };
 }
 /**
- * Create data decorator.
+ * Create request data decorator with source.
  *
  * @param source
  */
-function createDataDecorator(source) {
+function createRequestDataDecoratorWithSource(source) {
     return function () {
         const schema = { type: DataType.OBJECT };
         return requestData({ schema, source });
     };
 }
 /**
- * Create property decorator.
+ * Create request data property decorator with source.
  *
  * @param source
  */
-function createPropertyDecorator(source) {
+function createRequestDataPropertyDecoratorWithSource(source) {
     return function (propertyKey, schemaOrType) {
         const properties = {};
         const rootSchema = { type: DataType.OBJECT };
@@ -55,15 +55,15 @@ function createPropertyDecorator(source) {
 /**
  * Decorator aliases.
  */
-export const params = createDataDecorator(RequestDataSource.PARAMS);
-export const param = createPropertyDecorator(RequestDataSource.PARAMS);
-export const queries = createDataDecorator(RequestDataSource.QUERY);
-export const query = createPropertyDecorator(RequestDataSource.QUERY);
-export const headers = createDataDecorator(RequestDataSource.HEADERS);
-export const header = createPropertyDecorator(RequestDataSource.HEADERS);
-export const cookies = createDataDecorator(RequestDataSource.COOKIE);
-export const cookie = createPropertyDecorator(RequestDataSource.COOKIE);
-export const bodyParam = createPropertyDecorator(RequestDataSource.BODY);
+export const params = createRequestDataDecoratorWithSource(RequestDataSource.PARAMS);
+export const param = createRequestDataPropertyDecoratorWithSource(RequestDataSource.PARAMS);
+export const queries = createRequestDataDecoratorWithSource(RequestDataSource.QUERY);
+export const query = createRequestDataPropertyDecoratorWithSource(RequestDataSource.QUERY);
+export const headers = createRequestDataDecoratorWithSource(RequestDataSource.HEADERS);
+export const header = createRequestDataPropertyDecoratorWithSource(RequestDataSource.HEADERS);
+export const cookies = createRequestDataDecoratorWithSource(RequestDataSource.COOKIE);
+export const cookie = createRequestDataPropertyDecoratorWithSource(RequestDataSource.COOKIE);
+export const bodyParam = createRequestDataPropertyDecoratorWithSource(RequestDataSource.BODY);
 /**
  * Request body decorator.
  *

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

@@ -27,22 +27,24 @@ import { requestData } from './request-data-decorator.js';
 import { RequestDataSource } from './request-data-metadata.js';
 import { RequestDataReflector } from './request-data-reflector.js';
 describe('requestData', function () {
-    it('sets a given argument to the target metadata', function () {
-        const md = {
-            source: RequestDataSource.PARAMS,
+    it('sets given options to the target metadata', function () {
+        const options = {
+            source: RequestDataSource.BODY,
+            schema: { type: DataType.STRING },
+            property: 'prop',
             customOption: 'myOption',
         };
         class Target {
             myMethod(prop) { }
         }
         __decorate([
-            __param(0, requestData(md)),
+            __param(0, requestData(options)),
             __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(md);
+        expect(res.get(0)).to.be.eql(options);
     });
     describe('request data by a given source', function () {
         describe('params', function () {

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

@@ -17,7 +17,6 @@ export type RequestDataMetadata = {
     source: RequestDataSource;
     schema?: DataSchema;
     property?: string;
-    [option: string]: unknown | undefined;
 };
 /**
  * Request data metadata map.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e22m4u/ts-rest-router",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Controllers-based REST router implementation for TypeScript",
   "author": "e22m4u <e22m4u@yandex.ru>",
   "keywords": [
@@ -31,6 +31,7 @@
     "build:esm": "tsc --build",
     "build:cjs": "rimraf ./dist/cjs && node --no-warnings=ExperimentalWarning build-cjs.js",
     "build": "rimraf dist && npm run build:esm && npm run build:cjs",
+    "postbuild": "rimraf ./dist/**/*.spec.* --glob ./dist/tsconfig.tsbuildinfo",
     "lint": "eslint ./src",
     "lint:fix": "eslint ./src --fix",
     "format": "prettier --write \"./src/**/*.ts\"",
@@ -39,37 +40,37 @@
     "prepare": "husky"
   },
   "dependencies": {
-    "@e22m4u/js-format": "0.1.x",
-    "@e22m4u/js-service": "0.1.x",
-    "@e22m4u/js-trie-router": "0.0.x",
-    "@e22m4u/ts-data-schema": "0.0.x",
-    "@e22m4u/ts-reflector": "0.1.x",
-    "debug": "~4.3.7",
+    "@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-reflector": "~0.1.0",
+    "debug": "~4.4.0",
     "http-errors": "~2.0.0"
   },
   "devDependencies": {
-    "@commitlint/cli": "~19.6.0",
+    "@commitlint/cli": "~19.6.1",
     "@commitlint/config-conventional": "~19.6.0",
-    "@eslint/js": "~9.15.0",
+    "@eslint/js": "~9.17.0",
     "@types/chai": "~5.0.1",
     "@types/debug": "~4.1.12",
     "@types/http-errors": "~2.0.4",
     "@types/mocha": "~10.0.10",
-    "@types/node": "~22.9.3",
-    "c8": "~10.1.2",
+    "@types/node": "~22.10.2",
+    "c8": "~10.1.3",
     "chai": "~5.1.2",
-    "esbuild": "~0.24.0",
-    "eslint": "~9.15.0",
+    "esbuild": "~0.24.2",
+    "eslint": "~9.17.0",
     "eslint-config-prettier": "~9.1.0",
     "eslint-plugin-chai-expect": "~3.1.0",
     "eslint-plugin-mocha": "~10.5.0",
     "husky": "~9.1.7",
-    "mocha": "~10.8.2",
-    "prettier": "~3.3.3",
+    "mocha": "~11.0.1",
+    "prettier": "~3.4.2",
     "rimraf": "~6.0.1",
     "tsx": "~4.19.2",
-    "typescript": "~5.6.3",
-    "typescript-eslint": "~8.15.0"
+    "typescript": "~5.7.2",
+    "typescript-eslint": "~8.18.2"
   },
   "license": "MIT"
 }

package/src/decorators/action/action-decorator.spec.ts

@@ -5,38 +5,38 @@ import {ActionReflector} from './action-reflector.js';
 
 describe('action', function () {
   it('sets given options to the target metadata', function () {
-    const method = HttpMethod.GET;
-    const path = 'myPath';
-    const before = () => undefined;
-    const after = () => undefined;
-    const customOption = 'customOption';
+    const options = {
+      method: HttpMethod.GET,
+      path: 'myPath',
+      before: () => undefined,
+      after: () => undefined,
+      customOption: 'customOption',
+    };
     class Target {
-      @action({method, path, before, after, customOption})
+      @action(options)
       method() {}
     }
     const res = ActionReflector.getMetadata(Target);
     expect(res.get('method')).to.be.eql({
+      ...options,
       propertyKey: 'method',
-      method,
-      path,
-      before,
-      after,
-      customOption,
     });
   });
 
   it('overrides a given "propertyKey" option by the target method name', function () {
-    const method = HttpMethod.GET;
-    const path = 'myPath';
+    const options = {
+      propertyKey: 'myMethod',
+      method: HttpMethod.GET,
+      path: 'myPath',
+    };
     class Target {
-      @action({propertyKey: 'myMethod', method, path})
+      @action(options)
       method() {}
     }
     const res = ActionReflector.getMetadata(Target);
     expect(res.get('method')).to.be.eql({
+      ...options,
       propertyKey: 'method',
-      method,
-      path,
     });
   });
 });

package/src/decorators/action/action-decorator.ts

@@ -32,12 +32,8 @@ export function action<T extends object>(options: ActionOptions) {
       throw new Error(
         '@action decorator is only supported on an instance method.',
       );
-    const metadata = {
-      ...options,
-      propertyKey,
-    } as ActionMetadata;
     ActionReflector.setMetadata(
-      metadata,
+      {...options, propertyKey},
       target.constructor as Constructor<T>,
       propertyKey,
     );
@@ -45,9 +41,11 @@ export function action<T extends object>(options: ActionOptions) {
 }
 
 /**
- * Action alias options.
+ * Action method options.
  */
-type ActionAliasOptions = Flatten<Omit<ActionOptions, 'method' | 'path'>>;
+export type ActionMethodOptions = Flatten<
+  Omit<ActionOptions, 'method' | 'path'>
+>;
 
 /**
  * Get decorator.
@@ -55,7 +53,7 @@ type ActionAliasOptions = Flatten<Omit<ActionOptions, 'method' | 'path'>>;
  * @param path
  * @param options
  */
-export const get = (path: string, options?: ActionAliasOptions) => {
+export const get = (path: string, options?: ActionMethodOptions) => {
   return action({...options, path, method: HttpMethod.GET});
 };
 
@@ -65,7 +63,7 @@ export const get = (path: string, options?: ActionAliasOptions) => {
  * @param path
  * @param options
  */
-export const post = (path: string, options?: ActionAliasOptions) => {
+export const post = (path: string, options?: ActionMethodOptions) => {
   return action({...options, path, method: HttpMethod.POST});
 };
 
@@ -75,7 +73,7 @@ export const post = (path: string, options?: ActionAliasOptions) => {
  * @param path
  * @param options
  */
-export const put = (path: string, options?: ActionAliasOptions) => {
+export const put = (path: string, options?: ActionMethodOptions) => {
   return action({...options, path, method: HttpMethod.PUT});
 };
 
@@ -85,7 +83,7 @@ export const put = (path: string, options?: ActionAliasOptions) => {
  * @param path
  * @param options
  */
-export const patch = (path: string, options?: ActionAliasOptions) => {
+export const patch = (path: string, options?: ActionMethodOptions) => {
   return action({...options, path, method: HttpMethod.PATCH});
 };
 
@@ -95,6 +93,6 @@ export const patch = (path: string, options?: ActionAliasOptions) => {
  * @param path
  * @param options
  */
-export const del = (path: string, options?: ActionAliasOptions) => {
+export const del = (path: string, options?: ActionMethodOptions) => {
   return action({...options, path, method: HttpMethod.DELETE});
 };

package/src/decorators/action/action-metadata.ts

@@ -12,7 +12,6 @@ export type ActionMetadata = {
   path: string;
   before?: RoutePreHandler | RoutePreHandler[];
   after?: RoutePostHandler | RoutePostHandler[];
-  [option: string]: unknown | undefined;
 };
 
 /**

package/src/decorators/controller/controller-decorator.spec.ts

@@ -1,9 +1,10 @@
 import {expect} from 'chai';
 import {controller} from './controller-decorator.js';
+import {ControllerOptions} from './controller-decorator.js';
 import {ControllerReflector} from './controller-reflector.js';
 
 describe('controller', function () {
-  it('does not requires options', function () {
+  it('does not require options', function () {
     @controller()
     class Target {}
     const res = ControllerReflector.getMetadata(Target);
@@ -11,29 +12,23 @@ describe('controller', function () {
   });
 
   it('sets given options to the target metadata', function () {
-    const path = 'myPath';
-    const before = () => undefined;
-    const after = () => undefined;
-    const extraOption = 'extraOption';
-    @controller({
-      path,
-      before,
-      after,
-      extraOption,
-    })
+    const options = {
+      path: 'myPath',
+      before: () => undefined,
+      after: () => undefined,
+      extraOption: 'extraOption',
+    };
+    @controller(options)
     class Target {}
     const res = ControllerReflector.getMetadata(Target);
     expect(res).to.be.eql({
+      ...options,
       className: 'Target',
-      path,
-      before,
-      after,
-      extraOption,
     });
   });
 
   it('overrides given "className" option by the target class name', function () {
-    @controller({className: 'myClassName'})
+    @controller({className: 'myClassName'} as ControllerOptions)
     class Target {}
     const res = ControllerReflector.getMetadata(Target);
     expect(res).to.be.eql({className: 'Target'});

package/src/decorators/controller/controller-decorator.ts

@@ -20,10 +20,9 @@ export function controller<T extends object>(options?: ControllerOptions) {
     const decoratorType = getDecoratorTargetType(target);
     if (decoratorType !== DecoratorTargetType.CONSTRUCTOR)
       throw new Error('@controller decorator is only supported on a class.');
-    const metadata = {
-      ...options,
-      className: target.name,
-    };
-    ControllerReflector.setMetadata(metadata, target);
+    ControllerReflector.setMetadata(
+      {...options, className: target.name},
+      target,
+    );
   };
 }

package/src/decorators/controller/controller-metadata.ts

@@ -10,7 +10,6 @@ export type ControllerMetadata = {
   path?: string;
   before?: RoutePreHandler | RoutePreHandler[];
   after?: RoutePostHandler | RoutePostHandler[];
-  [option: string]: unknown | undefined;
 };
 
 /**

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

@@ -4,7 +4,7 @@ import {requestContext} from './request-context-decorator.js';
 import {RequestContextReflector} from './request-context-reflector.js';
 
 describe('requestContext', function () {
-  it('does not requires options', function () {
+  it('does not require options', function () {
     class Target {
       method(
         @requestContext()
@@ -15,7 +15,7 @@ describe('requestContext', function () {
     expect(res.get(0)).to.be.eql({property: undefined});
   });
 
-  it('sets a given key of RequestContext as "propertyKey" of the target metadata', function () {
+  it('sets a given property to the target metadata', function () {
     class Target {
       method(
         @requestContext('res')
@@ -25,17 +25,4 @@ describe('requestContext', function () {
     const res = RequestContextReflector.getMetadata(Target, 'method');
     expect(res.get(0)).to.be.eql({property: 'res'});
   });
-
-  it('sets a given RequestContextMetadata as the target metadata', function () {
-    const property = 'res';
-    const customOption = 'customOption';
-    class Target {
-      method(
-        @requestContext({property, customOption})
-        prop: unknown,
-      ) {}
-    }
-    const res = RequestContextReflector.getMetadata(Target, 'method');
-    expect(res.get(0)).to.be.eql({property, customOption});
-  });
 });

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

@@ -4,15 +4,14 @@ import {RequestContext} from '@e22m4u/js-trie-router';
 import {DecoratorTargetType} from '@e22m4u/ts-reflector';
 import {getDecoratorTargetType} from '@e22m4u/ts-reflector';
 import {RequestContextReflector} from './request-context-reflector.js';
-import {RequestContextMetadata} from './request-context-metadata.js';
 
 /**
  * Request context decorator.
  *
- * @param propertyOrMetadata
+ * @param propertyName
  */
 export function requestContext<T extends object>(
-  propertyOrMetadata?: keyof RequestContext | RequestContextMetadata,
+  propertyName?: keyof RequestContext,
 ) {
   return function (
     target: Prototype<T>,
@@ -29,12 +28,8 @@ export function requestContext<T extends object>(
         '@requestContext decorator is only supported ' +
           'on an instance method parameter.',
       );
-    const metadata =
-      typeof propertyOrMetadata !== 'object'
-        ? {property: propertyOrMetadata}
-        : propertyOrMetadata;
     RequestContextReflector.setMetadata(
-      metadata,
+      {property: propertyName},
       target.constructor as Constructor<T>,
       indexOrDescriptor,
       propertyKey,

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

@@ -6,7 +6,6 @@ import {RequestContext} from '@e22m4u/js-trie-router';
  */
 export type RequestContextMetadata = {
   property?: keyof RequestContext;
-  [option: string]: unknown | undefined;
 };
 
 /**