@e22m4u/ts-rest-router 0.0.6 → 0.1.0

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

@@ -0,0 +1,102 @@
+import { expect } from 'chai';
+import { describe } from 'mocha';
+import { Reflector } from '@e22m4u/ts-reflector';
+import { BeforeReflector } from './before-reflector.js';
+import { BEFORE_METADATA_KEY } from './before-metadata.js';
+const MIDDLEWARE_1 = () => undefined;
+const MIDDLEWARE_2 = () => undefined;
+const MIDDLEWARE_3 = () => undefined;
+describe('BeforeReflector', function () {
+    describe('class target', function () {
+        describe('addMetadata', function () {
+            it('adds a given value to the target metadata', function () {
+                class Target {
+                }
+                const md1 = { middleware: MIDDLEWARE_1 };
+                const md2 = { middleware: [MIDDLEWARE_2, MIDDLEWARE_3] };
+                BeforeReflector.addMetadata(md1, Target);
+                BeforeReflector.addMetadata(md2, Target);
+                const res = Reflector.getOwnMetadata(BEFORE_METADATA_KEY, Target);
+                expect(res).to.be.eql([md2, md1]);
+            });
+        });
+        describe('getMetadata', function () {
+            it('returns an empty array if no metadata', function () {
+                class Target {
+                }
+                const res = BeforeReflector.getMetadata(Target);
+                expect(res).to.be.eql([]);
+            });
+            it('returns existing metadata by the target', function () {
+                class Target {
+                }
+                const md1 = { middleware: MIDDLEWARE_1 };
+                const md2 = { middleware: [MIDDLEWARE_2, MIDDLEWARE_3] };
+                const mdArray = [md1, md2];
+                Reflector.defineMetadata(BEFORE_METADATA_KEY, mdArray, Target);
+                const res = BeforeReflector.getMetadata(Target);
+                expect(res).to.be.eql(mdArray);
+            });
+        });
+    });
+    describe('method target', function () {
+        describe('addMetadata', function () {
+            it('adds a given value to the target metadata', function () {
+                class Target {
+                }
+                const md1 = { middleware: MIDDLEWARE_1 };
+                const md2 = { middleware: [MIDDLEWARE_2, MIDDLEWARE_3] };
+                BeforeReflector.addMetadata(md1, Target, 'prop');
+                BeforeReflector.addMetadata(md2, Target, 'prop');
+                const res = Reflector.getOwnMetadata(BEFORE_METADATA_KEY, Target, 'prop');
+                expect(res).to.be.eql([md2, md1]);
+            });
+        });
+        describe('getMetadata', function () {
+            it('returns an empty array if no metadata', function () {
+                class Target {
+                }
+                const res = BeforeReflector.getMetadata(Target, 'prop');
+                expect(res).to.be.eql([]);
+            });
+            it('returns existing metadata by the target', function () {
+                class Target {
+                }
+                const md1 = { middleware: MIDDLEWARE_1 };
+                const md2 = { middleware: [MIDDLEWARE_2, MIDDLEWARE_3] };
+                const mdArray = [md1, md2];
+                Reflector.defineMetadata(BEFORE_METADATA_KEY, mdArray, Target, 'prop');
+                const res = BeforeReflector.getMetadata(Target, 'prop');
+                expect(res).to.be.eql(mdArray);
+            });
+        });
+    });
+    describe('addMetadata', function () {
+        it('can distinguish class and method metadata', function () {
+            class Target {
+            }
+            const md1 = { middleware: MIDDLEWARE_1 };
+            const md2 = { middleware: MIDDLEWARE_2 };
+            BeforeReflector.addMetadata(md1, Target);
+            BeforeReflector.addMetadata(md2, Target, 'prop');
+            const res1 = Reflector.getOwnMetadata(BEFORE_METADATA_KEY, Target);
+            const res2 = Reflector.getOwnMetadata(BEFORE_METADATA_KEY, Target, 'prop');
+            expect(res1).to.be.eql([md1]);
+            expect(res2).to.be.eql([md2]);
+        });
+    });
+    describe('getMetadata', function () {
+        it('can distinguish class and method metadata', function () {
+            class Target {
+            }
+            const md1 = { middleware: MIDDLEWARE_1 };
+            const md2 = { middleware: MIDDLEWARE_2 };
+            Reflector.defineMetadata(BEFORE_METADATA_KEY, [md1], Target);
+            Reflector.defineMetadata(BEFORE_METADATA_KEY, [md2], Target, 'prop');
+            const res1 = BeforeReflector.getMetadata(Target);
+            const res2 = BeforeReflector.getMetadata(Target, 'prop');
+            expect(res1).to.be.eql([md1]);
+            expect(res2).to.be.eql([md2]);
+        });
+    });
+});

package/dist/esm/decorators/before/index.d.ts

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

package/dist/esm/decorators/before/index.js

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

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

@@ -8,6 +8,7 @@ export type ControllerOptions = Flatten<Omit<ControllerMetadata, 'className'>>;
 /**
  * Controller decorator.
  *
+ * @param pathOrOptions
  * @param options
  */
-export declare function controller<T extends object>(options?: ControllerOptions): (target: Constructor<T>) => void;
+export declare function controller<T extends object>(pathOrOptions?: string | ControllerOptions, options?: ControllerOptions): (target: Constructor<T>) => void;

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

@@ -4,17 +4,38 @@ import { ControllerReflector } from './controller-reflector.js';
 /**
  * Controller decorator.
  *
+ * @param pathOrOptions
  * @param options
  */
-export function controller(options) {
+export function controller(pathOrOptions, options) {
     return function (target) {
         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);
+        // если первый аргумент является строкой,
+        // то значение используется в качестве
+        // базового пути контроллера
+        if (typeof pathOrOptions === 'string') {
+            // если второй аргумент не определен,
+            // то создается новый объект опций,
+            // который включает базовый путь
+            if (!options) {
+                options = { path: pathOrOptions };
+            }
+            // если второй аргумент определен,
+            // то базовый путь из первого аргумента
+            // передается в объект опций декоратора
+            else {
+                options.path = pathOrOptions;
+            }
+        }
+        // если первый аргумент является объектом,
+        // то его значение используется в качестве
+        // объекта опций декоратора, а второй
+        // аргумент игнорируется
+        else if (typeof pathOrOptions === 'object') {
+            options = pathOrOptions;
+        }
+        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 () {
@@ -50,4 +44,32 @@ describe('controller', function () {
         const res = ControllerReflector.getMetadata(Target);
         expect(res).to.be.eql({ className: 'Target' });
     });
+    it('allows to pass the path option to the first parameter', function () {
+        let Target = class Target {
+        };
+        Target = __decorate([
+            controller('myPath')
+        ], Target);
+        const res = ControllerReflector.getMetadata(Target);
+        expect(res).to.be.eql({ className: 'Target', path: 'myPath' });
+    });
+    it('merges two given arguments in the target metadata', function () {
+        const before = () => undefined;
+        let Target = class Target {
+        };
+        Target = __decorate([
+            controller('myPath', { before })
+        ], Target);
+        const res = ControllerReflector.getMetadata(Target);
+        expect(res).to.be.eql({ className: 'Target', path: 'myPath', before });
+    });
+    it('overrides the path option by the first argument', function () {
+        let Target = class Target {
+        };
+        Target = __decorate([
+            controller('myPath1', { path: 'myPath2' })
+        ], Target);
+        const res = ControllerReflector.getMetadata(Target);
+        expect(res).to.be.eql({ className: 'Target', path: 'myPath1' });
+    });
 });

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/index.d.ts

@@ -1,3 +1,5 @@
+export * from './after/index.js';
+export * from './before/index.js';
 export * from './action/index.js';
 export * from './controller/index.js';
 export * from './request-data/index.js';

package/dist/esm/decorators/index.js

@@ -1,3 +1,5 @@
+export * from './after/index.js';
+export * from './before/index.js';
 export * from './action/index.js';
 export * from './controller/index.js';
 export * from './request-data/index.js';

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.
  */
@@ -19,7 +23,7 @@ export declare const headers: () => (target: Prototype<object>, propertyKey: str
 export declare const header: (propertyKey: string, schemaOrType?: DataSchema | DataType) => (target: Prototype<object>, propertyKey: string, indexOrDescriptor: number) => void;
 export declare const cookies: () => (target: Prototype<object>, propertyKey: string, indexOrDescriptor: number) => void;
 export declare const cookie: (propertyKey: string, schemaOrType?: DataSchema | DataType) => (target: Prototype<object>, propertyKey: string, indexOrDescriptor: number) => void;
-export declare const bodyParam: (propertyKey: string, schemaOrType?: DataSchema | DataType) => (target: Prototype<object>, propertyKey: string, indexOrDescriptor: number) => void;
+export declare const bodyProp: (propertyKey: string, schemaOrType?: DataSchema | DataType) => (target: Prototype<object>, propertyKey: string, indexOrDescriptor: number) => void;
 /**
  * Request body decorator.
  *

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 bodyProp = createRequestDataPropertyDecoratorWithSource(RequestDataSource.BODY);
 /**
  * Request body decorator.
  *

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

@@ -22,27 +22,29 @@ import { params } from './request-data-decorator.js';
 import { queries } from './request-data-decorator.js';
 import { cookies } from './request-data-decorator.js';
 import { headers } from './request-data-decorator.js';
-import { bodyParam } from './request-data-decorator.js';
+import { bodyProp } from './request-data-decorator.js';
 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 () {
@@ -458,13 +460,13 @@ describe('requestData', function () {
                 });
             });
         });
-        describe('bodyParam', function () {
+        describe('bodyProp', function () {
             it('sets a given "propertyKey" to the target metadata', function () {
                 class Target {
                     myMethod(prop) { }
                 }
                 __decorate([
-                    __param(0, bodyParam('myPropertyKey')),
+                    __param(0, bodyProp('myPropertyKey')),
                     __metadata("design:type", Function),
                     __metadata("design:paramtypes", [Object]),
                     __metadata("design:returntype", void 0)
@@ -483,7 +485,7 @@ describe('requestData', function () {
                     myMethod(prop) { }
                 }
                 __decorate([
-                    __param(0, bodyParam(propertyKey, propertyType)),
+                    __param(0, bodyProp(propertyKey, propertyType)),
                     __metadata("design:type", Function),
                     __metadata("design:paramtypes", [Object]),
                     __metadata("design:returntype", void 0)
@@ -512,7 +514,7 @@ describe('requestData', function () {
                     myMethod(prop) { }
                 }
                 __decorate([
-                    __param(0, bodyParam(propertyKey, schema)),
+                    __param(0, bodyProp(propertyKey, schema)),
                     __metadata("design:type", Function),
                     __metadata("design:paramtypes", [Object]),
                     __metadata("design:returntype", void 0)

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/dist/esm/utils/create-debugger.d.ts

@@ -1,11 +1,44 @@
-import { format } from '@e22m4u/js-format';
 /**
  * Debugger.
  */
-export type Debugger = (...args: Parameters<typeof format>) => void;
+export type Debugger = (messageOrData: string | unknown, ...args: any[]) => void;
 /**
  * Create debugger.
  *
+ * Base usage:
+ * ```ts
+ * const debug = createDebugger('myService');
+ * debug('Service created.');
+ * // ujut:myService Service created.
+ * ```
+ *
+ * Nested namespaces:
+ * ```ts
+ * const debug1 = debug.bind('namespace1');
+ * const debug2 = debug.bind('namespace2');
+ * debug1('Application started');    // ujut:myService [namespace1] Application started
+ * debug2('Connection established'); // ujut:myService [namespace2] Connection established
+ * ```
+ *
+ * Value inspection:
+ * ```ts
+ * debug({foo: 'lorem', bar: 'ipsum'})
+ * // ujut:myService {
+ * // ujut:myService   "foo": "lorem",
+ * // ujut:myService   "bar": "ipsum"
+ * // ujut:myService }
+ * ```
+ *
+ * Titled inspection output:
+ * ```ts
+ * debug({foo: 'lorem', bar: 'ipsum'}, 'My awesome output:')
+ * // ujut:myService My awesome output:
+ * // ujut:myService {
+ * // ujut:myService   "foo": "lorem",
+ * // ujut:myService   "bar": "ipsum"
+ * // ujut:myService }
+ * ```
+ *
  * @param name
  */
 export declare function createDebugger(name: string): Debugger;