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

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;

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

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceDiscovery = void 0;
+/**
+ * ServiceDiscovery - Service discovery for microservices.
+ *
+ * Features:
+ * - Static service registration
+ * - Consul integration
+ * - etcd integration
+ * - Automatic service refresh
+ * - Round-robin load balancing
+ * - Health-based filtering
+ *
+ * @example
+ * ```typescript
+ * // Static service discovery
+ * const discovery = new ServiceDiscovery({ type: "static" });
+ *
+ * discovery.registerService({
+ *     id: "user-service-1",
+ *     name: "user-service",
+ *     host: "user-service",
+ *     port: 3001,
+ *     health: "healthy",
+ *     lastCheck: new Date(),
+ * });
+ *
+ * // Get a healthy instance
+ * const instance = discovery.getService("user-service");
+ * const client = new ServiceClient({
+ *     name: "user-service",
+ *     baseUrl: `http://${instance.host}:${instance.port}`,
+ * });
+ *
+ * // Or with Consul
+ * const discovery = new ServiceDiscovery({
+ *     type: "consul",
+ *     endpoint: "http://consul:8500",
+ * });
+ * await discovery.initialize();
+ * ```
+ */
+class ServiceDiscovery {
+    constructor(config) {
+        this.services = new Map();
+        this.roundRobinIndex = new Map();
+        this.config = {
+            type: config.type,
+            endpoint: config.endpoint ?? "",
+            refreshInterval: config.refreshInterval ?? 30000,
+            debug: config.debug ?? false,
+        };
+    }
+    /**
+     * Initialize the service discovery
+     * For consul/etcd, this starts the refresh loop
+     */
+    async initialize() {
+        if (this.config.type === "static") {
+            // Static configuration - no auto-discovery
+            return;
+        }
+        // Initial refresh
+        await this.refresh();
+        // Start refresh loop
+        if (this.config.refreshInterval > 0) {
+            this.refreshTimer = setInterval(() => this.refresh(), this.config.refreshInterval);
+        }
+    }
+    /**
+     * Register a service instance (for static mode)
+     * @param service - Service instance to register
+     */
+    registerService(service) {
+        const instances = this.services.get(service.name) || [];
+        // Check if instance already exists
+        const existingIndex = instances.findIndex((i) => i.id === service.id);
+        if (existingIndex >= 0) {
+            instances[existingIndex] = service;
+        }
+        else {
+            instances.push(service);
+        }
+        this.services.set(service.name, instances);
+        if (this.config.debug) {
+            console.log(`[ServiceDiscovery] Registered ${service.name} (${service.id})`);
+        }
+    }
+    /**
+     * Deregister a service instance
+     * @param serviceName - Service name
+     * @param instanceId - Instance ID to remove
+     */
+    deregisterService(serviceName, instanceId) {
+        const instances = this.services.get(serviceName);
+        if (!instances)
+            return;
+        const filtered = instances.filter((i) => i.id !== instanceId);
+        this.services.set(serviceName, filtered);
+        if (this.config.debug) {
+            console.log(`[ServiceDiscovery] Deregistered ${serviceName} (${instanceId})`);
+        }
+    }
+    /**
+     * Get a healthy instance of a service (round-robin)
+     * @param name - Service name
+     * @returns A healthy service instance or null
+     */
+    getService(name) {
+        const instances = this.services.get(name);
+        if (!instances || instances.length === 0) {
+            return null;
+        }
+        // Filter to healthy instances only
+        const healthy = instances.filter((i) => i.health === "healthy");
+        if (healthy.length === 0) {
+            return null;
+        }
+        // Round-robin selection
+        const currentIndex = this.roundRobinIndex.get(name) ?? 0;
+        const instance = healthy[currentIndex % healthy.length];
+        this.roundRobinIndex.set(name, currentIndex + 1);
+        return instance;
+    }
+    /**
+     * Get all instances of a service
+     * @param name - Service name
+     * @param healthyOnly - Only return healthy instances (default: true)
+     */
+    getServiceInstances(name, healthyOnly = true) {
+        const instances = this.services.get(name) || [];
+        if (healthyOnly) {
+            return instances.filter((i) => i.health === "healthy");
+        }
+        return instances;
+    }
+    /**
+     * Get all registered services
+     */
+    getAllServices() {
+        return new Map(this.services);
+    }
+    /**
+     * List all registered service names
+     */
+    listServices() {
+        return Array.from(this.services.keys());
+    }
+    /**
+     * Update health status of a service instance
+     * @param serviceName - Service name
+     * @param instanceId - Instance ID
+     * @param health - New health status
+     */
+    updateHealth(serviceName, instanceId, health) {
+        const instances = this.services.get(serviceName);
+        if (!instances)
+            return false;
+        const instance = instances.find((i) => i.id === instanceId);
+        if (!instance)
+            return false;
+        instance.health = health;
+        instance.lastCheck = new Date();
+        if (this.config.debug) {
+            console.log(`[ServiceDiscovery] Updated ${serviceName} (${instanceId}) health to ${health}`);
+        }
+        return true;
+    }
+    /**
+     * Get service statistics
+     */
+    getStats() {
+        const stats = {};
+        for (const [name, instances] of this.services) {
+            stats[name] = {
+                total: instances.length,
+                healthy: instances.filter((i) => i.health === "healthy").length,
+                unhealthy: instances.filter((i) => i.health === "unhealthy").length,
+            };
+        }
+        return stats;
+    }
+    /**
+     * Stop the service discovery
+     */
+    stop() {
+        if (this.refreshTimer) {
+            clearInterval(this.refreshTimer);
+            this.refreshTimer = undefined;
+        }
+    }
+    /**
+     * Refresh service list from discovery backend
+     */
+    async refresh() {
+        try {
+            if (this.config.type === "consul") {
+                await this.refreshFromConsul();
+            }
+            else if (this.config.type === "etcd") {
+                await this.refreshFromEtcd();
+            }
+        }
+        catch (error) {
+            console.error("[ServiceDiscovery] Refresh failed:", error);
+        }
+    }
+    /**
+     * Refresh from Consul
+     */
+    async refreshFromConsul() {
+        if (!this.config.endpoint) {
+            throw new Error("Consul endpoint not configured");
+        }
+        try {
+            // Get list of services
+            const servicesResponse = await fetch(`${this.config.endpoint}/v1/catalog/services`);
+            const services = await servicesResponse.json();
+            // Get instances for each service
+            for (const serviceName of Object.keys(services)) {
+                const instances = await this.getConsulInstances(serviceName);
+                this.services.set(serviceName, instances);
+            }
+            if (this.config.debug) {
+                console.log(`[ServiceDiscovery] Refreshed ${this.services.size} services from Consul`);
+            }
+        }
+        catch (error) {
+            console.error("[ServiceDiscovery] Consul refresh failed:", error);
+            throw error;
+        }
+    }
+    /**
+     * Get instances from Consul for a specific service
+     */
+    async getConsulInstances(serviceName) {
+        const response = await fetch(`${this.config.endpoint}/v1/health/service/${serviceName}?passing=true`);
+        const data = (await response.json());
+        return data.map((entry) => ({
+            id: entry.Service.ID,
+            name: entry.Service.Service,
+            host: entry.Service.Address || entry.Node.Address,
+            port: entry.Service.Port,
+            metadata: entry.Service.Meta,
+            health: "healthy",
+            lastCheck: new Date(),
+        }));
+    }
+    /**
+     * Refresh from etcd
+     */
+    async refreshFromEtcd() {
+        if (!this.config.endpoint) {
+            throw new Error("etcd endpoint not configured");
+        }
+        // etcd v3 API implementation
+        console.log("[ServiceDiscovery] etcd integration requires etcd3 client library");
+    }
+}
+exports.ServiceDiscovery = ServiceDiscovery;

package/lib/cjs/adapter-express/middleware/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * @file middleware/index.ts
+ * @description Exports for ExpressoTS middleware
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./request-logging.middleware.js"), exports);