@expressots/adapter-express 1.8.2 → 3.0.0-beta.2

package/lib/cjs/adapter-express/micro-api/application-express-micro-route.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Route = void 0;
+const core_1 = require("@expressots/core");
+class Route {
+    constructor(app) {
+        this.logger = new core_1.Logger();
+        this.routes = [];
+        this.globalPrefix = "";
+        this.app = app;
+    }
+    /**
+     * Set the global route prefix
+     * @param prefix
+     * @public API
+     */
+    setGlobalRoutePrefix(prefix) {
+        this.globalPrefix = prefix;
+    }
+    /**
+     * Define a route
+     * @param method - HTTP method
+     * @param path - Route path
+     * @param handler - Route handler
+     * @param middleware - Route middleware
+     * @public API
+     */
+    define(method, path, handler, ...middleware) {
+        const normalizedPath = `${this.globalPrefix.replace(/\/$/, "")}/${path.replace(/^\//, "")}`;
+        this.routes.push({ method, path: normalizedPath, handler, middleware });
+        this.logger.info(`Route ${method.toUpperCase()} '${normalizedPath}' added.`, "Route");
+    }
+    /**
+     * Define a GET route
+     * @param path - Route path
+     * @param handler - Route handler
+     * @param middleware - Route middleware
+     * @public API
+     */
+    get(path, handler, ...middleware) {
+        this.define("get", path, handler, ...middleware);
+    }
+    /**
+     * Define a POST route
+     * @param path - Route path
+     * @param handler - Route handler
+     * @param middleware - Route middleware
+     * @public API
+     */
+    post(path, handler, ...middleware) {
+        this.define("post", path, handler, ...middleware);
+    }
+    /**
+     * Define a PUT route
+     * @param path - Route path
+     * @param handler - Route handler
+     * @param middleware - Route middleware
+     * @public API
+     */
+    put(path, handler, ...middleware) {
+        this.define("put", path, handler, ...middleware);
+    }
+    /**
+     * Define a DELETE route
+     * @param path - Route path
+     * @param handler - Route handler
+     * @param middleware - Route middleware
+     * @public API
+     */
+    delete(path, handler, ...middleware) {
+        this.define("delete", path, handler, ...middleware);
+    }
+    /**
+     * Define a PATCH route
+     * @param path - Route path
+     * @param handler - Route handler
+     * @param middleware - Route middleware
+     * @public API
+     */
+    patch(path, handler, ...middleware) {
+        this.define("patch", path, handler, ...middleware);
+    }
+    /**
+     * Apply the routes to the Express application
+     */
+    applyRoutes() {
+        this.routes.forEach(({ method, path, handler, middleware }) => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this.app[method](path, ...middleware, handler);
+        });
+    }
+    /**
+     * Get the routes
+     * @returns Array of route definitions
+     * @public API
+     */
+    get Routes() {
+        return this.routes;
+    }
+}
+exports.Route = Route;

package/lib/cjs/adapter-express/micro-api/application-express-micro.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMicroAPI = createMicroAPI;
+const core_1 = require("@expressots/core");
+const shared_1 = require("@expressots/shared");
+const express_1 = __importDefault(require("express"));
+const fs_1 = __importDefault(require("fs"));
+const application_express_micro_container_1 = require("./application-express-micro-container");
+const application_express_micro_route_1 = require("./application-express-micro-route");
+class AppExpressMicro {
+    constructor() {
+        this.logger = new core_1.Logger();
+        this.globalPrefix = "/";
+    }
+    /**
+     * Handle the exit of the server
+     * @private
+     */
+    handleExit() {
+        this.logger.info("Server shutting down.", "MicroAPI");
+        process.exit(0);
+    }
+    /**
+     * Configure the middleware for the application
+     * @private
+     */
+    configureMiddleware() {
+        const sortedMiddlewarePipeline = this.middlewareManager.getMiddlewarePipeline();
+        const pipeline = sortedMiddlewarePipeline.map((entry) => entry.middleware);
+        for (const entry of pipeline) {
+            if (typeof entry === "function") {
+                this.app.use(entry);
+            }
+            else if (entry.middlewares) {
+                const { path, middlewares } = entry;
+                for (const mid of middlewares) {
+                    if (path) {
+                        this.app.use(path, mid);
+                    }
+                    else {
+                        this.app.use(mid);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Set the global route prefix
+     * @param prefix - The global route prefix
+     * @public API
+     */
+    setGlobalRoutePrefix(prefix) {
+        this.globalPrefix = prefix;
+    }
+    /**
+     * Initialize the environment for the application
+     * @param environment - The environment to initialize
+     * @param options - Options for the environment initialization
+     * @public API
+     */
+    initEnvironment(environment, options) {
+        this.environment = environment;
+        if (options === undefined) {
+            (0, shared_1.config)({ path: ".env" });
+        }
+        else {
+            if (!options.env[environment]) {
+                this.logger.error(`Environment configuration for [${environment}] does not exist.`, "adapter-express");
+                process.exit(1);
+            }
+            else {
+                const envFileName = options.env[environment];
+                if (!fs_1.default.existsSync(envFileName)) {
+                    this.logger.error(`Environment file [${envFileName}] does not exist.`, "adapter-express");
+                    process.exit(1);
+                }
+                else {
+                    (0, shared_1.config)({ path: envFileName });
+                }
+            }
+        }
+    }
+    /**
+     * Get the Middleware instance
+     * @returns IMiddleware
+     * @public API
+     */
+    get Middleware() {
+        return this.middlewareManager;
+    }
+    /**
+     * Get the Route instance
+     * @returns IRoute
+     * @public API
+     */
+    get Route() {
+        return this.routeManager;
+    }
+    /**
+     * Get the Container instance
+     * @returns IIOC
+     * @public API
+     */
+    get Container() {
+        return this.container;
+    }
+    /**
+     * Get the Express HTTP Server instance
+     * @returns express.Application
+     * @public API
+     */
+    getHttpServer() {
+        return this.app;
+    }
+    /**
+     * Create a new instance of the Express Micro API adapter
+     * @param config - Configuration options
+     * @returns ICreateMicroAPI
+     * @public API
+     */
+    create(config) {
+        this.app = (0, express_1.default)();
+        this.routeManager = new application_express_micro_route_1.Route(this.app);
+        this.container = new application_express_micro_container_1.IOC(config?.containerOptions);
+        this.middlewareManager = new core_1.Middleware();
+        this.environment = "development";
+        return this;
+    }
+    /**
+     * Build the Web Server Micro API
+     * @returns IWebServerMicroAPI
+     * @public API
+     */
+    build() {
+        this.routeManager.setGlobalRoutePrefix(this.globalPrefix);
+        return this;
+    }
+    /**
+     * Listen for incoming requests
+     * @param port - The port to listen on
+     * @param appInfo - Information about the application
+     * @public API
+     */
+    async listen(port, appInfo) {
+        const logger = new core_1.Logger();
+        this.port = typeof port === "string" ? parseInt(port, 10) : port || 3000;
+        this.configureMiddleware();
+        this.routeManager.applyRoutes();
+        if (this.Middleware.getErrorHandler()) {
+            this.app.use(this.Middleware.getErrorHandler());
+        }
+        return new Promise((resolve) => {
+            this.app.listen(this.port, () => {
+                const appInfoNormalized = appInfo ? `${appInfo?.appName} - ${appInfo?.appVersion} ` : "";
+                logger.info(`${appInfoNormalized}[${this.port}:${this.environment}]`, "MicroAPI");
+                ["SIGTERM", "SIGHUP", "SIGBREAK", "SIGQUIT", "SIGINT"].forEach((signal) => {
+                    process.on(signal, this.handleExit.bind(this));
+                });
+                resolve();
+            });
+        });
+    }
+}
+/**
+ * Create a new instance of the Express Micro API adapter
+ * @param config - Configuration options
+ * @returns ICreateMicroAPI
+ * @public API
+ */
+function createMicroAPI(config) {
+    const microAPI = new AppExpressMicro();
+    const create = microAPI.create.bind(microAPI);
+    return create(config);
+}

package/lib/cjs/adapter-express/micro-api/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMicroAPI = void 0;
+var application_express_micro_1 = require("./application-express-micro");
+Object.defineProperty(exports, "createMicroAPI", { enumerable: true, get: function () { return application_express_micro_1.createMicroAPI; } });

package/lib/cjs/adapter-express/render/constants.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PUG_DEFAULTS = exports.DEFAULT_PARTIALS_DIR = exports.HANDLEBARS_DEFAULTS = exports.EJS_DEFAULTS = void 0;
+const path_1 = require("path");
+/**
+ * Ejs defaults
+ * @type {EjsOptions}
+ * @constant
+ * @default
+ */
+exports.EJS_DEFAULTS = {
+    viewsDir: (0, path_1.join)(process.cwd(), "views"),
+    viewEngine: "ejs",
+    serverOptions: {},
+};
+/**
+ * Handlebars defaults
+ * @type {HandlebarsOptions}
+ * @constant
+ * @default
+ */
+exports.HANDLEBARS_DEFAULTS = {
+    viewEngine: "hbs",
+    viewsDir: (0, path_1.join)(process.cwd(), "views"),
+    partialsDir: (0, path_1.join)(process.cwd(), "views/partials"),
+};
+/**
+ * Default partials directory
+ */
+exports.DEFAULT_PARTIALS_DIR = (0, path_1.join)(process.cwd(), "views/partials");
+/**
+ * Pug defaults
+ * @type {PugOptions}
+ * @constant
+ * @default
+ */
+exports.PUG_DEFAULTS = {
+    viewEngine: "pug",
+    viewsDir: (0, path_1.join)(process.cwd(), "views"),
+};

package/lib/cjs/adapter-express/render/engine.js

@@ -1,15 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Engine = void 0;
+exports.setEngineEjs = setEngineEjs;
+exports.setEngineHandlebars = setEngineHandlebars;
+exports.setEnginePug = setEnginePug;
+const core_1 = require("@expressots/core");
+const resolve_render_1 = require("./resolve-render");
+const constants_1 = require("./constants");
 /**
- * The supported view engines.
- * @enum {string}
- * @readonly
- * @public
+ * Set Ejs as the view engine
+ * @param {Application} app - The express application
+ * @param {EjsOptions} [options=EJS_DEFAULTS] - The ejs options
  */
-var Engine;
-(function (Engine) {
-    Engine["HBS"] = "hbs";
-    Engine["EJS"] = "ejs";
-    Engine["PUG"] = "pug";
-})(Engine || (exports.Engine = Engine = {}));
+async function setEngineEjs(app, options = constants_1.EJS_DEFAULTS) {
+    (0, resolve_render_1.packageResolver)("ejs");
+    app.set("view engine", options.viewEngine || constants_1.EJS_DEFAULTS.viewEngine);
+    app.set("views", options.viewsDir || constants_1.EJS_DEFAULTS.viewsDir);
+    if (Array.isArray(options.viewsDir)) {
+        options.viewsDir.forEach((dir) => {
+            app.set("views", dir);
+        });
+    }
+    if (options.serverOptions) {
+        app.locals = {
+            ...app.locals,
+            ...options.serverOptions,
+        };
+    }
+}
+/**
+ * Set Handlebars as the view engine
+ * @param {express.Application} app - The express application
+ * @param {HandlebarsOptions} [options=HANDLEBARS_DEFAULTS] - The handlebars options
+ */
+async function setEngineHandlebars(app, options = constants_1.HANDLEBARS_DEFAULTS) {
+    const logger = new core_1.Logger();
+    try {
+        const hbs = (0, resolve_render_1.packageResolver)("hbs");
+        hbs.registerPartials(options.partialsDir || constants_1.DEFAULT_PARTIALS_DIR);
+        app.set("view engine", options.viewEngine || constants_1.HANDLEBARS_DEFAULTS.viewEngine);
+        app.set("views", options.viewsDir || constants_1.HANDLEBARS_DEFAULTS.viewsDir);
+    }
+    catch (error) {
+        logger.error(error.message, "handlebars-config");
+    }
+}
+/**
+ * Set Pug as the view engine
+ * @param {express.Application} app - The express application
+ * @param {PugOptions} [options=PUG_DEFAULTS] - The pug options
+ */
+async function setEnginePug(app, options = constants_1.PUG_DEFAULTS) {
+    (0, resolve_render_1.packageResolver)("pug");
+    app.set("view engine", options.viewEngine || constants_1.PUG_DEFAULTS.viewEngine);
+    app.set("views", options.viewsDir || constants_1.PUG_DEFAULTS.viewsDir);
+}

package/lib/cjs/adapter-express/render/index.js

@@ -1,5 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Engine = void 0;
-var engine_1 = require("./engine");
-Object.defineProperty(exports, "Engine", { enumerable: true, get: function () { return engine_1.Engine; } });

package/lib/cjs/di/di.interfaces.js

@@ -0,0 +1,10 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-namespace */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FactoryType = void 0;
+var FactoryType;
+(function (FactoryType) {
+    FactoryType["DynamicValue"] = "toDynamicValue";
+    FactoryType["Factory"] = "toFactory";
+    FactoryType["Provider"] = "toProvider";
+})(FactoryType || (exports.FactoryType = FactoryType = {}));

package/lib/cjs/types/adapter-express/application-express.base.d.ts

@@ -19,6 +19,17 @@
  * @abstract
  */
 export declare abstract class ApplicationBase {
+    /**
+     * Implement this method to set up global configurations for the server.
+     * This method is called before any other server initialization methods.
+     * Use this method to configure global settings that apply to the entire
+     * server application. Supports asynchronous setup with a Promise.
+     *
+     * @abstract
+     * @returns {void | Promise<void>}
+     * @public API
+     */
+    protected abstract globalConfiguration(): void | Promise<void>;
     /**
      * Implement this method to set up required services or configurations before
      * the server starts. This is essential for initializing dependencies or settings
@@ -26,6 +37,7 @@ export declare abstract class ApplicationBase {
      *
      * @abstract
      * @returns {void | Promise<void>}
+     * @public API
      */
     protected abstract configureServices(): void | Promise<void>;
     /**
@@ -35,6 +47,7 @@ export declare abstract class ApplicationBase {
      *
      * @abstract
      * @returns {void | Promise<void>}
+     * @public API
      */
     protected abstract postServerInitialization(): void | Promise<void>;
     /**
@@ -42,6 +55,10 @@ export declare abstract class ApplicationBase {
      * is shutting down. Ideal for closing resources, stopping tasks, or other
      * cleanup procedures to ensure a graceful server shutdown. Supports asynchronous
      * cleanup with a Promise.
+     *
+     * @abstract
+     * @returns {void | Promise<void>}
+     * @public API
      */
     protected abstract serverShutdown(): void | Promise<void>;
 }

package/lib/cjs/types/adapter-express/application-express.d.ts

@@ -1,9 +1,8 @@
-import { IApplicationMessageToConsole } from "@expressots/core";
 import express from "express";
-import { Container } from "inversify";
+import { AppContainer, IConsoleMessage, ProviderManager, IMiddleware } from "@expressots/core";
+import { RenderEngine, Env, Server } from "@expressots/shared";
+import { interfaces } from "../di/di.interfaces";
 import { ApplicationBase } from "./application-express.base";
-import { IWebServer, ServerEnvironment } from "./application-express.types";
-import { Engine, EngineOptions } from "./render/engine";
 /**
  * The AppExpress class provides methods for configuring and running an Express application.
  * @class AppExpress
@@ -15,16 +14,20 @@ import { Engine, EngineOptions } from "./render/engine";
  * @method setEngine - Configures the application's view engine based on the provided configuration options.
  * @method isDevelopment - Verifies if the current environment is development.
  */
-declare class AppExpress extends ApplicationBase implements IWebServer {
+export declare class AppExpress extends ApplicationBase implements Server.IWebServer {
     private logger;
+    private console;
     private app;
     private port;
-    private environment;
-    private container;
+    private environment?;
+    private appContainer;
     private globalPrefix;
+    private middlewareManager;
     private middlewares;
-    private console;
+    private providerManager;
     private renderOptions;
+    constructor();
+    protected globalConfiguration(): void | Promise<void>;
     protected configureServices(): void | Promise<void>;
     protected postServerInitialization(): void | Promise<void>;
     protected serverShutdown(): void | Promise<void>;
@@ -33,10 +36,29 @@ declare class AppExpress extends ApplicationBase implements IWebServer {
      */
     private handleExit;
     /**
-     * Configures the InversifyJS container.
-     * @param container - The InversifyJS container.
+     * Initialize the InversifyJS container with the provided modules and options.
+     * @param appModules - An array of application modules to be loaded into the container.
+     * @param containerOptions - Container global configuration options.
+     * @option skipBaseClassChecks - Skip the base class checks for the container.
+     * @option autoBindInjectable - Automatically bind the injectable classes.
+     * @option defaultScope - The default scope to use for bindings.
+     *
+     * @returns The configured AppContainer instance.
+     * @public API
+     */
+    configContainer(appModules: Array<interfaces.ContainerModule>, containerOptions?: interfaces.ContainerOptions): AppContainer;
+    /**
+     * Get the ProviderManager instance.
+     * @returns The ProviderManager instance.
+     * @public API
+     */
+    get Provider(): ProviderManager;
+    /**
+     * Get the Middleware instance.
+     * @returns The Middleware instance.
+     * @public API
      */
-    configure(container: Container): Promise<void>;
+    get Middleware(): IMiddleware;
     /**
      * Configures the Express application with the provided middleware entries.
      * @param app - The Express application instance.
@@ -53,18 +75,15 @@ declare class AppExpress extends ApplicationBase implements IWebServer {
     /**
      * Start listening on the given port and environment.
      * @param port - The port number to listen on.
-     * @param environment - The server environment.
-     * @param consoleMessage - Optional message to display in the console.
+     * @param appInfo - Optional message to display the app name and version.
+     * @public API
      */
-    listen(port: number, environment: ServerEnvironment, consoleMessage?: IApplicationMessageToConsole): Promise<void>;
+    listen(port: number | string, appInfo?: IConsoleMessage): Promise<void>;
     /**
      * Sets the global route prefix for the application.
-     *
-     * @public
      * @method setGlobalRoutePrefix
-     *
      * @param {string} prefix - The prefix to use for all routes.
-     *
+     * @public API
      */
     setGlobalRoutePrefix(prefix: string): void;
     /**
@@ -73,25 +92,41 @@ declare class AppExpress extends ApplicationBase implements IWebServer {
     private configEngine;
     /**
      * Configures the application's view engine based on the provided configuration options.
-     *
-     * @public
      * @method setEngine
      * @template T - A generic type extending from RenderTemplateOptions.
      *
      * @param {Engine} engine - The view engine to set
      * @param {EngineOptions} [options] - The configuration options for the view engine
+     * @public API
      */
-    setEngine<T extends EngineOptions>(engine: Engine, options?: T): Promise<void>;
+    setEngine<T extends RenderEngine.EngineOptions>(engine: RenderEngine.Engine, options?: T): Promise<void>;
     /**
      * Verifies if the current environment is development.
-     *
      * @returns A boolean value indicating whether the current environment is development or not.
+     * @public API
      */
     protected isDevelopment(): boolean;
+    /**
+     * Load environment variables from the specified file based on the environment configuration.
+     * @param environment - The environment to load configuration for.
+     * @param options - The options to use for loading the environment configuration.
+     * @option env - The environment configuration options.
+     * @example
+     * ```typescript
+     * {
+              env: {
+                  development: ".env.development",
+                  production: ".env.production"
+              }
+          }
+      * ```
+     * @public API
+     */
+    initEnvironment(environment: Env.Environment, options?: Env.IEnvironment): void;
     /**
      * Get the underlying HTTP server. (default: Express.js)
      * @returns The underlying HTTP server after initialization.
+     * @public API
      */
     getHttpServer(): Promise<express.Application>;
 }
-export { AppExpress };

package/lib/cjs/types/adapter-express/application-express.types.d.ts

@@ -1,21 +1,4 @@
-import express, { Request, Response, NextFunction } from "express";
-import { IApplicationMessageToConsole } from "@expressots/core";
-import { Container } from "inversify";
-import { Engine, EngineOptions } from "./render/engine";
-/**
- * Interface for the WebServer application implementation.
- */
-export interface IWebServer {
-    configure(container: Container): Promise<void>;
-    listen(port: number, environment: ServerEnvironment, consoleMessage?: IApplicationMessageToConsole): Promise<void>;
-    setEngine<T extends EngineOptions>(engine: Engine, options?: T): Promise<void>;
-}
-/**
- * Constructor type for IWebServer.
- */
-export interface IWebServerConstructor<T extends IWebServer> {
-    new (): T;
-}
+import express from "express";
 /**
  * ExpressHandler Type
  *
@@ -38,26 +21,3 @@ export type MiddlewareConfig = {
     path?: string;
     middlewares: Array<ExpressHandler>;
 };
-/**
- * Expresso middleware interface.
- */
-interface IExpressoMiddleware {
-    use(req: Request, res: Response, next: NextFunction): Promise<void> | void;
-}
-/**
- * Abstract class for creating custom Expresso middleware.
- * Custom middleware classes should extend this class and implement the use method.
- *
- */
-export declare abstract class ExpressoMiddleware implements IExpressoMiddleware {
-    get name(): string;
-    abstract use(req: Request, res: Response, next: NextFunction): Promise<void> | void;
-}
-/**
- * Enum representing possible server environments.
- */
-export declare enum ServerEnvironment {
-    Development = "development",
-    Production = "production"
-}
-export {};

package/lib/cjs/types/adapter-express/express-utils/base-middleware.d.ts

@@ -1,5 +1,5 @@
 import type { NextFunction, Request, Response } from "express";
-import { interfaces as inversifyInterfaces } from "inversify";
+import { interfaces as inversifyInterfaces } from "../../di/di.interfaces";
 import type { HttpContext } from "./interfaces";
 export declare abstract class BaseMiddleware implements BaseMiddleware {
     httpContext: HttpContext;

package/lib/cjs/types/adapter-express/express-utils/constants.d.ts

@@ -40,5 +40,5 @@ export declare enum HTTP_VERBS_ENUM {
     trace = "TRACE"
 }
 export declare const DUPLICATED_CONTROLLER_NAME: (name: string) => string;
-export declare const NO_CONTROLLERS_FOUND: string;
+export declare const NO_CONTROLLERS_FOUND = "No controller found! Please ensure that you have register at least one Controller.";
 export declare const DEFAULT_ROUTING_ROOT_PATH = "/";