@arkyn/server 1.9.1 → 1.9.5

package/src/http/badResponses/unauthorized.ts

@@ -0,0 +1,63 @@
+import { httpDebug } from "../../services/httpDebug";
+
+/**
+ * Represents an HTTP error response with a status code of 401 (Unauthorized).
+ * This class is used to standardize the structure of an "Unauthorized" error response,
+ * including the response body, headers, status, and status text.
+ */
+
+class Unauthorized {
+  body: any;
+  cause?: any;
+  status: number = 401;
+  statusText: string;
+
+  /**
+   * Creates an instance of the `Unauthorized` class.
+   *
+   * @param message - A descriptive message explaining why the request is unauthorized.
+   * @param cause - Optional additional information about the cause of the error.
+   */
+
+  constructor(message: string, cause?: any) {
+    this.body = { name: "Unauthorized", message: message };
+    this.statusText = message;
+    this.cause = cause ? JSON.stringify(cause) : undefined;
+    httpDebug("Unauthorized", this.body, this.cause);
+  }
+
+  /**
+   * Converts the `Unauthorized` instance into a `Response` object with a JSON body.
+   * This method ensures the response has the appropriate headers, status, and status text.
+   *
+   * @returns A `Response` object with the serialized JSON body and response metadata.
+   */
+
+  toResponse(): Response {
+    const responseInit: ResponseInit = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return new Response(JSON.stringify(this.body), responseInit);
+  }
+
+  /**
+   * Converts the `Unauthorized` instance into a `Response` object using the `Response.json` method.
+   * This method is an alternative to `toResponse` for generating JSON error responses.
+   *
+   * @returns A `Response` object with the JSON body and response metadata.
+   */
+
+  toJson(): Response {
+    const responseInit: ResponseInit = {
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return Response.json(this.body, responseInit);
+  }
+}
+
+export { Unauthorized };

package/src/http/badResponses/unprocessableEntity.ts

@@ -0,0 +1,79 @@
+import { httpDebug } from "../../services/httpDebug";
+
+type UnprocessableEntityProps = {
+  data?: any;
+  fieldErrors?: Record<string, string>;
+  fields?: Record<string, string>;
+  message?: string;
+};
+
+/**
+ * Represents an HTTP error response with a status code of 422 (Unprocessable Entity).
+ * This class is used to standardize the structure of an "Unprocessable Entity" error response,
+ * including the response body, headers, status, and status text.
+ */
+
+class UnprocessableEntity {
+  body: any;
+  status: number = 422;
+  statusText: string;
+
+  /**
+   * Creates an instance of the `UnprocessableEntity` class.
+   *
+   * @param props - An object containing details about the error, such as:
+   *   - `data`: Additional data related to the error.
+   *   - `fieldErrors`: A record of field-specific error messages.
+   *   - `fields`: A record of field values that caused the error.
+   *   - `message`: A descriptive message explaining the error.
+   * @param enableDebug - A boolean indicating whether to enable debug logging for this error.
+   */
+
+  constructor(props: UnprocessableEntityProps, enableDebug = false) {
+    this.statusText = props.message || "Unprocessable Entity";
+    this.body = {
+      name: "UnprocessableEntity",
+      message: props.message || null,
+      data: props.data,
+      fieldErrors: props.fieldErrors,
+      fields: props.fields,
+    };
+
+    enableDebug && httpDebug("UnprocessableEntity", this.body);
+  }
+
+  /**
+   * Converts the `UnprocessableEntity` instance into a `Response` object with a JSON body.
+   * This method ensures the response has the appropriate headers, status, and status text.
+   *
+   * @returns A `Response` object with the serialized JSON body and response metadata.
+   */
+
+  toResponse(): Response {
+    const responseInit: ResponseInit = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return new Response(JSON.stringify(this.body), responseInit);
+  }
+
+  /**
+   * Converts the `UnprocessableEntity` instance into a `Response` object using the `Response.json` method.
+   * This method is an alternative to `toResponse` for generating JSON error responses.
+   *
+   * @returns A `Response` object with the JSON body and response metadata.
+   */
+
+  toJson(): Response {
+    const responseInit: ResponseInit = {
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return Response.json(this.body, responseInit);
+  }
+}
+
+export { UnprocessableEntity };

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

@@ -0,0 +1,65 @@
+import { describe, it, expect } from "vitest";
+import { Created } from "../created";
+
+describe("Created", () => {
+  it("should create a response with default values", () => {
+    const body = { message: "Resource created" };
+    const created = new Created(body);
+
+    const response = created.toResponse();
+    expect(response.status).toBe(201);
+    expect(response.statusText).toBe("Resource created successfully");
+    expect(response.headers.get("Content-Type")).toBe("application/json");
+    response.json().then((data) => {
+      expect(data).toEqual(body);
+    });
+  });
+
+  it("should create a response with custom values", () => {
+    const body = { message: "Custom resource created" };
+    const init = {
+      headers: { "X-Custom-Header": "CustomValue" },
+      status: 202,
+      statusText: "Accepted",
+    };
+    const created = new Created(body, init);
+
+    const response = created.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");
+    response.json().then((data) => {
+      expect(data).toEqual(body);
+    });
+  });
+
+  it("should create a JSON response with default values", () => {
+    const body = { message: "Resource created" };
+    const created = new Created(body);
+
+    const response = created.toJson();
+    expect(response.status).toBe(201);
+    expect(response.statusText).toBe("Resource created successfully");
+    response.json().then((data) => {
+      expect(data).toEqual(body);
+    });
+  });
+
+  it("should create a JSON response with custom values", () => {
+    const body = { message: "Custom resource created" };
+    const init = {
+      headers: { "X-Custom-Header": "CustomValue" },
+      status: 202,
+      statusText: "Accepted",
+    };
+    const created = new Created(body, init);
+
+    const response = created.toJson();
+    expect(response.status).toBe(202);
+    expect(response.statusText).toBe("Accepted");
+    response.json().then((data) => {
+      expect(data).toEqual(body);
+    });
+  });
+});

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

@@ -0,0 +1,65 @@
+import { describe, it, expect } from "vitest";
+import { Found } from "../found";
+
+describe("Found", () => {
+  it("should create a response with default values", () => {
+    const body = { message: "Resource found" };
+    const found = new Found(body);
+
+    const response = found.toResponse();
+    expect(response.status).toBe(302);
+    expect(response.statusText).toBe("Found");
+    expect(response.headers.get("Content-Type")).toBe("application/json");
+    response.json().then((data) => {
+      expect(data).toEqual(body);
+    });
+  });
+
+  it("should create a response with custom values", () => {
+    const body = { message: "Custom resource found" };
+    const init = {
+      headers: { "X-Custom-Header": "CustomValue" },
+      status: 301,
+      statusText: "Moved Permanently",
+    };
+    const found = new Found(body, init);
+
+    const response = found.toResponse();
+    expect(response.status).toBe(301);
+    expect(response.statusText).toBe("Moved Permanently");
+    expect(response.headers.get("Content-Type")).toBe("application/json");
+    expect(response.headers.get("X-Custom-Header")).toBe("CustomValue");
+    response.json().then((data) => {
+      expect(data).toEqual(body);
+    });
+  });
+
+  it("should create a JSON response with default values", () => {
+    const body = { message: "Resource found" };
+    const found = new Found(body);
+
+    const response = found.toJson();
+    expect(response.status).toBe(302);
+    expect(response.statusText).toBe("Found");
+    response.json().then((data) => {
+      expect(data).toEqual(body);
+    });
+  });
+
+  it("should create a JSON response with custom values", () => {
+    const body = { message: "Custom resource found" };
+    const init = {
+      headers: { "X-Custom-Header": "CustomValue" },
+      status: 301,
+      statusText: "Moved Permanently",
+    };
+    const found = new Found(body, init);
+
+    const response = found.toJson();
+    expect(response.status).toBe(301);
+    expect(response.statusText).toBe("Moved Permanently");
+    response.json().then((data) => {
+      expect(data).toEqual(body);
+    });
+  });
+});

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

@@ -0,0 +1,49 @@
+import { describe, expect, it } from "vitest";
+import { NoContent } from "../noContent";
+
+describe("NoContent", () => {
+  it("should create a NoContent instance with default values", () => {
+    const noContent = new NoContent();
+
+    expect(noContent.status).toBe(204);
+    expect(noContent.statusText).toBe("No content");
+    expect(noContent.headers).toEqual({});
+  });
+
+  it("should create a NoContent instance with custom values", () => {
+    const customInit = {
+      headers: { "Content-Type": "application/json" },
+      status: 200,
+      statusText: "Custom Status",
+    };
+    const noContent = new NoContent(customInit);
+
+    expect(noContent.status).toBe(200);
+    expect(noContent.statusText).toBe("Custom Status");
+    expect(noContent.headers).toEqual(customInit.headers);
+  });
+
+  it("should return a Response object with default values from toResponse", () => {
+    const noContent = new NoContent();
+    const response = noContent.toResponse();
+
+    expect(response.status).toBe(204);
+    expect(response.statusText).toBe("No content");
+    expect(response.headers.get("Content-Type")).toBeNull();
+  });
+
+  it("should return a Response object with custom values from toResponse", () => {
+    const customInit = {
+      headers: { "Content-Type": "application/json" },
+      status: 200,
+      statusText: "Custom Status",
+    };
+
+    const noContent = new NoContent(customInit);
+    const response = noContent.toResponse();
+
+    expect(response.status).toBe(200);
+    expect(response.statusText).toBe("Custom Status");
+    expect(response.headers.get("Content-Type")).toBe("application/json");
+  });
+});

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

@@ -0,0 +1,68 @@
+import { describe, expect, it } from "vitest";
+import { Success } from "../success";
+
+describe("Success", () => {
+  it("should create a response with default values", () => {
+    const body = { message: "Success" };
+    const success = new Success(body);
+
+    const response = success.toResponse();
+    expect(response.status).toBe(200);
+    expect(response.statusText).toBe("OK");
+    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 Success" };
+    const init = {
+      headers: { "X-Custom-Header": "CustomValue" },
+      status: 201,
+      statusText: "Created",
+    };
+    const success = new Success(body, init);
+
+    const response = success.toResponse();
+    expect(response.status).toBe(201);
+    expect(response.statusText).toBe("Created");
+    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: "Success" };
+    const success = new Success(body);
+
+    const response = success.toJson();
+    expect(response.status).toBe(200);
+    expect(response.statusText).toBe("OK");
+    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 Success" };
+    const init = {
+      headers: { "X-Custom-Header": "CustomValue" },
+      status: 201,
+      statusText: "Created",
+    };
+    const success = new Success(body, init);
+
+    const response = success.toJson();
+    expect(response.status).toBe(201);
+    expect(response.statusText).toBe("Created");
+    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/http/successResponses/__test__/updated.spec.ts

@@ -0,0 +1,68 @@
+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/http/successResponses/created.ts

@@ -0,0 +1,64 @@
+/**
+ * Represents a successful HTTP response with a status code of 201 (Created).
+ * This class is used to standardize the structure of a "Created" response,
+ * including the response body, headers, status, and status text.
+ *
+ * @template T - The type of the response body.
+ */
+
+class Created<T> {
+  body: T;
+  headers: ResponseInit["headers"];
+  status: number;
+  statusText: string;
+
+  /**
+   * Creates an instance of the `Created` class.
+   *
+   * @param body - The response body to be included in the HTTP response.
+   * @param init - Optional initialization object for customizing headers, status, and status text.
+   */
+
+  constructor(body: T, init?: ResponseInit) {
+    this.body = body;
+    this.headers = init?.headers || {};
+    this.status = init?.status || 201;
+    this.statusText = init?.statusText || "Resource created successfully";
+  }
+
+  /**
+   * Converts the `Created` instance into a `Response` object with a JSON body.
+   * This method ensures the response has the appropriate headers, status, and status text.
+   *
+   * @returns A `Response` object with the serialized JSON body and response metadata.
+   */
+
+  toResponse(): Response {
+    const responseInit: ResponseInit = {
+      headers: { "Content-Type": "application/json", ...this.headers },
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return new Response(JSON.stringify(this.body), responseInit);
+  }
+
+  /**
+   * Converts the `Created` instance into a `Response` object using the `Response.json` method.
+   * This method is an alternative to `toResponse` for generating JSON responses.
+   *
+   * @returns A `Response` object with the JSON body and response metadata.
+   */
+
+  toJson(): Response {
+    const responseInit: ResponseInit = {
+      headers: this.headers,
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return Response.json(this.body, responseInit);
+  }
+}
+
+export { Created };

package/src/http/successResponses/found.ts

@@ -0,0 +1,67 @@
+/**
+ * Represents an HTTP 302 Found response.
+ * This class is used to create a standardized HTTP response with a status of 302 (Found),
+ * including optional headers and a response body.
+ *
+ * @template T - The type of the response body.
+ */
+
+class Found<T> {
+  body: T;
+  headers: ResponseInit["headers"];
+  status: number;
+  statusText: string;
+
+  /**
+   * Creates an instance of the `Found` class.
+   *
+   * @param body - The body of the response.
+   * @param init - Optional initialization object to set headers, status, and statusText.
+   *   - `headers`: Additional headers to include in the response.
+   *   - `status`: HTTP status code (default is 302).
+   *   - `statusText`: HTTP status text (default is "Found").
+   */
+
+  constructor(body: T, init?: ResponseInit) {
+    this.body = body;
+    this.headers = init?.headers || {};
+    this.status = init?.status || 302;
+    this.statusText = init?.statusText || "Found";
+  }
+
+  /**
+   * Converts the `Found` instance into a `Response` object.
+   * This method serializes the response body as JSON and includes the appropriate headers.
+   *
+   * @returns A `Response` object with the serialized JSON body and the specified headers, status, and statusText.
+   */
+
+  toResponse() {
+    const responseInit: ResponseInit = {
+      headers: { "Content-Type": "application/json", ...this.headers },
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return new Response(JSON.stringify(this.body), responseInit);
+  }
+
+  /**
+   * Converts the `Found` instance into a JSON response using `Response.json`.
+   * This method is an alternative to `toResponse` for creating JSON responses.
+   *
+   * @returns A `Response` object with the JSON body and the specified headers, status, and statusText.
+   */
+
+  toJson() {
+    const responseInit: ResponseInit = {
+      headers: this.headers,
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return Response.json(this.body, responseInit);
+  }
+}
+
+export { Found };

package/src/http/successResponses/noContent.ts

@@ -0,0 +1,42 @@
+/**
+ * Represents a successful HTTP response with a status code of 204 (No Content).
+ * This class is used to standardize the structure of a "No Content" response,
+ * including headers, status, and status text.
+ */
+
+class NoContent {
+  headers: ResponseInit["headers"];
+  status: number;
+  statusText: string;
+
+  /**
+   * Creates an instance of the `NoContent` class.
+   *
+   * @param init - Optional initialization object for customizing headers, status, and status text.
+   */
+
+  constructor(init?: ResponseInit) {
+    this.headers = init?.headers || {};
+    this.status = init?.status || 204;
+    this.statusText = init?.statusText ?? "No content";
+  }
+
+  /**
+   * Converts the `NoContent` instance into a `Response` object.
+   * This method ensures the response has the appropriate headers, status, and status text.
+   *
+   * @returns A `Response` object with no body and response metadata.
+   */
+
+  toResponse(): Response {
+    const responseInit: ResponseInit = {
+      headers: this.headers,
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return new Response(null, responseInit);
+  }
+}
+
+export { NoContent };