@avleon/core 0.0.45 → 0.0.48

package/dist/file-storage.test.js

@@ -1,104 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
-const stream_1 = require("stream");
-const file_storage_1 = require("./file-storage");
-const system_exception_1 = require("./exceptions/system-exception");
-const promises_1 = require("stream/promises");
-jest.mock("fs");
-jest.mock("stream/promises", () => ({
-    pipeline: jest.fn((...args) => Promise.resolve()),
-}));
-const mockFs = fs_1.default;
-describe("FileStorage", () => {
-    let fileStorage;
-    const testFile = {
-        type: "file",
-        filename: "test.txt",
-        file: new stream_1.Readable({ read() { } }),
-    };
-    beforeEach(() => {
-        jest.clearAllMocks();
-        fileStorage = new file_storage_1.FileStorage();
-        mockFs.existsSync.mockReturnValue(false);
-        mockFs.createWriteStream.mockReturnValue({});
-        mockFs.createReadStream.mockReturnValue({});
-        mockFs.unlinkSync.mockImplementation(() => { });
-        mockFs.mkdirSync.mockImplementation(() => undefined);
-    });
-    describe("save", () => {
-        it("should save a file successfully", async () => {
-            await expect(fileStorage.save(testFile)).resolves.toEqual(testFile);
-        });
-        it("should throw SystemUseError if file exists and overwrite is false", async () => {
-            mockFs.existsSync.mockReturnValue(true);
-            await expect(fileStorage.save(testFile, { overwrite: false })).rejects.toThrow(system_exception_1.SystemUseError);
-        });
-        it("should throw SystemUseError on pipeline error", async () => {
-            promises_1.pipeline.mockImplementationOnce(() => {
-                throw new Error("Pipeline failed");
-            });
-            await expect(fileStorage.save(testFile)).rejects.toThrow(system_exception_1.SystemUseError);
-        });
-    });
-    describe("remove", () => {
-        it("should remove a file successfully", async () => {
-            mockFs.existsSync.mockReturnValue(true);
-            await expect(fileStorage.remove("test.txt")).resolves.toBeUndefined();
-            expect(mockFs.unlinkSync).toHaveBeenCalled();
-        });
-        it("should throw SystemUseError if file does not exist", async () => {
-            mockFs.existsSync.mockReturnValue(false);
-            await expect(fileStorage.remove("test.txt")).rejects.toThrow(system_exception_1.SystemUseError);
-        });
-    });
-    describe("saveAll", () => {
-        it("should save multiple files successfully", async () => {
-            const files = [
-                { ...testFile, filename: "a.txt" },
-                { ...testFile, filename: "b.txt" },
-            ];
-            await expect(fileStorage.saveAll(files)).resolves.toEqual(files);
-        });
-        it("should throw SystemUseError on error", async () => {
-            promises_1.pipeline.mockImplementationOnce(() => {
-                throw new Error("Pipeline failed");
-            });
-            await expect(fileStorage.saveAll([testFile])).rejects.toThrow(system_exception_1.SystemUseError);
-        });
-    });
-    describe("transform", () => {
-        it("should set transform options and return itself", () => {
-            const options = { resize: { width: 100, height: 100 }, format: "jpeg" };
-            const result = fileStorage.transform(options);
-            expect(result).toBe(fileStorage);
-            // @ts-ignore
-            expect(fileStorage.transformOptions).toEqual(options);
-        });
-    });
-    // describe("processImage", () => {
-    //     it("should throw InternalErrorException if sharp is not installed", async () => {
-    //         jest.resetModules();
-    //         const fileStorage = new (require("./file-storage").FileStorage)();
-    //         fileStorage.transform({ format: "jpeg" });
-    //         await expect(
-    //             fileStorage["processImage"](new Readable({ read() {} }), "output.jpg"),
-    //         ).rejects.toThrow(InternalErrorException);
-    //     });
-    // });
-    describe("ensureDirectoryExists", () => {
-        it("should create directory if not exists", async () => {
-            mockFs.existsSync.mockReturnValue(false);
-            await fileStorage["ensureDirectoryExists"]("public/test.txt");
-            expect(mockFs.mkdirSync).toHaveBeenCalled();
-        });
-        it("should not create directory if exists", async () => {
-            mockFs.existsSync.mockReturnValue(true);
-            await fileStorage["ensureDirectoryExists"]("public/test.txt");
-            expect(mockFs.mkdirSync).not.toHaveBeenCalled();
-        });
-    });
-});

package/dist/helpers.d.ts

@@ -1,44 +0,0 @@
-export declare const uuid: `${string}-${string}-${string}-${string}-${string}`;
-export declare function inject<T>(cls: new (...args: any[]) => T): T;
-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 declare const isClassValidator: (target: Constructor) => boolean;
-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 getDataType(expectedType: any): any;
-export declare function isValidType(value: any, expectedType: any): boolean;
-export declare function isValidJsonString(value: string): object | boolean;
-export declare function jsonToJs(value: string): any;
-export declare function jsonToInstance(value: string, instance: Constructor): any;
-export declare function transformObjectByInstanceToObject(instance: Constructor, value: object): Record<string, any>;
-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 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.
- * Supports:
- *  - filter[name]=john
- *  - filter[user][age]=25
- *  - filter[tags][]=a&filter[tags][]=b
- *  - filter=name&filter=sorna
- */
-export declare function normalizeQueryDeep(query: Record<string, any>): Record<string, any>;
-export {};

package/dist/helpers.js

@@ -1,419 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isClassValidatorClass = exports.getLineNumber = exports.isClassValidator = exports.uuid = void 0;
-exports.inject = inject;
-exports.isConstructor = isConstructor;
-exports.formatUrl = formatUrl;
-exports.parsedPath = parsedPath;
-exports.normalizePath = normalizePath;
-exports.extrctParamFromUrl = extrctParamFromUrl;
-exports.findDuplicates = findDuplicates;
-exports.getDataType = getDataType;
-exports.isValidType = isValidType;
-exports.isValidJsonString = isValidJsonString;
-exports.jsonToJs = jsonToJs;
-exports.jsonToInstance = jsonToInstance;
-exports.transformObjectByInstanceToObject = transformObjectByInstanceToObject;
-exports.validateObjectByInstance = validateObjectByInstance;
-exports.validateRequestBody = validateRequestBody;
-exports.pick = pick;
-exports.exclude = exclude;
-exports.autoCast = autoCast;
-exports.normalizeQueryDeep = normalizeQueryDeep;
-/**
- * @copyright 2024
- * @author Tareq Hossain
- * @email xtrinsic96@gmail.com
- * @url https://github.com/xtareq
- */
-const class_transformer_1 = require("class-transformer");
-const exceptions_1 = require("./exceptions");
-const fs_1 = __importDefault(require("fs"));
-const container_1 = __importDefault(require("./container"));
-const system_exception_1 = require("./exceptions/system-exception");
-const crypto_1 = __importDefault(require("crypto"));
-const class_validator_1 = require("class-validator");
-exports.uuid = crypto_1.default.randomUUID();
-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.");
-    }
-}
-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 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;
-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 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;
-    }
-}
-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;
-    }
-}
-function transformObjectByInstanceToObject(instance, value) {
-    return (0, class_transformer_1.instanceToPlain)((0, class_transformer_1.plainToInstance)(instance, value), {
-        excludeExtraneousValues: true,
-        exposeUnsetFields: true,
-    });
-}
-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 };
-}
-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.
- * Supports:
- *  - filter[name]=john
- *  - filter[user][age]=25
- *  - filter[tags][]=a&filter[tags][]=b
- *  - filter=name&filter=sorna
- */
-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;
-}

package/dist/helpers.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/helpers.test.js

@@ -1,95 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const helpers_1 = require("./helpers");
-describe("helpers.ts", () => {
-    describe("formatUrl", () => {
-        it("should format URLs correctly", () => {
-            expect((0, helpers_1.formatUrl)("test")).toBe("/test");
-            expect((0, helpers_1.formatUrl)("/test")).toBe("/test");
-            expect((0, helpers_1.formatUrl)("///test//")).toBe("/test");
-            expect(() => (0, helpers_1.formatUrl)(123)).toThrow();
-        });
-    });
-    describe("parsedPath", () => {
-        it("should ensure path starts with /", () => {
-            expect((0, helpers_1.parsedPath)("abc")).toBe("/abc");
-            expect((0, helpers_1.parsedPath)("/abc")).toBe("/abc");
-        });
-    });
-    describe("findDuplicates", () => {
-        it("should find duplicates in array", () => {
-            expect((0, helpers_1.findDuplicates)(["a", "b", "a", "c", "b"])).toEqual(["a", "b"]);
-            expect((0, helpers_1.findDuplicates)(["a", "b", "c"])).toEqual([]);
-        });
-    });
-    describe("getDataType", () => {
-        it("should return correct data type", () => {
-            expect((0, helpers_1.getDataType)(String)).toBe("string");
-            expect((0, helpers_1.getDataType)(Number)).toBe("number");
-            expect((0, helpers_1.getDataType)(Boolean)).toBe("boolean");
-            expect((0, helpers_1.getDataType)(Object)).toBe("object");
-            expect((0, helpers_1.getDataType)(Array)).toBe(Array);
-        });
-    });
-    describe("isValidType", () => {
-        it("should validate types correctly", () => {
-            expect((0, helpers_1.isValidType)("abc", String)).toBe(true);
-            expect((0, helpers_1.isValidType)(123, Number)).toBe(true);
-            expect((0, helpers_1.isValidType)(true, Boolean)).toBe(true);
-            expect((0, helpers_1.isValidType)({}, Object)).toBe(true);
-            expect((0, helpers_1.isValidType)(undefined, String)).toBe(true);
-            expect((0, helpers_1.isValidType)(null, Number)).toBe(true);
-            expect((0, helpers_1.isValidType)("123", Number)).toBe(true);
-            expect((0, helpers_1.isValidType)("abc", Number)).toBe(false);
-        });
-    });
-    describe("isValidJsonString", () => {
-        it("should validate JSON strings", () => {
-            expect((0, helpers_1.isValidJsonString)('{"a":1}')).toEqual({ a: 1 });
-            expect((0, helpers_1.isValidJsonString)("not json")).toBe(false);
-        });
-    });
-    describe("jsonToJs", () => {
-        it("should parse JSON to JS object", () => {
-            expect((0, helpers_1.jsonToJs)('{"a":1}')).toEqual({ a: 1 });
-            expect((0, helpers_1.jsonToJs)("bad json")).toBe(false);
-        });
-    });
-    // describe("normalizePath", () => {
-    //     it("should normalize paths", () => {
-    //         expect(normalizePath("api", "v1")).toBe("/api/v1");
-    //         expect(normalizePath("/", "/")).toBe("/");
-    //         expect(normalizePath("api/", "/v1/")).toBe("/api/v1");
-    //     });
-    // });
-    describe("extrctParamFromUrl", () => {
-        it("should extract params from URL", () => {
-            expect((0, helpers_1.extrctParamFromUrl)("/user/:id/:name")).toEqual([
-                { key: "id", required: true },
-                { key: "name", required: true },
-            ]);
-            expect((0, helpers_1.extrctParamFromUrl)("/user/?:id")).toEqual([
-                { key: "id", required: false },
-            ]);
-        });
-    });
-    describe("pick", () => {
-        it("should pick properties from object", () => {
-            const obj = { a: 1, b: { c: 2, d: 3 }, e: 4 };
-            expect((0, helpers_1.pick)(obj, ["a"])).toEqual({ a: 1 });
-            expect((0, helpers_1.pick)(obj, ["b.c"])).toEqual({ b: { c: 2 } });
-            expect((0, helpers_1.pick)(obj, ["b.d", "e"])).toEqual({ b: { d: 3 }, e: 4 });
-        });
-    });
-    describe("exclude", () => {
-        it("should exclude properties from object", () => {
-            const obj = { a: 1, b: { c: 2, d: 3 }, e: 4 };
-            expect((0, helpers_1.exclude)(obj, ["a"])).toEqual({ b: { c: 2, d: 3 }, e: 4 });
-            expect((0, helpers_1.exclude)(obj, ["b.c"])).toEqual({ a: 1, b: { d: 3 }, e: 4 });
-            expect((0, helpers_1.exclude)([obj, obj], ["e"])).toEqual([
-                { a: 1, b: { c: 2, d: 3 } },
-                { a: 1, b: { c: 2, d: 3 } },
-            ]);
-        });
-    });
-});