@avleon/core 0.0.45 → 0.0.46

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() { }

package/package.json

@@ -1,35 +1,40 @@
 {
   "name": "@avleon/core",
-  "version": "0.0.45",
+  "version": "0.0.46",
+  "description": "TypeScript-first web framework built on Fastify",
+  "author": "Tareq Hossain",
+  "license": "ISC",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "keywords": [
     "restapi",
     "avleon",
     "backend",
-    "fastify"
-  ],
-  "author": "Tareq Hossain",
-  "license": "ISC",
-  "description": "avleon core",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/avleonjs/avleon-core"
-  },
-  "files": [
-    "dist"
+    "fastify",
+    "typescript"
   ],
-  "directories": {
-    "test": "."
+  "scripts": {
+    "build": "npm run clean && tsc",
+    "clean": "rimraf dist",
+    "prepublishOnly": "npm run build",
+    "watch": "tsc-watch",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "husky:init": "husky install"
   },
   "dependencies": {
-    "bull": "^4.16.5",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.2",
     "fastify": "^5.1.0",
-    "mime": "^4.1.0",
-    "pino": "^9.10.0",
-    "pino-pretty": "^13.1.1",
+    "mime": "^3.0.0",
     "reflect-metadata": "^0.2.2",
     "typedi": "^0.10.0"
   },
@@ -42,23 +47,23 @@
     "@fastify/view": "^11.0.0",
     "@scalar/fastify-api-reference": "*",
     "bcryptjs": "3.0.2",
+    "bull": "^4.16.5",
     "dotenv": "*",
     "fastify-socket.io": "^4.0.0",
     "highlight.js": "*",
     "ioredis": "*",
     "knex": "*",
-    "mssql": "*",
+    "mssql": ">=9.0.0",
     "mysql2": "*",
     "pg": "*",
+    "pino": "^9.0.0",
+    "pino-pretty": "^13.0.0",
     "sharp": "*",
     "socket.io": "*",
     "sqlite3": "*",
     "typeorm": "*"
   },
   "peerDependenciesMeta": {
-    "bcryptjs": {
-      "optional": true
-    },
     "@fastify/cors": {
       "optional": true
     },
@@ -80,13 +85,22 @@
     "@scalar/fastify-api-reference": {
       "optional": true
     },
-    "ioredis": {
+    "bcryptjs": {
       "optional": true
     },
-    "sharp": {
+    "bull": {
       "optional": true
     },
-    "typeorm": {
+    "dotenv": {
+      "optional": true
+    },
+    "fastify-socket.io": {
+      "optional": true
+    },
+    "highlight.js": {
+      "optional": true
+    },
+    "ioredis": {
       "optional": true
     },
     "knex": {
@@ -101,19 +115,22 @@
     "pg": {
       "optional": true
     },
-    "sqlite3": {
+    "pino": {
       "optional": true
     },
-    "fastify-socket.io": {
+    "pino-pretty": {
+      "optional": true
+    },
+    "sharp": {
       "optional": true
     },
     "socket.io": {
       "optional": true
     },
-    "dotenv": {
+    "sqlite3": {
       "optional": true
     },
-    "highlight.js": {
+    "typeorm": {
       "optional": true
     }
   },
@@ -141,15 +158,11 @@
       "cross-env CI=true jest --bail --findRelatedTests --passWithNoTests --config=jest.config.js"
     ]
   },
-  "scripts": {
-    "build": "npm run clean && tsc",
-    "clean": "rimraf dist",
-    "watch": "tsc-watch",
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix",
-    "format": "prettier --write .",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "husky:init": "husky install"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/avleonjs/avleon-core"
+  },
+  "publishConfig": {
+    "access": "public"
   }
-}
+}

package/dist/application.d.ts

@@ -1,47 +0,0 @@
-import { Constructor } from "./helpers";
-import { RouteShorthandMethod } from "fastify";
-export interface AvleonApplication {
-    useCors: () => void;
-    useOpenApi: () => void;
-    useView: () => void;
-    useAuth: () => void;
-    useMultipart: () => void;
-    useDataSource: () => void;
-    useMiddlewares: () => void;
-    useControllers: () => void;
-    useAutoControllers: () => void;
-    useStaticFiles: () => void;
-    useCustomErrorHandler: () => void;
-    mapGroup: () => any;
-    mapGet: () => any;
-    mapPost: () => any;
-    mapPut: () => any;
-    mapPatch: () => any;
-    mapDelete: () => any;
-    mapView: () => any;
-    run: (port: number) => void;
-}
-export interface InlineRoutes {
-    get: RouteShorthandMethod;
-    post: RouteShorthandMethod;
-    put: RouteShorthandMethod;
-    patch: RouteShorthandMethod;
-    delete: RouteShorthandMethod;
-}
-export interface Application {
-    inlineRoutes: () => InlineRoutes;
-    mapGroup: (path?: string | RegExp) => InlineRoutes;
-    /**
-     * Start the application
-     * @param port
-     * @returns void
-     */
-    start: (port?: number) => void;
-}
-export interface TestApplication {
-    getController: <T>(controller: Constructor<T>) => T;
-}
-export declare class Builder {
-    static createApplication(): Application;
-    static createTestApplication(app?: Application): TestApplication;
-}

package/dist/application.js

@@ -1,50 +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.Builder = void 0;
-const typedi_1 = __importDefault(require("typedi"));
-const fastify_1 = __importDefault(require("fastify"));
-class IqraTestApplication {
-    getController(controller) {
-        const con = typedi_1.default.get(controller);
-        return con;
-    }
-}
-class IqraApplication {
-    constructor() {
-        if (!this.app) {
-            this.app = fastify_1.default.prototype;
-        }
-    }
-    inlineRoutes() {
-        return {
-            get: this.app.get,
-            post: this.app.post,
-            put: this.app.put,
-            patch: this.app.patch,
-            delete: this.app.delete,
-        };
-    }
-    mapGroup(path) {
-        return this.inlineRoutes();
-    }
-    start(port) {
-        const p = port ? port : 4000;
-        this.app.listen({ port: p });
-    }
-}
-class Builder {
-    static createApplication() {
-        const app = new IqraApplication();
-        return app;
-    }
-    static createTestApplication(app) {
-        const testApp = new IqraTestApplication();
-        return testApp;
-    }
-}
-exports.Builder = Builder;
-const app = Builder.createApplication();
-const route = app.inlineRoutes();