@arkyn/server 2.0.1 → 2.0.2

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

@@ -1,125 +0,0 @@
-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

@@ -1,125 +0,0 @@
-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

@@ -1,125 +0,0 @@
-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/config/__test__/apiInstance.spec.ts

@@ -1,129 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { ApiInstance } from "../apiInstance";
-import { getRequest } from "../../api/getRequest";
-import { postRequest } from "../../api/postRequest";
-import { putRequest } from "../../api/putRequest";
-import { patchRequest } from "../../api/patchRequest";
-import { deleteRequest } from "../../api/deleteRequest";
-
-vi.mock("../../api/getRequest");
-vi.mock("../../api/postRequest");
-vi.mock("../../api/putRequest");
-vi.mock("../../api/patchRequest");
-vi.mock("../../api/deleteRequest");
-
-describe("ApiInstance", () => {
-  const baseUrl = "https://api.example.com";
-  const baseHeaders = { "Content-Type": "application/json" };
-  const baseToken = "base-token";
-
-  const apiInstance = new ApiInstance({
-    baseUrl,
-    baseHeaders,
-    baseToken,
-  });
-
-  it("should send a GET request with correct headers and URL", async () => {
-    const mockResponse = { success: true, data: "GET response" };
-    (getRequest as any).mockResolvedValueOnce(mockResponse);
-
-    const response = await apiInstance.GET("/resource", {});
-
-    expect(getRequest).toHaveBeenCalledWith(
-      `${baseUrl}/resource`,
-      expect.objectContaining({
-        Authorization: `Bearer ${baseToken}`,
-        "Content-Type": "application/json",
-      })
-    );
-    expect(response).toEqual(mockResponse);
-  });
-
-  it("should send a POST request with correct headers, URL, and body", async () => {
-    const mockResponse = { success: true, data: "POST response" };
-    const mockBody = { name: "New Resource" };
-    (postRequest as any).mockResolvedValueOnce(mockResponse);
-
-    const response = await apiInstance.POST("/resource", { body: mockBody });
-
-    expect(postRequest).toHaveBeenCalledWith(
-      `${baseUrl}/resource`,
-      expect.objectContaining({
-        Authorization: `Bearer ${baseToken}`,
-        "Content-Type": "application/json",
-      }),
-      mockBody
-    );
-    expect(response).toEqual(mockResponse);
-  });
-
-  it("should send a PUT request with correct headers, URL, and body", async () => {
-    const mockResponse = { success: true, data: "PUT response" };
-    const mockBody = { name: "Updated Resource" };
-    (putRequest as any).mockResolvedValueOnce(mockResponse);
-
-    const response = await apiInstance.PUT("/resource", { body: mockBody });
-
-    expect(putRequest).toHaveBeenCalledWith(
-      `${baseUrl}/resource`,
-      expect.objectContaining({
-        Authorization: `Bearer ${baseToken}`,
-        "Content-Type": "application/json",
-      }),
-      mockBody
-    );
-    expect(response).toEqual(mockResponse);
-  });
-
-  it("should send a PATCH request with correct headers, URL, and body", async () => {
-    const mockResponse = { success: true, data: "PATCH response" };
-    const mockBody = { name: "Partially Updated Resource" };
-    (patchRequest as any).mockResolvedValueOnce(mockResponse);
-
-    const response = await apiInstance.PATCH("/resource", { body: mockBody });
-
-    expect(patchRequest).toHaveBeenCalledWith(
-      `${baseUrl}/resource`,
-      expect.objectContaining({
-        Authorization: `Bearer ${baseToken}`,
-        "Content-Type": "application/json",
-      }),
-      mockBody
-    );
-    expect(response).toEqual(mockResponse);
-  });
-
-  it("should send a DELETE request with correct headers, URL, and body", async () => {
-    const mockResponse = { success: true, data: "DELETE response" };
-    const mockBody = { id: 1 };
-    (deleteRequest as any).mockResolvedValueOnce(mockResponse);
-
-    const response = await apiInstance.DELETE("/resource", { body: mockBody });
-
-    expect(deleteRequest).toHaveBeenCalledWith(
-      `${baseUrl}/resource`,
-      expect.objectContaining({
-        Authorization: `Bearer ${baseToken}`,
-        "Content-Type": "application/json",
-      }),
-      mockBody
-    );
-    expect(response).toEqual(mockResponse);
-  });
-
-  it("should override base token with provided token", async () => {
-    const mockResponse = { success: true, data: "GET response with token" };
-    (getRequest as any).mockResolvedValueOnce(mockResponse);
-
-    const response = await apiInstance.GET("/resource", { token: "new-token" });
-
-    expect(getRequest).toHaveBeenCalledWith(
-      `${baseUrl}/resource`,
-      expect.objectContaining({
-        Authorization: `Bearer new-token`,
-        "Content-Type": "application/json",
-      })
-    );
-    expect(response).toEqual(mockResponse);
-  });
-});

package/src/config/__test__/inboxFlowInstance.spec.ts

@@ -1,61 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { InboxFlowInstance } from "../inboxFlowInstance";
-
-describe("InboxFlowInstance", () => {
-  it("should set the inbox configuration if not already set", () => {
-    const inboxConfig = {
-      inboxChannelId: "channel-123",
-      inboxUserToken: "user-token-abc",
-      inboxApiUrl: "https://custom-inbox-api.com",
-    };
-
-    InboxFlowInstance.setInboxConfig(inboxConfig);
-
-    const config = InboxFlowInstance.getInboxConfig();
-    expect(config).toEqual(inboxConfig);
-  });
-
-  it("should not overwrite the inbox configuration if already set", () => {
-    const initialConfig = {
-      inboxChannelId: "channel-123",
-      inboxUserToken: "user-token-abc",
-      inboxApiUrl: "https://custom-inbox-api.com",
-    };
-
-    const newConfig = {
-      inboxChannelId: "channel-456",
-      inboxUserToken: "user-token-def",
-      inboxApiUrl: "https://another-inbox-api.com",
-    };
-
-    InboxFlowInstance.setInboxConfig(initialConfig);
-    InboxFlowInstance.setInboxConfig(newConfig);
-
-    const config = InboxFlowInstance.getInboxConfig();
-    expect(config).toEqual(initialConfig);
-  });
-
-  it("should return undefined if no configuration is set", () => {
-    InboxFlowInstance.resetInboxConfig();
-
-    const config = InboxFlowInstance.getInboxConfig();
-    expect(config).toBeUndefined();
-  });
-
-  it("should use the default API URL if none is provided", () => {
-    const inboxConfig = {
-      inboxChannelId: "channel-123",
-      inboxUserToken: "user-token-abc",
-    };
-
-    const defaultInboxURL = `https://logs-inbox-flow-logs.vw6wo7.easypanel.host/api/call`;
-
-    InboxFlowInstance.setInboxConfig(inboxConfig);
-
-    const config = InboxFlowInstance.getInboxConfig();
-    expect(config).toEqual({
-      ...inboxConfig,
-      inboxApiUrl: defaultInboxURL,
-    });
-  });
-});

package/src/http/badResponses/__test__/badGateway.spec.ts

@@ -1,50 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { BadGateway } from "../badGateway";
-
-describe("BadGateway", () => {
-  it("should create an instance with the correct properties", () => {
-    const message = "Bad Gateway error occurred";
-    const cause = { reason: "Upstream server is down" };
-    const error = new BadGateway(message, cause);
-
-    expect(error.body).toEqual({ name: "BadGateway", message });
-    expect(error.status).toBe(502);
-    expect(error.statusText).toBe(message);
-    expect(error.cause).toBe(JSON.stringify(cause));
-  });
-
-  it("should create an instance without a cause", () => {
-    const message = "Bad Gateway error occurred";
-    const error = new BadGateway(message);
-
-    expect(error.body).toEqual({ name: "BadGateway", message });
-    expect(error.status).toBe(502);
-    expect(error.statusText).toBe(message);
-    expect(error.cause).toBeUndefined();
-  });
-
-  it("should return a Response object from toResponse", () => {
-    const message = "Bad Gateway error occurred";
-    const error = new BadGateway(message);
-    const response = error.toResponse();
-
-    expect(response.status).toBe(502);
-    expect(response.statusText).toBe(message);
-    expect(response.headers.get("Content-Type")).toBe("application/json");
-    response.json().then((body) => {
-      expect(body).toEqual({ name: "BadGateway", message });
-    });
-  });
-
-  it("should return a Response object from toJson", () => {
-    const message = "Bad Gateway error occurred";
-    const error = new BadGateway(message);
-    const response = error.toJson();
-
-    expect(response.status).toBe(502);
-    expect(response.statusText).toBe(message);
-    response.json().then((body) => {
-      expect(body).toEqual({ name: "BadGateway", message });
-    });
-  });
-});

package/src/http/badResponses/__test__/badRequest.spec.ts

@@ -1,50 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { BadRequest } from "../badRequest";
-
-describe("BadRequest", () => {
-  it("should create an instance with the correct properties", () => {
-    const message = "Invalid request data";
-    const cause = { field: "email", error: "Invalid format" };
-    const error = new BadRequest(message, cause);
-
-    expect(error.body).toEqual({ name: "BadRequest", message });
-    expect(error.status).toBe(400);
-    expect(error.statusText).toBe(message);
-    expect(error.cause).toBe(JSON.stringify(cause));
-  });
-
-  it("should create an instance without a cause", () => {
-    const message = "Invalid request data";
-    const error = new BadRequest(message);
-
-    expect(error.body).toEqual({ name: "BadRequest", message });
-    expect(error.status).toBe(400);
-    expect(error.statusText).toBe(message);
-    expect(error.cause).toBeUndefined();
-  });
-
-  it("should return a Response object from toResponse", async () => {
-    const message = "Invalid request data";
-    const error = new BadRequest(message);
-    const response = error.toResponse();
-
-    expect(response.status).toBe(400);
-    expect(response.statusText).toBe(message);
-    expect(response.headers.get("Content-Type")).toBe("application/json");
-
-    const body = await response.json();
-    expect(body).toEqual({ name: "BadRequest", message });
-  });
-
-  it("should return a Response object from toJson", async () => {
-    const message = "Invalid request data";
-    const error = new BadRequest(message);
-    const response = error.toJson();
-
-    expect(response.status).toBe(400);
-    expect(response.statusText).toBe(message);
-
-    const body = await response.json();
-    expect(body).toEqual({ name: "BadRequest", message });
-  });
-});