opticore-api-gateway 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1100 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  APIGateway: () => APIGateway,
+  AuthMiddleware: () => AuthMiddleware,
+  BaseMiddleware: () => BaseMiddleware,
+  GatewayRoute: () => GatewayRoute,
+  HttpClient: () => HttpClient,
+  LoadBalancer: () => LoadBalancer,
+  LoggingMiddleware: () => LoggingMiddleware,
+  MiddlewareChain: () => MiddlewareChain,
+  RateLimitMiddleware: () => RateLimitMiddleware,
+  ServiceRegistry: () => ServiceRegistry,
+  ValidationMiddleware: () => ValidationMiddleware
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/gateway.core.ts
+var http2 = __toESM(require("http"), 1);
+var import_opticore_router2 = require("opticore-router");
+
+// src/infrastructure/services/strategies/serviceRegistry.strategy.ts
+var ServiceRegistry = class {
+  services = /* @__PURE__ */ new Map();
+  serviceHealthChecks = /* @__PURE__ */ new Map();
+  circuitBreakers = /* @__PURE__ */ new Map();
+  registerService(service) {
+    if (!this.services.has(service.name)) {
+      this.services.set(service.name, []);
+    }
+    const instance = {
+      ...service,
+      healthy: true,
+      currentConnections: 0,
+      lastHealthCheck: /* @__PURE__ */ new Date(),
+      failureCount: 0,
+      circuitState: "closed"
+    };
+    this.services.get(service.name).push(instance);
+    this.circuitBreakers.set(`${service.name}-${service.url}`, new CircuitBreaker());
+    if (service.healthCheck) {
+      this.startHealthCheck(service.name, instance);
+    }
+  }
+  startHealthCheck(serviceName, instance) {
+    const healthCheck = setInterval(async () => {
+      try {
+        instance.healthy = true;
+        instance.lastHealthCheck = /* @__PURE__ */ new Date();
+      } catch (error) {
+        instance.healthy = false;
+        console.error(`Health check failed for ${serviceName}: ${error}`);
+      }
+    }, 3e4);
+    this.serviceHealthChecks.set(`${serviceName}-${instance.url}`, healthCheck);
+  }
+  getServiceInstances(serviceName) {
+    return this.services.get(serviceName) || [];
+  }
+  getHealthyInstances(serviceName) {
+    const instances = this.services.get(serviceName) || [];
+    const now = /* @__PURE__ */ new Date();
+    return instances.filter((instance) => {
+      const circuitBreaker = this.circuitBreakers.get(`${serviceName}-${instance.url}`);
+      if (circuitBreaker && !circuitBreaker.allowRequest()) {
+        return false;
+      }
+      return instance.healthy;
+    });
+  }
+  recordSuccess(serviceName, url) {
+    const circuitBreaker = this.circuitBreakers.get(`${serviceName}-${url}`);
+    if (circuitBreaker) {
+      circuitBreaker.recordSuccess();
+    }
+  }
+  recordFailure(serviceName, url) {
+    const circuitBreaker = this.circuitBreakers.get(`${serviceName}-${url}`);
+    if (circuitBreaker) {
+      circuitBreaker.recordFailure();
+    }
+    const instances = this.services.get(serviceName);
+    if (instances) {
+      const instance = instances.find((inst) => inst.url === url);
+      if (instance) {
+        instance.failureCount++;
+      }
+    }
+  }
+  deregisterService(serviceName, url) {
+    const instances = this.services.get(serviceName);
+    if (instances) {
+      const filtered = instances.filter((instance) => instance.url !== url);
+      this.services.set(serviceName, filtered);
+      const healthCheckKey = `${serviceName}-${url}`;
+      const interval = this.serviceHealthChecks.get(healthCheckKey);
+      if (interval) {
+        clearInterval(interval);
+        this.serviceHealthChecks.delete(healthCheckKey);
+      }
+      this.circuitBreakers.delete(healthCheckKey);
+    }
+  }
+  getAllServices() {
+    return new Map(this.services);
+  }
+};
+var CircuitBreaker = class {
+  state = "closed";
+  failureCount = 0;
+  successCount = 0;
+  lastFailureTime = null;
+  failureThreshold = 5;
+  resetTimeout = 3e4;
+  halfOpenMaxAttempts = 3;
+  allowRequest() {
+    if (this.state === "closed") {
+      return true;
+    }
+    if (this.state === "open") {
+      if (this.lastFailureTime) {
+        const now = /* @__PURE__ */ new Date();
+        const timeSinceFailure = now.getTime() - this.lastFailureTime.getTime();
+        if (timeSinceFailure > this.resetTimeout) {
+          this.state = "half-open";
+          this.successCount = 0;
+          return true;
+        }
+      }
+      return false;
+    }
+    return this.successCount < this.halfOpenMaxAttempts;
+  }
+  recordSuccess() {
+    if (this.state === "half-open") {
+      this.successCount++;
+      if (this.successCount >= this.halfOpenMaxAttempts) {
+        this.reset();
+      }
+    } else {
+      this.failureCount = Math.max(0, this.failureCount - 1);
+    }
+  }
+  recordFailure() {
+    this.failureCount++;
+    this.lastFailureTime = /* @__PURE__ */ new Date();
+    if (this.failureCount >= this.failureThreshold) {
+      this.state = "open";
+    } else if (this.state === "half-open") {
+      this.state = "open";
+      this.successCount = 0;
+    }
+  }
+  reset() {
+    this.state = "closed";
+    this.failureCount = 0;
+    this.successCount = 0;
+    this.lastFailureTime = null;
+  }
+};
+
+// src/infrastructure/services/strategies/loadBalancer.strategy.ts
+var LoadBalancer = class {
+  strategy;
+  counters = /* @__PURE__ */ new Map();
+  constructor(strategy = "round-robin") {
+    this.strategy = strategy;
+  }
+  /**
+   *
+   * @param serviceName
+   * @param instances
+   */
+  selectInstance(serviceName, instances) {
+    if (instances.length === 0) return null;
+    switch (this.strategy) {
+      case "round-robin":
+        return this.roundRobin(serviceName, instances);
+      case "random":
+        return this.random(instances);
+      case "weighted":
+        return this.weighted(instances);
+      case "least-connections":
+        return this.leastConnections(instances);
+      default:
+        return this.roundRobin(serviceName, instances);
+    }
+  }
+  /**
+   *
+   * @param serviceName
+   * @param instances
+   * @private
+   */
+  roundRobin(serviceName, instances) {
+    const counter = this.counters.get(serviceName) || 0;
+    const index = counter % instances.length;
+    this.counters.set(serviceName, counter + 1);
+    return instances[index];
+  }
+  /**
+   *
+   * @param instances
+   * @private
+   */
+  random(instances) {
+    const index = Math.floor(Math.random() * instances.length);
+    return instances[index];
+  }
+  /**
+   *
+   * @param instances
+   * @private
+   */
+  weighted(instances) {
+    const totalWeight = instances.reduce((sum, instance) => sum + (instance.weight || 1), 0);
+    let random = Math.random() * totalWeight;
+    for (const instance of instances) {
+      random -= instance.weight || 1;
+      if (random <= 0) {
+        return instance;
+      }
+    }
+    return instances[0];
+  }
+  /**
+   *
+   * @param instances
+   * @private
+   */
+  leastConnections(instances) {
+    return instances.reduce(
+      (prev, current) => prev.currentConnections < current.currentConnections ? prev : current
+    );
+  }
+  /**
+   *
+   * @param strategy
+   */
+  setStrategy(strategy) {
+    this.strategy = strategy;
+  }
+};
+
+// src/utils/httpClient.utils.ts
+var http = __toESM(require("http"), 1);
+var https = __toESM(require("https"), 1);
+var import_node_buffer = require("buffer");
+var HttpClient = class {
+  /**
+   *
+   * @param url
+   * @param options
+   */
+  async request(url, options) {
+    return new Promise((resolve, reject) => {
+      try {
+        const urlObj = new URL(url);
+        const isHttps = urlObj.protocol === "https:";
+        const headers = {
+          "User-Agent": "API-Gateway/1.0",
+          "Accept": "application/json",
+          ...options.headers
+        };
+        let requestBody;
+        if (options.body !== void 0 && options.body !== null) {
+          if (typeof options.body === "string") {
+            requestBody = options.body;
+            headers["Content-Type"] = headers["Content-Type"] || "text/plain";
+          } else if (import_node_buffer.Buffer.isBuffer(options.body)) {
+            requestBody = options.body;
+          } else if (typeof options.body === "object") {
+            requestBody = JSON.stringify(options.body);
+            headers["Content-Type"] = headers["Content-Type"] || "application/json";
+          }
+          if (requestBody) {
+            headers["Content-Length"] = import_node_buffer.Buffer.byteLength(requestBody).toString();
+          }
+        }
+        const requestOptions = {
+          method: options.method.toUpperCase(),
+          headers,
+          timeout: options.timeout || 1e4
+        };
+        const client = isHttps ? https : http;
+        const req = client.request(
+          url,
+          requestOptions,
+          (res) => {
+            const responseHeaders = {};
+            Object.keys(res.headers).forEach((key) => {
+              const value = res.headers[key];
+              if (value !== void 0) {
+                responseHeaders[key] = value;
+              }
+            });
+            const chunks = [];
+            res.on("data", (chunk) => {
+              chunks.push(chunk);
+            });
+            res.on("end", () => {
+              const body = import_node_buffer.Buffer.concat(chunks).toString("utf8");
+              resolve({
+                status: res.statusCode || 500,
+                headers: responseHeaders,
+                body
+              });
+            });
+            res.on("error", (error) => {
+              reject(error);
+            });
+          }
+        );
+        req.on("error", (error) => {
+          reject(error);
+        });
+        req.on("timeout", () => {
+          req.destroy();
+          reject(new Error(`Request timeout after ${requestOptions.timeout}ms`));
+        });
+        if (requestBody) {
+          req.write(requestBody);
+        }
+        req.end();
+      } catch (error) {
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+  /**
+   *
+   * @param method
+   * @private
+   */
+  getDefaultHeaders(method) {
+    const headers = {};
+    if (["POST", "PUT", "PATCH"].includes(method.toUpperCase())) {
+      headers["Content-Type"] = "application/json";
+    }
+    return headers;
+  }
+  /**
+   *
+   * @param req
+   * @param body
+   * @param headers
+   * @private
+   */
+  writeRequestBody(req, body, headers) {
+    const contentType = this.getContentType(headers);
+    try {
+      if (import_node_buffer.Buffer.isBuffer(body)) {
+        req.write(body);
+        return;
+      }
+      if (typeof body === "string") {
+        req.write(body);
+        return;
+      }
+      if (contentType?.includes("application/json")) {
+        if (typeof body === "object" && body !== null) {
+          req.write(JSON.stringify(body));
+        } else {
+          req.write(String(body));
+        }
+      } else if (contentType?.includes("application/x-www-form-urlencoded")) {
+        if (typeof body === "object" && body !== null) {
+          const params = new URLSearchParams();
+          for (const [key, value] of Object.entries(body)) {
+            if (value !== void 0 && value !== null) {
+              params.append(key, String(value));
+            }
+          }
+          req.write(params.toString());
+        } else {
+          req.write(String(body));
+        }
+      } else if (contentType?.includes("text/")) {
+        req.write(String(body));
+      } else {
+        if (typeof body === "object" && body !== null) {
+          req.write(JSON.stringify(body));
+        } else {
+          req.write(String(body));
+        }
+      }
+    } catch (error) {
+      console.error("Error writing request body:", error);
+      throw new Error(`Failed to write request body: ${error.message}`);
+    }
+  }
+  /**
+   *
+   * @param headers
+   * @private
+   */
+  getContentType(headers) {
+    const contentType = headers["Content-Type"] || headers["content-type"];
+    if (!contentType) return void 0;
+    if (Array.isArray(contentType)) {
+      return contentType[0];
+    }
+    return contentType;
+  }
+  /**
+   *
+   * @param url
+   * @param headers
+   */
+  async get(url, headers) {
+    return this.request(url, {
+      method: "GET",
+      headers: headers || {}
+    });
+  }
+  /**
+   *
+   * @param url
+   * @param body
+   * @param headers
+   */
+  async post(url, body, headers) {
+    return this.request(url, {
+      method: "POST",
+      headers: headers || {},
+      body
+    });
+  }
+  /**
+   *
+   * @param url
+   * @param body
+   * @param headers
+   */
+  async put(url, body, headers) {
+    return this.request(url, {
+      method: "PUT",
+      headers: headers || {},
+      body
+    });
+  }
+  /**
+   *
+   * @param url
+   * @param headers
+   */
+  async delete(url, headers) {
+    return this.request(url, {
+      method: "DELETE",
+      headers: headers || {}
+    });
+  }
+  /**
+   *
+   * @param url
+   * @param body
+   * @param headers
+   */
+  async patch(url, body, headers) {
+    return this.request(url, {
+      method: "PATCH",
+      headers: headers || {},
+      body
+    });
+  }
+};
+
+// src/core/middleware.core.ts
+var BaseMiddleware = class {
+};
+var MiddlewareChain = class {
+  middlewares = [];
+  add(middleware) {
+    this.middlewares.push(middleware);
+  }
+  async execute(req, res, finalHandler) {
+    let index = 0;
+    const next = () => {
+      if (index < this.middlewares.length) {
+        const middleware = this.middlewares[index++];
+        try {
+          const result = middleware(req, res, next);
+          if (result instanceof Promise) {
+            result.catch((error) => {
+              console.error("Middleware error:", error);
+              res.statusCode = 500;
+              res.end(JSON.stringify({ error: "Internal Server Error" }));
+            });
+          }
+        } catch (error) {
+          console.error("Middleware error:", error);
+          res.statusCode = 500;
+          res.end(JSON.stringify({ error: "Internal Server Error" }));
+        }
+      } else {
+        finalHandler(req, res, () => {
+        });
+      }
+    };
+    next();
+  }
+  getAll() {
+    return [...this.middlewares];
+  }
+};
+
+// src/core/gatewayRoute.core.ts
+var import_opticore_router = require("opticore-router");
+var import_opticore_logger = require("opticore-logger");
+var import_opticore_http_response = require("opticore-http-response");
+var import_opticore_translator = require("opticore-translator");
+var GatewayRoute = class {
+  localLanguage;
+  config;
+  standaloneRouter;
+  collectionRouter = null;
+  routeHandler;
+  logger = new import_opticore_logger.LoggerCore();
+  /**
+   *
+   * @param config
+   * @param routeHandler
+   * @param localLanguage
+   */
+  constructor(config, routeHandler, localLanguage) {
+    this.localLanguage = localLanguage;
+    this.config = config;
+    this.routeHandler = routeHandler;
+    this.standaloneRouter = new import_opticore_router.OpticoreStandaloneRouterFactory();
+    this.logger = new import_opticore_logger.LoggerCore();
+    this.standaloneRouter.storeRoute(
+      config.method,
+      config.path,
+      async (context) => routeHandler(context.req, context.res, context.next),
+      false
+    );
+  }
+  /**
+   * Method for creating a multi-router configuration
+   *
+   * @param controller
+   */
+  createMultipleRouterConfig(controller) {
+    return {
+      path: this.config.path,
+      method: this.config.method,
+      middlewares: this.config.middlewares || [],
+      handler: async (context) => {
+        return await this.routeHandler(context.req, context.res, context.next);
+      }
+    };
+  }
+  /**
+   * Method for creating a router collection
+   *
+   * @param controller
+   * @param routes
+   */
+  createCollectionRouter(controller, routes) {
+    this.collectionRouter = new import_opticore_router.OpticoreRouterCollectionRouterFactory(
+      controller,
+      routes
+    );
+  }
+  /**
+   * Get the standalone router
+   *
+   * @param strategy
+   * @param options
+   */
+  getStandaloneRoute(strategy, options) {
+    return this.standaloneRouter.getRoute(strategy, options);
+  }
+  /**
+   * Get the definition of multiple routes
+   */
+  getMultipleRouteDefinition() {
+    if (!this.collectionRouter) {
+      this.logger.error({
+        errorType: import_opticore_translator.TranslationLoader.t("MISSING_ROUTES", this.localLanguage),
+        httpCodeValue: import_opticore_http_response.HttpStatusCode.NOT_FOUND,
+        message: import_opticore_translator.TranslationLoader.t("ROUTER_COLLECTION_NOT_FOUND", this.localLanguage),
+        stackTrace: void 0,
+        title: import_opticore_translator.TranslationLoader.t("ROUTER_COLLECTION", this.localLanguage)
+      });
+      throw new Error(import_opticore_translator.TranslationLoader.t("ROUTER_COLLECTION_NOT_FOUND", this.localLanguage));
+    }
+    return this.collectionRouter.getRoute();
+  }
+  /**
+   *
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Utility method for creating an Opticore-compatible route
+   *
+   * @param path
+   * @param handler
+   */
+  static createOpticoreRouteDefinition(path, handler) {
+    return {
+      path,
+      handler: async (context) => {
+        return await handler(context.req, context.res, context.next);
+      }
+    };
+  }
+};
+
+// src/core/gateway.core.ts
+var APIGateway = class {
+  config;
+  server = null;
+  serviceRegistry;
+  loadBalancer;
+  httpClient;
+  middlewareChain;
+  routes = /* @__PURE__ */ new Map();
+  opticoreRoutes = [];
+  registerRouter;
+  constructor(config) {
+    this.config = config;
+    this.serviceRegistry = new ServiceRegistry();
+    this.loadBalancer = new LoadBalancer(config.loadBalancer || "round-robin");
+    this.httpClient = new HttpClient();
+    this.middlewareChain = new MiddlewareChain();
+    this.registerRouter = new import_opticore_router2.OpticoreRegisterRouter();
+    this.initializeServices();
+    this.initializeGlobalMiddlewares();
+    this.initializeRoutes();
+    this.buildOpticoreRoutes();
+  }
+  initializeServices() {
+    this.config.services.forEach((service) => {
+      this.serviceRegistry.registerService(service);
+    });
+  }
+  initializeGlobalMiddlewares() {
+    if (this.config.globalMiddlewares) {
+      this.config.globalMiddlewares.forEach((middleware) => {
+        if (typeof middleware === "function") {
+          this.middlewareChain.add(middleware);
+        } else if (middleware.handle && typeof middleware.handle === "function") {
+          this.middlewareChain.add(middleware.handle());
+        }
+      });
+    }
+  }
+  initializeRoutes() {
+    this.config.routes.forEach((routeConfig) => {
+      const handler = async (req, res, next) => {
+        await this.handleGatewayRequest(req, res, routeConfig);
+      };
+      const route = new GatewayRoute(routeConfig, handler, "");
+      this.routes.set(`${routeConfig.method}:${routeConfig.path}`, route);
+    });
+  }
+  buildOpticoreRoutes() {
+    const featureRoutes = [];
+    const gatewayFeature = { routes: [] };
+    this.routes.forEach((gatewayRoute) => {
+      const config = gatewayRoute.getConfig();
+      const standaloneRouter = new import_opticore_router2.OpticoreStandaloneRouterFactory();
+      const contextHandler = async (context) => {
+        const { req, res } = context;
+        req.url = req.originalUrl || req.url;
+        return new Promise((resolve) => {
+          this.middlewareChain.execute(req, res, (_r, _s, _n) => {
+            this.handleGatewayRequest(req, res, config).then(resolve).catch(() => {
+              if (!res.headersSent) {
+                res.statusCode = 502;
+                res.end(JSON.stringify({ error: "Bad Gateway" }));
+              }
+              resolve();
+            });
+          });
+        });
+      };
+      standaloneRouter.storeRoute(
+        config.method,
+        "*",
+        contextHandler
+      );
+      gatewayFeature.routes.push({
+        path: config.path,
+        handler: standaloneRouter.getRoute()
+      });
+    });
+    featureRoutes.push(gatewayFeature);
+    this.opticoreRoutes = this.registerRouter.registered(featureRoutes);
+  }
+  async handleGatewayRequest(req, res, routeConfig) {
+    const startTime = Date.now();
+    try {
+      if (routeConfig.middlewares && routeConfig.middlewares.length > 0) {
+        const routeMiddlewareChain = new MiddlewareChain();
+        routeConfig.middlewares.forEach((middleware) => {
+          if (typeof middleware === "function") {
+            routeMiddlewareChain.add(middleware);
+          } else if (middleware.handle && typeof middleware.handle === "function") {
+            routeMiddlewareChain.add(middleware.handle());
+          }
+        });
+        await new Promise((resolve, reject) => {
+          routeMiddlewareChain.execute(req, res, (req2, res2, next) => {
+            resolve();
+          });
+        });
+      }
+      let serviceUrl;
+      let serviceName;
+      if (Array.isArray(routeConfig.target)) {
+        serviceName = routeConfig.serviceName || this.extractServiceName(routeConfig.target[0]);
+        const instances = this.serviceRegistry.getHealthyInstances(serviceName);
+        if (instances.length === 0) {
+          res.statusCode = 503;
+          res.end(JSON.stringify({ error: "Service unavailable" }));
+          return;
+        }
+        const instance = this.loadBalancer.selectInstance(serviceName, instances);
+        if (!instance) {
+          res.statusCode = 503;
+          res.end(JSON.stringify({ error: "No healthy instances available" }));
+          return;
+        }
+        serviceUrl = this.rewriteUrl(req.url, instance.url, routeConfig.target[0]);
+        instance.currentConnections++;
+        const response = await this.forwardRequest(req, res, serviceUrl, instance);
+        this.serviceRegistry.recordSuccess(serviceName, instance.url);
+        instance.currentConnections--;
+        this.sendResponse(res, response);
+      } else {
+        serviceName = routeConfig.serviceName || this.extractServiceName(routeConfig.target);
+        const instances = this.serviceRegistry.getHealthyInstances(serviceName);
+        if (instances.length === 0) {
+          res.statusCode = 503;
+          res.end(JSON.stringify({ error: "Service unavailable" }));
+          return;
+        }
+        const instance = instances[0];
+        serviceUrl = this.rewriteUrl(req.url, instance.url, routeConfig.target);
+        instance.currentConnections++;
+        const response = await this.forwardRequest(req, res, serviceUrl, instance);
+        this.serviceRegistry.recordSuccess(serviceName, instance.url);
+        instance.currentConnections--;
+        this.sendResponse(res, response);
+      }
+    } catch (error) {
+      console.error("Gateway error:", error);
+      res.statusCode = 502;
+      res.end(JSON.stringify({
+        error: "Bad Gateway",
+        message: error instanceof Error ? error.message : "Unknown error"
+      }));
+    } finally {
+      const duration = Date.now() - startTime;
+      if (this.config.enableLogging) {
+        console.log(`Gateway request completed in ${duration}ms`);
+      }
+    }
+  }
+  extractServiceName(url) {
+    try {
+      const urlObj = new URL(url);
+      return urlObj.hostname;
+    } catch {
+      return "unknown-service";
+    }
+  }
+  rewriteUrl(originalUrl, baseUrl, pattern) {
+    if (pattern && originalUrl.startsWith(pattern)) {
+      const url = new URL(baseUrl);
+      const path = originalUrl.replace(new RegExp(`^${pattern}`), "");
+      return `${url.protocol}//${url.host}${path}`;
+    }
+    try {
+      const base = new URL(baseUrl);
+      return `${base.protocol}//${base.host}${originalUrl}`;
+    } catch {
+      return `${baseUrl}${originalUrl}`;
+    }
+  }
+  async forwardRequest(req, res, targetUrl, instance) {
+    const headers = { ...req.headers };
+    delete headers["host"];
+    delete headers["connection"];
+    headers["x-forwarded-for"] = req.socket?.remoteAddress || "";
+    headers["x-forwarded-proto"] = req.protocol || "http";
+    headers["x-gateway-service"] = instance.name || "unknown";
+    const timeout = instance.timeout || this.config.routes.find(
+      (r) => r.target === instance.url || Array.isArray(r.target) && r.target.includes(instance.url)
+    )?.timeout || 3e4;
+    try {
+      return await this.httpClient.request(targetUrl, {
+        method: req.method,
+        headers,
+        body: req.body,
+        timeout
+      });
+    } catch (error) {
+      this.serviceRegistry.recordFailure(instance.name, instance.url);
+      throw error;
+    }
+  }
+  sendResponse(res, httpResponse) {
+    if (httpResponse.headers) {
+      Object.keys(httpResponse.headers).forEach((key) => {
+        const value = httpResponse.headers[key];
+        if (value !== void 0) {
+          res.setHeader(key, value);
+        }
+      });
+    }
+    res.statusCode = httpResponse.status;
+    res.end(httpResponse.body);
+  }
+  addRoute(routeConfig) {
+    const handler = async (req, res, next) => {
+      await this.handleGatewayRequest(req, res, routeConfig);
+    };
+    const route = new GatewayRoute(routeConfig, handler, "");
+    this.routes.set(`${routeConfig.method}:${routeConfig.path}`, route);
+    this.buildOpticoreRoutes();
+  }
+  addMiddleware(middleware) {
+    this.middlewareChain.add(middleware);
+  }
+  registerService(service) {
+    this.serviceRegistry.registerService(service);
+  }
+  getOpticoreRoutes() {
+    return this.opticoreRoutes;
+  }
+  async parseRequestBody(req) {
+    if (req.body !== void 0) return;
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      req.on("data", (chunk) => chunks.push(chunk));
+      req.on("end", () => {
+        if (chunks.length === 0) {
+          resolve();
+          return;
+        }
+        const raw = Buffer.concat(chunks).toString("utf8");
+        const contentType = req.headers["content-type"] || "";
+        if (contentType.includes("application/json")) {
+          try {
+            req.body = JSON.parse(raw);
+          } catch {
+            req.body = raw;
+          }
+        } else if (contentType.includes("application/x-www-form-urlencoded")) {
+          req.body = Object.fromEntries(new URLSearchParams(raw));
+        } else {
+          req.body = raw || void 0;
+        }
+        resolve();
+      });
+      req.on("error", reject);
+    });
+  }
+  getExpressMiddleware() {
+    return (req, res, next) => {
+      this.middlewareChain.execute(req, res, (_r, _s, _n) => next());
+    };
+  }
+  start() {
+    return new Promise((resolve, reject) => {
+      this.server = http2.createServer(async (req, res) => {
+        await this.parseRequestBody(req);
+        this.middlewareChain.execute(req, res, () => {
+          let handled = false;
+          this.routes.forEach((gatewayRoute) => {
+            if (handled) return;
+            const config = gatewayRoute.getConfig();
+            if (req.method?.toLowerCase() === config.method && req.url?.startsWith(config.path)) {
+              this.handleGatewayRequest(req, res, config).catch(() => {
+                if (!res.headersSent) {
+                  res.statusCode = 502;
+                  res.end(JSON.stringify({ error: "Bad Gateway" }));
+                }
+              });
+              handled = true;
+            }
+          });
+          if (!handled) {
+            res.statusCode = 404;
+            res.end(JSON.stringify({ error: "Route not found" }));
+          }
+        });
+      });
+      this.server.listen(this.config.port, () => {
+        console.log(`API Gateway running on port ${this.config.port}`);
+        console.log(`Registered ${this.routes.size} routes`);
+        resolve();
+      });
+      this.server.on("error", (error) => {
+        reject(error);
+      });
+    });
+  }
+  stop() {
+    return new Promise((resolve, reject) => {
+      if (this.server) {
+        this.server.close((error) => {
+          if (error) {
+            reject(error);
+          } else {
+            console.log("API Gateway stopped");
+            this.server = null;
+            resolve();
+          }
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+};
+
+// src/presentation/middleware/auth.middleware.ts
+var AuthMiddleware = class extends BaseMiddleware {
+  apiKeys;
+  constructor(apiKeys = []) {
+    super();
+    this.apiKeys = new Set(apiKeys);
+  }
+  handle() {
+    return (req, res, next) => {
+      const apiKey = req.headers["x-api-key"] || req.query && req.query.apiKey;
+      if (!apiKey) {
+        res.statusCode = 401;
+        res.end(JSON.stringify({ error: "API key required" }));
+        return;
+      }
+      if (!this.apiKeys.has(apiKey)) {
+        res.statusCode = 403;
+        res.end(JSON.stringify({ error: "Invalid API key" }));
+        return;
+      }
+      next();
+    };
+  }
+};
+
+// src/presentation/middleware/rateLimit.middleware.ts
+var RateLimitMiddleware = class extends BaseMiddleware {
+  requestsPerWindow;
+  windowMs;
+  store;
+  constructor(requestsPerWindow = 100, windowMs = 6e4) {
+    super();
+    this.requestsPerWindow = requestsPerWindow;
+    this.windowMs = windowMs;
+    this.store = /* @__PURE__ */ new Map();
+  }
+  handle() {
+    return (req, res, next) => {
+      const clientId = req.headers["x-forwarded-for"] || req.socket?.remoteAddress || "unknown";
+      const key = `rate-limit:${clientId}`;
+      const now = Date.now();
+      let window = this.store.get(key);
+      if (!window || now > window.resetTime) {
+        window = {
+          count: 0,
+          resetTime: now + this.windowMs
+        };
+        this.store.set(key, window);
+      }
+      window.count++;
+      res.setHeader("X-RateLimit-Limit", this.requestsPerWindow.toString());
+      res.setHeader("X-RateLimit-Remaining", Math.max(0, this.requestsPerWindow - window.count).toString());
+      res.setHeader("X-RateLimit-Reset", Math.ceil(window.resetTime / 1e3).toString());
+      if (window.count > this.requestsPerWindow) {
+        res.statusCode = 429;
+        res.end(JSON.stringify({
+          error: "Too many requests",
+          retryAfter: Math.ceil((window.resetTime - now) / 1e3)
+        }));
+        return;
+      }
+      next();
+    };
+  }
+};
+
+// src/presentation/middleware/loggin.middleware.ts
+var LoggingMiddleware = class extends BaseMiddleware {
+  constructor(logLevel = "info") {
+    super();
+    this.logLevel = logLevel;
+  }
+  handle() {
+    return (req, res, next) => {
+      const start = Date.now();
+      res.on("finish", () => {
+        const duration = Date.now() - start;
+        const message = `${req.method} ${req.originalUrl} ${res.statusCode} ${duration}ms`;
+        if (res.statusCode >= 500) console.error(message);
+        else console.log(message);
+      });
+      next();
+    };
+  }
+};
+
+// src/presentation/middleware/validation.middleware.ts
+var import_opticore_validator = require("opticore-validator");
+var ValidationMiddleware = class extends BaseMiddleware {
+  validator;
+  target;
+  /**
+   * Crée un middleware de validation.
+   * @param schema - Le schéma de validation au format opticore-validator.
+   * @param target - La partie de la requête à valider (par défaut 'body').
+   */
+  constructor(schema, target = "body") {
+    super();
+    this.validator = new import_opticore_validator.Validator(schema);
+    this.target = target;
+  }
+  handle() {
+    return (req, res, next) => {
+      let dataToValidate;
+      switch (this.target) {
+        case "body":
+          dataToValidate = req.body;
+          break;
+        case "query":
+          dataToValidate = req.query;
+          break;
+        case "params":
+          dataToValidate = req.params;
+          break;
+        case "all":
+          dataToValidate = { ...req.body, ...req.query, ...req.params };
+          break;
+        default:
+          dataToValidate = req.body;
+      }
+      if (dataToValidate === void 0 || dataToValidate === null) {
+        dataToValidate = {};
+      }
+      const errors = this.validator.validate(dataToValidate);
+      if (errors && typeof errors === "object" && Object.keys(errors).length > 0) {
+        res.status(400).json({
+          message: "Validation failed",
+          errors
+        });
+        return;
+      }
+      next();
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APIGateway,
+  AuthMiddleware,
+  BaseMiddleware,
+  GatewayRoute,
+  HttpClient,
+  LoadBalancer,
+  LoggingMiddleware,
+  MiddlewareChain,
+  RateLimitMiddleware,
+  ServiceRegistry,
+  ValidationMiddleware
+});