@e22m4u/ts-rest-router 0.0.2

package/src/decorators/action/index.ts

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

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

@@ -0,0 +1,41 @@
+import {expect} from 'chai';
+import {controller} from './controller-decorator.js';
+import {ControllerReflector} from './controller-reflector.js';
+
+describe('controller', function () {
+  it('does not requires options', function () {
+    @controller()
+    class Target {}
+    const res = ControllerReflector.getMetadata(Target);
+    expect(res).to.be.eql({className: 'Target'});
+  });
+
+  it('sets given options to the target metadata', function () {
+    const path = 'myPath';
+    const before = () => undefined;
+    const after = () => undefined;
+    const extraOption = 'extraOption';
+    @controller({
+      path,
+      before,
+      after,
+      extraOption,
+    })
+    class Target {}
+    const res = ControllerReflector.getMetadata(Target);
+    expect(res).to.be.eql({
+      className: 'Target',
+      path,
+      before,
+      after,
+      extraOption,
+    });
+  });
+
+  it('overrides given "className" option by the target class name', function () {
+    @controller({className: 'myClassName'})
+    class Target {}
+    const res = ControllerReflector.getMetadata(Target);
+    expect(res).to.be.eql({className: 'Target'});
+  });
+});

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

@@ -0,0 +1,29 @@
+import {Flatten} from '../../types.js';
+import {Constructor} from '../../types.js';
+import {DecoratorTargetType} from '@e22m4u/ts-reflector';
+import {ControllerMetadata} from './controller-metadata.js';
+import {getDecoratorTargetType} from '@e22m4u/ts-reflector';
+import {ControllerReflector} from './controller-reflector.js';
+
+/**
+ * Controller options.
+ */
+export type ControllerOptions = Flatten<Omit<ControllerMetadata, 'className'>>;
+
+/**
+ * Controller decorator.
+ *
+ * @param options
+ */
+export function controller<T extends object>(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.');
+    const metadata = {
+      ...options,
+      className: target.name,
+    };
+    ControllerReflector.setMetadata(metadata, target);
+  };
+}

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

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

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

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

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

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

package/src/decorators/controller/index.ts

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

package/src/decorators/index.ts

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

package/src/decorators/request-context/index.ts

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

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

@@ -0,0 +1,41 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import {expect} from 'chai';
+import {requestContext} from './request-context-decorator.js';
+import {RequestContextReflector} from './request-context-reflector.js';
+
+describe('requestContext', function () {
+  it('does not requires options', function () {
+    class Target {
+      method(
+        @requestContext()
+        prop: unknown,
+      ) {}
+    }
+    const res = RequestContextReflector.getMetadata(Target, 'method');
+    expect(res.get(0)).to.be.eql({property: undefined});
+  });
+
+  it('sets a given key of RequestContext as "propertyKey" of the target metadata', function () {
+    class Target {
+      method(
+        @requestContext('res')
+        prop: unknown,
+      ) {}
+    }
+    const res = RequestContextReflector.getMetadata(Target, 'method');
+    expect(res.get(0)).to.be.eql({property: 'res'});
+  });
+
+  it('sets a given RequestContextMetadata as the target metadata', function () {
+    const property = 'res';
+    const customOption = 'customOption';
+    class Target {
+      method(
+        @requestContext({property, customOption})
+        prop: unknown,
+      ) {}
+    }
+    const res = RequestContextReflector.getMetadata(Target, 'method');
+    expect(res.get(0)).to.be.eql({property, customOption});
+  });
+});

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

@@ -0,0 +1,57 @@
+import {Prototype} from '../../types.js';
+import {Constructor} from '../../types.js';
+import {RequestContext} from '@e22m4u/js-trie-router';
+import {DecoratorTargetType} from '@e22m4u/ts-reflector';
+import {getDecoratorTargetType} from '@e22m4u/ts-reflector';
+import {RequestContextReflector} from './request-context-reflector.js';
+import {RequestContextMetadata} from './request-context-metadata.js';
+
+/**
+ * Request context decorator.
+ *
+ * @param propertyOrMetadata
+ */
+export function requestContext<T extends object>(
+  propertyOrMetadata?: keyof RequestContext | RequestContextMetadata,
+) {
+  return function (
+    target: Prototype<T>,
+    propertyKey: string,
+    indexOrDescriptor: number,
+  ) {
+    const decoratorType = getDecoratorTargetType(
+      target,
+      propertyKey,
+      indexOrDescriptor,
+    );
+    if (decoratorType !== DecoratorTargetType.INSTANCE_METHOD_PARAMETER)
+      throw new Error(
+        '@requestContext decorator is only supported ' +
+          'on an instance method parameter.',
+      );
+    const metadata =
+      typeof propertyOrMetadata !== 'object'
+        ? {property: propertyOrMetadata}
+        : propertyOrMetadata;
+    RequestContextReflector.setMetadata(
+      metadata,
+      target.constructor as Constructor<T>,
+      indexOrDescriptor,
+      propertyKey,
+    );
+  };
+}
+
+/**
+ * Request decorator.
+ */
+export function request() {
+  return requestContext('req');
+}
+
+/**
+ * Response decorator.
+ */
+export function response() {
+  return requestContext('res');
+}

package/src/decorators/request-context/request-context-metadata.ts

@@ -0,0 +1,21 @@
+import {MetadataKey} from '@e22m4u/ts-reflector';
+import {RequestContext} from '@e22m4u/js-trie-router';
+
+/**
+ * Request context metadata.
+ */
+export type RequestContextMetadata = {
+  property?: keyof RequestContext;
+  [option: string]: unknown | undefined;
+};
+
+/**
+ * Request context metadata map.
+ */
+export type RequestContextMetadataMap = Map<number, RequestContextMetadata>;
+
+/**
+ * Request context metadata key.
+ */
+export const REQUEST_CONTEXT_METADATA_KEY =
+  new MetadataKey<RequestContextMetadataMap>('requestContextMetadataKey');

package/src/decorators/request-context/request-context-reflector.spec.ts

@@ -0,0 +1,77 @@
+import {expect} from 'chai';
+import {describe} from 'mocha';
+import {Reflector} from '@e22m4u/ts-reflector';
+import {RequestContextMetadata} from './request-context-metadata.js';
+import {RequestContextReflector} from './request-context-reflector.js';
+import {REQUEST_CONTEXT_METADATA_KEY} from './request-context-metadata.js';
+
+describe('RequestContextReflector', function () {
+  describe('setMetadata', function () {
+    it('sets a given value as target metadata', function () {
+      class Target {}
+      const md1 = {property: 'req' as const};
+      const md2 = {property: 'res' as const};
+      RequestContextReflector.setMetadata(md1, Target, 0, 'propertyKey');
+      RequestContextReflector.setMetadata(md2, Target, 1, 'propertyKey');
+      const res = Reflector.getOwnMetadata(
+        REQUEST_CONTEXT_METADATA_KEY,
+        Target,
+        'propertyKey',
+      );
+      expect(res).to.be.instanceof(Map);
+      expect(res!.get(0)).to.be.eq(md1);
+      expect(res!.get(1)).to.be.eq(md2);
+    });
+
+    it('overrides existing metadata', function () {
+      class Target {}
+      const md1 = {property: 'req' as const};
+      const md2 = {property: 'res' as const};
+      RequestContextReflector.setMetadata(md1, Target, 0, 'propertyKey');
+      const res1 = Reflector.getOwnMetadata(
+        REQUEST_CONTEXT_METADATA_KEY,
+        Target,
+        'propertyKey',
+      );
+      expect(res1).to.be.instanceof(Map);
+      expect(res1!.get(0)).to.be.eq(md1);
+      RequestContextReflector.setMetadata(md2, Target, 0, 'propertyKey');
+      const res2 = Reflector.getOwnMetadata(
+        REQUEST_CONTEXT_METADATA_KEY,
+        Target,
+        'propertyKey',
+      );
+      expect(res2).to.be.instanceof(Map);
+      expect(res2!.get(0)).to.be.eq(md2);
+    });
+  });
+
+  describe('getMetadata', function () {
+    it('returns an existing metadata of the target', function () {
+      class Target {}
+      const md1 = {property: 'req' as const};
+      const md2 = {property: 'res' as const};
+      const mdMap = new Map<number, RequestContextMetadata>([
+        [0, md1],
+        [1, md2],
+      ]);
+      Reflector.defineMetadata(
+        REQUEST_CONTEXT_METADATA_KEY,
+        mdMap,
+        Target,
+        'propertyKey',
+      );
+      const res = RequestContextReflector.getMetadata(Target, 'propertyKey');
+      expect(res).to.be.instanceof(Map);
+      expect(res!.get(0)).to.be.eq(md1);
+      expect(res!.get(1)).to.be.eq(md2);
+    });
+
+    it('returns an empty map if no metadata', function () {
+      class Target {}
+      const res = RequestContextReflector.getMetadata(Target, 'propertyKey');
+      expect(res).to.be.instanceof(Map);
+      expect(res).to.be.empty;
+    });
+  });
+});

package/src/decorators/request-context/request-context-reflector.ts

@@ -0,0 +1,57 @@
+import {Constructor} from '../../types.js';
+import {Reflector} from '@e22m4u/ts-reflector';
+import {RequestContextMetadata} from './request-context-metadata.js';
+import {RequestContextMetadataMap} from './request-context-metadata.js';
+import {REQUEST_CONTEXT_METADATA_KEY} from './request-context-metadata.js';
+
+/**
+ * Request context reflector.
+ */
+export class RequestContextReflector {
+  /**
+   * Set metadata.
+   *
+   * @param metadata
+   * @param target
+   * @param index
+   * @param propertyKey
+   */
+  static setMetadata(
+    metadata: RequestContextMetadata,
+    target: Constructor,
+    index: number,
+    propertyKey: string,
+  ) {
+    const oldMap = Reflector.getOwnMetadata(
+      REQUEST_CONTEXT_METADATA_KEY,
+      target,
+      propertyKey,
+    );
+    const newMap = new Map(oldMap);
+    newMap.set(index, metadata);
+    Reflector.defineMetadata(
+      REQUEST_CONTEXT_METADATA_KEY,
+      newMap,
+      target,
+      propertyKey,
+    );
+  }
+
+  /**
+   * Get metadata.
+   *
+   * @param target
+   * @param propertyKey
+   */
+  static getMetadata(
+    target: Constructor,
+    propertyKey: string,
+  ): RequestContextMetadataMap {
+    const metadata = Reflector.getOwnMetadata(
+      REQUEST_CONTEXT_METADATA_KEY,
+      target,
+      propertyKey,
+    );
+    return metadata ?? new Map();
+  }
+}

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

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