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

package/dist/{config/arkynLogInstance.js → services/arkynLogService.js}

@@ -1,9 +1,9 @@
 /**
- * The `ArkynLogInstance` class manages the configuration for the arkyn flow.
+ * The `ArkynLogService` class manages the configuration for the arkyn flow.
  * It allows you to set and retrieve the arkyn configuration, including the traffic source ID,
  * user token, and API URL.
  */
-class ArkynLogInstance {
+class ArkynLogService {
     static arkynConfig;
     /**
      * Sets the configuration for the arkyn. This method initializes the arkyn configuration
@@ -19,18 +19,15 @@ class ArkynLogInstance {
     static setArkynConfig(arkynConfig) {
         if (!!this.arkynConfig)
             return;
-        let defaultArkynURL = `https://logs-arkyn-flow-logs.vw6wo7.easypanel.host`;
-        let arkynLogBaseApiUrl = arkynConfig.arkynLogBaseApiUrl || defaultArkynURL;
-        arkynLogBaseApiUrl =
-            arkynLogBaseApiUrl + "/http-traffic-records/:trafficSourceId";
+        const { trafficSourceId, userToken, logBaseApiUrl } = arkynConfig;
         this.arkynConfig = {
-            arkynTrafficSourceId: arkynConfig.arkynTrafficSourceId,
-            arkynUserToken: arkynConfig.arkynUserToken,
-            arkynApiUrl: arkynLogBaseApiUrl,
+            trafficSourceId,
+            userToken,
+            apiUrl: logBaseApiUrl || `http://95.216.190.158:8081/ingest-log`,
         };
     }
     /**
-     * Retrieves the current arkyn configuration for the ArkynLogInstance.
+     * Retrieves the current arkyn configuration for the ArkynLogService.
      *
      * @returns {ArkynConfigProps | undefined} The current arkyn configuration if set,
      * or `undefined` if no configuration has been initialized.
@@ -46,4 +43,4 @@ class ArkynLogInstance {
         this.arkynConfig = undefined;
     }
 }
-export { ArkynLogInstance };
+export { ArkynLogService };

package/dist/services/debugService.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Service for managing HTTP debug configuration and behavior.
+ *
+ * This service provides functionality to configure how the `getCaller` function
+ * identifies the actual caller in the stack trace by allowing specific files
+ * to be ignored during stack trace analysis.
+ *
+ * @example
+ * ```typescript
+ * // Configure to ignore httpAdapter.ts in stack traces
+ * HttpDebugService.setIgnoreFile("httpAdapter.ts");
+ *
+ * // Now when httpDebug is called from within httpAdapter.ts,
+ * // it will show the actual caller (e.g., cart.ts) instead
+ * ```
+ */
+declare class DebugService {
+    /**
+     * The name of the file to ignore when analyzing the stack trace.
+     * When set, the `getCaller` function will skip stack frames containing this file name.
+     */
+    static ignoreFiles: string[];
+    /**
+     * Sets the file name to be ignored during stack trace analysis.
+     *
+     * This method configures the debug service to skip specific files when
+     * determining the actual caller of a function. This is useful when you have
+     * adapter or wrapper functions that you want to be transparent in the debug output.
+     *
+     * @param file - The name of the file to ignore in stack traces (e.g., "httpAdapter.ts")
+     *
+     * @example
+     * ```typescript
+     * // Ignore the HTTP adapter file so debug shows the actual business logic caller
+     * DebugService.setIgnoreFile("httpAdapter.ts");
+     * ```
+     */
+    static setIgnoreFile(file: string): void;
+    /**
+     * Clears all configured ignore files.
+     *
+     * This method resets the ignore file configuration, allowing all files to be
+     * considered in stack trace analysis again.
+     *
+     * @example
+     * ```typescript
+     * // Clear all ignore file configurations
+     * DebugService.clearIgnoreFiles();
+     * ```
+     */
+    static clearIgnoreFiles(): void;
+}
+export { DebugService };
+//# sourceMappingURL=debugService.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"debugService.d.ts","sourceRoot":"","sources":["../../src/services/debugService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,cAAM,YAAY;IAChB;;;OAGG;IACH,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,CAAM;IAElC;;;;;;;;;;;;;;OAcG;IAEH,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE,MAAM;IAIjC;;;;;;;;;;;OAWG;IAEH,MAAM,CAAC,gBAAgB;CAGxB;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/services/debugService.js

@@ -0,0 +1,57 @@
+/**
+ * Service for managing HTTP debug configuration and behavior.
+ *
+ * This service provides functionality to configure how the `getCaller` function
+ * identifies the actual caller in the stack trace by allowing specific files
+ * to be ignored during stack trace analysis.
+ *
+ * @example
+ * ```typescript
+ * // Configure to ignore httpAdapter.ts in stack traces
+ * HttpDebugService.setIgnoreFile("httpAdapter.ts");
+ *
+ * // Now when httpDebug is called from within httpAdapter.ts,
+ * // it will show the actual caller (e.g., cart.ts) instead
+ * ```
+ */
+class DebugService {
+    /**
+     * The name of the file to ignore when analyzing the stack trace.
+     * When set, the `getCaller` function will skip stack frames containing this file name.
+     */
+    static ignoreFiles = [];
+    /**
+     * Sets the file name to be ignored during stack trace analysis.
+     *
+     * This method configures the debug service to skip specific files when
+     * determining the actual caller of a function. This is useful when you have
+     * adapter or wrapper functions that you want to be transparent in the debug output.
+     *
+     * @param file - The name of the file to ignore in stack traces (e.g., "httpAdapter.ts")
+     *
+     * @example
+     * ```typescript
+     * // Ignore the HTTP adapter file so debug shows the actual business logic caller
+     * DebugService.setIgnoreFile("httpAdapter.ts");
+     * ```
+     */
+    static setIgnoreFile(file) {
+        this.ignoreFiles.push(file);
+    }
+    /**
+     * Clears all configured ignore files.
+     *
+     * This method resets the ignore file configuration, allowing all files to be
+     * considered in stack trace analysis again.
+     *
+     * @example
+     * ```typescript
+     * // Clear all ignore file configurations
+     * DebugService.clearIgnoreFiles();
+     * ```
+     */
+    static clearIgnoreFiles() {
+        this.ignoreFiles = [];
+    }
+}
+export { DebugService };

package/dist/services/flushDebugLogs.d.ts

@@ -0,0 +1,8 @@
+type FlushDebugLogsProps = {
+    scheme: "yellow" | "cyan" | "red" | "green";
+    name: string;
+    debugs: string[];
+};
+declare function flushDebugLogs(props: FlushDebugLogsProps): void;
+export { flushDebugLogs };
+//# sourceMappingURL=flushDebugLogs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flushDebugLogs.d.ts","sourceRoot":"","sources":["../../src/services/flushDebugLogs.ts"],"names":[],"mappings":"AAAA,KAAK,mBAAmB,GAAG;IACzB,MAAM,EAAE,QAAQ,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,CAAC;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,iBAAS,cAAc,CAAC,KAAK,EAAE,mBAAmB,QAwBjD;AAED,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/services/flushDebugLogs.js

@@ -0,0 +1,20 @@
+function flushDebugLogs(props) {
+    const isDebugMode = process.env.NODE_ENV === "development" ||
+        process.env?.SHOW_ERRORS_IN_CONSOLE === "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) => {
+            consoleData += `${debugName} ${debug.trim()}\n`;
+        });
+        console.log(consoleData);
+    }
+}
+export { flushDebugLogs };

package/{src/services/formParse.ts → dist/services/formAsyncParse.d.ts}

@@ -1,24 +1,23 @@
-import type { Schema } from "zod";
-
+import type { ZodType } from "zod";
 type SuccessResponse<T extends FormParseProps> = {
-  success: true;
-  data: T[1] extends Schema<infer U> ? U : never;
+    success: true;
+    data: T[1] extends ZodType<infer U> ? U : never;
 };
-
 type ErrorResponse = {
-  success: false;
-  fields: { [x: string]: string };
-  fieldErrors: { [x: string]: string };
+    success: false;
+    fields: {
+        [x: string]: string;
+    };
+    fieldErrors: {
+        [x: string]: string;
+    };
 };
-
-type FormParseProps = [formData: { [k: string]: any }, schema: Schema];
-
-type FormParseReturnType<T extends FormParseProps> =
-  | SuccessResponse<T>
-  | ErrorResponse;
-
+type FormParseProps = [formData: {
+    [k: string]: any;
+}, schema: ZodType];
+type FormParseReturnType<T extends FormParseProps> = SuccessResponse<T> | ErrorResponse;
 /**
- * Parses form data using a Zod schema and returns the result.
+ * Asynchronously parses form data using a Zod schema and returns the result.
  *
  * @template T - A type that extends `FormParseProps`.
  *
@@ -26,7 +25,7 @@ type FormParseReturnType<T extends FormParseProps> =
  * @param {T[0]} param0[0] - The form data to be validated.
  * @param {T[1]} param0[1] - The Zod schema used for validation.
  *
- * @returns {FormParseReturnType<T>} An object containing the validation result.
+ * @returns {Promise<FormParseReturnType<T>>} A promise that resolves to an object containing the validation result.
  * - If validation fails, it includes:
  *   - `success`: A boolean indicating the validation status (false).
  *   - `fieldErrors`: An object mapping field names to their respective error messages.
@@ -46,7 +45,7 @@ type FormParseReturnType<T extends FormParseProps> =
  *
  * const formData = { name: "", age: 17 };
  *
- * const result = formParse([formData, schema]);
+ * const result = await formAsyncParse([formData, schema]);
  *
  * if (!result.success) {
  *   console.log(result.fieldErrors); // { name: "Name is required", age: "Must be at least 18" }
@@ -55,29 +54,6 @@ type FormParseReturnType<T extends FormParseProps> =
  * }
  * ```
  */
-
-function formParse<T extends FormParseProps>([
-  formData,
-  schema,
-]: T): FormParseReturnType<T> {
-  const zodResponse = schema.safeParse(formData);
-
-  if (zodResponse.success === false) {
-    const errorsObject = Object.fromEntries(
-      zodResponse.error.errors.map((item) => [
-        item.path.join("."),
-        item.message,
-      ])
-    );
-
-    return {
-      success: zodResponse.success,
-      fieldErrors: errorsObject,
-      fields: formData,
-    };
-  } else {
-    return { success: zodResponse.success, data: zodResponse.data };
-  }
-}
-
-export { formParse };
+declare function formAsyncParse<T extends FormParseProps>([formData, schema,]: T): Promise<FormParseReturnType<T>>;
+export { formAsyncParse };
+//# sourceMappingURL=formAsyncParse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"formAsyncParse.d.ts","sourceRoot":"","sources":["../../src/services/formAsyncParse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;AAEnC,KAAK,eAAe,CAAC,CAAC,SAAS,cAAc,IAAI;IAC/C,OAAO,EAAE,IAAI,CAAC;IACd,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;CACjD,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,OAAO,EAAE,KAAK,CAAC;IACf,MAAM,EAAE;QAAE,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IAChC,WAAW,EAAE;QAAE,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;CACtC,CAAC;AAEF,KAAK,cAAc,GAAG,CAAC,QAAQ,EAAE;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;AAExE,KAAK,mBAAmB,CAAC,CAAC,SAAS,cAAc,IAC7C,eAAe,CAAC,CAAC,CAAC,GAClB,aAAa,CAAC;AAElB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,iBAAe,cAAc,CAAC,CAAC,SAAS,cAAc,EAAE,CACtD,QAAQ,EACR,MAAM,EACP,EAAE,CAAC,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAqBrC;AAED,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/services/formAsyncParse.js

@@ -0,0 +1,58 @@
+/**
+ * Asynchronously parses form data using a Zod schema and returns the result.
+ *
+ * @template T - A type that extends `FormParseProps`.
+ *
+ * @param {T} param0 - An array containing the form data and the Zod schema.
+ * @param {T[0]} param0[0] - The form data to be validated.
+ * @param {T[1]} param0[1] - The Zod schema used for validation.
+ *
+ * @returns {Promise<FormParseReturnType<T>>} A promise that resolves to an object containing the validation result.
+ * - If validation fails, it includes:
+ *   - `success`: A boolean indicating the validation status (false).
+ *   - `fieldErrors`: An object mapping field names to their respective error messages.
+ *   - `fields`: The original form data.
+ * - If validation succeeds, it includes:
+ *   - `success`: A boolean indicating the validation status (true).
+ *   - `data`: The parsed and validated data.
+ *
+ * @example
+ * ```typescript
+ * import { z } from "zod";
+ *
+ * const schema = z.object({
+ *   name: z.string().min(1, "Name is required"),
+ *   age: z.number().min(18, "Must be at least 18"),
+ * });
+ *
+ * const formData = { name: "", age: 17 };
+ *
+ * const result = await formAsyncParse([formData, schema]);
+ *
+ * if (!result.success) {
+ *   console.log(result.fieldErrors); // { name: "Name is required", age: "Must be at least 18" }
+ * } else {
+ *   console.log(result.data); // Parsed data
+ * }
+ * ```
+ */
+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/services/formParse.d.ts

@@ -1,7 +1,7 @@
-import type { Schema } from "zod";
+import type { ZodType } from "zod";
 type SuccessResponse<T extends FormParseProps> = {
     success: true;
-    data: T[1] extends Schema<infer U> ? U : never;
+    data: T[1] extends ZodType<infer U> ? U : never;
 };
 type ErrorResponse = {
     success: false;
@@ -14,7 +14,7 @@ type ErrorResponse = {
 };
 type FormParseProps = [formData: {
     [k: string]: any;
-}, schema: Schema];
+}, schema: ZodType];
 type FormParseReturnType<T extends FormParseProps> = SuccessResponse<T> | ErrorResponse;
 /**
  * Parses form data using a Zod schema and returns the result.

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

@@ -1 +1 @@
-{"version":3,"file":"formParse.d.ts","sourceRoot":"","sources":["../../src/services/formParse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,KAAK,CAAC;AAElC,KAAK,eAAe,CAAC,CAAC,SAAS,cAAc,IAAI;IAC/C,OAAO,EAAE,IAAI,CAAC;IACd,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;CAChD,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,OAAO,EAAE,KAAK,CAAC;IACf,MAAM,EAAE;QAAE,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IAChC,WAAW,EAAE;QAAE,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;CACtC,CAAC;AAEF,KAAK,cAAc,GAAG,CAAC,QAAQ,EAAE;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAEvE,KAAK,mBAAmB,CAAC,CAAC,SAAS,cAAc,IAC7C,eAAe,CAAC,CAAC,CAAC,GAClB,aAAa,CAAC;AAElB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,iBAAS,SAAS,CAAC,CAAC,SAAS,cAAc,EAAE,CAC3C,QAAQ,EACR,MAAM,EACP,EAAE,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAmB5B;AAED,OAAO,EAAE,SAAS,EAAE,CAAC"}
+{"version":3,"file":"formParse.d.ts","sourceRoot":"","sources":["../../src/services/formParse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;AAEnC,KAAK,eAAe,CAAC,CAAC,SAAS,cAAc,IAAI;IAC/C,OAAO,EAAE,IAAI,CAAC;IACd,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;CACjD,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,OAAO,EAAE,KAAK,CAAC;IACf,MAAM,EAAE;QAAE,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IAChC,WAAW,EAAE;QAAE,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;CACtC,CAAC;AAEF,KAAK,cAAc,GAAG,CAAC,QAAQ,EAAE;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;AAExE,KAAK,mBAAmB,CAAC,CAAC,SAAS,cAAc,IAC7C,eAAe,CAAC,CAAC,CAAC,GAClB,aAAa,CAAC;AAElB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,iBAAS,SAAS,CAAC,CAAC,SAAS,cAAc,EAAE,CAC3C,QAAQ,EACR,MAAM,EACP,EAAE,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAqB5B;AAED,OAAO,EAAE,SAAS,EAAE,CAAC"}

package/dist/services/formParse.js

@@ -39,10 +39,9 @@
 function formParse([formData, schema,]) {
     const zodResponse = schema.safeParse(formData);
     if (zodResponse.success === false) {
-        const errorsObject = Object.fromEntries(zodResponse.error.errors.map((item) => [
-            item.path.join("."),
-            item.message,
-        ]));
+        const errorsObject = Object.fromEntries(zodResponse.error.issues.map((item) => {
+            return [item.path.join("."), item.message];
+        }));
         return {
             success: zodResponse.success,
             fieldErrors: errorsObject,
@@ -50,7 +49,10 @@ function formParse([formData, schema,]) {
         };
     }
     else {
-        return { success: zodResponse.success, data: zodResponse.data };
+        return {
+            success: zodResponse.success,
+            data: zodResponse.data,
+        };
     }
 }
 export { formParse };

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

@@ -1 +1 @@
-{"version":3,"file":"getCaller.d.ts","sourceRoot":"","sources":["../../src/services/getCaller.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,iBAAS,SAAS;;;EAkEjB;AAED,OAAO,EAAE,SAAS,EAAE,CAAC"}
+{"version":3,"file":"getCaller.d.ts","sourceRoot":"","sources":["../../src/services/getCaller.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AAEH,iBAAS,SAAS;;;EAiEjB;AAED,OAAO,EAAE,SAAS,EAAE,CAAC"}

package/dist/services/getCaller.js

@@ -1,4 +1,5 @@
 import path from "path";
+import { DebugService } from "./debugService";
 /**
  * Retrieves information about the caller of the current function.
  *
@@ -15,51 +16,45 @@ function getCaller() {
     const err = new Error();
     const stack = err.stack || "";
     const stackLines = stack.split("\n").map((line) => line.trim());
-    // The first line is the error message
-    // The second line is this function (getCaller)
-    // The third line should be the direct caller
-    // We start from 2 because indexes are zero-based
+    const ignoreFiles = DebugService.ignoreFiles;
     let callerIndex = 2;
-    // Ignore internal or infrastructure lines if necessary
     while (callerIndex < stackLines.length &&
         (stackLines[callerIndex].includes("node:internal") ||
             stackLines[callerIndex].includes("/node_modules/"))) {
         callerIndex++;
     }
+    if (ignoreFiles.length > 0) {
+        while (callerIndex < stackLines.length &&
+            ignoreFiles.some((ignoreFile) => stackLines[callerIndex].includes(ignoreFile))) {
+            callerIndex++;
+        }
+    }
     const callerLine = stackLines[callerIndex] || "";
     let functionName = "Unknown function";
     let callerInfo = "Unknown caller";
-    // Default for named functions: "at functionName (file:line:column)"
     const namedFunctionMatch = callerLine.match(/at\s+([^(\s]+)\s+\(([^)]+)\)/);
     if (namedFunctionMatch) {
         functionName = namedFunctionMatch[1];
         callerInfo = namedFunctionMatch[2];
     }
-    // Default for anonymous functions or methods: "at file:line:column"
     else {
         const anonymousFunctionMatch = callerLine.match(/at\s+(.+)/);
         if (anonymousFunctionMatch) {
             callerInfo = anonymousFunctionMatch[1];
-            // Tenta extrair nome da função de padrões como Object.method ou Class.method
             const objectMethodMatch = callerInfo.match(/at\s+([^(\s]+)\s+/);
             if (objectMethodMatch && objectMethodMatch[1] !== "new") {
                 functionName = objectMethodMatch[1];
             }
         }
     }
-    // Handles file paths
     if (callerInfo.includes("(")) {
         callerInfo = callerInfo.substring(callerInfo.indexOf("(") + 1, callerInfo.lastIndexOf(")"));
     }
-    // Remove the line:column part of the file path
     callerInfo = callerInfo.split(":").slice(0, -2).join(":");
-    // Make the path relative to the project
     try {
         callerInfo = path.relative(projectRoot, callerInfo);
     }
-    catch (e) {
-        // If it fails to relativize, use the original path
-    }
+    catch (e) { }
     return { functionName, callerInfo };
 }
 export { getCaller };

package/dist/services/measureRouteExecution.d.ts

@@ -0,0 +1,3 @@
+declare function measureRouteExecution<T = unknown>(handler: (props: any) => Promise<T>): (props: any) => Promise<T>;
+export { measureRouteExecution };
+//# sourceMappingURL=measureRouteExecution.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"measureRouteExecution.d.ts","sourceRoot":"","sources":["../../src/services/measureRouteExecution.ts"],"names":[],"mappings":"AAAA,iBAAS,qBAAqB,CAAC,CAAC,GAAG,OAAO,EACxC,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,OAAO,CAAC,CAAC,CAAC,IAEG,OAAO,GAAG,KAAG,OAAO,CAAC,CAAC,CAAC,CAyB9D;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/services/measureRouteExecution.js

@@ -0,0 +1,24 @@
+function measureRouteExecution(handler) {
+    return async function measuredHandler(props) {
+        const startTime = performance.now();
+        try {
+            const result = await handler(props);
+            const url = new URL(props.request.url);
+            const endTime = performance.now();
+            const duration = (endTime - startTime).toFixed(2);
+            console.log({
+                domain: url.hostname,
+                pathname: url.pathname,
+                method: props.request.method,
+                duration,
+            });
+            return result;
+        }
+        catch (error) {
+            const endTime = performance.now();
+            console.error("");
+            throw error;
+        }
+    };
+}
+export { measureRouteExecution };

package/dist/services/schemaValidator.d.ts

@@ -1,13 +1,158 @@
-import { Schema, z } from "zod";
-declare class SchemaValidator<T extends Schema> {
+import { ZodType, z } from "zod";
+/**
+ * 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
+ * }
+ * ```
+ */
+declare class SchemaValidator<T extends ZodType> {
     readonly schema: T;
     functionName: string;
     callerInfo: string;
+    /**
+     * Creates a new SchemaValidator instance.
+     *
+     * @param {T} schema - The Zod schema to use for validation.
+     */
     constructor(schema: T);
+    /**
+     * 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: any): boolean;
-    safeValidate(data: any): z.SafeParseReturnType<z.infer<T>, z.infer<T>>;
+    /**
+     * 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: any): z.ZodSafeParseResult<z.infer<T>>;
+    /**
+     * 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: any): z.infer<T>;
+    /**
+     * 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: any, message?: string): z.infer<T>;
+    /**
+     * 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)
+     * }
+     * ```
+     */
+    formAsyncValidate(data: any, message?: string): Promise<z.infer<T>>;
 }
 export { SchemaValidator };
 //# sourceMappingURL=schemaValidator.d.ts.map