@arkyn/server 3.0.1-beta.12 → 3.0.1-beta.121

package/dist/utilities/schemaValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaValidator.d.ts","sourceRoot":"","sources":["../../src/utilities/schemaValidator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgBjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,cAAM,eAAe,CAAC,CAAC,SAAS,OAAO;IAKzB,QAAQ,CAAC,MAAM,EAAE,CAAC;IAJ9B;;;OAGG;gBACkB,MAAM,EAAE,CAAC;IAE9B;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO;IAI3B;;;;;;;;;;;;;;;;;OAiBG;IACH,YAAY,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAIzD;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;IAQ/B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;IAiBrD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACG,iBAAiB,CAAC,IAAI,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;CAgB1E;AAED,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/utilities/schemaValidator.js

@@ -0,0 +1,191 @@
+import { ZodType, z } from "zod";
+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");
+}
+/**
+ * A schema validator class that provides multiple validation methods for Zod schemas.
+ *
+ * @example
+ * ```typescript
+ * import { z } from "zod";
+ *
+ * const userSchema = z.object({
+ *   name: z.string().min(1, "Name is required"),
+ *   email: z.string().email("Invalid email"),
+ *   age: z.number().min(18, "Must be at least 18")
+ * });
+ *
+ * const validator = new SchemaValidator(userSchema);
+ *
+ * // Check if data is valid without throwing
+ * const isValid = validator.isValid({ name: "John", email: "john@example.com", age: 25 });
+ *
+ * // Validate and throw ServerError on failure
+ * try {
+ *   const validData = validator.validate({ name: "John", email: "john@example.com", age: 25 });
+ * } catch (error) {
+ *   console.error(error.message);
+ * }
+ *
+ * // Form validation with UnprocessableEntity error
+ * try {
+ *   const formData = validator.formValidate(requestBody);
+ * } catch (error) {
+ *   // Returns structured error with fieldErrors for forms
+ * }
+ * ```
+ */
+class SchemaValidator {
+    schema;
+    /**
+     * Creates a new SchemaValidator instance.
+     * @param {T} schema - The Zod schema to use for validation.
+     */
+    constructor(schema) {
+        this.schema = schema;
+    }
+    /**
+     * Checks if the provided data is valid according to the schema without throwing errors.
+     *
+     * @param {any} data - The data to validate.
+     *
+     * @returns {boolean} True if the data is valid, false otherwise.
+     *
+     * @example
+     * ```typescript
+     * const validator = new SchemaValidator(userSchema);
+     * const isValid = validator.isValid({ name: "John", email: "invalid-email" });
+     * console.log(isValid); // false
+     * ```
+     */
+    isValid(data) {
+        return this.schema.safeParse(data).success;
+    }
+    /**
+     * Safely validates data and returns the complete parse result without throwing errors.
+     *
+     * @param {any} data - The data to validate.
+     * @returns {z.ZodSafeParseResult<z.infer<T>>} The Zod safe parse result containing success status and data or error.
+     *
+     * @example
+     * ```typescript
+     * const validator = new SchemaValidator(userSchema);
+     * const result = validator.safeValidate({ name: "", email: "john@example.com" });
+     *
+     * if (result.success) {
+     *   console.log(result.data); // Validated data
+     * } else {
+     *   console.log(result.error.issues); // Validation errors
+     * }
+     * ```
+     */
+    safeValidate(data) {
+        return this.schema.safeParse(data);
+    }
+    /**
+     * Validates data and returns the parsed result, throwing a ServerError on validation failure.
+     *
+     * @param {any} data - The data to validate.
+     * @throws {ServerError} When validation fails, with a formatted error message.
+     * @returns {z.infer<T>} The validated and parsed data.
+     *
+     * @example
+     * ```typescript
+     * const validator = new SchemaValidator(userSchema);
+     *
+     * try {
+     *   const validUser = validator.validate({ name: "John", email: "john@example.com", age: 25 });
+     *   console.log(validUser); // { name: "John", email: "john@example.com", age: 25 }
+     * } catch (error) {
+     *   console.error(error.message); // "Error validating:\n-> name: String must contain at least 1 character(s)"
+     * }
+     * ```
+     */
+    validate(data) {
+        try {
+            return this.schema.parse(data);
+        }
+        catch (error) {
+            throw new ServerError(formatErrorMessage(error));
+        }
+    }
+    /**
+     * Validates form data and returns the parsed result, throwing an UnprocessableEntity error on validation failure.
+     * This method is specifically designed for form validation in web applications.
+     *
+     * @param {any} data - The form data to validate.
+     * @param {string} [message] - Optional custom error message.
+     * @throws {UnprocessableEntity} When validation fails, with structured field errors for form handling.
+     * @returns {z.infer<T>} The validated and parsed form data.
+     *
+     * @example
+     * ```typescript
+     * const validator = new SchemaValidator(userSchema);
+     *
+     * try {
+     *   const validFormData = validator.formValidate(requestBody, "User data is invalid");
+     *   console.log(validFormData);
+     * } catch (error) {
+     *   // UnprocessableEntity with fieldErrors, fields, and scrollTo data
+     *   console.log(error.fieldErrors); // { name: "Name is required", email: "Invalid email" }
+     *   console.log(error.data.scrollTo); // "name" (first error field)
+     * }
+     * ```
+     */
+    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;
+    }
+    /**
+     * Asynchronously validates form data and returns the parsed result, throwing an UnprocessableEntity error on validation failure.
+     * This method is the async version of formValidate, designed for form validation with async schemas.
+     *
+     * @param {any} data - The form data to validate.
+     * @param {string} [message] - Optional custom error message.
+     * @throws {UnprocessableEntity} When validation fails, with structured field errors for form handling.
+     * @returns {Promise<z.infer<T>>} A promise that resolves to the validated and parsed form data.
+     *
+     * @example
+     * ```typescript
+     * const validator = new SchemaValidator(userSchemaWithAsyncValidation);
+     *
+     * try {
+     *   const validFormData = await validator.formAsyncValidate(requestBody, "User data is invalid");
+     *   console.log(validFormData);
+     * } catch (error) {
+     *   // UnprocessableEntity with fieldErrors, fields, and scrollTo data
+     *   console.log(error.fieldErrors); // { name: "Name is required", email: "Invalid email" }
+     *   console.log(error.data.scrollTo); // "name" (first error field)
+     * }
+     * ```
+     */
+    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.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Validates a Brazilian CEP (postal code).
+ *
+ * A valid CEP must contain exactly 8 numeric digits,
+ * optionally formatted as "12345-678".
+ *
+ * @param {string} rawCep - CEP value, with or without formatting.
+ * @returns {boolean} `true` if the CEP is valid, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * validateCep("12345-678"); // true
+ * validateCep("12345678");  // true
+ * validateCep("ABCDE-123"); // false
+ * ```
+ */
+declare function validateCep(rawCep: string): boolean;
+export { validateCep };
+//# sourceMappingURL=validateCep.d.ts.map

package/dist/validations/validateCep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateCep.d.ts","sourceRoot":"","sources":["../../src/validations/validateCep.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AAEH,iBAAS,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAU5C;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/validations/validateCep.js

@@ -0,0 +1,27 @@
+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 {string} rawCep - CEP value, with or without formatting.
+ * @returns {boolean} `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.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 {string} rawCnpj - CNPJ string, possibly formatted.
+ * @returns {boolean} `true` if valid, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * validateCnpj("12.345.678/0001-95"); // false
+ * validateCnpj("11.444.777/0001-61"); // true
+ * ```
+ */
+declare function validateCnpj(rawCnpj: string): boolean;
+export { validateCnpj };
+//# sourceMappingURL=validateCnpj.d.ts.map

package/dist/validations/validateCnpj.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateCnpj.d.ts","sourceRoot":"","sources":["../../src/validations/validateCnpj.ts"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;GAiBG;AAEH,iBAAS,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAqB9C;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/validations/validateCnpj.js

@@ -0,0 +1,59 @@
+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 {string} rawCnpj - CNPJ string, possibly formatted.
+ * @returns {boolean} `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.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Validates a Brazilian CPF (Cadastro de Pessoas Físicas) number.
+ *
+ * The CPF is a unique identifier assigned to Brazilian citizens and residents.
+ * This function checks if the provided CPF is valid by performing the following steps:
+ * - Removes any non-digit characters from the input.
+ * - Verifies if the CPF has the correct length (11 digits).
+ * - Ensures that all digits are not the same (e.g., "111.111.111-11" is invalid).
+ * - Calculates the first and second verification digits using the CPF algorithm.
+ * - Compares the calculated verification digits with the ones provided in the CPF.
+ *
+ * @param {string} rawCpf - The raw CPF string, which may include formatting characters (e.g., dots or dashes).
+ * @returns {boolean} `true` if the CPF is valid, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * validateCpf("123.456.789-09"); // false
+ * validateCpf("111.444.777-35"); // true
+ * ```
+ */
+declare function validateCpf(rawCpf: string): boolean;
+export { validateCpf };
+//# sourceMappingURL=validateCpf.d.ts.map

package/dist/validations/validateCpf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateCpf.d.ts","sourceRoot":"","sources":["../../src/validations/validateCpf.ts"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,iBAAS,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAiB5C;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/validations/validateCpf.js

@@ -0,0 +1,61 @@
+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 (Cadastro de Pessoas Físicas) number.
+ *
+ * The CPF is a unique identifier assigned to Brazilian citizens and residents.
+ * This function checks if the provided CPF is valid by performing the following steps:
+ * - Removes any non-digit characters from the input.
+ * - Verifies if the CPF has the correct length (11 digits).
+ * - Ensures that all digits are not the same (e.g., "111.111.111-11" is invalid).
+ * - Calculates the first and second verification digits using the CPF algorithm.
+ * - Compares the calculated verification digits with the ones provided in the CPF.
+ *
+ * @param {string} rawCpf - The raw CPF string, which may include formatting characters (e.g., dots or dashes).
+ * @returns {boolean} `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.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Validates a date string based on the provided format and configuration.
+ *
+ * @param {string} date - The date string to validate.
+ * @param {object} config - Optional configuration object to customize validation.
+ * @param {number} config.minYear - The minimum allowed year for the date. Defaults to 1900.
+ * @param {number} config.maxYear - The maximum allowed year for the date. Defaults to 3000.
+ * @throws {Error} If an invalid input format is provided.
+ * @returns {boolean} `true` if the date is valid according to the specified format and configuration, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * validateDate("31/12/2023"); // true
+ * validateDate("12-31-2023", { inputFormat: "isoDate" }); // true
+ * validateDate("2023-12-31", { inputFormat: "timestamp", minYear: 2000, maxYear: 2100 }); // true
+ * validateDate("29/02/2024", { inputFormat: "brazilianDate" }); // true (leap year)
+ * validateDate("29/02/2023", { inputFormat: "brazilianDate" }); // false (not a leap year)
+ * validateDate("31/04/2023", { inputFormat: "brazilianDate" }); // false (April has 30 days)
+ * ```
+ */
+declare function validateDate(date: string, config?: {
+    inputFormat?: "brazilianDate" | "isoDate" | "timestamp";
+    minYear?: number;
+    maxYear?: number;
+}): boolean;
+export { validateDate };
+//# sourceMappingURL=validateDate.d.ts.map

package/dist/validations/validateDate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateDate.d.ts","sourceRoot":"","sources":["../../src/validations/validateDate.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,iBAAS,YAAY,CACnB,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE;IACP,WAAW,CAAC,EAAE,eAAe,GAAG,SAAS,GAAG,WAAW,CAAC;IACxD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GACA,OAAO,CAiCT;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/validations/validateDate.js

@@ -0,0 +1,55 @@
+import { ValidateDateService } from "@arkyn/shared";
+/**
+ * Validates a date string based on the provided format and configuration.
+ *
+ * @param {string} date - The date string to validate.
+ * @param {object} config - Optional configuration object to customize validation.
+ * @param {number} config.minYear - The minimum allowed year for the date. Defaults to 1900.
+ * @param {number} config.maxYear - The maximum allowed year for the date. Defaults to 3000.
+ * @throws {Error} If an invalid input format is provided.
+ * @returns {boolean} `true` if the date is valid according to the specified format and configuration, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * validateDate("31/12/2023"); // true
+ * validateDate("12-31-2023", { inputFormat: "isoDate" }); // true
+ * validateDate("2023-12-31", { inputFormat: "timestamp", minYear: 2000, maxYear: 2100 }); // true
+ * validateDate("29/02/2024", { inputFormat: "brazilianDate" }); // true (leap year)
+ * validateDate("29/02/2023", { inputFormat: "brazilianDate" }); // false (not a leap year)
+ * validateDate("31/04/2023", { inputFormat: "brazilianDate" }); // false (April has 30 days)
+ * ```
+ */
+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.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 {string} rawEmail - The email address string to validate
+ * @returns {Promise<boolean>} A promise that resolves to `true` if the email is valid (including 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)
+ * ```
+ */
+declare function validateEmail(rawEmail: string): Promise<boolean>;
+export { validateEmail };
+//# sourceMappingURL=validateEmail.d.ts.map

package/dist/validations/validateEmail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateEmail.d.ts","sourceRoot":"","sources":["../../src/validations/validateEmail.ts"],"names":[],"mappings":"AAwFA;;;;;;;;;;;;;;;;;GAiBG;AAEH,iBAAe,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAW/D;AAED,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/validations/validateEmail.js

@@ -0,0 +1,111 @@
+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 {string} rawEmail - The email address string to validate
+ * @returns {Promise<boolean>} A promise that resolves to `true` if the email is valid (including 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 };

package/dist/validations/validatePassword.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Validates a password based on the following rules:
+ * - At least 8 characters
+ * - At least 1 uppercase letter
+ * - At least 1 letter (any case)
+ * - At least 1 number
+ * - At least 1 special character
+ *
+ * @param {string} rawPassword - The raw password string.
+ * @returns {boolean} `true` if password is valid, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * validatePassword("Senha@123"); // true
+ * validatePassword("senha123");  // false (no uppercase, no special char)
+ * ```
+ */
+declare function validatePassword(rawPassword: string): boolean;
+export { validatePassword };
+//# sourceMappingURL=validatePassword.d.ts.map

package/dist/validations/validatePassword.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validatePassword.d.ts","sourceRoot":"","sources":["../../src/validations/validatePassword.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,iBAAS,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAkBtD;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC"}