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

package/dist/{services/decodeErrorMessageFromRequest.js → utilities/decodeRequestErrorMessage.js}

@@ -5,14 +5,14 @@
  * `data` or `response` objects by checking various properties in a specific order.
  * If no valid error message is found, it returns a default message: "Missing error message".
  *
- * @param data - The data object that may contain error information. It can have properties
+ * @param {any} data - The data object that may contain error information. It can have properties
  * such as `message`, `error`, or `error.message` that are checked for a string value.
- * @param response - The response object that may contain a `statusText` property
+ * @param {Response} response - The response object that may contain a `statusText` property
  * representing the HTTP status text.
- * @returns A string representing the decoded error message, or a default message
+ * @returns {string} A string representing the decoded error message, or a default message
  * if no error message is found.
  */
-function decodeErrorMessageFromRequest(data, response) {
+function decodeRequestErrorMessage(data, response) {
     if (data?.message && typeof data?.message === "string") {
         return data?.message;
     }
@@ -27,4 +27,4 @@ function decodeErrorMessageFromRequest(data, response) {
     }
     return "Missing error message";
 }
-export { decodeErrorMessageFromRequest };
+export { decodeRequestErrorMessage };

package/dist/utilities/errorHandler.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Handles errors and success responses, converting them into standard HTTP Response objects.
+ *
+ * This function acts as a centralized error and response handler that processes various
+ * response types (both success and error responses) and converts them into HTTP Response
+ * objects. If the error is not recognized, it defaults to returning a ServerError response.
+ *
+ * @param {any} error - The error or response object to be handled. Can be:
+ *   - A native Response object
+ *   - A success response instance (Found, Created, Updated, Success, NoContent)
+ *   - An error response instance (BadGateway, BadRequest, Conflict, Forbidden, NotFound, NotImplemented, ServerError, Unauthorized, UnprocessableEntity)
+ *   - Any other error object (will be wrapped in ServerError)
+ *
+ * @returns {Response} A standard HTTP Response object with appropriate status code, headers, and body
+ *
+ * @example
+ * ```typescript
+ * // Handling a success response
+ * try {
+ *   const result = await someOperation();
+ *   throw new Success("Operation successful", result);
+ * } catch (error) {
+ *   return errorHandler(error);
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Handling an error response
+ * try {
+ *   const user = await findUser(id);
+ *   if (!user) throw new NotFound("User not found");
+ * } catch (error) {
+ *   return errorHandler(error);
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Handling unexpected errors
+ * try {
+ *   await riskyOperation();
+ * } catch (error) {
+ *   return errorHandler(error); // Returns ServerError response
+ * }
+ * ```
+ */
+declare function errorHandler(error: any): Response;
+export { errorHandler };
+//# sourceMappingURL=errorHandler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errorHandler.d.ts","sourceRoot":"","sources":["../../src/utilities/errorHandler.ts"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,iBAAS,YAAY,CAAC,KAAK,EAAE,GAAG,GAAG,QAAQ,CAsC1C;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/{services → utilities}/errorHandler.js

@@ -13,45 +13,51 @@ import { NoContent } from "../http/successResponses/noContent";
 import { Success } from "../http/successResponses/success";
 import { Updated } from "../http/successResponses/updated";
 /**
- * Handles errors and converts them into appropriate HTTP responses.
+ * Handles errors and success responses, converting them into standard HTTP Response objects.
  *
- * This function takes an error object and determines its type to return
- * the corresponding HTTP response. It supports both success and error
- * response types, converting them into a standardized format using the
- * `toResponse` method when applicable.
+ * This function acts as a centralized error and response handler that processes various
+ * response types (both success and error responses) and converts them into HTTP Response
+ * objects. If the error is not recognized, it defaults to returning a ServerError response.
  *
- * @param error - The error object to handle. It can be an instance of various
- * HTTP response classes or a generic error.
+ * @param {any} error - The error or response object to be handled. Can be:
+ *   - A native Response object
+ *   - A success response instance (Found, Created, Updated, Success, NoContent)
+ *   - An error response instance (BadGateway, BadRequest, Conflict, Forbidden, NotFound, NotImplemented, ServerError, Unauthorized, UnprocessableEntity)
+ *   - Any other error object (will be wrapped in ServerError)
  *
- * @returns The corresponding HTTP response object if the error matches a known
- * type, or `undefined` if no match is found.
+ * @returns {Response} A standard HTTP Response object with appropriate status code, headers, and body
  *
- * ### Supported Success Responses:
- * - `Found`
- * - `Created`
- * - `Updated`
- * - `Success`
- * - `NoContent`
- *
- * ### Supported Error Responses:
- * - `BadGateway`
- * - `BadRequest`
- * - `Conflict`
- * - `Forbidden`
- * - `NotFound`
- * - `NotImplemented`
- * - `ServerError`
- * - `Unauthorized`
- * - `UnprocessableEntity`
+ * @example
+ * ```typescript
+ * // Handling a success response
+ * try {
+ *   const result = await someOperation();
+ *   throw new Success("Operation successful", result);
+ * } catch (error) {
+ *   return errorHandler(error);
+ * }
+ * ```
  *
- * ### Example Usage:
+ * @example
  * ```typescript
+ * // Handling an error response
  * try {
- *   // Some operation that might throw an error
+ *   const user = await findUser(id);
+ *   if (!user) throw new NotFound("User not found");
  * } catch (error) {
  *   return errorHandler(error);
  * }
  * ```
+ *
+ * @example
+ * ```typescript
+ * // Handling unexpected errors
+ * try {
+ *   await riskyOperation();
+ * } catch (error) {
+ *   return errorHandler(error); // Returns ServerError response
+ * }
+ * ```
  */
 function errorHandler(error) {
     switch (true) {

package/dist/utilities/flushDebugLogs.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Flushes debug logs to the console with colored output in development mode.
+ *
+ * This function only outputs logs when running in development mode or when
+ * the DEBUG_MODE environment variable is set to "true".
+ * Each log entry is prefixed with a colored name tag based on the specified color scheme.
+ *
+ * @param {object} props - Configuration object for debug logging.
+ * @param {string} props.name - The name/label to display before each log entry (e.g., "API", "Database").
+ * @param {"yellow" | "cyan" | "red" | "green"} props.scheme - The color scheme for the name tag:
+ *   - "yellow": Warning-level logs
+ *   - "cyan": Info-level logs
+ *   - "red": Error-level logs
+ *   - "green": Success-level logs
+ * @param {string[]} props.debugs - Array of debug messages to be logged.
+ *
+ * @returns {void}
+ *
+ * @example
+ * ```typescript
+ * // Log API request information
+ * flushDebugLogs({
+ *   name: "API",
+ *   scheme: "cyan",
+ *   debugs: ["POST /api/users", "Status: 201", "Response time: 45ms"]
+ * });
+ * // Output:
+ * // [API] POST /api/users
+ * // [API] Status: 201
+ * // [API] Response time: 45ms
+ *
+ * // Log error messages
+ * flushDebugLogs({
+ *   name: "ERROR",
+ *   scheme: "red",
+ *   debugs: ["Database connection failed", "Retrying in 5s..."]
+ * });
+ * ```
+ */
+declare function flushDebugLogs(props: {
+    scheme: "yellow" | "cyan" | "red" | "green";
+    name: string;
+    debugs: string[];
+}): void;
+export { flushDebugLogs };
+//# sourceMappingURL=flushDebugLogs.d.ts.map

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

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

package/dist/utilities/flushDebugLogs.js

@@ -0,0 +1,59 @@
+/**
+ * Flushes debug logs to the console with colored output in development mode.
+ *
+ * This function only outputs logs when running in development mode or when
+ * the DEBUG_MODE environment variable is set to "true".
+ * Each log entry is prefixed with a colored name tag based on the specified color scheme.
+ *
+ * @param {object} props - Configuration object for debug logging.
+ * @param {string} props.name - The name/label to display before each log entry (e.g., "API", "Database").
+ * @param {"yellow" | "cyan" | "red" | "green"} props.scheme - The color scheme for the name tag:
+ *   - "yellow": Warning-level logs
+ *   - "cyan": Info-level logs
+ *   - "red": Error-level logs
+ *   - "green": Success-level logs
+ * @param {string[]} props.debugs - Array of debug messages to be logged.
+ *
+ * @returns {void}
+ *
+ * @example
+ * ```typescript
+ * // Log API request information
+ * flushDebugLogs({
+ *   name: "API",
+ *   scheme: "cyan",
+ *   debugs: ["POST /api/users", "Status: 201", "Response time: 45ms"]
+ * });
+ * // Output:
+ * // [API] POST /api/users
+ * // [API] Status: 201
+ * // [API] Response time: 45ms
+ *
+ * // Log error messages
+ * flushDebugLogs({
+ *   name: "ERROR",
+ *   scheme: "red",
+ *   debugs: ["Database connection failed", "Retrying in 5s..."]
+ * });
+ * ```
+ */
+function flushDebugLogs(props) {
+    const isDebugMode = process.env.NODE_ENV === "development" ||
+        process.env?.DEBUG_MODE === "true";
+    if (isDebugMode) {
+        const reset = "\x1b[0m";
+        const colors = {
+            yellow: "\x1b[33m",
+            cyan: "\x1b[36m",
+            red: "\x1b[31m",
+            green: "\x1b[32m",
+        };
+        const debugName = `${colors[props.scheme]}[${props.name}]${reset}`;
+        let consoleData = `\n`;
+        props.debugs.forEach((debug) => {
+            consoleData += `${debugName} ${debug.trim()}\n`;
+        });
+        console.log(consoleData);
+    }
+}
+export { flushDebugLogs };

package/dist/utilities/formAsyncParse.d.ts

@@ -0,0 +1,59 @@
+import type { ZodType } from "zod";
+type SuccessResponse<T extends FormParseProps> = {
+    success: true;
+    data: T[1] extends ZodType<infer U> ? U : never;
+};
+type ErrorResponse = {
+    success: false;
+    fields: {
+        [x: string]: string;
+    };
+    fieldErrors: {
+        [x: string]: string;
+    };
+};
+type FormParseProps = [formData: {
+    [k: string]: any;
+}, schema: ZodType];
+type FormParseReturnType<T extends FormParseProps> = SuccessResponse<T> | ErrorResponse;
+/**
+ * Asynchronously parses form data using a Zod schema and returns the result.
+ *
+ * @template T - A type that extends `FormParseProps`.
+ *
+ * @param {T} props - An array containing the form data and the Zod schema.
+ * @param {T[0]} formData[0] - The form data to be validated.
+ * @param {T[1]} schema[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
+ * }
+ * ```
+ */
+declare function formAsyncParse<T extends FormParseProps>([formData, schema,]: T): Promise<FormParseReturnType<T>>;
+export { formAsyncParse };
+//# sourceMappingURL=formAsyncParse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"formAsyncParse.d.ts","sourceRoot":"","sources":["../../src/utilities/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/utilities/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} props - An array containing the form data and the Zod schema.
+ * @param {T[0]} formData[0] - The form data to be validated.
+ * @param {T[1]} schema[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 → utilities}/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,16 +14,16 @@ 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.
  *
  * @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.
+ * @param {T} props - An array containing the form data and the Zod schema.
+ * @param {T[0]} formData[0] - The form data to be validated.
+ * @param {T[1]} schema[1] - The Zod schema used for validation.
  *
  * @returns {FormParseReturnType<T>} An object containing the validation result.
  * - If validation fails, it includes:

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

@@ -0,0 +1 @@
+{"version":3,"file":"formParse.d.ts","sourceRoot":"","sources":["../../src/utilities/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 → utilities}/formParse.js

@@ -3,9 +3,9 @@
  *
  * @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.
+ * @param {T} props - An array containing the form data and the Zod schema.
+ * @param {T[0]} formData[0] - The form data to be validated.
+ * @param {T[1]} schema[1] - The Zod schema used for validation.
  *
  * @returns {FormParseReturnType<T>} An object containing the validation result.
  * - If validation fails, it includes:
@@ -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 → utilities}/getScopedParams.d.ts

@@ -1,9 +1,8 @@
-type GetScopedParamsFunction = (request: Request, scope?: string) => URLSearchParams;
 /**
  * Extracts and returns scoped query parameters from a request URL.
  *
- * @param request - The incoming request object containing the URL.
- * @param scope - An optional string representing the scope prefix for filtering query parameters.
+ * @param {Request} request - The incoming request object containing the URL.
+ * @param {string} scope - An optional string representing the scope prefix for filtering query parameters.
  *                If no scope is provided, all query parameters are returned.
  *
  * @returns A `URLSearchParams` object containing the scoped query parameters.
@@ -23,6 +22,6 @@ type GetScopedParamsFunction = (request: Request, scope?: string) => URLSearchPa
  * const params = getScopedParams(request, "scope");
  * console.log(params.toString()); // Output: "key1=value1&key2=value2"
  */
-declare const getScopedParams: GetScopedParamsFunction;
+declare function getScopedParams(request: Request, scope?: string): URLSearchParams;
 export { getScopedParams };
 //# sourceMappingURL=getScopedParams.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getScopedParams.d.ts","sourceRoot":"","sources":["../../src/utilities/getScopedParams.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,iBAAS,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,GAAE,MAAW,mBAW5D;AAED,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/{services → utilities}/getScopedParams.js

@@ -1,8 +1,8 @@
 /**
  * Extracts and returns scoped query parameters from a request URL.
  *
- * @param request - The incoming request object containing the URL.
- * @param scope - An optional string representing the scope prefix for filtering query parameters.
+ * @param {Request} request - The incoming request object containing the URL.
+ * @param {string} scope - An optional string representing the scope prefix for filtering query parameters.
  *                If no scope is provided, all query parameters are returned.
  *
  * @returns A `URLSearchParams` object containing the scoped query parameters.
@@ -22,7 +22,7 @@
  * const params = getScopedParams(request, "scope");
  * console.log(params.toString()); // Output: "key1=value1&key2=value2"
  */
-const getScopedParams = (request, scope = "") => {
+function getScopedParams(request, scope = "") {
     const url = new URL(request.url);
     if (scope === "")
         return url.searchParams;
@@ -30,5 +30,5 @@ const getScopedParams = (request, scope = "") => {
         .filter(([key]) => key.startsWith(`${scope}:`))
         .map(([key, value]) => [key.replace(`${scope}:`, ""), value]);
     return new URLSearchParams(scopedSearchParams);
-};
+}
 export { getScopedParams };

package/dist/utilities/schemaValidator.d.ts

@@ -0,0 +1,146 @@
+import { ZodType, z } from "zod";
+/**
+ * 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
+ * }
+ * ```
+ */
+declare class SchemaValidator<T extends ZodType> {
+    readonly schema: T;
+    /**
+     * 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;
+    /**
+     * 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.
+     * @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: 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.
+     * @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: 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.
+     * @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)
+     * }
+     * ```
+     */
+    formAsyncValidate(data: any, message?: string): Promise<z.infer<T>>;
+}
+export { SchemaValidator };
+//# sourceMappingURL=schemaValidator.d.ts.map