@arkyn/server 2.0.1-beta.8 → 2.0.1

package/src/api/makeRequest.ts

@@ -0,0 +1,117 @@
+import type { ApiResponseDTO } from "@arkyn/types";
+import { InboxFlowInstance } from "../config/inboxFlowInstance";
+import { inboxFlowRequest } from "./inboxFlowRequest";
+
+/**
+ * Makes an HTTP request using the Fetch API and returns a standardized response.
+ *
+ * @template T - The expected type of the response data.
+ * @param method - The HTTP method to use for the request. Supported methods are:
+ *   - "POST": Create a new resource.
+ *   - "PUT": Update an existing resource.
+ *   - "DELETE": Remove a resource.
+ *   - "PATCH": Partially update a resource.
+ *   - "GET": Retrieve a resource.
+ * @param url - The URL to which the request is sent.
+ * @param headers - Optional headers to include in the request. Defaults to an empty object.
+ * @param body - Optional body to include in the request. Should be serializable to JSON.
+ * @returns A promise that resolves to an `ApiResponseDTO<T>` object containing:
+ *   - `success`: A boolean indicating whether the request was successful.
+ *   - `status`: The HTTP status code of the response.
+ *   - `message`: A message describing the result of the request.
+ *   - `response`: The parsed JSON response data, or `null` if parsing fails.
+ *   - `cause`: Additional error information, if applicable.
+ *
+ * @example
+ * ```typescript
+ * import { makeRequest } from "./makeRequest";
+ *
+ * async function fetchData() {
+ *   const response = await makeRequest("GET", "https://api.example.com/data");
+ *   if (response.success) {
+ *     console.log("Data:", response.response);
+ *   } else {
+ *     console.error("Error:", response.message);
+ *   }
+ * }
+ * ```
+ */
+
+async function makeRequest<T = any>(
+  method: "POST" | "PUT" | "DELETE" | "PATCH" | "GET",
+  url: string,
+  headers: HeadersInit = {},
+  body?: any
+): Promise<ApiResponseDTO<T>> {
+  const successMessage = {
+    POST: "Resource created successfully",
+    PUT: "Resource updated successfully",
+    DELETE: "Resource deleted successfully",
+    PATCH: "Resource patched successfully",
+    GET: "Request successful",
+  };
+
+  try {
+    const response = await fetch(url, {
+      method,
+      headers: {
+        ...headers,
+        "Content-Type": "application/json",
+      },
+      body: body ? JSON.stringify(body) : undefined,
+    });
+
+    const status = response.status;
+
+    let data: any = null;
+    try {
+      data = await response.json();
+    } catch {
+      data = null;
+    }
+
+    inboxFlowRequest({
+      method,
+      status,
+      request: JSON.stringify(response.headers),
+      response: JSON.stringify(data),
+      token: (headers as any)?.Authorization || "TOKEN_NOT_FOUND",
+    });
+
+    if (!response.ok) {
+      return {
+        success: false,
+        status,
+        message: data?.message || response.statusText || "Request failed",
+        response: data,
+        cause: null,
+      };
+    }
+
+    return {
+      success: true,
+      status,
+      message: data?.message || successMessage[method],
+      response: data,
+      cause: null,
+    };
+  } catch (err) {
+    inboxFlowRequest({
+      method,
+      request: JSON.stringify(headers),
+      response: String(err),
+      status: 500,
+      token: "TOKEN_NOT_FOUND",
+    });
+
+    return {
+      success: false,
+      status: 0,
+      message: "Network error or request failed",
+      response: null,
+      cause: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
+export { makeRequest };

package/src/api/patchRequest.ts

@@ -0,0 +1,22 @@
+import type { ApiResponseDTO } from "@arkyn/types";
+import { makeRequest } from "./makeRequest";
+
+/**
+ * Sends a PATCH 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 PATCH request to.
+ * @param {HeadersInit} [headers={}] - Optional headers to include in the request.
+ * @param {any} body - The body to include in the request.
+ * @returns {Promise<ApiResponseDTO<T>>} A promise that resolves to the API response.
+ */
+
+async function patchRequest<T = any>(
+  url: string,
+  headers: HeadersInit = {},
+  body: any
+): Promise<ApiResponseDTO<T>> {
+  return makeRequest("PATCH", url, headers, body);
+}
+
+export { patchRequest };

package/src/api/postRequest.ts

@@ -0,0 +1,22 @@
+import type { ApiResponseDTO } from "@arkyn/types";
+import { makeRequest } from "./makeRequest";
+
+/**
+ * Sends a PATCH 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 PATCH request to.
+ * @param {HeadersInit} [headers={}] - Optional headers to include in the request.
+ * @param {any} body - The body to include in the request.
+ * @returns {Promise<ApiResponseDTO<T>>} A promise that resolves to the API response.
+ */
+
+async function postRequest<T = any>(
+  url: string,
+  headers: HeadersInit = {},
+  body: any
+): Promise<ApiResponseDTO<T>> {
+  return makeRequest("POST", url, headers, body);
+}
+
+export { postRequest };

package/src/api/putRequest.ts

@@ -0,0 +1,22 @@
+import type { ApiResponseDTO } from "@arkyn/types";
+import { makeRequest } from "./makeRequest";
+
+/**
+ * Sends a PATCH 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 PATCH request to.
+ * @param {HeadersInit} [headers={}] - Optional headers to include in the request.
+ * @param {any} body - The body to include in the request.
+ * @returns {Promise<ApiResponseDTO<T>>} A promise that resolves to the API response.
+ */
+
+async function putRequest<T = any>(
+  url: string,
+  headers: HeadersInit = {},
+  body: any
+): Promise<ApiResponseDTO<T>> {
+  return makeRequest("PUT", url, headers, body);
+}
+
+export { putRequest };

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

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

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

@@ -0,0 +1,148 @@
+import { deleteRequest } from "../api/deleteRequest";
+import { getRequest } from "../api/getRequest";
+import { patchRequest } from "../api/patchRequest";
+import { postRequest } from "../api/postRequest";
+import { putRequest } from "../api/putRequest";
+
+type ApiAinstanceContructorProps = {
+  baseUrl: string;
+  baseHeaders?: HeadersInit;
+  baseToken?: string | null;
+};
+
+type ApiRequestDataWithoutBodyProps = {
+  headers?: HeadersInit;
+  token?: string;
+};
+
+type ApiRequestDataWithBodyProps = {
+  body?: any;
+  headers?: HeadersInit;
+  token?: string;
+};
+
+/**
+ * Class representing an API instance to handle HTTP requests with base configurations.
+ */
+
+class ApiInstance {
+  private baseUrl: string;
+  private baseHeaders?: HeadersInit;
+  private baseToken?: string;
+
+  /**
+   * Creates an instance of ApiInstance.
+   * @param props - The configuration properties for the API instance.
+   * @param props.baseUrl - The base URL for the API.
+   * @param props.baseHeaders - Optional base headers to include in all requests.
+   * @param props.baseToken - Optional base token for authorization.
+   */
+
+  constructor(props: ApiAinstanceContructorProps) {
+    this.baseUrl = props.baseUrl;
+    this.baseHeaders = props.baseHeaders || undefined;
+    this.baseToken = props.baseToken || undefined;
+  }
+
+  /**
+   * Generates the full URL by appending the route to the base URL.
+   * @param route - The route to append to the base URL.
+   * @returns The full URL as a string.
+   */
+
+  private generateURL(route: string) {
+    return this.baseUrl + route;
+  }
+
+  /**
+   * Generates the headers for a request by merging base headers, provided headers, and tokens.
+   * @param initHeaders - Initial headers to include in the request.
+   * @param token - Optional token to override the base token.
+   * @returns The merged headers as a HeadersInit object.
+   */
+
+  private generateHeaders(
+    initHeaders: HeadersInit,
+    token?: string
+  ): HeadersInit {
+    let headers: HeadersInit = {};
+    if (this.baseToken) headers = { Authorization: `Bearer ${this.baseToken}` };
+    if (this.baseHeaders) headers = { ...headers, ...this.baseHeaders };
+
+    if (initHeaders) headers = { ...headers, ...initHeaders };
+    if (token) headers = { ...headers, Authorization: `Bearer ${token}` };
+
+    return headers;
+  }
+
+  /**
+   * Sends a GET request to the specified route.
+   * @param route - The API route to send the GET request to.
+   * @param data - The request data, including optional headers and token.
+   * @returns The API response data.
+   */
+
+  async GET(route: string, data?: ApiRequestDataWithoutBodyProps) {
+    const url = this.generateURL(route);
+    const headers = this.generateHeaders(data?.headers || {}, data?.token);
+    return await getRequest(url, headers);
+  }
+
+  /**
+   * Sends a POST request to the specified route.
+   * @param route - The API route to send the POST request to.
+   * @param data - The request data, including body, optional headers, and token.
+   * @returns The API response data.
+   */
+
+  async POST(route: string, data?: ApiRequestDataWithBodyProps) {
+    const url = this.generateURL(route);
+    const headers = this.generateHeaders(data?.headers || {}, data?.token);
+    const body = data?.body;
+    return await postRequest(url, headers, body);
+  }
+
+  /**
+   * Sends a PUT request to the specified route.
+   * @param route - The API route to send the PUT request to.
+   * @param data - The request data, including body, optional headers, and token.
+   * @returns The API response data.
+   */
+
+  async PUT(route: string, data?: ApiRequestDataWithBodyProps) {
+    const url = this.generateURL(route);
+    const headers = this.generateHeaders(data?.headers || {}, data?.token);
+    const body = data?.body;
+    return await putRequest(url, headers, body);
+  }
+
+  /**
+   * Sends a PATCH request to the specified route.
+   * @param route - The API route to send the PATCH request to.
+   * @param data - The request data, including body, optional headers, and token.
+   * @returns The API response data.
+   */
+
+  async PATCH(route: string, data?: ApiRequestDataWithBodyProps) {
+    const url = this.generateURL(route);
+    const headers = this.generateHeaders(data?.headers || {}, data?.token);
+    const body = data?.body;
+    return await patchRequest(url, headers, body);
+  }
+
+  /**
+   * Sends a DELETE request to the specified route.
+   * @param route - The API route to send the DELETE request to.
+   * @param data - The request data, including body, optional headers, and token.
+   * @returns The API response data.
+   */
+
+  async DELETE(route: string, data?: ApiRequestDataWithBodyProps) {
+    const url = this.generateURL(route);
+    const headers = this.generateHeaders(data?.headers || {}, data?.token);
+    const body = data?.body;
+    return await deleteRequest(url, headers, body);
+  }
+}
+
+export { ApiInstance };

package/src/config/inboxFlowInstance.ts

@@ -0,0 +1,65 @@
+type InboxConfigProps = {
+  inboxChannelId: string;
+  inboxUserToken: string;
+  inboxApiUrl: string;
+};
+
+type SetInboxConfigProps = {
+  inboxChannelId: string;
+  inboxUserToken: string;
+  inboxApiUrl?: string;
+};
+
+/**
+ * The `InboxFlowInstance` class manages the configuration for the inbox flow.
+ * It allows you to set and retrieve the inbox configuration, including the channel ID,
+ * user token, and API URL.
+ */
+
+class InboxFlowInstance {
+  private static inboxConfig?: InboxConfigProps;
+
+  /**
+   * Sets the configuration for the inbox. This method initializes the inbox configuration
+   * with the provided `inboxConfig` values. If the configuration has already been set,
+   * the method will return early without making any changes.
+   *
+   * @param inboxConfig - An object containing the inbox configuration properties.
+   * @param inboxConfig.inboxChannelId - The key used to identify the inbox.
+   * @param inboxConfig.inboxUserToken - The user token for authenticating with the inbox.
+   * @param inboxConfig.inboxApiUrl - (Optional) The API URL for the inbox. If not provided,
+   * a default URL will be used.
+   */
+
+  static setInboxConfig(inboxConfig: SetInboxConfigProps) {
+    const defaultInboxURL = `https://logs-inbox-flow-logs.vw6wo7.easypanel.host/api/call`;
+    if (!!this.inboxConfig) return;
+
+    this.inboxConfig = {
+      inboxChannelId: inboxConfig.inboxChannelId,
+      inboxUserToken: inboxConfig.inboxUserToken,
+      inboxApiUrl: inboxConfig.inboxApiUrl || defaultInboxURL,
+    };
+  }
+
+  /**
+   * Retrieves the current inbox configuration for the InboxFlowInstance.
+   *
+   * @returns {InboxConfigProps | undefined} The current inbox configuration if set,
+   * or `undefined` if no configuration has been initialized.
+   */
+  static getInboxConfig(): InboxConfigProps | undefined {
+    return this.inboxConfig;
+  }
+
+  /**
+   * Resets the inbox configuration to `undefined`.
+   * This method can be used to clear the current configuration.
+   */
+
+  static resetInboxConfig() {
+    this.inboxConfig = undefined;
+  }
+}
+
+export { InboxFlowInstance };

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

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

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