@arkyn/server 3.0.1-beta.154 → 3.0.1-beta.156

package/dist/index.js

@@ -1,37 +1,1301 @@
-// http
-export { BadGateway } from "./http/badResponses/badGateway";
-export { BadRequest } from "./http/badResponses/badRequest";
-export { Conflict } from "./http/badResponses/conflict";
-export { Forbidden } from "./http/badResponses/forbidden";
-export { NotFound } from "./http/badResponses/notFound";
-export { NotImplemented } from "./http/badResponses/notImplemented";
-export { ServerError } from "./http/badResponses/serverError";
-export { Unauthorized } from "./http/badResponses/unauthorized";
-export { UnprocessableEntity } from "./http/badResponses/unprocessableEntity";
-export { Created } from "./http/successResponses/created";
-export { Found } from "./http/successResponses/found";
-export { NoContent } from "./http/successResponses/noContent";
-export { Success } from "./http/successResponses/success";
-export { Updated } from "./http/successResponses/updated";
-// services
-export { ApiService } from "./services/apiService";
-export { DebugService } from "./services/debugService";
-export { LogService } from "./services/logService";
-// utilities
-export { decodeRequestBody } from "./utilities/decodeRequestBody";
-export { decodeRequestErrorMessage } from "./utilities/decodeRequestErrorMessage";
-export { errorHandler } from "./utilities/errorHandler";
-export { flushDebugLogs } from "./utilities/flushDebugLogs";
-export { formAsyncParse } from "./utilities/formAsyncParse";
-export { formParse } from "./utilities/formParse";
-export { getScopedParams } from "./utilities/getScopedParams";
-export { SchemaValidator } from "./utilities/schemaValidator";
-// validates
-export { validateCep } from "./validations/validateCep";
-export { validateCnpj } from "./validations/validateCnpj";
-export { validateCpf } from "./validations/validateCpf";
-export { validateDate } from "./validations/validateDate";
-export { validateEmail } from "./validations/validateEmail";
-export { validatePassword } from "./validations/validatePassword";
-export { validatePhone } from "./validations/validatePhone";
-export { validateRg } from "./validations/validateRg";
+var k = Object.defineProperty;
+var I = (e, s, t) => s in e ? k(e, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[s] = t;
+var c = (e, s, t) => I(e, typeof s != "symbol" ? s + "" : s, t);
+import { formatJsonString as U, formatJsonObject as q, removeNonNumeric as S, ValidateDateService as A } from "@arkyn/shared";
+import H from "node:path";
+import L from "node:dns";
+import { countries as F } from "@arkyn/templates";
+import { isValidPhoneNumber as z, parsePhoneNumberWithError as M } from "libphonenumber-js";
+class N {
+  /**
+   * Adds a file name to the ignore list so it is skipped when resolving the caller in stack traces.
+   *
+   * @param file - File name to ignore (e.g. `"httpAdapter.ts"`).
+   */
+  static setIgnoreFile(s) {
+    this.ignoreFiles.push(s);
+  }
+  /** Resets the ignore list, restoring full stack trace analysis. */
+  static clearIgnoreFiles() {
+    this.ignoreFiles = [];
+  }
+  /**
+   * Resolves the file path and function name of the code that triggered the current debug call,
+   * skipping internal node modules and any files registered with `setIgnoreFile`.
+   *
+   * @returns `{ functionName, callerInfo }` — caller function name and file path relative to `process.cwd()`.
+   */
+  static getCaller() {
+    const s = process.cwd(), r = (new Error().stack || "").split(`
+`).map((h) => h.trim());
+    let o = 2;
+    for (; o < r.length && (r[o].includes("node:internal") || r[o].includes("/node_modules/")); )
+      o++;
+    if (this.ignoreFiles.length > 0)
+      for (; o < r.length && this.ignoreFiles.some(
+        (h) => r[o].includes(h)
+      ); )
+        o++;
+    const a = r[o] || "";
+    let u = "Unknown function", i = "Unknown caller";
+    const l = a.match(/at\s+([^(\s]+)\s+\(([^)]+)\)/);
+    if (l)
+      u = l[1], i = l[2];
+    else {
+      const h = a.match(/at\s+(.+)/);
+      if (h) {
+        i = h[1];
+        const d = i.match(/at\s+([^(\s]+)\s+/);
+        d && d[1] !== "new" && (u = d[1]);
+      }
+    }
+    i.includes("(") && (i = i.substring(
+      i.indexOf("(") + 1,
+      i.lastIndexOf(")")
+    )), i = i.split(":").slice(0, -2).join(":");
+    try {
+      i = H.relative(s, i);
+    } catch {
+    }
+    return { functionName: u, callerInfo: i };
+  }
+}
+/**
+ * The name of the file to ignore when analyzing the stack trace.
+ * When set, the `getCaller` function will skip stack frames containing this file name.
+ */
+c(N, "ignoreFiles", []);
+function g(e) {
+  var t;
+  if (process.env.NODE_ENV === "development" || ((t = process.env) == null ? void 0 : t.DEBUG_MODE) === "true") {
+    const o = `${{
+      yellow: "\x1B[33m",
+      cyan: "\x1B[36m",
+      red: "\x1B[31m",
+      green: "\x1B[32m"
+    }[e.scheme]}[${e.name}]\x1B[0m`;
+    let a = `
+`;
+    e.debugs.forEach((u, i) => {
+      a += `${o} ${u.trim()}`, i < e.debugs.length - 1 && (a += `
+`);
+    }), console.log(a);
+  }
+}
+class f {
+  constructor() {
+    c(this, "_cause");
+    c(this, "_name", "BadResponse");
+    c(this, "_status", 500);
+    c(this, "_statusText", "Unknown error");
+    c(this, "_debugColor", "red");
+  }
+  get cause() {
+    return this._cause;
+  }
+  set cause(s) {
+    this._cause = s;
+  }
+  get name() {
+    return this._name;
+  }
+  set name(s) {
+    this._name = s;
+  }
+  get status() {
+    return this._status;
+  }
+  set status(s) {
+    this._status = s;
+  }
+  get statusText() {
+    return this._statusText;
+  }
+  set statusText(s) {
+    this._statusText = s;
+  }
+  get debugColor() {
+    return this._debugColor;
+  }
+  set debugColor(s) {
+    ["green", "yellow", "cyan", "red"].includes(s) && (this._debugColor = s);
+  }
+  onDebug() {
+    const s = [], { callerInfo: t, functionName: n } = N.getCaller();
+    s.push(`Caller Function: ${n}`), s.push(`Caller Location: ${t}`), this._statusText && s.push(`Message: ${this._statusText}`), this._cause && s.push(`Cause: ${U(JSON.stringify(this._cause))}`), g({ scheme: "red", name: this._name, debugs: s });
+  }
+  makeBody() {
+    return {
+      name: this._name,
+      message: this._statusText,
+      cause: this._cause
+    };
+  }
+}
+class V extends f {
+  /**
+   * @param message - Error description sent in the response body and logged for debugging.
+   * @param cause - Optional extra context (serialized to JSON in the response).
+   */
+  constructor(s, t) {
+    super(), this.name = "BadGateway", this.status = 502, this.statusText = s, this.cause = t ? JSON.stringify(t) : void 0, this.onDebug();
+  }
+  /** Converts to a `Response` with `Content-Type: application/json` header. */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.makeBody()), s);
+  }
+  /** Converts to a `Response` using `Response.json()`. Alternative to `toResponse()`. */
+  toJson() {
+    const s = {
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.makeBody(), s);
+  }
+}
+class T extends f {
+  /**
+   * @param message - Error description.
+   * @param cause - Optional extra context (serialized to JSON).
+   */
+  constructor(s, t) {
+    super(), this.name = "BadRequest", this.status = 400, this.statusText = s, this.cause = t ? JSON.stringify(t) : void 0, this.onDebug();
+  }
+  /** Converts to a `Response` with `Content-Type: application/json` header. */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.makeBody()), s);
+  }
+  /** Converts to a `Response` using `Response.json()`. Alternative to `toResponse()`. */
+  toJson() {
+    const s = {
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.makeBody(), s);
+  }
+}
+class Z extends f {
+  /**
+   * @param message - Error description.
+   * @param cause - Optional extra context (serialized to JSON).
+   */
+  constructor(s, t) {
+    super(), this.name = "Conflict", this.status = 409, this.statusText = s, this.debugColor = "yellow", this.cause = t ? JSON.stringify(t) : void 0, this.onDebug();
+  }
+  /** Converts to a `Response` with `Content-Type: application/json` header. */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.makeBody()), s);
+  }
+  /** Converts to a `Response` using `Response.json()`. Alternative to `toResponse()`. */
+  toJson() {
+    const s = {
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.makeBody(), s);
+  }
+}
+class G extends f {
+  /**
+   * @param message - Error description.
+   * @param cause - Optional extra context (serialized to JSON).
+   */
+  constructor(s, t) {
+    super(), this.name = "Forbidden", this.status = 403, this.statusText = s, this.cause = t ? JSON.stringify(t) : void 0, this.onDebug();
+  }
+  /** Converts to a `Response` with `Content-Type: application/json` header. */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.makeBody()), s);
+  }
+  /** Converts to a `Response` using `Response.json()`. Alternative to `toResponse()`. */
+  toJson() {
+    const s = {
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.makeBody(), s);
+  }
+}
+class W extends f {
+  /**
+   * @param message - Error description.
+   * @param cause - Optional extra context (serialized to JSON).
+   */
+  constructor(s, t) {
+    super(), this.name = "NotFound", this.status = 404, this.statusText = s, this.cause = t ? JSON.stringify(t) : void 0, this.onDebug();
+  }
+  /** Converts to a `Response` with `Content-Type: application/json` header. */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.makeBody()), s);
+  }
+  /** Converts to a `Response` using `Response.json()`. Alternative to `toResponse()`. */
+  toJson() {
+    const s = {
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.makeBody(), s);
+  }
+}
+class Y extends f {
+  /**
+   * @param message - Error description.
+   * @param cause - Optional extra context (serialized to JSON).
+   */
+  constructor(s, t) {
+    super(), this.name = "NotImplemented", this.status = 501, this.statusText = s, this.cause = t ? JSON.stringify(t) : void 0, this.onDebug();
+  }
+  /** Converts to a `Response` with `Content-Type: application/json` header. */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.makeBody()), s);
+  }
+  /** Converts to a `Response` using `Response.json()`. Alternative to `toResponse()`. */
+  toJson() {
+    const s = {
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.makeBody(), s);
+  }
+}
+class x extends f {
+  /**
+   * @param message - Error description.
+   * @param cause - Optional extra context (serialized to JSON).
+   */
+  constructor(s, t) {
+    super(), this.name = "ServerError", this.status = 500, this.statusText = s, this.cause = t ? JSON.stringify(t) : void 0, this.onDebug();
+  }
+  /** Converts to a `Response` with `Content-Type: application/json` header. */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.makeBody()), s);
+  }
+  /** Converts to a `Response` using `Response.json()`. Alternative to `toResponse()`. */
+  toJson() {
+    const s = {
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.makeBody(), s);
+  }
+}
+class K extends f {
+  /**
+   * @param message - Error description.
+   * @param cause - Optional extra context (serialized to JSON).
+   */
+  constructor(s, t) {
+    super(), this.name = "Unauthorized", this.status = 401, this.statusText = s, this.debugColor = "yellow", this.cause = t ? JSON.stringify(t) : void 0, this.onDebug();
+  }
+  /** Converts to a `Response` with `Content-Type: application/json` header. */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.makeBody()), s);
+  }
+  /** Converts to a `Response` using `Response.json()`. Alternative to `toResponse()`. */
+  toJson() {
+    const s = {
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.makeBody(), s);
+  }
+}
+class R extends f {
+  /**
+   * @param props.message - Human-readable description of the error.
+   * @param props.fieldErrors - Per-field validation messages keyed by field name.
+   * @param props.fields - Original submitted field values (useful for repopulating forms).
+   * @param props.data - Any extra data to include in the response body.
+   */
+  constructor(s) {
+    super(), this.name = "UnprocessableEntity", this.status = 422, this.statusText = s.message || "Unprocessable entity", this.debugColor = "yellow", this.cause = {
+      data: s.data,
+      fieldErrors: s.fieldErrors,
+      fields: s.fields
+    }, this.onDebug();
+  }
+  /** Converts to a `Response` with `Content-Type: application/json` header. */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.makeBody()), s);
+  }
+  /** Converts to a `Response` using `Response.json()`. Alternative to `toResponse()`. */
+  toJson() {
+    const s = {
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.makeBody(), s);
+  }
+}
+class y {
+  constructor() {
+    c(this, "_body", null);
+    c(this, "_name", "SuccessResponse");
+    c(this, "_status", 200);
+    c(this, "_statusText", "OK");
+    c(this, "_debugColor", "green");
+  }
+  get body() {
+    return this._body;
+  }
+  set body(s) {
+    this._body = s ?? null;
+  }
+  get name() {
+    return this._name;
+  }
+  set name(s) {
+    this._name = s;
+  }
+  get status() {
+    return this._status;
+  }
+  set status(s) {
+    this._status = s;
+  }
+  get statusText() {
+    return this._statusText;
+  }
+  set statusText(s) {
+    this._statusText = s;
+  }
+  get debugColor() {
+    return this._debugColor;
+  }
+  set debugColor(s) {
+    ["green", "yellow", "cyan", "red"].includes(s) && (this._debugColor = s);
+  }
+  /**
+   * Logs debug information for success responses including caller context and response details.
+   *
+   * @param {any} body - The response body or success data to be logged
+   *
+   * @example
+   * ```typescript
+   * const SuccessResponse = new SuccessResponse();
+   * SuccessResponse.onDebug({ data: "Operation completed successfully" });
+   * ```
+   */
+  onDebug(s) {
+    const t = [], { callerInfo: n, functionName: r } = N.getCaller();
+    t.push(`Caller Function: ${r}`), t.push(`Caller Location: ${n}`), this.statusText && t.push(`Message: ${this.statusText}`), s && t.push(`Body: ${JSON.stringify(s)}`), g({ scheme: this._debugColor, name: this.name, debugs: t });
+  }
+  makeBody() {
+    return {
+      name: this.name,
+      message: this.statusText,
+      body: this.body
+    };
+  }
+}
+class Q extends y {
+  /**
+   * @param message - Description included in the response status text.
+   * @param body - Data to include in the response body.
+   */
+  constructor(s, t) {
+    super(), this.name = "Created", this.status = 201, this.statusText = s, this.body = t || void 0, this.onDebug();
+  }
+  /** Converts to a `Response` with `Content-Type: application/json` header. */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.body), s);
+  }
+  /** Converts to a `Response` using `Response.json()`. Alternative to `toResponse()`. */
+  toJson() {
+    const s = {
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.body, s);
+  }
+}
+class X extends y {
+  /**
+   * @param message - Description included in the response status text.
+   * @param body - Data to include in the response body.
+   */
+  constructor(s, t) {
+    super(), this.name = "Found", this.status = 302, this.statusText = s, this.body = t || void 0, this.onDebug();
+  }
+  /** Converts to a `Response` with `Content-Type: application/json` header. */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.body), s);
+  }
+  /** Converts to a `Response` using `Response.json()`. Alternative to `toResponse()`. */
+  toJson() {
+    const s = {
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.body, s);
+  }
+}
+class ss extends y {
+  /**
+   * @param message - Description included in the response status text.
+   */
+  constructor(s) {
+    super(), this.name = "NoContent", this.status = 204, this.statusText = s, this.onDebug();
+  }
+  /** Converts to a `Response` with `Content-Type: application/json` header and no body. */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(null, s);
+  }
+}
+class es extends y {
+  /**
+   * @param message - Description included in the response status text.
+   * @param body - Data to include in the response body.
+   */
+  constructor(s, t) {
+    super(), this.name = "Success", this.status = 200, this.statusText = s, this.body = t || void 0, this.onDebug();
+  }
+  /** Converts to a `Response` with `Content-Type: application/json` header. */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.body), s);
+  }
+  /** Converts to a `Response` using `Response.json()`. Alternative to `toResponse()`. */
+  toJson() {
+    const s = {
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.body, s);
+  }
+}
+class ts extends y {
+  /**
+   * @param message - Description included in the response status text.
+   * @param body - Data to include in the response body.
+   */
+  constructor(s, t) {
+    super(), this.name = "Updated", this.status = 200, this.statusText = s, this.body = t || void 0, this.onDebug();
+  }
+  /** Converts to a `Response` with `Content-Type: application/json` header. */
+  toResponse() {
+    const s = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText
+    };
+    return new Response(JSON.stringify(this.body), s);
+  }
+  /** Converts to a `Response` using `Response.json()`. Alternative to `toResponse()`. */
+  toJson() {
+    const s = {
+      status: this.status,
+      statusText: this.statusText
+    };
+    return Response.json(this.body, s);
+  }
+}
+class ns {
+  /**
+   * Converts various header formats into a plain key-value object.
+   *
+   * @param {HeadersInit} headers - The headers to map.
+   * @returns {Record<string, string>} A plain object with header key-value pairs.
+   * @private
+   */
+  static mapHeaders(s) {
+    return s instanceof Headers ? Object.fromEntries(s.entries()) : typeof s == "object" ? Object.entries(s).reduce(
+      (t, [n, r]) => (typeof r == "string" ? t[n] = r : Array.isArray(r) ? t[n] = r.join(", ") : t[n] = JSON.stringify(r), t),
+      {}
+    ) : {};
+  }
+  /**
+   * Converts URLSearchParams into a plain key-value object.
+   *
+   * @param {URLSearchParams} queryParams - The query parameters to map.
+   * @returns {Record<string, string>} A plain object with query parameter key-value pairs.
+   * @private
+   */
+  static mapQueryParams(s) {
+    const t = {};
+    return s.forEach((n, r) => t[r] = n), t;
+  }
+  /**
+   * Transforms raw HTTP request/response data into a standardized log output format.
+   *
+   * @param {InputProps} props - The input properties containing request/response data.
+   * @returns {OutputProps} The mapped output object ready for logging.
+   */
+  static handle(s) {
+    return {
+      rawUrl: s.rawUrl,
+      status: s.status,
+      method: s.method,
+      token: null,
+      elapsedTime: s.elapsedTime,
+      requestHeaders: this.mapHeaders(s.requestHeaders),
+      requestBody: s.requestBody || null,
+      queryParams: {
+        ...this.mapQueryParams(s.queryParams),
+        ...s.urlParams
+      },
+      responseHeaders: this.mapHeaders(s.responseHeaders),
+      responseBody: s.responseBody || null
+    };
+  }
+}
+class v {
+  /**
+   * Sets the log service configuration once. Subsequent calls are ignored.
+   *
+   * @param config.trafficSourceId - Traffic source identifier.
+   * @param config.userToken - User token for authentication.
+   * @param config.logBaseApiUrl - Override the default log ingestion base URL.
+   */
+  static setConfig(s) {
+    if (this.config) return;
+    const { trafficSourceId: t, userToken: n, logBaseApiUrl: r } = s, a = `${r || "http://62.238.8.44:8081"}/ingest-log`;
+    this.config = { trafficSourceId: t, userToken: n, apiUrl: a };
+  }
+  /** Returns the stored configuration, or `undefined` if `setConfig` has not been called. */
+  static getConfig() {
+    return this.config;
+  }
+  /**
+   * Resets the stored configuration, allowing a new initialization.
+   */
+  static resetConfig() {
+    this.config = void 0;
+  }
+}
+c(v, "config");
+async function rs(e) {
+  const s = v.getConfig();
+  if (!s) return;
+  const { userToken: t, apiUrl: n, trafficSourceId: r } = s, {
+    elapsedTime: o,
+    method: a,
+    queryParams: u,
+    requestBody: i,
+    requestHeaders: l,
+    responseBody: h,
+    responseHeaders: d,
+    status: P,
+    token: vs,
+    rawUrl: $
+  } = e;
+  if (process.env.NODE_ENV !== "development")
+    try {
+      const m = new URL($);
+      let D = "https";
+      m.protocol === "http:" && (D = "http");
+      const w = JSON.stringify({
+        domainUrl: m.protocol + "//" + m.host,
+        pathnameUrl: m.pathname,
+        trafficSourceId: r,
+        status: P,
+        protocol: D,
+        method: a.toLowerCase(),
+        trafficUserId: null,
+        elapsedTime: o,
+        requestHeaders: JSON.stringify(l),
+        requestBody: JSON.stringify(i),
+        queryParams: JSON.stringify(u),
+        responseHeaders: JSON.stringify(d),
+        responseBody: JSON.stringify(h)
+      }), C = {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${t}`
+      }, p = await fetch(n, {
+        method: "POST",
+        body: w,
+        headers: C
+      });
+      if (!p.ok) {
+        const j = await p.text(), B = p.status, J = p.statusText, E = await p.json().catch(() => null);
+        g({
+          name: "LogError",
+          scheme: "red",
+          debugs: [
+            "Failed to log request.",
+            `Status: ${B} ${J}.`,
+            `Status text: ${j}.`,
+            `JSON Response: ${E ? q(E, 0) : "No JSON response"}`
+          ]
+        });
+      }
+    } catch (m) {
+      g({
+        debugs: [`Error sending request: ${m}`],
+        name: "LogError",
+        scheme: "red"
+      });
+    }
+}
+async function b(e) {
+  let s = e.url;
+  e.urlParams && Object.entries(e.urlParams).forEach(([n, r]) => {
+    s = s.replaceAll(`:${n}`, r);
+  });
+  const t = {
+    POST: "Resource created successfully",
+    PUT: "Resource updated successfully",
+    DELETE: "Resource deleted successfully",
+    PATCH: "Resource patched successfully",
+    GET: "Request successful"
+  };
+  try {
+    const n = performance.now(), r = { ...e.headers, "Content-Type": "application/json" }, o = await fetch(s, {
+      headers: r,
+      method: e.method,
+      body: e.body ? JSON.stringify(e.body) : void 0
+    }), a = performance.now() - n, u = o.status;
+    let i = null;
+    try {
+      i = await o.json();
+    } catch {
+      i = null;
+    }
+    const l = ns.handle({
+      elapsedTime: a,
+      method: e.method,
+      queryParams: new URL(s).searchParams,
+      requestHeaders: r,
+      requestBody: e.body,
+      responseBody: i,
+      responseHeaders: o.headers,
+      status: u,
+      rawUrl: e.url,
+      urlParams: e.urlParams
+    });
+    return rs(l), o.ok ? {
+      success: !0,
+      status: u,
+      message: (i == null ? void 0 : i.message) || t[e.method],
+      response: i,
+      cause: null
+    } : {
+      success: !1,
+      status: u,
+      message: (i == null ? void 0 : i.message) || o.statusText || "Request failed",
+      response: i,
+      cause: null
+    };
+  } catch (n) {
+    return g({
+      debugs: [`Network error or request failed: ${n}`],
+      name: "MakeRequestError",
+      scheme: "red"
+    }), {
+      success: !1,
+      status: 0,
+      message: "Network error or request failed",
+      response: null,
+      cause: n instanceof Error ? n.message : String(n)
+    };
+  }
+}
+async function os(e) {
+  return b({
+    method: "DELETE",
+    url: e.url,
+    urlParams: e.urlParams,
+    headers: e.headers,
+    body: e.body
+  });
+}
+async function is(e) {
+  return b({
+    method: "GET",
+    url: e.url,
+    urlParams: e.urlParams,
+    headers: e.headers
+  });
+}
+async function as(e) {
+  return b({
+    method: "PATCH",
+    url: e.url,
+    urlParams: e.urlParams,
+    headers: e.headers,
+    body: e.body
+  });
+}
+async function us(e) {
+  return b({
+    method: "POST",
+    url: e.url,
+    urlParams: e.urlParams,
+    headers: e.headers,
+    body: e.body
+  });
+}
+async function cs(e) {
+  return b({
+    method: "PUT",
+    url: e.url,
+    urlParams: e.urlParams,
+    headers: e.headers,
+    body: e.body
+  });
+}
+class Js {
+  constructor(s) {
+    c(this, "baseUrl");
+    c(this, "baseHeaders");
+    c(this, "baseToken");
+    c(this, "enableDebug");
+    this.baseUrl = s.baseUrl, this.baseHeaders = s.baseHeaders || void 0, this.baseToken = s.baseToken || void 0, this.enableDebug = s.enableDebug || !1;
+  }
+  onDebug(s, t, n) {
+    if (this.enableDebug) {
+      const r = [], o = (a) => JSON.stringify(a, null, 2);
+      r.push(`Base URL: ${this.baseUrl}`), r.push(`Endpoint: ${s}`), r.push(`Status/Method: ${t} => ${n.status}`), r.push(`Message: ${n.message}`), n.headers && r.push(`Headers: ${o(n.headers)}`), n.body && r.push(`Body: ${o(n.body)}`), g({ debugs: r, name: "ApiDebug", scheme: "yellow" });
+    }
+  }
+  generateHeaders(s, t) {
+    let n = {};
+    return this.baseToken && (n = { Authorization: `Bearer ${this.baseToken}` }), this.baseHeaders && (n = { ...n, ...this.baseHeaders }), s && (n = { ...n, ...s }), t && (n = { ...n, Authorization: `Bearer ${t}` }), n;
+  }
+  /**
+   * Sends a get request to the specified endpoint.
+   * @param endpoint - The API endpoint to send the get request to.
+   * @param data - The request data, including optional headers and token.
+   * @returns The API response data.
+   */
+  async get(s, t) {
+    const n = this.generateHeaders((t == null ? void 0 : t.headers) || {}, t == null ? void 0 : t.token), r = await is({
+      url: this.baseUrl + s,
+      urlParams: (t == null ? void 0 : t.urlParams) || {},
+      headers: n
+    });
+    return this.onDebug(s, "get", {
+      headers: n,
+      message: r.message,
+      status: r.status
+    }), r;
+  }
+  /**
+   * Sends a post request to the specified endpoint.
+   * @param endpoint - The API endpoint to send the post request to.
+   * @param data - The request data, including body, optional headers, and token.
+   * @returns The API response data.
+   */
+  async post(s, t) {
+    const n = this.generateHeaders((t == null ? void 0 : t.headers) || {}, t == null ? void 0 : t.token), r = t == null ? void 0 : t.body, o = await us({
+      url: this.baseUrl + s,
+      urlParams: (t == null ? void 0 : t.urlParams) || {},
+      headers: n,
+      body: r
+    });
+    return this.onDebug(s, "post", {
+      headers: n,
+      body: r,
+      message: o.message,
+      status: o.status
+    }), o;
+  }
+  /**
+   * Sends a put request to the specified endpoint.
+   * @param endpoint - The API endpoint to send the put request to.
+   * @param data - The request data, including body, optional headers, and token.
+   * @returns The API response data.
+   */
+  async put(s, t) {
+    const n = this.generateHeaders((t == null ? void 0 : t.headers) || {}, t == null ? void 0 : t.token), r = t == null ? void 0 : t.body, o = await cs({
+      url: this.baseUrl + s,
+      urlParams: (t == null ? void 0 : t.urlParams) || {},
+      headers: n,
+      body: r
+    });
+    return this.onDebug(s, "put", {
+      headers: n,
+      body: r,
+      message: o.message,
+      status: o.status
+    }), o;
+  }
+  /**
+   * Sends a patch request to the specified endpoint.
+   * @param endpoint - The API endpoint to send the patch request to.
+   * @param data - The request data, including body, optional headers, and token.
+   * @returns The API response data.
+   */
+  async patch(s, t) {
+    const n = this.generateHeaders((t == null ? void 0 : t.headers) || {}, t == null ? void 0 : t.token), r = t == null ? void 0 : t.body, o = await as({
+      url: this.baseUrl + s,
+      urlParams: (t == null ? void 0 : t.urlParams) || {},
+      headers: n,
+      body: r
+    });
+    return this.onDebug(s, "patch", {
+      headers: n,
+      body: r,
+      message: o.message,
+      status: o.status
+    }), o;
+  }
+  /**
+   * Sends a delete request to the specified endpoint.
+   * @param endpoint - The API endpoint to send the delete request to.
+   * @param data - The request data, including body, optional headers, and token.
+   * @returns The API response data.
+   */
+  async delete(s, t) {
+    const n = this.generateHeaders((t == null ? void 0 : t.headers) || {}, t == null ? void 0 : t.token), r = t == null ? void 0 : t.body, o = await os({
+      url: this.baseUrl + s,
+      urlParams: (t == null ? void 0 : t.urlParams) || {},
+      headers: n,
+      body: r
+    });
+    return this.onDebug(s, "delete", {
+      headers: n,
+      body: r,
+      message: o.message,
+      status: o.status
+    }), o;
+  }
+}
+async function ks(e) {
+  let s;
+  const t = await e.arrayBuffer(), n = new TextDecoder().decode(t);
+  try {
+    s = JSON.parse(n);
+  } catch {
+    try {
+      if (n.includes("=")) {
+        const o = new URLSearchParams(n);
+        s = Object.fromEntries(o.entries());
+      } else
+        throw new T("Invalid URLSearchParams format");
+    } catch {
+      throw new T("Failed to extract data from request");
+    }
+  }
+  return s;
+}
+function Is(e, s) {
+  var t, n, r;
+  return e != null && e.message && typeof (e == null ? void 0 : e.message) == "string" ? e == null ? void 0 : e.message : e != null && e.operator_erro_message && typeof (e == null ? void 0 : e.operator_erro_message) == "string" ? e == null ? void 0 : e.operator_erro_message : e != null && e.error && typeof (e == null ? void 0 : e.error) == "string" ? e == null ? void 0 : e.error : (t = e == null ? void 0 : e.error) != null && t.message && typeof ((n = e == null ? void 0 : e.error) == null ? void 0 : n.message) == "string" ? (r = e == null ? void 0 : e.error) == null ? void 0 : r.message : s != null && s.statusText && typeof (s == null ? void 0 : s.statusText) == "string" ? s == null ? void 0 : s.statusText : "Missing error message";
+}
+function Us(e) {
+  switch (!0) {
+    case e instanceof Response:
+      return e;
+    case e instanceof X:
+      return e.toResponse();
+    case e instanceof Q:
+      return e.toResponse();
+    case e instanceof ts:
+      return e.toResponse();
+    case e instanceof es:
+      return e.toResponse();
+    case e instanceof ss:
+      return e.toResponse();
+  }
+  switch (!0) {
+    case e instanceof V:
+      return e.toResponse();
+    case e instanceof T:
+      return e.toResponse();
+    case e instanceof Z:
+      return e.toResponse();
+    case e instanceof G:
+      return e.toResponse();
+    case e instanceof W:
+      return e.toResponse();
+    case e instanceof Y:
+      return e.toResponse();
+    case e instanceof x:
+      return e.toResponse();
+    case e instanceof K:
+      return e.toResponse();
+    case e instanceof R:
+      return e.toResponse();
+  }
+  return new x("Server error", e).toResponse();
+}
+async function ls([
+  e,
+  s
+]) {
+  const t = await s.safeParseAsync(e);
+  return t.success === !1 ? {
+    success: !1,
+    fieldErrors: Object.fromEntries(
+      t.error.issues.map((r) => [r.path.join("."), r.message])
+    ),
+    fields: e
+  } : {
+    success: !0,
+    data: t.data
+  };
+}
+function hs([
+  e,
+  s
+]) {
+  const t = s.safeParse(e);
+  return t.success === !1 ? {
+    success: !1,
+    fieldErrors: Object.fromEntries(
+      t.error.issues.map((r) => [r.path.join("."), r.message])
+    ),
+    fields: e
+  } : {
+    success: !0,
+    data: t.data
+  };
+}
+function qs(e, s = "") {
+  const t = new URL(e.url);
+  if (s === "") return t.searchParams;
+  const n = Array.from(
+    t.searchParams.entries()
+  ).filter(([r]) => r.startsWith(`${s}:`)).map(([r, o]) => [r.replace(`${s}:`, ""), o]);
+  return new URLSearchParams(n);
+}
+function fs(e) {
+  const s = "Error validating:", t = e.issues.map(
+    ({ path: n, message: r }) => `-> ${n.join(".")}: ${r}`
+  );
+  return [s, ...t].join(`
+`);
+}
+class As {
+  /**
+   * @param schema - The Zod schema used for all validation methods on this instance.
+   */
+  constructor(s) {
+    this.schema = s;
+  }
+  /**
+   * Returns `true` if the data satisfies the schema, `false` otherwise. Never throws.
+   *
+   * @param data - The value to check.
+   */
+  isValid(s) {
+    return this.schema.safeParse(s).success;
+  }
+  /**
+   * Validates data and returns the raw Zod `safeParseResult` without throwing.
+   * Useful when you need access to the full error details.
+   *
+   * @param data - The value to validate.
+   */
+  safeValidate(s) {
+    return this.schema.safeParse(s);
+  }
+  /**
+   * Validates data and returns the typed result, throwing `ServerError` on failure.
+   * Use for validating internal/trusted data (e.g. env vars, config objects).
+   *
+   * @param data - The value to validate.
+   * @throws `ServerError` with a formatted field-by-field error message.
+   */
+  validate(s) {
+    try {
+      return this.schema.parse(s);
+    } catch (t) {
+      throw new x(fs(t));
+    }
+  }
+  /**
+   * Validates form data and returns the typed result, throwing `UnprocessableEntity` on failure.
+   * The error includes `fieldErrors`, `fields`, and `data.scrollTo` (first failing field name).
+   *
+   * @param data - The raw form data to validate.
+   * @param message - Optional human-readable error message for the 422 response.
+   * @throws `UnprocessableEntity` with structured field errors for client-side form handling.
+   *
+   * @example
+   * ```typescript
+   * const validator = new SchemaValidator(registerSchema);
+   * const body = validator.formValidate(await decodeRequestBody(request));
+   * ```
+   */
+  formValidate(s, t) {
+    const n = hs([s, this.schema]);
+    if ("fieldErrors" in n) {
+      const r = Object.keys(n.fieldErrors)[0];
+      throw new R({
+        fields: n.fields,
+        fieldErrors: n.fieldErrors,
+        data: { scrollTo: r },
+        message: t
+      });
+    }
+    return n.data;
+  }
+  /**
+   * Async version of `formValidate` for schemas with async refinements (e.g. uniqueness checks).
+   *
+   * @param data - The raw form data to validate.
+   * @param message - Optional human-readable error message for the 422 response.
+   * @throws `UnprocessableEntity` with structured field errors for client-side form handling.
+   *
+   * @example
+   * ```typescript
+   * const validator = new SchemaValidator(registerSchema);
+   * const body = await validator.formAsyncValidate(await decodeRequestBody(request));
+   * ```
+   */
+  async formAsyncValidate(s, t) {
+    const n = await ls([s, this.schema]);
+    if ("fieldErrors" in n) {
+      const r = Object.keys(n.fieldErrors)[0];
+      throw new R({
+        fields: n.fields,
+        fieldErrors: n.fieldErrors,
+        data: { scrollTo: r },
+        message: t
+      });
+    }
+    return n.data;
+  }
+}
+function Hs(e) {
+  if (!(/^\d{5}-\d{3}$/.test(e) || /^\d{8}$/.test(e))) return !1;
+  const t = S(e), n = 8, r = /^\d{8}$/.test(t);
+  return t.length === n && r;
+}
+function ms(e) {
+  return e.length !== 14;
+}
+function gs(e) {
+  const [s] = e;
+  return [...e].every((t) => t === s);
+}
+function O(e, s) {
+  let t = 0;
+  for (let r = 0; r < s.length; r++)
+    t += parseInt(e[r]) * s[r];
+  const n = t % 11;
+  return n < 2 ? 0 : 11 - n;
+}
+function ds(e) {
+  return e.slice(12);
+}
+function Ls(e) {
+  if (!e || e.length > 18 || e.length < 14 || /\s/.test(e)) return !1;
+  const t = S(e);
+  if (ms(t) || gs(t)) return !1;
+  const n = t.slice(0, 12), r = O(n, [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]), o = O(
+    n + r,
+    [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
+  );
+  return ds(t) === `${r}${o}`;
+}
+function ps(e) {
+  return e.length !== 11;
+}
+function ys(e) {
+  const [s] = e;
+  return [...e].every((t) => t === s);
+}
+function _(e, s) {
+  let t = 0;
+  for (const r of e)
+    s > 1 && (t += parseInt(r) * s--);
+  const n = t % 11;
+  return n < 2 ? 0 : 11 - n;
+}
+function bs(e) {
+  return e.slice(9);
+}
+function Fs(e) {
+  if (!e || e.length > 14 || e.length < 11 || /\s/.test(e)) return !1;
+  const t = S(e);
+  if (ps(t) || ys(t)) return !1;
+  const n = _(t, 10), r = _(t, 11);
+  return bs(t) === `${n}${r}`;
+}
+function zs(e, s) {
+  const t = (s == null ? void 0 : s.inputFormat) || "brazilianDate", n = (s == null ? void 0 : s.minYear) || 1900, r = (s == null ? void 0 : s.maxYear) || 3e3, o = new A();
+  o.validateInputFormat(t);
+  let a, u, i;
+  const l = e.split(/[-/]/).map(Number);
+  if (l.length !== 3) return !1;
+  try {
+    switch (t) {
+      case "brazilianDate":
+        [a, u, i] = l, o.validateDateParts(i, u, a);
+        break;
+      case "isoDate":
+        [u, a, i] = l, o.validateDateParts(i, u, a);
+        break;
+      case "timestamp":
+        [i, u, a] = l, o.validateDateParts(i, u, a);
+        break;
+    }
+    return !(i < n || i > r);
+  } catch {
+    return !1;
+  }
+}
+function Ts(e) {
+  return /^[a-zA-Z0-9.!$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/.test(e);
+}
+function xs(e) {
+  return !(e.length === 0 || e.length > 64 || e.startsWith(".") || e.endsWith(".") || e.includes("..") || !/^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+$/.test(e));
+}
+function Rs(e) {
+  return !(e.length === 0 || e.length > 63 || e.startsWith("-") || e.endsWith("-") || !/^[a-zA-Z0-9-]+$/.test(e));
+}
+function Ss(e) {
+  if (e.length === 0 || e.length > 253 || e.startsWith(".") || e.endsWith(".") || e.startsWith("-") || e.endsWith("-"))
+    return !1;
+  const s = e.split(".");
+  if (s.length < 2) return !1;
+  for (const n of s) if (!Rs(n)) return !1;
+  const t = s[s.length - 1];
+  return !(t.length < 2 || !/^[a-zA-Z]+$/.test(t));
+}
+function Ns(e) {
+  const s = e.split("@");
+  if (s.length !== 2) return !1;
+  const [t, n] = s;
+  return !(!xs(t) || !Ss(n));
+}
+function Ds(e) {
+  const s = e.split("@");
+  return s.length === 2 ? s[1].toLowerCase() : null;
+}
+const Es = ["MX", "A", "AAAA"];
+async function Os(e, s) {
+  var t, n;
+  try {
+    return await ((n = (t = L) == null ? void 0 : t.promises) == null ? void 0 : n.resolve(e, s)), !0;
+  } catch {
+    return !1;
+  }
+}
+async function _s(e) {
+  for (const s of Es)
+    if (await Os(e, s)) return !0;
+  return !1;
+}
+async function Ms(e) {
+  if (!e || typeof e != "string") return !1;
+  const s = e.trim();
+  if (!Ts(s) || !Ns(s)) return !1;
+  const t = Ds(s);
+  return t ? await _s(t) : !1;
+}
+function Vs(e) {
+  if (!e) return !1;
+  const s = e.length >= 8, t = /[A-Z]/.test(e), n = /[a-z]/.test(e), r = /\d/.test(e), o = /[!@#$%^&*(),.?":;{}|<>_\-+=~`[\]\\\/]/.test(
+    e
+  );
+  return [
+    s,
+    t,
+    n,
+    r,
+    o
+  ].every((a) => a);
+}
+function Zs(e) {
+  if (!z(e)) return !1;
+  const s = M(e), t = s == null ? void 0 : s.country;
+  return !(!t || !F.find((r) => r.iso === t));
+}
+function Gs(e) {
+  if (!e || !/^[0-9a-zA-Z.-]+$/.test(e)) return !1;
+  const t = e.replace(/[^a-zA-Z0-9]/g, "");
+  return t.length < 7 || t.length > 9 ? !1 : /^[0-9]{7,8}[0-9Xx]?$/.test(t);
+}
+export {
+  Js as ApiService,
+  V as BadGateway,
+  T as BadRequest,
+  Z as Conflict,
+  Q as Created,
+  N as DebugService,
+  G as Forbidden,
+  X as Found,
+  v as LogService,
+  ss as NoContent,
+  W as NotFound,
+  Y as NotImplemented,
+  As as SchemaValidator,
+  x as ServerError,
+  es as Success,
+  K as Unauthorized,
+  R as UnprocessableEntity,
+  ts as Updated,
+  ks as decodeRequestBody,
+  Is as decodeRequestErrorMessage,
+  Us as errorHandler,
+  g as flushDebugLogs,
+  ls as formAsyncParse,
+  hs as formParse,
+  qs as getScopedParams,
+  Hs as validateCep,
+  Ls as validateCnpj,
+  Fs as validateCpf,
+  zs as validateDate,
+  Ms as validateEmail,
+  Vs as validatePassword,
+  Zs as validatePhone,
+  Gs as validateRg
+};