azurajs 3.0.1 → 3.0.2

package/dist/core/index.mjs

@@ -1,5 +1,1104 @@
-export { AzuraServer, Router } from '../chunk-EYAHUNC7.mjs';
-import '../chunk-REJDZUZ5.mjs';
-import '../chunk-OWUGAI5V.mjs';
+import { createServer as createServer$1 } from 'http';
+import { createServer } from 'https';
+import { readFileSync } from 'fs';
+
+// src/core/server.ts
+
+// src/core/router.ts
+var PARAM_PREFIX = 58;
+function createNode(segment = "") {
+  return {
+    segment,
+    children: /* @__PURE__ */ new Map(),
+    paramChild: null,
+    paramName: "",
+    handlers: /* @__PURE__ */ new Map(),
+    wildcardHandler: null
+  };
+}
+var LRUCache = class {
+  capacity;
+  map;
+  head;
+  tail;
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.map = /* @__PURE__ */ new Map();
+    this.head = { prev: null, next: null };
+    this.tail = { prev: null, next: null };
+    this.head.next = this.tail;
+    this.tail.prev = this.head;
+  }
+  get(key) {
+    const node = this.map.get(key);
+    if (!node) return void 0;
+    this.moveToHead(node);
+    return node.value;
+  }
+  set(key, value) {
+    const existing = this.map.get(key);
+    if (existing) {
+      existing.value = value;
+      this.moveToHead(existing);
+      return;
+    }
+    const node = { value, key, prev: null, next: null };
+    this.map.set(key, node);
+    this.addToHead(node);
+    if (this.map.size > this.capacity) {
+      const removed = this.removeTail();
+      if (removed) this.map.delete(removed.key);
+    }
+  }
+  addToHead(node) {
+    node.prev = this.head;
+    node.next = this.head.next;
+    this.head.next.prev = node;
+    this.head.next = node;
+  }
+  removeNode(node) {
+    node.prev.next = node.next;
+    node.next.prev = node.prev;
+  }
+  moveToHead(node) {
+    this.removeNode(node);
+    this.addToHead(node);
+  }
+  removeTail() {
+    const node = this.tail.prev;
+    if (node === this.head) return null;
+    this.removeNode(node);
+    return node;
+  }
+  clear() {
+    this.map.clear();
+    this.head.next = this.tail;
+    this.tail.prev = this.head;
+  }
+};
+var Router = class {
+  root = createNode();
+  cache;
+  staticRoutes = /* @__PURE__ */ new Map();
+  constructor(cacheSize = 1024) {
+    this.cache = new LRUCache(cacheSize);
+  }
+  add(method, path, handler, middlewares = [], meta) {
+    this.cache.clear();
+    const normalizedPath = this.normalizePath(path);
+    const stored = { handler, middlewares, meta };
+    if (!normalizedPath.includes(":") && !normalizedPath.includes("*")) {
+      const key = `${method}:${normalizedPath}`;
+      this.staticRoutes.set(key, stored);
+      return;
+    }
+    const segments = normalizedPath.split("/").filter(Boolean);
+    let node = this.root;
+    for (let i = 0; i < segments.length; i++) {
+      const seg = segments[i];
+      if (seg === "*") {
+        if (!node.wildcardHandler) {
+          node.wildcardHandler = /* @__PURE__ */ new Map();
+        }
+        node.wildcardHandler.set(method, stored);
+        return;
+      }
+      if (seg.charCodeAt(0) === PARAM_PREFIX) {
+        if (!node.paramChild) {
+          node.paramChild = createNode(seg);
+          node.paramChild.paramName = seg.slice(1);
+        }
+        node = node.paramChild;
+        continue;
+      }
+      let child = node.children.get(seg);
+      if (!child) {
+        child = createNode(seg);
+        node.children.set(seg, child);
+      }
+      node = child;
+    }
+    node.handlers.set(method, stored);
+  }
+  find(method, path) {
+    const normalizedPath = this.normalizePath(path);
+    const staticKey = `${method}:${normalizedPath}`;
+    const staticRoute = this.staticRoutes.get(staticKey);
+    if (staticRoute) {
+      return {
+        handler: staticRoute.handler,
+        params: {},
+        middlewares: staticRoute.middlewares,
+        meta: staticRoute.meta
+      };
+    }
+    const cacheKey = staticKey;
+    const cached = this.cache.get(cacheKey);
+    if (cached !== void 0) {
+      return cached ? { ...cached, params: { ...cached.params } } : null;
+    }
+    const segments = normalizedPath.split("/").filter(Boolean);
+    const params = {};
+    const result = this.matchNode(this.root, segments, 0, params, method);
+    if (result) {
+      const match = {
+        handler: result.handler,
+        params,
+        middlewares: result.middlewares,
+        meta: result.meta
+      };
+      this.cache.set(cacheKey, match);
+      return { ...match, params: { ...params } };
+    }
+    this.cache.set(cacheKey, null);
+    return null;
+  }
+  matchNode(node, segments, idx, params, method) {
+    if (idx === segments.length) {
+      return node.handlers.get(method) ?? null;
+    }
+    const seg = segments[idx];
+    const child = node.children.get(seg);
+    if (child) {
+      const result = this.matchNode(child, segments, idx + 1, params, method);
+      if (result) return result;
+    }
+    if (node.paramChild) {
+      params[node.paramChild.paramName] = seg;
+      const result = this.matchNode(node.paramChild, segments, idx + 1, params, method);
+      if (result) return result;
+      delete params[node.paramChild.paramName];
+    }
+    if (node.wildcardHandler) {
+      const route = node.wildcardHandler.get(method);
+      if (route) return route;
+    }
+    return null;
+  }
+  normalizePath(path) {
+    if (path === "/") return "/";
+    if (path.endsWith("/") && path.length > 1) return path.slice(0, -1);
+    return path;
+  }
+  getAllRoutes() {
+    const routes = [];
+    for (const [key] of this.staticRoutes) {
+      const [method, path] = key.split(":", 2);
+      routes.push({ method, path });
+    }
+    this.collectRoutes(this.root, "", routes);
+    return routes;
+  }
+  collectRoutes(node, prefix, routes) {
+    for (const [method] of node.handlers) {
+      routes.push({ method, path: prefix || "/" });
+    }
+    for (const [seg, child] of node.children) {
+      this.collectRoutes(child, `${prefix}/${seg}`, routes);
+    }
+    if (node.paramChild) {
+      this.collectRoutes(
+        node.paramChild,
+        `${prefix}/:${node.paramChild.paramName}`,
+        routes
+      );
+    }
+    if (node.wildcardHandler) {
+      for (const [method] of node.wildcardHandler) {
+        routes.push({ method, path: `${prefix}/*` });
+      }
+    }
+  }
+};
+
+// src/utils/Logger.ts
+var LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  silent: 4
+};
+var COLORS = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m"};
+var METHOD_COLORS = {
+  GET: COLORS.green,
+  POST: COLORS.blue,
+  PUT: COLORS.yellow,
+  DELETE: COLORS.red,
+  PATCH: COLORS.magenta,
+  HEAD: COLORS.cyan,
+  OPTIONS: COLORS.gray
+};
+function statusColor(code) {
+  if (code < 200) return COLORS.gray;
+  if (code < 300) return COLORS.green;
+  if (code < 400) return COLORS.cyan;
+  if (code < 500) return COLORS.yellow;
+  return COLORS.red;
+}
+function formatDuration(ns) {
+  const us = Number(ns) / 1e3;
+  if (us < 1e3) return `${us.toFixed(0)}\xB5s`;
+  const ms = us / 1e3;
+  if (ms < 1e3) return `${ms.toFixed(1)}ms`;
+  return `${(ms / 1e3).toFixed(2)}s`;
+}
+var Logger = class {
+  level;
+  useColors;
+  showTimestamp;
+  prefix;
+  constructor(options = {}) {
+    this.level = options.level ?? "info";
+    this.useColors = options.colors ?? process.stdout.isTTY !== false;
+    this.showTimestamp = options.timestamp ?? true;
+    this.prefix = options.prefix ?? "azura";
+  }
+  shouldLog(level) {
+    return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[this.level];
+  }
+  timestamp() {
+    if (!this.showTimestamp) return "";
+    const now = /* @__PURE__ */ new Date();
+    return `${COLORS.gray}${now.toISOString().slice(11, 23)}${COLORS.reset} `;
+  }
+  tag(level) {
+    if (!this.useColors) return `[${level.toUpperCase()}]`;
+    const colorMap = {
+      debug: COLORS.gray,
+      info: COLORS.blue,
+      warn: COLORS.yellow,
+      error: COLORS.red
+    };
+    return `${colorMap[level] ?? ""}[${level.toUpperCase()}]${COLORS.reset}`;
+  }
+  debug(message, ...args) {
+    if (!this.shouldLog("debug")) return;
+    console.debug(`${this.timestamp()}${this.tag("debug")} ${message}`, ...args);
+  }
+  info(message, ...args) {
+    if (!this.shouldLog("info")) return;
+    console.info(`${this.timestamp()}${this.tag("info")} ${message}`, ...args);
+  }
+  warn(message, ...args) {
+    if (!this.shouldLog("warn")) return;
+    console.warn(`${this.timestamp()}${this.tag("warn")} ${message}`, ...args);
+  }
+  error(message, ...args) {
+    if (!this.shouldLog("error")) return;
+    console.error(`${this.timestamp()}${this.tag("error")} ${message}`, ...args);
+  }
+  request(method, path, statusCode, duration) {
+    if (!this.shouldLog("info")) return;
+    const mc = this.useColors ? METHOD_COLORS[method] ?? COLORS.white : "";
+    const sc = this.useColors ? statusColor(statusCode) : "";
+    const r = this.useColors ? COLORS.reset : "";
+    const dur = formatDuration(duration);
+    console.info(
+      `${this.timestamp()}${mc}${method.padEnd(7)}${r} ${path} ${sc}${statusCode}${r} ${COLORS.dim}${dur}${r}`
+    );
+  }
+  banner(port, host) {
+    if (!this.shouldLog("info")) return;
+    const c = this.useColors;
+    const lines = [
+      "",
+      `${c ? COLORS.bold + COLORS.cyan : ""}  \u26A1 AzuraJS v3.0.0${c ? COLORS.reset : ""}`,
+      "",
+      `${c ? COLORS.green : ""}  \u279C Local:   ${c ? COLORS.bold : ""}http://${host}:${port}/${c ? COLORS.reset : ""}`,
+      `${c ? COLORS.dim : ""}  \u279C Press Ctrl+C to stop${c ? COLORS.reset : ""}`,
+      ""
+    ];
+    console.info(lines.join("\n"));
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+};
+new Logger();
+
+// src/types/http/status.ts
+var HttpStatusText = {
+  200: "OK",
+  201: "Created",
+  202: "Accepted",
+  204: "No Content",
+  301: "Moved Permanently",
+  302: "Found",
+  304: "Not Modified",
+  400: "Bad Request",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  409: "Conflict",
+  410: "Gone",
+  422: "Unprocessable Entity",
+  429: "Too Many Requests",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout"
+};
+
+// src/utils/HttpError.ts
+var HttpError = class _HttpError extends Error {
+  statusCode;
+  details;
+  isOperational;
+  constructor(statusCode, message, details) {
+    super(message ?? HttpStatusText[statusCode] ?? "Unknown Error");
+    this.statusCode = statusCode;
+    this.details = details;
+    this.isOperational = true;
+    Object.setPrototypeOf(this, _HttpError.prototype);
+  }
+  toJSON() {
+    const obj = {
+      error: {
+        statusCode: this.statusCode,
+        message: this.message
+      }
+    };
+    if (this.details) obj.error.details = this.details;
+    return obj;
+  }
+  static badRequest(message, details) {
+    return new _HttpError(400, message ?? "Bad Request", details);
+  }
+  static unauthorized(message) {
+    return new _HttpError(401, message ?? "Unauthorized");
+  }
+  static forbidden(message) {
+    return new _HttpError(403, message ?? "Forbidden");
+  }
+  static notFound(message) {
+    return new _HttpError(404, message ?? "Not Found");
+  }
+  static methodNotAllowed(message) {
+    return new _HttpError(405, message ?? "Method Not Allowed");
+  }
+  static conflict(message, details) {
+    return new _HttpError(409, message ?? "Conflict", details);
+  }
+  static unprocessableEntity(message, details) {
+    return new _HttpError(422, message ?? "Unprocessable Entity", details);
+  }
+  static tooManyRequests(message) {
+    return new _HttpError(429, message ?? "Too Many Requests");
+  }
+  static internal(message) {
+    return new _HttpError(500, message ?? "Internal Server Error");
+  }
+};
+
+// src/utils/Parser.ts
+function parseQueryString(qs) {
+  const result = /* @__PURE__ */ Object.create(null);
+  if (!qs || qs.length === 0) return result;
+  let key = "";
+  let value = "";
+  let startingKey = true;
+  let i = qs.charCodeAt(0) === 63 ? 1 : 0;
+  for (; i < qs.length; i++) {
+    const ch = qs.charCodeAt(i);
+    if (ch === 61 && startingKey) {
+      startingKey = false;
+      continue;
+    }
+    if (ch === 38) {
+      if (key.length > 0) {
+        const decodedKey = fastDecode(key);
+        const decodedVal = fastDecode(value);
+        const existing = result[decodedKey];
+        if (existing === void 0) {
+          result[decodedKey] = decodedVal;
+        } else if (typeof existing === "string") {
+          result[decodedKey] = [existing, decodedVal];
+        } else {
+          existing.push(decodedVal);
+        }
+      }
+      key = "";
+      value = "";
+      startingKey = true;
+      continue;
+    }
+    if (startingKey) {
+      key += qs[i];
+    } else {
+      value += qs[i];
+    }
+  }
+  if (key.length > 0) {
+    const decodedKey = fastDecode(key);
+    const decodedVal = fastDecode(value);
+    const existing = result[decodedKey];
+    if (existing === void 0) {
+      result[decodedKey] = decodedVal;
+    } else if (typeof existing === "string") {
+      result[decodedKey] = [existing, decodedVal];
+    } else {
+      existing.push(decodedVal);
+    }
+  }
+  return result;
+}
+function fastDecode(str) {
+  if (str.indexOf("%") === -1 && str.indexOf("+") === -1) return str;
+  try {
+    return decodeURIComponent(str.replace(/\+/g, " "));
+  } catch {
+    return str;
+  }
+}
+function parseCookies(header) {
+  const cookies = /* @__PURE__ */ Object.create(null);
+  if (!header) return cookies;
+  let i = 0;
+  const len = header.length;
+  while (i < len) {
+    while (i < len && header.charCodeAt(i) === 32) i++;
+    let eqIdx = -1;
+    let semiIdx = -1;
+    for (let j = i; j < len; j++) {
+      const ch = header.charCodeAt(j);
+      if (ch === 61 && eqIdx === -1) eqIdx = j;
+      if (ch === 59) {
+        semiIdx = j;
+        break;
+      }
+    }
+    if (eqIdx === -1) {
+      i = semiIdx === -1 ? len : semiIdx + 1;
+      continue;
+    }
+    const end = semiIdx === -1 ? len : semiIdx;
+    const name = header.slice(i, eqIdx).trim();
+    let val = header.slice(eqIdx + 1, end).trim();
+    if (val.charCodeAt(0) === 34 && val.charCodeAt(val.length - 1) === 34) {
+      val = val.slice(1, -1);
+    }
+    if (cookies[name] === void 0) {
+      cookies[name] = fastDecode(val);
+    }
+    i = end + 1;
+  }
+  return cookies;
+}
+var CONTENT_TYPE_JSON = "application/json";
+var CONTENT_TYPE_FORM = "application/x-www-form-urlencoded";
+async function parseBody(req) {
+  const contentType = req.headers["content-type"] ?? "";
+  const contentLength = req.headers["content-length"];
+  if (req.method === "GET" || req.method === "HEAD" || req.method === "OPTIONS" || contentLength !== void 0 && contentLength === "0") {
+    return void 0;
+  }
+  const chunks = [];
+  let totalSize = 0;
+  const maxSize = 10 * 1024 * 1024;
+  return new Promise((resolve, reject) => {
+    req.on("data", (chunk) => {
+      totalSize += chunk.length;
+      if (totalSize > maxSize) {
+        req.destroy();
+        reject(new Error("Request body too large"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      if (chunks.length === 0) {
+        resolve(void 0);
+        return;
+      }
+      const raw = Buffer.concat(chunks).toString("utf-8");
+      if (contentType.startsWith(CONTENT_TYPE_JSON)) {
+        try {
+          resolve(JSON.parse(raw));
+        } catch {
+          resolve(raw);
+        }
+      } else if (contentType.startsWith(CONTENT_TYPE_FORM)) {
+        resolve(parseQueryString(raw));
+      } else {
+        resolve(raw);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function parseUrl(url) {
+  let pathname = "";
+  let search = "";
+  let i = 0;
+  for (; i < url.length; i++) {
+    if (url.charCodeAt(i) === 63) {
+      pathname = url.slice(0, i);
+      search = url.slice(i);
+      return { pathname, search };
+    }
+  }
+  return { pathname: url, search: "" };
+}
+
+// src/utils/IpResolver.ts
+var PROXY_HEADERS = [
+  "x-forwarded-for",
+  "x-real-ip",
+  "cf-connecting-ip",
+  "x-client-ip",
+  "x-cluster-client-ip",
+  "fastly-client-ip",
+  "true-client-ip"
+];
+function resolveIp(req) {
+  for (const header of PROXY_HEADERS) {
+    const val = req.headers[header];
+    if (val) {
+      const ip = typeof val === "string" ? val.split(",")[0].trim() : val[0];
+      if (ip && ip.length > 0) return normalizeIp(ip);
+    }
+  }
+  const remoteAddr = req.socket?.remoteAddress ?? "127.0.0.1";
+  return normalizeIp(remoteAddr);
+}
+function normalizeIp(ip) {
+  if (ip === "::1" || ip === "::ffff:127.0.0.1") return "127.0.0.1";
+  if (ip.startsWith("::ffff:")) return ip.slice(7);
+  return ip;
+}
+
+// src/utils/cookies/CookieManager.ts
+function serializeCookie(name, value, options = {}) {
+  let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+  if (options.maxAge != null) {
+    cookie += `; Max-Age=${Math.floor(options.maxAge)}`;
+  }
+  if (options.expires) {
+    cookie += `; Expires=${options.expires.toUTCString()}`;
+  }
+  if (options.domain) {
+    cookie += `; Domain=${options.domain}`;
+  }
+  cookie += `; Path=${options.path ?? "/"}`;
+  if (options.secure) {
+    cookie += "; Secure";
+  }
+  if (options.httpOnly !== false) {
+    cookie += "; HttpOnly";
+  }
+  if (options.sameSite) {
+    cookie += `; SameSite=${options.sameSite}`;
+  }
+  return cookie;
+}
+function clearCookieHeader(name, options = {}) {
+  return serializeCookie(name, "", {
+    ...options,
+    maxAge: 0,
+    expires: /* @__PURE__ */ new Date(0)
+  });
+}
+
+// src/core/server.ts
+var CONTROLLER_META_KEY = "azura:controller";
+var ROUTES_META_KEY = "azura:routes";
+var PARAMS_META_KEY = "azura:params";
+var AzuraServer = class {
+  server = null;
+  router;
+  logger;
+  middlewares = [];
+  plugins = [];
+  errorHandler = null;
+  config;
+  compiledChain = null;
+  constructor(config = {}) {
+    this.config = {
+      environment: config.environment ?? process.env.NODE_ENV ?? "development",
+      server: {
+        port: config.server?.port ?? 3e3,
+        host: config.server?.host ?? "0.0.0.0",
+        keepAliveTimeout: config.server?.keepAliveTimeout ?? 72e3,
+        headersTimeout: config.server?.headersTimeout ?? 75e3,
+        requestTimeout: config.server?.requestTimeout ?? 3e4,
+        ...config.server
+      },
+      logging: {
+        enabled: config.logging?.enabled ?? true,
+        level: config.logging?.level ?? "info",
+        timestamp: config.logging?.timestamp ?? true,
+        colors: config.logging?.colors ?? true,
+        requestLogging: config.logging?.requestLogging ?? true,
+        ...config.logging
+      },
+      plugins: config.plugins ?? {},
+      debug: config.debug ?? false
+    };
+    this.router = new Router();
+    this.logger = new Logger({
+      level: this.config.logging?.enabled === false ? "silent" : this.config.logging?.level,
+      colors: this.config.logging?.colors,
+      timestamp: this.config.logging?.timestamp
+    });
+  }
+  use(handler) {
+    this.compiledChain = null;
+    if (handler.length <= 2) {
+      this.plugins.push(handler);
+    } else {
+      this.middlewares.push(handler);
+    }
+    return this;
+  }
+  plugin(handler) {
+    this.compiledChain = null;
+    this.plugins.push(handler);
+    return this;
+  }
+  onError(handler) {
+    this.errorHandler = handler;
+    return this;
+  }
+  get(path, ...handlers) {
+    return this.route("GET", path, handlers);
+  }
+  post(path, ...handlers) {
+    return this.route("POST", path, handlers);
+  }
+  put(path, ...handlers) {
+    return this.route("PUT", path, handlers);
+  }
+  delete(path, ...handlers) {
+    return this.route("DELETE", path, handlers);
+  }
+  patch(path, ...handlers) {
+    return this.route("PATCH", path, handlers);
+  }
+  head(path, ...handlers) {
+    return this.route("HEAD", path, handlers);
+  }
+  options(path, ...handlers) {
+    return this.route("OPTIONS", path, handlers);
+  }
+  all(path, ...handlers) {
+    const methods = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
+    for (const method of methods) {
+      this.route(method, path, handlers);
+    }
+    return this;
+  }
+  route(method, path, handlers) {
+    const routeHandler = handlers[handlers.length - 1];
+    const middlewares = handlers.slice(0, -1);
+    this.router.add(method, path, routeHandler, middlewares);
+    return this;
+  }
+  register(...controllers) {
+    for (const Controller of controllers) {
+      this.registerController(Controller);
+    }
+    return this;
+  }
+  registerController(Controller) {
+    const instance = new Controller();
+    const prefix = Reflect.getMetadata?.(CONTROLLER_META_KEY, Controller) ?? "";
+    const controllerMiddlewares = Reflect.getMetadata?.("azura:middlewares", Controller) ?? [];
+    const prototype = Controller.prototype;
+    const propertyNames = Object.getOwnPropertyNames(prototype).filter(
+      (p) => p !== "constructor"
+    );
+    for (const propertyKey of propertyNames) {
+      const routeMeta = Reflect.getMetadata?.(
+        ROUTES_META_KEY,
+        prototype,
+        propertyKey
+      );
+      if (!routeMeta) continue;
+      const fullPath = this.joinPaths(prefix, routeMeta.path);
+      const paramsMeta = Reflect.getMetadata?.(PARAMS_META_KEY, prototype, propertyKey) ?? [];
+      const routeMiddlewares = Reflect.getMetadata?.("azura:middlewares", prototype, propertyKey) ?? [];
+      const allMiddlewares = [...controllerMiddlewares, ...routeMiddlewares];
+      const handler = async (req, res) => {
+        const args = this.resolveParams(paramsMeta, req, res);
+        const result = await instance[propertyKey](...args);
+        if (result !== void 0 && !res.sent) {
+          if (typeof result === "object") {
+            res.json(result);
+          } else {
+            res.send(String(result));
+          }
+        }
+      };
+      this.router.add(routeMeta.method, fullPath, handler, allMiddlewares, routeMeta.meta);
+    }
+  }
+  resolveParams(paramsMeta, req, res) {
+    if (!paramsMeta || paramsMeta.length === 0) return [req, res];
+    const sorted = [...paramsMeta].sort((a, b) => a.index - b.index);
+    const args = new Array(sorted.length);
+    for (const meta of sorted) {
+      let value;
+      switch (meta.type) {
+        case "body":
+          value = meta.name ? req.body?.[meta.name] : req.body;
+          break;
+        case "query":
+          value = meta.name ? req.query[meta.name] : req.query;
+          break;
+        case "param":
+          value = meta.name ? req.params[meta.name] : req.params;
+          break;
+        case "header":
+          value = meta.name ? req.headers[meta.name.toLowerCase()] : req.headers;
+          break;
+        case "cookie":
+          value = meta.name ? req.cookies[meta.name] : req.cookies;
+          break;
+        case "req":
+          value = req;
+          break;
+        case "res":
+          value = res;
+          break;
+        case "next":
+          value = () => {
+          };
+          break;
+        case "ip":
+          value = req.ip;
+          break;
+        case "session":
+          value = req.session;
+          break;
+        default:
+          value = void 0;
+      }
+      if (meta.pipes) {
+        for (const pipe of meta.pipes) {
+          value = pipe(value);
+        }
+      }
+      args[meta.index] = value;
+    }
+    return args;
+  }
+  joinPaths(prefix, path) {
+    const p = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+    const s = path.startsWith("/") ? path : `/${path}`;
+    return `${p}${s}`;
+  }
+  extendRequest(req, pathname, query) {
+    const azReq = req;
+    azReq.pathname = pathname;
+    azReq.query = query;
+    azReq.params = {};
+    azReq.cookies = parseCookies(req.headers.cookie);
+    azReq.ip = resolveIp(req);
+    azReq.protocol = req.socket.encrypted ? "https" : "http";
+    azReq.secure = azReq.protocol === "https";
+    azReq.hostname = (req.headers.host ?? "localhost").split(":")[0];
+    azReq.startTime = process.hrtime.bigint();
+    azReq.raw = req;
+    return azReq;
+  }
+  extendResponse(res) {
+    const azRes = res;
+    azRes.locals = {};
+    azRes.sent = false;
+    azRes.status = function(code) {
+      this.statusCode = code;
+      return this;
+    };
+    azRes.json = function(data) {
+      if (this.sent) return;
+      this.sent = true;
+      const body = JSON.stringify(data);
+      this.setHeader("Content-Type", "application/json; charset=utf-8");
+      this.setHeader("Content-Length", Buffer.byteLength(body));
+      this.end(body);
+    };
+    azRes.send = function(body) {
+      if (this.sent) return;
+      this.sent = true;
+      if (!this.getHeader("Content-Type")) {
+        this.setHeader("Content-Type", typeof body === "string" ? "text/plain; charset=utf-8" : "application/octet-stream");
+      }
+      const buf = typeof body === "string" ? Buffer.from(body) : body;
+      this.setHeader("Content-Length", buf.length);
+      this.end(buf);
+    };
+    azRes.html = function(body) {
+      if (this.sent) return;
+      this.sent = true;
+      this.setHeader("Content-Type", "text/html; charset=utf-8");
+      this.setHeader("Content-Length", Buffer.byteLength(body));
+      this.end(body);
+    };
+    azRes.redirect = function(url, code = 302) {
+      if (this.sent) return;
+      this.sent = true;
+      this.statusCode = code;
+      this.setHeader("Location", url);
+      this.end();
+    };
+    azRes.cookie = function(name, value, options) {
+      const header = serializeCookie(name, value, options);
+      const existing = this.getHeader("Set-Cookie");
+      if (existing) {
+        const arr = Array.isArray(existing) ? existing : [String(existing)];
+        arr.push(header);
+        this.setHeader("Set-Cookie", arr);
+      } else {
+        this.setHeader("Set-Cookie", header);
+      }
+      return this;
+    };
+    azRes.clearCookie = function(name, options) {
+      const header = clearCookieHeader(name, options);
+      const existing = this.getHeader("Set-Cookie");
+      if (existing) {
+        const arr = Array.isArray(existing) ? existing : [String(existing)];
+        arr.push(header);
+        this.setHeader("Set-Cookie", arr);
+      } else {
+        this.setHeader("Set-Cookie", header);
+      }
+      return this;
+    };
+    azRes.header = function(name, value) {
+      this.setHeader(name, value);
+      return this;
+    };
+    azRes.type = function(contentType) {
+      this.setHeader("Content-Type", contentType);
+      return this;
+    };
+    azRes.attachment = function(filename) {
+      if (filename) {
+        this.setHeader("Content-Disposition", `attachment; filename="${filename}"`);
+      } else {
+        this.setHeader("Content-Disposition", "attachment");
+      }
+      return this;
+    };
+    azRes.download = function(_path, _filename) {
+    };
+    return azRes;
+  }
+  compileMiddlewareChain() {
+    if (this.compiledChain) return this.compiledChain;
+    const self = this;
+    const globalMiddlewares = [...this.middlewares];
+    this.compiledChain = async (req, res) => {
+      for (const plugin of self.plugins) {
+        if (res.sent) return;
+        await new Promise((resolve, reject) => {
+          try {
+            const result = plugin({ req, res }, (err) => {
+              if (err) reject(err);
+              else resolve();
+            });
+            if (result && typeof result.then === "function") {
+              result.then(resolve, reject);
+            }
+          } catch (e) {
+            reject(e);
+          }
+        });
+      }
+      if (res.sent) return;
+      let idx = 0;
+      const runMiddleware = async () => {
+        if (idx >= globalMiddlewares.length || res.sent) return;
+        const mw = globalMiddlewares[idx++];
+        await new Promise((resolve, reject) => {
+          try {
+            const result = mw(req, res, (err) => {
+              if (err) reject(err);
+              else resolve();
+            });
+            if (result && typeof result.then === "function") {
+              result.then(resolve, reject);
+            }
+          } catch (e) {
+            reject(e);
+          }
+        });
+        await runMiddleware();
+      };
+      await runMiddleware();
+    };
+    return this.compiledChain;
+  }
+  async handleRequest(req, res) {
+    const { pathname, search } = parseUrl(req.url ?? "/");
+    const query = parseQueryString(search);
+    const azReq = this.extendRequest(req, pathname, query);
+    const azRes = this.extendResponse(res);
+    try {
+      const chain = this.compileMiddlewareChain();
+      await chain(azReq, azRes);
+      if (azRes.sent) return;
+      const method = (req.method ?? "GET").toUpperCase();
+      const match = this.router.find(method, pathname);
+      if (!match) {
+        if (pathname === "/favicon.ico") {
+          azRes.status(204).send("");
+          return;
+        }
+        throw HttpError.notFound(`Route ${method} ${pathname} not found`);
+      }
+      azReq.params = match.params;
+      if (method !== "GET" && method !== "HEAD" && method !== "OPTIONS") {
+        azReq.body = await parseBody(req);
+      }
+      for (const mw of match.middlewares) {
+        if (azRes.sent) return;
+        await new Promise((resolve, reject) => {
+          try {
+            const result2 = mw(azReq, azRes, (err) => {
+              if (err) reject(err);
+              else resolve();
+            });
+            if (result2 && typeof result2.then === "function") {
+              result2.then(resolve, reject);
+            }
+          } catch (e) {
+            reject(e);
+          }
+        });
+      }
+      if (azRes.sent) return;
+      const result = await match.handler(azReq, azRes);
+      if (result !== void 0 && !azRes.sent) {
+        if (typeof result === "object" && result !== null) {
+          azRes.json(result);
+        } else {
+          azRes.send(String(result));
+        }
+      }
+    } catch (err) {
+      this.handleError(err, azReq, azRes);
+    } finally {
+      if (this.config.logging?.requestLogging) {
+        const duration = process.hrtime.bigint() - azReq.startTime;
+        this.logger.request(
+          req.method ?? "GET",
+          pathname,
+          res.statusCode,
+          duration
+        );
+      }
+    }
+  }
+  handleError(err, req, res) {
+    if (res.sent) return;
+    if (this.errorHandler) {
+      try {
+        this.errorHandler(err, req, res, () => {
+        });
+        return;
+      } catch (handlerErr) {
+        this.logger.error("Error handler threw:", handlerErr);
+      }
+    }
+    if (err instanceof HttpError) {
+      res.status(err.statusCode).json(err.toJSON());
+      return;
+    }
+    const statusCode = err?.statusCode ?? err?.status ?? 500;
+    const message = this.config.environment === "production" ? "Internal Server Error" : err?.message ?? "Internal Server Error";
+    this.logger.error(`Unhandled error: ${err?.message ?? err}`);
+    if (this.config.debug && err?.stack) {
+      this.logger.error(err.stack);
+    }
+    res.status(statusCode).json({
+      error: {
+        statusCode,
+        message,
+        ...this.config.debug ? { stack: err?.stack } : {}
+      }
+    });
+  }
+  async listen(port, callback) {
+    const serverPort = port ?? this.config.server?.port ?? 3e3;
+    const host = this.config.server?.host ?? "0.0.0.0";
+    const handler = (req, res) => {
+      this.handleRequest(req, res).catch((err) => {
+        this.logger.error("Fatal request error:", err);
+        if (!res.headersSent) {
+          res.statusCode = 500;
+          res.end('{"error":{"statusCode":500,"message":"Internal Server Error"}}');
+        }
+      });
+    };
+    if (this.config.server?.https) {
+      const httpsConfig = this.config.server.https;
+      this.server = createServer(
+        {
+          key: readFileSync(httpsConfig.key),
+          cert: readFileSync(httpsConfig.cert),
+          ...httpsConfig.ca ? { ca: readFileSync(httpsConfig.ca) } : {}
+        },
+        handler
+      );
+    } else {
+      this.server = createServer$1(handler);
+    }
+    if (this.config.server?.keepAliveTimeout) {
+      this.server.keepAliveTimeout = this.config.server.keepAliveTimeout;
+    }
+    if (this.config.server?.headersTimeout) {
+      this.server.headersTimeout = this.config.server.headersTimeout;
+    }
+    return new Promise((resolve) => {
+      this.server.listen(serverPort, host, () => {
+        this.logger.banner(serverPort, host);
+        callback?.();
+        resolve(this.server);
+      });
+    });
+  }
+  async close() {
+    return new Promise((resolve, reject) => {
+      if (!this.server) {
+        resolve();
+        return;
+      }
+      this.server.close((err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+  getRouter() {
+    return this.router;
+  }
+  getLogger() {
+    return this.logger;
+  }
+  getConfig() {
+    return this.config;
+  }
+  getRoutes() {
+    return this.router.getAllRoutes();
+  }
+};
+
+export { AzuraServer, Router };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map