@e22m4u/ts-rest-router 0.1.2 → 0.2.0

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

@@ -85,31 +85,31 @@ function createRequestDataPropertyDecoratorWithSource(
 /**
  * Decorator aliases.
  */
-export const params = createRequestDataDecoratorWithSource(
+export const requestParams = createRequestDataDecoratorWithSource(
   RequestDataSource.PARAMS,
 );
-export const param = createRequestDataPropertyDecoratorWithSource(
+export const requestParam = createRequestDataPropertyDecoratorWithSource(
   RequestDataSource.PARAMS,
 );
-export const queries = createRequestDataDecoratorWithSource(
+export const requestQueries = createRequestDataDecoratorWithSource(
   RequestDataSource.QUERY,
 );
-export const query = createRequestDataPropertyDecoratorWithSource(
+export const requestQuery = createRequestDataPropertyDecoratorWithSource(
   RequestDataSource.QUERY,
 );
-export const headers = createRequestDataDecoratorWithSource(
+export const requestHeaders = createRequestDataDecoratorWithSource(
   RequestDataSource.HEADERS,
 );
-export const header = createRequestDataPropertyDecoratorWithSource(
+export const requestHeader = createRequestDataPropertyDecoratorWithSource(
   RequestDataSource.HEADERS,
 );
-export const cookies = createRequestDataDecoratorWithSource(
+export const requestCookies = createRequestDataDecoratorWithSource(
   RequestDataSource.COOKIE,
 );
-export const cookie = createRequestDataPropertyDecoratorWithSource(
+export const requestCookie = createRequestDataPropertyDecoratorWithSource(
   RequestDataSource.COOKIE,
 );
-export const field = createRequestDataPropertyDecoratorWithSource(
+export const requestField = createRequestDataPropertyDecoratorWithSource(
   RequestDataSource.BODY,
 );
 
@@ -118,7 +118,7 @@ export const field = createRequestDataPropertyDecoratorWithSource(
  *
  * @param schemaOrType
  */
-export function body(schemaOrType?: DataSchema | DataType) {
+export function requestBody(schemaOrType?: DataSchema | DataType) {
   let schema: DataSchema;
   if (typeof schemaOrType === 'object') {
     schema = schemaOrType;

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

@@ -1,5 +1,5 @@
-import {DataSchema} from '@e22m4u/ts-data-schema';
 import {MetadataKey} from '@e22m4u/ts-reflector';
+import {DataSchema} from '@e22m4u/ts-data-schema';
 
 /**
  * Request data source.

package/src/decorators/rest-action/index.ts

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

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

@@ -0,0 +1,325 @@
+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 {
+      @restAction(options)
+      method() {}
+    }
+    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 {
+      @restAction(options)
+      method() {}
+    }
+    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 {
+        @getAction()
+        method() {}
+      }
+      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 {
+        @getAction(options)
+        method() {}
+      }
+      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 {
+        @getAction('myPath1', options)
+        method() {}
+      }
+      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 {
+        @postAction()
+        method() {}
+      }
+      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 {
+        @postAction(options)
+        method() {}
+      }
+      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 {
+        @postAction('myPath1', options)
+        method() {}
+      }
+      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 {
+        @putAction()
+        method() {}
+      }
+      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 {
+        @putAction(options)
+        method() {}
+      }
+      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 {
+        @putAction('myPath1', options)
+        method() {}
+      }
+      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 {
+        @patchAction()
+        method() {}
+      }
+      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 {
+        @patchAction(options)
+        method() {}
+      }
+      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 {
+        @patchAction('myPath1', options)
+        method() {}
+      }
+      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 {
+        @deleteAction()
+        method() {}
+      }
+      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 {
+        @deleteAction(options)
+        method() {}
+      }
+      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 {
+        @deleteAction('myPath1', options)
+        method() {}
+      }
+      const res = RestActionReflector.getMetadata(Target);
+      expect(res.get('method')).to.be.eql({
+        ...options,
+        propertyKey: 'method',
+        method: HttpMethod.DELETE,
+        path: 'myPath1',
+      });
+    });
+  });
+});

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

@@ -0,0 +1,166 @@
+import {Flatten, PartialBy} from '../../types.js';
+import {Prototype} from '../../types.js';
+import {Constructor} from '../../types.js';
+import {HttpMethod} from '@e22m4u/js-trie-router';
+import {DecoratorTargetType} from '@e22m4u/ts-reflector';
+import {getDecoratorTargetType} from '@e22m4u/ts-reflector';
+import {RestActionMetadata} from './rest-action-metadata.js';
+import {RestActionReflector} from './rest-action-reflector.js';
+
+/**
+ * Rest action options.
+ */
+export type RestActionOptions = Flatten<
+  Omit<RestActionMetadata, 'propertyKey'>
+>;
+
+/**
+ * Rest action decorator.
+ */
+type RestActionDecorator = ReturnType<typeof restAction>;
+
+/**
+ * Rest action decorator factory.
+ *
+ * @param options
+ */
+export function restAction<T extends object>(options: RestActionOptions) {
+  return function (
+    target: Prototype<T>,
+    propertyKey: string,
+    descriptor: PropertyDescriptor,
+  ) {
+    const decoratorType = getDecoratorTargetType(
+      target,
+      propertyKey,
+      descriptor,
+    );
+    if (decoratorType !== DecoratorTargetType.INSTANCE_METHOD)
+      throw new Error(
+        '@restAction decorator is only supported on an instance method.',
+      );
+    RestActionReflector.setMetadata(
+      {...options, propertyKey},
+      target.constructor as Constructor<T>,
+      propertyKey,
+    );
+  };
+}
+
+/**
+ * Rest action method options.
+ */
+export type RestActionAliasOptions = Flatten<
+  PartialBy<Omit<RestActionOptions, 'method'>, 'path'>
+>;
+
+/**
+ * Get action decorator.
+ */
+export function getAction(): RestActionDecorator;
+export function getAction(path: string): RestActionDecorator;
+export function getAction(options: RestActionAliasOptions): RestActionDecorator;
+export function getAction(
+  path: string,
+  options: RestActionAliasOptions,
+): RestActionDecorator;
+export function getAction(
+  pathOrOptions?: string | RestActionAliasOptions,
+  options?: RestActionAliasOptions,
+) {
+  let path = typeof pathOrOptions === 'string' ? pathOrOptions : '';
+  options = typeof pathOrOptions === 'object' ? pathOrOptions : options;
+  if (typeof options === 'object' && !path && options.path != null)
+    path = options.path;
+  return restAction({...options, path, method: HttpMethod.GET});
+}
+
+/**
+ * Post action decorator.
+ */
+export function postAction(): RestActionDecorator;
+export function postAction(path: string): RestActionDecorator;
+export function postAction(
+  options: RestActionAliasOptions,
+): RestActionDecorator;
+export function postAction(
+  path: string,
+  options: RestActionAliasOptions,
+): RestActionDecorator;
+export function postAction(
+  pathOrOptions?: string | RestActionAliasOptions,
+  options?: RestActionAliasOptions,
+) {
+  let path = typeof pathOrOptions === 'string' ? pathOrOptions : '';
+  options = typeof pathOrOptions === 'object' ? pathOrOptions : options;
+  if (typeof options === 'object' && !path && options.path != null)
+    path = options.path;
+  return restAction({...options, path, method: HttpMethod.POST});
+}
+
+/**
+ * Put action decorator.
+ */
+export function putAction(): RestActionDecorator;
+export function putAction(path: string): RestActionDecorator;
+export function putAction(options: RestActionAliasOptions): RestActionDecorator;
+export function putAction(
+  path: string,
+  options: RestActionAliasOptions,
+): RestActionDecorator;
+export function putAction(
+  pathOrOptions?: string | RestActionAliasOptions,
+  options?: RestActionAliasOptions,
+) {
+  let path = typeof pathOrOptions === 'string' ? pathOrOptions : '';
+  options = typeof pathOrOptions === 'object' ? pathOrOptions : options;
+  if (typeof options === 'object' && !path && options.path != null)
+    path = options.path;
+  return restAction({...options, path, method: HttpMethod.PUT});
+}
+
+/**
+ * Patch action decorator.
+ */
+export function patchAction(): RestActionDecorator;
+export function patchAction(path: string): RestActionDecorator;
+export function patchAction(
+  options: RestActionAliasOptions,
+): RestActionDecorator;
+export function patchAction(
+  path: string,
+  options: RestActionAliasOptions,
+): RestActionDecorator;
+export function patchAction(
+  pathOrOptions?: string | RestActionAliasOptions,
+  options?: RestActionAliasOptions,
+) {
+  let path = typeof pathOrOptions === 'string' ? pathOrOptions : '';
+  options = typeof pathOrOptions === 'object' ? pathOrOptions : options;
+  if (typeof options === 'object' && !path && options.path != null)
+    path = options.path;
+  return restAction({...options, path, method: HttpMethod.PATCH});
+}
+
+/**
+ * Delete action decorator.
+ */
+export function deleteAction(): RestActionDecorator;
+export function deleteAction(path: string): RestActionDecorator;
+export function deleteAction(
+  options: RestActionAliasOptions,
+): RestActionDecorator;
+export function deleteAction(
+  path: string,
+  options: RestActionAliasOptions,
+): RestActionDecorator;
+export function deleteAction(
+  pathOrOptions?: string | RestActionAliasOptions,
+  options?: RestActionAliasOptions,
+) {
+  let path = typeof pathOrOptions === 'string' ? pathOrOptions : '';
+  options = typeof pathOrOptions === 'object' ? pathOrOptions : options;
+  if (typeof options === 'object' && !path && options.path != null)
+    path = options.path;
+  return restAction({...options, path, method: HttpMethod.DELETE});
+}

package/src/decorators/{action/action-metadata.ts → rest-action/rest-action-metadata.ts}

@@ -4,9 +4,9 @@ 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;
@@ -15,13 +15,13 @@ export type ActionMetadata = {
 };
 
 /**
- * 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 const ACTIONS_METADATA_KEY = new MetadataKey<ActionMetadataMap>(
-  'actionsMetadataKey',
+export const REST_ACTIONS_METADATA_KEY = new MetadataKey<RestActionMetadataMap>(
+  'restActionsMetadataKey',
 );

package/src/decorators/{action/action-reflector.spec.ts → rest-action/rest-action-reflector.spec.ts}

@@ -2,10 +2,10 @@ 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';
+import {RestActionReflector} from './rest-action-reflector.js';
+import {REST_ACTIONS_METADATA_KEY} from './rest-action-metadata.js';
 
-describe('ActionReflector', function () {
+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/src/decorators/rest-action/rest-action-reflector.ts

@@ -0,0 +1,41 @@
+import {Constructor} from '../../types.js';
+import {Reflector} from '@e22m4u/ts-reflector';
+import {RestActionMetadata} from './rest-action-metadata.js';
+import {RestActionMetadataMap} from './rest-action-metadata.js';
+import {REST_ACTIONS_METADATA_KEY} from './rest-action-metadata.js';
+
+/**
+ * Rest action reflector.
+ */
+export class RestActionReflector {
+  /**
+   * Set metadata.
+   *
+   * @param metadata
+   * @param target
+   * @param propertyKey
+   */
+  static setMetadata(
+    metadata: RestActionMetadata,
+    target: Constructor,
+    propertyKey: string,
+  ) {
+    const oldMap = Reflector.getOwnMetadata(REST_ACTIONS_METADATA_KEY, target);
+    const newMap = new Map(oldMap);
+    newMap.set(propertyKey, metadata);
+    Reflector.defineMetadata(REST_ACTIONS_METADATA_KEY, newMap, target);
+  }
+
+  /**
+   * Get metadata.
+   *
+   * @param target
+   */
+  static getMetadata(target: Constructor): RestActionMetadataMap {
+    const metadata = Reflector.getOwnMetadata(
+      REST_ACTIONS_METADATA_KEY,
+      target,
+    );
+    return metadata ?? new Map();
+  }
+}

package/src/decorators/rest-controller/index.ts

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