@expressots/adapter-express 3.0.0-beta.4.2 → 4.0.0-preview.1

package/lib/esm/adapter-express/application-express.types.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/adapter-express/express-utils/base-middleware.js

@@ -0,0 +1,19 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable } from "@expressots/core";
+let BaseMiddleware = class BaseMiddleware {
+    // httpContext is initialized when the middleware is invoked
+    // see resolveMiddleware in server.ts for more details
+    httpContext;
+    bind(serviceIdentifier) {
+        return this.httpContext.container.bind(serviceIdentifier);
+    }
+};
+BaseMiddleware = __decorate([
+    injectable()
+], BaseMiddleware);
+export { BaseMiddleware };

package/lib/esm/adapter-express/express-utils/conditional-middleware.js

@@ -0,0 +1,96 @@
+/**
+ * Symbol to identify conditional middleware configuration objects.
+ * Used internally for type checking.
+ */
+export const CONDITIONAL_MIDDLEWARE_SYMBOL = Symbol("ConditionalMiddleware");
+/**
+ * Type guard to check if an object is a ConditionalMiddlewareConfig.
+ */
+export function isConditionalMiddleware(item) {
+    return (typeof item === "object" &&
+        item !== null &&
+        "condition" in item &&
+        "middleware" in item &&
+        typeof item.condition === "function");
+}
+/**
+ * Creates a conditional middleware configuration that executes the middleware
+ * when the condition evaluates to true.
+ *
+ * @param condition - Function that receives the Request and returns boolean or Promise<boolean>
+ * @param middleware - The middleware to execute when condition is true
+ * @returns ConditionalMiddlewareConfig object
+ *
+ * @example
+ * ```typescript
+ * // Phase 2: Class reference support - no 'new' keyword needed
+ * @Get("/admin",
+ *   when(req => req.hostname.startsWith("admin."), AdminMiddleware),
+ *   AuthMiddleware
+ * )
+ * async adminHandler() {}
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Async condition with class reference (Phase 2)
+ * @Get("/api",
+ *   when(async req => {
+ *     const user = await getUser(req);
+ *     return user.isAdmin;
+ *   }, AdminMiddleware)
+ * )
+ * async apiHandler() {}
+ * ```
+ */
+export function when(condition, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+middleware) {
+    return {
+        condition,
+        middleware: middleware,
+        skipOnFalse: true,
+    };
+}
+/**
+ * Creates a conditional middleware configuration that executes the middleware
+ * when the condition evaluates to false (inverse of `when`).
+ *
+ * @param condition - Function that receives the Request and returns boolean or Promise<boolean>
+ * @param middleware - The middleware to execute when condition is false
+ * @returns ConditionalMiddlewareConfig object
+ *
+ * @example
+ * ```typescript
+ * // Phase 2: Class reference support - no 'new' keyword needed
+ * @Get("/public",
+ *   unless(req => req.headers.authorization, AuthMiddleware)
+ * )
+ * async publicHandler() {}
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Skip authentication for public routes (Phase 2: class reference)
+ * @Get("/health",
+ *   unless(req => req.path.startsWith("/api"), AuthMiddleware)
+ * )
+ * async healthCheck() {}
+ * ```
+ */
+export function unless(condition, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+middleware) {
+    return {
+        condition: (req) => {
+            const result = condition(req);
+            // Invert the condition: if condition returns Promise, return inverted Promise
+            if (result instanceof Promise) {
+                return result.then((value) => !value);
+            }
+            return !result;
+        },
+        middleware: middleware,
+        skipOnFalse: true,
+    };
+}

package/lib/esm/adapter-express/express-utils/constants.js

@@ -0,0 +1,63 @@
+export const TYPE = {
+    AuthProvider: Symbol.for("AuthProvider"),
+    Controller: Symbol.for("Controller"),
+    HttpContext: Symbol.for("HttpContext"),
+};
+// Import exception filter metadata keys from core to maintain compatibility
+import { EXCEPTION_FILTER_METADATA_KEY } from "@expressots/core";
+export const METADATA_KEY = {
+    controller: "inversify-express-utils:controller",
+    controllerMethod: "inversify-express-utils:controller-method",
+    controllerParameter: "inversify-express-utils:controller-parameter",
+    httpContext: "inversify-express-utils:httpcontext",
+    version: "inversify-express-utils:version",
+    accept: "inversify-express-utils:accept",
+    consumes: "inversify-express-utils:consumes",
+    produces: "inversify-express-utils:produces",
+    csvOptions: "inversify-express-utils:csv-options",
+    xmlOptions: "inversify-express-utils:xml-options",
+    yamlOptions: "inversify-express-utils:yaml-options",
+    streamResponse: "inversify-express-utils:stream-response",
+    // Validation metadata
+    validationSchema: "inversify-express-utils:validation-schema",
+    validationOptions: "inversify-express-utils:validation-options",
+    // Re-export exception filter metadata keys from core for backward compatibility
+    exceptionFilter: EXCEPTION_FILTER_METADATA_KEY.exceptionFilter,
+    controllerExceptionFilters: EXCEPTION_FILTER_METADATA_KEY.controllerExceptionFilters,
+    methodExceptionFilters: EXCEPTION_FILTER_METADATA_KEY.methodExceptionFilters,
+};
+export const HTTP_CODE_METADATA = {
+    httpCode: "inversify-express-utils:httpcode",
+    statusCode: "inversify-express-utils:statuscode",
+    path: "inversify-express-utils:path",
+};
+export const RENDER_METADATA_KEY = Symbol("Render");
+export var PARAMETER_TYPE;
+(function (PARAMETER_TYPE) {
+    PARAMETER_TYPE[PARAMETER_TYPE["REQUEST"] = 0] = "REQUEST";
+    PARAMETER_TYPE[PARAMETER_TYPE["RESPONSE"] = 1] = "RESPONSE";
+    PARAMETER_TYPE[PARAMETER_TYPE["PARAMS"] = 2] = "PARAMS";
+    PARAMETER_TYPE[PARAMETER_TYPE["QUERY"] = 3] = "QUERY";
+    PARAMETER_TYPE[PARAMETER_TYPE["BODY"] = 4] = "BODY";
+    PARAMETER_TYPE[PARAMETER_TYPE["HEADERS"] = 5] = "HEADERS";
+    PARAMETER_TYPE[PARAMETER_TYPE["COOKIES"] = 6] = "COOKIES";
+    PARAMETER_TYPE[PARAMETER_TYPE["NEXT"] = 7] = "NEXT";
+    PARAMETER_TYPE[PARAMETER_TYPE["PRINCIPAL"] = 8] = "PRINCIPAL";
+})(PARAMETER_TYPE || (PARAMETER_TYPE = {}));
+export var HTTP_VERBS_ENUM;
+(function (HTTP_VERBS_ENUM) {
+    HTTP_VERBS_ENUM["all"] = "ALL";
+    HTTP_VERBS_ENUM["connect"] = "CONNECT";
+    HTTP_VERBS_ENUM["delete"] = "DELETE";
+    HTTP_VERBS_ENUM["get"] = "GET";
+    HTTP_VERBS_ENUM["head"] = "HEAD";
+    HTTP_VERBS_ENUM["options"] = "OPTIONS";
+    HTTP_VERBS_ENUM["patch"] = "PATCH";
+    HTTP_VERBS_ENUM["post"] = "POST";
+    HTTP_VERBS_ENUM["propfind"] = "PROPFIND";
+    HTTP_VERBS_ENUM["put"] = "PUT";
+    HTTP_VERBS_ENUM["trace"] = "TRACE";
+})(HTTP_VERBS_ENUM || (HTTP_VERBS_ENUM = {}));
+export const DUPLICATED_CONTROLLER_NAME = (name) => `Two controllers cannot have the same name: ${name}`;
+export const NO_CONTROLLERS_FOUND = "No controller found! Please ensure that you have register at least one Controller.";
+export const DEFAULT_ROUTING_ROOT_PATH = "/";

package/lib/esm/adapter-express/express-utils/content/httpContent.js

@@ -0,0 +1,6 @@
+export class HttpContent {
+    _headers = {};
+    get headers() {
+        return this._headers;
+    }
+}

package/lib/esm/adapter-express/express-utils/content-negotiation-decorators.js

@@ -0,0 +1,120 @@
+import "reflect-metadata";
+import { METADATA_KEY } from "./constants.js";
+/**
+ * Accept decorator to specify which content types this route accepts for responses.
+ * Used for content negotiation based on Accept header.
+ * @param contentTypes - Array of accepted content types (e.g., ["application/json", "application/xml"])
+ * @returns MethodDecorator
+ * @example
+ * ```typescript
+ * @Accept("application/json", "application/xml")
+ * @Get("/users")
+ * getUsers() {
+ *   return [{ id: 1, name: "John" }];
+ * }
+ * ```
+ * @public API
+ */
+export function Accept(...contentTypes) {
+    return (target, key) => {
+        Reflect.defineMetadata(METADATA_KEY.accept, contentTypes, target, key);
+    };
+}
+/**
+ * Consumes decorator to specify which content types this route consumes for requests.
+ * Used for content negotiation based on Content-Type header.
+ * @param contentTypes - Array of consumed content types (e.g., ["application/json", "application/xml"])
+ * @returns MethodDecorator
+ * @example
+ * ```typescript
+ * @Consumes("application/json", "application/xml")
+ * @Post("/users")
+ * createUser(@body() user: UserDto) {
+ *   return this.userService.create(user);
+ * }
+ * ```
+ * @public API
+ */
+export function Consumes(...contentTypes) {
+    return (target, key) => {
+        Reflect.defineMetadata(METADATA_KEY.consumes, contentTypes, target, key);
+    };
+}
+/**
+ * Produces decorator to specify which content types this route produces for responses.
+ * Alias for @Accept() decorator.
+ * @param contentTypes - Array of produced content types
+ * @returns MethodDecorator
+ * @public API
+ */
+export function Produces(...contentTypes) {
+    return Accept(...contentTypes);
+}
+/**
+ * CsvOptions decorator to configure CSV formatting options for a route.
+ * @param options - CSV formatting options
+ * @returns MethodDecorator
+ * @example
+ * ```typescript
+ * @CsvOptions({ fields: ["id", "name"], includeHeaders: true })
+ * @Get("/users")
+ * getUsers() {
+ *   return [{ id: 1, name: "John", email: "john@example.com" }];
+ * }
+ * ```
+ * @public API
+ */
+export function CsvOptions(options) {
+    return (target, key) => {
+        Reflect.defineMetadata(METADATA_KEY.csvOptions, options, target, key);
+    };
+}
+/**
+ * XmlOptions decorator to configure XML formatting options for a route.
+ * @param options - XML formatting options
+ * @returns MethodDecorator
+ * @example
+ * ```typescript
+ * @XmlOptions({ rootElement: "users", itemElement: "user", prettyPrint: true })
+ * @Get("/users")
+ * getUsers() {
+ *   return [{ id: 1, name: "John" }];
+ * }
+ * ```
+ * @public API
+ */
+export function XmlOptions(options) {
+    return (target, key) => {
+        Reflect.defineMetadata(METADATA_KEY.xmlOptions, options, target, key);
+    };
+}
+/**
+ * YamlOptions decorator to configure YAML formatting options for a route.
+ * @param options - YAML formatting options
+ * @returns MethodDecorator
+ * @public API
+ */
+export function YamlOptions(options) {
+    return (target, key) => {
+        Reflect.defineMetadata(METADATA_KEY.yamlOptions, options, target, key);
+    };
+}
+/**
+ * StreamResponse decorator to indicate that the response should be streamed.
+ * Useful for large datasets.
+ * @returns MethodDecorator
+ * @example
+ * ```typescript
+ * @StreamResponse()
+ * @Get("/large-dataset")
+ * getLargeDataset() {
+ *   return this.dataService.streamLargeDataset(); // Returns async iterator
+ * }
+ * ```
+ * @public API
+ */
+export function StreamResponse() {
+    return (target, key) => {
+        Reflect.defineMetadata(METADATA_KEY.streamResponse, true, target, key);
+    };
+}