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

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

@@ -2,67 +2,75 @@ import "reflect-metadata";
 import { PARAMETER_TYPE, HTTP_VERBS_ENUM } from "./constants";
 import type { HandlerDecorator, Middleware } from "./interfaces";
 import { Request } from "express";
-export declare const injectHttpContext: (target: import("inversify/lib/annotation/decorator_utils").DecoratorTarget<unknown>, targetKey?: string | symbol | undefined, indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<unknown>) => void;
+export declare const injectHttpContext: (target: import("@expressots/core/lib/cjs/types/di/annotation/decorator_utils").DecoratorTarget, targetKey?: string | symbol, indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<unknown>) => void;
 /**
  * Controller decorator to define a new controller
  * @param path route path
  * @param middleware array of middleware to be applied to all routes in the controller
+ * @public API
  */
 export declare function controller(path: string, ...middleware: Array<Middleware>): (target: NewableFunction) => void;
 /**
  * Http decorator to define the status code for a route
  * @param code
  * @returns MethodDecorator
- * @example
- * ```ts
+ * @example ```typescript
  * @Http(200)
  * @Get("/")
  * hello() {
  *  return "Hello World";
  * }
  * ```
+ * @public API
  */
 export declare function Http(code: number): (target: object, key: string | symbol, descriptor: TypedPropertyDescriptor<any>) => void;
 /**
  * Decorator to allow accept all HTTP methods
  * @param path route path, wildcard
  * @param middleware array of middleware to be applied to all routes defined in path logic
+ * @public API
  */
 export declare function All(path: string, ...middleware: Array<Middleware>): HandlerDecorator;
 /**
  * Decorator to allow GET HTTP method
  * @param path route path
  * @param middleware array of middleware to be applied to the route
+ * @public API
  */
 export declare function Get(path: string, ...middleware: Array<Middleware>): HandlerDecorator;
 /**
  * Decorator to allow POST HTTP method
  * @param path route path
  * @param middleware array of middleware to be applied to the route
+ * @public API
  */
 export declare function Post(path: string, ...middleware: Array<Middleware>): HandlerDecorator;
 /**
  * Decorator to allow PUT HTTP method
  * @param path route path
  * @param middleware array of middleware to be applied to the route
+ * @public API
  */
 export declare function Put(path: string, ...middleware: Array<Middleware>): HandlerDecorator;
 /**
  * Decorator to allow PATCH HTTP method
  * @param path route path
  * @param middleware array of middleware to be applied to the route
+ * @public API
  */
 export declare function Patch(path: string, ...middleware: Array<Middleware>): HandlerDecorator;
 /**
  * Decorator to allow HEAD HTTP method
  * @param path route path
  * @param middleware array of middleware to be applied to the route
+ * @public API
  */
 export declare function Head(path: string, ...middleware: Array<Middleware>): HandlerDecorator;
 /**
  * Decorator to allow DELETE HTTP method
  * @param path route path
  * @param middleware array of middleware to be applied to the route
+ * @public API
  */
 export declare function Delete(path: string, ...middleware: Array<Middleware>): HandlerDecorator;
 /**
@@ -70,6 +78,7 @@ export declare function Delete(path: string, ...middleware: Array<Middleware>):
  * @param method custom HTTP method
  * @param path route path
  * @param middleware array of middleware to be applied to the route
+ * @public API
  */
 export declare function Method(method: keyof typeof HTTP_VERBS_ENUM, path: string, ...middleware: Array<Middleware>): HandlerDecorator;
 /**
@@ -120,13 +129,17 @@ export declare const principal: () => ParameterDecorator;
 /**
  * Parameter decorator to inject the request object
  * @returns ParameterDecorator
+ * @param type - The type of parameter to inject
+ * @param parameterName - The name of the parameter to inject
+ * @public API
  */
 export declare function params(type: PARAMETER_TYPE, parameterName?: string): ParameterDecorator;
 /**
  * Render decorator to define the template and default data for a route
  * @param template The template to render
  * @param defaultData The default data to pass to the template
- * @returns
+ * @returns MethodDecorator
+ * @public API
  */
 export declare function Render(template: string, defaultData?: Record<string, unknown>): MethodDecorator;
 export declare function getRenderMetadata(target: object, propertyKey: string | symbol): {
@@ -187,6 +200,7 @@ type FieldOptions = {
  * @param multerOptions
  * @default { none: true }
  * @returns MethodDecorator
+ * @public API
  */
 export declare function FileUpload(options?: FieldOptions | Array<FieldOptions> | {
     none?: boolean;

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

@@ -6,6 +6,8 @@ import { ExpressoMiddleware } from "@expressots/core";
  * @returns express.RequestHandler
  */
 export declare class HttpStatusCodeMiddleware extends ExpressoMiddleware {
+    private globalPrefix;
+    constructor(globalPrefix?: string);
     use(req: Request, res: Response, next: NextFunction): void | Promise<void>;
     /**
      * Find the matching parameter path.

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

@@ -1,5 +1,5 @@
 import type { Application, NextFunction, Request, RequestHandler, Response } from "express";
-import { interfaces as inversifyInterfaces } from "inversify";
+import { interfaces as inversifyInterfaces } from "../../di/di.interfaces";
 import { HTTP_VERBS_ENUM, PARAMETER_TYPE } from "./constants";
 import { HttpResponseMessage } from "./httpResponseMessage";
 type Prototype<T> = {

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

@@ -1,5 +1,5 @@
 import express, { Application, Router } from "express";
-import { interfaces } from "inversify";
+import { interfaces } from "../../di/di.interfaces";
 import type { AuthProvider, ConfigFunction, RoutingConfig } from "./interfaces";
 export declare class InversifyExpressServer {
     private _router;

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

@@ -1,4 +1,4 @@
-import { interfaces } from "inversify";
+import { interfaces } from "../../di/di.interfaces";
 import type { BaseController, ControllerMetadata, ControllerMethodMetadata, ControllerParameterMetadata, DecoratorTarget, IHttpActionResult } from "./interfaces";
 export declare function getControllersFromContainer(container: interfaces.Container, forceControllers: boolean): Array<BaseController>;
 export declare function getControllersFromMetadata(): Array<DecoratorTarget>;

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

@@ -1,5 +1,5 @@
 export * from "./express-utils";
 export { AppExpress } from "./application-express";
-export { IWebServerPublic } from "./application-express.interface";
-export { IWebServer, IWebServerConstructor } from "./application-express.types";
+export * from "./micro-api";
+export { IWebServerPublic, IWebServer, IWebServerConstructor, Environment, IEnvironment, RenderEngine, } from "@expressots/shared";
 export * from "./render";

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

@@ -0,0 +1,47 @@
+import { interfaces } from "@expressots/core";
+/**
+ * Inversion of Control Container interface
+ * @public API
+ */
+export interface IIOC {
+    addSingleton<T>(concrete: interfaces.Newable<T>): void;
+    addTransient<T>(concrete: interfaces.Newable<T>): void;
+    addScoped<T>(concrete: interfaces.Newable<T>): void;
+    get<I>(identifier: interfaces.ServiceIdentifier<I>): I;
+}
+/**
+ * Inversion of Control Container
+ * @public API
+ */
+export declare class IOC {
+    private container;
+    constructor(containerOptions?: interfaces.ContainerOptions);
+    /**
+     * Add a singleton to the container
+     * @param identifierOrConcrete - The identifier or concrete class
+     * @param concrete - The concrete class if identifier is provided
+     * @public API
+     */
+    addSingleton<T>(concrete: interfaces.Newable<T>): void;
+    /**
+     * Add a transient to the container
+     * @param identifierOrConcrete - The identifier or concrete class
+     * @param concrete - The concrete class if identifier is provided
+     * @public API
+     */
+    addTransient<T>(concrete: interfaces.Newable<T>): void;
+    /**
+     * Add a scoped to the container
+     * @param identifierOrConcrete - The identifier or concrete class
+     * @param concrete - The concrete class if identifier is provided
+     * @public API
+     */
+    addScoped<T>(concrete: interfaces.Newable<T>): void;
+    /**
+     * Get an instance from the container
+     * @param identifier - The identifier for the instance
+     * @returns The resolved instance
+     * @public API
+     */
+    get(identifier: interfaces.ServiceIdentifier): any;
+}

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

@@ -0,0 +1,93 @@
+import express from "express";
+import { Middleware } from "../express-utils/interfaces";
+type RouteDefinition = {
+    method: "get" | "post" | "put" | "patch" | "delete";
+    path: string;
+    handler: express.RequestHandler;
+    middleware: Array<Middleware>;
+};
+/**
+ * Route manager for Express Micro API adapter
+ * @public API
+ */
+export interface IRoute {
+    define(method: "get" | "post" | "put" | "delete" | "patch", path: string, handler: express.RequestHandler, ...middleware: Array<Middleware>): void;
+    get(path: string, handler: express.RequestHandler, ...middleware: Array<Middleware>): void;
+    post(path: string, handler: express.RequestHandler, ...middleware: Array<Middleware>): void;
+    put(path: string, handler: express.RequestHandler, ...middleware: Array<Middleware>): void;
+    delete(path: string, handler: express.RequestHandler, ...middleware: Array<Middleware>): void;
+    patch(path: string, handler: express.RequestHandler, ...middleware: Array<Middleware>): void;
+}
+export declare class Route implements IRoute {
+    private logger;
+    private routes;
+    private app;
+    private globalPrefix;
+    constructor(app: express.Application);
+    /**
+     * Set the global route prefix
+     * @param prefix
+     * @public API
+     */
+    setGlobalRoutePrefix(prefix: string): void;
+    /**
+     * Define a route
+     * @param method - HTTP method
+     * @param path - Route path
+     * @param handler - Route handler
+     * @param middleware - Route middleware
+     * @public API
+     */
+    define(method: "get" | "post" | "put" | "delete" | "patch", path: string, handler: express.RequestHandler, ...middleware: Array<Middleware>): void;
+    /**
+     * Define a GET route
+     * @param path - Route path
+     * @param handler - Route handler
+     * @param middleware - Route middleware
+     * @public API
+     */
+    get(path: string, handler: express.RequestHandler, ...middleware: Array<Middleware>): void;
+    /**
+     * Define a POST route
+     * @param path - Route path
+     * @param handler - Route handler
+     * @param middleware - Route middleware
+     * @public API
+     */
+    post(path: string, handler: express.RequestHandler, ...middleware: Array<Middleware>): void;
+    /**
+     * Define a PUT route
+     * @param path - Route path
+     * @param handler - Route handler
+     * @param middleware - Route middleware
+     * @public API
+     */
+    put(path: string, handler: express.RequestHandler, ...middleware: Array<Middleware>): void;
+    /**
+     * Define a DELETE route
+     * @param path - Route path
+     * @param handler - Route handler
+     * @param middleware - Route middleware
+     * @public API
+     */
+    delete(path: string, handler: express.RequestHandler, ...middleware: Array<Middleware>): void;
+    /**
+     * Define a PATCH route
+     * @param path - Route path
+     * @param handler - Route handler
+     * @param middleware - Route middleware
+     * @public API
+     */
+    patch(path: string, handler: express.RequestHandler, ...middleware: Array<Middleware>): void;
+    /**
+     * Apply the routes to the Express application
+     */
+    applyRoutes(): void;
+    /**
+     * Get the routes
+     * @returns Array of route definitions
+     * @public API
+     */
+    get Routes(): Array<RouteDefinition>;
+}
+export {};

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

@@ -0,0 +1,79 @@
+import { IMiddleware, interfaces } from "@expressots/core";
+import { Env, IConsoleMessage } from "@expressots/shared";
+import express from "express";
+import { IIOC } from "./application-express-micro-container";
+import { IRoute } from "./application-express-micro-route";
+/**
+ * Configuration options for the Express Micro API adapter
+ * @public API
+ */
+export type MicroAPIConfig = {
+    containerOptions: interfaces.ContainerOptions;
+};
+/**
+ * Interface for the Create Method of Express Micro API adapter
+ */
+export interface ICreateMicroAPI {
+    /**
+     * Initialize the environment for the application
+     * @param environment - The environment to initialize
+     * @param options - Options for the environment initialization
+     * @public API
+     */
+    initEnvironment(environment: Env.Environment, options?: Env.IEnvironment): void;
+    /**
+     * Set the global route prefix
+     * @param prefix - The global route prefix
+     * @public API
+     */
+    setGlobalRoutePrefix(prefix: string): void;
+    /**
+     * Get the Container instance
+     * @returns IIOC - The container instance interface
+     * @public API
+     */
+    get Container(): IIOC;
+    /**
+     * Get the Express HTTP Server instance
+     * @returns express.Application
+     * @public API
+     */
+    getHttpServer(): express.Application;
+    /**
+     * Build the Web Server Micro API
+     * @returns IWebServerMicroAPI
+     * @public API
+     */
+    build(): IWebServerMicroAPI;
+}
+/**
+ * Interface for the Build Method of the Web Server Micro API adapter
+ */
+export interface IWebServerMicroAPI {
+    /**
+     * Get the Middleware instance
+     * @returns IMiddleware
+     * @public API
+     */
+    get Middleware(): IMiddleware;
+    /**
+     * Get the Route instance
+     * @returns IRoute
+     * @public API
+     */
+    get Route(): IRoute;
+    /**
+     * Listen for incoming requests
+     * @param port - The port to listen on
+     * @param appInfo - Information about the application
+     * @public API
+     */
+    listen(port: number | string, appInfo?: IConsoleMessage): Promise<void>;
+}
+/**
+ * Create a new instance of the Express Micro API adapter
+ * @param config - Configuration options
+ * @returns ICreateMicroAPI
+ * @public API
+ */
+export declare function createMicroAPI(config?: MicroAPIConfig): ICreateMicroAPI;

package/lib/cjs/types/adapter-express/micro-api/index.d.ts

@@ -0,0 +1 @@
+export { createMicroAPI, MicroAPIConfig } from "./application-express-micro";

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

@@ -0,0 +1,26 @@
+import { RenderEngine } from "@expressots/shared";
+/**
+ * Ejs defaults
+ * @type {EjsOptions}
+ * @constant
+ * @default
+ */
+export declare const EJS_DEFAULTS: RenderEngine.EjsOptions;
+/**
+ * Handlebars defaults
+ * @type {HandlebarsOptions}
+ * @constant
+ * @default
+ */
+export declare const HANDLEBARS_DEFAULTS: RenderEngine.HandlebarsOptions;
+/**
+ * Default partials directory
+ */
+export declare const DEFAULT_PARTIALS_DIR: string;
+/**
+ * Pug defaults
+ * @type {PugOptions}
+ * @constant
+ * @default
+ */
+export declare const PUG_DEFAULTS: RenderEngine.PugOptions;

package/lib/cjs/types/adapter-express/render/engine.d.ts

@@ -1,28 +1,20 @@
-import { EjsOptions } from "./ejs/ejs.config";
-import { HandlebarsOptions } from "./handlebars/hbs.config";
+import { Application } from "express";
+import { RenderEngine } from "@expressots/shared";
 /**
- * The configuration options for the view engine.
- * @typedef {HandlebarsOptions | EjsOptions} EngineOptions
- * @private
+ * Set Ejs as the view engine
+ * @param {Application} app - The express application
+ * @param {EjsOptions} [options=EJS_DEFAULTS] - The ejs options
  */
-export type RenderOptions = {
-    engine: Engine;
-    options?: EngineOptions;
-};
+export declare function setEngineEjs(app: Application, options?: RenderEngine.EjsOptions): Promise<void>;
 /**
- * The supported view engines.
- * @enum {string}
- * @readonly
- * @public
+ * Set Handlebars as the view engine
+ * @param {express.Application} app - The express application
+ * @param {HandlebarsOptions} [options=HANDLEBARS_DEFAULTS] - The handlebars options
  */
-export declare enum Engine {
-    HBS = "hbs",
-    EJS = "ejs",
-    PUG = "pug"
-}
+export declare function setEngineHandlebars(app: Application, options?: RenderEngine.HandlebarsOptions): Promise<void>;
 /**
- * The configuration options for the view engine.
- * @typedef {HandlebarsOptions | EjsOptions} EngineOptions
- * @public
+ * Set Pug as the view engine
+ * @param {express.Application} app - The express application
+ * @param {PugOptions} [options=PUG_DEFAULTS] - The pug options
  */
-export type EngineOptions = HandlebarsOptions | EjsOptions;
+export declare function setEnginePug(app: Application, options?: RenderEngine.PugOptions): Promise<void>;

package/lib/cjs/types/adapter-express/render/index.d.ts

@@ -1,4 +1,4 @@
-export { EjsOptions as EJS } from "./ejs/ejs.config";
-export { HandlebarsOptions as HBS } from "./handlebars/hbs.config";
-export { PugOptions as PUG } from "./pug/pug.config";
-export { Engine } from "./engine";
+import { RenderEngine } from "@expressots/shared";
+export type EJS = RenderEngine.EjsOptions;
+export type HBS = RenderEngine.HandlebarsOptions;
+export type PUG = RenderEngine.PugOptions;