quantum-flow 1.0.1

package/src/utils/validate.ts

@@ -0,0 +1,53 @@
+import { plainToInstance } from 'class-transformer';
+import { validate as Validate, ValidationError } from 'class-validator';
+
+export async function validate(dtoClass: any, data: any) {
+  if (!dtoClass) {
+    return data;
+  }
+
+  try {
+    if (typeof dtoClass.from === 'function') {
+      return dtoClass.from(data);
+    }
+
+    if (typeof dtoClass === 'function') {
+      const instance = plainToInstance(dtoClass, data);
+      const errors = await Validate(instance);
+
+      if (errors.length > 0) {
+        const formattedErrors = formatValidationErrors(errors);
+
+        throw {
+          status: 400,
+          message: 'Validation failed',
+          errors: formattedErrors,
+        };
+      }
+
+      return instance;
+    }
+
+    return data;
+  } catch (error) {
+    throw error;
+  }
+}
+
+function formatValidationErrors(errors: ValidationError[]): any[] {
+  return errors.map((error) => {
+    const constraints = error.constraints || {};
+
+    const children =
+      error.children && error.children.length > 0
+        ? formatValidationErrors(error.children)
+        : undefined;
+
+    return {
+      property: error.property,
+      value: error.value,
+      constraints: Object.values(constraints),
+      children,
+    };
+  });
+}

package/src/validators/Validate.ts

@@ -0,0 +1,48 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { validate } from 'class-validator';
+
+type ToValidate = 'query' | 'body' | 'params' | 'headers';
+
+export function Validate(param: ToValidate, dtoClass: any) {
+  return function (target: any, propertyKey?: string, descriptor?: PropertyDescriptor): void {
+    // METHOD DECORATOR
+    if (descriptor) {
+      wrapMethod(descriptor, param, dtoClass);
+      return;
+    }
+
+    // CLASS DECORATOR
+    const prototype = target.prototype;
+
+    Object.getOwnPropertyNames(prototype).forEach((method) => {
+      if (method === 'constructor') return;
+
+      const desc = Object.getOwnPropertyDescriptor(prototype, method);
+      if (!desc || typeof desc.value !== 'function') return;
+
+      wrapMethod(desc, param, dtoClass);
+      Object.defineProperty(prototype, method, desc);
+    });
+  };
+}
+
+function wrapMethod(descriptor: PropertyDescriptor, param: any, dtoClass: any) {
+  const originalMethod = descriptor.value;
+
+  descriptor.value = async function (...args: any[]) {
+    const value = args[0][param];
+    const instance = new dtoClass();
+
+    Object.entries(value || {}).forEach(([key, val]) => {
+      instance[key] = val;
+    });
+
+    const errors = await validate(instance, { whitelist: true });
+
+    if (errors.length) {
+      throw { status: 422, message: 'Validation failed', data: errors };
+    }
+
+    return originalMethod.apply(this, args);
+  };
+}

package/src/validators/index.ts

@@ -0,0 +1 @@
+export * from './Validate';

package/tsconfig.json

@@ -0,0 +1,51 @@
+{
+  "compilerOptions": {
+    "moduleResolution": "nodenext",
+    "module": "nodenext",
+    "target": "es2022",
+    "types": [
+      "node"
+    ],
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "strictPropertyInitialization": false,
+    "typeRoots": [
+      "./node_modules/@types"
+    ],
+    "paths": {
+      "@controllers": [
+        "./src/controllers/index.ts"
+      ],
+      "@utils": [
+        "./src/utils/index.ts"
+      ],
+      "@types": [
+        "./src/types/index.ts"
+      ],
+      "@validators": [
+        "./src/validators/index.ts"
+      ],
+      "@constants": [
+        "./src/constants.ts"
+      ]
+    },
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "testing",
+    "./testing",
+    "**/*.test.ts",
+    "**/*.spec.ts",
+    "examples"
+  ]
+}