@e22m4u/ts-rest-router 0.0.7 → 0.1.0

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]);
+    });
+  });
+});

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

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

package/src/decorators/before/index.ts

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

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

@@ -33,4 +33,26 @@ describe('controller', function () {
     const res = ControllerReflector.getMetadata(Target);
     expect(res).to.be.eql({className: 'Target'});
   });
+
+  it('allows to pass the path option to the first parameter', function () {
+    @controller('myPath')
+    class Target {}
+    const res = ControllerReflector.getMetadata(Target);
+    expect(res).to.be.eql({className: 'Target', path: 'myPath'});
+  });
+
+  it('merges two given arguments in the target metadata', function () {
+    const before = () => undefined;
+    @controller('myPath', {before})
+    class Target {}
+    const res = ControllerReflector.getMetadata(Target);
+    expect(res).to.be.eql({className: 'Target', path: 'myPath', before});
+  });
+
+  it('overrides the path option by the first argument', function () {
+    @controller('myPath1', {path: 'myPath2'})
+    class Target {}
+    const res = ControllerReflector.getMetadata(Target);
+    expect(res).to.be.eql({className: 'Target', path: 'myPath1'});
+  });
 });

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

@@ -13,13 +13,41 @@ export type ControllerOptions = Flatten<Omit<ControllerMetadata, 'className'>>;
 /**
  * Controller decorator.
  *
+ * @param pathOrOptions
  * @param options
  */
-export function controller<T extends object>(options?: ControllerOptions) {
+export function controller<T extends object>(
+  pathOrOptions?: string | ControllerOptions,
+  options?: ControllerOptions,
+) {
   return function (target: Constructor<T>) {
     const decoratorType = getDecoratorTargetType(target);
     if (decoratorType !== DecoratorTargetType.CONSTRUCTOR)
       throw new Error('@controller decorator is only supported on a class.');
+    // если первый аргумент является строкой,
+    // то значение используется в качестве
+    // базового пути контроллера
+    if (typeof pathOrOptions === 'string') {
+      // если второй аргумент не определен,
+      // то создается новый объект опций,
+      // который включает базовый путь
+      if (!options) {
+        options = {path: pathOrOptions};
+      }
+      // если второй аргумент определен,
+      // то базовый путь из первого аргумента
+      // передается в объект опций декоратора
+      else {
+        options.path = pathOrOptions;
+      }
+    }
+    // если первый аргумент является объектом,
+    // то его значение используется в качестве
+    // объекта опций декоратора, а второй
+    // аргумент игнорируется
+    else if (typeof pathOrOptions === 'object') {
+      options = pathOrOptions;
+    }
     ControllerReflector.setMetadata(
       {...options, className: target.name},
       target,

package/src/decorators/index.ts

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

package/src/decorators/request-data/request-data-decorator.spec.ts

@@ -10,7 +10,7 @@ import {params} from './request-data-decorator.js';
 import {queries} from './request-data-decorator.js';
 import {cookies} from './request-data-decorator.js';
 import {headers} from './request-data-decorator.js';
-import {bodyParam} from './request-data-decorator.js';
+import {bodyProp} from './request-data-decorator.js';
 import {requestData} from './request-data-decorator.js';
 import {RequestDataSource} from './request-data-metadata.js';
 import {RequestDataReflector} from './request-data-reflector.js';
@@ -409,11 +409,11 @@ describe('requestData', function () {
       });
     });
 
-    describe('bodyParam', function () {
+    describe('bodyProp', function () {
       it('sets a given "propertyKey" to the target metadata', function () {
         class Target {
           myMethod(
-            @bodyParam('myPropertyKey')
+            @bodyProp('myPropertyKey')
             prop: unknown,
           ) {}
         }
@@ -430,7 +430,7 @@ describe('requestData', function () {
         const propertyType = DataType.STRING;
         class Target {
           myMethod(
-            @bodyParam(propertyKey, propertyType)
+            @bodyProp(propertyKey, propertyType)
             prop: unknown,
           ) {}
         }
@@ -457,7 +457,7 @@ describe('requestData', function () {
         const propertyKey = 'myPropertyKey';
         class Target {
           myMethod(
-            @bodyParam(propertyKey, schema)
+            @bodyProp(propertyKey, schema)
             prop: unknown,
           ) {}
         }

package/src/decorators/request-data/request-data-decorator.ts

@@ -109,7 +109,7 @@ export const cookies = createRequestDataDecoratorWithSource(
 export const cookie = createRequestDataPropertyDecoratorWithSource(
   RequestDataSource.COOKIE,
 );
-export const bodyParam = createRequestDataPropertyDecoratorWithSource(
+export const bodyProp = createRequestDataPropertyDecoratorWithSource(
   RequestDataSource.BODY,
 );