@expressots/adapter-express 3.0.0 → 4.0.0-preview.3

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

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONDITIONAL_MIDDLEWARE_SYMBOL = void 0;
+exports.isConditionalMiddleware = isConditionalMiddleware;
+exports.when = when;
+exports.unless = unless;
+/**
+ * Symbol to identify conditional middleware configuration objects.
+ * Used internally for type checking.
+ */
+exports.CONDITIONAL_MIDDLEWARE_SYMBOL = Symbol("ConditionalMiddleware");
+/**
+ * Type guard to check if an object is a ConditionalMiddlewareConfig.
+ */
+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() {}
+ * ```
+ */
+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() {}
+ * ```
+ */
+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/cjs/adapter-express/express-utils/constants.js

@@ -6,11 +6,28 @@ exports.TYPE = {
     Controller: Symbol.for("Controller"),
     HttpContext: Symbol.for("HttpContext"),
 };
+// Import exception filter metadata keys from core to maintain compatibility
+const core_1 = require("@expressots/core");
 exports.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: core_1.EXCEPTION_FILTER_METADATA_KEY.exceptionFilter,
+    controllerExceptionFilters: core_1.EXCEPTION_FILTER_METADATA_KEY.controllerExceptionFilters,
+    methodExceptionFilters: core_1.EXCEPTION_FILTER_METADATA_KEY.methodExceptionFilters,
 };
 exports.HTTP_CODE_METADATA = {
     httpCode: "inversify-express-utils:httpcode",

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

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Accept = Accept;
+exports.Consumes = Consumes;
+exports.Produces = Produces;
+exports.CsvOptions = CsvOptions;
+exports.XmlOptions = XmlOptions;
+exports.YamlOptions = YamlOptions;
+exports.StreamResponse = StreamResponse;
+require("reflect-metadata");
+const constants_js_1 = require("./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
+ */
+function Accept(...contentTypes) {
+    return (target, key) => {
+        Reflect.defineMetadata(constants_js_1.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
+ */
+function Consumes(...contentTypes) {
+    return (target, key) => {
+        Reflect.defineMetadata(constants_js_1.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
+ */
+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
+ */
+function CsvOptions(options) {
+    return (target, key) => {
+        Reflect.defineMetadata(constants_js_1.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
+ */
+function XmlOptions(options) {
+    return (target, key) => {
+        Reflect.defineMetadata(constants_js_1.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
+ */
+function YamlOptions(options) {
+    return (target, key) => {
+        Reflect.defineMetadata(constants_js_1.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
+ */
+function StreamResponse() {
+    return (target, key) => {
+        Reflect.defineMetadata(constants_js_1.METADATA_KEY.streamResponse, true, target, key);
+    };
+}