@arkyn/server 2.0.1 → 2.0.2

package/dist/services/__test__/getScopedParams.spec.js

@@ -1,51 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getScopedParams } from "../getScopedParams";
-describe("getScopedParams", () => {
-    it("should return all query parameters when no scope is provided", () => {
-        const request = {
-            url: "https://example.com?key1=value1&key2=value2",
-        };
-        const params = getScopedParams(request);
-        expect(params.get("key1")).toBe("value1");
-        expect(params.get("key2")).toBe("value2");
-        expect(params.toString()).toBe("key1=value1&key2=value2");
-    });
-    it("should return only scoped query parameters when a scope is provided", () => {
-        const request = {
-            url: "https://example.com?scope:key1=value1&scope:key2=value2&key3=value3",
-        };
-        const params = getScopedParams(request, "scope");
-        expect(params.get("key1")).toBe("value1");
-        expect(params.get("key2")).toBe("value2");
-        expect(params.get("key3")).toBeNull();
-        expect(params.toString()).toBe("key1=value1&key2=value2");
-    });
-    it("should return an empty URLSearchParams object if no parameters match the scope", () => {
-        const request = {
-            url: "https://example.com?key1=value1&key2=value2",
-        };
-        const params = getScopedParams(request, "scope");
-        expect(params.toString()).toBe("");
-    });
-    it("should handle URLs with no query parameters", () => {
-        const request = { url: "https://example.com" };
-        const params = getScopedParams(request);
-        expect(params.toString()).toBe("");
-    });
-    it("should handle URLs with query parameters but no matching scope", () => {
-        const request = {
-            url: "https://example.com?other:key1=value1&other:key2=value2",
-        };
-        const params = getScopedParams(request, "scope");
-        expect(params.toString()).toBe("");
-    });
-    it("should handle special characters in query parameter keys and values", () => {
-        const request = {
-            url: "https://example.com?scope:key+1=value+1&scope:key+2=value+2",
-        };
-        const params = getScopedParams(request, "scope");
-        expect(params.get("key 1")).toBe("value 1");
-        expect(params.get("key 2")).toBe("value 2");
-        expect(params.toString()).toBe("key+1=value+1&key+2=value+2");
-    });
-});

package/dist/services/__test__/schemaValidator.spec.d.ts

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

package/dist/services/__test__/schemaValidator.spec.d.ts.map

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

package/dist/services/__test__/schemaValidator.spec.js

@@ -1,89 +0,0 @@
-import { z } from "zod";
-import { SchemaValidator } from "../schemaValidator";
-import { httpDebug } from "../httpDebug";
-import { ServerError } from "../../http/badResponses/serverError";
-import { UnprocessableEntity } from "../../http/badResponses/unprocessableEntity";
-import { describe, expect, it, vi } from "vitest";
-vi.mock("../getCaller", () => ({
-    getCaller: vi.fn(() => ({
-        callerInfo: "mockedCallerInfo",
-        functionName: "mockedFunctionName",
-    })),
-}));
-vi.mock("../httpDebug", () => ({
-    httpDebug: vi.fn(),
-}));
-describe("SchemaValidator", () => {
-    const schema = z.object({
-        name: z.string().min(1, "Name is required"),
-        age: z.number().min(18, "Must be at least 18"),
-    });
-    const validator = new SchemaValidator(schema);
-    describe("constructor", () => {
-        it("should initialize with caller info and function name", () => {
-            expect(validator.callerInfo).toBe("mockedCallerInfo");
-            expect(validator.functionName).toBe("mockedFunctionName");
-        });
-    });
-    describe("isValid", () => {
-        it("should return true for valid data", () => {
-            const data = { name: "John", age: 25 };
-            expect(validator.isValid(data)).toBe(true);
-        });
-        it("should return false for invalid data", () => {
-            const data = { name: "", age: 17 };
-            expect(validator.isValid(data)).toBe(false);
-        });
-    });
-    describe("safeValidate", () => {
-        it("should return success for valid data", () => {
-            const data = { name: "John", age: 25 };
-            const result = validator.safeValidate(data);
-            expect(result.success).toBe(true);
-            expect(result.data).toEqual(data);
-        });
-        it("should return failure for invalid data", () => {
-            const data = { name: "", age: 17 };
-            const result = validator.safeValidate(data);
-            expect(result.success).toBe(false);
-            if (!result.success)
-                expect(result.error.issues).toHaveLength(2);
-        });
-    });
-    describe("validate", () => {
-        it("should return parsed data for valid input", () => {
-            const data = { name: "John", age: 25 };
-            expect(validator.validate(data)).toEqual(data);
-        });
-        it("should throw ServerError for invalid input", () => {
-            const data = { name: "", age: 17 };
-            expect(() => validator.validate(data)).toThrow(ServerError);
-        });
-    });
-    describe("formValidate", () => {
-        it("should return parsed data for valid input", () => {
-            const data = { name: "John", age: 25 };
-            expect(validator.formValidate(data)).toEqual(data);
-        });
-        it("should throw UnprocessableEntity for invalid input", () => {
-            const data = { name: "", age: 17 };
-            expect(() => validator.formValidate(data)).toThrow(UnprocessableEntity);
-        });
-        it("should call httpDebug with formParsed data on validation failure", () => {
-            const data = { name: "", age: 17 };
-            try {
-                validator.formValidate(data);
-            }
-            catch (error) {
-                // Ignore the error
-            }
-            expect(httpDebug).toHaveBeenCalledWith("UnprocessableEntity", expect.objectContaining({
-                success: false,
-                fieldErrors: {
-                    name: "Name is required",
-                    age: "Must be at least 18",
-                },
-            }));
-        });
-    });
-});

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

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

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

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

@@ -1,121 +0,0 @@
-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,
-    });
-  });
-});