@e22m4u/ts-rest-router 0.0.2

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

@@ -0,0 +1,477 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import {expect} from 'chai';
+import {DataType} from '@e22m4u/ts-data-schema';
+import {body} from './request-data-decorator.js';
+import {param} from './request-data-decorator.js';
+import {query} from './request-data-decorator.js';
+import {cookie} from './request-data-decorator.js';
+import {header} from './request-data-decorator.js';
+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 {requestData} from './request-data-decorator.js';
+import {RequestDataSource} from './request-data-metadata.js';
+import {RequestDataMetadata} from './request-data-metadata.js';
+import {RequestDataReflector} from './request-data-reflector.js';
+
+describe('requestData', function () {
+  it('sets a given argument to the target metadata', function () {
+    const md: RequestDataMetadata = {
+      source: RequestDataSource.PARAMS,
+      customOption: 'myOption',
+    };
+    class Target {
+      myMethod(
+        @requestData(md)
+        prop: unknown,
+      ) {}
+    }
+    const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+    expect(res.get(0)).to.be.eql(md);
+  });
+
+  describe('request data by a given source', function () {
+    describe('params', function () {
+      it('sets metadata with specified source and schema', function () {
+        class Target {
+          myMethod(
+            @params()
+            prop: unknown,
+          ) {}
+        }
+        const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+        expect(res.get(0)).to.be.eql({
+          source: RequestDataSource.PARAMS,
+          schema: {type: DataType.OBJECT},
+        });
+      });
+    });
+
+    describe('queries', function () {
+      it('sets metadata with specified source and schema', function () {
+        class Target {
+          myMethod(
+            @queries()
+            prop: unknown,
+          ) {}
+        }
+        const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+        expect(res.get(0)).to.be.eql({
+          source: RequestDataSource.QUERY,
+          schema: {type: DataType.OBJECT},
+        });
+      });
+    });
+
+    describe('headers', function () {
+      it('sets metadata with specified source and schema', function () {
+        class Target {
+          myMethod(
+            @headers()
+            prop: unknown,
+          ) {}
+        }
+        const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+        expect(res.get(0)).to.be.eql({
+          source: RequestDataSource.HEADERS,
+          schema: {type: DataType.OBJECT},
+        });
+      });
+    });
+
+    describe('cookies', function () {
+      it('sets metadata with specified source and schema', function () {
+        class Target {
+          myMethod(
+            @cookies()
+            prop: unknown,
+          ) {}
+        }
+        const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+        expect(res.get(0)).to.be.eql({
+          source: RequestDataSource.COOKIE,
+          schema: {type: DataType.OBJECT},
+        });
+      });
+    });
+
+    describe('body', function () {
+      it('sets metadata with specified source and schema', function () {
+        class Target {
+          myMethod(
+            @body()
+            prop: unknown,
+          ) {}
+        }
+        const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+        expect(res.get(0)).to.be.eql({
+          source: RequestDataSource.BODY,
+          schema: {type: DataType.ANY},
+        });
+      });
+
+      it('sets a given DataType to the target metadata', function () {
+        class Target {
+          myMethod(
+            @body(DataType.STRING)
+            prop: unknown,
+          ) {}
+        }
+        const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+        expect(res.get(0)).to.be.eql({
+          source: RequestDataSource.BODY,
+          schema: {type: DataType.STRING},
+        });
+      });
+
+      it('set a given DataSchema to the target metadata', function () {
+        const schema = {type: DataType.STRING, required: true};
+        class Target {
+          myMethod(
+            @body(schema)
+            prop: unknown,
+          ) {}
+        }
+        const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+        expect(res.get(0)).to.be.eql({
+          source: RequestDataSource.BODY,
+          schema,
+        });
+      });
+    });
+  });
+
+  describe('request data piece by a given property key', function () {
+    describe('param', function () {
+      it('sets a given "propertyKey" to the target metadata', function () {
+        class Target {
+          myMethod(
+            @param('myPropertyKey')
+            prop: unknown,
+          ) {}
+        }
+        const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+        expect(res.get(0)).to.be.eql({
+          source: RequestDataSource.PARAMS,
+          schema: {type: DataType.OBJECT},
+          property: 'myPropertyKey',
+        });
+      });
+
+      it('sets a given DataType as property type', function () {
+        const propertyKey = 'myPropertyKey';
+        const propertyType = DataType.STRING;
+        class Target {
+          myMethod(
+            @param(propertyKey, propertyType)
+            prop: unknown,
+          ) {}
+        }
+        const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+        expect(res.get(0)).to.be.eql({
+          source: RequestDataSource.PARAMS,
+          schema: {
+            type: DataType.OBJECT,
+            properties: {
+              [propertyKey]: {
+                type: propertyType,
+              },
+            },
+          },
+          property: propertyKey,
+        });
+      });
+
+      it('sets a given DataSchema as property schema', function () {
+        const schema = {
+          type: DataType.STRING,
+          required: true,
+        };
+        const propertyKey = 'myPropertyKey';
+        class Target {
+          myMethod(
+            @param(propertyKey, schema)
+            prop: unknown,
+          ) {}
+        }
+        const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+        expect(res.get(0)).to.be.eql({
+          source: RequestDataSource.PARAMS,
+          schema: {
+            type: DataType.OBJECT,
+            properties: {
+              [propertyKey]: schema,
+            },
+          },
+          property: propertyKey,
+        });
+      });
+    });
+
+    describe('query', function () {
+      it('sets a given "propertyKey" to the target metadata', function () {
+        class Target {
+          myMethod(
+            @query('myPropertyKey')
+            prop: unknown,
+          ) {}
+        }
+        const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+        expect(res.get(0)).to.be.eql({
+          source: RequestDataSource.QUERY,
+          schema: {type: DataType.OBJECT},
+          property: 'myPropertyKey',
+        });
+      });
+
+      it('sets a given DataType as property type', function () {
+        const propertyKey = 'myPropertyKey';
+        const propertyType = DataType.STRING;
+        class Target {
+          myMethod(
+            @query(propertyKey, propertyType)
+            prop: unknown,
+          ) {}
+        }
+        const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+        expect(res.get(0)).to.be.eql({
+          source: RequestDataSource.QUERY,
+          schema: {
+            type: DataType.OBJECT,
+            properties: {
+              [propertyKey]: {
+                type: propertyType,
+              },
+            },
+          },
+          property: propertyKey,
+        });
+      });
+
+      it('sets a given DataSchema as property schema', function () {
+        const schema = {
+          type: DataType.STRING,
+          required: true,
+        };
+        const propertyKey = 'myPropertyKey';
+        class Target {
+          myMethod(
+            @query(propertyKey, schema)
+            prop: unknown,
+          ) {}
+        }
+        const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+        expect(res.get(0)).to.be.eql({
+          source: RequestDataSource.QUERY,
+          schema: {
+            type: DataType.OBJECT,
+            properties: {
+              [propertyKey]: schema,
+            },
+          },
+          property: propertyKey,
+        });
+      });
+    });
+
+    describe('header', function () {
+      it('sets a given "propertyKey" to the target metadata', function () {
+        class Target {
+          myMethod(
+            @header('myPropertyKey')
+            prop: unknown,
+          ) {}
+        }
+        const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+        expect(res.get(0)).to.be.eql({
+          source: RequestDataSource.HEADERS,
+          schema: {type: DataType.OBJECT},
+          property: 'myPropertyKey',
+        });
+      });
+
+      it('sets a given DataType as property type', function () {
+        const propertyKey = 'myPropertyKey';
+        const propertyType = DataType.STRING;
+        class Target {
+          myMethod(
+            @header(propertyKey, propertyType)
+            prop: unknown,
+          ) {}
+        }
+        const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+        expect(res.get(0)).to.be.eql({
+          source: RequestDataSource.HEADERS,
+          schema: {
+            type: DataType.OBJECT,
+            properties: {
+              [propertyKey]: {
+                type: propertyType,
+              },
+            },
+          },
+          property: propertyKey,
+        });
+      });
+
+      it('sets a given DataSchema as property schema', function () {
+        const schema = {
+          type: DataType.STRING,
+          required: true,
+        };
+        const propertyKey = 'myPropertyKey';
+        class Target {
+          myMethod(
+            @header(propertyKey, schema)
+            prop: unknown,
+          ) {}
+        }
+        const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+        expect(res.get(0)).to.be.eql({
+          source: RequestDataSource.HEADERS,
+          schema: {
+            type: DataType.OBJECT,
+            properties: {
+              [propertyKey]: schema,
+            },
+          },
+          property: propertyKey,
+        });
+      });
+    });
+
+    describe('cookie', function () {
+      it('sets a given "propertyKey" to the target metadata', function () {
+        class Target {
+          myMethod(
+            @cookie('myPropertyKey')
+            prop: unknown,
+          ) {}
+        }
+        const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+        expect(res.get(0)).to.be.eql({
+          source: RequestDataSource.COOKIE,
+          schema: {type: DataType.OBJECT},
+          property: 'myPropertyKey',
+        });
+      });
+
+      it('sets a given DataType as property type', function () {
+        const propertyKey = 'myPropertyKey';
+        const propertyType = DataType.STRING;
+        class Target {
+          myMethod(
+            @cookie(propertyKey, propertyType)
+            prop: unknown,
+          ) {}
+        }
+        const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+        expect(res.get(0)).to.be.eql({
+          source: RequestDataSource.COOKIE,
+          schema: {
+            type: DataType.OBJECT,
+            properties: {
+              [propertyKey]: {
+                type: propertyType,
+              },
+            },
+          },
+          property: propertyKey,
+        });
+      });
+
+      it('sets a given DataSchema as property schema', function () {
+        const schema = {
+          type: DataType.STRING,
+          required: true,
+        };
+        const propertyKey = 'myPropertyKey';
+        class Target {
+          myMethod(
+            @cookie(propertyKey, schema)
+            prop: unknown,
+          ) {}
+        }
+        const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+        expect(res.get(0)).to.be.eql({
+          source: RequestDataSource.COOKIE,
+          schema: {
+            type: DataType.OBJECT,
+            properties: {
+              [propertyKey]: schema,
+            },
+          },
+          property: propertyKey,
+        });
+      });
+    });
+
+    describe('bodyParam', function () {
+      it('sets a given "propertyKey" to the target metadata', function () {
+        class Target {
+          myMethod(
+            @bodyParam('myPropertyKey')
+            prop: unknown,
+          ) {}
+        }
+        const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+        expect(res.get(0)).to.be.eql({
+          source: RequestDataSource.BODY,
+          schema: {type: DataType.OBJECT},
+          property: 'myPropertyKey',
+        });
+      });
+
+      it('sets a given DataType as property type', function () {
+        const propertyKey = 'myPropertyKey';
+        const propertyType = DataType.STRING;
+        class Target {
+          myMethod(
+            @bodyParam(propertyKey, propertyType)
+            prop: unknown,
+          ) {}
+        }
+        const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+        expect(res.get(0)).to.be.eql({
+          source: RequestDataSource.BODY,
+          schema: {
+            type: DataType.OBJECT,
+            properties: {
+              [propertyKey]: {
+                type: propertyType,
+              },
+            },
+          },
+          property: propertyKey,
+        });
+      });
+
+      it('sets a given DataSchema as property schema', function () {
+        const schema = {
+          type: DataType.STRING,
+          required: true,
+        };
+        const propertyKey = 'myPropertyKey';
+        class Target {
+          myMethod(
+            @bodyParam(propertyKey, schema)
+            prop: unknown,
+          ) {}
+        }
+        const res = RequestDataReflector.getMetadata(Target, 'myMethod');
+        expect(res.get(0)).to.be.eql({
+          source: RequestDataSource.BODY,
+          schema: {
+            type: DataType.OBJECT,
+            properties: {
+              [propertyKey]: schema,
+            },
+          },
+          property: propertyKey,
+        });
+      });
+    });
+  });
+});

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

@@ -0,0 +1,106 @@
+import {NoUndef} from '../../types.js';
+import {Prototype} from '../../types.js';
+import {Constructor} from '../../types.js';
+import {DataType} from '@e22m4u/ts-data-schema';
+import {DataSchema} from '@e22m4u/ts-data-schema';
+import {DecoratorTargetType} from '@e22m4u/ts-reflector';
+import {getDecoratorTargetType} from '@e22m4u/ts-reflector';
+import {RequestDataSource} from './request-data-metadata.js';
+import {RequestDataMetadata} from './request-data-metadata.js';
+import {RequestDataReflector} from './request-data-reflector.js';
+
+/**
+ * Request data decorator.
+ *
+ * @param metadata
+ */
+export function requestData<T extends object>(metadata: RequestDataMetadata) {
+  return function (
+    target: Prototype<T>,
+    propertyKey: string,
+    indexOrDescriptor: number,
+  ) {
+    const decoratorType = getDecoratorTargetType(
+      target,
+      propertyKey,
+      indexOrDescriptor,
+    );
+    if (decoratorType !== DecoratorTargetType.INSTANCE_METHOD_PARAMETER)
+      throw new Error(
+        '@requestData decorator is only supported ' +
+          'on an instance method parameter.',
+      );
+    RequestDataReflector.setMetadata(
+      metadata,
+      target.constructor as Constructor<T>,
+      indexOrDescriptor,
+      propertyKey,
+    );
+  };
+}
+
+/**
+ * Create data decorator.
+ *
+ * @param source
+ */
+function createDataDecorator(source: RequestDataSource) {
+  return function () {
+    const schema = {type: DataType.OBJECT};
+    return requestData({schema, source});
+  };
+}
+
+/**
+ * Create property decorator.
+ *
+ * @param source
+ */
+function createPropertyDecorator(source: RequestDataSource) {
+  return function (propertyKey: string, schemaOrType?: DataSchema | DataType) {
+    const properties = {} as NoUndef<DataSchema['properties']>;
+    const rootSchema: DataSchema = {type: DataType.OBJECT};
+    if (typeof schemaOrType === 'object') {
+      properties[propertyKey] = schemaOrType;
+      rootSchema.properties = properties;
+    } else if (typeof schemaOrType === 'string') {
+      properties[propertyKey] = {type: schemaOrType};
+      rootSchema.properties = properties;
+    }
+    return requestData({
+      source: source,
+      schema: rootSchema,
+      property: propertyKey,
+    });
+  };
+}
+
+/**
+ * Decorator aliases.
+ */
+export const params = createDataDecorator(RequestDataSource.PARAMS);
+export const param = createPropertyDecorator(RequestDataSource.PARAMS);
+export const queries = createDataDecorator(RequestDataSource.QUERY);
+export const query = createPropertyDecorator(RequestDataSource.QUERY);
+export const headers = createDataDecorator(RequestDataSource.HEADERS);
+export const header = createPropertyDecorator(RequestDataSource.HEADERS);
+export const cookies = createDataDecorator(RequestDataSource.COOKIE);
+export const cookie = createPropertyDecorator(RequestDataSource.COOKIE);
+export const bodyParam = createPropertyDecorator(RequestDataSource.BODY);
+
+/**
+ * Request body decorator.
+ *
+ * @param schemaOrType
+ */
+export function body(schemaOrType?: DataSchema | DataType) {
+  let schema: DataSchema;
+  if (typeof schemaOrType === 'object') {
+    schema = schemaOrType;
+  } else if (typeof schemaOrType === 'string') {
+    schema = {type: schemaOrType};
+  } else {
+    schema = {type: DataType.ANY};
+  }
+  return requestData({schema, source: RequestDataSource.BODY});
+}

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

@@ -0,0 +1,34 @@
+import {DataSchema} from '@e22m4u/ts-data-schema';
+import {MetadataKey} from '@e22m4u/ts-reflector';
+
+/**
+ * Request data source.
+ */
+export enum RequestDataSource {
+  PARAMS = 'params',
+  QUERY = 'query',
+  HEADERS = 'headers',
+  COOKIE = 'cookie',
+  BODY = 'body',
+}
+
+/**
+ * Request data metadata.
+ */
+export type RequestDataMetadata = {
+  source: RequestDataSource;
+  schema?: DataSchema;
+  property?: string;
+  [option: string]: unknown | undefined;
+};
+
+/**
+ * Request data metadata map.
+ */
+export type RequestDataMetadataMap = Map<number, RequestDataMetadata>;
+
+/**
+ * Request data metadata key.
+ */
+export const REQUEST_DATA_METADATA_KEY =
+  new MetadataKey<RequestDataMetadataMap>('requestDataMetadataKey');

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

@@ -0,0 +1,78 @@
+import {expect} from 'chai';
+import {describe} from 'mocha';
+import {Reflector} from '@e22m4u/ts-reflector';
+import {RequestDataSource} from './request-data-metadata.js';
+import {RequestDataMetadata} from './request-data-metadata.js';
+import {RequestDataReflector} from './request-data-reflector.js';
+import {REQUEST_DATA_METADATA_KEY} from './request-data-metadata.js';
+
+describe('RequestDataReflector', function () {
+  describe('setMetadata', function () {
+    it('sets a given value as target metadata', function () {
+      class Target {}
+      const md1 = {source: RequestDataSource.PARAMS};
+      const md2 = {source: RequestDataSource.QUERY};
+      RequestDataReflector.setMetadata(md1, Target, 0, 'propertyKey');
+      RequestDataReflector.setMetadata(md2, Target, 1, 'propertyKey');
+      const res = Reflector.getOwnMetadata(
+        REQUEST_DATA_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 = {source: RequestDataSource.PARAMS};
+      const md2 = {source: RequestDataSource.QUERY};
+      RequestDataReflector.setMetadata(md1, Target, 0, 'propertyKey');
+      const res1 = Reflector.getOwnMetadata(
+        REQUEST_DATA_METADATA_KEY,
+        Target,
+        'propertyKey',
+      );
+      expect(res1).to.be.instanceof(Map);
+      expect(res1!.get(0)).to.be.eq(md1);
+      RequestDataReflector.setMetadata(md2, Target, 0, 'propertyKey');
+      const res2 = Reflector.getOwnMetadata(
+        REQUEST_DATA_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 = {source: RequestDataSource.PARAMS};
+      const md2 = {source: RequestDataSource.QUERY};
+      const mdMap = new Map<number, RequestDataMetadata>([
+        [0, md1],
+        [1, md2],
+      ]);
+      Reflector.defineMetadata(
+        REQUEST_DATA_METADATA_KEY,
+        mdMap,
+        Target,
+        'propertyKey',
+      );
+      const res = RequestDataReflector.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 = RequestDataReflector.getMetadata(Target, 'propertyKey');
+      expect(res).to.be.instanceof(Map);
+      expect(res).to.be.empty;
+    });
+  });
+});