@arkyn/server 2.0.1-beta.8 → 2.0.1

package/LICENSE.txt

@@ -0,0 +1,24 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   Copyright 2025 Lucas Gonçalves
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+---
+
+For more information or to contribute, visit:
+https://github.com/Lucas-Eduardo-Goncalves

package/README.md

@@ -0,0 +1,116 @@
+The `@arkyn/server` package provides utilities and services to streamline backend application development. It includes API configurations, HTTP error handlers, and various services for file manipulation.
+
+---
+
+## Installation
+
+Install the package using npm:
+
+```bash
+npm install @arkyn/server
+```
+
+---
+
+## Features
+
+### Settings
+
+- **`ApiInstance`**  
+  Pre-configured instance for API calls.
+
+- **`InboxFlowInstance`**  
+  Pre-configured instance for integration with Inbox Flow.
+
+---
+
+### HTTP Responses - Errors
+
+- **`BadGateway(message: string): Error`**  
+  Represents an HTTP 502 error.
+
+- **`BadRequest(message: string): Error`**  
+  Represents an HTTP 400 error.
+
+- **`Conflict(message: string): Error`**  
+  Represents an HTTP 409 error.
+
+- **`Forbidden(message: string): Error`**  
+  Represents an HTTP 403 error.
+
+- **`NotFound(message: string): Error`**  
+  Represents an HTTP 404 error.
+
+- **`NotImplemented(message: string): Error`**  
+  Represents an HTTP 501 error.
+
+- **`ServerError(message: string): Error`**  
+  Represents an HTTP 500 error.
+
+- **`Unauthorized(message: string): Error`**  
+  Represents an HTTP 401 error.
+
+- **`UnprocessableEntity(message: string): Error`**  
+  Represents an HTTP 422 error.
+
+---
+
+### HTTP Responses - Success
+
+- **`Created(data: any): Response`**  
+  Represents an HTTP 201 response.
+
+- **`Found(data: any): Response`**  
+  Represents an HTTP 302 response.
+
+- **`NoContent(): Response`**  
+  Represents an HTTP 204 response.
+
+- **`Success(data: any): Response`**  
+  Represents an HTTP 200 response.
+
+- **`Updated(data: any): Response`**  
+  Represents an HTTP 200 response for updates.
+
+---
+
+### Services
+
+- **`decodeErrorMessageFromRequest(request: Request): string`**  
+  Decodes error messages from a request.
+
+- **`decodeRequestBody(request: Request): any`**  
+  Decodes the body of a request.
+
+- **`errorHandler(error: Error): Response`**  
+  Handles errors and returns an appropriate response.
+
+- **`formParse(request: Request): FormData`**  
+  Parses form data.
+
+- **`getCaller(): string`**  
+  Returns the name of the function that invoked the method.
+
+- **`getScopedParams(request: Request): URLSearchParams`**  
+  Retrieves scoped parameters from a request.
+
+- **`httpDebug(request: Request): void`**  
+  Displays debug information for an HTTP request.
+
+- **`SchemaValidator(schema: any, data: any): boolean`**  
+  Validates data against a schema.
+
+- **`sendFileToS3(file: File, config: AwsConfig): Promise<{ url: string }>`**  
+  Uploads a file to AWS S3.
+
+---
+
+## Contribution
+
+Contributions are welcome! Feel free to open issues or submit pull requests to improve the project.
+
+---
+
+## License
+
+This project is licensed under the Apache 2.0 License. See the `LICENSE` file for more details.

package/dist/api/__test__/deleteRequest.spec.d.ts

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

package/dist/api/__test__/deleteRequest.spec.d.ts.map

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

package/dist/api/__test__/deleteRequest.spec.js

@@ -0,0 +1,84 @@
+import { describe, it, expect, vi } from "vitest";
+import { deleteRequest } from "../deleteRequest";
+global.fetch = vi.fn();
+describe("deleteRequest", () => {
+    it("should return success response for a successfully delete request", async () => {
+        const mockResponse = { message: "Resource deleted successfully" };
+        fetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            json: async () => mockResponse,
+        });
+        const response = await deleteRequest("https://api.example.com/resource");
+        expect(response).toEqual({
+            success: true,
+            status: 200,
+            message: "Resource deleted successfully",
+            response: mockResponse,
+            cause: null,
+        });
+    });
+    it("should return failed response for a failed delete request", async () => {
+        const mockErrorResponse = { error: "Resource not found" };
+        fetch.mockResolvedValueOnce({
+            ok: false,
+            status: 404,
+            json: async () => mockErrorResponse,
+        });
+        const response = await deleteRequest("https://api.example.com/resource");
+        expect(response.success).toBe(false);
+        expect(response.status).toBe(404);
+        expect(response.response).toEqual(mockErrorResponse);
+        expect(response.message).toBeDefined();
+    });
+    it("should handle network errors gracefully", async () => {
+        fetch.mockRejectedValueOnce(new Error("Network Error"));
+        const response = await deleteRequest("https://api.example.com/resource");
+        expect(response).toEqual({
+            success: false,
+            status: 0,
+            message: "Network error or request failed",
+            response: null,
+            cause: "Network Error",
+        });
+    });
+    it("should handle invalid JSON response gracefully", async () => {
+        fetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            json: async () => {
+                throw new Error("Invalid JSON");
+            },
+        });
+        const response = await deleteRequest("https://api.example.com/resource");
+        expect(response).toEqual({
+            success: true,
+            status: 200,
+            message: "Resource deleted successfully",
+            response: null,
+            cause: null,
+        });
+    });
+    it("should send a body with the delete request if provided", async () => {
+        const mockResponse = { message: "Resource deleted successfully" };
+        const mockBody = { reason: "No longer needed" };
+        fetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            json: async () => mockResponse,
+        });
+        const response = await deleteRequest("https://api.example.com/resource", { "Content-Type": "application/json" }, mockBody);
+        expect(fetch).toHaveBeenCalledWith("https://api.example.com/resource", {
+            method: "DELETE",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(mockBody),
+        });
+        expect(response).toEqual({
+            success: true,
+            status: 200,
+            message: "Resource deleted successfully",
+            response: mockResponse,
+            cause: null,
+        });
+    });
+});

package/dist/api/__test__/getRequest.spec.d.ts

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

package/dist/api/__test__/getRequest.spec.d.ts.map

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

package/dist/api/__test__/getRequest.spec.js

@@ -0,0 +1,62 @@
+import { describe, it, expect, vi } from "vitest";
+import { getRequest } from "../getRequest";
+global.fetch = vi.fn();
+describe("getRequest", () => {
+    it("should return success response for a successful request", async () => {
+        const mockResponse = { message: "Request successful", data: { id: 1 } };
+        fetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            json: async () => mockResponse,
+        });
+        const response = await getRequest("https://api.example.com/resource");
+        expect(response).toEqual({
+            success: true,
+            status: 200,
+            message: "Request successful",
+            response: mockResponse,
+            cause: null,
+        });
+    });
+    it("should return failed response for a failed request", async () => {
+        const mockErrorResponse = { error: "Not Found" };
+        fetch.mockResolvedValueOnce({
+            ok: false,
+            status: 404,
+            json: async () => mockErrorResponse,
+        });
+        const response = await getRequest("https://api.example.com/resource");
+        expect(response.success).toBe(false);
+        expect(response.status).toBe(404);
+        expect(response.response).toEqual(mockErrorResponse);
+        expect(response.message).toBeDefined();
+    });
+    it("should handle network errors gracefully", async () => {
+        fetch.mockRejectedValueOnce(new Error("Network Error"));
+        const response = await getRequest("https://api.example.com/resource");
+        expect(response).toEqual({
+            success: false,
+            status: 0,
+            message: "Network error or request failed",
+            response: null,
+            cause: "Network Error",
+        });
+    });
+    it("should handle invalid JSON response gracefully", async () => {
+        fetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            json: async () => {
+                throw new Error("Invalid JSON");
+            },
+        });
+        const response = await getRequest("https://api.example.com/resource");
+        expect(response).toEqual({
+            success: true,
+            status: 200,
+            message: "Request successful",
+            response: null,
+            cause: null,
+        });
+    });
+});

package/dist/api/__test__/inboxFlowRequest.spec.d.ts

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

package/dist/api/__test__/inboxFlowRequest.spec.d.ts.map

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

package/dist/api/__test__/inboxFlowRequest.spec.js

@@ -0,0 +1,96 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { inboxFlowRequest } from "../inboxFlowRequest";
+import { InboxFlowInstance } from "../../config/inboxFlowInstance";
+import { httpDebug } from "../../services/httpDebug";
+vi.mock("../../config/inboxFlowInstance");
+vi.mock("../../services/httpDebug");
+global.fetch = vi.fn();
+describe("inboxFlowRequest", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("should send a POST request with correct body and headers", async () => {
+        const mockConfig = {
+            status: 200,
+            method: "POST",
+            request: "Request data",
+            response: "Response data",
+            token: "test-token",
+        };
+        const mockInboxConfig = {
+            inboxChannelId: "channel-id",
+            inboxUserToken: "user-token",
+            inboxApiUrl: "https://api.example.com/inbox",
+        };
+        InboxFlowInstance.getInboxConfig.mockReturnValue(mockInboxConfig);
+        fetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+        });
+        await inboxFlowRequest(mockConfig);
+        expect(fetch).toHaveBeenCalledWith(mockInboxConfig.inboxApiUrl, {
+            method: "POST",
+            body: JSON.stringify({
+                status: mockConfig.status,
+                channelId: mockInboxConfig.inboxChannelId,
+                method: mockConfig.method,
+                token: mockConfig.token,
+                request: mockConfig.request,
+                response: mockConfig.response,
+            }),
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${mockInboxConfig.inboxUserToken}`,
+            },
+        });
+    });
+    it("should not send a request if inbox configuration is not set", async () => {
+        InboxFlowInstance.getInboxConfig.mockReturnValue(undefined);
+        await inboxFlowRequest({
+            status: 200,
+            method: "POST",
+            request: "Request data",
+            response: "Response data",
+            token: "test-token",
+        });
+        expect(fetch).not.toHaveBeenCalled();
+    });
+    it("should handle fetch errors gracefully", async () => {
+        const mockConfig = {
+            status: 500,
+            method: "ERROR",
+            request: "Request data",
+            response: "Error response",
+            token: "test-token",
+        };
+        const mockInboxConfig = {
+            inboxChannelId: "channel-id",
+            inboxUserToken: "user-token",
+            inboxApiUrl: "https://api.example.com/inbox",
+        };
+        InboxFlowInstance.getInboxConfig.mockReturnValue(mockInboxConfig);
+        fetch.mockRejectedValueOnce(new Error("Network Error"));
+        await inboxFlowRequest(mockConfig);
+        expect(httpDebug).toHaveBeenCalledWith("inboxFlowRequest", "Error sending inbox flow request", expect.any(Error));
+    });
+    it("should not send a request in development environment", async () => {
+        const originalEnv = process.env.NODE_ENV;
+        process.env.NODE_ENV = "development";
+        const mockConfig = {
+            status: 200,
+            method: "POST",
+            request: "Request data",
+            response: "Response data",
+            token: "test-token",
+        };
+        const mockInboxConfig = {
+            inboxChannelId: "channel-id",
+            inboxUserToken: "user-token",
+            inboxApiUrl: "https://api.example.com/inbox",
+        };
+        InboxFlowInstance.getInboxConfig.mockReturnValue(mockInboxConfig);
+        await inboxFlowRequest(mockConfig);
+        expect(fetch).not.toHaveBeenCalled();
+        process.env.NODE_ENV = originalEnv;
+    });
+});

package/dist/api/__test__/makeRequest.spec.d.ts

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

package/dist/api/__test__/makeRequest.spec.d.ts.map

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

package/dist/api/__test__/makeRequest.spec.js

@@ -0,0 +1,80 @@
+import { describe, it, expect, vi } from "vitest";
+import { makeRequest } from "../makeRequest";
+global.fetch = vi.fn();
+describe("makeRequest", () => {
+    it("should return success response for a successful POST request", async () => {
+        const mockResponse = { message: "Resource created successfully" };
+        const mockBody = { name: "New Resource" };
+        fetch.mockResolvedValueOnce({
+            ok: true,
+            status: 201,
+            json: async () => mockResponse,
+        });
+        const response = await makeRequest("POST", "https://api.example.com/resource", { "Content-Type": "application/json" }, mockBody);
+        expect(response).toEqual({
+            success: true,
+            status: 201,
+            message: "Resource created successfully",
+            response: mockResponse,
+            cause: null,
+        });
+    });
+    it("should return failed response for a failed PUT request", async () => {
+        const mockErrorResponse = { error: "Invalid data" };
+        const mockBody = { name: "" };
+        fetch.mockResolvedValueOnce({
+            ok: false,
+            status: 400,
+            json: async () => mockErrorResponse,
+        });
+        const response = await makeRequest("PUT", "https://api.example.com/resource", { "Content-Type": "application/json" }, mockBody);
+        expect(response.success).toBe(false);
+        expect(response.status).toBe(400);
+        expect(response.response).toEqual(mockErrorResponse);
+        expect(response.message).toBeDefined();
+    });
+    it("should handle network errors gracefully", async () => {
+        fetch.mockRejectedValueOnce(new Error("Network Error"));
+        const response = await makeRequest("GET", "https://api.example.com/resource", { "Content-Type": "application/json" });
+        expect(response).toEqual({
+            success: false,
+            status: 0,
+            message: "Network error or request failed",
+            response: null,
+            cause: "Network Error",
+        });
+    });
+    it("should handle invalid JSON response gracefully", async () => {
+        fetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            json: async () => {
+                throw new Error("Invalid JSON");
+            },
+        });
+        const response = await makeRequest("GET", "https://api.example.com/resource", { "Content-Type": "application/json" });
+        expect(response).toEqual({
+            success: true,
+            status: 200,
+            message: "Request successful",
+            response: null,
+            cause: null,
+        });
+    });
+    it("should send headers and body correctly for a DELETE request", async () => {
+        const mockResponse = { message: "Resource deleted successfully" };
+        fetch.mockResolvedValueOnce({
+            ok: true,
+            status: 204,
+            json: async () => mockResponse,
+        });
+        const response = await makeRequest("DELETE", "https://api.example.com/resource", { Authorization: "Bearer token" });
+        expect(response).toEqual({
+            success: true,
+            status: 204,
+            message: "Resource deleted successfully",
+            response: mockResponse,
+            cause: null,
+        });
+    });
+});

package/dist/api/__test__/patchRequest.spec.d.ts

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

package/dist/api/__test__/patchRequest.spec.d.ts.map

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

package/dist/api/__test__/patchRequest.spec.js

@@ -0,0 +1,84 @@
+import { describe, it, expect, vi } from "vitest";
+import { patchRequest } from "../patchRequest";
+global.fetch = vi.fn();
+describe("patchRequest", () => {
+    it("should return success response for a successful patch request", async () => {
+        const mockResponse = { message: "Resource updated successfully" };
+        const mockBody = { name: "Updated Name" };
+        fetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            json: async () => mockResponse,
+        });
+        const response = await patchRequest("https://api.example.com/resource", { "Content-Type": "application/json" }, mockBody);
+        expect(response).toEqual({
+            success: true,
+            status: 200,
+            message: "Resource updated successfully",
+            response: mockResponse,
+            cause: null,
+        });
+    });
+    it("should return failed response for a failed patch request", async () => {
+        const mockErrorResponse = { error: "Resource not found" };
+        const mockBody = { name: "Updated Name" };
+        fetch.mockResolvedValueOnce({
+            ok: false,
+            status: 404,
+            json: async () => mockErrorResponse,
+        });
+        const response = await patchRequest("https://api.example.com/resource", { "Content-Type": "application/json" }, mockBody);
+        expect(response.success).toBe(false);
+        expect(response.status).toBe(404);
+        expect(response.response).toEqual(mockErrorResponse);
+        expect(response.message).toBeDefined();
+    });
+    it("should handle network errors gracefully", async () => {
+        const mockBody = { name: "Updated Name" };
+        fetch.mockRejectedValueOnce(new Error("Network Error"));
+        const response = await patchRequest("https://api.example.com/resource", { "Content-Type": "application/json" }, mockBody);
+        expect(response).toEqual({
+            success: false,
+            status: 0,
+            message: "Network error or request failed",
+            response: null,
+            cause: "Network Error",
+        });
+    });
+    it("should handle invalid JSON response gracefully", async () => {
+        const mockBody = { name: "Updated Name" };
+        fetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            json: async () => {
+                throw new Error("Invalid JSON");
+            },
+        });
+        const response = await patchRequest("https://api.example.com/resource", { "Content-Type": "application/json" }, mockBody);
+        expect(response).toEqual({
+            success: true,
+            status: 200,
+            message: "Resource patched successfully",
+            response: null,
+            cause: null,
+        });
+    });
+    it("should send headers and body correctly", async () => {
+        const mockResponse = { message: "Resource updated successfully" };
+        const mockBody = { name: "Updated Name" };
+        const mockHeaders = { Authorization: "Bearer token" };
+        fetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            json: async () => mockResponse,
+        });
+        const response = await patchRequest("https://api.example.com/resource", mockHeaders, mockBody);
+        expect(response).toEqual({
+            success: true,
+            status: 200,
+            message: "Resource updated successfully",
+            response: mockResponse,
+            cause: null,
+        });
+    });
+});

package/dist/api/__test__/postRequest.spec.d.ts

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

package/dist/api/__test__/postRequest.spec.d.ts.map

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