@arkyn/server 2.0.1 → 2.0.2

package/src/http/successResponses/__test__/updated.spec.ts

@@ -1,68 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { Updated } from "../updated";
-
-describe("Updated", () => {
-  it("should create a response with default values", () => {
-    const body = { message: "Resource updated" };
-    const updated = new Updated(body);
-
-    const response = updated.toResponse();
-    expect(response.status).toBe(200);
-    expect(response.statusText).toBe("Resource updated successfully");
-    expect(response.headers.get("Content-Type")).toBe("application/json");
-    return response.json().then((data) => {
-      expect(data).toEqual(body);
-    });
-  });
-
-  it("should create a response with custom values", () => {
-    const body = { message: "Custom update" };
-    const init = {
-      headers: { "X-Custom-Header": "CustomValue" },
-      status: 202,
-      statusText: "Accepted",
-    };
-    const updated = new Updated(body, init);
-
-    const response = updated.toResponse();
-    expect(response.status).toBe(202);
-    expect(response.statusText).toBe("Accepted");
-    expect(response.headers.get("Content-Type")).toBe("application/json");
-    expect(response.headers.get("X-Custom-Header")).toBe("CustomValue");
-    return response.json().then((data) => {
-      expect(data).toEqual(body);
-    });
-  });
-
-  it("should create a JSON response with default values using toJson", () => {
-    const body = { message: "Resource updated" };
-    const updated = new Updated(body);
-
-    const response = updated.toJson();
-    expect(response.status).toBe(200);
-    expect(response.statusText).toBe("Resource updated successfully");
-    expect(response.headers.get("Content-Type")).toBe("application/json");
-    return response.json().then((data) => {
-      expect(data).toEqual(body);
-    });
-  });
-
-  it("should create a JSON response with custom values using toJson", () => {
-    const body = { message: "Custom update" };
-    const init = {
-      headers: { "X-Custom-Header": "CustomValue" },
-      status: 202,
-      statusText: "Accepted",
-    };
-    const updated = new Updated(body, init);
-
-    const response = updated.toJson();
-    expect(response.status).toBe(202);
-    expect(response.statusText).toBe("Accepted");
-    expect(response.headers.get("Content-Type")).toBe("application/json");
-    expect(response.headers.get("X-Custom-Header")).toBe("CustomValue");
-    return response.json().then((data) => {
-      expect(data).toEqual(body);
-    });
-  });
-});

package/src/services/__test__/decodeRequestBody.spec.ts

@@ -1,51 +0,0 @@
-import { decodeRequestBody } from "../decodeRequestBody";
-import { BadRequest } from "../../http/badResponses/badRequest";
-import { describe, expect, it } from "vitest";
-
-describe("decodeRequestBody", () => {
-  it("should decode the request body as JSON", async () => {
-    const mockRequest = {
-      arrayBuffer: async () =>
-        new TextEncoder().encode(JSON.stringify({ key: "value" })).buffer,
-    };
-
-    const result = await decodeRequestBody(mockRequest as any);
-    expect(result).toEqual({ key: "value" });
-  });
-
-  it("should decode the request body as URL-encoded form data", async () => {
-    const mockRequest = {
-      arrayBuffer: async () =>
-        new TextEncoder().encode("key=value&anotherKey=anotherValue").buffer,
-    };
-
-    const result = await decodeRequestBody(mockRequest as any);
-    expect(result).toEqual({ key: "value", anotherKey: "anotherValue" });
-  });
-
-  it("should throw BadRequest if the text is neither valid JSON nor URL-encoded", async () => {
-    const mockRequest = {
-      arrayBuffer: async () => new TextEncoder().encode("{invalidJson").buffer,
-    };
-
-    await expect(decodeRequestBody(mockRequest as any)).rejects.toThrow();
-  });
-
-  it("should throw BadRequest if the text is not a valid format for URLSearchParams", async () => {
-    const mockRequest = {
-      arrayBuffer: async () => new TextEncoder().encode("invalidFormat").buffer,
-    };
-
-    await expect(decodeRequestBody(mockRequest as any)).rejects.toThrow();
-  });
-
-  it("should throw BadRequest if an error occurs while reading the body", async () => {
-    const mockRequest = {
-      arrayBuffer: async () => {
-        throw new Error("Error reading the body");
-      },
-    };
-
-    await expect(decodeRequestBody(mockRequest as any)).rejects.toThrow();
-  });
-});

package/src/services/__test__/errorHandler.spec.ts

@@ -1,133 +0,0 @@
-import { errorHandler } from "../errorHandler";
-import { Found } from "../../http/successResponses/found";
-import { Created } from "../../http/successResponses/created";
-import { Updated } from "../../http/successResponses/updated";
-import { Success } from "../../http/successResponses/success";
-import { NoContent } from "../../http/successResponses/noContent";
-
-import { BadGateway } from "../../http/badResponses/badGateway";
-import { BadRequest } from "../../http/badResponses/badRequest";
-import { Conflict } from "../../http/badResponses/conflict";
-import { Forbidden } from "../../http/badResponses/forbidden";
-import { NotFound } from "../../http/badResponses/notFound";
-import { NotImplemented } from "../../http/badResponses/notImplemented";
-import { ServerError } from "../../http/badResponses/serverError";
-import { Unauthorized } from "../../http/badResponses/unauthorized";
-import { UnprocessableEntity } from "../../http/badResponses/unprocessableEntity";
-import { describe, expect, it } from "vitest";
-
-describe("errorHandler", () => {
-  describe("Success Responses", () => {
-    it("should handle Found response", () => {
-      const found = new Found("Resource found");
-      const response = errorHandler(found);
-      expect(response.status).toBe(found.toResponse().status);
-      expect(response.statusText).toBe(found.toResponse().statusText);
-    });
-
-    it("should handle Created response", () => {
-      const created = new Created("Resource created");
-      const response = errorHandler(created);
-      expect(response.status).toBe(created.toResponse().status);
-      expect(response.statusText).toBe(created.toResponse().statusText);
-    });
-
-    it("should handle Updated response", () => {
-      const updated = new Updated("Resource updated");
-      const response = errorHandler(updated);
-      expect(response.status).toBe(updated.toResponse().status);
-      expect(response.statusText).toBe(updated.toResponse().statusText);
-    });
-
-    it("should handle Success response", () => {
-      const success = new Success("Operation successful");
-      const response = errorHandler(success);
-      expect(response.status).toBe(success.toResponse().status);
-      expect(response.statusText).toBe(success.toResponse().statusText);
-    });
-
-    it("should handle NoContent response", () => {
-      const noContent = new NoContent();
-      const response = errorHandler(noContent);
-      expect(response.status).toBe(noContent.toResponse().status);
-      expect(response.statusText).toBe(noContent.toResponse().statusText);
-    });
-  });
-
-  describe("Error Responses", () => {
-    it("should handle BadGateway error", () => {
-      const badGateway = new BadGateway("Bad gateway error");
-      const response = errorHandler(badGateway);
-      expect(response.status).toBe(badGateway.toResponse().status);
-      expect(response.statusText).toBe(badGateway.toResponse().statusText);
-    });
-
-    it("should handle BadRequest error", () => {
-      const badRequest = new BadRequest("Bad request error");
-      const response = errorHandler(badRequest);
-      expect(response.status).toBe(badRequest.toResponse().status);
-      expect(response.statusText).toBe(badRequest.toResponse().statusText);
-    });
-
-    it("should handle Conflict error", () => {
-      const conflict = new Conflict("Conflict error");
-      const response = errorHandler(conflict);
-      expect(response.status).toBe(conflict.toResponse().status);
-      expect(response.statusText).toBe(conflict.toResponse().statusText);
-    });
-
-    it("should handle Forbidden error", () => {
-      const forbidden = new Forbidden("Forbidden error");
-      const response = errorHandler(forbidden);
-      expect(response.status).toBe(forbidden.toResponse().status);
-      expect(response.statusText).toBe(forbidden.toResponse().statusText);
-    });
-
-    it("should handle NotFound error", () => {
-      const notFound = new NotFound("Not found error");
-      const response = errorHandler(notFound);
-      expect(response.status).toBe(notFound.toResponse().status);
-      expect(response.statusText).toBe(notFound.toResponse().statusText);
-    });
-
-    it("should handle NotImplemented error", () => {
-      const notImplemented = new NotImplemented("Not implemented error");
-      const response = errorHandler(notImplemented);
-      expect(response.status).toBe(notImplemented.toResponse().status);
-      expect(response.statusText).toBe(notImplemented.toResponse().statusText);
-    });
-
-    it("should handle ServerError error", () => {
-      const serverError = new ServerError("Server error");
-      const response = errorHandler(serverError);
-      expect(response.status).toBe(serverError.toResponse().status);
-      expect(response.statusText).toBe(serverError.toResponse().statusText);
-    });
-
-    it("should handle Unauthorized error", () => {
-      const unauthorized = new Unauthorized("Unauthorized error");
-      const response = errorHandler(unauthorized);
-      expect(response.status).toBe(unauthorized.toResponse().status);
-      expect(response.statusText).toBe(unauthorized.toResponse().statusText);
-    });
-
-    it("should handle UnprocessableEntity error", () => {
-      const unprocessableEntity = new UnprocessableEntity({});
-      const response = errorHandler(unprocessableEntity);
-      expect(response.status).toBe(unprocessableEntity.toResponse().status);
-      expect(response.statusText).toBe(
-        unprocessableEntity.toResponse().statusText
-      );
-    });
-  });
-
-  describe("Unknown Error", () => {
-    it("should return undefined for unknown error types", () => {
-      const unknownError = new Error("Unknown error");
-      const serverError = new ServerError("Server error");
-      const response = errorHandler(unknownError);
-      expect(response.status).toBe(serverError.toResponse().status);
-      expect(response.statusText).toBe(serverError.toResponse().statusText);
-    });
-  });
-});

package/src/services/__test__/formParse.spec.ts

@@ -1,96 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { z } from "zod";
-import { formParse } from "../formParse";
-
-describe("formParse", () => {
-  it("should return success and parsed data when validation passes", () => {
-    const schema = z.object({
-      name: z.string().min(1, "Name is required"),
-      age: z.number().min(18, "Must be at least 18"),
-    });
-
-    const formData = { name: "John", age: 25 };
-
-    const result = formParse([formData, schema]);
-
-    expect(result.success).toBe(true);
-    expect(result).toHaveProperty("data");
-    if (result.success) expect(result.data).toEqual(formData);
-  });
-
-  it("should return field errors when validation fails", () => {
-    const schema = z.object({
-      name: z.string().min(1, "Name is required"),
-      age: z.number().min(18, "Must be at least 18"),
-    });
-
-    const formData = { name: "", age: 17 };
-
-    const result = formParse([formData, schema]);
-
-    expect(result.success).toBe(false);
-    expect(result).toHaveProperty("fieldErrors");
-
-    if (!result.success) {
-      expect(result.fieldErrors).toEqual({
-        name: "Name is required",
-        age: "Must be at least 18",
-      });
-      expect(result.fields).toEqual(formData);
-    }
-  });
-
-  it("should handle missing fields gracefully", () => {
-    const schema = z.object({
-      name: z
-        .string({ required_error: "Name is required" })
-        .min(1, "Name is required"),
-      age: z.number().min(18, "Must be at least 18"),
-    });
-
-    const formData = { age: 20 }; // Missing "name"
-
-    const result = formParse([formData, schema]);
-
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.fieldErrors).toEqual({ name: "Name is required" });
-      expect(result.fields).toEqual(formData);
-    }
-  });
-
-  it("should return success for an empty schema", () => {
-    const schema = z.object({});
-    const formData = {};
-
-    const result = formParse([formData, schema]);
-
-    expect(result.success).toBe(true);
-    expect(result).toHaveProperty("data");
-    if (result.success) expect(result.data).toEqual(formData);
-  });
-
-  it("should handle nested schemas correctly", () => {
-    const schema = z.object({
-      user: z.object({
-        name: z.string().min(1, "Name is required"),
-        age: z.number().min(18, "Must be at least 18"),
-      }),
-    });
-
-    const formData = {
-      user: { name: "", age: 16 },
-    };
-
-    const result = formParse([formData, schema]);
-
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.fieldErrors).toEqual({
-        "user.name": "Name is required",
-        "user.age": "Must be at least 18",
-      });
-      expect(result.fields).toEqual(formData);
-    }
-  });
-});

package/src/services/__test__/getCaller.spec.ts

@@ -1,78 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getCaller } from "../getCaller";
-
-describe("getCaller", () => {
-  it("should return the correct caller function name and file path", () => {
-    function testFunction() {
-      return getCaller();
-    }
-
-    const result = testFunction();
-
-    expect(result.functionName).toBe("testFunction");
-    expect(result.callerInfo).toContain("getCaller.spec.ts");
-  });
-
-  it("should handle calls from anonymous functions", () => {
-    const result = (() => getCaller())();
-
-    expect(result.functionName).toBe("Unknown function");
-    expect(result.callerInfo).toContain("getCaller.spec.ts");
-  });
-
-  it("should return the correct name for nested functions", () => {
-    function outerFunction() {
-      function innerFunction() {
-        return getCaller();
-      }
-      return innerFunction();
-    }
-
-    const result = outerFunction();
-
-    expect(result.functionName).toBe("innerFunction");
-    expect(result.callerInfo).toContain("getCaller.spec.ts");
-  });
-
-  it("should return method name when called from object method", () => {
-    const obj = {
-      method() {
-        return getCaller();
-      },
-    };
-
-    const result = obj.method();
-
-    expect(result.functionName).toMatch(/method|Object.method/);
-    expect(result.callerInfo).toContain("getCaller.spec.ts");
-  });
-
-  it("should return method name when called from class method", () => {
-    class TestClass {
-      call() {
-        return getCaller();
-      }
-    }
-
-    const instance = new TestClass();
-    const result = instance.call();
-
-    expect(result.functionName).toMatch(/call|TestClass.call/);
-    expect(result.callerInfo).toContain("getCaller.spec.ts");
-  });
-
-  it("should return the correct caller for indirect calls", () => {
-    function intermediary(fn: () => any) {
-      return fn();
-    }
-
-    function actualCaller() {
-      return getCaller();
-    }
-
-    const result = intermediary(actualCaller);
-
-    expect(result.functionName).toBe("actualCaller");
-    expect(result.callerInfo).toContain("getCaller.spec.ts");
-  });
-});

package/src/services/__test__/getScopedParams.spec.ts

@@ -1,68 +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",
-    } as Request;
-
-    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",
-    } as Request;
-
-    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",
-    } as Request;
-
-    const params = getScopedParams(request, "scope");
-
-    expect(params.toString()).toBe("");
-  });
-
-  it("should handle URLs with no query parameters", () => {
-    const request = { url: "https://example.com" } as Request;
-    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",
-    } as Request;
-
-    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",
-    } as Request;
-
-    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/src/services/__test__/schemaValidator.spec.ts

@@ -1,106 +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",
-          },
-        })
-      );
-    });
-  });
-});