@arkyn/server 1.9.1 → 1.9.5

package/dist/services/errorHandler.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Handles errors and converts them into appropriate HTTP responses.
+ *
+ * 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.
+ *
+ * @param error - The error object to handle. It can be an instance of various
+ * HTTP response classes or a generic error.
+ *
+ * @returns The corresponding HTTP response object if the error matches a known
+ * type, or `undefined` if no match is found.
+ *
+ * ### Supported Success Responses:
+ * - `Found`
+ * - `Created`
+ * - `Updated`
+ * - `Success`
+ * - `NoContent`
+ *
+ * ### Supported Error Responses:
+ * - `BadGateway`
+ * - `BadRequest`
+ * - `Conflict`
+ * - `Forbidden`
+ * - `NotFound`
+ * - `NotImplemented`
+ * - `ServerError`
+ * - `Unauthorized`
+ * - `UnprocessableEntity`
+ *
+ * ### Example Usage:
+ * ```typescript
+ * try {
+ *   // Some operation that might throw an error
+ * } catch (error) {
+ *   return errorHandler(error);
+ * }
+ * ```
+ */
+declare function errorHandler(error: any): Response;
+export { errorHandler };
+//# sourceMappingURL=errorHandler.d.ts.map

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

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

package/dist/services/errorHandler.js

@@ -0,0 +1,93 @@
+import { BadGateway } from "../http/badResponses/badGateway";
+import { BadRequest } from "../http/badResponses/badRequest";
+import { Conflict } from "../http/badResponses/conflict";
+import { Forbidden } from "../http/badResponses/forbidden";
+import { NotFound } from "../http/badResponses/notFound";
+import { NotImplemented } from "../http/badResponses/notImplemented";
+import { ServerError } from "../http/badResponses/serverError";
+import { Unauthorized } from "../http/badResponses/unauthorized";
+import { UnprocessableEntity } from "../http/badResponses/unprocessableEntity";
+import { Created } from "../http/successResponses/created";
+import { Found } from "../http/successResponses/found";
+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.
+ *
+ * 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.
+ *
+ * @param error - The error object to handle. It can be an instance of various
+ * HTTP response classes or a generic error.
+ *
+ * @returns The corresponding HTTP response object if the error matches a known
+ * type, or `undefined` if no match is found.
+ *
+ * ### Supported Success Responses:
+ * - `Found`
+ * - `Created`
+ * - `Updated`
+ * - `Success`
+ * - `NoContent`
+ *
+ * ### Supported Error Responses:
+ * - `BadGateway`
+ * - `BadRequest`
+ * - `Conflict`
+ * - `Forbidden`
+ * - `NotFound`
+ * - `NotImplemented`
+ * - `ServerError`
+ * - `Unauthorized`
+ * - `UnprocessableEntity`
+ *
+ * ### Example Usage:
+ * ```typescript
+ * try {
+ *   // Some operation that might throw an error
+ * } catch (error) {
+ *   return errorHandler(error);
+ * }
+ * ```
+ */
+function errorHandler(error) {
+    switch (true) {
+        case error instanceof Response:
+            return error;
+        case error instanceof Found:
+            return error.toResponse();
+        case error instanceof Created:
+            return error.toResponse();
+        case error instanceof Updated:
+            return error.toResponse();
+        case error instanceof Success:
+            return error.toResponse();
+        case error instanceof NoContent:
+            return error.toResponse();
+    }
+    switch (true) {
+        case error instanceof BadGateway:
+            return error.toResponse();
+        case error instanceof BadRequest:
+            return error.toResponse();
+        case error instanceof Conflict:
+            return error.toResponse();
+        case error instanceof Forbidden:
+            return error.toResponse();
+        case error instanceof NotFound:
+            return error.toResponse();
+        case error instanceof NotImplemented:
+            return error.toResponse();
+        case error instanceof ServerError:
+            return error.toResponse();
+        case error instanceof Unauthorized:
+            return error.toResponse();
+        case error instanceof UnprocessableEntity:
+            return error.toResponse();
+    }
+    return new ServerError("Server error").toResponse();
+}
+export { errorHandler };

package/dist/services/formParse.d.ts

@@ -1,3 +1,42 @@
 import type { FormParseProps, FormParseReturnType } from "@arkyn/types";
-export declare function formParse<T extends FormParseProps>([formData, schema,]: T): FormParseReturnType<T>;
+/**
+ * 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 {FormParseReturnType<T>} 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 = formParse([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 formParse<T extends FormParseProps>([formData, schema,]: T): FormParseReturnType<T>;
+export { formParse };
 //# sourceMappingURL=formParse.d.ts.map

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,cAAc,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAExE,wBAAgB,SAAS,CAAC,CAAC,SAAS,cAAc,EAAE,CAClD,QAAQ,EACR,MAAM,EACP,EAAE,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAoB5B"}
+{"version":3,"file":"formParse.d.ts","sourceRoot":"","sources":["../../src/services/formParse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/dist/services/formParse.js

@@ -1,8 +1,48 @@
-export function formParse([formData, schema,]) {
+/**
+ * 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 {FormParseReturnType<T>} 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 = formParse([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
+ * }
+ * ```
+ */
+function formParse([formData, schema,]) {
     const zodResponse = schema.safeParse(formData);
     if (zodResponse.success === false) {
-        const errorsArray = Object.entries(zodResponse.error.formErrors.fieldErrors);
-        const errorsObject = Object.fromEntries(errorsArray.map((item) => [item[0], item[1]?.[0] || "Error"]));
+        const errorsObject = Object.fromEntries(zodResponse.error.errors.map((item) => [
+            item.path.join("."),
+            item.message,
+        ]));
         return {
             success: zodResponse.success,
             fieldErrors: errorsObject,
@@ -13,3 +53,4 @@ export function formParse([formData, schema,]) {
         return { success: zodResponse.success, data: zodResponse.data };
     }
 }
+export { formParse };

package/dist/services/getCaller.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Retrieves information about the caller of the current function.
+ *
+ * This function analyzes the stack trace to determine the file path and function name
+ * of the caller. It excludes stack trace entries related to the `@arkyn/server` package
+ * and attempts to resolve the file path relative to the project root directory.
+ *
+ * @returns An object containing:
+ * - `functionName`: The name of the function that called the current function, or "Unknown function" if it cannot be determined.
+ * - `callerInfo`: The file path of the caller relative to the project root, or "Unknown caller" if it cannot be determined.
+ */
+declare function getCaller(): {
+    functionName: string;
+    callerInfo: string;
+};
+export { getCaller };
+//# sourceMappingURL=getCaller.d.ts.map

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

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

package/dist/services/getCaller.js

@@ -0,0 +1,45 @@
+import path from "path";
+/**
+ * Retrieves information about the caller of the current function.
+ *
+ * This function analyzes the stack trace to determine the file path and function name
+ * of the caller. It excludes stack trace entries related to the `@arkyn/server` package
+ * and attempts to resolve the file path relative to the project root directory.
+ *
+ * @returns An object containing:
+ * - `functionName`: The name of the function that called the current function, or "Unknown function" if it cannot be determined.
+ * - `callerInfo`: The file path of the caller relative to the project root, or "Unknown caller" if it cannot be determined.
+ */
+function getCaller() {
+    const projectRoot = process.cwd();
+    const error = new Error();
+    const stackLines = error.stack?.split("\n").map((line) => line.trim()) || [];
+    let callerInfo = "Unknown caller";
+    let functionName = "Unknown function";
+    const relevantLines = stackLines.filter((line) => !line.includes("@arkyn/server"));
+    let foundGetCaller = false;
+    for (const line of relevantLines) {
+        if (!foundGetCaller) {
+            if (line.includes("getCaller")) {
+                foundGetCaller = true;
+            }
+            continue;
+        }
+        const match = line.match(/at (.+?) \((.+?)\)/) || line.match(/at (.+)/);
+        if (match) {
+            const rawFuncName = match[1]?.split(" ")[0] || "";
+            functionName =
+                rawFuncName && !rawFuncName.includes("/")
+                    ? rawFuncName
+                    : "Unknown function";
+            let fullPath = match[2] || match[1];
+            if (fullPath.startsWith(projectRoot)) {
+                fullPath = path.relative(projectRoot, fullPath);
+            }
+            callerInfo = fullPath;
+            break;
+        }
+    }
+    return { functionName, callerInfo };
+}
+export { getCaller };

package/dist/services/getScopedParams.d.ts

@@ -1,3 +1,28 @@
-declare function getScopedParams(request: Request, scope?: string): URLSearchParams;
+import type { GetScopedParamsFunction } from "@arkyn/types";
+/**
+ * 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.
+ *                If no scope is provided, all query parameters are returned.
+ *
+ * @returns A `URLSearchParams` object containing the scoped query parameters.
+ *          If a scope is provided, only parameters with keys starting with the scope
+ *          (e.g., `scope:key`) are included, and the scope prefix is removed from the keys.
+ *          If no scope is provided, all query parameters are returned as-is.
+ *
+ * @example
+ * // Example 1: No scope provided
+ * const request = { url: "https://example.com?key1=value1&key2=value2" };
+ * const params = getScopedParams(request);
+ * console.log(params.toString()); // Output: "key1=value1&key2=value2"
+ *
+ * @example
+ * // Example 2: Scope provided
+ * const request = { url: "https://example.com?scope:key1=value1&scope:key2=value2&key3=value3" };
+ * const params = getScopedParams(request, "scope");
+ * console.log(params.toString()); // Output: "key1=value1&key2=value2"
+ */
+declare const getScopedParams: GetScopedParamsFunction;
 export { getScopedParams };
 //# sourceMappingURL=getScopedParams.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getScopedParams.d.ts","sourceRoot":"","sources":["../../src/services/getScopedParams.ts"],"names":[],"mappings":"AAAA,iBAAS,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,GAAE,MAAW,mBAW5D;AAED,OAAO,EAAE,eAAe,EAAE,CAAC"}
+{"version":3,"file":"getScopedParams.d.ts","sourceRoot":"","sources":["../../src/services/getScopedParams.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,QAAA,MAAM,eAAe,EAAE,uBAWtB,CAAC;AAEF,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/services/getScopedParams.js

@@ -1,4 +1,28 @@
-function getScopedParams(request, scope = "") {
+/**
+ * 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.
+ *                If no scope is provided, all query parameters are returned.
+ *
+ * @returns A `URLSearchParams` object containing the scoped query parameters.
+ *          If a scope is provided, only parameters with keys starting with the scope
+ *          (e.g., `scope:key`) are included, and the scope prefix is removed from the keys.
+ *          If no scope is provided, all query parameters are returned as-is.
+ *
+ * @example
+ * // Example 1: No scope provided
+ * const request = { url: "https://example.com?key1=value1&key2=value2" };
+ * const params = getScopedParams(request);
+ * console.log(params.toString()); // Output: "key1=value1&key2=value2"
+ *
+ * @example
+ * // Example 2: Scope provided
+ * const request = { url: "https://example.com?scope:key1=value1&scope:key2=value2&key3=value3" };
+ * const params = getScopedParams(request, "scope");
+ * console.log(params.toString()); // Output: "key1=value1&key2=value2"
+ */
+const getScopedParams = (request, scope = "") => {
     const url = new URL(request.url);
     if (scope === "")
         return url.searchParams;
@@ -6,5 +30,5 @@ function getScopedParams(request, scope = "") {
         .filter(([key]) => key.startsWith(`${scope}:`))
         .map(([key, value]) => [key.replace(`${scope}:`, ""), value]);
     return new URLSearchParams(scopedSearchParams);
-}
+};
 export { getScopedParams };

package/dist/services/httpDebug.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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

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

package/dist/services/httpDebug.js

@@ -0,0 +1,56 @@
+import { InboxFlowInstance } from "../config/inboxFlowInstance";
+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);
+        const arkynKeys = InboxFlowInstance.getInboxConfig();
+        if (arkynKeys)
+            console.log(arkynKeys);
+    }
+}
+export { httpDebug };

package/dist/services/schemaValidator.d.ts

@@ -0,0 +1,13 @@
+import { Schema, z } from "zod";
+declare class SchemaValidator<T extends Schema> {
+    readonly schema: T;
+    functionName: string;
+    callerInfo: string;
+    constructor(schema: T);
+    isValid(data: any): boolean;
+    safeValidate(data: any): z.SafeParseReturnType<z.infer<T>, z.infer<T>>;
+    validate(data: any): z.infer<T>;
+    formValidate(data: any, message?: string): z.infer<T>;
+}
+export { SchemaValidator };
+//# sourceMappingURL=schemaValidator.d.ts.map

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

@@ -0,0 +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"}

package/dist/services/schemaValidator.js

@@ -0,0 +1,51 @@
+import { Schema, z } from "zod";
+import { ServerError } from "../http/badResponses/serverError";
+import { UnprocessableEntity } from "../http/badResponses/unprocessableEntity";
+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");
+}
+class SchemaValidator {
+    schema;
+    functionName;
+    callerInfo;
+    constructor(schema) {
+        this.schema = schema;
+        const { callerInfo, functionName } = getCaller();
+        this.callerInfo = callerInfo;
+        this.functionName = functionName;
+    }
+    isValid(data) {
+        return this.schema.safeParse(data).success;
+    }
+    safeValidate(data) {
+        return this.schema.safeParse(data);
+    }
+    validate(data) {
+        try {
+            return this.schema.parse(data);
+        }
+        catch (error) {
+            throw new ServerError(formatErrorMessage(error));
+        }
+    }
+    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;
+    }
+}
+export { SchemaValidator };

package/dist/services/sendFileToS3.d.ts

@@ -1,20 +1,52 @@
-import { type ActionFunctionArgs } from "@remix-run/node";
-type AWSConfig = {
-    AWS_REGION: string;
-    AWS_ACCESS_KEY_ID: string;
-    AWS_SECRET_ACCESS_KEY: string;
-    AWS_S3_BUCKET: string;
-};
-type Config = {
-    maxPartSize?: number;
-    fileName?: string;
-};
-declare function sendFileToS3(props: ActionFunctionArgs, awsS3Config: AWSConfig, config?: Config): Promise<{
-    error: string;
-    url?: undefined;
-} | {
-    url: string;
-    error?: undefined;
-}>;
+import type { SendFileToS3Function } from "@arkyn/types";
+/**
+ * Handles file uploads to an AWS S3 bucket. This function processes a file
+ * from a multipart form request, validates and optionally compresses the file,
+ * and uploads it to S3. It supports image-specific operations such as resizing
+ * validation and quality reduction.
+ *
+ * @param request - The HTTP request containing the multipart form data.
+ * @param awsS3Config - Configuration object for AWS S3, including bucket name,
+ * region, and credentials.
+ * @param config - Optional configuration object for file handling.
+ *
+ * @param config.fileName - The name of the form field containing the file. Defaults to `"file"`.
+ * @param config.maxPartSize - The maximum size (in bytes) for each part of the file. Defaults to `5_000_000`.
+ * @param config.reduceImageQuality - The quality percentage for image compression. Defaults to `100`.
+ * @param config.validateImageSize - Whether to validate the image dimensions. Defaults to `false`.
+ * @param config.validateImageMessage - The error message template for invalid image dimensions.
+ * Defaults to `"Invalid dimensions {{width}}px x {{height}}px"`.
+ *
+ * @returns A promise that resolves to an object containing the uploaded file's URL
+ * or an error message if validation fails.
+ *
+ * @throws {BadRequest} If no file is uploaded.
+ *
+ * @example
+ * ```typescript
+ * const awsS3Config = {
+ *   AWS_S3_BUCKET: "my-bucket",
+ *   AWS_REGION: "us-east-1",
+ *   AWS_ACCESS_KEY_ID: "my-access-key",
+ *   AWS_SECRET_ACCESS_KEY: "my-secret-key",
+ * };
+ *
+ * const config = {
+ *   fileName: "upload",
+ *   maxPartSize: 10_000_000,
+ *   reduceImageQuality: 80,
+ *   validateImageSize: true,
+ *   validateImageMessage: "Invalid dimensions {{width}}px x {{height}}px",
+ * };
+ *
+ * const response = await sendFileToS3(request, awsS3Config, config);
+ * if (response.error) {
+ *   console.error(response.error);
+ * } else {
+ *   console.log("File uploaded to:", response.url);
+ * }
+ * ```
+ */
+declare const sendFileToS3: SendFileToS3Function;
 export { sendFileToS3 };
 //# sourceMappingURL=sendFileToS3.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"sendFileToS3.d.ts","sourceRoot":"","sources":["../../src/services/sendFileToS3.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,kBAAkB,EAExB,MAAM,iBAAiB,CAAC;AAOzB,KAAK,SAAS,GAAG;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,KAAK,MAAM,GAAG;IACZ,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAmDF,iBAAe,YAAY,CACzB,KAAK,EAAE,kBAAkB,EACzB,WAAW,EAAE,SAAS,EACtB,MAAM,GAAE,MAGP;;;;;;GAwEF;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}
+{"version":3,"file":"sendFileToS3.d.ts","sourceRoot":"","sources":["../../src/services/sendFileToS3.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAa,oBAAoB,EAAE,MAAM,cAAc,CAAC;AA8CpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAEH,QAAA,MAAM,YAAY,EAAE,oBAkFnB,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,CAAC"}