@avleon/core 0.0.4

package/dist/icore.js

@@ -0,0 +1,239 @@
+"use strict";
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppBuilder = void 0;
+const fastify_1 = __importDefault(require("fastify"));
+const typedi_1 = __importDefault(require("typedi"));
+const promises_1 = __importDefault(require("fs/promises")); // Use promises for asynchronous file operations
+const path_1 = __importDefault(require("path"));
+const container_1 = __importStar(require("./container"));
+const helpers_1 = require("./helpers");
+const system_exception_1 = require("./exceptions/system-exception");
+const isTsNode = process.env.TS_NODE_DEV || process.env.TS_NODE_PROJECT || process[Symbol.for("ts-node.register.instance")];
+const controllerDir = path_1.default.join(process.cwd(), isTsNode ? "./src/controllers" : "./dist/cotrollers");
+class _InternalApplication {
+    constructor() {
+        this.routeSet = new Set(); // Use Set for fast duplicate detection
+        this.alreadyRun = false;
+        this.routes = new Map();
+        this.app = (0, fastify_1.default)();
+    }
+    static getInternalApp(buildOptions) {
+        if (!_InternalApplication.instance) {
+            _InternalApplication.instance = new _InternalApplication();
+        }
+        _InternalApplication.buildOptions = buildOptions;
+        return _InternalApplication.instance;
+    }
+    async buildController(controller) {
+        const ctrl = typedi_1.default.get(controller);
+        const controllerMeta = Reflect.getMetadata(container_1.CONTROLLER_META_KEY, ctrl.constructor);
+        if (!controllerMeta)
+            return;
+        const prototype = Object.getPrototypeOf(ctrl);
+        const methods = Object.getOwnPropertyNames(prototype).filter((name) => name !== "constructor");
+        for (const method of methods) {
+            const methodMeta = Reflect.getMetadata(container_1.ROUTE_META_KEY, prototype, method);
+            if (!methodMeta)
+                continue;
+            const methodmetaOptions = { method: methodMeta.method.toLowerCase(), path: (0, helpers_1.formatUrl)(controllerMeta.path + methodMeta.path) };
+            const routeKey = `${methodmetaOptions.method}:${methodmetaOptions.path}`;
+            if (this.routeSet.has(routeKey)) {
+                throw new system_exception_1.SystemUseError(`Duplicate Error: Duplicate route found for methoed ${methodMeta.method}: ${methodMeta.path} in ${controller.name}`);
+            }
+            this.routeSet.add(routeKey);
+            const allMeta = this._processMeta(prototype, controllerMeta, method, methodMeta);
+            this.app.route({
+                url: methodmetaOptions.path == "" ? "/" : methodmetaOptions.path,
+                method: methodmetaOptions.method.toUpperCase(),
+                preHandler: async (req, res, next) => {
+                    for (let bodyMeta of allMeta.body) {
+                        const args = await this._mapArgs(req, allMeta);
+                        if (bodyMeta.validatorClass) {
+                            const err = await (0, helpers_1.validateObjectByInstance)(bodyMeta.dataType, args[bodyMeta.index]);
+                            if (err) {
+                                console.log("Has validation error", err);
+                                return await res.code(400).send({
+                                    code: 400,
+                                    errorType: "ValidationError",
+                                    errors: err,
+                                    message: err.message
+                                });
+                            }
+                        }
+                    }
+                    next();
+                },
+                handler: async (req, res) => {
+                    const args = await this._mapArgs(req, allMeta);
+                    try {
+                        return await prototype[method].apply(ctrl, args);
+                    }
+                    catch (err) {
+                        console.error(err);
+                        return res.code(err.statusCode || 500).send({
+                            code: err.statusCode || 500,
+                            errorType: err.name || "InternalServerError",
+                            message: err.message,
+                        });
+                    }
+                },
+            });
+        }
+    }
+    async _mapArgs(req, meta) {
+        const args = [];
+        if (meta.params.length > 0) {
+            meta.params.forEach((param) => {
+                const value = param.key === "all" ? req.params : req.params[param.key];
+                args[param.index] = value;
+            });
+        }
+        if (meta.query.length > 0) {
+            meta.query.forEach((q) => {
+                const value = q.key === "all" ? req.query : req === null || req === void 0 ? void 0 : req.query[q.key];
+                args[q.index] = value;
+            });
+        }
+        if (meta.body.length > 0) {
+            meta.body.forEach(async (body) => {
+                args[body.index] = req.body;
+            });
+        }
+        if (meta.headers.length > 0) {
+            meta.headers.forEach((header) => {
+                const value = header.key === "all" ? req.headers : req.headers[header.key];
+                args[header.index] = value;
+            });
+        }
+        return args;
+    }
+    _processMeta(prototype, controllerMeta, method, methodMeta) {
+        const paramsMetaList = Reflect.getMetadata(container_1.PARAM_META_KEY, prototype, method) || [];
+        const queryMetaList = Reflect.getMetadata(container_1.QUERY_META_KEY, prototype, method) || [];
+        const bodyMetaList = Reflect.getMetadata(container_1.REQUEST_BODY_META_KEY, prototype, method) || [];
+        const headerMetaList = Reflect.getMetadata(container_1.REQUEST_HEADER_META_KEY, prototype, method) || [];
+        return { params: paramsMetaList, query: queryMetaList, body: bodyMetaList, headers: headerMetaList };
+    }
+    async mapControllers() {
+        // const controllers = getRegisteredControllers();
+        // await Promise.all(controllers.map((controller) => this.buildController(controller)));
+        await this._mapControllers();
+    }
+    async mapGroup(path) {
+    }
+    async handleRoute(args) {
+        console.log(args);
+    }
+    async mapGet(path = '', fn) {
+        this.app.get(path, async (req, res) => {
+            const result = await fn.apply(this, [req, res]);
+            return res.send(result);
+        });
+        /*     this.handleRoute = fn.apply(this, arguments);
+        
+                this.routes.set(path, async (...args: any[]) => {
+                    try {
+                        const result = await fn(...args);
+                        return result;
+                    } catch (error) {
+                        console.error(`Error handling route ${path}:`, error);
+                        throw error;
+                    }
+                }); */
+    }
+    async mapPost() { }
+    async mapPut() { }
+    async mapDelete() { }
+    async _mapControllers() {
+        const controllers = (0, container_1.getRegisteredControllers)();
+        await Promise.all(controllers.map((controller) => this.buildController(controller)));
+    }
+    async run(port = 4000) {
+        if (this.alreadyRun)
+            throw new system_exception_1.SystemUseError("App already running");
+        this.alreadyRun = true;
+        if (_InternalApplication.buildOptions.database) {
+        }
+        ///await this._mapControllers();
+        await this.app.listen({ port });
+        console.log(`Application running on port: ${port}`);
+    }
+}
+_InternalApplication.buildOptions = {};
+class AppBuilder {
+    constructor() {
+        this.alreadyBuilt = false;
+        this.databse = false;
+    }
+    static createBuilder() {
+        if (!AppBuilder.instance) {
+            AppBuilder.instance = new AppBuilder();
+        }
+        return AppBuilder.instance;
+    }
+    async registerPlugin(plugin, options) {
+        container_1.default.set(plugin, plugin.prototype);
+    }
+    async useDatabase() {
+        this.databse = true;
+    }
+    async build() {
+        //console.log("Hello", hello())
+        if (this.alreadyBuilt)
+            throw new Error("Already built");
+        this.alreadyBuilt = true;
+        const controllers = [];
+        const files = await promises_1.default.readdir(controllerDir);
+        for (const file of files) {
+            if (isTsNode ? file.endsWith(".ts") : file.endsWith(".js")) {
+                const filePath = path_1.default.join(controllerDir, file);
+                const module = await Promise.resolve(`${filePath}`).then(s => __importStar(require(s)));
+                for (const exported of Object.values(module)) {
+                    if (typeof exported === "function" && (0, container_1.isApiController)(exported)) {
+                        controllers.push(exported);
+                    }
+                }
+            }
+        }
+        const app = _InternalApplication.getInternalApp({ database: this.databse });
+        controllers.forEach(container_1.registerController);
+        return app;
+    }
+}
+exports.AppBuilder = AppBuilder;

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from './icore';
+export { inject } from './helpers';
+export * from "./decorators";
+export * from "./config";
+export * from "./openapi";
+export * from "./map-types";
+export * from './response';
+export * from './exceptions';
+export * from './validator-extend';
+export { default as Container } from './container';

package/dist/index.js

@@ -0,0 +1,33 @@
+"use strict";
+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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Container = exports.inject = void 0;
+//export * from "./iqra-core";
+__exportStar(require("./icore"), exports);
+var helpers_1 = require("./helpers");
+Object.defineProperty(exports, "inject", { enumerable: true, get: function () { return helpers_1.inject; } });
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./openapi"), exports);
+__exportStar(require("./map-types"), exports);
+__exportStar(require("./response"), exports);
+__exportStar(require("./exceptions"), exports);
+__exportStar(require("./validator-extend"), exports);
+var container_1 = require("./container");
+Object.defineProperty(exports, "Container", { enumerable: true, get: function () { return __importDefault(container_1).default; } });

package/dist/map-types.d.ts

@@ -0,0 +1,12 @@
+import "reflect-metadata";
+type Constructor<T = any> = new (...args: any[]) => T;
+export declare function PartialType<T>(BaseClass: Constructor<T>): Constructor<Partial<T>>;
+/**
+ * Utility to pick specific properties from a class.
+ */
+export declare function PickType<T, K extends keyof T>(BaseClass: Constructor<T>, keys: K[]): Constructor<Pick<T, K>>;
+/**
+ * Utility to omit specific properties from a class.
+ */
+export declare function OmitType<T, K extends keyof T>(BaseClass: Constructor<T>, keys: K[]): Constructor<Omit<T, K>>;
+export {};

package/dist/map-types.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PartialType = PartialType;
+exports.PickType = PickType;
+exports.OmitType = OmitType;
+require("reflect-metadata");
+function PartialType(BaseClass) {
+    const baseProperties = [];
+    let currentPrototype = BaseClass.prototype;
+    // Collect properties from the base class (including inherited ones)
+    while (currentPrototype && currentPrototype !== Object.prototype) {
+        const properties = Object.getOwnPropertyNames(currentPrototype).filter((prop) => prop !== "constructor");
+        // Retrieve metadata for each property
+        properties.forEach((key) => {
+            // Check if the property has type metadata (design:type)
+            const designType = Reflect.getMetadata("design:type", currentPrototype, key);
+            if (designType) {
+                baseProperties.push(key);
+            }
+            // Retrieve validation metadata (class-validator)
+            const validationMetadata = Reflect.getMetadataKeys(currentPrototype, key);
+            validationMetadata.forEach((metadataKey) => {
+            });
+        });
+        currentPrototype = Object.getPrototypeOf(currentPrototype); // Move up the prototype chain
+    }
+    class PartialClass {
+    }
+    // Define properties as optional and copy metadata
+    baseProperties.forEach((key) => {
+        const propertyType = Reflect.getMetadata("design:type", BaseClass.prototype, key);
+        Reflect.defineMetadata("design:type", propertyType, PartialClass.prototype, key);
+        // Propagate class-validator metadata to the new class
+        const validationMetadataKeys = Reflect.getMetadataKeys(BaseClass.prototype, key) || [];
+        validationMetadataKeys.forEach((metadataKey) => {
+            const metadataValue = Reflect.getMetadata(metadataKey, BaseClass.prototype, key);
+            Reflect.defineMetadata(metadataKey, metadataValue, PartialClass.prototype, key);
+        });
+    });
+    // Copy other metadata from the base class (non-property metadata)
+    Reflect.getMetadataKeys(BaseClass.prototype).forEach((key) => {
+        const metadataValue = Reflect.getMetadata(key, BaseClass.prototype);
+        Reflect.defineMetadata(key, metadataValue, PartialClass.prototype);
+    });
+    return PartialClass;
+}
+/**
+ * Utility to pick specific properties from a class.
+ */
+function PickType(BaseClass, keys) {
+    class PickClass {
+        constructor() {
+            keys.forEach((key) => {
+                Reflect.defineMetadata("design:type", Reflect.getMetadata("design:type", BaseClass.prototype, key), this, key);
+            });
+        }
+    }
+    Reflect.decorate([Reflect.metadata("design:properties", keys)], PickClass);
+    // Copy metadata from BaseClass to PickClass
+    Reflect.getMetadataKeys(BaseClass.prototype).forEach((key) => {
+        Reflect.defineMetadata(key, Reflect.getMetadata(key, BaseClass.prototype), PickClass.prototype);
+    });
+    return PickClass;
+}
+/**
+ * Utility to omit specific properties from a class.
+ */
+function OmitType(BaseClass, keys) {
+    const allKeys = Reflect.getMetadata("design:properties", BaseClass) || [];
+    const omitKeys = new Set(keys);
+    const finalKeys = allKeys.filter((key) => !omitKeys.has(key));
+    class OmitClass {
+        constructor() {
+            finalKeys.forEach((key) => {
+                Reflect.defineMetadata("design:type", Reflect.getMetadata("design:type", BaseClass.prototype, key), this, key);
+            });
+        }
+    }
+    Reflect.decorate([Reflect.metadata("design:properties", finalKeys)], OmitClass);
+    // Copy metadata from BaseClass to OmitClass
+    Reflect.getMetadataKeys(BaseClass.prototype).forEach((key) => {
+        Reflect.defineMetadata(key, Reflect.getMetadata(key, BaseClass.prototype), OmitClass.prototype);
+    });
+    return OmitClass;
+}