@e22m4u/ts-rest-router 0.0.2

package/dist/esm/debuggable-service.d.ts

@@ -0,0 +1,18 @@
+import { Debugger } from './utils/index.js';
+import { Service } from '@e22m4u/js-service';
+import { ServiceContainer } from '@e22m4u/js-service';
+/**
+ * Service.
+ */
+export declare class DebuggableService extends Service {
+    /**
+     * Debug.
+     */
+    debug: Debugger;
+    /**
+     * Constructor.
+     *
+     * @param container
+     */
+    constructor(container?: ServiceContainer);
+}

package/dist/esm/debuggable-service.js

@@ -0,0 +1,23 @@
+import { Service } from '@e22m4u/js-service';
+import { toCamelCase } from './utils/index.js';
+import { createDebugger } from './utils/index.js';
+/**
+ * Service.
+ */
+export class DebuggableService extends Service {
+    /**
+     * Debug.
+     */
+    debug;
+    /**
+     * Constructor.
+     *
+     * @param container
+     */
+    constructor(container) {
+        super(container);
+        const serviceName = toCamelCase(this.constructor.name);
+        this.debug = createDebugger(serviceName);
+        this.debug('%v is created.', this.constructor);
+    }
+}

package/dist/esm/debuggable-service.spec.d.ts

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

package/dist/esm/debuggable-service.spec.js

@@ -0,0 +1,16 @@
+import { expect } from 'chai';
+import { describe } from 'mocha';
+import { Service } from '@e22m4u/js-service';
+import { DebuggableService } from './debuggable-service.js';
+describe('DebuggableService', function () {
+    it('has the debug method', function () {
+        const res = new DebuggableService();
+        expect(typeof res.debug).to.be.eq('function');
+    });
+    describe('constructor', function () {
+        it('extends the Service class', function () {
+            const res = new DebuggableService();
+            expect(res).to.be.instanceof(Service);
+        });
+    });
+});

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

@@ -0,0 +1,53 @@
+import { Flatten } from '../../types.js';
+import { Prototype } from '../../types.js';
+import { ActionMetadata } from './action-metadata.js';
+/**
+ * Action options.
+ */
+export type ActionOptions = Flatten<Omit<ActionMetadata, 'propertyKey'>>;
+/**
+ * Action decorator.
+ *
+ * @param options
+ */
+export declare function action<T extends object>(options: ActionOptions): (target: Prototype<T>, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Action alias options.
+ */
+type ActionAliasOptions = Flatten<Omit<ActionOptions, 'method' | 'path'>>;
+/**
+ * Get decorator.
+ *
+ * @param path
+ * @param options
+ */
+export declare const get: (path: string, options?: ActionAliasOptions) => (target: Prototype<object>, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Post decorator.
+ *
+ * @param path
+ * @param options
+ */
+export declare const post: (path: string, options?: ActionAliasOptions) => (target: Prototype<object>, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Put decorator.
+ *
+ * @param path
+ * @param options
+ */
+export declare const put: (path: string, options?: ActionAliasOptions) => (target: Prototype<object>, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Patch decorator.
+ *
+ * @param path
+ * @param options
+ */
+export declare const patch: (path: string, options?: ActionAliasOptions) => (target: Prototype<object>, propertyKey: string, descriptor: PropertyDescriptor) => void;
+/**
+ * Del decorator.
+ *
+ * @param path
+ * @param options
+ */
+export declare const del: (path: string, options?: ActionAliasOptions) => (target: Prototype<object>, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export {};

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

@@ -0,0 +1,66 @@
+import { HttpMethod } from '@e22m4u/js-trie-router';
+import { ActionReflector } from './action-reflector.js';
+import { DecoratorTargetType } from '@e22m4u/ts-reflector';
+import { getDecoratorTargetType } from '@e22m4u/ts-reflector';
+/**
+ * Action decorator.
+ *
+ * @param options
+ */
+export function action(options) {
+    return function (target, propertyKey, descriptor) {
+        const decoratorType = getDecoratorTargetType(target, propertyKey, descriptor);
+        if (decoratorType !== DecoratorTargetType.INSTANCE_METHOD)
+            throw new Error('@action decorator is only supported on an instance method.');
+        const metadata = {
+            ...options,
+            propertyKey,
+        };
+        ActionReflector.setMetadata(metadata, target.constructor, propertyKey);
+    };
+}
+/**
+ * Get decorator.
+ *
+ * @param path
+ * @param options
+ */
+export const get = (path, options) => {
+    return action({ ...options, path, method: HttpMethod.GET });
+};
+/**
+ * Post decorator.
+ *
+ * @param path
+ * @param options
+ */
+export const post = (path, options) => {
+    return action({ ...options, path, method: HttpMethod.POST });
+};
+/**
+ * Put decorator.
+ *
+ * @param path
+ * @param options
+ */
+export const put = (path, options) => {
+    return action({ ...options, path, method: HttpMethod.PUT });
+};
+/**
+ * Patch decorator.
+ *
+ * @param path
+ * @param options
+ */
+export const patch = (path, options) => {
+    return action({ ...options, path, method: HttpMethod.PATCH });
+};
+/**
+ * Del decorator.
+ *
+ * @param path
+ * @param options
+ */
+export const del = (path, options) => {
+    return action({ ...options, path, method: HttpMethod.DELETE });
+};

package/dist/esm/decorators/action/action-decorator.spec.d.ts

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

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

@@ -0,0 +1,59 @@
+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 { action } from './action-decorator.js';
+import { HttpMethod } from '@e22m4u/js-trie-router';
+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';
+        class Target {
+            method() { }
+        }
+        __decorate([
+            action({ method, path, before, after, customOption }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], Target.prototype, "method", null);
+        const res = ActionReflector.getMetadata(Target);
+        expect(res.get('method')).to.be.eql({
+            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';
+        class Target {
+            method() { }
+        }
+        __decorate([
+            action({ propertyKey: 'myMethod', method, path }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], Target.prototype, "method", null);
+        const res = ActionReflector.getMetadata(Target);
+        expect(res.get('method')).to.be.eql({
+            propertyKey: 'method',
+            method,
+            path,
+        });
+    });
+});

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

@@ -0,0 +1,23 @@
+import { MetadataKey } from '@e22m4u/ts-reflector';
+import { HttpMethod } from '@e22m4u/js-trie-router';
+import { RoutePreHandler } from '@e22m4u/js-trie-router';
+import { RoutePostHandler } from '@e22m4u/js-trie-router';
+/**
+ * Action metadata.
+ */
+export type ActionMetadata = {
+    propertyKey: string;
+    method: HttpMethod;
+    path: string;
+    before?: RoutePreHandler | RoutePreHandler[];
+    after?: RoutePostHandler | RoutePostHandler[];
+    [option: string]: unknown | undefined;
+};
+/**
+ * Action metadata map.
+ */
+export type ActionMetadataMap = Map<string, ActionMetadata>;
+/**
+ * Actions metadata key.
+ */
+export declare const ACTIONS_METADATA_KEY: MetadataKey<ActionMetadataMap>;

package/dist/esm/decorators/action/action-metadata.js

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

package/dist/esm/decorators/action/action-reflector.d.ts

@@ -0,0 +1,22 @@
+import { Constructor } from '../../types.js';
+import { ActionMetadata } from './action-metadata.js';
+import { ActionMetadataMap } from './action-metadata.js';
+/**
+ * Action reflector.
+ */
+export declare class ActionReflector {
+    /**
+     * Set metadata.
+     *
+     * @param metadata
+     * @param target
+     * @param propertyKey
+     */
+    static setMetadata(metadata: ActionMetadata, target: Constructor, propertyKey: string): void;
+    /**
+     * Get metadata.
+     *
+     * @param target
+     */
+    static getMetadata(target: Constructor): ActionMetadataMap;
+}

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

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

package/dist/esm/decorators/action/action-reflector.spec.d.ts

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

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

@@ -0,0 +1,84 @@
+import { expect } from 'chai';
+import { describe } from 'mocha';
+import { Reflector } from '@e22m4u/ts-reflector';
+import { HttpMethod } from '@e22m4u/js-trie-router';
+import { ActionReflector } from './action-reflector.js';
+import { ACTIONS_METADATA_KEY } from './action-metadata.js';
+describe('ActionReflector', function () {
+    describe('setMetadata', function () {
+        it('sets a given value as target metadata', function () {
+            class Target {
+            }
+            const md1 = {
+                propertyKey: 'propertyKey1',
+                method: HttpMethod.GET,
+                path: '/foo',
+            };
+            const md2 = {
+                propertyKey: 'propertyKey2',
+                method: HttpMethod.GET,
+                path: '/bar',
+            };
+            ActionReflector.setMetadata(md1, Target, 'propertyKey1');
+            ActionReflector.setMetadata(md2, Target, 'propertyKey2');
+            const res = Reflector.getOwnMetadata(ACTIONS_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 = {
+                propertyKey: 'propertyKey',
+                method: HttpMethod.GET,
+                path: '/foo',
+            };
+            const md2 = {
+                propertyKey: 'propertyKey',
+                method: HttpMethod.POST,
+                path: '/bar',
+            };
+            ActionReflector.setMetadata(md1, Target, 'propertyKey');
+            const res1 = Reflector.getOwnMetadata(ACTIONS_METADATA_KEY, Target);
+            expect(res1).to.be.instanceof(Map);
+            expect(res1.get('propertyKey')).to.be.eq(md1);
+            ActionReflector.setMetadata(md2, Target, 'propertyKey');
+            const res2 = Reflector.getOwnMetadata(ACTIONS_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 = {
+                propertyKey: 'propertyKey1',
+                method: HttpMethod.GET,
+                path: '/foo',
+            };
+            const md2 = {
+                propertyKey: 'propertyKey2',
+                method: HttpMethod.GET,
+                path: '/bar',
+            };
+            const mdMap = new Map([
+                ['propertyKey1', md1],
+                ['propertyKey2', md2],
+            ]);
+            Reflector.defineMetadata(ACTIONS_METADATA_KEY, mdMap, Target);
+            const res = ActionReflector.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 = ActionReflector.getMetadata(Target);
+            expect(res).to.be.instanceof(Map);
+            expect(res).to.be.empty;
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,13 @@
+import { Flatten } from '../../types.js';
+import { Constructor } from '../../types.js';
+import { ControllerMetadata } from './controller-metadata.js';
+/**
+ * Controller options.
+ */
+export type ControllerOptions = Flatten<Omit<ControllerMetadata, 'className'>>;
+/**
+ * Controller decorator.
+ *
+ * @param options
+ */
+export declare function controller<T extends object>(options?: ControllerOptions): (target: Constructor<T>) => void;

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

@@ -0,0 +1,20 @@
+import { DecoratorTargetType } from '@e22m4u/ts-reflector';
+import { getDecoratorTargetType } from '@e22m4u/ts-reflector';
+import { ControllerReflector } from './controller-reflector.js';
+/**
+ * Controller decorator.
+ *
+ * @param options
+ */
+export function controller(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);
+    };
+}

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

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

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

@@ -0,0 +1,53 @@
+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;
+};
+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 () {
+        let Target = class Target {
+        };
+        Target = __decorate([
+            controller()
+        ], Target);
+        const res = ControllerReflector.getMetadata(Target);
+        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';
+        let Target = class Target {
+        };
+        Target = __decorate([
+            controller({
+                path,
+                before,
+                after,
+                extraOption,
+            })
+        ], Target);
+        const res = ControllerReflector.getMetadata(Target);
+        expect(res).to.be.eql({
+            className: 'Target',
+            path,
+            before,
+            after,
+            extraOption,
+        });
+    });
+    it('overrides given "className" option by the target class name', function () {
+        let Target = class Target {
+        };
+        Target = __decorate([
+            controller({ className: 'myClassName' })
+        ], Target);
+        const res = ControllerReflector.getMetadata(Target);
+        expect(res).to.be.eql({ className: 'Target' });
+    });
+});

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

@@ -0,0 +1,17 @@
+import { RoutePreHandler } from '@e22m4u/js-trie-router';
+import { RoutePostHandler } from '@e22m4u/js-trie-router';
+import { MetadataKey } from '@e22m4u/ts-reflector';
+/**
+ * Controller metadata.
+ */
+export type ControllerMetadata = {
+    className: string;
+    path?: string;
+    before?: RoutePreHandler | RoutePreHandler[];
+    after?: RoutePostHandler | RoutePostHandler[];
+    [option: string]: unknown | undefined;
+};
+/**
+ * Controller metadata key.
+ */
+export declare const CONTROLLER_METADATA_KEY: MetadataKey<ControllerMetadata>;

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

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

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

@@ -0,0 +1,20 @@
+import { Constructor } from '../../types.js';
+import { ControllerMetadata } from './controller-metadata.js';
+/**
+ * Controller reflector.
+ */
+export declare class ControllerReflector {
+    /**
+     * Set metadata.
+     *
+     * @param metadata
+     * @param target
+     */
+    static setMetadata(metadata: ControllerMetadata, target: Constructor): void;
+    /**
+     * Get metadata.
+     *
+     * @param target
+     */
+    static getMetadata(target: Constructor): ControllerMetadata | undefined;
+}

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

@@ -0,0 +1,24 @@
+import { Reflector } from '@e22m4u/ts-reflector';
+import { CONTROLLER_METADATA_KEY } from './controller-metadata.js';
+/**
+ * Controller reflector.
+ */
+export class ControllerReflector {
+    /**
+     * Set metadata.
+     *
+     * @param metadata
+     * @param target
+     */
+    static setMetadata(metadata, target) {
+        return Reflector.defineMetadata(CONTROLLER_METADATA_KEY, metadata, target);
+    }
+    /**
+     * Get metadata.
+     *
+     * @param target
+     */
+    static getMetadata(target) {
+        return Reflector.getOwnMetadata(CONTROLLER_METADATA_KEY, target);
+    }
+}

package/dist/esm/decorators/controller/controller-reflector.spec.d.ts

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

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

@@ -0,0 +1,45 @@
+import { expect } from 'chai';
+import { describe } from 'mocha';
+import { Reflector } from '@e22m4u/ts-reflector';
+import { ControllerReflector } from './controller-reflector.js';
+import { CONTROLLER_METADATA_KEY } from './controller-metadata.js';
+describe('ControllerReflector', function () {
+    describe('setMetadata', function () {
+        it('sets a given value as target metadata', function () {
+            class Target {
+            }
+            const md = { className: 'Target' };
+            ControllerReflector.setMetadata(md, Target);
+            const res = Reflector.getOwnMetadata(CONTROLLER_METADATA_KEY, Target);
+            expect(res).to.be.eq(md);
+        });
+        it('overrides existing metadata', function () {
+            class Target {
+            }
+            const md1 = { className: 'Target', path: 'path1' };
+            const md2 = { className: 'Target', path: 'path2' };
+            ControllerReflector.setMetadata(md1, Target);
+            const res1 = Reflector.getOwnMetadata(CONTROLLER_METADATA_KEY, Target);
+            expect(res1).to.be.eq(md1);
+            ControllerReflector.setMetadata(md2, Target);
+            const res2 = Reflector.getOwnMetadata(CONTROLLER_METADATA_KEY, Target);
+            expect(res2).to.be.eq(md2);
+        });
+    });
+    describe('getMetadata', function () {
+        it('returns an existing metadata of the target', function () {
+            class Target {
+            }
+            const md = { className: 'Target' };
+            Reflector.defineMetadata(CONTROLLER_METADATA_KEY, md, Target);
+            const res = ControllerReflector.getMetadata(Target);
+            expect(res).to.be.eq(md);
+        });
+        it('returns undefined if no metadata', function () {
+            class Target {
+            }
+            const res = ControllerReflector.getMetadata(Target);
+            expect(res).to.be.undefined;
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,4 @@
+export * from './action/index.js';
+export * from './controller/index.js';
+export * from './request-data/index.js';
+export * from './request-context/index.js';

package/dist/esm/decorators/index.js

@@ -0,0 +1,4 @@
+export * from './action/index.js';
+export * from './controller/index.js';
+export * from './request-data/index.js';
+export * from './request-context/index.js';