@arkyn/server 3.0.1-beta.10 → 3.0.1-beta.101

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"}

package/dist/validations/validateEmail.js

@@ -0,0 +1,123 @@
+import dns from "node:dns";
+// const resolveDns = dns.promises.resolve;
+// Validates basic email format using a comprehensive regex pattern
+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);
+}
+// Validates the local part of email (before @)
+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;
+}
+// Validates a single domain label
+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;
+}
+// Validates the domain part of email (after @)
+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;
+}
+// Performs advanced syntax validation beyond basic regex
+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;
+}
+// Extracts the domain from email address
+function extractDomain(email) {
+    const parts = email.split("@");
+    return parts.length === 2 ? parts[1].toLowerCase() : null;
+}
+// DNS record types to check for domain validation
+const DNS_RECORD_TYPES = ["MX", "A", "AAAA"];
+// Attempts to resolve a specific DNS record type for a domain
+// async function tryResolveDnsRecord(
+//   domain: string,
+//   recordType: string
+// ): Promise<boolean> {
+//   try {
+//     await resolveDns(domain, recordType);
+//     return true;
+//   } catch {
+//     return false;
+//   }
+// }
+// Validates if domain has valid DNS records (MX, A, or AAAA records)
+// async function isValidDns(domain: string): Promise<boolean> {
+//   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 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)
+ * ```
+ */
+const validateEmail = async (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);
+    return true;
+};
+export { validateEmail };

package/dist/validations/validatePassword.d.ts

@@ -0,0 +1,21 @@
+type ValidatePasswordFunction = (rawPassword: string) => boolean;
+/**
+ * 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 rawPassword - The raw password string.
+ * @returns `true` if password is valid, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * validatePassword("Senha@123"); // true
+ * validatePassword("senha123");  // false (no uppercase, no special char)
+ * ```
+ */
+declare const validatePassword: ValidatePasswordFunction;
+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,KAAK,wBAAwB,GAAG,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC;AAEjE;;;;;;;;;;;;;;;;GAgBG;AAEH,QAAA,MAAM,gBAAgB,EAAE,wBAkBvB,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/validations/validatePassword.js

@@ -0,0 +1,34 @@
+/**
+ * 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 rawPassword - The raw password string.
+ * @returns `true` if password is valid, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * validatePassword("Senha@123"); // true
+ * validatePassword("senha123");  // false (no uppercase, no special char)
+ * ```
+ */
+const validatePassword = (rawPassword) => {
+    if (!rawPassword)
+        return false;
+    const hasMinLength = rawPassword.length >= 8;
+    const hasUppercase = /[A-Z]/.test(rawPassword);
+    const hasLetter = /[a-z]/.test(rawPassword);
+    const hasNumber = /\d/.test(rawPassword);
+    const hasSpecialChar = /[!@#$%^&*(),.?":{}|<>_\-+=~`[\]\\\/]/.test(rawPassword);
+    return [
+        hasMinLength,
+        hasUppercase,
+        hasLetter,
+        hasNumber,
+        hasSpecialChar,
+    ].every((condition) => condition);
+};
+export { validatePassword };

package/dist/validations/validatePhone.d.ts

@@ -0,0 +1,29 @@
+type ValidatePhoneFunction = (rawPhone: string) => boolean;
+/**
+ * Validates a phone number against a list of country-specific formats.
+ *
+ * The function iterates through a predefined list of countries and checks if the
+ * provided phone number matches the format for any of the countries. It uses
+ * regular expressions to validate the phone number based on the country's code,
+ * prefix, and mask.
+ *
+ * Special handling is applied for Brazilian phone numbers (ISO code "BR"), which
+ * allows for an optional ninth digit.
+ *
+ * @param rawPhone - The phone number to validate as a string.
+ * @returns `true` if the phone number matches any country's format, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * import { validatePhone } from "./validatePhone";
+ *
+ * validatePhone("+55 32912345678"); // true for a valid Brazilian phone number
+ * validatePhone("+55 3212345678"); // true for a valid Brazilian phone number
+ * validatePhone("+1-684 1234567"); // true for a valid American Samoa phone number
+ * validatePhone("+5532912345678"); // false for an invalid Brazilian phone number
+ * validatePhone("+55 1234567890"); // false for an invalid Brazilian phone number
+ * ```
+ */
+declare const validatePhone: ValidatePhoneFunction;
+export { validatePhone };
+//# sourceMappingURL=validatePhone.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validatePhone.d.ts","sourceRoot":"","sources":["../../src/validations/validatePhone.ts"],"names":[],"mappings":"AAEA,KAAK,qBAAqB,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,QAAA,MAAM,aAAa,EAAE,qBAiBpB,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/validations/validatePhone.js

@@ -0,0 +1,44 @@
+import { countries } from "@arkyn/templates";
+/**
+ * Validates a phone number against a list of country-specific formats.
+ *
+ * The function iterates through a predefined list of countries and checks if the
+ * provided phone number matches the format for any of the countries. It uses
+ * regular expressions to validate the phone number based on the country's code,
+ * prefix, and mask.
+ *
+ * Special handling is applied for Brazilian phone numbers (ISO code "BR"), which
+ * allows for an optional ninth digit.
+ *
+ * @param rawPhone - The phone number to validate as a string.
+ * @returns `true` if the phone number matches any country's format, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * import { validatePhone } from "./validatePhone";
+ *
+ * validatePhone("+55 32912345678"); // true for a valid Brazilian phone number
+ * validatePhone("+55 3212345678"); // true for a valid Brazilian phone number
+ * validatePhone("+1-684 1234567"); // true for a valid American Samoa phone number
+ * validatePhone("+5532912345678"); // false for an invalid Brazilian phone number
+ * validatePhone("+55 1234567890"); // false for an invalid Brazilian phone number
+ * ```
+ */
+const validatePhone = (rawPhone) => {
+    for (const country of countries) {
+        const countryCode = country.code;
+        const prefix = country.prefix ? `-${country.prefix}` : "";
+        const digitCount = country.mask.replace(/[^_]/g, "").length;
+        if (country.iso === "BR") {
+            const brazilRegex = new RegExp(`^\\${countryCode} \\d{2}9?\\d{8}$`);
+            if (brazilRegex.test(rawPhone))
+                return true;
+            continue;
+        }
+        const regex = new RegExp(`^\\${countryCode}${prefix} \\d{${digitCount}}$`);
+        if (regex.test(rawPhone))
+            return true;
+    }
+    return false;
+};
+export { validatePhone };

package/dist/validations/validateRg.d.ts

@@ -0,0 +1,22 @@
+type ValidateRgFunction = (rawRg: string) => boolean;
+/**
+ * Validates a Brazilian RG (Registro Geral) in a generic way.
+ *
+ * This function does a basic structure validation:
+ * - Removes non-alphanumeric characters.
+ * - Ensures length is reasonable (7–9 digits).
+ * - Optionally allows for a final letter (verifier).
+ *
+ * @param rawRg - RG string, possibly formatted.
+ * @returns `true` if format seems valid, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * validateRg("12.345.678-9"); // true
+ * validateRg("MG-12.345.678"); // false (not supported)
+ * validateRg("12345678X"); // true
+ * ```
+ */
+declare const validateRg: ValidateRgFunction;
+export { validateRg };
+//# sourceMappingURL=validateRg.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validateRg.d.ts","sourceRoot":"","sources":["../../src/validations/validateRg.ts"],"names":[],"mappings":"AAAA,KAAK,kBAAkB,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;AAErD;;;;;;;;;;;;;;;;;GAiBG;AAEH,QAAA,MAAM,UAAU,EAAE,kBAajB,CAAC;AAEF,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/validations/validateRg.js

@@ -0,0 +1,31 @@
+/**
+ * Validates a Brazilian RG (Registro Geral) in a generic way.
+ *
+ * This function does a basic structure validation:
+ * - Removes non-alphanumeric characters.
+ * - Ensures length is reasonable (7–9 digits).
+ * - Optionally allows for a final letter (verifier).
+ *
+ * @param rawRg - RG string, possibly formatted.
+ * @returns `true` if format seems valid, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * validateRg("12.345.678-9"); // true
+ * validateRg("MG-12.345.678"); // false (not supported)
+ * validateRg("12345678X"); // true
+ * ```
+ */
+const validateRg = (rawRg) => {
+    if (!rawRg)
+        return false;
+    const validFormat = /^[0-9a-zA-Z.-]+$/.test(rawRg);
+    if (!validFormat)
+        return false;
+    const rg = rawRg.replace(/[^a-zA-Z0-9]/g, "");
+    if (rg.length < 7 || rg.length > 9)
+        return false;
+    const isValidFormat = /^[0-9]{7,8}[0-9Xx]?$/.test(rg);
+    return isValidFormat;
+};
+export { validateRg };

package/package.json

@@ -1,29 +1,45 @@
 {
   "name": "@arkyn/server",
-  "version": "3.0.1-beta.10",
+  "version": "3.0.1-beta.101",
   "author": "Arkyn | Lucas Gonçalves",
   "main": "./dist/bundle.js",
-  "module": "./src/index.ts",
-  "dependencies": {
-    "@arkyn/shared": "*",
-    "zod": ">=3.24.2"
-  },
-  "devDependencies": {
-    "bun-types": "latest",
-    "vitest": "^3.1.1",
-    "typescript": "^5.8.3"
-  },
-  "peerDependencies": {
-    "@react-router/node": ">=7.6.0"
-  },
-  "description": "Server-side utilities for projects.",
+  "module": "./dist/bundle.js",
+  "type": "module",
+  "types": "./dist/index.d.ts",
   "license": "Apache-2.0",
+  "description": "Comprehensive server-side utilities for building robust backend applications, featuring HTTP response helpers, error handlers, request utilities, and API configurations.",
+  "keywords": [
+    "server",
+    "http",
+    "api",
+    "utilities",
+    "error-handling",
+    "validation",
+    "remix",
+    "typescript",
+    "zod"
+  ],
+  "homepage": "https://docs.arkyn.dev/en/server/introduction",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Lucas-Eduardo-Goncalves/arkyn.git",
+    "directory": "packages/server"
+  },
   "scripts": {
     "clean": "rm -rf dist",
-    "build": "bun run clean && bunx tsc --project tsconfig.json",
+    "build": "bunx vite build && tsc",
     "test": "vitest --config vitest.config.ts",
     "typecheck": "bunx tsc --project tsconfig.json --noEmit"
   },
-  "type": "module",
-  "types": "./dist/index.d.ts"
+  "peerDependencies": {
+    "@arkyn/shared": "*",
+    "@arkyn/templates": "*",
+    "zod": ">=4.0.17"
+  },
+  "devDependencies": {
+    "bun-types": "latest",
+    "vitest": "^3.2.4",
+    "typescript": "^5.9.2",
+    "vite": "^5.4.19"
+  }
 }

package/dist/config/apiInstance.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"apiInstance.d.ts","sourceRoot":"","sources":["../../src/config/apiInstance.ts"],"names":[],"mappings":"AAMA,KAAK,0BAA0B,GAAG;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B,CAAC;AAEF,KAAK,8BAA8B,GAAG;IACpC,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,KAAK,2BAA2B,GAAG;IACjC,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;GAEG;AAEH,cAAM,WAAW;IACf,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,WAAW,CAAC,CAAc;IAClC,OAAO,CAAC,SAAS,CAAC,CAAS;IAE3B;;;;;;OAMG;gBAES,KAAK,EAAE,0BAA0B;IAM7C;;;;OAIG;IAEH,OAAO,CAAC,WAAW;IAInB;;;;;OAKG;IAEH,OAAO,CAAC,eAAe;IAcvB;;;;;OAKG;IAEG,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,8BAA8B;IAM9D;;;;;OAKG;IAEG,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,2BAA2B;IAO5D;;;;;OAKG;IAEG,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,2BAA2B;IAO3D;;;;;OAKG;IAEG,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,2BAA2B;IAO7D;;;;;OAKG;IAEG,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,2BAA2B;CAM/D;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/config/arkynLogInstance.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"arkynLogInstance.d.ts","sourceRoot":"","sources":["../../src/config/arkynLogInstance.ts"],"names":[],"mappings":"AAAA,KAAK,gBAAgB,GAAG;IACtB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,KAAK,mBAAmB,GAAG;IACzB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAEF;;;;GAIG;AAEH,cAAM,gBAAgB;IACpB,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,CAAmB;IAE9C;;;;;;;;;;OAUG;IAEH,MAAM,CAAC,cAAc,CAAC,WAAW,EAAE,mBAAmB;IAgBtD;;;;;OAKG;IACH,MAAM,CAAC,cAAc,IAAI,gBAAgB,GAAG,SAAS;IAIrD;;;OAGG;IAEH,MAAM,CAAC,gBAAgB;CAGxB;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/services/httpDebug.d.ts

@@ -1,35 +0,0 @@
-/**
- * Logs debug information to the console when in development mode or when the
- * `SHOW_ERRORS_IN_CONSOLE` environment variable is set to "true".
- *
- * This function provides detailed information about the caller function,
- * its location, and the provided body and cause, if any.
- *
- * @param name - A string representing the name or context of the debug log.
- * @param body - The main content or data to be logged.
- * @param cause - (Optional) Additional information or error cause to be logged.
- *
- * @remarks
- * The debug logs are only displayed when the application is running in
- * development mode (`NODE_ENV === "development"`) or when the
- * `SHOW_ERRORS_IN_CONSOLE` environment variable is explicitly set to "true".
- *
- * The logs include:
- * - The name of the debug context.
- * - The caller function name and its location.
- * - The provided body content.
- * - The optional cause, if provided.
- *
- * @example
- * ```typescript
- * httpDebug("FetchUserData", { userId: 123 });
- * ```
- *
- * @example
- * ```typescript
- * httpDebug("FetchUserDataError", { userId: 123 }, new Error("User not found"));
- * ```
- */
-declare function httpDebug(name: string, body: any, cause?: any): void;
-export { httpDebug };
-//# sourceMappingURL=httpDebug.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"httpDebug.d.ts","sourceRoot":"","sources":["../../src/services/httpDebug.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,iBAAS,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,GAAG,QAuBtD;AAED,OAAO,EAAE,SAAS,EAAE,CAAC"}

package/dist/services/httpDebug.js

@@ -1,52 +0,0 @@
-import { getCaller } from "../services/getCaller";
-/**
- * Logs debug information to the console when in development mode or when the
- * `SHOW_ERRORS_IN_CONSOLE` environment variable is set to "true".
- *
- * This function provides detailed information about the caller function,
- * its location, and the provided body and cause, if any.
- *
- * @param name - A string representing the name or context of the debug log.
- * @param body - The main content or data to be logged.
- * @param cause - (Optional) Additional information or error cause to be logged.
- *
- * @remarks
- * The debug logs are only displayed when the application is running in
- * development mode (`NODE_ENV === "development"`) or when the
- * `SHOW_ERRORS_IN_CONSOLE` environment variable is explicitly set to "true".
- *
- * The logs include:
- * - The name of the debug context.
- * - The caller function name and its location.
- * - The provided body content.
- * - The optional cause, if provided.
- *
- * @example
- * ```typescript
- * httpDebug("FetchUserData", { userId: 123 });
- * ```
- *
- * @example
- * ```typescript
- * httpDebug("FetchUserDataError", { userId: 123 }, new Error("User not found"));
- * ```
- */
-function httpDebug(name, body, cause) {
-    const isDebugMode = process.env.NODE_ENV === "development" ||
-        process.env?.SHOW_ERRORS_IN_CONSOLE === "true";
-    if (isDebugMode) {
-        const reset = "\x1b[0m";
-        const cyan = "\x1b[36m";
-        const debugName = `${cyan}[ARKYN-DEBUG]${reset}`;
-        const { callerInfo, functionName } = getCaller();
-        let consoleData = `${debugName} ${name} initialized\n`;
-        consoleData += `${debugName} Caller Function: ${functionName}\n`;
-        consoleData += `${debugName} Caller Location: ${callerInfo}\n`;
-        consoleData += `${debugName} Body: ${JSON.stringify(body, null, 2)}\n`;
-        if (cause) {
-            consoleData += `${debugName} Cause: ${JSON.stringify(cause, null, 2)}\n`;
-        }
-        console.log(consoleData);
-    }
-}
-export { httpDebug };