@avleon/core 0.0.20 → 0.0.25

package/src/utils/optional-require.ts

@@ -0,0 +1,50 @@
+
+export function optionalRequire<T = any>(
+    moduleName: string,
+    options: {
+      failOnMissing?: boolean;
+      customMessage?: string;
+    } = {},
+  ): T | undefined {
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      return require(moduleName);
+    } catch (err: any) {
+      if (err.code === "MODULE_NOT_FOUND" && err.message.includes(moduleName)) {
+        if (options.failOnMissing) {
+          throw new Error(
+            options.customMessage ||
+              `Optional dependency "${moduleName}" is not installed.\nInstall it with:\n\n  npm install ${moduleName}`
+          );
+        }
+        return undefined;
+      }
+      throw err;
+    }
+  }
+
+  export async function optionalImport<T = any>(
+    moduleName: string,
+    options: {
+      failOnMissing?: boolean;
+      customMessage?: string;
+    } = {},
+  ): Promise<T | undefined> {
+    try {
+      const mod = await import(moduleName);
+      return mod as T;
+    } catch (err: any) {
+      if ((err.code === "ERR_MODULE_NOT_FOUND" || err.code === "MODULE_NOT_FOUND") &&
+          err.message.includes(moduleName)) {
+        if (options.failOnMissing) {
+          throw new Error(
+            options.customMessage ||
+              `Optional dependency "${moduleName}" is not installed.\nInstall it with:\n\n  npm install ${moduleName}`
+          );
+        }
+        return undefined;
+      }
+      throw err;
+    }
+  }
+  

package/src/validation.ts

@@ -0,0 +1,156 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+
+import { BadRequestException } from "./exceptions";
+
+class PValidationRule<T> {
+  name: string;
+  type: T;
+  message?: string;
+
+  constructor(name: string, type: T, message?: string) {
+    this.name = name;
+    this.type = type;
+    this.message = message;
+  }
+}
+
+type BaseRule = {
+  required?: boolean;
+  optional?: boolean;
+  message?: string;
+};
+
+type StringRule = BaseRule & {
+  type: "string";
+};
+
+type NumberRule = BaseRule & {
+  type: "number";
+  min?: number;
+  max?: number;
+  exact?: number;
+};
+
+type BooleanRule = BaseRule & {
+  type: "boolean";
+};
+
+export type ValidationRule = StringRule | NumberRule | BooleanRule;
+
+export type ValidationProps = {
+  [key: string]: ValidationRule;
+};
+
+export type ValidateOptons = {
+  location?:'header' | 'queryparam' | 'param' | 'body' | 'custom'
+}
+
+class Validator {
+  private rules: PValidationRule<any>[] = [];
+  private options:ValidateOptons = {}
+
+  constructor(obj: ValidationProps, options?:ValidateOptons) {
+    this.init(obj);
+    if (options) {
+      this.options = options;
+    }
+  }
+
+  private init(obj: ValidationProps) {
+    Object.keys(obj).forEach((key) => {
+      const rule = obj[key];
+      this.rules.push(
+        new PValidationRule<typeof rule.type>(key, rule.type, rule.message),
+      );
+    });
+  }
+
+  validate(obj: any | Array<any>, options?:ValidateOptons) {
+    const erors: any[] = [];
+
+    this.rules.forEach((k) => {
+      const r = Object.keys(obj).find((key) => key == k.name);
+      let messages: any = [];
+      if (!r || obj[r] == undefined || obj[r] == "") {
+        messages.push({
+          constraint: "required",
+          message: k.name + " is required",
+        });
+      }
+
+      if (k.type == "string" && typeof obj[k.name] != "string") {
+        messages.push({
+          constraint: "type",
+          message: `${k.name} must be type ${k.type}`,
+        });
+      }
+      if (k.type == "number" && !parseInt(obj[k.name])) {
+        messages.push({
+          constraint: "type",
+          message: `${k.name} must be type ${k.type}`,
+        });
+      }
+
+      if (k.type == "number") {
+        obj[k.name] = parseInt(obj[k.name]);
+      }
+      if (k.type == "boolean" && !isBool(obj[k.name])) {
+        messages.push({
+          constraint: "type",
+          message: `${k.name} must be type ${k.type}`,
+        });
+      }
+      if (k.type == "boolean") {
+        obj[k.name] = parseBoolean(obj[k.name]);
+      }
+      if (messages.length > 0) {
+        erors.push({
+          path: k.name,
+          ...(this.options.location ? { location: this.options.location } :{}),
+          constraints: messages,
+        });
+      }
+    });
+
+    return [erors, obj];
+  }
+}
+
+const isBool = (val: any) => {
+  if (typeof val == "boolean") return true;
+  if (parseInt(val) == 0 || parseInt(val) == 1) return true;
+  if (val == "true" || val == "false") return true;
+
+  return false;
+};
+
+const parseBoolean = (val: any): boolean => {
+  if (typeof val === "boolean") return val;
+
+  // if (typeof val === "number") {
+  //   return val !== 0; // Common convention: 0 → false, any other number → true
+  // }
+
+  if (parseInt(val) == 1) return true;
+  if (typeof val === "string") {
+    const normalized = val.trim().toLowerCase();
+    return normalized === "true";
+  }
+  return false; // Default for unsupported types (null, undefined, objects, etc.)
+};
+
+export function validateOrThrow<T extends {}>(obj: T, rules: ValidationProps, options?:ValidateOptons) {
+  const valid = new Validator(rules, options);
+  const errors = valid.validate(obj);
+
+  if (errors[0].length > 0) {
+    throw new BadRequestException(errors[0]);
+  }
+
+  return errors[1];
+}

package/src/validator-extend.ts

@@ -0,0 +1,25 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+export function IsArrayNotEmpty(validationOptions?: any) {
+  const { registerDecorator, ValidationArguments } = require("class-validator");
+  return function (object: Object, propertyName: string) {
+    registerDecorator({
+      name: "isArrayWithAtLeastOneElement",
+      target: object.constructor,
+      propertyName: propertyName,
+      options: validationOptions,
+      validator: {
+        validate(value: any, args: any) {
+          return Array.isArray(value) && value.length > 0;
+        },
+        defaultMessage(args: any) {
+          return `${args.property} must contain at least one item.`;
+        },
+      },
+    });
+  };
+}

package/dist/classToOpenapi.js

@@ -1 +0,0 @@
-"use strict";

package/dist/render.d.ts

@@ -1 +0,0 @@
-export declare function render(viewPath: string, data: any): void;

package/dist/render.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.render = render;
-function render(viewPath, data) {
-    // complie view
-    // razor
-    // export
-}

package/jest.config.ts

@@ -1,9 +0,0 @@
-import type { Config } from 'jest'
-
-const config: Config = {
-  preset: "ts-jest",
-  testEnvironment: "node",
-}
-
-
-export default config;

package/tsconfig.json

@@ -1,25 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2017",
-    "module": "CommonJS",
-    "strict": true,
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
-    "outDir": "./dist",
-    "declaration": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "moduleResolution": "node",
-    "allowSyntheticDefaultImports": true,
-    "forceConsistentCasingInFileNames": true
-  },
-  "include": [
-    "src/**/*"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist",
-    "scripts",
-    "jest.config.ts"
-  ]
-}