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

package/dist/utilities/decodeRequestErrorMessage.js

@@ -1,36 +0,0 @@
-/**
- * Extracts a human-readable error message from an API response body or a `Response` object.
- * Checks `data.message`, `data.operator_erro_message`, `data.error`, `data.error.message`,
- * and `response.statusText` in that order. Falls back to `"Missing error message"`.
- *
- * @param data - Parsed response body that may contain error info.
- * @param response - The raw `Response` object, used as a fallback for `statusText`.
- * @returns The first non-empty string error message found.
- *
- * @example
- * ```typescript
- * const res = await fetch("/api/orders");
- * const data = await res.json().catch(() => null);
- * const message = decodeRequestErrorMessage(data, res);
- * ```
- */
-function decodeRequestErrorMessage(data, response) {
-    if (data?.message && typeof data?.message === "string") {
-        return data?.message;
-    }
-    if (data?.operator_erro_message &&
-        typeof data?.operator_erro_message === "string") {
-        return data?.operator_erro_message;
-    }
-    if (data?.error && typeof data?.error === "string") {
-        return data?.error;
-    }
-    if (data?.error?.message && typeof data?.error?.message === "string") {
-        return data?.error?.message;
-    }
-    if (response?.statusText && typeof response?.statusText === "string") {
-        return response?.statusText;
-    }
-    return "Missing error message";
-}
-export { decodeRequestErrorMessage };

package/dist/utilities/errorHandler.js

@@ -1,74 +0,0 @@
-import { BadGateway } from "../http/badResponses/badGateway";
-import { BadRequest } from "../http/badResponses/badRequest";
-import { Conflict } from "../http/badResponses/conflict";
-import { Forbidden } from "../http/badResponses/forbidden";
-import { NotFound } from "../http/badResponses/notFound";
-import { NotImplemented } from "../http/badResponses/notImplemented";
-import { ServerError } from "../http/badResponses/serverError";
-import { Unauthorized } from "../http/badResponses/unauthorized";
-import { UnprocessableEntity } from "../http/badResponses/unprocessableEntity";
-import { Created } from "../http/successResponses/created";
-import { Found } from "../http/successResponses/found";
-import { NoContent } from "../http/successResponses/noContent";
-import { Success } from "../http/successResponses/success";
-import { Updated } from "../http/successResponses/updated";
-/**
- * Converts any thrown value into a `Response`. Recognizes all `@arkyn/server` success and error
- * response classes, native `Response` objects, and falls back to a 500 `ServerError` for anything else.
- *
- * Intended to be used as the catch handler of a route action or loader:
- *
- * @param error - The thrown value to convert.
- * @returns A `Response` with the appropriate HTTP status, headers, and JSON body.
- *
- * @example
- * ```typescript
- * export async function action({ request }: ActionFunctionArgs) {
- *   try {
- *     const user = await findUser(id);
- *     if (!user) throw new NotFound("User not found");
- *     return new Success("User retrieved", { user }).toJson();
- *   } catch (error) {
- *     return errorHandler(error);
- *   }
- * }
- * ```
- */
-function errorHandler(error) {
-    switch (true) {
-        case error instanceof Response:
-            return error;
-        case error instanceof Found:
-            return error.toResponse();
-        case error instanceof Created:
-            return error.toResponse();
-        case error instanceof Updated:
-            return error.toResponse();
-        case error instanceof Success:
-            return error.toResponse();
-        case error instanceof NoContent:
-            return error.toResponse();
-    }
-    switch (true) {
-        case error instanceof BadGateway:
-            return error.toResponse();
-        case error instanceof BadRequest:
-            return error.toResponse();
-        case error instanceof Conflict:
-            return error.toResponse();
-        case error instanceof Forbidden:
-            return error.toResponse();
-        case error instanceof NotFound:
-            return error.toResponse();
-        case error instanceof NotImplemented:
-            return error.toResponse();
-        case error instanceof ServerError:
-            return error.toResponse();
-        case error instanceof Unauthorized:
-            return error.toResponse();
-        case error instanceof UnprocessableEntity:
-            return error.toResponse();
-    }
-    return new ServerError("Server error", error).toResponse();
-}
-export { errorHandler };

package/dist/utilities/flushDebugLogs.js

@@ -1,39 +0,0 @@
-/**
- * Writes colored `[name] message` lines to the console, but only when
- * `NODE_ENV === "development"` or `DEBUG_MODE === "true"`. No-op in production.
- *
- * @param props.name - Label shown before each line (e.g. `"API"`, `"Auth"`).
- * @param props.scheme - Color of the label tag: `"cyan"` info, `"green"` success, `"yellow"` warning, `"red"` error.
- * @param props.debugs - Lines of text to print, one per console entry.
- *
- * @example
- * ```typescript
- * flushDebugLogs({
- *   name: "API",
- *   scheme: "cyan",
- *   debugs: ["POST /api/users", "Status: 201"],
- * });
- * ```
- */
-function flushDebugLogs(props) {
-    const isDebugMode = process.env.NODE_ENV === "development" ||
-        process.env?.DEBUG_MODE === "true";
-    if (isDebugMode) {
-        const reset = "\x1b[0m";
-        const colors = {
-            yellow: "\x1b[33m",
-            cyan: "\x1b[36m",
-            red: "\x1b[31m",
-            green: "\x1b[32m",
-        };
-        const debugName = `${colors[props.scheme]}[${props.name}]${reset}`;
-        let consoleData = `\n`;
-        props.debugs.forEach((debug, index) => {
-            consoleData += `${debugName} ${debug.trim()}`;
-            if (index < props.debugs.length - 1)
-                consoleData += `\n`;
-        });
-        console.log(consoleData);
-    }
-}
-export { flushDebugLogs };

package/dist/utilities/formAsyncParse.js

@@ -1,37 +0,0 @@
-/**
- * Async variant of `formParse` — uses `safeParseAsync` to support Zod schemas with async refinements.
- * Returns `{ success: true, data }` on success or `{ success: false, fieldErrors, fields }` on failure.
- *
- * @param formData - The raw form data object to validate.
- * @param schema - The Zod schema to validate against.
- *
- * @example
- * ```typescript
- * const schema = z.object({ email: z.string().email() });
- * const result = await formAsyncParse([{ email: "bad" }, schema]);
- *
- * if (!result.success) {
- *   console.log(result.fieldErrors); // { email: "Invalid email" }
- * }
- * ```
- */
-async function formAsyncParse([formData, schema,]) {
-    const zodResponse = await schema.safeParseAsync(formData);
-    if (zodResponse.success === false) {
-        const errorsObject = Object.fromEntries(zodResponse.error.issues.map((item) => {
-            return [item.path.join("."), item.message];
-        }));
-        return {
-            success: zodResponse.success,
-            fieldErrors: errorsObject,
-            fields: formData,
-        };
-    }
-    else {
-        return {
-            success: zodResponse.success,
-            data: zodResponse.data,
-        };
-    }
-}
-export { formAsyncParse };

package/dist/utilities/formParse.js

@@ -1,37 +0,0 @@
-/**
- * Validates form data against a Zod schema synchronously.
- * Returns `{ success: true, data }` on success or `{ success: false, fieldErrors, fields }` on failure.
- *
- * @param formData - The raw form data object to validate.
- * @param schema - The Zod schema to validate against.
- *
- * @example
- * ```typescript
- * const schema = z.object({ name: z.string().min(1, "Required"), age: z.number().min(18) });
- * const result = formParse([{ name: "", age: 15 }, schema]);
- *
- * if (!result.success) {
- *   console.log(result.fieldErrors); // { name: "Required", age: "..." }
- * }
- * ```
- */
-function formParse([formData, schema,]) {
-    const zodResponse = schema.safeParse(formData);
-    if (zodResponse.success === false) {
-        const errorsObject = Object.fromEntries(zodResponse.error.issues.map((item) => {
-            return [item.path.join("."), item.message];
-        }));
-        return {
-            success: zodResponse.success,
-            fieldErrors: errorsObject,
-            fields: formData,
-        };
-    }
-    else {
-        return {
-            success: zodResponse.success,
-            data: zodResponse.data,
-        };
-    }
-}
-export { formParse };

package/dist/utilities/getScopedParams.js

@@ -1,26 +0,0 @@
-/**
- * Extracts URL search parameters from a request, optionally filtered by a namespace prefix
- * (e.g. `scope:key` → `key`). Without a scope, returns all search params as-is.
- *
- * @param request - The incoming request whose URL will be parsed.
- * @param scope - Namespace prefix to filter by (e.g. `"table"` matches `table:page`, `table:sort`).
- * @returns A `URLSearchParams` object with the matching params, stripped of the scope prefix.
- *
- * @example
- * ```typescript
- * // URL: /products?table:page=2&table:sort=asc&other=1
- * const params = getScopedParams(request, "table");
- * params.get("page");  // "2"
- * params.get("sort");  // "asc"
- * ```
- */
-function getScopedParams(request, scope = "") {
-    const url = new URL(request.url);
-    if (scope === "")
-        return url.searchParams;
-    const scopedSearchParams = Array.from(url.searchParams.entries())
-        .filter(([key]) => key.startsWith(`${scope}:`))
-        .map(([key, value]) => [key.replace(`${scope}:`, ""), value]);
-    return new URLSearchParams(scopedSearchParams);
-}
-export { getScopedParams };

package/dist/utilities/schemaValidator.js

@@ -1,119 +0,0 @@
-import { ServerError } from "../http/badResponses/serverError";
-import { UnprocessableEntity } from "../http/badResponses/unprocessableEntity";
-import { formAsyncParse } from "./formAsyncParse";
-import { formParse } from "./formParse";
-function formatErrorMessage(error) {
-    const title = "Error validating:";
-    const lines = error.issues.map(({ path, message }) => `-> ${path.join(".")}: ${message}`);
-    return [title, ...lines].join("\n");
-}
-/**
- * Wraps a Zod schema with convenience validation methods suited for server-side use:
- * - `isValid` — boolean check, no throws
- * - `safeValidate` — raw Zod result, no throws
- * - `validate` — throws `ServerError` on failure (for trusted/internal data)
- * - `formValidate` / `formAsyncValidate` — throws `UnprocessableEntity` on failure (for user-submitted forms)
- *
- * @example
- * ```typescript
- * const validator = new SchemaValidator(z.object({ email: z.string().email() }));
- *
- * // Inside a Remix action:
- * const body = validator.formValidate(await decodeRequestBody(request));
- * ```
- */
-class SchemaValidator {
-    schema;
-    /**
-     * @param schema - The Zod schema used for all validation methods on this instance.
-     */
-    constructor(schema) {
-        this.schema = schema;
-    }
-    /**
-     * Returns `true` if the data satisfies the schema, `false` otherwise. Never throws.
-     *
-     * @param data - The value to check.
-     */
-    isValid(data) {
-        return this.schema.safeParse(data).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(data) {
-        return this.schema.safeParse(data);
-    }
-    /**
-     * 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(data) {
-        try {
-            return this.schema.parse(data);
-        }
-        catch (error) {
-            throw new ServerError(formatErrorMessage(error));
-        }
-    }
-    /**
-     * 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(data, message) {
-        const formParsed = formParse([data, this.schema]);
-        if (!formParsed.success) {
-            const firstErrorKey = Object.keys(formParsed.fieldErrors)[0];
-            throw new UnprocessableEntity({
-                fields: formParsed.fields,
-                fieldErrors: formParsed.fieldErrors,
-                data: { scrollTo: firstErrorKey },
-                message,
-            });
-        }
-        return formParsed.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(data, message) {
-        const formParsed = await formAsyncParse([data, this.schema]);
-        if (!formParsed.success) {
-            const firstErrorKey = Object.keys(formParsed.fieldErrors)[0];
-            throw new UnprocessableEntity({
-                fields: formParsed.fields,
-                fieldErrors: formParsed.fieldErrors,
-                data: { scrollTo: firstErrorKey },
-                message,
-            });
-        }
-        return formParsed.data;
-    }
-}
-export { SchemaValidator };

package/dist/validations/validateCep.js

@@ -1,27 +0,0 @@
-import { removeNonNumeric } from "@arkyn/shared";
-/**
- * Validates a Brazilian CEP (postal code).
- *
- * A valid CEP must contain exactly 8 numeric digits,
- * optionally formatted as "12345-678".
- *
- * @param rawCep - CEP value, with or without formatting.
- * @returns `true` if the CEP is valid, otherwise `false`.
- *
- * @example
- * ```typescript
- * validateCep("12345-678"); // true
- * validateCep("12345678");  // true
- * validateCep("ABCDE-123"); // false
- * ```
- */
-function validateCep(rawCep) {
-    const validFormat = /^\d{5}-\d{3}$/.test(rawCep) || /^\d{8}$/.test(rawCep);
-    if (!validFormat)
-        return false;
-    const cep = removeNonNumeric(rawCep);
-    const CEP_LENGTH = 8;
-    const isOnlyDigits = /^\d{8}$/.test(cep);
-    return cep.length === CEP_LENGTH && isOnlyDigits;
-}
-export { validateCep };

package/dist/validations/validateCnpj.js

@@ -1,59 +0,0 @@
-import { removeNonNumeric } from "@arkyn/shared";
-function isInvalidLength(cnpj) {
-    const CNPJ_LENGTH = 14;
-    return cnpj.length !== CNPJ_LENGTH;
-}
-function hasAllDigitsEqual(cnpj) {
-    const [firstDigit] = cnpj;
-    return [...cnpj].every((digit) => digit === firstDigit);
-}
-function calculateDigit(cnpj, multipliers) {
-    let total = 0;
-    for (let i = 0; i < multipliers.length; i++) {
-        total += parseInt(cnpj[i]) * multipliers[i];
-    }
-    const rest = total % 11;
-    return rest < 2 ? 0 : 11 - rest;
-}
-function extractDigit(cnpj) {
-    return cnpj.slice(12);
-}
-/**
- * Validates a Brazilian CNPJ (Cadastro Nacional da Pessoa Jurídica) number.
- *
- * This function performs:
- * - Sanitization (removes non-digit characters).
- * - Length check (must be 14 digits).
- * - Repeating digits check (invalid if all digits are the same).
- * - Verifies the two check digits with the proper weights.
- *
- * @param rawCnpj - CNPJ string, possibly formatted.
- * @returns `true` if valid, otherwise `false`.
- *
- * @example
- * ```typescript
- * validateCnpj("12.345.678/0001-95"); // false
- * validateCnpj("11.444.777/0001-61"); // true
- * ```
- */
-function validateCnpj(rawCnpj) {
-    if (!rawCnpj)
-        return false;
-    if (rawCnpj.length > 18)
-        return false;
-    if (rawCnpj.length < 14)
-        return false;
-    const hasSpaces = /\s/.test(rawCnpj);
-    if (hasSpaces)
-        return false;
-    const cnpj = removeNonNumeric(rawCnpj);
-    if (isInvalidLength(cnpj))
-        return false;
-    if (hasAllDigitsEqual(cnpj))
-        return false;
-    const base = cnpj.slice(0, 12);
-    const digit1 = calculateDigit(base, [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]);
-    const digit2 = calculateDigit(base + digit1, [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]);
-    return extractDigit(cnpj) === `${digit1}${digit2}`;
-}
-export { validateCnpj };

package/dist/validations/validateCpf.js

@@ -1,54 +0,0 @@
-import { removeNonNumeric } from "@arkyn/shared";
-function isInvalidLength(cpf) {
-    const CPF_LENGTH = 11;
-    return cpf.length !== CPF_LENGTH;
-}
-function hasAllDigitsEqual(cpf) {
-    const [firstCpfDigit] = cpf;
-    return [...cpf].every((digit) => digit === firstCpfDigit);
-}
-function calculateDigit(cpf, factor) {
-    let total = 0;
-    for (const digit of cpf) {
-        if (factor > 1)
-            total += parseInt(digit) * factor--;
-    }
-    const rest = total % 11;
-    return rest < 2 ? 0 : 11 - rest;
-}
-function extractDigit(cpf) {
-    return cpf.slice(9);
-}
-/**
- * Validates a Brazilian CPF number. Strips formatting, checks length, rejects
- * repeated-digit sequences, and verifies both check digits with the CPF algorithm.
- *
- * @param rawCpf - CPF string, with or without formatting (dots and dashes).
- * @returns `true` if the CPF is valid, otherwise `false`.
- *
- * @example
- * ```typescript
- * validateCpf("123.456.789-09"); // false
- * validateCpf("111.444.777-35"); // true
- * ```
- */
-function validateCpf(rawCpf) {
-    if (!rawCpf)
-        return false;
-    if (rawCpf.length > 14)
-        return false;
-    if (rawCpf.length < 11)
-        return false;
-    const hasSpaces = /\s/.test(rawCpf);
-    if (hasSpaces)
-        return false;
-    const cpf = removeNonNumeric(rawCpf);
-    if (isInvalidLength(cpf))
-        return false;
-    if (hasAllDigitsEqual(cpf))
-        return false;
-    const digit1 = calculateDigit(cpf, 10);
-    const digit2 = calculateDigit(cpf, 11);
-    return extractDigit(cpf) === `${digit1}${digit2}`;
-}
-export { validateCpf };

package/dist/validations/validateDate.js

@@ -1,51 +0,0 @@
-import { ValidateDateService } from "@arkyn/shared";
-/**
- * Validates a date string against a format and optional year bounds.
- *
- * @param date - The date string to validate.
- * @param config.inputFormat - Parsing format: `"brazilianDate"` (DD/MM/YYYY, default), `"isoDate"` (MM-DD-YYYY), or `"timestamp"` (YYYY-MM-DD).
- * @param config.minYear - Minimum allowed year. Defaults to 1900.
- * @param config.maxYear - Maximum allowed year. Defaults to 3000.
- * @returns `true` if the date is valid according to the format and bounds, otherwise `false`.
- *
- * @example
- * ```typescript
- * validateDate("31/12/2023"); // true
- * validateDate("2023-12-31", { inputFormat: "timestamp", minYear: 2000, maxYear: 2100 }); // true
- * validateDate("29/02/2023"); // false (not a leap year)
- * ```
- */
-function validateDate(date, config) {
-    const inputFormat = config?.inputFormat || "brazilianDate";
-    const minYear = config?.minYear || 1900;
-    const maxYear = config?.maxYear || 3000;
-    const validateDateService = new ValidateDateService();
-    validateDateService.validateInputFormat(inputFormat);
-    let day, month, year;
-    const dateParts = date.split(/[-/]/).map(Number);
-    if (dateParts.length !== 3)
-        return false;
-    try {
-        switch (inputFormat) {
-            case "brazilianDate":
-                [day, month, year] = dateParts;
-                validateDateService.validateDateParts(year, month, day);
-                break;
-            case "isoDate":
-                [month, day, year] = dateParts;
-                validateDateService.validateDateParts(year, month, day);
-                break;
-            case "timestamp":
-                [year, month, day] = dateParts;
-                validateDateService.validateDateParts(year, month, day);
-                break;
-        }
-        if (year < minYear || year > maxYear)
-            return false;
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export { validateDate };

package/dist/validations/validateEmail.js

@@ -1,111 +0,0 @@
-import dns from "node:dns";
-function isValidBasicFormat(email) {
-    const emailRegex = /^[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])?)*$/;
-    return emailRegex.test(email);
-}
-function isValidLocalPart(localPart) {
-    if (localPart.length === 0 || localPart.length > 64)
-        return false;
-    if (localPart.startsWith(".") || localPart.endsWith("."))
-        return false;
-    if (localPart.includes(".."))
-        return false;
-    const validLocalRegex = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+$/;
-    if (!validLocalRegex.test(localPart))
-        return false;
-    return true;
-}
-function isValidDomainLabel(label) {
-    if (label.length === 0 || label.length > 63)
-        return false;
-    if (label.startsWith("-") || label.endsWith("-"))
-        return false;
-    if (!/^[a-zA-Z0-9-]+$/.test(label))
-        return false;
-    return true;
-}
-function isValidDomainPart(domainPart) {
-    if (domainPart.length === 0 || domainPart.length > 253)
-        return false;
-    if (domainPart.startsWith(".") ||
-        domainPart.endsWith(".") ||
-        domainPart.startsWith("-") ||
-        domainPart.endsWith("-")) {
-        return false;
-    }
-    const labels = domainPart.split(".");
-    if (labels.length < 2)
-        return false;
-    for (const label of labels)
-        if (!isValidDomainLabel(label))
-            return false;
-    const tld = labels[labels.length - 1];
-    if (tld.length < 2 || !/^[a-zA-Z]+$/.test(tld))
-        return false;
-    return true;
-}
-function isValidAdvancedSyntax(email) {
-    const parts = email.split("@");
-    if (parts.length !== 2)
-        return false;
-    const [localPart, domainPart] = parts;
-    if (!isValidLocalPart(localPart))
-        return false;
-    if (!isValidDomainPart(domainPart))
-        return false;
-    return true;
-}
-function extractDomain(email) {
-    const parts = email.split("@");
-    return parts.length === 2 ? parts[1].toLowerCase() : null;
-}
-const DNS_RECORD_TYPES = ["MX", "A", "AAAA"];
-async function tryResolveDnsRecord(domain, recordType) {
-    try {
-        await dns?.promises?.resolve(domain, recordType);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function isValidDns(domain) {
-    for (const recordType of DNS_RECORD_TYPES) {
-        const hasRecord = await tryResolveDnsRecord(domain, recordType);
-        if (hasRecord)
-            return true;
-    }
-    return false;
-}
-/**
- * Validates if an email address is valid in all possible ways, including DNS validation.
- *
- * This function performs comprehensive email validation by:
- * - Checking basic email format and syntax
- * - Validating advanced RFC 5322 compliance rules
- * - Verifying that the domain has valid MX or A records in DNS
- *
- * @param rawEmail - The email address to validate.
- * @returns `true` if the email passes format checks and its domain resolves in DNS, otherwise `false`.
- *
- * @example
- * ```typescript
- * await validateEmail("user@gmail.com"); // true
- * await validateEmail("user@gmil.com"); // false (invalid domain)
- * await validateEmail("invalid-email"); // false (invalid format)
- * ```
- */
-async function validateEmail(rawEmail) {
-    if (!rawEmail || typeof rawEmail !== "string")
-        return false;
-    const email = rawEmail.trim();
-    if (!isValidBasicFormat(email))
-        return false;
-    if (!isValidAdvancedSyntax(email))
-        return false;
-    const domain = extractDomain(email);
-    if (!domain)
-        return false;
-    return await isValidDns(domain);
-}
-export { validateEmail };