azurajs 2.1.2 → 2.2.0

package/dist/index.cjs

@@ -0,0 +1,910 @@
+'use strict';
+
+var http = require('http');
+var cluster2 = require('cluster');
+var os = require('os');
+var fs = require('fs');
+var path = require('path');
+require('net');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var http__default = /*#__PURE__*/_interopDefault(http);
+var cluster2__default = /*#__PURE__*/_interopDefault(cluster2);
+var os__default = /*#__PURE__*/_interopDefault(os);
+var path__default = /*#__PURE__*/_interopDefault(path);
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var ConfigModule = class {
+  constructor() {
+    this.config = {};
+  }
+  /**
+   * Load config files first (azura.config.*)
+   * Recivied error if config file not found or invalid format
+   * @param configFiles
+   */
+  initSync() {
+    const cdw = process.cwd();
+    const configFiles = [
+      "azura.config.ts",
+      "azura.config.json",
+      "azura.config.yaml",
+      "azura.config.yml"
+    ];
+    let loaded = false;
+    for (const fileName of configFiles) {
+      const filePath = path__default.default.join(cdw, fileName);
+      if (!fs.existsSync(filePath)) continue;
+      const extension = path__default.default.extname(fileName);
+      const raw = fs.readFileSync(filePath, "utf8");
+      try {
+        let parsed;
+        switch (extension) {
+          case ".ts":
+            const mod = __require(filePath);
+            parsed = mod.default || mod;
+            break;
+          case ".json":
+            parsed = JSON.parse(raw);
+            break;
+          case ".yaml":
+          case ".yml":
+            parsed = __require("js-yaml").load(raw);
+            break;
+          default:
+            throw new Error(`Invalid config file extension: ${extension}`);
+        }
+        this.config = { ...this.config, ...parsed };
+        loaded = true;
+        break;
+      } catch (error) {
+        throw new Error(`Error loading config file: ${filePath}
+${error.message}`);
+      }
+    }
+    if (!loaded) {
+      throw new Error("Nothing config file found in the current directory.");
+    }
+  }
+  /**
+   * Get all configs from loaded config file
+   * @returns ConfigTypes
+   */
+  getAll() {
+    return this.config;
+  }
+  /**
+   * Return a specific config from loaded config file
+   *
+   * @template T
+   * @param {T} key - key of the config to retrieve
+   * @returns {ConfigTypes[T]}
+   */
+  get(key) {
+    return this.config[key];
+  }
+};
+
+// src/infra/utils/HttpError.ts
+var HttpError = class extends Error {
+  constructor(status, message, payload) {
+    super(message ?? String(message ?? "Error"));
+    this.status = status;
+    this.payload = payload;
+  }
+};
+
+// src/utils/Logger.ts
+var RESET = "\x1B[0m";
+var COLORS = {
+  info: "\x1B[36m",
+  warn: "\x1B[33m",
+  error: "\x1B[31m"
+};
+var LEVEL_LABELS = {
+  info: "INFO",
+  warn: "WARN",
+  error: "ERROR"
+};
+function logger(level, msg) {
+  const color = COLORS[level];
+  const levelLabel = LEVEL_LABELS[level];
+  const prefix = `${color}[Azura:${levelLabel}]${RESET}`;
+  (level === "error" ? console.error : level === "warn" ? console.warn : console.log)(
+    `${prefix} ${msg}`
+  );
+}
+
+// src/utils/Parser.ts
+function parseQS(qs) {
+  const out = {};
+  if (!qs) return out;
+  const parts = qs.split("&");
+  for (let i = 0; i < parts.length; i++) {
+    const p = parts[i];
+    if (!p) continue;
+    const idx = p.indexOf("=");
+    if (idx === -1) {
+      out[decodeURIComponent(p)] = "";
+      continue;
+    }
+    const k = decodeURIComponent(p.slice(0, idx));
+    const v = decodeURIComponent(p.slice(idx + 1));
+    const existing = out[k];
+    if (existing !== void 0) {
+      if (Array.isArray(existing)) {
+        existing.push(v);
+      } else {
+        out[k] = [existing, v];
+      }
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+
+// src/utils/cookies/SerializeCookie.ts
+function serializeCookie(name, val, opts = {}) {
+  const encode = opts.encode ?? encodeURIComponent;
+  let str = `${name}=${encode(val)}`;
+  if (opts.maxAge != null && !Number.isNaN(Number(opts.maxAge)))
+    str += `; Max-Age=${Math.floor(Number(opts.maxAge))}`;
+  if (opts.domain) str += `; Domain=${opts.domain}`;
+  if (opts.path) str += `; Path=${opts.path}`;
+  if (opts.expires) str += `; Expires=${opts.expires.toUTCString()}`;
+  if (opts.httpOnly) str += `; HttpOnly`;
+  if (opts.secure) str += `; Secure`;
+  if (opts.sameSite) str += `; SameSite=${opts.sameSite}`;
+  return str;
+}
+
+// src/utils/cookies/ParserCookie.ts
+function parseCookiesHeader(header) {
+  if (!header) return {};
+  return header.split(";").reduce((acc, pair) => {
+    const [k, ...vals] = pair.trim().split("=");
+    if (!k) return acc;
+    acc[k] = decodeURIComponent(vals.join("="));
+    return acc;
+  }, {});
+}
+
+// src/infra/utils/RequestHandler.ts
+function adaptRequestHandler(mw) {
+  if (typeof mw !== "function") return mw;
+  return async (ctx) => {
+    try {
+      if (mw.length === 3) {
+        await new Promise((resolve, reject) => {
+          try {
+            const maybe = mw(ctx.request, ctx.response, (err) => {
+              if (err) reject(err);
+              else resolve();
+            });
+            if (maybe && typeof maybe.then === "function") {
+              maybe.then(() => resolve()).catch(reject);
+            }
+          } catch (e) {
+            reject(e);
+          }
+        });
+      } else {
+        await mw(ctx);
+      }
+    } catch (err) {
+      throw err;
+    }
+  };
+}
+
+// src/infra/utils/route/Node.ts
+var Node = class {
+  constructor() {
+    this.children = /* @__PURE__ */ new Map();
+    this.handlers = /* @__PURE__ */ new Map();
+  }
+};
+
+// src/infra/Router.ts
+var Router = class {
+  constructor(debug = false) {
+    this.root = new Node();
+    this.debug = debug;
+  }
+  add(method, path2, ...handlers) {
+    const segments = path2.split("/").filter(Boolean);
+    let node = this.root;
+    for (const seg of segments) {
+      let child;
+      if (seg.startsWith(":")) {
+        child = new Node();
+        child.isParam = true;
+        child.paramName = seg.slice(1);
+      } else {
+        child = node.children.get(seg) ?? new Node();
+      }
+      node.children.set(seg.startsWith(":") ? ":" : seg, child);
+      node = child;
+    }
+    node.handlers.set(method.toUpperCase(), handlers);
+  }
+  find(method, path2) {
+    const cleanPath = path2.split("?")[0];
+    const segments = cleanPath?.split("/").filter(Boolean) ?? [];
+    let node = this.root;
+    const params = {};
+    if (this.debug && segments?.length === 0 && node.handlers.size === 0) {
+      console.error("[Router:DEBUG] Root node has no handlers");
+      console.error("[Router:DEBUG] Available methods at root:", Array.from(node.handlers.keys()));
+    }
+    for (let i = 0; i < segments.length; i++) {
+      const seg = segments[i];
+      if (!seg) continue;
+      let child = node.children.get(seg);
+      if (child) {
+        node = child;
+      } else {
+        child = node.children.get(":");
+        if (child) {
+          node = child;
+          if (node.paramName) {
+            params[node.paramName] = seg;
+          }
+        } else {
+          if (this.debug) {
+            console.error(`[Router:DEBUG] Route not found for ${method} ${cleanPath}`);
+            console.error(`[Router:DEBUG] Failed at segment: "${seg}"`);
+            console.error(`[Router:DEBUG] Available children:`, Array.from(node.children.keys()));
+          }
+          throw new HttpError(404, "Route not found");
+        }
+      }
+    }
+    const handlers = node.handlers.get(method.toUpperCase());
+    if (!handlers) {
+      if (this.debug) {
+        console.error(
+          `[Router:DEBUG] No handlers for method ${method.toUpperCase()} at path ${cleanPath}`
+        );
+        console.error(
+          `[Router:DEBUG] Available methods at this path:`,
+          Array.from(node.handlers.keys())
+        );
+        console.error(`[Router:DEBUG] Segments matched:`, segments);
+      }
+      throw new HttpError(404, "Route not found");
+    }
+    return { handlers, params };
+  }
+  listRoutes() {
+    const routes = [];
+    const traverse = (node, path2) => {
+      if (node.handlers.size > 0) {
+        for (const method of node.handlers.keys()) {
+          routes.push({ method, path: path2 || "/" });
+        }
+      }
+      for (const [segment, child] of node.children) {
+        const newPath = path2 + "/" + (segment === ":" && child.paramName ? `:${child.paramName}` : segment);
+        traverse(child, newPath);
+      }
+    };
+    traverse(this.root, "");
+    return routes;
+  }
+};
+function getIP(port) {
+  const networkInterfaces = os__default.default.networkInterfaces();
+  Object.values(networkInterfaces).forEach((ifaceList) => {
+    ifaceList?.forEach((iface) => {
+      if (iface.family === "IPv4" && !iface.internal) {
+        const who = cluster2__default.default.isPrimary ? "master" : "worker";
+        logger("info", `[${who}] accessible at http://${iface.address}:${port}`);
+      }
+    });
+  });
+}
+
+// src/shared/plugins/CORSPlugin.ts
+function cors(opts) {
+  const { origin, methods, allowedHeaders } = opts;
+  return (ctx, next) => {
+    ctx.response.setHeader(
+      "Access-Control-Allow-Origin",
+      Array.isArray(origin) ? origin.join(",") : origin
+    );
+    ctx.response.setHeader(
+      "Access-Control-Allow-Methods",
+      Array.isArray(methods) ? methods.join(",") : methods
+    );
+    ctx.response.setHeader(
+      "Access-Control-Allow-Headers",
+      Array.isArray(allowedHeaders) ? allowedHeaders.join(",") : allowedHeaders
+    );
+    if (ctx.request.method === "OPTIONS") {
+      ctx.response.writeHead(204);
+      return ctx.response.end();
+    }
+    return next();
+  };
+}
+
+// src/shared/plugins/RateLimitPlugin.ts
+var store = /* @__PURE__ */ new Map();
+function rateLimit(limit, ttl) {
+  return async (ctx, next) => {
+    const ip = ctx.request.socket.remoteAddress;
+    const now = Date.now();
+    const entry = store.get(ip) ?? { count: 0, ts: now };
+    if (now - entry.ts > ttl) {
+      entry.count = 1;
+      entry.ts = now;
+    } else {
+      entry.count++;
+    }
+    store.set(ip, entry);
+    if (entry.count > limit) {
+      ctx.response.status(429).send("Too many requests");
+      return;
+    }
+    await next();
+  };
+}
+
+// src/middleware/LoggingMiddleware.ts
+function createLoggingMiddleware(config) {
+  const isEnabled = config.logging?.enabled ?? true;
+  const showDetails = config.logging?.showDetails ?? true;
+  const env = config.environment || "development";
+  const reset = "\x1B[0m";
+  const bold = "\x1B[1m";
+  const dim = "\x1B[2m";
+  const colors = {
+    GET: "\x1B[36m",
+    POST: "\x1B[32m",
+    PUT: "\x1B[33m",
+    DELETE: "\x1B[31m",
+    PATCH: "\x1B[35m",
+    DEFAULT: "\x1B[37m"
+  };
+  const fn = async (...args) => {
+    let req;
+    let res;
+    let next;
+    if (args.length === 1 && typeof args[0] === "object" && args[0] !== null) {
+      const ctx = args[0];
+      req = ctx.request || ctx.req;
+      res = ctx.response || ctx.res;
+      next = ctx.next;
+    } else {
+      req = args[0];
+      res = args[1];
+      next = args[2];
+    }
+    if (!req || !res) {
+      if (typeof next === "function") await next();
+      return;
+    }
+    if (!isEnabled) {
+      if (typeof next === "function") await next();
+      return;
+    }
+    const start = Date.now();
+    const methodRaw = String(req.method || "GET").toUpperCase();
+    const methodPad = methodRaw.padEnd(6, " ");
+    const methodColor = colors[methodRaw] || colors.DEFAULT;
+    const url = String(req.originalUrl || req.url || "/");
+    const ip = String(req.ip || "").replace("::ffff:", "");
+    const time = (/* @__PURE__ */ new Date()).toLocaleTimeString("pt-BR", { hour12: false });
+    try {
+      if (env === "development") {
+        const header = `${dim}\xB7${reset} ${bold}${time}${reset}  ${methodColor}${methodPad}${reset} ${bold}${url}${reset}`;
+        console.log(header);
+        if (showDetails) {
+          try {
+            if (req.query && Object.keys(req.query).length > 0) {
+              console.log(`${dim}   \u203A query:${reset} ${JSON.stringify(req.query)}`);
+            }
+          } catch {
+          }
+          try {
+            const params = req.params;
+            if (params && Object.keys(params).length > 0) {
+              console.log(`${dim}   \u203A params:${reset} ${JSON.stringify(params)}`);
+            }
+          } catch {
+          }
+          try {
+            if (req.body && Object.keys(req.body).length > 0) {
+              console.log(`${dim}   \u203A body:${reset} ${JSON.stringify(req.body)}`);
+            }
+          } catch {
+          }
+        }
+      } else {
+        console.log(
+          `${dim}\xB7${reset} ${time}  ${methodColor}${methodPad}${reset} ${url} ${dim}\u2022 IP:${ip}${reset}`
+        );
+      }
+    } catch {
+    }
+    try {
+      if (typeof res.on === "function") {
+        res.on("finish", () => {
+          const duration = Date.now() - start;
+          const statusCode = Number(res.statusCode || 0);
+          const statusColor = statusCode >= 500 ? "\x1B[31m" : statusCode >= 400 ? "\x1B[33m" : "\x1B[32m";
+          const statusText = `${statusColor}${statusCode}${reset}`;
+          const durationText = `${dim}(${duration}ms)${reset}`;
+          const ipShort = ip || "-";
+          const line = `${dim}\u2192${reset} ${statusText} ${durationText} ${dim}\u2022 IP:${ipShort}${reset}`;
+          console.log(line);
+        });
+      }
+    } catch {
+    }
+    if (typeof next === "function") {
+      await next();
+    }
+  };
+  return fn;
+}
+
+// src/infra/Server.ts
+var AzuraClient = class {
+  constructor() {
+    this.port = 3e3;
+    this.middlewares = [];
+    this.get = (p, ...h) => this.addRoute("GET", p, ...h);
+    this.post = (p, ...h) => this.addRoute("POST", p, ...h);
+    this.put = (p, ...h) => this.addRoute("PUT", p, ...h);
+    this.delete = (p, ...h) => this.addRoute("DELETE", p, ...h);
+    this.patch = (p, ...h) => this.addRoute("PATCH", p, ...h);
+    const config = new ConfigModule();
+    try {
+      config.initSync();
+    } catch (error) {
+      console.error("[Azura] \u274C Falha ao carregar configura\xE7\xE3o:");
+      console.error("        ", error.message);
+      process.exit(1);
+    }
+    this.opts = config.getAll();
+    this.router = new Router(this.opts.debug || false);
+    this.initPromise = this.init();
+    this.setupDefaultRoutes();
+  }
+  /**
+   * Configura rotas padrão para evitar erros 404 comuns
+   */
+  setupDefaultRoutes() {
+    this.router.add(
+      "GET",
+      "/favicon.ico",
+      adaptRequestHandler((ctx) => {
+        ctx.res.status(204).send();
+      })
+    );
+  }
+  getConfig() {
+    return this.opts;
+  }
+  async init() {
+    this.port = this.opts.server?.port || 3e3;
+    if (this.opts.server?.cluster && cluster2__default.default.isPrimary) {
+      for (let i = 0; i < os__default.default.cpus().length; i++) cluster2__default.default.fork();
+      cluster2__default.default.on("exit", () => cluster2__default.default.fork());
+      return;
+    }
+    if (this.opts.plugins?.cors?.enabled) {
+      cors({
+        origin: this.opts.plugins.cors.origins,
+        methods: this.opts.plugins.cors.methods,
+        allowedHeaders: this.opts.plugins.cors.allowedHeaders
+      });
+      logger("info", "CORS plugin enabled");
+    }
+    if (this.opts.plugins?.rateLimit?.enabled) {
+      rateLimit(this.opts.plugins.rateLimit.limit, this.opts.plugins.rateLimit.timeframe);
+      logger("info", "Rate Limit plugin enabled");
+    }
+    this.server = http__default.default.createServer();
+    this.server.on("request", this.handle.bind(this));
+  }
+  use(mw) {
+    this.middlewares.push(mw);
+  }
+  addRoute(method, path2, ...handlers) {
+    const adapted = handlers.map(adaptRequestHandler);
+    this.router.add(method, path2, ...adapted);
+  }
+  getRoutes() {
+    return this.router.listRoutes();
+  }
+  async listen(port = this.port) {
+    await this.initPromise;
+    if (!this.server) {
+      logger("error", "Server not initialized");
+      return;
+    }
+    this.server.on("error", (error) => {
+      if (error.code === "EADDRINUSE") {
+        logger("error", `\u274C Port ${port} is already in use. Please choose a different port.`);
+      } else {
+        logger("error", "Server failed to start: " + (error?.message || String(error)));
+      }
+      process.exit(1);
+    });
+    const who = cluster2__default.default.isPrimary ? "master" : "worker";
+    this.server.listen(port, () => {
+      logger("info", `[${who}] listening on http://localhost:${port}`);
+      if (this.opts.server?.ipHost) getIP(port);
+      const routes = this.getRoutes();
+      if (routes.length > 0) {
+        logger("info", `
+\u{1F4CB} Registered routes (${routes.length}):`);
+        routes.forEach((r) => {
+          logger("info", `   ${r.method.padEnd(7)} ${r.path}`);
+        });
+      }
+    });
+    return this.server;
+  }
+  /**
+   * Fetch handler compatible with Web API (Bun, Deno, Cloudflare Workers, etc.)
+   * @example
+   * ```typescript
+   * const app = new AzuraClient();
+   * app.get('/', (req, res) => res.text('Hello World!'));
+   *
+   * // Use with Bun
+   * Bun.serve({
+   *   port: 3000,
+   *   fetch: app.fetch.bind(app),
+   * });
+   *
+   * // Use with Deno
+   * Deno.serve({ port: 3000 }, app.fetch.bind(app));
+   * ```
+   */
+  async fetch(request) {
+    await this.initPromise;
+    const url = new URL(request.url);
+    const urlPath = url.pathname;
+    const safeQuery = {};
+    if (url.search) {
+      const rawQuery = parseQS(url.search.slice(1));
+      for (const k in rawQuery) {
+        const v = rawQuery[k];
+        safeQuery[k] = Array.isArray(v) ? v[0] || "" : v;
+      }
+    }
+    const cookieHeader = request.headers.get("cookie") || "";
+    const cookies = parseCookiesHeader(cookieHeader);
+    let body = {};
+    if (["POST", "PUT", "PATCH"].includes(request.method.toUpperCase())) {
+      const contentType = request.headers.get("content-type") || "";
+      try {
+        if (contentType.includes("application/json")) {
+          body = await request.json();
+        } else if (contentType.includes("application/x-www-form-urlencoded")) {
+          const text = await request.text();
+          const parsed = parseQS(text || "");
+          const b = {};
+          for (const k in parsed) {
+            const v = parsed[k];
+            b[k] = Array.isArray(v) ? v[0] || "" : v || "";
+          }
+          body = b;
+        } else {
+          body = await request.text();
+        }
+      } catch {
+        body = {};
+      }
+    }
+    const protocol = url.protocol.slice(0, -1);
+    const headersObj = {};
+    request.headers.forEach((value, key) => {
+      headersObj[key] = value;
+    });
+    const rawReq = {
+      method: request.method,
+      url: url.pathname + url.search,
+      originalUrl: url.pathname + url.search,
+      path: urlPath || "/",
+      protocol,
+      secure: url.protocol === "https:",
+      hostname: url.hostname,
+      subdomains: url.hostname ? url.hostname.split(".").slice(0, -2) : [],
+      query: safeQuery,
+      cookies,
+      params: {},
+      body,
+      headers: headersObj,
+      get: (name) => request.headers.get(name.toLowerCase()) || void 0,
+      header: (name) => request.headers.get(name.toLowerCase()) || void 0,
+      ip: request.headers.get("x-forwarded-for")?.split(",")[0]?.trim() || "",
+      ips: request.headers.get("x-forwarded-for")?.split(/\s*,\s*/) || []
+    };
+    let statusCode = 200;
+    const responseHeaders = new Headers();
+    let responseBody = null;
+    const rawRes = {
+      statusCode,
+      status: (code) => {
+        statusCode = code;
+        return rawRes;
+      },
+      set: (field, value) => {
+        responseHeaders.set(field, String(value));
+        return rawRes;
+      },
+      header: (field, value) => {
+        responseHeaders.set(field, String(value));
+        return rawRes;
+      },
+      get: (field) => responseHeaders.get(field) || void 0,
+      type: (t) => {
+        responseHeaders.set("Content-Type", t);
+        return rawRes;
+      },
+      contentType: (t) => {
+        responseHeaders.set("Content-Type", t);
+        return rawRes;
+      },
+      location: (u) => {
+        responseHeaders.set("Location", u);
+        return rawRes;
+      },
+      redirect: ((a, b) => {
+        if (typeof a === "number") {
+          statusCode = a;
+          responseHeaders.set("Location", b);
+        } else {
+          statusCode = 302;
+          responseHeaders.set("Location", a);
+        }
+        return rawRes;
+      }),
+      cookie: (name, val, opts = {}) => {
+        const s = serializeCookie(name, val, opts);
+        const prev = responseHeaders.get("Set-Cookie");
+        if (prev) {
+          responseHeaders.append("Set-Cookie", s);
+        } else {
+          responseHeaders.set("Set-Cookie", s);
+        }
+        return rawRes;
+      },
+      clearCookie: (name, opts = {}) => {
+        return rawRes.cookie(name, "", { ...opts, expires: /* @__PURE__ */ new Date(1), maxAge: 0 });
+      },
+      send: (b) => {
+        if (b === void 0 || b === null) {
+          responseBody = "";
+        } else if (typeof b === "object") {
+          responseHeaders.set("Content-Type", "application/json");
+          responseBody = JSON.stringify(b);
+        } else {
+          responseBody = String(b);
+        }
+        return rawRes;
+      },
+      json: (b) => {
+        responseHeaders.set("Content-Type", "application/json");
+        responseBody = JSON.stringify(b);
+        return rawRes;
+      }
+    };
+    const errorHandler = (err) => {
+      statusCode = err instanceof HttpError ? err.status : 500;
+      responseHeaders.set("Content-Type", "application/json");
+      responseBody = JSON.stringify(
+        err instanceof HttpError ? err.payload ?? { error: err.message || "Internal Server Error" } : { error: err?.message || "Internal Server Error" }
+      );
+    };
+    try {
+      const { handlers, params } = this.router.find(request.method, urlPath || "/");
+      rawReq.params = params || {};
+      const chain = [
+        ...this.middlewares.map(adaptRequestHandler),
+        ...handlers.map(adaptRequestHandler)
+      ];
+      let idx = 0;
+      const next = async (err) => {
+        if (err) return errorHandler(err);
+        if (idx >= chain.length) return;
+        const fn = chain[idx++];
+        try {
+          await fn({
+            request: rawReq,
+            response: rawRes,
+            req: rawReq,
+            res: rawRes,
+            next
+          });
+        } catch (e) {
+          return errorHandler(e);
+        }
+      };
+      await next();
+    } catch (err) {
+      errorHandler(err);
+    }
+    return new Response(responseBody, {
+      status: statusCode,
+      headers: responseHeaders
+    });
+  }
+  async handle(rawReq, rawRes) {
+    rawReq.originalUrl = rawReq.url || "";
+    rawReq.protocol = this.opts.server?.https ? "https" : "http";
+    rawReq.secure = rawReq.protocol === "https";
+    rawReq.hostname = String(rawReq.headers["host"] || "").split(":")[0] || "";
+    rawReq.subdomains = rawReq.hostname ? rawReq.hostname.split(".").slice(0, -2) : [];
+    const ipsRaw = rawReq.headers["x-forwarded-for"];
+    rawReq.ips = typeof ipsRaw === "string" ? ipsRaw.split(/\s*,\s*/) : [];
+    rawReq.get = rawReq.header = (name) => {
+      const v = rawReq.headers[name.toLowerCase()];
+      if (Array.isArray(v)) return v[0];
+      return typeof v === "string" ? v : void 0;
+    };
+    rawRes.status = (code) => {
+      rawRes.statusCode = code;
+      return rawRes;
+    };
+    rawRes.set = rawRes.header = (field, value) => {
+      rawRes.setHeader(field, value);
+      return rawRes;
+    };
+    rawRes.get = (field) => {
+      const v = rawRes.getHeader(field);
+      if (Array.isArray(v)) return v[0];
+      return typeof v === "number" ? String(v) : v;
+    };
+    rawRes.type = rawRes.contentType = (t) => {
+      rawRes.setHeader("Content-Type", t);
+      return rawRes;
+    };
+    rawRes.location = (u) => {
+      rawRes.setHeader("Location", u);
+      return rawRes;
+    };
+    rawRes.redirect = ((a, b) => {
+      if (typeof a === "number") {
+        rawRes.statusCode = a;
+        rawRes.setHeader("Location", b);
+      } else {
+        rawRes.statusCode = 302;
+        rawRes.setHeader("Location", a);
+      }
+      rawRes.end();
+      return rawRes;
+    });
+    rawRes.cookie = (name, val, opts = {}) => {
+      const s = serializeCookie(name, val, opts);
+      const prev = rawRes.getHeader("Set-Cookie");
+      if (prev) {
+        const list = Array.isArray(prev) ? prev.concat(s) : [String(prev), s];
+        rawRes.setHeader("Set-Cookie", list);
+      } else {
+        rawRes.setHeader("Set-Cookie", s);
+      }
+      return rawRes;
+    };
+    rawRes.clearCookie = (name, opts = {}) => {
+      return rawRes.cookie(name, "", { ...opts, expires: /* @__PURE__ */ new Date(1), maxAge: 0 });
+    };
+    rawRes.send = (b) => {
+      if (b === void 0 || b === null) {
+        rawRes.end();
+        return rawRes;
+      }
+      if (typeof b === "object") {
+        rawRes.setHeader("Content-Type", "application/json");
+        rawRes.end(JSON.stringify(b));
+      } else {
+        rawRes.end(String(b));
+      }
+      return rawRes;
+    };
+    rawRes.json = (b) => {
+      rawRes.setHeader("Content-Type", "application/json");
+      rawRes.end(JSON.stringify(b));
+      return rawRes;
+    };
+    const [urlPath, qs] = (rawReq.url || "").split("?");
+    rawReq.path = urlPath || "/";
+    const rawQuery = parseQS(qs || "");
+    const safeQuery = {};
+    for (const k in rawQuery) {
+      const v = rawQuery[k];
+      safeQuery[k] = Array.isArray(v) ? v[0] || "" : v || "";
+    }
+    rawReq.query = safeQuery;
+    rawReq.cookies = parseCookiesHeader(rawReq.headers["cookie"] || "");
+    rawReq.params = {};
+    const ipRaw = rawReq.headers["x-forwarded-for"] || rawReq.socket.remoteAddress || "";
+    const ipStr = Array.isArray(ipRaw) ? ipRaw[0] : ipRaw;
+    rawReq.ip = String(ipStr).split(",")[0]?.trim() || "";
+    rawReq.body = {};
+    if (["POST", "PUT", "PATCH"].includes((rawReq.method || "").toUpperCase())) {
+      await new Promise((resolve) => {
+        let buf = "";
+        rawReq.on("data", (chunk) => {
+          buf += chunk;
+        });
+        rawReq.on("end", () => {
+          try {
+            const ct = String(rawReq.headers["content-type"] || "");
+            if (ct.includes("application/json")) {
+              rawReq.body = JSON.parse(buf || "{}");
+            } else {
+              const parsed = parseQS(buf || "");
+              const b = {};
+              for (const k in parsed) {
+                const v = parsed[k];
+                b[k] = Array.isArray(v) ? v[0] || "" : v || "";
+              }
+              rawReq.body = b;
+            }
+          } catch {
+            rawReq.body = {};
+          }
+          resolve();
+        });
+        rawReq.on("error", (err) => {
+          logger("error", "Body parse error: " + err.message);
+          resolve();
+        });
+      });
+    }
+    const errorHandler = (err) => {
+      logger("error", err?.message || String(err));
+      rawRes.status(err instanceof HttpError ? err.status : 500).json(
+        err instanceof HttpError ? err.payload ?? { error: err.message || "Internal Server Error" } : { error: err?.message || "Internal Server Error" }
+      );
+    };
+    try {
+      const { handlers, params } = this.router.find(rawReq.method || "GET", rawReq.path);
+      rawReq.params = params || {};
+      const chain = [
+        ...this.middlewares.map(adaptRequestHandler),
+        ...handlers.map(adaptRequestHandler)
+      ];
+      let idx = 0;
+      const next = async (err) => {
+        if (err) return errorHandler(err);
+        if (idx >= chain.length) return;
+        const fn = chain[idx++];
+        try {
+          await fn({
+            request: rawReq,
+            response: rawRes,
+            req: rawReq,
+            res: rawRes,
+            next
+          });
+        } catch (e) {
+          return errorHandler(e);
+        }
+      };
+      await next();
+    } catch (err) {
+      errorHandler(err);
+    }
+  }
+};
+
+exports.AzuraClient = AzuraClient;
+exports.Router = Router;
+exports.createLoggingMiddleware = createLoggingMiddleware;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map