@e22m4u/ts-rest-router 0.1.1 → 0.2.0

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

@@ -0,0 +1,401 @@
+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 { HttpMethod } from '@e22m4u/js-trie-router';
+import { getAction } from './rest-action-decorator.js';
+import { putAction } from './rest-action-decorator.js';
+import { restAction } from './rest-action-decorator.js';
+import { postAction } from './rest-action-decorator.js';
+import { patchAction } from './rest-action-decorator.js';
+import { deleteAction } from './rest-action-decorator.js';
+import { RestActionReflector } from './rest-action-reflector.js';
+describe('restAction', function () {
+    it('hasAliases', function () {
+        expect(getAction).to.be.instanceOf(Function);
+        expect(postAction).to.be.instanceOf(Function);
+        expect(putAction).to.be.instanceOf(Function);
+        expect(patchAction).to.be.instanceOf(Function);
+        expect(deleteAction).to.be.instanceOf(Function);
+    });
+    it('sets given options to the target metadata', function () {
+        const options = {
+            method: HttpMethod.GET,
+            path: 'myPath',
+            before: () => undefined,
+            after: () => undefined,
+            customOption: 'customOption',
+        };
+        class Target {
+            method() { }
+        }
+        __decorate([
+            restAction(options),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], Target.prototype, "method", null);
+        const res = RestActionReflector.getMetadata(Target);
+        expect(res.get('method')).to.be.eql({
+            ...options,
+            propertyKey: 'method',
+        });
+    });
+    it('overrides a given "propertyKey" option by the target method name', function () {
+        const options = {
+            propertyKey: 'myMethod',
+            method: HttpMethod.GET,
+            path: 'myPath',
+        };
+        class Target {
+            method() { }
+        }
+        __decorate([
+            restAction(options),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], Target.prototype, "method", null);
+        const res = RestActionReflector.getMetadata(Target);
+        expect(res.get('method')).to.be.eql({
+            ...options,
+            propertyKey: 'method',
+        });
+    });
+    describe('getAction', function () {
+        it('allows no arguments', function () {
+            class Target {
+                method() { }
+            }
+            __decorate([
+                getAction(),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], Target.prototype, "method", null);
+            const res = RestActionReflector.getMetadata(Target);
+            expect(res.get('method')).to.be.eql({
+                propertyKey: 'method',
+                method: HttpMethod.GET,
+                path: '',
+            });
+        });
+        it('allows options as first argument', function () {
+            const options = {
+                path: 'myPath',
+                before: () => undefined,
+                after: () => undefined,
+                customOption: 'customOption',
+            };
+            class Target {
+                method() { }
+            }
+            __decorate([
+                getAction(options),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], Target.prototype, "method", null);
+            const res = RestActionReflector.getMetadata(Target);
+            expect(res.get('method')).to.be.eql({
+                ...options,
+                propertyKey: 'method',
+                method: HttpMethod.GET,
+            });
+        });
+        it('allows path and options arguments', function () {
+            const options = {
+                path: 'myPath2',
+                before: () => undefined,
+                after: () => undefined,
+                customOption: 'customOption',
+            };
+            class Target {
+                method() { }
+            }
+            __decorate([
+                getAction('myPath1', options),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], Target.prototype, "method", null);
+            const res = RestActionReflector.getMetadata(Target);
+            expect(res.get('method')).to.be.eql({
+                ...options,
+                propertyKey: 'method',
+                method: HttpMethod.GET,
+                path: 'myPath1',
+            });
+        });
+    });
+    describe('postAction', function () {
+        it('allows no arguments', function () {
+            class Target {
+                method() { }
+            }
+            __decorate([
+                postAction(),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], Target.prototype, "method", null);
+            const res = RestActionReflector.getMetadata(Target);
+            expect(res.get('method')).to.be.eql({
+                propertyKey: 'method',
+                method: HttpMethod.POST,
+                path: '',
+            });
+        });
+        it('allows options as first argument', function () {
+            const options = {
+                path: 'myPath',
+                before: () => undefined,
+                after: () => undefined,
+                customOption: 'customOption',
+            };
+            class Target {
+                method() { }
+            }
+            __decorate([
+                postAction(options),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], Target.prototype, "method", null);
+            const res = RestActionReflector.getMetadata(Target);
+            expect(res.get('method')).to.be.eql({
+                ...options,
+                propertyKey: 'method',
+                method: HttpMethod.POST,
+            });
+        });
+        it('allows path and options arguments', function () {
+            const options = {
+                path: 'myPath2',
+                before: () => undefined,
+                after: () => undefined,
+                customOption: 'customOption',
+            };
+            class Target {
+                method() { }
+            }
+            __decorate([
+                postAction('myPath1', options),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], Target.prototype, "method", null);
+            const res = RestActionReflector.getMetadata(Target);
+            expect(res.get('method')).to.be.eql({
+                ...options,
+                propertyKey: 'method',
+                method: HttpMethod.POST,
+                path: 'myPath1',
+            });
+        });
+    });
+    describe('putAction', function () {
+        it('allows no arguments', function () {
+            class Target {
+                method() { }
+            }
+            __decorate([
+                putAction(),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], Target.prototype, "method", null);
+            const res = RestActionReflector.getMetadata(Target);
+            expect(res.get('method')).to.be.eql({
+                propertyKey: 'method',
+                method: HttpMethod.PUT,
+                path: '',
+            });
+        });
+        it('allows options as first argument', function () {
+            const options = {
+                path: 'myPath',
+                before: () => undefined,
+                after: () => undefined,
+                customOption: 'customOption',
+            };
+            class Target {
+                method() { }
+            }
+            __decorate([
+                putAction(options),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], Target.prototype, "method", null);
+            const res = RestActionReflector.getMetadata(Target);
+            expect(res.get('method')).to.be.eql({
+                ...options,
+                propertyKey: 'method',
+                method: HttpMethod.PUT,
+            });
+        });
+        it('allows path and options arguments', function () {
+            const options = {
+                path: 'myPath2',
+                before: () => undefined,
+                after: () => undefined,
+                customOption: 'customOption',
+            };
+            class Target {
+                method() { }
+            }
+            __decorate([
+                putAction('myPath1', options),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], Target.prototype, "method", null);
+            const res = RestActionReflector.getMetadata(Target);
+            expect(res.get('method')).to.be.eql({
+                ...options,
+                propertyKey: 'method',
+                method: HttpMethod.PUT,
+                path: 'myPath1',
+            });
+        });
+    });
+    describe('patchAction', function () {
+        it('allows no arguments', function () {
+            class Target {
+                method() { }
+            }
+            __decorate([
+                patchAction(),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], Target.prototype, "method", null);
+            const res = RestActionReflector.getMetadata(Target);
+            expect(res.get('method')).to.be.eql({
+                propertyKey: 'method',
+                method: HttpMethod.PATCH,
+                path: '',
+            });
+        });
+        it('allows options as first argument', function () {
+            const options = {
+                path: 'myPath',
+                before: () => undefined,
+                after: () => undefined,
+                customOption: 'customOption',
+            };
+            class Target {
+                method() { }
+            }
+            __decorate([
+                patchAction(options),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], Target.prototype, "method", null);
+            const res = RestActionReflector.getMetadata(Target);
+            expect(res.get('method')).to.be.eql({
+                ...options,
+                propertyKey: 'method',
+                method: HttpMethod.PATCH,
+            });
+        });
+        it('allows path and options arguments', function () {
+            const options = {
+                path: 'myPath2',
+                before: () => undefined,
+                after: () => undefined,
+                customOption: 'customOption',
+            };
+            class Target {
+                method() { }
+            }
+            __decorate([
+                patchAction('myPath1', options),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], Target.prototype, "method", null);
+            const res = RestActionReflector.getMetadata(Target);
+            expect(res.get('method')).to.be.eql({
+                ...options,
+                propertyKey: 'method',
+                method: HttpMethod.PATCH,
+                path: 'myPath1',
+            });
+        });
+    });
+    describe('deleteAction', function () {
+        it('allows no arguments', function () {
+            class Target {
+                method() { }
+            }
+            __decorate([
+                deleteAction(),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], Target.prototype, "method", null);
+            const res = RestActionReflector.getMetadata(Target);
+            expect(res.get('method')).to.be.eql({
+                propertyKey: 'method',
+                method: HttpMethod.DELETE,
+                path: '',
+            });
+        });
+        it('allows options as first argument', function () {
+            const options = {
+                path: 'myPath',
+                before: () => undefined,
+                after: () => undefined,
+                customOption: 'customOption',
+            };
+            class Target {
+                method() { }
+            }
+            __decorate([
+                deleteAction(options),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], Target.prototype, "method", null);
+            const res = RestActionReflector.getMetadata(Target);
+            expect(res.get('method')).to.be.eql({
+                ...options,
+                propertyKey: 'method',
+                method: HttpMethod.DELETE,
+            });
+        });
+        it('allows path and options arguments', function () {
+            const options = {
+                path: 'myPath2',
+                before: () => undefined,
+                after: () => undefined,
+                customOption: 'customOption',
+            };
+            class Target {
+                method() { }
+            }
+            __decorate([
+                deleteAction('myPath1', options),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], Target.prototype, "method", null);
+            const res = RestActionReflector.getMetadata(Target);
+            expect(res.get('method')).to.be.eql({
+                ...options,
+                propertyKey: 'method',
+                method: HttpMethod.DELETE,
+                path: 'myPath1',
+            });
+        });
+    });
+});

package/dist/esm/decorators/{action/action-metadata.d.ts → rest-action/rest-action-metadata.d.ts}

@@ -3,9 +3,9 @@ import { HttpMethod } from '@e22m4u/js-trie-router';
 import { RoutePreHandler } from '@e22m4u/js-trie-router';
 import { RoutePostHandler } from '@e22m4u/js-trie-router';
 /**
- * Action metadata.
+ * Rest action metadata.
  */
-export type ActionMetadata = {
+export type RestActionMetadata = {
     propertyKey: string;
     method: HttpMethod;
     path: string;
@@ -13,10 +13,10 @@ export type ActionMetadata = {
     after?: RoutePostHandler | RoutePostHandler[];
 };
 /**
- * Action metadata map.
+ * Rest action metadata map.
  */
-export type ActionMetadataMap = Map<string, ActionMetadata>;
+export type RestActionMetadataMap = Map<string, RestActionMetadata>;
 /**
- * Actions metadata key.
+ * Rest actions metadata key.
  */
-export declare const ACTIONS_METADATA_KEY: MetadataKey<ActionMetadataMap>;
+export declare const REST_ACTIONS_METADATA_KEY: MetadataKey<RestActionMetadataMap>;

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

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

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

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

package/dist/esm/decorators/{action/action-reflector.js → rest-action/rest-action-reflector.js}

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

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

@@ -2,9 +2,9 @@ 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 () {
+import { RestActionReflector } from './rest-action-reflector.js';
+import { REST_ACTIONS_METADATA_KEY } from './rest-action-metadata.js';
+describe('RestActionReflector', function () {
     describe('setMetadata', function () {
         it('sets a given value as target metadata', function () {
             class Target {
@@ -19,9 +19,9 @@ describe('ActionReflector', function () {
                 method: HttpMethod.GET,
                 path: '/bar',
             };
-            ActionReflector.setMetadata(md1, Target, 'propertyKey1');
-            ActionReflector.setMetadata(md2, Target, 'propertyKey2');
-            const res = Reflector.getOwnMetadata(ACTIONS_METADATA_KEY, Target);
+            RestActionReflector.setMetadata(md1, Target, 'propertyKey1');
+            RestActionReflector.setMetadata(md2, Target, 'propertyKey2');
+            const res = Reflector.getOwnMetadata(REST_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);
@@ -39,12 +39,12 @@ describe('ActionReflector', function () {
                 method: HttpMethod.POST,
                 path: '/bar',
             };
-            ActionReflector.setMetadata(md1, Target, 'propertyKey');
-            const res1 = Reflector.getOwnMetadata(ACTIONS_METADATA_KEY, Target);
+            RestActionReflector.setMetadata(md1, Target, 'propertyKey');
+            const res1 = Reflector.getOwnMetadata(REST_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);
+            RestActionReflector.setMetadata(md2, Target, 'propertyKey');
+            const res2 = Reflector.getOwnMetadata(REST_ACTIONS_METADATA_KEY, Target);
             expect(res2).to.be.instanceof(Map);
             expect(res2.get('propertyKey')).to.be.eq(md2);
         });
@@ -67,8 +67,8 @@ describe('ActionReflector', function () {
                 ['propertyKey1', md1],
                 ['propertyKey2', md2],
             ]);
-            Reflector.defineMetadata(ACTIONS_METADATA_KEY, mdMap, Target);
-            const res = ActionReflector.getMetadata(Target);
+            Reflector.defineMetadata(REST_ACTIONS_METADATA_KEY, mdMap, Target);
+            const res = RestActionReflector.getMetadata(Target);
             expect(res).to.be.instanceof(Map);
             expect(res.get('propertyKey1')).to.be.eq(md1);
             expect(res.get('propertyKey2')).to.be.eq(md2);
@@ -76,7 +76,7 @@ describe('ActionReflector', function () {
         it('returns an empty map if no metadata', function () {
             class Target {
             }
-            const res = ActionReflector.getMetadata(Target);
+            const res = RestActionReflector.getMetadata(Target);
             expect(res).to.be.instanceof(Map);
             expect(res).to.be.empty;
         });

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

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

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

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

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

@@ -0,0 +1,14 @@
+import { Flatten } from '../../types.js';
+import { Constructor } from '../../types.js';
+import { RestControllerMetadata } from './rest-controller-metadata.js';
+/**
+ * Rest controller options.
+ */
+export type RestControllerOptions = Flatten<Omit<RestControllerMetadata, 'className'>>;
+/**
+ * Rest controller decorator.
+ *
+ * @param pathOrOptions
+ * @param options
+ */
+export declare function restController<T extends object>(pathOrOptions?: string | RestControllerOptions, options?: RestControllerOptions): (target: Constructor<T>) => void;

package/dist/esm/decorators/{controller/controller-decorator.js → rest-controller/rest-controller-decorator.js}

@@ -1,17 +1,17 @@
 import { DecoratorTargetType } from '@e22m4u/ts-reflector';
 import { getDecoratorTargetType } from '@e22m4u/ts-reflector';
-import { ControllerReflector } from './controller-reflector.js';
+import { RestControllerReflector } from './rest-controller-reflector.js';
 /**
- * Controller decorator.
+ * Rest controller decorator.
  *
  * @param pathOrOptions
  * @param options
  */
-export function controller(pathOrOptions, options) {
+export function restController(pathOrOptions, options) {
     return function (target) {
         const decoratorType = getDecoratorTargetType(target);
         if (decoratorType !== DecoratorTargetType.CONSTRUCTOR)
-            throw new Error('@controller decorator is only supported on a class.');
+            throw new Error('@restController decorator is only supported on a class.');
         // если первый аргумент является строкой,
         // то значение используется в качестве
         // базового пути контроллера
@@ -36,6 +36,6 @@ export function controller(pathOrOptions, options) {
         else if (typeof pathOrOptions === 'object') {
             options = pathOrOptions;
         }
-        ControllerReflector.setMetadata({ ...options, className: target.name }, target);
+        RestControllerReflector.setMetadata({ ...options, className: target.name }, target);
     };
 }