@arkyn/server 2.0.1-beta.8 → 2.0.1

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,
+    });
+  });
+});

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

@@ -0,0 +1,125 @@
+import { describe, it, expect, vi } from "vitest";
+import { patchRequest } from "../patchRequest";
+
+global.fetch = vi.fn() as any;
+
+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 as any).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 as any).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 as any).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 as any).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 as any).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/src/api/__test__/postRequest.spec.ts

@@ -0,0 +1,125 @@
+import { describe, it, expect, vi } from "vitest";
+import { postRequest } from "../postRequest";
+
+global.fetch = vi.fn() as any;
+
+describe("postRequest", () => {
+  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 postRequest(
+      "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 POST request", async () => {
+    const mockErrorResponse = { error: "Invalid data" };
+    const mockBody = { name: "" };
+
+    (fetch as any).mockResolvedValueOnce({
+      ok: false,
+      status: 400,
+      json: async () => mockErrorResponse,
+    });
+
+    const response = await postRequest(
+      "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 () => {
+    const mockBody = { name: "New Resource" };
+
+    (fetch as any).mockRejectedValueOnce(new Error("Network Error"));
+
+    const response = await postRequest(
+      "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: "New Resource" };
+
+    (fetch as any).mockResolvedValueOnce({
+      ok: true,
+      status: 201,
+      json: async () => {
+        throw new Error("Invalid JSON");
+      },
+    });
+
+    const response = await postRequest(
+      "https://api.example.com/resource",
+      { "Content-Type": "application/json" },
+      mockBody
+    );
+
+    expect(response).toEqual({
+      success: true,
+      status: 201,
+      message: "Resource created successfully",
+      response: null,
+      cause: null,
+    });
+  });
+
+  it("should send headers and body correctly", async () => {
+    const mockResponse = { message: "Resource created successfully" };
+    const mockBody = { name: "New Resource" };
+    const mockHeaders = { Authorization: "Bearer token" };
+
+    (fetch as any).mockResolvedValueOnce({
+      ok: true,
+      status: 201,
+      json: async () => mockResponse,
+    });
+
+    const response = await postRequest(
+      "https://api.example.com/resource",
+      mockHeaders,
+      mockBody
+    );
+
+    expect(response).toEqual({
+      success: true,
+      status: 201,
+      message: "Resource created successfully",
+      response: mockResponse,
+      cause: null,
+    });
+  });
+});

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

@@ -0,0 +1,125 @@
+import { describe, it, expect, vi } from "vitest";
+import { putRequest } from "../putRequest";
+
+global.fetch = vi.fn() as any;
+
+describe("putRequest", () => {
+  it("should return success response for a successful PUT request", async () => {
+    const mockResponse = { message: "Resource updated successfully" };
+    const mockBody = { name: "Updated Resource" };
+
+    (fetch as any).mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: async () => mockResponse,
+    });
+
+    const response = await putRequest(
+      "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 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 putRequest(
+      "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 () => {
+    const mockBody = { name: "Updated Resource" };
+
+    (fetch as any).mockRejectedValueOnce(new Error("Network Error"));
+
+    const response = await putRequest(
+      "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 Resource" };
+
+    (fetch as any).mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: async () => {
+        throw new Error("Invalid JSON");
+      },
+    });
+
+    const response = await putRequest(
+      "https://api.example.com/resource",
+      { "Content-Type": "application/json" },
+      mockBody
+    );
+
+    expect(response).toEqual({
+      success: true,
+      status: 200,
+      message: "Resource updated successfully",
+      response: null,
+      cause: null,
+    });
+  });
+
+  it("should send headers and body correctly", async () => {
+    const mockResponse = { message: "Resource updated successfully" };
+    const mockBody = { name: "Updated Resource" };
+    const mockHeaders = { Authorization: "Bearer token" };
+
+    (fetch as any).mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: async () => mockResponse,
+    });
+
+    const response = await putRequest(
+      "https://api.example.com/resource",
+      mockHeaders,
+      mockBody
+    );
+
+    expect(response).toEqual({
+      success: true,
+      status: 200,
+      message: "Resource updated successfully",
+      response: mockResponse,
+      cause: null,
+    });
+  });
+});

package/src/api/deleteRequest.ts

@@ -0,0 +1,22 @@
+import type { ApiResponseDTO } from "@arkyn/types";
+import { makeRequest } from "./makeRequest";
+
+/**
+ * Sends a DELETE request to the specified URL with optional headers and body.
+ *
+ * @template T - The expected type of the response data.
+ * @param {string} url - The URL to send the DELETE request to.
+ * @param {HeadersInit} [headers={}] - Optional headers to include in the request.
+ * @param {any} [body] - Optional body to include in the request.
+ * @returns {Promise<ApiResponseDTO<T>>} A promise that resolves to the API response.
+ */
+
+async function deleteRequest<T = any>(
+  url: string,
+  headers: HeadersInit = {},
+  body?: any
+): Promise<ApiResponseDTO<T>> {
+  return makeRequest("DELETE", url, headers, body);
+}
+
+export { deleteRequest };

package/src/api/getRequest.ts

@@ -0,0 +1,20 @@
+import type { ApiResponseDTO } from "@arkyn/types";
+import { makeRequest } from "./makeRequest";
+
+/**
+ * Sends a GET request to the specified URL with optional headers.
+ *
+ * @template T - The expected type of the response data.
+ * @param {string} url - The URL to send the GET request to.
+ * @param {HeadersInit} [headers={}] - Optional headers to include in the request.
+ * @returns {Promise<ApiResponseDTO<T>>} A promise that resolves to the API response.
+ */
+
+async function getRequest<T = any>(
+  url: string,
+  headers: HeadersInit = {}
+): Promise<ApiResponseDTO<T>> {
+  return makeRequest("GET", url, headers);
+}
+
+export { getRequest };

package/src/api/inboxFlowRequest.ts

@@ -0,0 +1,76 @@
+import { InboxFlowInstance } from "../config/inboxFlowInstance";
+import { httpDebug } from "../services/httpDebug";
+
+type ConfigProps = {
+  status: number;
+  method: "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | "ERROR";
+  request: string;
+  response: string;
+  token: string;
+};
+
+/**
+ * Sends a request to the inbox flow API with the provided configuration.
+ *
+ * @param config - The configuration object for the request.
+ * @param config.status - The HTTP status code associated with the request.
+ * @param config.method - The HTTP method used for the request. Can be "POST", "GET", "PUT", "DELETE", "PATCH", or "ERROR".
+ * @param config.request - The request payload or details as a string.
+ * @param config.response - The response payload or details as a string.
+ * @param config.token - The token associated with the request for authentication or identification.
+ *
+ * @remarks
+ * - This function retrieves the inbox flow configuration using `InboxFlowInstance.getInboxConfig()`.
+ * - If the configuration is not available, the function will return early without performing any action.
+ * - In a development environment (`NODE_ENV === "development"`), the function will also return early.
+ * - The request is sent as a POST request to the inbox API URL with the provided configuration details.
+ * - If an error occurs during the request, it will be logged using the `httpDebug` service.
+ *
+ * @example
+ * ```typescript
+ * const config = {
+ *   status: 200,
+ *   method: "POST",
+ *   request: JSON.stringify({ key: "value" }),
+ *   response: JSON.stringify({ success: true }),
+ *   token: "example-token",
+ * };
+ *
+ * await inboxFlowRequest(config);
+ * ```
+ */
+
+async function inboxFlowRequest(config: ConfigProps) {
+  const inboxFlowInstance = InboxFlowInstance.getInboxConfig();
+  if (!inboxFlowInstance) return;
+
+  const { inboxChannelId, inboxUserToken, inboxApiUrl } = inboxFlowInstance;
+
+  const { status, method, request, response, token } = config;
+
+  if (process.env.NODE_ENV === "development") return;
+
+  try {
+    const body = JSON.stringify({
+      status,
+      channelId: inboxChannelId,
+      method,
+      token,
+      request,
+      response,
+    });
+
+    await fetch(inboxApiUrl, {
+      method: "POST",
+      body,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${inboxUserToken}`,
+      },
+    });
+  } catch (err) {
+    httpDebug("inboxFlowRequest", "Error sending inbox flow request", err);
+  }
+}
+
+export { inboxFlowRequest };