@avleon/core 0.0.44 → 0.0.46

package/dist/utils/common-utils.d.ts

@@ -0,0 +1,17 @@
+export declare const uuid: `${string}-${string}-${string}-${string}-${string}`;
+export type Constructor<T = any> = new (...args: any[]) => T;
+export declare function isConstructor(func: any): boolean;
+export declare function formatUrl(path: string): string;
+export declare function parsedPath(ipath: string): string;
+export interface MatchLocation {
+    line: number;
+    column: number;
+}
+export declare const getLineNumber: (filePath: string, rpath: string | RegExp) => MatchLocation[] | null;
+export declare function normalizePath(base?: string, subPath?: string): string;
+export declare function extrctParamFromUrl(url: string): {
+    key: string;
+    required: boolean;
+}[];
+export declare function findDuplicates(arr: string[]): string[];
+export declare function sleep(ms: number): Promise<unknown>;

package/dist/utils/common-utils.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLineNumber = exports.uuid = void 0;
+exports.isConstructor = isConstructor;
+exports.formatUrl = formatUrl;
+exports.parsedPath = parsedPath;
+exports.normalizePath = normalizePath;
+exports.extrctParamFromUrl = extrctParamFromUrl;
+exports.findDuplicates = findDuplicates;
+exports.sleep = sleep;
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+const fs_1 = __importDefault(require("fs"));
+const crypto_1 = __importDefault(require("crypto"));
+exports.uuid = crypto_1.default.randomUUID();
+function isConstructor(func) {
+    if (typeof func !== "function") {
+        return false;
+    }
+    if (func === Function.prototype.bind || func instanceof RegExp) {
+        return false;
+    }
+    if (func.prototype && typeof func.prototype === "object") {
+        return true;
+    }
+    try {
+        const instance = new func();
+        return typeof instance === "object";
+    }
+    catch (e) {
+        return false;
+    }
+}
+function formatUrl(path) {
+    if (typeof path !== "string") {
+        throw new Error("The path must be a string");
+    }
+    path = path.trim();
+    if (!path.startsWith("/")) {
+        path = "/" + path;
+    }
+    path = path.replace(/\/\/+/g, "/");
+    if (path.endsWith("/")) {
+        path = path.slice(0, -1);
+    }
+    return path;
+}
+function parsedPath(ipath) {
+    return !ipath.startsWith("/") ? "/" + ipath : ipath;
+}
+const getLineNumber = (filePath, rpath) => {
+    var _a;
+    let numbers = [];
+    try {
+        const fileContent = fs_1.default.readFileSync(filePath, "utf8");
+        const lines = fileContent.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+            const match = lines[i].match(rpath);
+            if (match) {
+                console.log(match);
+                numbers.push({
+                    line: i + 1,
+                    column: (_a = match.index) !== null && _a !== void 0 ? _a : 0,
+                });
+            }
+        }
+        return numbers;
+    }
+    catch (error) {
+        return numbers;
+    }
+};
+exports.getLineNumber = getLineNumber;
+function normalizePath(base = "/", subPath = "/") {
+    return `/${base}/${subPath}`.replace(/\/+/g, "/").replace(/\/$/, "");
+}
+function extrctParamFromUrl(url) {
+    const splitPart = url
+        .split("/")
+        .filter((x) => x.startsWith(":") || x.startsWith("?:"));
+    return splitPart.map((f) => ({
+        key: f.replace(/(\?|:)/g, ""),
+        required: !f.startsWith("?:"),
+    }));
+}
+function findDuplicates(arr) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const str of arr) {
+        if (seen.has(str)) {
+            duplicates.add(str);
+        }
+        else {
+            seen.add(str);
+        }
+    }
+    return Array.from(duplicates);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/utils/di-utils.d.ts

@@ -0,0 +1 @@
+export declare function inject<T>(cls: new (...args: any[]) => T): T;

package/dist/utils/di-utils.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inject = inject;
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+const container_1 = __importDefault(require("../container"));
+const system_exception_1 = require("../exceptions/system-exception");
+function inject(cls) {
+    try {
+        return container_1.default.get(cls);
+    }
+    catch (error) {
+        throw new system_exception_1.SystemUseError("Not a project class. Maybe you wanna register it first.");
+    }
+}

package/dist/utils/hash.d.ts

@@ -1,4 +1,2 @@
-export declare const hashPasswordSync: (password: string) => string;
-export declare const matchPasswordSync: (password: string, hash: string) => boolean;
 export declare const hashPassword: (password: string) => Promise<string>;
 export declare const matchPassword: (password: string, hash: string) => Promise<boolean>;

package/dist/utils/hash.js

@@ -3,12 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.matchPassword = exports.hashPassword = exports.matchPasswordSync = exports.hashPasswordSync = void 0;
+exports.matchPassword = exports.hashPassword = void 0;
 const bcryptjs_1 = __importDefault(require("bcryptjs"));
-const hashPasswordSync = (password) => bcryptjs_1.default.hashSync(password, 12);
-exports.hashPasswordSync = hashPasswordSync;
-const matchPasswordSync = (password, hash) => bcryptjs_1.default.compareSync(password, hash);
-exports.matchPasswordSync = matchPasswordSync;
 const hashPassword = (password) => bcryptjs_1.default.hash(password, 12);
 exports.hashPassword = hashPassword;
 const matchPassword = (password, hash) => bcryptjs_1.default.compare(password, hash);

package/dist/utils/object-utils.d.ts

@@ -0,0 +1,11 @@
+import { Constructor } from "./common-utils";
+export declare function pick<T extends object>(obj: T, paths: string[]): Partial<T>;
+export declare function exclude<T extends object>(obj: T | T[], paths: string[]): Partial<T> | Partial<T>[];
+export declare function autoCast(value: any, typeHint?: any, schema?: any): any;
+/**
+ * Deeply normalizes query strings into nested JS objects.
+ */
+export declare function normalizeQueryDeep(query: Record<string, any>): Record<string, any>;
+export declare function transformObjectByInstanceToObject(instance: Constructor, value: object): Record<string, any>;
+export declare function jsonToJs(value: string): any;
+export declare function jsonToInstance(value: string, instance: Constructor): any;

package/dist/utils/object-utils.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pick = pick;
+exports.exclude = exclude;
+exports.autoCast = autoCast;
+exports.normalizeQueryDeep = normalizeQueryDeep;
+exports.transformObjectByInstanceToObject = transformObjectByInstanceToObject;
+exports.jsonToJs = jsonToJs;
+exports.jsonToInstance = jsonToInstance;
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+const class_transformer_1 = require("class-transformer");
+function pick(obj, paths) {
+    const result = {};
+    for (const path of paths) {
+        const keys = path.split(".");
+        let source = obj;
+        let target = result;
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (!(key in source))
+                break;
+            if (i === keys.length - 1) {
+                target[key] = source[key];
+            }
+            else {
+                source = source[key];
+                target[key] = target[key] || {};
+                target = target[key];
+            }
+        }
+    }
+    return result;
+}
+function exclude(obj, paths) {
+    if (Array.isArray(obj)) {
+        return obj.map((item) => exclude(item, paths));
+    }
+    const clone = structuredClone(obj); // Or use lodash.cloneDeep
+    for (const path of paths) {
+        const keys = path.split(".");
+        let target = clone;
+        for (let i = 0; i < keys.length - 1; i++) {
+            if (!(keys[i] in target))
+                break;
+            target = target[keys[i]];
+        }
+        target === null || target === void 0 ? true : delete target[keys[keys.length - 1]];
+    }
+    return clone;
+}
+function autoCast(value, typeHint, schema) {
+    var _a, _b;
+    if (value === null || value === undefined)
+        return value;
+    if (Array.isArray(value)) {
+        const elementType = Array.isArray(typeHint) ? typeHint[0] : undefined;
+        return value.map((v) => autoCast(v, elementType));
+    }
+    if (typeof value === "object" && !(value instanceof Date)) {
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+            let fieldType = undefined;
+            if ((_b = (_a = schema === null || schema === void 0 ? void 0 : schema.properties) === null || _a === void 0 ? void 0 : _a[key]) === null || _b === void 0 ? void 0 : _b.type) {
+                const t = schema.properties[key].type;
+                fieldType =
+                    t === "integer" || t === "number"
+                        ? Number
+                        : t === "boolean"
+                            ? Boolean
+                            : t === "array"
+                                ? Array
+                                : t === "object"
+                                    ? Object
+                                    : String;
+            }
+            result[key] = autoCast(val, fieldType);
+        }
+        return result;
+    }
+    if (typeof value !== "string")
+        return value;
+    const trimmed = value.trim();
+    if (typeHint === Boolean || trimmed.toLowerCase() === "true")
+        return true;
+    if (trimmed.toLowerCase() === "false")
+        return false;
+    if (typeHint === Number || (!isNaN(Number(trimmed)) && trimmed !== "")) {
+        const n = Number(trimmed);
+        if (!isNaN(n))
+            return n;
+    }
+    if ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+        (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            return autoCast(parsed, typeHint, schema);
+        }
+        catch (_c) {
+            return trimmed;
+        }
+    }
+    if (typeHint === Date ||
+        /^\d{4}-\d{2}-\d{2}([Tt]\d{2}:\d{2})?/.test(trimmed)) {
+        const d = new Date(trimmed);
+        if (!isNaN(d.getTime()))
+            return d;
+    }
+    return trimmed;
+}
+/**
+ * Deeply normalizes query strings into nested JS objects.
+ */
+function normalizeQueryDeep(query) {
+    const result = {};
+    const setDeep = (obj, path, value) => {
+        let current = obj;
+        for (let i = 0; i < path.length; i++) {
+            const key = path[i];
+            const nextKey = path[i + 1];
+            if (i === path.length - 1) {
+                if (key === "") {
+                    if (!Array.isArray(current))
+                        current = [];
+                    current.push(value);
+                }
+                else if (Array.isArray(current[key])) {
+                    current[key].push(value);
+                }
+                else if (current[key] !== undefined) {
+                    current[key] = [current[key], value];
+                }
+                else {
+                    current[key] = value;
+                }
+            }
+            else {
+                if (!current[key]) {
+                    current[key] = nextKey === "" || /^\d+$/.test(nextKey) ? [] : {};
+                }
+                current = current[key];
+            }
+        }
+    };
+    for (const [rawKey, rawValue] of Object.entries(query)) {
+        const path = [];
+        const regex = /([^\[\]]+)|(\[\])/g;
+        let match;
+        while ((match = regex.exec(rawKey)) !== null) {
+            if (match[1])
+                path.push(match[1]);
+            else if (match[2])
+                path.push("");
+        }
+        if (path.length === 0) {
+            if (result[rawKey]) {
+                if (Array.isArray(result[rawKey]))
+                    result[rawKey].push(rawValue);
+                else
+                    result[rawKey] = [result[rawKey], rawValue];
+            }
+            else {
+                result[rawKey] = rawValue;
+            }
+        }
+        else {
+            setDeep(result, path, rawValue);
+        }
+    }
+    return result;
+}
+function transformObjectByInstanceToObject(instance, value) {
+    return (0, class_transformer_1.instanceToPlain)((0, class_transformer_1.plainToInstance)(instance, value), {
+        excludeExtraneousValues: true,
+        exposeUnsetFields: true,
+    });
+}
+function jsonToJs(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch (err) {
+        return false;
+    }
+}
+function jsonToInstance(value, instance) {
+    try {
+        const parsedValue = JSON.parse(value);
+        return (0, class_transformer_1.plainToInstance)(instance, parsedValue);
+    }
+    catch (err) {
+        return false;
+    }
+}

package/dist/utils/validation-utils.d.ts

@@ -0,0 +1,13 @@
+import { Constructor } from "./common-utils";
+export declare const isClassValidator: (target: Constructor) => boolean;
+export declare function getDataType(expectedType: any): any;
+export declare function isValidType(value: any, expectedType: any): boolean;
+export declare function isValidJsonString(value: string): object | boolean;
+export declare const isClassValidatorClass: (target: Constructor) => boolean;
+export declare function validateObjectByInstance(target: Constructor, value?: object, options?: "object" | "array"): Promise<any>;
+type ValidationError = {
+    count: number;
+    errors: any;
+};
+export declare function validateRequestBody(target: Constructor, value: object, options?: "object" | "array"): ValidationError;
+export {};

package/dist/utils/validation-utils.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isClassValidatorClass = exports.isClassValidator = void 0;
+exports.getDataType = getDataType;
+exports.isValidType = isValidType;
+exports.isValidJsonString = isValidJsonString;
+exports.validateObjectByInstance = validateObjectByInstance;
+exports.validateRequestBody = validateRequestBody;
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+const class_validator_1 = require("class-validator");
+const exceptions_1 = require("../exceptions"); // Need to check path relative to utils
+const class_transformer_1 = require("class-transformer");
+const isClassValidator = (target) => {
+    try {
+        const clsval = require("class-validator");
+        const result = (0, class_validator_1.getMetadataStorage)().getTargetValidationMetadatas(target, "", false, false);
+        return result.length > 0;
+    }
+    catch (err) {
+        console.log(err);
+        return false;
+    }
+};
+exports.isClassValidator = isClassValidator;
+function getDataType(expectedType) {
+    switch (expectedType.name) {
+        case "Object":
+            if (Array.isArray(expectedType)) {
+                return "array";
+            }
+            return "object";
+        case "String":
+            return "string";
+        case "Number":
+            return "number";
+        case "Boolean":
+            return "boolean";
+        default:
+            return expectedType;
+    }
+}
+function isValidType(value, expectedType) {
+    if (value === undefined || value === null)
+        return true;
+    switch (expectedType.name) {
+        case "String":
+            return typeof value === "string";
+        case "Number":
+            return typeof value === "number" || !isNaN(Number(value));
+        case "Boolean":
+            return typeof value === "boolean";
+        default:
+            return value instanceof expectedType;
+    }
+}
+function isValidJsonString(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch (err) {
+        return false;
+    }
+}
+const isClassValidatorClass = (target) => {
+    try {
+        const clsval = require("class-validator");
+        const result = clsval
+            .getMetadataStorage()
+            .getTargetValidationMetadatas(target, undefined, false, false);
+        return result.length > 0;
+    }
+    catch (err) {
+        return false;
+    }
+};
+exports.isClassValidatorClass = isClassValidatorClass;
+async function validateObjectByInstance(target, value = {}, options = "array") {
+    try {
+        const { validateOrReject } = require("class-validator");
+        const { plainToInstance } = require("class-transformer");
+        await validateOrReject(plainToInstance(target, value));
+    }
+    catch (error) {
+        if (typeof error == "object" && Array.isArray(error)) {
+            const errors = options == "object"
+                ? error.reduce((acc, x) => {
+                    //acc[x.property] = Object.values(x.constraints);
+                    acc[x.property] = x.constraints;
+                    return acc;
+                }, {})
+                : error.map((x) => ({
+                    path: x.property,
+                    constraints: x.constraints,
+                }));
+            return errors;
+        }
+        else {
+            throw new exceptions_1.InternalErrorException("Can't validate object");
+        }
+    }
+}
+function validateRequestBody(target, value, options = "array") {
+    if (!(0, exports.isClassValidatorClass)(target))
+        return { count: 0, errors: {} };
+    const error = (0, class_validator_1.validateSync)((0, class_transformer_1.plainToInstance)(target, value ? value : {}));
+    const errors = options == "object"
+        ? error.reduce((acc, x) => {
+            //acc[x.property] = Object.values(x.constraints);
+            acc[x.property] = x.constraints;
+            return acc;
+        }, {})
+        : error.map((x) => ({ path: x.property, constraints: x.constraints }));
+    return { count: error.length, errors };
+}

package/dist/validation.js

@@ -90,16 +90,13 @@ const isBool = (val) => {
 const parseBoolean = (val) => {
     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.)
+    return false;
 };
 function validateOrThrow(obj, rules, options) {
     const valid = new Validator(rules, options);

package/dist/websocket.d.ts

@@ -1,3 +1,6 @@
+import { Server } from "socket.io";
+import { Token } from "typedi";
+export declare const SocketIoServer: Token<Server<import("socket.io").DefaultEventsMap, import("socket.io").DefaultEventsMap, import("socket.io").DefaultEventsMap, any>>;
 export declare class AvleonSocketIo {
     private io?;
     sendToAll(): void;

package/dist/websocket.js

@@ -6,8 +6,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AvleonSocketIo = void 0;
+exports.AvleonSocketIo = exports.SocketIoServer = void 0;
 const typedi_1 = require("typedi");
+exports.SocketIoServer = new typedi_1.Token("SocketIoServer");
 let AvleonSocketIo = class AvleonSocketIo {
     sendToAll() { }
     sendOnly() { }