@e22m4u/ts-rest-router 0.0.6 → 0.1.0

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

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

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

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

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

@@ -0,0 +1,92 @@
+/* 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 () {
+      @after(MIDDLEWARE_1)
+      class Target {
+        method() {}
+      }
+      const res = AfterReflector.getMetadata(Target);
+      expect(res).to.be.eql([{middleware: MIDDLEWARE_1}]);
+    });
+
+    it('sets miltiple middlewares to the target metadata', function () {
+      @after([MIDDLEWARE_1, MIDDLEWARE_2])
+      class Target {
+        method() {}
+      }
+      const res = AfterReflector.getMetadata(Target);
+      expect(res).to.be.eql([{middleware: [MIDDLEWARE_1, MIDDLEWARE_2]}]);
+    });
+
+    it('allows to use the decorator multiple times', function () {
+      @after(MIDDLEWARE_1)
+      @after([MIDDLEWARE_2, MIDDLEWARE_3])
+      class Target {
+        method() {}
+      }
+      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 {
+        @after(MIDDLEWARE_1)
+        method() {}
+      }
+      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 {
+        @after([MIDDLEWARE_1, MIDDLEWARE_2])
+        method() {}
+      }
+      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 {
+        @after(MIDDLEWARE_1)
+        @after([MIDDLEWARE_2, MIDDLEWARE_3])
+        method() {}
+      }
+      const res = AfterReflector.getMetadata(Target, 'method');
+      expect(res).to.be.eql([
+        {
+          propertyKey: 'method',
+          middleware: MIDDLEWARE_1,
+        },
+        {
+          propertyKey: 'method',
+          middleware: [MIDDLEWARE_2, MIDDLEWARE_3],
+        },
+      ]);
+    });
+  });
+});

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

@@ -0,0 +1,40 @@
+import {Prototype} from '../../types.js';
+import {Constructor} from '../../types.js';
+import {AfterMetadata} from './after-metadata.js';
+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<T extends object>(
+  middleware: AfterMetadata['middleware'],
+) {
+  return function (
+    target: Constructor<T> | Prototype<T>,
+    propertyKey?: string,
+    descriptor?: PropertyDescriptor,
+  ) {
+    const decoratorType = getDecoratorTargetType(
+      target,
+      propertyKey,
+      descriptor,
+    );
+    if (decoratorType === DecoratorTargetType.CONSTRUCTOR) {
+      AfterReflector.addMetadata({middleware}, target as Constructor<T>);
+    } else if (decoratorType === DecoratorTargetType.INSTANCE_METHOD) {
+      AfterReflector.addMetadata(
+        {propertyKey, middleware},
+        target.constructor as Constructor<T>,
+        propertyKey,
+      );
+    } else {
+      throw new Error(
+        '@after decorator is only supported on a class or an instance method.',
+      );
+    }
+  };
+}

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

@@ -0,0 +1,17 @@
+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 const AFTER_METADATA_KEY = new MetadataKey<AfterMetadata[]>(
+  'afterMetadataKey',
+);

package/src/decorators/after/after-reflector.spec.ts

@@ -0,0 +1,107 @@
+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/src/decorators/after/after-reflector.ts

@@ -0,0 +1,45 @@
+import {Constructor} from '../../types.js';
+import {Reflector} from '@e22m4u/ts-reflector';
+import {AfterMetadata} from './after-metadata.js';
+import {AFTER_METADATA_KEY} from './after-metadata.js';
+
+/**
+ * After reflector.
+ */
+export class AfterReflector {
+  /**
+   * Set metadata.
+   *
+   * @param metadata
+   * @param target
+   * @param propertyKey
+   */
+  static addMetadata(
+    metadata: AfterMetadata,
+    target: Constructor,
+    propertyKey?: string,
+  ) {
+    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: Constructor,
+    propertyKey?: string,
+  ): AfterMetadata[] {
+    const metadata = Reflector.getOwnMetadata(
+      AFTER_METADATA_KEY,
+      target,
+      propertyKey,
+    );
+    return metadata ?? [];
+  }
+}

package/src/decorators/after/index.ts

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

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

@@ -0,0 +1,92 @@
+/* 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 () {
+      @before(MIDDLEWARE_1)
+      class Target {
+        method() {}
+      }
+      const res = BeforeReflector.getMetadata(Target);
+      expect(res).to.be.eql([{middleware: MIDDLEWARE_1}]);
+    });
+
+    it('sets miltiple middlewares to the target metadata', function () {
+      @before([MIDDLEWARE_1, MIDDLEWARE_2])
+      class Target {
+        method() {}
+      }
+      const res = BeforeReflector.getMetadata(Target);
+      expect(res).to.be.eql([{middleware: [MIDDLEWARE_1, MIDDLEWARE_2]}]);
+    });
+
+    it('allows to use the decorator multiple times', function () {
+      @before(MIDDLEWARE_1)
+      @before([MIDDLEWARE_2, MIDDLEWARE_3])
+      class Target {
+        method() {}
+      }
+      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 {
+        @before(MIDDLEWARE_1)
+        method() {}
+      }
+      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 {
+        @before([MIDDLEWARE_1, MIDDLEWARE_2])
+        method() {}
+      }
+      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 {
+        @before(MIDDLEWARE_1)
+        @before([MIDDLEWARE_2, MIDDLEWARE_3])
+        method() {}
+      }
+      const res = BeforeReflector.getMetadata(Target, 'method');
+      expect(res).to.be.eql([
+        {
+          propertyKey: 'method',
+          middleware: MIDDLEWARE_1,
+        },
+        {
+          propertyKey: 'method',
+          middleware: [MIDDLEWARE_2, MIDDLEWARE_3],
+        },
+      ]);
+    });
+  });
+});

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

@@ -0,0 +1,40 @@
+import {Prototype} from '../../types.js';
+import {Constructor} from '../../types.js';
+import {BeforeMetadata} from './before-metadata.js';
+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<T extends object>(
+  middleware: BeforeMetadata['middleware'],
+) {
+  return function (
+    target: Constructor<T> | Prototype<T>,
+    propertyKey?: string,
+    descriptor?: PropertyDescriptor,
+  ) {
+    const decoratorType = getDecoratorTargetType(
+      target,
+      propertyKey,
+      descriptor,
+    );
+    if (decoratorType === DecoratorTargetType.CONSTRUCTOR) {
+      BeforeReflector.addMetadata({middleware}, target as Constructor<T>);
+    } else if (decoratorType === DecoratorTargetType.INSTANCE_METHOD) {
+      BeforeReflector.addMetadata(
+        {propertyKey, middleware},
+        target.constructor as Constructor<T>,
+        propertyKey,
+      );
+    } else {
+      throw new Error(
+        '@before decorator is only supported on a class or an instance method.',
+      );
+    }
+  };
+}

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

@@ -0,0 +1,17 @@
+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 const BEFORE_METADATA_KEY = new MetadataKey<BeforeMetadata[]>(
+  'beforeMetadataKey',
+);

package/src/decorators/before/before-reflector.spec.ts

@@ -0,0 +1,111 @@
+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]);
+    });
+  });
+});