@arkyn/server 2.0.1-beta.8 → 2.0.1

package/dist/services/errorHandler.js

@@ -12,6 +12,47 @@ 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:
@@ -47,5 +88,6 @@ function errorHandler(error) {
         case error instanceof UnprocessableEntity:
             return error.toResponse();
     }
+    return new ServerError("Server error").toResponse();
 }
 export { errorHandler };

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,iBAAS,SAAS,CAAC,CAAC,SAAS,cAAc,EAAE,CAC3C,QAAQ,EACR,MAAM,EACP,EAAE,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAoB5B;AAED,OAAO,EAAE,SAAS,EAAE,CAAC"}
+{"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

@@ -39,8 +39,10 @@
 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,

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/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/package.json

@@ -1,24 +1,31 @@
 {
   "name": "@arkyn/server",
-  "version": "2.0.1-beta.8",
+  "version": "2.0.1",
   "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": "*",
     "@arkyn/shared": "*",
-    "@aws-sdk/client-s3": "^3.775.0",
-    "@remix-run/node": "^2.16.2",
-    "sharp": "^0.33.5"
+    "@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;
+  });
+});