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

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; } });

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

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * Vercel Adapter for ExpressoTS Micro API
+ *
+ * Converts Vercel serverless function requests to Express format.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vercelAdapter = vercelAdapter;
+/**
+ * Create a Vercel serverless handler from an Express app
+ *
+ * @example
+ * ```typescript
+ * // api/index.ts
+ * import { createMicroAPI, vercelAdapter } from "@expressots/adapter-express";
+ *
+ * const microAPI = createMicroAPI();
+ * const app = microAPI.build();
+ *
+ * app.Middleware.parse();
+ * app.Route.get("/api", (req, res) => res.json({ message: "Hello Vercel!" }));
+ *
+ * export default vercelAdapter(app);
+ * ```
+ *
+ * vercel.json:
+ * ```json
+ * {
+ *   "rewrites": [{ "source": "/api/(.*)", "destination": "/api" }]
+ * }
+ * ```
+ */
+function vercelAdapter(app, config) {
+    const expressApp = "getExpressApp" in app && app.getExpressApp ? app.getExpressApp() : app;
+    const debug = config?.debug ?? false;
+    return async (req, res) => {
+        if (debug) {
+            console.log("[Vercel] Request:", {
+                method: req.method,
+                url: req.url,
+                query: req.query,
+            });
+        }
+        // Vercel passes the request directly to Express
+        // We just need to handle the response properly
+        return new Promise((resolve) => {
+            const originalEnd = res.end.bind(res);
+            // Override end to resolve the promise when response is complete
+            // Using 'any' to avoid complex Express Response type conflicts
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            res.end = function (chunk, encoding, callback) {
+                if (debug) {
+                    console.log("[Vercel] Response:", {
+                        statusCode: res.statusCode,
+                    });
+                }
+                // Call original end with proper typing
+                if (typeof chunk === "function") {
+                    originalEnd();
+                    chunk();
+                }
+                else if (typeof encoding === "function") {
+                    originalEnd(chunk);
+                    encoding();
+                }
+                else if (callback) {
+                    originalEnd(chunk, encoding, callback);
+                }
+                else if (encoding) {
+                    originalEnd(chunk, encoding);
+                }
+                else if (chunk) {
+                    originalEnd(chunk);
+                }
+                else {
+                    originalEnd();
+                }
+                resolve();
+                return this;
+            };
+            // Handle request through Express
+            try {
+                expressApp(req, res, (err) => {
+                    if (err) {
+                        console.error("[Vercel] Express error:", err);
+                        res.status(500).json({
+                            error: err instanceof Error ? err.message : "Unknown error",
+                        });
+                        resolve();
+                    }
+                });
+            }
+            catch (error) {
+                console.error("[Vercel] Handler error:", error);
+                res.status(500).json({
+                    error: error instanceof Error ? error.message : "Unknown error",
+                });
+                resolve();
+            }
+        });
+    };
+}

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

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Service Mesh Utilities for ExpressoTS Micro Template
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceDiscovery = exports.ServiceClient = void 0;
+var service_client_js_1 = require("./service-client.js");
+Object.defineProperty(exports, "ServiceClient", { enumerable: true, get: function () { return service_client_js_1.ServiceClient; } });
+var service_discovery_js_1 = require("./service-discovery.js");
+Object.defineProperty(exports, "ServiceDiscovery", { enumerable: true, get: function () { return service_discovery_js_1.ServiceDiscovery; } });

package/lib/cjs/adapter-express/micro-api/service-mesh/service-client.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceClient = void 0;
+const circuit_breaker_js_1 = require("../gateway/circuit-breaker.js");
+/**
+ * ServiceClient - HTTP client for service-to-service communication.
+ *
+ * Features:
+ * - Automatic retries with exponential backoff
+ * - Circuit breaker integration
+ * - Request timeout
+ * - JSON request/response handling
+ * - Trace context propagation
+ *
+ * @example
+ * ```typescript
+ * const userService = new ServiceClient({
+ *     name: "user-service",
+ *     baseUrl: "http://user-service:3001",
+ *     timeout: 5000,
+ *     retries: 3,
+ *     circuitBreaker: true,
+ * });
+ *
+ * // GET request
+ * const user = await userService.call<User>("/users/123");
+ *
+ * // POST request
+ * const newUser = await userService.call<User>("/users", {
+ *     method: "POST",
+ *     body: { name: "John", email: "john@example.com" },
+ * });
+ *
+ * // With query parameters
+ * const users = await userService.call<User[]>("/users", {
+ *     params: { page: "1", limit: "10" },
+ * });
+ * ```
+ */
+class ServiceClient {
+    constructor(config) {
+        this.stats = {
+            totalRequests: 0,
+            successfulRequests: 0,
+            failedRequests: 0,
+        };
+        this.config = {
+            name: config.name,
+            baseUrl: config.baseUrl.replace(/\/$/, ""), // Remove trailing slash
+            timeout: config.timeout ?? 5000,
+            retries: config.retries ?? 3,
+            headers: config.headers ?? {},
+        };
+        // Initialize circuit breaker
+        if (config.circuitBreaker !== false) {
+            const cbConfig = typeof config.circuitBreaker === "object" ? config.circuitBreaker : undefined;
+            this.config.circuitBreaker = new circuit_breaker_js_1.CircuitBreaker(cbConfig);
+        }
+    }
+    /**
+     * Make a request to the service
+     * @param path - Request path
+     * @param options - Request options
+     */
+    async call(path, options = {}) {
+        this.stats.totalRequests++;
+        const execute = async () => {
+            return await this.executeWithRetry(path, options);
+        };
+        try {
+            let result;
+            if (this.config.circuitBreaker) {
+                result = await this.config.circuitBreaker.execute(execute);
+            }
+            else {
+                result = await execute();
+            }
+            this.stats.successfulRequests++;
+            return result;
+        }
+        catch (error) {
+            this.stats.failedRequests++;
+            throw error;
+        }
+    }
+    /**
+     * GET request helper
+     */
+    async get(path, options) {
+        return this.call(path, { ...options, method: "GET" });
+    }
+    /**
+     * POST request helper
+     */
+    async post(path, body, options) {
+        return this.call(path, { ...options, method: "POST", body });
+    }
+    /**
+     * PUT request helper
+     */
+    async put(path, body, options) {
+        return this.call(path, { ...options, method: "PUT", body });
+    }
+    /**
+     * PATCH request helper
+     */
+    async patch(path, body, options) {
+        return this.call(path, { ...options, method: "PATCH", body });
+    }
+    /**
+     * DELETE request helper
+     */
+    async delete(path, options) {
+        return this.call(path, { ...options, method: "DELETE" });
+    }
+    /**
+     * Get service stats
+     */
+    getStats() {
+        return {
+            name: this.config.name,
+            baseUrl: this.config.baseUrl,
+            ...this.stats,
+            circuitBreaker: this.config.circuitBreaker?.getStats(),
+        };
+    }
+    /**
+     * Execute request with retry logic
+     */
+    async executeWithRetry(path, options, attempt = 1) {
+        try {
+            return await this.executeRequest(path, options);
+        }
+        catch (error) {
+            if (attempt < this.config.retries) {
+                // Exponential backoff
+                await this.delay(Math.pow(2, attempt) * 100);
+                return await this.executeWithRetry(path, options, attempt + 1);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Execute a single request
+     */
+    async executeRequest(path, options) {
+        // Build URL
+        const url = new URL(path, this.config.baseUrl);
+        // Add query parameters
+        if (options.params) {
+            Object.entries(options.params).forEach(([key, value]) => {
+                url.searchParams.append(key, value);
+            });
+        }
+        // Build headers
+        const headers = {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            ...this.config.headers,
+            ...options.headers,
+        };
+        // Setup timeout
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), options.timeout ?? this.config.timeout);
+        try {
+            const response = await fetch(url.toString(), {
+                method: options.method || "GET",
+                headers,
+                body: options.body ? JSON.stringify(options.body) : undefined,
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorBody = await response.text();
+                throw new Error(`HTTP ${response.status}: ${response.statusText}. ${errorBody}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof Error && error.name === "AbortError") {
+                throw new Error(`Request timeout: ${this.config.name} ${path}`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Delay helper
+     */
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+exports.ServiceClient = ServiceClient;