@arkyn/server 2.0.1-beta.9 → 2.0.1

package/dist/services/__test__/decodeRequestBody.spec.js

@@ -0,0 +1,39 @@
+import { decodeRequestBody } from "../decodeRequestBody";
+import { BadRequest } from "../../http/badResponses/badRequest";
+import { describe, expect, it } from "vitest";
+describe("decodeRequestBody", () => {
+    it("should decode the request body as JSON", async () => {
+        const mockRequest = {
+            arrayBuffer: async () => new TextEncoder().encode(JSON.stringify({ key: "value" })).buffer,
+        };
+        const result = await decodeRequestBody(mockRequest);
+        expect(result).toEqual({ key: "value" });
+    });
+    it("should decode the request body as URL-encoded form data", async () => {
+        const mockRequest = {
+            arrayBuffer: async () => new TextEncoder().encode("key=value&anotherKey=anotherValue").buffer,
+        };
+        const result = await decodeRequestBody(mockRequest);
+        expect(result).toEqual({ key: "value", anotherKey: "anotherValue" });
+    });
+    it("should throw BadRequest if the text is neither valid JSON nor URL-encoded", async () => {
+        const mockRequest = {
+            arrayBuffer: async () => new TextEncoder().encode("{invalidJson").buffer,
+        };
+        await expect(decodeRequestBody(mockRequest)).rejects.toThrow();
+    });
+    it("should throw BadRequest if the text is not a valid format for URLSearchParams", async () => {
+        const mockRequest = {
+            arrayBuffer: async () => new TextEncoder().encode("invalidFormat").buffer,
+        };
+        await expect(decodeRequestBody(mockRequest)).rejects.toThrow();
+    });
+    it("should throw BadRequest if an error occurs while reading the body", async () => {
+        const mockRequest = {
+            arrayBuffer: async () => {
+                throw new Error("Error reading the body");
+            },
+        };
+        await expect(decodeRequestBody(mockRequest)).rejects.toThrow();
+    });
+});

package/dist/services/__test__/errorHandler.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=errorHandler.spec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errorHandler.spec.d.ts","sourceRoot":"","sources":["../../../src/services/__test__/errorHandler.spec.ts"],"names":[],"mappings":""}

package/dist/services/__test__/errorHandler.spec.js

@@ -0,0 +1,115 @@
+import { errorHandler } from "../errorHandler";
+import { Found } from "../../http/successResponses/found";
+import { Created } from "../../http/successResponses/created";
+import { Updated } from "../../http/successResponses/updated";
+import { Success } from "../../http/successResponses/success";
+import { NoContent } from "../../http/successResponses/noContent";
+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 { describe, expect, it } from "vitest";
+describe("errorHandler", () => {
+    describe("Success Responses", () => {
+        it("should handle Found response", () => {
+            const found = new Found("Resource found");
+            const response = errorHandler(found);
+            expect(response.status).toBe(found.toResponse().status);
+            expect(response.statusText).toBe(found.toResponse().statusText);
+        });
+        it("should handle Created response", () => {
+            const created = new Created("Resource created");
+            const response = errorHandler(created);
+            expect(response.status).toBe(created.toResponse().status);
+            expect(response.statusText).toBe(created.toResponse().statusText);
+        });
+        it("should handle Updated response", () => {
+            const updated = new Updated("Resource updated");
+            const response = errorHandler(updated);
+            expect(response.status).toBe(updated.toResponse().status);
+            expect(response.statusText).toBe(updated.toResponse().statusText);
+        });
+        it("should handle Success response", () => {
+            const success = new Success("Operation successful");
+            const response = errorHandler(success);
+            expect(response.status).toBe(success.toResponse().status);
+            expect(response.statusText).toBe(success.toResponse().statusText);
+        });
+        it("should handle NoContent response", () => {
+            const noContent = new NoContent();
+            const response = errorHandler(noContent);
+            expect(response.status).toBe(noContent.toResponse().status);
+            expect(response.statusText).toBe(noContent.toResponse().statusText);
+        });
+    });
+    describe("Error Responses", () => {
+        it("should handle BadGateway error", () => {
+            const badGateway = new BadGateway("Bad gateway error");
+            const response = errorHandler(badGateway);
+            expect(response.status).toBe(badGateway.toResponse().status);
+            expect(response.statusText).toBe(badGateway.toResponse().statusText);
+        });
+        it("should handle BadRequest error", () => {
+            const badRequest = new BadRequest("Bad request error");
+            const response = errorHandler(badRequest);
+            expect(response.status).toBe(badRequest.toResponse().status);
+            expect(response.statusText).toBe(badRequest.toResponse().statusText);
+        });
+        it("should handle Conflict error", () => {
+            const conflict = new Conflict("Conflict error");
+            const response = errorHandler(conflict);
+            expect(response.status).toBe(conflict.toResponse().status);
+            expect(response.statusText).toBe(conflict.toResponse().statusText);
+        });
+        it("should handle Forbidden error", () => {
+            const forbidden = new Forbidden("Forbidden error");
+            const response = errorHandler(forbidden);
+            expect(response.status).toBe(forbidden.toResponse().status);
+            expect(response.statusText).toBe(forbidden.toResponse().statusText);
+        });
+        it("should handle NotFound error", () => {
+            const notFound = new NotFound("Not found error");
+            const response = errorHandler(notFound);
+            expect(response.status).toBe(notFound.toResponse().status);
+            expect(response.statusText).toBe(notFound.toResponse().statusText);
+        });
+        it("should handle NotImplemented error", () => {
+            const notImplemented = new NotImplemented("Not implemented error");
+            const response = errorHandler(notImplemented);
+            expect(response.status).toBe(notImplemented.toResponse().status);
+            expect(response.statusText).toBe(notImplemented.toResponse().statusText);
+        });
+        it("should handle ServerError error", () => {
+            const serverError = new ServerError("Server error");
+            const response = errorHandler(serverError);
+            expect(response.status).toBe(serverError.toResponse().status);
+            expect(response.statusText).toBe(serverError.toResponse().statusText);
+        });
+        it("should handle Unauthorized error", () => {
+            const unauthorized = new Unauthorized("Unauthorized error");
+            const response = errorHandler(unauthorized);
+            expect(response.status).toBe(unauthorized.toResponse().status);
+            expect(response.statusText).toBe(unauthorized.toResponse().statusText);
+        });
+        it("should handle UnprocessableEntity error", () => {
+            const unprocessableEntity = new UnprocessableEntity({});
+            const response = errorHandler(unprocessableEntity);
+            expect(response.status).toBe(unprocessableEntity.toResponse().status);
+            expect(response.statusText).toBe(unprocessableEntity.toResponse().statusText);
+        });
+    });
+    describe("Unknown Error", () => {
+        it("should return undefined for unknown error types", () => {
+            const unknownError = new Error("Unknown error");
+            const serverError = new ServerError("Server error");
+            const response = errorHandler(unknownError);
+            expect(response.status).toBe(serverError.toResponse().status);
+            expect(response.statusText).toBe(serverError.toResponse().statusText);
+        });
+    });
+});

package/dist/services/__test__/formParse.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=formParse.spec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"formParse.spec.d.ts","sourceRoot":"","sources":["../../../src/services/__test__/formParse.spec.ts"],"names":[],"mappings":""}

package/dist/services/__test__/formParse.spec.js

@@ -0,0 +1,78 @@
+import { describe, expect, it } from "vitest";
+import { z } from "zod";
+import { formParse } from "../formParse";
+describe("formParse", () => {
+    it("should return success and parsed data when validation passes", () => {
+        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: "John", age: 25 };
+        const result = formParse([formData, schema]);
+        expect(result.success).toBe(true);
+        expect(result).toHaveProperty("data");
+        if (result.success)
+            expect(result.data).toEqual(formData);
+    });
+    it("should return field errors when validation fails", () => {
+        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]);
+        expect(result.success).toBe(false);
+        expect(result).toHaveProperty("fieldErrors");
+        if (!result.success) {
+            expect(result.fieldErrors).toEqual({
+                name: "Name is required",
+                age: "Must be at least 18",
+            });
+            expect(result.fields).toEqual(formData);
+        }
+    });
+    it("should handle missing fields gracefully", () => {
+        const schema = z.object({
+            name: z
+                .string({ required_error: "Name is required" })
+                .min(1, "Name is required"),
+            age: z.number().min(18, "Must be at least 18"),
+        });
+        const formData = { age: 20 }; // Missing "name"
+        const result = formParse([formData, schema]);
+        expect(result.success).toBe(false);
+        if (!result.success) {
+            expect(result.fieldErrors).toEqual({ name: "Name is required" });
+            expect(result.fields).toEqual(formData);
+        }
+    });
+    it("should return success for an empty schema", () => {
+        const schema = z.object({});
+        const formData = {};
+        const result = formParse([formData, schema]);
+        expect(result.success).toBe(true);
+        expect(result).toHaveProperty("data");
+        if (result.success)
+            expect(result.data).toEqual(formData);
+    });
+    it("should handle nested schemas correctly", () => {
+        const schema = z.object({
+            user: z.object({
+                name: z.string().min(1, "Name is required"),
+                age: z.number().min(18, "Must be at least 18"),
+            }),
+        });
+        const formData = {
+            user: { name: "", age: 16 },
+        };
+        const result = formParse([formData, schema]);
+        expect(result.success).toBe(false);
+        if (!result.success) {
+            expect(result.fieldErrors).toEqual({
+                "user.name": "Name is required",
+                "user.age": "Must be at least 18",
+            });
+            expect(result.fields).toEqual(formData);
+        }
+    });
+});

package/dist/services/__test__/getCaller.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=getCaller.spec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getCaller.spec.d.ts","sourceRoot":"","sources":["../../../src/services/__test__/getCaller.spec.ts"],"names":[],"mappings":""}

package/dist/services/__test__/getCaller.spec.js

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import { getCaller } from "../getCaller";
+describe("getCaller", () => {
+    it("should return the correct caller function name and file path", () => {
+        function testFunction() {
+            return getCaller();
+        }
+        const result = testFunction();
+        expect(result.functionName).toBe("testFunction");
+        expect(result.callerInfo).toContain("getCaller.spec.ts");
+    });
+    it("should handle calls from anonymous functions", () => {
+        const result = (() => getCaller())();
+        expect(result.functionName).toBe("Unknown function");
+        expect(result.callerInfo).toContain("getCaller.spec.ts");
+    });
+    it("should return the correct name for nested functions", () => {
+        function outerFunction() {
+            function innerFunction() {
+                return getCaller();
+            }
+            return innerFunction();
+        }
+        const result = outerFunction();
+        expect(result.functionName).toBe("innerFunction");
+        expect(result.callerInfo).toContain("getCaller.spec.ts");
+    });
+    it("should return method name when called from object method", () => {
+        const obj = {
+            method() {
+                return getCaller();
+            },
+        };
+        const result = obj.method();
+        expect(result.functionName).toMatch(/method|Object.method/);
+        expect(result.callerInfo).toContain("getCaller.spec.ts");
+    });
+    it("should return method name when called from class method", () => {
+        class TestClass {
+            call() {
+                return getCaller();
+            }
+        }
+        const instance = new TestClass();
+        const result = instance.call();
+        expect(result.functionName).toMatch(/call|TestClass.call/);
+        expect(result.callerInfo).toContain("getCaller.spec.ts");
+    });
+    it("should return the correct caller for indirect calls", () => {
+        function intermediary(fn) {
+            return fn();
+        }
+        function actualCaller() {
+            return getCaller();
+        }
+        const result = intermediary(actualCaller);
+        expect(result.functionName).toBe("actualCaller");
+        expect(result.callerInfo).toContain("getCaller.spec.ts");
+    });
+});

package/dist/services/__test__/getScopedParams.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=getScopedParams.spec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getScopedParams.spec.d.ts","sourceRoot":"","sources":["../../../src/services/__test__/getScopedParams.spec.ts"],"names":[],"mappings":""}

package/dist/services/__test__/getScopedParams.spec.js

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+import { getScopedParams } from "../getScopedParams";
+describe("getScopedParams", () => {
+    it("should return all query parameters when no scope is provided", () => {
+        const request = {
+            url: "https://example.com?key1=value1&key2=value2",
+        };
+        const params = getScopedParams(request);
+        expect(params.get("key1")).toBe("value1");
+        expect(params.get("key2")).toBe("value2");
+        expect(params.toString()).toBe("key1=value1&key2=value2");
+    });
+    it("should return only scoped query parameters when a scope is provided", () => {
+        const request = {
+            url: "https://example.com?scope:key1=value1&scope:key2=value2&key3=value3",
+        };
+        const params = getScopedParams(request, "scope");
+        expect(params.get("key1")).toBe("value1");
+        expect(params.get("key2")).toBe("value2");
+        expect(params.get("key3")).toBeNull();
+        expect(params.toString()).toBe("key1=value1&key2=value2");
+    });
+    it("should return an empty URLSearchParams object if no parameters match the scope", () => {
+        const request = {
+            url: "https://example.com?key1=value1&key2=value2",
+        };
+        const params = getScopedParams(request, "scope");
+        expect(params.toString()).toBe("");
+    });
+    it("should handle URLs with no query parameters", () => {
+        const request = { url: "https://example.com" };
+        const params = getScopedParams(request);
+        expect(params.toString()).toBe("");
+    });
+    it("should handle URLs with query parameters but no matching scope", () => {
+        const request = {
+            url: "https://example.com?other:key1=value1&other:key2=value2",
+        };
+        const params = getScopedParams(request, "scope");
+        expect(params.toString()).toBe("");
+    });
+    it("should handle special characters in query parameter keys and values", () => {
+        const request = {
+            url: "https://example.com?scope:key+1=value+1&scope:key+2=value+2",
+        };
+        const params = getScopedParams(request, "scope");
+        expect(params.get("key 1")).toBe("value 1");
+        expect(params.get("key 2")).toBe("value 2");
+        expect(params.toString()).toBe("key+1=value+1&key+2=value+2");
+    });
+});

package/dist/services/__test__/schemaValidator.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=schemaValidator.spec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemaValidator.spec.d.ts","sourceRoot":"","sources":["../../../src/services/__test__/schemaValidator.spec.ts"],"names":[],"mappings":""}

package/dist/services/__test__/schemaValidator.spec.js

@@ -0,0 +1,89 @@
+import { z } from "zod";
+import { SchemaValidator } from "../schemaValidator";
+import { httpDebug } from "../httpDebug";
+import { ServerError } from "../../http/badResponses/serverError";
+import { UnprocessableEntity } from "../../http/badResponses/unprocessableEntity";
+import { describe, expect, it, vi } from "vitest";
+vi.mock("../getCaller", () => ({
+    getCaller: vi.fn(() => ({
+        callerInfo: "mockedCallerInfo",
+        functionName: "mockedFunctionName",
+    })),
+}));
+vi.mock("../httpDebug", () => ({
+    httpDebug: vi.fn(),
+}));
+describe("SchemaValidator", () => {
+    const schema = z.object({
+        name: z.string().min(1, "Name is required"),
+        age: z.number().min(18, "Must be at least 18"),
+    });
+    const validator = new SchemaValidator(schema);
+    describe("constructor", () => {
+        it("should initialize with caller info and function name", () => {
+            expect(validator.callerInfo).toBe("mockedCallerInfo");
+            expect(validator.functionName).toBe("mockedFunctionName");
+        });
+    });
+    describe("isValid", () => {
+        it("should return true for valid data", () => {
+            const data = { name: "John", age: 25 };
+            expect(validator.isValid(data)).toBe(true);
+        });
+        it("should return false for invalid data", () => {
+            const data = { name: "", age: 17 };
+            expect(validator.isValid(data)).toBe(false);
+        });
+    });
+    describe("safeValidate", () => {
+        it("should return success for valid data", () => {
+            const data = { name: "John", age: 25 };
+            const result = validator.safeValidate(data);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(data);
+        });
+        it("should return failure for invalid data", () => {
+            const data = { name: "", age: 17 };
+            const result = validator.safeValidate(data);
+            expect(result.success).toBe(false);
+            if (!result.success)
+                expect(result.error.issues).toHaveLength(2);
+        });
+    });
+    describe("validate", () => {
+        it("should return parsed data for valid input", () => {
+            const data = { name: "John", age: 25 };
+            expect(validator.validate(data)).toEqual(data);
+        });
+        it("should throw ServerError for invalid input", () => {
+            const data = { name: "", age: 17 };
+            expect(() => validator.validate(data)).toThrow(ServerError);
+        });
+    });
+    describe("formValidate", () => {
+        it("should return parsed data for valid input", () => {
+            const data = { name: "John", age: 25 };
+            expect(validator.formValidate(data)).toEqual(data);
+        });
+        it("should throw UnprocessableEntity for invalid input", () => {
+            const data = { name: "", age: 17 };
+            expect(() => validator.formValidate(data)).toThrow(UnprocessableEntity);
+        });
+        it("should call httpDebug with formParsed data on validation failure", () => {
+            const data = { name: "", age: 17 };
+            try {
+                validator.formValidate(data);
+            }
+            catch (error) {
+                // Ignore the error
+            }
+            expect(httpDebug).toHaveBeenCalledWith("UnprocessableEntity", expect.objectContaining({
+                success: false,
+                fieldErrors: {
+                    name: "Name is required",
+                    age: "Must be at least 18",
+                },
+            }));
+        });
+    });
+});

package/dist/services/decodeErrorMessageFromRequest.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Decodes an error message from a given request data object or response object.
+ *
+ * This function attempts to extract a meaningful error message from the provided
+ * `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
+ * 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
+ * representing the HTTP status text.
+ * @returns A string representing the decoded error message, or a default message
+ * if no error message is found.
+ */
+declare function decodeErrorMessageFromRequest(data: any, response: Response): string;
+export { decodeErrorMessageFromRequest };
+//# sourceMappingURL=decodeErrorMessageFromRequest.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decodeErrorMessageFromRequest.d.ts","sourceRoot":"","sources":["../../src/services/decodeErrorMessageFromRequest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,iBAAS,6BAA6B,CAAC,IAAI,EAAE,GAAG,EAAE,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAkB5E;AAED,OAAO,EAAE,6BAA6B,EAAE,CAAC"}

package/dist/services/decodeErrorMessageFromRequest.js

@@ -0,0 +1,30 @@
+/**
+ * Decodes an error message from a given request data object or response object.
+ *
+ * This function attempts to extract a meaningful error message from the provided
+ * `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
+ * 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
+ * representing the HTTP status text.
+ * @returns A string representing the decoded error message, or a default message
+ * if no error message is found.
+ */
+function decodeErrorMessageFromRequest(data, response) {
+    if (data?.message && typeof data?.message === "string") {
+        return data?.message;
+    }
+    if (data?.error && typeof data?.error === "string") {
+        return data?.error;
+    }
+    if (data?.error?.message && typeof data?.error?.message === "string") {
+        return data?.error?.message;
+    }
+    if (response?.statusText && typeof response?.statusText === "string") {
+        return response?.statusText;
+    }
+    return "Missing error message";
+}
+export { decodeErrorMessageFromRequest };

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

@@ -1 +1 @@
-{"version":3,"file":"decodeRequestBody.d.ts","sourceRoot":"","sources":["../../src/services/decodeRequestBody.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAE9D;;;;;;;;;;;;GAYG;AAEH,QAAA,MAAM,iBAAiB,EAAE,yBA2BxB,CAAC;AAEF,OAAO,EAAE,iBAAiB,EAAE,CAAC"}
+{"version":3,"file":"decodeRequestBody.d.ts","sourceRoot":"","sources":["../../src/services/decodeRequestBody.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAG9D;;;;;;;;;;;;GAYG;AAEH,QAAA,MAAM,iBAAiB,EAAE,yBAsBxB,CAAC;AAEF,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/services/decodeRequestBody.js

@@ -1,3 +1,4 @@
+import { BadRequest } from "../http/badResponses/badRequest";
 /**
  * Decodes the body of an incoming request into a JavaScript object.
  *
@@ -13,29 +14,24 @@
  */
 const decodeRequestBody = async (req) => {
     let data;
+    const arrayBuffer = await req.arrayBuffer();
+    const text = new TextDecoder().decode(arrayBuffer);
     try {
-        const arrayBuffer = await req.arrayBuffer();
-        const text = new TextDecoder().decode(arrayBuffer);
+        data = JSON.parse(text);
+    }
+    catch (jsonError) {
         try {
-            data = JSON.parse(text);
-        }
-        catch (jsonError) {
-            try {
+            if (text.includes("=")) {
                 const formData = new URLSearchParams(text);
                 data = Object.fromEntries(formData.entries());
             }
-            catch (formDataError) {
-                console.error("Failed to extract data from request:", {
-                    jsonError,
-                    formDataError,
-                });
-                data = {};
+            else {
+                throw new BadRequest("Invalid URLSearchParams format");
             }
         }
-    }
-    catch (error) {
-        console.error("Failed to read request body:", error);
-        data = {};
+        catch (formDataError) {
+            throw new BadRequest("Failed to extract data from request");
+        }
     }
     return data;
 };

package/dist/services/errorHandler.d.ts

@@ -1,3 +1,44 @@
-declare function errorHandler(error: any): Response | undefined;
+/**
+ * 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

@@ -1 +1 @@
-{"version":3,"file":"errorHandler.d.ts","sourceRoot":"","sources":["../../src/services/errorHandler.ts"],"names":[],"mappings":"AAgBA,iBAAS,YAAY,CAAC,KAAK,EAAE,GAAG,wBAoC/B;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}
+{"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"}