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

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

@@ -0,0 +1,155 @@
+/**
+ * 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.
+ */
+/**
+ * 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"
+ * ```
+ */
+export 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/esm/adapter-express/micro-api/serverless/index.js

@@ -0,0 +1,6 @@
+/**
+ * Serverless Adapters for ExpressoTS Micro Template
+ */
+export { awsLambdaAdapter, } from "./aws-lambda.adapter.js";
+export { vercelAdapter, } from "./vercel.adapter.js";
+export { cloudflareAdapter, } from "./cloudflare.adapter.js";

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

@@ -0,0 +1,99 @@
+/**
+ * Vercel Adapter for ExpressoTS Micro API
+ *
+ * Converts Vercel serverless function requests to Express format.
+ */
+/**
+ * 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" }]
+ * }
+ * ```
+ */
+export 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/esm/adapter-express/micro-api/service-mesh/index.js

@@ -0,0 +1,5 @@
+/**
+ * Service Mesh Utilities for ExpressoTS Micro Template
+ */
+export { ServiceClient, } from "./service-client.js";
+export { ServiceDiscovery, } from "./service-discovery.js";

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

@@ -0,0 +1,191 @@
+import { CircuitBreaker } from "../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" },
+ * });
+ * ```
+ */
+export class ServiceClient {
+    config;
+    stats = {
+        totalRequests: 0,
+        successfulRequests: 0,
+        failedRequests: 0,
+    };
+    constructor(config) {
+        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 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));
+    }
+}