@avleon/core 0.0.45 → 0.0.46

package/dist/core/types.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+import { FastifyRequest, FastifyReply } from "fastify";
+import { MultipartFile } from "../multipart";
+import { OpenApiUiOptions } from "../openapi";
+import { IAvleonApplication, AvleonApplicationOptions, CorsOptions, GlobalOptions, AutoControllerOptions, TestApplication, TestResponse } from "../interfaces/avleon-application";
+export { IAvleonApplication, AvleonApplicationOptions, CorsOptions, GlobalOptions, AutoControllerOptions, TestApplication, TestResponse };
+export interface IRequest extends Omit<FastifyRequest, "files" | "formData" | "file" | "saveRequestFiles"> {
+    params: any;
+    query: any;
+    body: any;
+    headers: any;
+    user?: any;
+    formData?: any;
+    file?: MultipartFile;
+    files?: MultipartFile[];
+    saveRequestFiles?: (options?: any) => Promise<MultipartFile[]>;
+    _argsCache?: Map<string, any[]>;
+}
+export interface IResponse extends FastifyReply {
+}
+export interface ParamMetaOptions {
+    index: number;
+    key: string;
+    name: string;
+    required: boolean;
+    validate: boolean;
+    dataType: any;
+    validatorClass: boolean;
+    schema?: any;
+    type: "route:param" | "route:query" | "route:body" | "route:header" | "route:user" | "route:file" | "route:files";
+}
+export interface ParamMetaFilesOptions {
+    index: number;
+    type: "route:files";
+    files: MultipartFile[];
+    fieldName: string;
+}
+export interface MethodParamMeta {
+    request: any[];
+    params: ParamMetaOptions[];
+    query: ParamMetaOptions[];
+    body: ParamMetaOptions[];
+    headers: ParamMetaOptions[];
+    currentUser: ParamMetaOptions[];
+    swagger?: OpenApiUiOptions;
+    file?: any[];
+    files?: ParamMetaFilesOptions[];
+}
+export interface IRoute {
+    url: string;
+    method: string;
+    controller: string;
+}
+export type FuncRoute = {
+    handler: Function;
+    middlewares: any[];
+    schema: any;
+};
+export type StaticFileOptions = {
+    path?: string;
+    prefix?: string;
+};

package/dist/core/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/event-dispatcher.d.ts

@@ -11,7 +11,6 @@ export type DispatchOptions = {
     retry?: number;
     retryDelay?: number;
 };
-export declare function sleep(ms: number): Promise<unknown>;
 export declare class EventDispatcher {
     private readonly _context;
     constructor(_context: SocketContextService);

package/dist/event-dispatcher.js

@@ -10,11 +10,11 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventDispatcher = exports.SocketContextService = void 0;
-exports.sleep = sleep;
 exports.Dispatch = Dispatch;
 const typedi_1 = require("typedi");
-const socket_io_1 = require("socket.io");
+const websocket_1 = require("./websocket");
 const node_async_hooks_1 = require("node:async_hooks");
+const helpers_1 = require("./helpers");
 let SocketContextService = class SocketContextService {
     constructor() {
         this.storage = new node_async_hooks_1.AsyncLocalStorage();
@@ -31,9 +31,6 @@ exports.SocketContextService = SocketContextService;
 exports.SocketContextService = SocketContextService = __decorate([
     (0, typedi_1.Service)()
 ], SocketContextService);
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
 let EventDispatcher = class EventDispatcher {
     constructor(_context) {
         this._context = _context;
@@ -50,7 +47,7 @@ let EventDispatcher = class EventDispatcher {
             catch (err) {
                 if (attempt === retryCount)
                     throw err;
-                await sleep(delay * (attempt + 1));
+                await (0, helpers_1.sleep)(delay * (attempt + 1));
             }
         }
     }
@@ -59,7 +56,7 @@ let EventDispatcher = class EventDispatcher {
         const transports = (_a = options.transports) !== null && _a !== void 0 ? _a : ["socket"];
         for (const transport of transports) {
             if (transport === "socket") {
-                const io = typedi_1.Container.get(socket_io_1.Server);
+                const io = typedi_1.Container.get(websocket_1.SocketIoServer);
                 const context = typedi_1.Container.get(SocketContextService);
                 const socket = context.getSocket();
                 if (options.broadcast && socket) {

package/dist/file-storage.test.js

@@ -31,7 +31,10 @@ describe("FileStorage", () => {
     });
     describe("save", () => {
         it("should save a file successfully", async () => {
-            await expect(fileStorage.save(testFile)).resolves.toEqual(testFile);
+            await expect(fileStorage.save(testFile)).resolves.toEqual({
+                uploadPath: "/uploads/test.txt",
+                staticPath: "/static/test.txt",
+            });
         });
         it("should throw SystemUseError if file exists and overwrite is false", async () => {
             mockFs.existsSync.mockReturnValue(true);
@@ -61,7 +64,16 @@ describe("FileStorage", () => {
                 { ...testFile, filename: "a.txt" },
                 { ...testFile, filename: "b.txt" },
             ];
-            await expect(fileStorage.saveAll(files)).resolves.toEqual(files);
+            await expect(fileStorage.saveAll(files)).resolves.toEqual([
+                {
+                    uploadPath: "/uploads/a.txt",
+                    staticPath: "/static/a.txt",
+                },
+                {
+                    uploadPath: "/uploads/b.txt",
+                    staticPath: "/static/b.txt",
+                },
+            ]);
         });
         it("should throw SystemUseError on error", async () => {
             promises_1.pipeline.mockImplementationOnce(() => {
@@ -96,6 +108,7 @@ describe("FileStorage", () => {
             expect(mockFs.mkdirSync).toHaveBeenCalled();
         });
         it("should not create directory if exists", async () => {
+            mockFs.mkdirSync.mockClear();
             mockFs.existsSync.mockReturnValue(true);
             await fileStorage["ensureDirectoryExists"]("public/test.txt");
             expect(mockFs.mkdirSync).not.toHaveBeenCalled();

package/dist/helpers.d.ts

@@ -1,44 +1,11 @@
-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
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
  */
-export declare function normalizeQueryDeep(query: Record<string, any>): Record<string, any>;
-export {};
+export * from "./utils/common-utils";
+export * from "./utils/object-utils";
+export * from "./utils/validation-utils";
+export * from "./utils/di-utils";
+export * from "./validation";

package/dist/helpers.js

@@ -1,419 +1,27 @@
 "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;
-    }
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-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;
-}
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./utils/common-utils"), exports);
+__exportStar(require("./utils/object-utils"), exports);
+__exportStar(require("./utils/validation-utils"), exports);
+__exportStar(require("./utils/di-utils"), exports);
+__exportStar(require("./validation"), exports);