@e22m4u/ts-rest-router 0.0.6 → 0.1.0

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

@@ -13,47 +13,47 @@ 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';
+        const options = {
+            method: HttpMethod.GET,
+            path: 'myPath',
+            before: () => undefined,
+            after: () => undefined,
+            customOption: 'customOption',
+        };
         class Target {
             method() { }
         }
         __decorate([
-            action({ method, path, before, after, customOption }),
+            action(options),
             __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({
+            ...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 {
             method() { }
         }
         __decorate([
-            action({ propertyKey: 'myMethod', method, path }),
+            action(options),
             __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({
+            ...options,
             propertyKey: 'method',
-            method,
-            path,
         });
     });
 });

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

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

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

@@ -0,0 +1,9 @@
+import { Prototype } from '../../types.js';
+import { Constructor } from '../../types.js';
+import { AfterMetadata } from './after-metadata.js';
+/**
+ * After decorator.
+ *
+ * @param options
+ */
+export declare function after<T extends object>(middleware: AfterMetadata['middleware']): (target: Constructor<T> | Prototype<T>, propertyKey?: string, descriptor?: PropertyDescriptor) => void;

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

@@ -0,0 +1,22 @@
+import { AfterReflector } from './after-reflector.js';
+import { DecoratorTargetType } from '@e22m4u/ts-reflector';
+import { getDecoratorTargetType } from '@e22m4u/ts-reflector';
+/**
+ * After decorator.
+ *
+ * @param options
+ */
+export function after(middleware) {
+    return function (target, propertyKey, descriptor) {
+        const decoratorType = getDecoratorTargetType(target, propertyKey, descriptor);
+        if (decoratorType === DecoratorTargetType.CONSTRUCTOR) {
+            AfterReflector.addMetadata({ middleware }, target);
+        }
+        else if (decoratorType === DecoratorTargetType.INSTANCE_METHOD) {
+            AfterReflector.addMetadata({ propertyKey, middleware }, target.constructor, propertyKey);
+        }
+        else {
+            throw new Error('@after decorator is only supported on a class or an instance method.');
+        }
+    };
+}

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

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

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

@@ -0,0 +1,115 @@
+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);
+};
+/* eslint mocha/no-sibling-hooks: 0 */
+import { expect } from 'chai';
+import { after } from './after-decorator.js';
+import { AfterReflector } from './after-reflector.js';
+const MIDDLEWARE_1 = () => undefined;
+const MIDDLEWARE_2 = () => undefined;
+const MIDDLEWARE_3 = () => undefined;
+describe('after', function () {
+    describe('class target', function () {
+        it('sets given middleware to the target metadata', function () {
+            let Target = class Target {
+                method() { }
+            };
+            Target = __decorate([
+                after(MIDDLEWARE_1)
+            ], Target);
+            const res = AfterReflector.getMetadata(Target);
+            expect(res).to.be.eql([{ middleware: MIDDLEWARE_1 }]);
+        });
+        it('sets miltiple middlewares to the target metadata', function () {
+            let Target = class Target {
+                method() { }
+            };
+            Target = __decorate([
+                after([MIDDLEWARE_1, MIDDLEWARE_2])
+            ], Target);
+            const res = AfterReflector.getMetadata(Target);
+            expect(res).to.be.eql([{ middleware: [MIDDLEWARE_1, MIDDLEWARE_2] }]);
+        });
+        it('allows to use the decorator multiple times', function () {
+            let Target = class Target {
+                method() { }
+            };
+            Target = __decorate([
+                after(MIDDLEWARE_1),
+                after([MIDDLEWARE_2, MIDDLEWARE_3])
+            ], Target);
+            const res = AfterReflector.getMetadata(Target);
+            expect(res).to.be.eql([
+                { middleware: MIDDLEWARE_1 },
+                { middleware: [MIDDLEWARE_2, MIDDLEWARE_3] },
+            ]);
+        });
+    });
+    describe('method target', function () {
+        it('sets given middleware to the target metadata', function () {
+            class Target {
+                method() { }
+            }
+            __decorate([
+                after(MIDDLEWARE_1),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], Target.prototype, "method", null);
+            const res = AfterReflector.getMetadata(Target, 'method');
+            expect(res).to.be.eql([
+                {
+                    propertyKey: 'method',
+                    middleware: MIDDLEWARE_1,
+                },
+            ]);
+        });
+        it('sets miltiple middlewares to the target metadata', function () {
+            class Target {
+                method() { }
+            }
+            __decorate([
+                after([MIDDLEWARE_1, MIDDLEWARE_2]),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], Target.prototype, "method", null);
+            const res = AfterReflector.getMetadata(Target, 'method');
+            expect(res).to.be.eql([
+                {
+                    propertyKey: 'method',
+                    middleware: [MIDDLEWARE_1, MIDDLEWARE_2],
+                },
+            ]);
+        });
+        it('allows to use the decorator multiple times', function () {
+            class Target {
+                method() { }
+            }
+            __decorate([
+                after(MIDDLEWARE_1),
+                after([MIDDLEWARE_2, MIDDLEWARE_3]),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], Target.prototype, "method", null);
+            const res = AfterReflector.getMetadata(Target, 'method');
+            expect(res).to.be.eql([
+                {
+                    propertyKey: 'method',
+                    middleware: MIDDLEWARE_1,
+                },
+                {
+                    propertyKey: 'method',
+                    middleware: [MIDDLEWARE_2, MIDDLEWARE_3],
+                },
+            ]);
+        });
+    });
+});

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

@@ -0,0 +1,13 @@
+import { MetadataKey } from '@e22m4u/ts-reflector';
+import { RoutePostHandler } from '@e22m4u/js-trie-router';
+/**
+ * After metadata.
+ */
+export type AfterMetadata = {
+    propertyKey?: string;
+    middleware: RoutePostHandler | RoutePostHandler[];
+};
+/**
+ * After metadata key.
+ */
+export declare const AFTER_METADATA_KEY: MetadataKey<AfterMetadata[]>;

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

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

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

@@ -0,0 +1,22 @@
+import { Constructor } from '../../types.js';
+import { AfterMetadata } from './after-metadata.js';
+/**
+ * After reflector.
+ */
+export declare class AfterReflector {
+    /**
+     * Set metadata.
+     *
+     * @param metadata
+     * @param target
+     * @param propertyKey
+     */
+    static addMetadata(metadata: AfterMetadata, target: Constructor, propertyKey?: string): void;
+    /**
+     * Get metadata.
+     *
+     * @param target
+     * @param propertyKey
+     */
+    static getMetadata(target: Constructor, propertyKey?: string): AfterMetadata[];
+}

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

@@ -0,0 +1,29 @@
+import { Reflector } from '@e22m4u/ts-reflector';
+import { AFTER_METADATA_KEY } from './after-metadata.js';
+/**
+ * After reflector.
+ */
+export class AfterReflector {
+    /**
+     * Set metadata.
+     *
+     * @param metadata
+     * @param target
+     * @param propertyKey
+     */
+    static addMetadata(metadata, target, propertyKey) {
+        const oldArray = Reflector.getOwnMetadata(AFTER_METADATA_KEY, target, propertyKey) ?? [];
+        const newArray = [metadata, ...oldArray];
+        Reflector.defineMetadata(AFTER_METADATA_KEY, newArray, target, propertyKey);
+    }
+    /**
+     * Get metadata.
+     *
+     * @param target
+     * @param propertyKey
+     */
+    static getMetadata(target, propertyKey) {
+        const metadata = Reflector.getOwnMetadata(AFTER_METADATA_KEY, target, propertyKey);
+        return metadata ?? [];
+    }
+}

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

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

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

@@ -0,0 +1,102 @@
+import { expect } from 'chai';
+import { describe } from 'mocha';
+import { Reflector } from '@e22m4u/ts-reflector';
+import { AfterReflector } from './after-reflector.js';
+import { AFTER_METADATA_KEY } from './after-metadata.js';
+const MIDDLEWARE_1 = () => undefined;
+const MIDDLEWARE_2 = () => undefined;
+const MIDDLEWARE_3 = () => undefined;
+describe('AfterReflector', 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] };
+                AfterReflector.addMetadata(md1, Target);
+                AfterReflector.addMetadata(md2, Target);
+                const res = Reflector.getOwnMetadata(AFTER_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 = AfterReflector.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(AFTER_METADATA_KEY, mdArray, Target);
+                const res = AfterReflector.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] };
+                AfterReflector.addMetadata(md1, Target, 'prop');
+                AfterReflector.addMetadata(md2, Target, 'prop');
+                const res = Reflector.getOwnMetadata(AFTER_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 = AfterReflector.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(AFTER_METADATA_KEY, mdArray, Target, 'prop');
+                const res = AfterReflector.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 };
+            AfterReflector.addMetadata(md1, Target);
+            AfterReflector.addMetadata(md2, Target, 'prop');
+            const res1 = Reflector.getOwnMetadata(AFTER_METADATA_KEY, Target);
+            const res2 = Reflector.getOwnMetadata(AFTER_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(AFTER_METADATA_KEY, [md1], Target);
+            Reflector.defineMetadata(AFTER_METADATA_KEY, [md2], Target, 'prop');
+            const res1 = AfterReflector.getMetadata(Target);
+            const res2 = AfterReflector.getMetadata(Target, 'prop');
+            expect(res1).to.be.eql([md1]);
+            expect(res2).to.be.eql([md2]);
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,9 @@
+import { Prototype } from '../../types.js';
+import { Constructor } from '../../types.js';
+import { BeforeMetadata } from './before-metadata.js';
+/**
+ * Before decorator.
+ *
+ * @param options
+ */
+export declare function before<T extends object>(middleware: BeforeMetadata['middleware']): (target: Constructor<T> | Prototype<T>, propertyKey?: string, descriptor?: PropertyDescriptor) => void;

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

@@ -0,0 +1,22 @@
+import { BeforeReflector } from './before-reflector.js';
+import { DecoratorTargetType } from '@e22m4u/ts-reflector';
+import { getDecoratorTargetType } from '@e22m4u/ts-reflector';
+/**
+ * Before decorator.
+ *
+ * @param options
+ */
+export function before(middleware) {
+    return function (target, propertyKey, descriptor) {
+        const decoratorType = getDecoratorTargetType(target, propertyKey, descriptor);
+        if (decoratorType === DecoratorTargetType.CONSTRUCTOR) {
+            BeforeReflector.addMetadata({ middleware }, target);
+        }
+        else if (decoratorType === DecoratorTargetType.INSTANCE_METHOD) {
+            BeforeReflector.addMetadata({ propertyKey, middleware }, target.constructor, propertyKey);
+        }
+        else {
+            throw new Error('@before decorator is only supported on a class or an instance method.');
+        }
+    };
+}

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

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

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

@@ -0,0 +1,115 @@
+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);
+};
+/* eslint mocha/no-sibling-hooks: 0 */
+import { expect } from 'chai';
+import { before } from './before-decorator.js';
+import { BeforeReflector } from './before-reflector.js';
+const MIDDLEWARE_1 = () => undefined;
+const MIDDLEWARE_2 = () => undefined;
+const MIDDLEWARE_3 = () => undefined;
+describe('before', function () {
+    describe('class target', function () {
+        it('sets given middleware to the target metadata', function () {
+            let Target = class Target {
+                method() { }
+            };
+            Target = __decorate([
+                before(MIDDLEWARE_1)
+            ], Target);
+            const res = BeforeReflector.getMetadata(Target);
+            expect(res).to.be.eql([{ middleware: MIDDLEWARE_1 }]);
+        });
+        it('sets miltiple middlewares to the target metadata', function () {
+            let Target = class Target {
+                method() { }
+            };
+            Target = __decorate([
+                before([MIDDLEWARE_1, MIDDLEWARE_2])
+            ], Target);
+            const res = BeforeReflector.getMetadata(Target);
+            expect(res).to.be.eql([{ middleware: [MIDDLEWARE_1, MIDDLEWARE_2] }]);
+        });
+        it('allows to use the decorator multiple times', function () {
+            let Target = class Target {
+                method() { }
+            };
+            Target = __decorate([
+                before(MIDDLEWARE_1),
+                before([MIDDLEWARE_2, MIDDLEWARE_3])
+            ], Target);
+            const res = BeforeReflector.getMetadata(Target);
+            expect(res).to.be.eql([
+                { middleware: MIDDLEWARE_1 },
+                { middleware: [MIDDLEWARE_2, MIDDLEWARE_3] },
+            ]);
+        });
+    });
+    describe('method target', function () {
+        it('sets given middleware to the target metadata', function () {
+            class Target {
+                method() { }
+            }
+            __decorate([
+                before(MIDDLEWARE_1),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], Target.prototype, "method", null);
+            const res = BeforeReflector.getMetadata(Target, 'method');
+            expect(res).to.be.eql([
+                {
+                    propertyKey: 'method',
+                    middleware: MIDDLEWARE_1,
+                },
+            ]);
+        });
+        it('sets miltiple middlewares to the target metadata', function () {
+            class Target {
+                method() { }
+            }
+            __decorate([
+                before([MIDDLEWARE_1, MIDDLEWARE_2]),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], Target.prototype, "method", null);
+            const res = BeforeReflector.getMetadata(Target, 'method');
+            expect(res).to.be.eql([
+                {
+                    propertyKey: 'method',
+                    middleware: [MIDDLEWARE_1, MIDDLEWARE_2],
+                },
+            ]);
+        });
+        it('allows to use the decorator multiple times', function () {
+            class Target {
+                method() { }
+            }
+            __decorate([
+                before(MIDDLEWARE_1),
+                before([MIDDLEWARE_2, MIDDLEWARE_3]),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], Target.prototype, "method", null);
+            const res = BeforeReflector.getMetadata(Target, 'method');
+            expect(res).to.be.eql([
+                {
+                    propertyKey: 'method',
+                    middleware: MIDDLEWARE_1,
+                },
+                {
+                    propertyKey: 'method',
+                    middleware: [MIDDLEWARE_2, MIDDLEWARE_3],
+                },
+            ]);
+        });
+    });
+});

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

@@ -0,0 +1,13 @@
+import { MetadataKey } from '@e22m4u/ts-reflector';
+import { RoutePreHandler } from '@e22m4u/js-trie-router';
+/**
+ * Before metadata.
+ */
+export type BeforeMetadata = {
+    propertyKey?: string;
+    middleware: RoutePreHandler | RoutePreHandler[];
+};
+/**
+ * Before metadata key.
+ */
+export declare const BEFORE_METADATA_KEY: MetadataKey<BeforeMetadata[]>;

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

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

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

@@ -0,0 +1,22 @@
+import { Constructor } from '../../types.js';
+import { BeforeMetadata } from './before-metadata.js';
+/**
+ * Before reflector.
+ */
+export declare class BeforeReflector {
+    /**
+     * Set metadata.
+     *
+     * @param metadata
+     * @param target
+     * @param propertyKey
+     */
+    static addMetadata(metadata: BeforeMetadata, target: Constructor, propertyKey?: string): void;
+    /**
+     * Get metadata.
+     *
+     * @param target
+     * @param propertyKey
+     */
+    static getMetadata(target: Constructor, propertyKey?: string): BeforeMetadata[];
+}

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

@@ -0,0 +1,29 @@
+import { Reflector } from '@e22m4u/ts-reflector';
+import { BEFORE_METADATA_KEY } from './before-metadata.js';
+/**
+ * Before reflector.
+ */
+export class BeforeReflector {
+    /**
+     * Set metadata.
+     *
+     * @param metadata
+     * @param target
+     * @param propertyKey
+     */
+    static addMetadata(metadata, target, propertyKey) {
+        const oldArray = Reflector.getOwnMetadata(BEFORE_METADATA_KEY, target, propertyKey) ?? [];
+        const newArray = [metadata, ...oldArray];
+        Reflector.defineMetadata(BEFORE_METADATA_KEY, newArray, target, propertyKey);
+    }
+    /**
+     * Get metadata.
+     *
+     * @param target
+     * @param propertyKey
+     */
+    static getMetadata(target, propertyKey) {
+        const metadata = Reflector.getOwnMetadata(BEFORE_METADATA_KEY, target, propertyKey);
+        return metadata ?? [];
+    }
+}

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

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