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

package/lib/cjs/adapter-express/micro-api/queue/rabbitmq-consumer.js

@@ -0,0 +1,255 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitMQConsumer = void 0;
+/**
+ * Load amqplib dynamically to avoid requiring it as a dependency
+ */
+async function loadAmqpLib() {
+    try {
+        // `amqplib` is an OPTIONAL peer dep - it is intentionally not installed
+        // in this package's devDependencies. We route the specifier through a
+        // variable so TypeScript does not try to statically resolve it during
+        // build (TS treats variable-typed specifiers in `await import(...)` as
+        // `any` and skips the resolution check). Resolution happens at runtime
+        // in user apps that have actually installed amqplib.
+        const specifier = "amqplib";
+        const amqp = (await Promise.resolve(`${specifier}`).then(s => __importStar(require(s))));
+        return amqp;
+    }
+    catch {
+        throw new Error("amqplib is not installed. Install it with: npm install amqplib @types/amqplib");
+    }
+}
+/**
+ * RabbitMQ Consumer - Message queue consumer for RabbitMQ.
+ *
+ * Features:
+ * - Message consumption with handlers
+ * - Message publishing
+ * - Exchange support
+ * - Automatic reconnection
+ * - Prefetch control
+ * - Dead letter queue support
+ *
+ * @example
+ * ```typescript
+ * const orderQueue = new RabbitMQConsumer({
+ *     url: process.env.RABBITMQ_URL,
+ *     queue: "orders",
+ *     prefetch: 10,
+ * });
+ *
+ * // Start consuming
+ * await orderQueue.consume(async (message) => {
+ *     const order = message.body;
+ *     console.log("Processing order:", order.id);
+ *     await processOrder(order);
+ * });
+ *
+ * // Publish from HTTP endpoint
+ * app.Route.post("/orders", async (req, res) => {
+ *     await orderQueue.publish(req.body);
+ *     res.status(202).json({ message: "Order queued" });
+ * });
+ *
+ * // Graceful shutdown
+ * process.on("SIGTERM", async () => {
+ *     await orderQueue.close();
+ * });
+ * ```
+ *
+ * Note: This implementation requires the 'amqplib' package.
+ * Install with: npm install amqplib @types/amqplib
+ */
+class RabbitMQConsumer {
+    constructor(config) {
+        // Using 'any' for AMQP types since amqplib is an optional peer dependency
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.connection = null;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.channel = null;
+        this.stats = {
+            messagesReceived: 0,
+            messagesProcessed: 0,
+            messagesFailed: 0,
+            messagesPublished: 0,
+            isConnected: false,
+        };
+        this.config = {
+            queue: config.queue,
+            url: config.url,
+            exchange: config.exchange ?? "",
+            exchangeType: config.exchangeType ?? "direct",
+            routingKey: config.routingKey ?? config.queue,
+            prefetch: config.prefetch ?? 1,
+            durable: config.durable ?? true,
+            concurrency: config.concurrency ?? 1,
+            autoAck: config.autoAck ?? true,
+            debug: config.debug ?? false,
+        };
+    }
+    /**
+     * Connect to RabbitMQ
+     */
+    async connect() {
+        if (this.connection)
+            return;
+        try {
+            const amqp = await loadAmqpLib();
+            this.connection = await amqp.connect(this.config.url);
+            this.channel = await this.connection.createChannel();
+            // Set prefetch
+            await this.channel.prefetch(this.config.prefetch);
+            // Declare queue
+            await this.channel.assertQueue(this.config.queue, {
+                durable: this.config.durable,
+            });
+            // Declare exchange if configured
+            if (this.config.exchange) {
+                await this.channel.assertExchange(this.config.exchange, this.config.exchangeType, {
+                    durable: true,
+                });
+                // Bind queue to exchange
+                await this.channel.bindQueue(this.config.queue, this.config.exchange, this.config.routingKey);
+            }
+            this.stats.isConnected = true;
+            if (this.config.debug) {
+                console.log(`[RabbitMQ] Connected to ${this.config.url}, queue: ${this.config.queue}`);
+            }
+            // Handle connection close
+            this.connection.on("close", () => {
+                this.stats.isConnected = false;
+                console.log("[RabbitMQ] Connection closed");
+            });
+            this.connection.on("error", (err) => {
+                console.error("[RabbitMQ] Connection error:", err);
+            });
+        }
+        catch (error) {
+            console.error("[RabbitMQ] Failed to connect:", error);
+            throw error;
+        }
+    }
+    /**
+     * Start consuming messages
+     */
+    async consume(handler) {
+        await this.connect();
+        if (!this.channel) {
+            throw new Error("Channel not initialized");
+        }
+        await this.channel.consume(this.config.queue, 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        async (msg) => {
+            if (!msg)
+                return;
+            this.stats.messagesReceived++;
+            this.stats.lastMessageAt = new Date();
+            try {
+                // Parse message
+                const body = JSON.parse(msg.content.toString());
+                const queueMessage = {
+                    id: msg.properties.messageId || Date.now().toString(36),
+                    body,
+                    headers: msg.properties.headers,
+                    timestamp: new Date(msg.properties.timestamp || Date.now()),
+                    receiveCount: msg.properties.headers?.["x-delivery-count"] || 1,
+                    raw: msg,
+                };
+                if (this.config.debug) {
+                    console.log(`[RabbitMQ] Received message:`, queueMessage.id);
+                }
+                // Process message
+                await handler(queueMessage);
+                this.stats.messagesProcessed++;
+                // Acknowledge
+                if (!this.config.autoAck && this.channel) {
+                    this.channel.ack(msg);
+                }
+            }
+            catch (error) {
+                this.stats.messagesFailed++;
+                console.error("[RabbitMQ] Message processing failed:", error);
+                // Reject and requeue if not auto-ack
+                if (!this.config.autoAck && this.channel) {
+                    this.channel.nack(msg, false, true);
+                }
+            }
+        }, { noAck: this.config.autoAck });
+        if (this.config.debug) {
+            console.log(`[RabbitMQ] Consuming from ${this.config.queue}`);
+        }
+    }
+    /**
+     * Publish a message to the queue
+     */
+    async publish(message) {
+        await this.connect();
+        if (!this.channel) {
+            throw new Error("Channel not initialized");
+        }
+        const content = Buffer.from(JSON.stringify(message));
+        const properties = {
+            messageId: Date.now().toString(36),
+            timestamp: Date.now(),
+            contentType: "application/json",
+        };
+        if (this.config.exchange) {
+            this.channel.publish(this.config.exchange, this.config.routingKey, content, properties);
+        }
+        else {
+            this.channel.sendToQueue(this.config.queue, content, properties);
+        }
+        this.stats.messagesPublished++;
+        if (this.config.debug) {
+            console.log(`[RabbitMQ] Published message to ${this.config.queue}`);
+        }
+    }
+    /**
+     * Close the connection
+     */
+    async close() {
+        if (this.channel) {
+            await this.channel.close();
+            this.channel = null;
+        }
+        if (this.connection) {
+            await this.connection.close();
+            this.connection = null;
+        }
+        this.stats.isConnected = false;
+        if (this.config.debug) {
+            console.log("[RabbitMQ] Connection closed");
+        }
+    }
+    /**
+     * Get consumer statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+}
+exports.RabbitMQConsumer = RabbitMQConsumer;

package/lib/cjs/adapter-express/micro-api/serverless/aws-lambda.adapter.js

@@ -0,0 +1,183 @@
+"use strict";
+/**
+ * AWS Lambda Adapter for ExpressoTS Micro API
+ *
+ * Converts Lambda events to Express requests and responses.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.awsLambdaAdapter = awsLambdaAdapter;
+/**
+ * Create an AWS Lambda handler from an Express app
+ *
+ * @example
+ * ```typescript
+ * import { createMicroAPI, awsLambdaAdapter } from "@expressots/adapter-express";
+ *
+ * const microAPI = createMicroAPI();
+ * const app = microAPI.build();
+ *
+ * app.Middleware.parse();
+ * app.Route.get("/", (req, res) => res.json({ message: "Hello Lambda!" }));
+ *
+ * export const handler = awsLambdaAdapter(app);
+ * ```
+ */
+function awsLambdaAdapter(app, config) {
+    const expressApp = "getExpressApp" in app && app.getExpressApp ? app.getExpressApp() : app;
+    const binaryTypes = config?.binaryContentTypes ?? [
+        "application/octet-stream",
+        "image/*",
+        "audio/*",
+        "video/*",
+        "font/*",
+    ];
+    const debug = config?.debug ?? false;
+    return async (event, context) => {
+        if (debug) {
+            console.log("[Lambda] Event:", JSON.stringify(event, null, 2));
+        }
+        // Parse body
+        let body;
+        if (event.body) {
+            let rawBody;
+            if (event.isBase64Encoded) {
+                rawBody = Buffer.from(event.body, "base64");
+            }
+            else {
+                rawBody = event.body;
+            }
+            // Parse JSON body if content-type is application/json
+            const contentType = event.headers?.["content-type"] || event.headers?.["Content-Type"] || "";
+            if (contentType.includes("application/json")) {
+                try {
+                    const bodyStr = Buffer.isBuffer(rawBody) ? rawBody.toString("utf8") : rawBody;
+                    body = JSON.parse(bodyStr);
+                }
+                catch {
+                    // Keep as raw if JSON parsing fails
+                    body = rawBody;
+                }
+            }
+            else {
+                body = rawBody;
+            }
+        }
+        // Build request URL
+        const queryString = event.queryStringParameters
+            ? "?" +
+                Object.entries(event.queryStringParameters)
+                    .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+                    .join("&")
+            : "";
+        const url = event.path + queryString;
+        // Build headers
+        const headers = {
+            ...event.headers,
+        };
+        // Add Lambda context to headers
+        headers["x-lambda-request-id"] = context.awsRequestId;
+        headers["x-lambda-function"] = context.functionName;
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        return new Promise((resolve, _reject) => {
+            // Create mock Express-compatible request object
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const req = {
+                method: event.httpMethod,
+                url,
+                path: event.path,
+                headers,
+                body,
+                query: event.queryStringParameters || {},
+                params: {},
+                lambda: { event, context },
+                get: (name) => headers[name.toLowerCase()],
+            };
+            // Create mock Express-compatible response object
+            const chunks = [];
+            const responseHeaders = {};
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const res = {
+                statusCode: 200,
+                setHeader: (name, value) => {
+                    responseHeaders[name.toLowerCase()] = value;
+                },
+                getHeader: (name) => responseHeaders[name.toLowerCase()],
+                write: (chunk) => {
+                    chunks.push(Buffer.from(chunk));
+                },
+                end: (chunk) => {
+                    if (chunk) {
+                        chunks.push(Buffer.from(chunk));
+                    }
+                    const bodyBuffer = Buffer.concat(chunks);
+                    const contentType = responseHeaders["content-type"] || "";
+                    const isBinary = binaryTypes.some((type) => {
+                        if (type.endsWith("/*")) {
+                            return contentType.startsWith(type.replace("/*", "/"));
+                        }
+                        return contentType === type;
+                    });
+                    const response = {
+                        statusCode: res.statusCode,
+                        headers: responseHeaders,
+                        body: isBinary ? bodyBuffer.toString("base64") : bodyBuffer.toString("utf8"),
+                        isBase64Encoded: isBinary,
+                    };
+                    if (debug) {
+                        console.log("[Lambda] Response:", {
+                            statusCode: response.statusCode,
+                            headers: response.headers,
+                            bodyLength: response.body.length,
+                        });
+                    }
+                    resolve(response);
+                },
+                status: (code) => {
+                    res.statusCode = code;
+                    return res;
+                },
+                json: (data) => {
+                    res.setHeader("content-type", "application/json");
+                    res.end(JSON.stringify(data));
+                },
+                send: (data) => {
+                    if (typeof data === "string") {
+                        res.setHeader("content-type", "text/html");
+                        res.end(data);
+                    }
+                    else if (Buffer.isBuffer(data)) {
+                        res.end(data);
+                    }
+                    else {
+                        res.json(data);
+                    }
+                },
+            };
+            // Handle request through Express
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                expressApp(req, res, (err) => {
+                    if (err) {
+                        console.error("[Lambda] Express error:", err);
+                        resolve({
+                            statusCode: 500,
+                            headers: { "content-type": "application/json" },
+                            body: JSON.stringify({ error: err.message }),
+                            isBase64Encoded: false,
+                        });
+                    }
+                });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                console.error("[Lambda] Handler error:", error);
+                resolve({
+                    statusCode: 500,
+                    headers: { "content-type": "application/json" },
+                    body: JSON.stringify({ error: errorMessage }),
+                    isBase64Encoded: false,
+                });
+            }
+        });
+    };
+}

package/lib/cjs/adapter-express/micro-api/serverless/cloudflare.adapter.js

@@ -0,0 +1,158 @@
+"use strict";
+/**
+ * Cloudflare Workers Adapter for ExpressoTS Micro API
+ *
+ * Converts Cloudflare Workers requests to Express format.
+ * Note: This adapter requires a Cloudflare Workers-compatible Express implementation
+ * or uses a fetch-based approach.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloudflareAdapter = cloudflareAdapter;
+/**
+ * Create a Cloudflare Workers handler from an Express app
+ *
+ * Note: Full Express compatibility in Cloudflare Workers requires
+ * additional setup. This adapter provides a basic implementation.
+ *
+ * @example
+ * ```typescript
+ * // src/worker.ts
+ * import { createMicroAPI, cloudflareAdapter } from "@expressots/adapter-express";
+ *
+ * const microAPI = createMicroAPI();
+ * const app = microAPI.build();
+ *
+ * app.Middleware.parse();
+ * app.Route.get("/", (req, res) => res.json({ message: "Hello Workers!" }));
+ *
+ * export default cloudflareAdapter(app);
+ * ```
+ *
+ * wrangler.toml:
+ * ```toml
+ * name = "my-worker"
+ * main = "src/worker.ts"
+ * compatibility_date = "2024-01-01"
+ * ```
+ */
+function cloudflareAdapter(app, config) {
+    const expressApp = "getExpressApp" in app && app.getExpressApp ? app.getExpressApp() : app;
+    const debug = config?.debug ?? false;
+    return {
+        async fetch(request, env, ctx) {
+            const url = new URL(request.url);
+            if (debug) {
+                console.log("[Cloudflare] Request:", {
+                    method: request.method,
+                    url: request.url,
+                    path: url.pathname,
+                });
+            }
+            // Parse body if present
+            let body;
+            if (request.method !== "GET" && request.method !== "HEAD") {
+                body = await request.text();
+            }
+            // Build query parameters
+            const query = {};
+            url.searchParams.forEach((value, key) => {
+                query[key] = value;
+            });
+            // Build headers
+            const headers = {};
+            request.headers.forEach((value, key) => {
+                headers[key.toLowerCase()] = value;
+            });
+            return new Promise((resolve) => {
+                // Create mock Express-compatible request object
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const req = {
+                    method: request.method,
+                    url: url.pathname + url.search,
+                    path: url.pathname,
+                    headers,
+                    query,
+                    params: {},
+                    body: body ? JSON.parse(body) : undefined,
+                    get: (name) => headers[name.toLowerCase()],
+                    cloudflare: { env, ctx },
+                };
+                // Create mock Express-compatible response object
+                const chunks = [];
+                const responseHeaders = {};
+                let statusCode = 200;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const res = {
+                    statusCode: 200,
+                    setHeader: (name, value) => {
+                        responseHeaders[name.toLowerCase()] = value;
+                    },
+                    getHeader: (name) => responseHeaders[name.toLowerCase()],
+                    write: (chunk) => {
+                        chunks.push(Buffer.from(chunk));
+                    },
+                    end: (chunk) => {
+                        if (chunk) {
+                            chunks.push(Buffer.from(chunk));
+                        }
+                        const bodyBuffer = Buffer.concat(chunks);
+                        if (debug) {
+                            console.log("[Cloudflare] Response:", {
+                                statusCode,
+                                headers: responseHeaders,
+                                bodyLength: bodyBuffer.length,
+                            });
+                        }
+                        resolve(new globalThis.Response(bodyBuffer, {
+                            status: statusCode,
+                            headers: responseHeaders,
+                        }));
+                    },
+                    status: (code) => {
+                        statusCode = code;
+                        return res;
+                    },
+                    json: (data) => {
+                        res.setHeader("content-type", "application/json");
+                        res.end(JSON.stringify(data));
+                    },
+                    send: (data) => {
+                        if (typeof data === "string") {
+                            res.setHeader("content-type", "text/html");
+                            res.end(data);
+                        }
+                        else if (Buffer.isBuffer(data)) {
+                            res.end(data);
+                        }
+                        else {
+                            res.json(data);
+                        }
+                    },
+                };
+                // Handle request through Express
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    expressApp(req, res, (err) => {
+                        if (err) {
+                            console.error("[Cloudflare] Express error:", err);
+                            resolve(new globalThis.Response(JSON.stringify({ error: err.message }), {
+                                status: 500,
+                                headers: {
+                                    "content-type": "application/json",
+                                },
+                            }));
+                        }
+                    });
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    console.error("[Cloudflare] Handler error:", error);
+                    resolve(new globalThis.Response(JSON.stringify({ error: errorMessage }), {
+                        status: 500,
+                        headers: { "content-type": "application/json" },
+                    }));
+                }
+            });
+        },
+    };
+}

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

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * Serverless Adapters for ExpressoTS Micro Template
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloudflareAdapter = exports.vercelAdapter = exports.awsLambdaAdapter = void 0;
+var aws_lambda_adapter_js_1 = require("./aws-lambda.adapter.js");
+Object.defineProperty(exports, "awsLambdaAdapter", { enumerable: true, get: function () { return aws_lambda_adapter_js_1.awsLambdaAdapter; } });
+var vercel_adapter_js_1 = require("./vercel.adapter.js");
+Object.defineProperty(exports, "vercelAdapter", { enumerable: true, get: function () { return vercel_adapter_js_1.vercelAdapter; } });
+var cloudflare_adapter_js_1 = require("./cloudflare.adapter.js");
+Object.defineProperty(exports, "cloudflareAdapter", { enumerable: true, get: function () { return cloudflare_adapter_js_1.cloudflareAdapter; } });