azurajs 3.0.1 → 3.0.2

package/dist/utils/index.js

@@ -1,54 +1,555 @@
 'use strict';
 
-var chunkAOG6NYAM_js = require('../chunk-AOG6NYAM.js');
-var chunk3UFAWS2V_js = require('../chunk-3UFAWS2V.js');
-require('../chunk-7NSRIVZM.js');
-
-
-
-Object.defineProperty(exports, "DTOValidator", {
-  enumerable: true,
-  get: function () { return chunkAOG6NYAM_js.DTOValidator; }
-});
-Object.defineProperty(exports, "SchemaValidator", {
-  enumerable: true,
-  get: function () { return chunkAOG6NYAM_js.SchemaValidator; }
-});
-Object.defineProperty(exports, "HttpError", {
-  enumerable: true,
-  get: function () { return chunk3UFAWS2V_js.HttpError; }
-});
-Object.defineProperty(exports, "Logger", {
-  enumerable: true,
-  get: function () { return chunk3UFAWS2V_js.Logger; }
-});
-Object.defineProperty(exports, "clearCookieHeader", {
-  enumerable: true,
-  get: function () { return chunk3UFAWS2V_js.clearCookieHeader; }
-});
-Object.defineProperty(exports, "parseBody", {
-  enumerable: true,
-  get: function () { return chunk3UFAWS2V_js.parseBody; }
-});
-Object.defineProperty(exports, "parseCookies", {
-  enumerable: true,
-  get: function () { return chunk3UFAWS2V_js.parseCookies; }
-});
-Object.defineProperty(exports, "parseQueryString", {
-  enumerable: true,
-  get: function () { return chunk3UFAWS2V_js.parseQueryString; }
-});
-Object.defineProperty(exports, "parseUrl", {
-  enumerable: true,
-  get: function () { return chunk3UFAWS2V_js.parseUrl; }
-});
-Object.defineProperty(exports, "resolveIp", {
-  enumerable: true,
-  get: function () { return chunk3UFAWS2V_js.resolveIp; }
-});
-Object.defineProperty(exports, "serializeCookie", {
-  enumerable: true,
-  get: function () { return chunk3UFAWS2V_js.serializeCookie; }
-});
+// 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/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/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/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/utils/validators/DTOValidator.ts
+var DTOValidator = class {
+  static validate(data, schema) {
+    const errors = [];
+    if (data == null || typeof data !== "object") {
+      return {
+        valid: false,
+        errors: [{ field: "_root", message: "Request body must be an object" }]
+      };
+    }
+    for (const [field, rule] of Object.entries(schema)) {
+      const value = data[field];
+      if (rule.required && (value === void 0 || value === null || value === "")) {
+        errors.push({
+          field,
+          message: rule.message ?? `${field} is required`,
+          value
+        });
+        continue;
+      }
+      if (value === void 0 || value === null) continue;
+      if (rule.type) {
+        const actualType = Array.isArray(value) ? "array" : typeof value;
+        if (actualType !== rule.type) {
+          errors.push({
+            field,
+            message: rule.message ?? `${field} must be of type ${rule.type}`,
+            value
+          });
+          continue;
+        }
+      }
+      if (rule.type === "string" || typeof value === "string") {
+        if (rule.min !== void 0 && value.length < rule.min) {
+          errors.push({
+            field,
+            message: rule.message ?? `${field} must be at least ${rule.min} characters`,
+            value
+          });
+        }
+        if (rule.max !== void 0 && value.length > rule.max) {
+          errors.push({
+            field,
+            message: rule.message ?? `${field} must be at most ${rule.max} characters`,
+            value
+          });
+        }
+        if (rule.pattern && !rule.pattern.test(value)) {
+          errors.push({
+            field,
+            message: rule.message ?? `${field} has invalid format`,
+            value
+          });
+        }
+      }
+      if (rule.type === "number" || typeof value === "number") {
+        if (rule.min !== void 0 && value < rule.min) {
+          errors.push({
+            field,
+            message: rule.message ?? `${field} must be at least ${rule.min}`,
+            value
+          });
+        }
+        if (rule.max !== void 0 && value > rule.max) {
+          errors.push({
+            field,
+            message: rule.message ?? `${field} must be at most ${rule.max}`,
+            value
+          });
+        }
+      }
+      if (rule.type === "array" && Array.isArray(value)) {
+        if (rule.min !== void 0 && value.length < rule.min) {
+          errors.push({
+            field,
+            message: rule.message ?? `${field} must have at least ${rule.min} items`,
+            value
+          });
+        }
+        if (rule.max !== void 0 && value.length > rule.max) {
+          errors.push({
+            field,
+            message: rule.message ?? `${field} must have at most ${rule.max} items`,
+            value
+          });
+        }
+      }
+      if (rule.enum && !rule.enum.includes(value)) {
+        errors.push({
+          field,
+          message: rule.message ?? `${field} must be one of: ${rule.enum.join(", ")}`,
+          value
+        });
+      }
+      if (rule.custom) {
+        const customError = rule.custom(value);
+        if (customError) {
+          errors.push({ field, message: customError, value });
+        }
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      data: errors.length === 0 ? data : void 0
+    };
+  }
+};
+
+// src/utils/validators/SchemaValidator.ts
+var SchemaValidator = class {
+  static validate(data, schema) {
+    if (typeof schema.safeParse === "function") {
+      const result = schema.safeParse(data);
+      if (result.success) {
+        return { valid: true, data: result.data };
+      }
+      return { valid: false, errors: result.error };
+    }
+    if (typeof schema.parse === "function") {
+      try {
+        const parsed = schema.parse(data);
+        return { valid: true, data: parsed };
+      } catch (err) {
+        return { valid: false, errors: err };
+      }
+    }
+    if (typeof schema.validate === "function") {
+      const result = schema.validate(data);
+      if (result.error) {
+        return { valid: false, errors: result.error };
+      }
+      return { valid: true, data: result.value };
+    }
+    return { valid: true, data };
+  }
+};
+
+exports.DTOValidator = DTOValidator;
+exports.HttpError = HttpError;
+exports.Logger = Logger;
+exports.SchemaValidator = SchemaValidator;
+exports.clearCookieHeader = clearCookieHeader;
+exports.parseBody = parseBody;
+exports.parseCookies = parseCookies;
+exports.parseQueryString = parseQueryString;
+exports.parseUrl = parseUrl;
+exports.resolveIp = resolveIp;
+exports.serializeCookie = serializeCookie;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map