@arkyn/server 1.9.1 → 1.9.5

package/dist/services/sendFileToS3.js

@@ -1,31 +1,22 @@
+import { generateId } from "@arkyn/shared";
 import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
 import { unstable_composeUploadHandlers as composeUploadHandlers, unstable_createFileUploadHandler as createFileUploadHandler, unstable_parseMultipartFormData as parseMultipartFormData, } from "@remix-run/node";
-import { randomUUID } from "crypto";
 import fs from "fs";
 import sharp from "sharp";
-import { BadRequestError } from "../httpBadResponses/badRequest";
+import { BadRequest } from "../http/badResponses/badRequest";
 import { getScopedParams } from "./getScopedParams";
-async function s3_upload(fileStream, contentType, awsS3Config) {
-    const { AWS_ACCESS_KEY_ID, AWS_REGION, AWS_S3_BUCKET, AWS_SECRET_ACCESS_KEY, } = awsS3Config;
-    const filePath = fileStream.path;
-    let fileName = "";
-    if (typeof filePath === "string") {
-        fileName = filePath.split("/").pop() || "";
-    }
-    else {
-        fileName = randomUUID();
-    }
+async function s3Upload(fileStream, contentType, awsConfig) {
     const uploadParams = {
-        Bucket: AWS_S3_BUCKET,
-        Key: `uploads/${Date.now()}-${fileName.split(" ").join("-")}`,
+        Bucket: awsConfig.AWS_S3_BUCKET,
+        Key: `uploads/${generateId("text", "v4")}`,
         Body: fileStream,
         ContentType: contentType,
     };
     const s3Client = new S3Client({
-        region: AWS_REGION,
+        region: awsConfig.AWS_REGION,
         credentials: {
-            accessKeyId: AWS_ACCESS_KEY_ID,
-            secretAccessKey: AWS_SECRET_ACCESS_KEY,
+            accessKeyId: awsConfig.AWS_ACCESS_KEY_ID,
+            secretAccessKey: awsConfig.AWS_SECRET_ACCESS_KEY,
         },
     });
     const command = new PutObjectCommand(uploadParams);
@@ -36,15 +27,64 @@ async function s3_upload(fileStream, contentType, awsS3Config) {
         console.error(error);
     }
     return {
-        location: `https://${AWS_S3_BUCKET}.s3.amazonaws.com/${uploadParams.Key}`,
+        location: `https://${awsConfig.AWS_S3_BUCKET}.s3.amazonaws.com/${uploadParams.Key}`,
     };
 }
-async function sendFileToS3(props, awsS3Config, config = {
-    maxPartSize: 5_000_000,
-    fileName: "file",
-}) {
-    const { fileName = "file", maxPartSize = 5_000_000 } = config;
-    const { request } = props;
+/**
+ * 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);
+ * }
+ * ```
+ */
+const sendFileToS3 = async (request, awsS3Config, config) => {
+    const fileName = config?.fileName || "file";
+    const maxPartSize = config?.maxPartSize || 5_000_000;
+    const reduceImageQuality = config?.reduceImageQuality || 100;
+    const validateImageSize = config?.validateImageSize || false;
+    const validateImageMessage = config?.validateImageMessage ||
+        "Invalid dimensions {{width}}px x {{height}}px";
     const uploadHandler = composeUploadHandlers(createFileUploadHandler({
         maxPartSize,
         file: ({ filename }) => filename,
@@ -52,14 +92,14 @@ async function sendFileToS3(props, awsS3Config, config = {
     const formData = await parseMultipartFormData(request, uploadHandler);
     const file = formData.get(fileName);
     if (!file)
-        throw new BadRequestError("No file uploaded");
+        throw new BadRequest("No file uploaded");
     const filterParams = getScopedParams(request);
     const width = filterParams.get("w");
     const height = filterParams.get("h");
     const reduceQuality = filterParams.get("reduceQuality");
-    const quality = reduceQuality ? +reduceQuality : 100;
+    const quality = reduceQuality ? +reduceQuality : reduceImageQuality;
     const isImage = file.type.startsWith("image");
-    if (isImage && width && height) {
+    if (isImage && width && height && validateImageSize) {
         const image = sharp(file.getFilePath());
         const metadata = await image.metadata();
         if (metadata.width && metadata.height) {
@@ -67,7 +107,9 @@ async function sendFileToS3(props, awsS3Config, config = {
             const heightDiff = Math.abs(metadata.height - +height);
             if (widthDiff > 10 || heightDiff > 10) {
                 return {
-                    error: `Formato inválido ${metadata.width}px x ${metadata.height}px`,
+                    error: validateImageMessage
+                        .replace("{{width}}", width)
+                        .replace("{{height}}", height),
                 };
             }
         }
@@ -87,7 +129,7 @@ async function sendFileToS3(props, awsS3Config, config = {
         await image.toFile(compressedFilePath);
         file.getFilePath = () => compressedFilePath;
         const streamFile = fs.createReadStream(file.getFilePath());
-        const apiResponse = await s3_upload(streamFile, file.type, awsS3Config);
+        const apiResponse = await s3Upload(streamFile, file.type, awsS3Config);
         fs.unlink(compressedFilePath, (err) => {
             if (err)
                 console.error(`Delete image error: ${err}`);
@@ -95,7 +137,7 @@ async function sendFileToS3(props, awsS3Config, config = {
         return { url: apiResponse.location };
     }
     const streamFile = fs.createReadStream(file.getFilePath());
-    const apiResponse = await s3_upload(streamFile, file.type, awsS3Config);
+    const apiResponse = await s3Upload(streamFile, file.type, awsS3Config);
     return { url: apiResponse.location };
-}
+};
 export { sendFileToS3 };

package/package.json

@@ -1,23 +1,31 @@
 {
   "name": "@arkyn/server",
-  "version": "1.9.1",
+  "version": "1.9.5",
   "main": "./dist/bundle.js",
   "module": "./src/index.ts",
   "type": "module",
   "types": "./dist/index.d.ts",
+  "license": "Apache-2.0",
+  "author": "Arkyn | Lucas Gonçalves",
+  "description": "Server-side utilities for projects.",
   "scripts": {
     "clean": "rm -rf dist",
     "build": "bun run clean && bunx tsc --project tsconfig.json",
+    "test": "vitest --config vitest.config.ts",
     "typecheck": "bunx tsc --project tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@arkyn/server": "*",
-    "@aws-sdk/client-s3": "^3.775.0",
-    "@remix-run/node": "^2.16.2",
-    "sharp": "^0.33.5"
+    "@arkyn/shared": "*",
+    "@aws-sdk/client-s3": "^3.782.0",
+    "sharp": "^0.33.5",
+    "zod": "^3.24.2"
+  },
+  "peerDependencies": {
+    "@remix-run/node": "^2.16.4"
   },
   "devDependencies": {
     "bun-types": "latest",
-    "typescript": "^5.8.2"
+    "vitest": "^3.1.1",
+    "typescript": "^5.8.3"
   }
 }

package/src/api/__test__/deleteRequest.spec.ts

@@ -0,0 +1,107 @@
+import { describe, it, expect, vi } from "vitest";
+import { deleteRequest } from "../deleteRequest";
+
+global.fetch = vi.fn() as any;
+
+describe("deleteRequest", () => {
+  it("should return success response for a successfully delete request", async () => {
+    const mockResponse = { message: "Resource deleted successfully" };
+    (fetch as any).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 as any).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 as any).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 as any).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 as any).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/src/api/__test__/getRequest.spec.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect, vi } from "vitest";
+import { getRequest } from "../getRequest";
+
+global.fetch = vi.fn() as any;
+
+describe("getRequest", () => {
+  it("should return success response for a successful request", async () => {
+    const mockResponse = { message: "Request successful", data: { id: 1 } };
+    (fetch as any).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 as any).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 as any).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 as any).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/src/api/__test__/inboxFlowRequest.spec.ts

@@ -0,0 +1,125 @@
+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() as any;
+
+describe("inboxFlowRequest", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should send a POST request with correct body and headers", async () => {
+    const mockConfig = {
+      status: 200,
+      method: "POST" as any,
+      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 as any).mockReturnValue(mockInboxConfig);
+
+    (fetch as any).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 as any).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" as any,
+      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 as any).mockReturnValue(mockInboxConfig);
+
+    (fetch as any).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" as any,
+      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 as any).mockReturnValue(mockInboxConfig);
+
+    await inboxFlowRequest(mockConfig);
+
+    expect(fetch).not.toHaveBeenCalled();
+
+    process.env.NODE_ENV = originalEnv;
+  });
+});

package/src/api/__test__/makeRequest.spec.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect, vi } from "vitest";
+import { makeRequest } from "../makeRequest";
+
+global.fetch = vi.fn() as any;
+
+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 as any).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 as any).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 as any).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 as any).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 as any).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,
+    });
+  });
+});