@arkyn/server 3.0.1-beta.9 → 3.0.1-beta.91

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

@@ -1 +1 @@
-{"version":3,"file":"schemaValidator.d.ts","sourceRoot":"","sources":["../../src/services/schemaValidator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAiBhC,cAAM,eAAe,CAAC,CAAC,SAAS,MAAM;IAIxB,QAAQ,CAAC,MAAM,EAAE,CAAC;IAH9B,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;gBAEE,MAAM,EAAE,CAAC;IAM9B,OAAO,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO;IAI3B,YAAY,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAItE,QAAQ,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;IAQ/B,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;CAoBtD;AAED,OAAO,EAAE,eAAe,EAAE,CAAC"}
+{"version":3,"file":"schemaValidator.d.ts","sourceRoot":"","sources":["../../src/services/schemaValidator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAiBjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,cAAM,eAAe,CAAC,CAAC,SAAS,OAAO;IASzB,QAAQ,CAAC,MAAM,EAAE,CAAC;IAR9B,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IAEnB;;;;OAIG;gBACkB,MAAM,EAAE,CAAC;IAM9B;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO;IAI3B;;;;;;;;;;;;;;;;;;OAkBG;IACH,YAAY,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAIzD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;IAQ/B;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;IAiBrD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;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/services/schemaValidator.js

@@ -1,30 +1,124 @@
-import { Schema, z } from "zod";
+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";
 import { getCaller } from "./getCaller";
-import { httpDebug } from "./httpDebug";
 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.
+ *
+ * @template T - A type that extends ZodType.
+ *
+ * @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;
     functionName;
     callerInfo;
+    /**
+     * Creates a new SchemaValidator instance.
+     *
+     * @param {T} schema - The Zod schema to use for validation.
+     */
     constructor(schema) {
         this.schema = schema;
         const { callerInfo, functionName } = getCaller();
         this.callerInfo = callerInfo;
         this.functionName = functionName;
     }
+    /**
+     * 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.
+     *
+     * @returns {z.infer<T>} The validated and parsed data.
+     *
+     * @throws {ServerError} When validation fails, with a formatted error message.
+     *
+     * @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);
@@ -33,17 +127,79 @@ class SchemaValidator {
             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.
+     *
+     * @returns {z.infer<T>} The validated and parsed form data.
+     *
+     * @throws {UnprocessableEntity} When validation fails, with structured field errors for form handling.
+     *
+     * @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) {
-            httpDebug("UnprocessableEntity", formParsed);
             const firstErrorKey = Object.keys(formParsed.fieldErrors)[0];
             throw new UnprocessableEntity({
                 fields: formParsed.fields,
                 fieldErrors: formParsed.fieldErrors,
                 data: { scrollTo: firstErrorKey },
                 message,
-            }, false);
+            });
+        }
+        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.
+     *
+     * @returns {Promise<z.infer<T>>} A promise that resolves to the validated and parsed form data.
+     *
+     * @throws {UnprocessableEntity} When validation fails, with structured field errors for form handling.
+     *
+     * @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;
     }

package/dist/validations/validateCep.d.ts

@@ -0,0 +1,24 @@
+type ValidateCepFunction = (rawCep: string) => boolean;
+/**
+ * Removes all non-digit characters from the CEP.
+ * @param cep - Raw CEP string.
+ * @returns Only numeric characters.
+ */
+/**
+ * Validates a Brazilian CEP (Código de Endereçamento Postal).
+ *
+ * A valid CEP has 8 numeric digits.
+ *
+ * @param rawCep - CEP string, may include formatting (e.g., "12345-678").
+ * @returns `true` if the CEP is valid, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * validateCep("12345-678"); // true
+ * validateCep("12345678");  // true
+ * validateCep("ABCDE-123"); // false
+ * ```
+ */
+declare const validateCep: ValidateCepFunction;
+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,KAAK,mBAAmB,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;AAEvD;;;;GAIG;AAEH;;;;;;;;;;;;;;GAcG;AAEH,QAAA,MAAM,WAAW,EAAE,mBAYlB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/validations/validateCep.js

@@ -0,0 +1,33 @@
+import { removeNonNumeric } from "@arkyn/shared";
+/**
+ * Removes all non-digit characters from the CEP.
+ * @param cep - Raw CEP string.
+ * @returns Only numeric characters.
+ */
+/**
+ * Validates a Brazilian CEP (Código de Endereçamento Postal).
+ *
+ * A valid CEP has 8 numeric digits.
+ *
+ * @param rawCep - CEP string, may include formatting (e.g., "12345-678").
+ * @returns `true` if the CEP is valid, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * validateCep("12345-678"); // true
+ * validateCep("12345678");  // true
+ * validateCep("ABCDE-123"); // false
+ * ```
+ */
+const validateCep = (rawCep) => {
+    if (!rawCep)
+        return false;
+    const validFormat = /^[0-9-]+$/.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,22 @@
+type ValidateCnpjFunction = (rawCnpj: string) => boolean;
+/**
+ * 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
+ * ```ts
+ * validateCnpj("12.345.678/0001-95"); // false
+ * validateCnpj("11.444.777/0001-61"); // true
+ * ```
+ */
+declare const validateCnpj: ValidateCnpjFunction;
+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":"AAEA,KAAK,oBAAoB,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;AAyBzD;;;;;;;;;;;;;;;;;GAiBG;AAEH,QAAA,MAAM,YAAY,EAAE,oBAgBnB,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/validations/validateCnpj.js

@@ -0,0 +1,52 @@
+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
+ * ```ts
+ * validateCnpj("12.345.678/0001-95"); // false
+ * validateCnpj("11.444.777/0001-61"); // true
+ * ```
+ */
+const validateCnpj = (rawCnpj) => {
+    if (!rawCnpj)
+        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,24 @@
+type ValidateCpfFunction = (rawCpf: string) => boolean;
+/**
+ * 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 rawCpf - The raw CPF string, which may include formatting characters (e.g., dots or dashes).
+ * @returns `true` if the CPF is valid, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * validateCpf("123.456.789-09"); // false
+ * validateCpf("111.444.777-35"); // true
+ * ```
+ */
+declare const validateCpf: ValidateCpfFunction;
+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":"AAEA,KAAK,mBAAmB,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;AAyBvD;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,QAAA,MAAM,WAAW,EAAE,mBAWlB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/validations/validateCpf.js

@@ -0,0 +1,54 @@
+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 rawCpf - The raw CPF string, which may include formatting characters (e.g., dots or dashes).
+ * @returns `true` if the CPF is valid, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * validateCpf("123.456.789-09"); // false
+ * validateCpf("111.444.777-35"); // true
+ * ```
+ */
+const validateCpf = (rawCpf) => {
+    if (!rawCpf)
+        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,34 @@
+type ValidateDateConfig = {
+    inputFormat?: "DD/MM/YYYY" | "MM-DD-YYYY" | "YYYY-MM-DD";
+    minYear?: number;
+    maxYear?: number;
+};
+type ValidateDateFunction = (rawDate: string, config?: ValidateDateConfig) => boolean;
+/**
+ * Validates a date string based on the provided format and configuration.
+ *
+ * @param rawDate - The date string to validate.
+ * @param config - Optional configuration object to customize validation.
+ * @param config.inputFormat - The expected format of the input date.
+ *                            Supported formats are "DD/MM/YYYY", "MM-DD-YYYY", and "YYYY-MM-DD".
+ *                            Defaults to "DD/MM/YYYY".
+ * @param config.minYear - The minimum allowed year for the date. Defaults to 1900.
+ * @param config.maxYear - The maximum allowed year for the date. Defaults to 3000.
+ *
+ * @returns `true` if the date is valid according to the specified format and configuration, otherwise `false`.
+ *
+ * @throws {Error} If an invalid date format is provided in the configuration.
+ *
+ * @example
+ * ```typescript
+ * validateDate("31/12/2023"); // true
+ * validateDate("12-31-2023", { inputFormat: "MM-DD-YYYY" }); // true
+ * validateDate("2023-12-31", { inputFormat: "YYYY-MM-DD", minYear: 2000, maxYear: 2100 }); // true
+ * validateDate("29/02/2024", { inputFormat: "DD/MM/YYYY" }); // true (leap year)
+ * validateDate("29/02/2023", { inputFormat: "DD/MM/YYYY" }); // false (not a leap year)
+ * validateDate("31/04/2023", { inputFormat: "DD/MM/YYYY" }); // false (April has 30 days)
+ * ```
+ */
+declare const validateDate: ValidateDateFunction;
+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":"AAAA,KAAK,kBAAkB,GAAG;IACxB,WAAW,CAAC,EAAE,YAAY,GAAG,YAAY,GAAG,YAAY,CAAC;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,KAAK,oBAAoB,GAAG,CAC1B,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,kBAAkB,KACxB,OAAO,CAAC;AAEb;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,QAAA,MAAM,YAAY,EAAE,oBA8CnB,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/validations/validateDate.js

@@ -0,0 +1,73 @@
+/**
+ * Validates a date string based on the provided format and configuration.
+ *
+ * @param rawDate - The date string to validate.
+ * @param config - Optional configuration object to customize validation.
+ * @param config.inputFormat - The expected format of the input date.
+ *                            Supported formats are "DD/MM/YYYY", "MM-DD-YYYY", and "YYYY-MM-DD".
+ *                            Defaults to "DD/MM/YYYY".
+ * @param config.minYear - The minimum allowed year for the date. Defaults to 1900.
+ * @param config.maxYear - The maximum allowed year for the date. Defaults to 3000.
+ *
+ * @returns `true` if the date is valid according to the specified format and configuration, otherwise `false`.
+ *
+ * @throws {Error} If an invalid date format is provided in the configuration.
+ *
+ * @example
+ * ```typescript
+ * validateDate("31/12/2023"); // true
+ * validateDate("12-31-2023", { inputFormat: "MM-DD-YYYY" }); // true
+ * validateDate("2023-12-31", { inputFormat: "YYYY-MM-DD", minYear: 2000, maxYear: 2100 }); // true
+ * validateDate("29/02/2024", { inputFormat: "DD/MM/YYYY" }); // true (leap year)
+ * validateDate("29/02/2023", { inputFormat: "DD/MM/YYYY" }); // false (not a leap year)
+ * validateDate("31/04/2023", { inputFormat: "DD/MM/YYYY" }); // false (April has 30 days)
+ * ```
+ */
+const validateDate = (rawDate, config) => {
+    let day, month, year;
+    const inputFormat = config?.inputFormat || "DD/MM/YYYY";
+    const minYear = config?.minYear || 1900;
+    const maxYear = config?.maxYear || 3000;
+    if (inputFormat === "DD/MM/YYYY") {
+        const dateRegex = /^(\d{2})\/(\d{2})\/(\d{4})$/;
+        if (!dateRegex.test(rawDate))
+            return false;
+        [, day, month, year] = rawDate.match(dateRegex) || [];
+    }
+    else if (inputFormat === "MM-DD-YYYY") {
+        const dateRegex = /^(\d{2})-(\d{2})-(\d{4})$/;
+        if (!dateRegex.test(rawDate))
+            return false;
+        [, month, day, year] = rawDate.match(dateRegex) || [];
+    }
+    else if (inputFormat === "YYYY-MM-DD") {
+        const dateRegex = /^(\d{4})-(\d{2})-(\d{2})$/;
+        if (!dateRegex.test(rawDate))
+            return false;
+        [, year, month, day] = rawDate.match(dateRegex) || [];
+    }
+    else {
+        throw new Error("Invalid date format");
+    }
+    const dayNum = parseInt(day, 10);
+    const monthNum = parseInt(month, 10);
+    const yearNum = parseInt(year, 10);
+    if (dayNum < 1 || dayNum > 31)
+        return false;
+    if (monthNum < 1 || monthNum > 12)
+        return false;
+    const daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    if (monthNum === 2) {
+        const isLeapYear = (yearNum % 4 === 0 && yearNum % 100 !== 0) || yearNum % 400 === 0;
+        if (dayNum > (isLeapYear ? 29 : 28))
+            return false;
+    }
+    else if (dayNum > daysInMonth[monthNum - 1]) {
+        return false;
+    }
+    if (yearNum < minYear || yearNum > maxYear)
+        return false;
+    const isValidDate = new Date(yearNum, monthNum - 1, dayNum).getDate() === dayNum;
+    return isValidDate;
+};
+export { validateDate };

package/dist/validations/validateEmail.d.ts

@@ -0,0 +1,22 @@
+type ValidateEmailFunction = (rawEmail: string) => Promise<boolean>;
+/**
+ * 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 string to validate
+ * @returns 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 const validateEmail: ValidateEmailFunction;
+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":"AAEA,KAAK,qBAAqB,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAmGpE;;;;;;;;;;;;;;;;;GAiBG;AAEH,QAAA,MAAM,aAAa,EAAE,qBAYpB,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,CAAC"}