@avleon/core 0.0.45 → 0.0.46

package/dist/application.test.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const testing_1 = require("./core/testing");
+const application_1 = require("./core/application");
+describe("Avleon.createApplication", () => {
+    it("should return an instance of AvleonApplication", () => {
+        const app = testing_1.Avleon.createApplication();
+        expect(app).toBeInstanceOf(application_1.AvleonApplication);
+    });
+    it("should always return the same instance (singleton)", () => {
+        const app1 = testing_1.Avleon.createApplication();
+        const app2 = testing_1.Avleon.createApplication();
+        expect(app1).toBe(app2);
+    });
+});

package/dist/controller.test.js

@@ -42,7 +42,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
 const controller_1 = require("./controller");
 const containerModule = __importStar(require("./container"));
-const typedi_1 = require("typedi");
 describe("Controller Decorators", () => {
     beforeEach(() => {
         jest.clearAllMocks();
@@ -94,18 +93,5 @@ describe("Controller Decorators", () => {
                 options,
             });
         });
-        const originalService = typedi_1.Service;
-        // @ts-ignore
-        containerModule.Service = undefined;
-        expect(() => {
-            let TestController = class TestController {
-            };
-            TestController = __decorate([
-                controller_1.ApiController
-            ], TestController);
-        }).toThrow("Service decorator is not a function");
-        // Restore
-        // @ts-ignore
-        containerModule.Service = originalService;
     });
 });

package/dist/core/application.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+import { FastifyInstance } from "fastify";
+import "@fastify/swagger";
+import { IAvleonApplication, AvleonApplicationOptions, CorsOptions, GlobalOptions } from "../interfaces/avleon-application";
+import { Constructor } from "../helpers";
+import { OpenApiUiOptions } from "../openapi";
+import { DataSource } from "typeorm";
+import { AvleonMiddleware } from "../middleware";
+import { AutoControllerOptions } from "./types";
+export declare class AvleonApplication implements IAvleonApplication {
+    app: FastifyInstance;
+    private router;
+    private static instance;
+    private alreadyRun;
+    private hasSwagger;
+    private globalSwaggerOptions;
+    private dataSourceOptions;
+    private dataSource;
+    private isMapFeatures;
+    private registerControllerAuto;
+    private registerControllerPath;
+    private controllers;
+    private _hasWebsocket;
+    private io;
+    private constructor();
+    static getApp(options?: AvleonApplicationOptions): AvleonApplication;
+    /**
+     * @deprecated Use `getApp` instead. This is internal.
+     */
+    static getInternalApp(options?: AvleonApplicationOptions): AvleonApplication;
+    useCors(options: CorsOptions): this;
+    useDatasource(dataSource: DataSource): this;
+    useMultipart(options?: any): this;
+    useOpenApi(options: OpenApiUiOptions): this;
+    private initSwagger;
+    useMiddlewares(middlewares: Constructor<AvleonMiddleware>[]): this;
+    useAuthorization(authorization: Constructor<any>): this;
+    useSerialization(): this;
+    useControllers(controllers: Constructor[] | AutoControllerOptions): this;
+    useStaticFiles(options: any): this;
+    useHttps(options?: any): this;
+    useGlobal(options: GlobalOptions): this;
+    useSocketIo(options?: any): this;
+    useKnex(options: any): this;
+    mapFeatures(): this;
+    private _mapControllers;
+    private _resolveControllerDir;
+    private autoControllers;
+    private _mapFeatures;
+    initializeDatabase(): Promise<void>;
+    handleSocket(socket: any): void;
+    mapGet<T extends (...args: any[]) => any>(path: string | undefined, fn: T): {
+        useMiddleware: <M extends AvleonMiddleware>(middlewares: Constructor<AvleonMiddleware>[]) => /*elided*/ any;
+        useOpenApi: (options: import("../openapi").OpenApiOptions) => /*elided*/ any;
+    };
+    mapPost<T extends (...args: any[]) => any>(path: string | undefined, fn: T): {
+        useMiddleware: <M extends AvleonMiddleware>(middlewares: Constructor<AvleonMiddleware>[]) => /*elided*/ any;
+        useOpenApi: (options: import("../openapi").OpenApiOptions) => /*elided*/ any;
+    };
+    mapPut<T extends (...args: any[]) => any>(path: string | undefined, fn: T): {
+        useMiddleware: <M extends AvleonMiddleware>(middlewares: Constructor<AvleonMiddleware>[]) => /*elided*/ any;
+        useOpenApi: (options: import("../openapi").OpenApiOptions) => /*elided*/ any;
+    };
+    mapDelete<T extends (...args: any[]) => any>(path: string | undefined, fn: T): {
+        useMiddleware: <M extends AvleonMiddleware>(middlewares: Constructor<AvleonMiddleware>[]) => /*elided*/ any;
+        useOpenApi: (options: import("../openapi").OpenApiOptions) => /*elided*/ any;
+    };
+    run(port?: number, fn?: CallableFunction): Promise<void>;
+}

package/dist/core/application.js

@@ -0,0 +1,424 @@
+"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.AvleonApplication = void 0;
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+const fastify_1 = __importDefault(require("fastify"));
+require("@fastify/swagger");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const router_1 = require("./router");
+const typedi_1 = __importDefault(require("typedi"));
+const exceptions_1 = require("../exceptions");
+const system_exception_1 = require("../exceptions/system-exception");
+const swagger_schema_1 = require("../swagger-schema");
+const typeorm_1 = require("typeorm");
+const kenx_provider_1 = require("../kenx-provider");
+const event_dispatcher_1 = require("../event-dispatcher");
+const event_subscriber_1 = require("../event-subscriber");
+const websocket_1 = require("../websocket");
+const container_1 = require("../container");
+class AvleonApplication {
+    constructor(options) {
+        var _a;
+        this.alreadyRun = false;
+        this.hasSwagger = false;
+        this.dataSourceOptions = null;
+        this.dataSource = null;
+        this.isMapFeatures = false;
+        this.registerControllerAuto = false;
+        this.registerControllerPath = "src/controllers";
+        this.controllers = [];
+        this._hasWebsocket = false;
+        this.app = (0, fastify_1.default)({
+            ...options === null || options === void 0 ? void 0 : options.server,
+            ajv: {
+                customOptions: {
+                    strict: false, // allows `example`, `examples` and other OpenAPI keywords
+                },
+                ...(_a = options === null || options === void 0 ? void 0 : options.server) === null || _a === void 0 ? void 0 : _a.ajv,
+            },
+        });
+        this.router = new router_1.AvleonRouter(this.app);
+        if (options === null || options === void 0 ? void 0 : options.dataSourceOptions) {
+            this.dataSourceOptions = options.dataSourceOptions;
+            if (this.dataSourceOptions) {
+                this.dataSource = new typeorm_1.DataSource(this.dataSourceOptions);
+                typedi_1.default.set(typeorm_1.DataSource, this.dataSource);
+            }
+        }
+    }
+    static getApp(options) {
+        if (!AvleonApplication.instance) {
+            AvleonApplication.instance = new AvleonApplication(options);
+        }
+        return AvleonApplication.instance;
+    }
+    /**
+     * @deprecated Use `getApp` instead. This is internal.
+     */
+    static getInternalApp(options) {
+        return new AvleonApplication(options);
+    }
+    useCors(options) {
+        this.app.register(require("@fastify/cors"), options);
+        return this;
+    }
+    useDatasource(dataSource) {
+        this.dataSource = dataSource;
+        typedi_1.default.set(typeorm_1.DataSource, this.dataSource);
+        return this;
+    }
+    useMultipart(options) {
+        this.app.register(require("@fastify/multipart"), {
+            attachFieldsToBody: true,
+            limits: {
+                fileSize: 10 * 1024 * 1024, // 10MB default
+            },
+            ...options,
+        });
+        return this;
+    }
+    useOpenApi(options) {
+        this.hasSwagger = true;
+        this.globalSwaggerOptions = options;
+        return this;
+    }
+    async initSwagger(options) {
+        var _a, _b, _c;
+        const safeControllers = ((_a = this.controllers) !== null && _a !== void 0 ? _a : []).filter((c) => c != null && typeof c === "function");
+        const baseSchema = (0, swagger_schema_1.generateSwaggerSchema)(safeControllers);
+        await this.app.register(require("@fastify/swagger"), {
+            openapi: {
+                ...baseSchema,
+                info: (options === null || options === void 0 ? void 0 : options.info) || { title: "API", version: "1.0.0" },
+                servers: options === null || options === void 0 ? void 0 : options.servers,
+                tags: options === null || options === void 0 ? void 0 : options.tags,
+                components: {
+                    ...baseSchema === null || baseSchema === void 0 ? void 0 : baseSchema.components,
+                    ...options === null || options === void 0 ? void 0 : options.components,
+                    schemas: {
+                        ...(_b = baseSchema === null || baseSchema === void 0 ? void 0 : baseSchema.components) === null || _b === void 0 ? void 0 : _b.schemas,
+                        ...(_c = options === null || options === void 0 ? void 0 : options.components) === null || _c === void 0 ? void 0 : _c.schemas,
+                    },
+                },
+                security: options === null || options === void 0 ? void 0 : options.security,
+                externalDocs: options === null || options === void 0 ? void 0 : options.externalDocs,
+            },
+        });
+        const routePrefix = (options === null || options === void 0 ? void 0 : options.routePrefix) || "/swagger";
+        if ((options === null || options === void 0 ? void 0 : options.provider) === "scalar") {
+            await this.app.register(require("@scalar/fastify-api-reference"), {
+                routePrefix,
+                configuration: {
+                    spec: {
+                        content: () => this.app.swagger(),
+                    },
+                    ...options === null || options === void 0 ? void 0 : options.uiConfig,
+                },
+            });
+        }
+        else {
+            await this.app.register(require("@fastify/swagger-ui"), {
+                routePrefix,
+                uiConfig: {
+                    docExpansion: "full",
+                    deepLinking: false,
+                    ...options === null || options === void 0 ? void 0 : options.uiConfig,
+                },
+                uiHooks: {
+                    onRequest: function (request, reply, next) {
+                        next();
+                    },
+                    preHandler: function (request, reply, next) {
+                        next();
+                    },
+                },
+                staticCSP: true,
+                transformSpecificationClone: true,
+            });
+        }
+    }
+    useMiddlewares(middlewares) {
+        middlewares.forEach((m) => {
+            const cls = typedi_1.default.get(m);
+            this.app.addHook("preHandler", async (req, res) => {
+                await cls.invoke(req, res);
+            });
+        });
+        return this;
+    }
+    useAuthorization(authorization) {
+        this.router.setAuthorizeMiddleware(authorization);
+        return this;
+    }
+    useSerialization() {
+        // Implementation if needed, currently seemingly handled elsewhere or default
+        return this;
+    }
+    useControllers(controllers) {
+        if (Array.isArray(controllers)) {
+            this.controllers = controllers;
+            // Dedupe
+            controllers.forEach((controller) => {
+                if (!this.controllers.includes(controller)) {
+                    this.controllers.push(controller);
+                }
+            });
+        }
+        else {
+            this.registerControllerAuto = true;
+            if (controllers.path) {
+                this.registerControllerPath = controllers.path;
+            }
+        }
+        return this;
+    }
+    useStaticFiles(options) {
+        this.app.register(require("@fastify/static"), options);
+        return this;
+    }
+    useHttps(options) {
+        // Fastify handles https via server options usually, but if this is strictly for https
+        // this might need logic. Original icore didn't show body for this.
+        return this;
+    }
+    useGlobal(options) {
+        if (options.cors)
+            this.useCors(options.cors);
+        if (options.openApi)
+            this.useOpenApi(options.openApi);
+        if (options.controllers)
+            this.useControllers(options.controllers);
+        if (options.middlewares)
+            this.useMiddlewares(options.middlewares);
+        if (options.authorization)
+            this.useAuthorization(options.authorization);
+        if (options.multipart)
+            this.useMultipart(options.multipart);
+        if (options.staticFiles)
+            this.useStaticFiles(options.staticFiles);
+        return this;
+    }
+    useSocketIo(options) {
+        this._hasWebsocket = true;
+        this.app.register(require("fastify-socket.io"), options);
+        return this;
+    }
+    useKnex(options) {
+        const db = typedi_1.default.get(kenx_provider_1.DB);
+        db.init(options.config);
+        return this;
+    }
+    mapFeatures() {
+        this.isMapFeatures = true;
+        return this;
+    }
+    async _mapControllers() {
+        if (this.controllers.length > 0) {
+            for (let controller of this.controllers) {
+                if ((0, container_1.isApiController)(controller)) {
+                    await this.router.buildController(controller);
+                }
+                else {
+                    throw new system_exception_1.SystemUseError("Not a api controller.");
+                }
+            }
+        }
+    }
+    // Auto controller discovery logic
+    _resolveControllerDir(dir) {
+        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(), this.registerControllerPath);
+        return isTsNode ? controllerDir : controllerDir.replace("src", "dist");
+    }
+    async autoControllers(controllersPath) {
+        const conDir = this._resolveControllerDir(controllersPath);
+        // This relies on isTsNode logic which we might want to clean up, but keeping for parity
+        const isTsNode = process.env.TS_NODE_DEV ||
+            process.env.TS_NODE_PROJECT ||
+            process[Symbol.for("ts-node.register.instance")];
+        try {
+            const files = await fs_1.default.readdirSync(conDir, { recursive: true, encoding: 'utf-8' }); // recursive readdir is node 20+
+            for (const file of files) {
+                const isTestFile = /\.(test|spec|e2e-spec)\.ts$/.test(file);
+                if (isTestFile)
+                    continue;
+                if (isTsNode ? file.endsWith(".ts") : file.endsWith(".js")) {
+                    const filePath = path_1.default.join(conDir, file);
+                    // Dynamically import
+                    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)) {
+                            // double check if constructor
+                            if (!this.controllers.some((con) => exported.name == con.name)) {
+                                this.controllers.push(exported);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (e) {
+            console.warn("Could not auto-register controllers from " + conDir, e);
+        }
+    }
+    _mapFeatures() {
+        // Placeholder as per original
+        const features = typedi_1.default.get("features");
+    }
+    async initializeDatabase() {
+        if (this.dataSourceOptions && this.dataSource) {
+            await this.dataSource.initialize();
+        }
+    }
+    handleSocket(socket) {
+        const contextService = typedi_1.default.get(event_dispatcher_1.SocketContextService);
+        const subscriberRegistry = typedi_1.default.get(event_subscriber_1.EventSubscriberRegistry);
+        subscriberRegistry.register(socket);
+        // Wrap all future event handlers with context
+        const originalOn = socket.on.bind(socket);
+        socket.on = (event, handler) => {
+            return originalOn(event, (...args) => {
+                contextService.run(socket, () => handler(...args));
+            });
+        };
+    }
+    // Proxy routing methods to Router for functional usage
+    mapGet(path = "", fn) {
+        return this.router.mapGet(path, fn);
+    }
+    mapPost(path = "", fn) {
+        return this.router.mapPost(path, fn);
+    }
+    mapPut(path = "", fn) {
+        return this.router.mapPut(path, fn);
+    }
+    mapDelete(path = "", fn) {
+        return this.router.mapDelete(path, fn);
+    }
+    async run(port = 4000, fn) {
+        if (this.alreadyRun)
+            throw new system_exception_1.SystemUseError("App already running");
+        this.alreadyRun = true;
+        if (this.hasSwagger) {
+            await this.initSwagger(this.globalSwaggerOptions);
+        }
+        await this.initializeDatabase();
+        if (this.isMapFeatures) {
+            this._mapFeatures();
+        }
+        if (this.registerControllerAuto) {
+            await this.autoControllers();
+        }
+        await this._mapControllers();
+        // Process functional routes if any were added to router
+        this.router.processFunctionalRoutes();
+        this.app.setErrorHandler((error, request, reply) => {
+            var _a;
+            const isDev = process.env.NODE_ENV === "development";
+            const timestamp = new Date().toISOString();
+            const requestInfo = `${request.method} ${request.url}`;
+            if (error instanceof exceptions_1.BaseHttpException) {
+                // ✅ Expected HTTP errors — compact one-liner
+                console.warn(`[${timestamp}] HTTP ${error.code} ${requestInfo} — ${error.message}`);
+                return reply
+                    .status(error.code || 500)
+                    .type("application/json")
+                    .serializer((payload) => JSON.stringify(payload))
+                    .send({
+                    code: error.code,
+                    status: "Error",
+                    message: error.message,
+                    data: error.payload,
+                });
+            }
+            // ✅ Unexpected errors — full details
+            console.error(`\n❌ UNHANDLED ERROR @ ${timestamp}`);
+            console.error(`   ${requestInfo}`);
+            console.error(`   ${error.name}: ${error.message}`);
+            if (error.stack) {
+                console.error(`   Stack:\n${error.stack
+                    .split("\n")
+                    .slice(1) // skip first line (duplicate of message)
+                    .map((l) => `      ${l.trim()}`)
+                    .join("\n")}`);
+            }
+            if (isDev) {
+                console.error(`   Params:`, JSON.stringify(request.params));
+                console.error(`   Query: `, JSON.stringify(request.query));
+                console.error(`   Body:  `, JSON.stringify(request.body));
+            }
+            console.error(""); // blank line for readability
+            return reply.status(500).send({
+                code: 500,
+                status: "Error",
+                message: isDev ? error.message : "Internal Server Error",
+                ...(isDev && {
+                    error: error.name,
+                    stack: (_a = error.stack) === null || _a === void 0 ? void 0 : _a.split("\n").slice(0, 5), // first 5 lines only
+                }),
+            });
+        });
+        await this.app.ready();
+        if (this._hasWebsocket) {
+            // @ts-ignore
+            if (!this.app.io) {
+                throw new Error("Socket.IO not initialized. Make sure fastify-socket.io is registered correctly.");
+            }
+            // Register the io instance in Container
+            // @ts-ignore
+            typedi_1.default.set(websocket_1.SocketIoServer, this.app.io);
+            // Then register connection handler
+            // @ts-ignore
+            await this.app.io.on("connection", this.handleSocket.bind(this));
+        }
+        await this.app.listen({ port });
+        console.log(`Application running on http://127.0.0.1:${port}`);
+        if (fn)
+            fn();
+    }
+}
+exports.AvleonApplication = AvleonApplication;

package/dist/core/router.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @copyright 2024
+ * @author Tareq Hossain
+ * @email xtrinsic96@gmail.com
+ * @url https://github.com/xtareq
+ */
+import { Constructor } from "../helpers";
+import { AvleonMiddleware } from "../middleware";
+import { OpenApiOptions } from "../openapi";
+import { FastifyInstance } from "fastify";
+export declare class AvleonRouter {
+    private routeSet;
+    private metaCache;
+    private middlewares;
+    private rMap;
+    private app;
+    private authorizeMiddleware?;
+    constructor(app: FastifyInstance);
+    setAuthorizeMiddleware(middleware: Constructor<any>): void;
+    registerMiddleware(name: string, instance: AvleonMiddleware): void;
+    private _processMeta;
+    private executeMiddlewares;
+    buildController(controller: any): Promise<void>;
+    private _mapArgs;
+    private _routeHandler;
+    mapGet<T extends (...args: any[]) => any>(path: string | undefined, fn: T): {
+        useMiddleware: <M extends AvleonMiddleware>(middlewares: Constructor<AvleonMiddleware>[]) => /*elided*/ any;
+        useOpenApi: (options: OpenApiOptions) => /*elided*/ any;
+    };
+    mapPost<T extends (...args: any[]) => any>(path: string | undefined, fn: T): {
+        useMiddleware: <M extends AvleonMiddleware>(middlewares: Constructor<AvleonMiddleware>[]) => /*elided*/ any;
+        useOpenApi: (options: OpenApiOptions) => /*elided*/ any;
+    };
+    mapPut<T extends (...args: any[]) => any>(path: string | undefined, fn: T): {
+        useMiddleware: <M extends AvleonMiddleware>(middlewares: Constructor<AvleonMiddleware>[]) => /*elided*/ any;
+        useOpenApi: (options: OpenApiOptions) => /*elided*/ any;
+    };
+    mapDelete<T extends (...args: any[]) => any>(path: string | undefined, fn: T): {
+        useMiddleware: <M extends AvleonMiddleware>(middlewares: Constructor<AvleonMiddleware>[]) => /*elided*/ any;
+        useOpenApi: (options: OpenApiOptions) => /*elided*/ any;
+    };
+    mapRoute<T extends (...args: any[]) => any>(method: "get" | "post" | "put" | "delete", path: string | undefined, fn: T): Promise<void>;
+    processFunctionalRoutes(): void;
+}