@arkyn/server 3.0.1-beta.31 → 3.0.1-beta.33

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@arkyn/server",
-  "version": "3.0.1-beta.31",
+  "version": "3.0.1-beta.33",
   "author": "Arkyn | Lucas Gonçalves",
   "main": "./dist/index.js",
-  "module": "./dist/index.js",
+  "module": "./src/index.ts",
   "type": "module",
-  "types": "./dist/index.d.ts",
+  "types": "./src/index.ts",
   "license": "Apache-2.0",
   "description": "Comprehensive server-side utilities for building robust backend applications, featuring HTTP response helpers, error handlers, request utilities, and API configurations.",
   "keywords": [

package/src/api/arkynLogRequest.ts

@@ -0,0 +1,118 @@
+import { ArkynLogInstance } from "../config/arkynLogInstance";
+import { httpDebug } from "../services/httpDebug";
+
+type ConfigProps = {
+  rawUrl: string;
+  status: number;
+  method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+  token: string | null;
+  elapsedTime: number;
+  requestHeaders: Record<string, string>;
+  requestBody: Record<string, string>;
+  queryParams: Record<string, string>;
+  responseHeaders: Record<string, string>;
+  responseBody: Record<string, string>;
+};
+
+/**
+ * Sends a request to the inbox flow API with the provided configuration.
+ *
+ * @param config - The configuration object for the request.
+ * @param config.rawUrl - The raw URL of the request.
+ * @param config.status - The HTTP status code associated with the request.
+ * @param config.method - The HTTP method used for the request. Can be "POST", "GET", "PUT", "DELETE", or "PATCH".
+ * @param config.token - The authentication token for the request.
+ * @param config.elapsedTime - The elapsed time for the request in milliseconds.
+ * @param config.requestHeaders - The headers sent with the request.
+ * @param config.requestBody - The body of the request, if applicable.
+ * @param config.queryParams - The query parameters for the request.
+ * @param config.responseHeaders - The headers received in the response.
+ * @param config.responseBody - The body of the response received.
+ *
+ * @remarks
+ * - This function retrieves the inbox flow configuration using `InboxFlowInstance.getInboxConfig()`.
+ * - If the configuration is not available, the function will return early without performing any action.
+ * - In a development environment (`NODE_ENV === "development"`), the function will also return early.
+ * - The request is sent as a POST request to the inbox API URL with the provided configuration details.
+ * - If an error occurs during the request, it will be logged using the `httpDebug` service.
+ *
+ * @example
+ * ```typescript
+ * const config = {
+ *   rawUrl: "https://example.com/api/data",
+ *   status: 200,
+ *   method: "GET",
+ *   token: "auth-token-123",
+ *   elapsedTime: "150ms",
+ *   requestHeaders: { "Accept": "application/json", "Authorization": "Bearer token123" },
+ *   requestBody: {},
+ *   queryParams: { "page": "1", "limit": "10" },
+ *   responseHeaders: { "Content-Type": "application/json" },
+ *   responseBody: { "data": "example response" }
+ * };
+ *
+ * await arkynLogRequest(config);
+ * ```
+ */
+
+async function arkynLogRequest(config: ConfigProps) {
+  const arkynInstance = ArkynLogInstance.getArkynConfig();
+  if (!arkynInstance) return;
+
+  const { arkynUserToken, arkynApiUrl } = arkynInstance;
+
+  const {
+    elapsedTime,
+    method,
+    queryParams,
+    requestBody,
+    requestHeaders,
+    responseBody,
+    responseHeaders,
+    status,
+    token,
+    rawUrl,
+  } = config;
+
+  // if (process.env.NODE_ENV === "development") return;
+
+  try {
+    const url = new URL(rawUrl);
+    let protocol: "HTTPS" | "HTTP" = "HTTPS";
+    if (url.protocol === "http:") protocol = "HTTP";
+
+    const body = JSON.stringify({
+      domainUrl: url.protocol + "//" + url.host,
+      pathnameUrl: url.pathname,
+      status,
+      protocol,
+      method,
+      trafficUserId: null,
+      elapsedTime,
+      requestHeaders,
+      requestBody,
+      queryParams,
+      responseHeaders,
+      responseBody,
+    });
+
+    await fetch(
+      arkynApiUrl.replace(
+        ":trafficSourceId",
+        arkynInstance.arkynTrafficSourceId
+      ),
+      {
+        method: "POST",
+        body,
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${arkynUserToken}`,
+        },
+      }
+    );
+  } catch (err) {
+    httpDebug("arkyn log error", "Error sending request", err);
+  }
+}
+
+export { arkynLogRequest };

package/src/api/deleteRequest.ts

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

package/src/api/getRequest.ts

@@ -0,0 +1,20 @@
+import type { ApiResponseDTO } from "../types/ApiResponseDTO";
+import { makeRequest } from "./makeRequest";
+
+/**
+ * Sends a GET request to the specified URL with optional headers.
+ *
+ * @template T - The expected type of the response data.
+ * @param {string} url - The URL to send the GET request to.
+ * @param {HeadersInit} [headers={}] - Optional headers to include in the request.
+ * @returns {Promise<ApiResponseDTO<T>>} A promise that resolves to the API response.
+ */
+
+async function getRequest<T = any>(
+  url: string,
+  headers: HeadersInit = {}
+): Promise<ApiResponseDTO<T>> {
+  return makeRequest("GET", url, headers);
+}
+
+export { getRequest };

package/src/api/makeRequest.ts

@@ -0,0 +1,118 @@
+import { ArkynLogRequestMapper } from "../mapper/arkynLogRequestMapper";
+import { httpDebug } from "../services/httpDebug";
+import type { ApiResponseDTO } from "../types/ApiResponseDTO";
+import { arkynLogRequest } from "./arkynLogRequest";
+
+/**
+ * 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,
+  rawHeaders: 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 startTime = performance.now();
+
+    const headers = { ...rawHeaders, "Content-Type": "application/json" };
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : undefined,
+    });
+
+    const elapsedTime = performance.now() - startTime;
+    const status = response.status;
+
+    let data: any = null;
+    try {
+      data = await response.json();
+    } catch {
+      data = null;
+    }
+
+    const logData = ArkynLogRequestMapper.handle({
+      elapsedTime,
+      method,
+      queryParams: new URL(url).searchParams,
+      requestHeaders: headers,
+      requestBody: body,
+      responseBody: data,
+      responseHeaders: response.headers,
+      status,
+      url,
+    });
+
+    arkynLogRequest(logData);
+
+    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) {
+    httpDebug("Network error or request failed", null, err);
+    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 "../types/ApiResponseDTO";
+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 "../types/ApiResponseDTO";
+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 "../types/ApiResponseDTO";
+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/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 ApiInstanceConstructorProps = {
+  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: ApiInstanceConstructorProps) {
+    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/arkynLogInstance.ts

@@ -0,0 +1,70 @@
+type ArkynConfigProps = {
+  arkynTrafficSourceId: string;
+  arkynUserToken: string;
+  arkynApiUrl: string;
+};
+
+type SetArkynConfigProps = {
+  arkynTrafficSourceId: string;
+  arkynUserToken: string;
+  arkynLogBaseApiUrl?: string;
+};
+
+/**
+ * The `ArkynLogInstance` class manages the configuration for the arkyn flow.
+ * It allows you to set and retrieve the arkyn configuration, including the traffic source ID,
+ * user token, and API URL.
+ */
+
+class ArkynLogInstance {
+  private static arkynConfig?: ArkynConfigProps;
+
+  /**
+   * Sets the configuration for the arkyn. This method initializes the arkyn configuration
+   * with the provided `arkynConfig` values. If the configuration has already been set,
+   * the method will return early without making any changes.
+   *
+   * @param arkynConfig - An object containing the arkyn configuration properties.
+   * @param arkynConfig.arkynTrafficSourceId - The key used to identify the arkyn.
+   * @param arkynConfig.arkynUserToken - The user token for authenticating with the arkyn.
+   * @param arkynConfig.arkynLogBaseApiUrl - (Optional) The API URL for the arkyn. If not provided,
+   * a default URL will be used.
+   */
+
+  static setArkynConfig(arkynConfig: SetArkynConfigProps) {
+    if (!!this.arkynConfig) return;
+
+    let defaultArkynURL = `https://logs-arkyn-flow-logs.vw6wo7.easypanel.host`;
+    let arkynLogBaseApiUrl = arkynConfig.arkynLogBaseApiUrl || defaultArkynURL;
+
+    arkynLogBaseApiUrl =
+      arkynLogBaseApiUrl + "/http-traffic-records/:trafficSourceId";
+
+    this.arkynConfig = {
+      arkynTrafficSourceId: arkynConfig.arkynTrafficSourceId,
+      arkynUserToken: arkynConfig.arkynUserToken,
+      arkynApiUrl: arkynLogBaseApiUrl,
+    };
+  }
+
+  /**
+   * Retrieves the current arkyn configuration for the ArkynLogInstance.
+   *
+   * @returns {ArkynConfigProps | undefined} The current arkyn configuration if set,
+   * or `undefined` if no configuration has been initialized.
+   */
+  static getArkynConfig(): ArkynConfigProps | undefined {
+    return this.arkynConfig;
+  }
+
+  /**
+   * Resets the arkyn configuration to `undefined`.
+   * This method can be used to clear the current configuration.
+   */
+
+  static resetArkynConfig() {
+    this.arkynConfig = undefined;
+  }
+}
+
+export { ArkynLogInstance };

package/src/http/badResponses/badGateway.ts

@@ -0,0 +1,63 @@
+import { httpDebug } from "../../services/httpDebug";
+
+/**
+ * Represents an HTTP error response with a status code of 502 (Bad Gateway).
+ * This class is used to standardize the structure of a "Bad Gateway" error response,
+ * including the response body, headers, status, and status text.
+ */
+
+class BadGateway {
+  body: any;
+  cause?: any;
+  status: number = 502;
+  statusText: string;
+
+  /**
+   * Creates an instance of the `BadGateway` class.
+   *
+   * @param message - A descriptive message explaining the cause of the error.
+   * @param cause - Optional additional information about the cause of the error.
+   */
+
+  constructor(message: string, cause?: any) {
+    this.body = { name: "BadGateway", message: message };
+    this.statusText = message;
+    this.cause = cause ? JSON.stringify(cause) : undefined;
+    httpDebug("BadGateway", this.body, this.cause);
+  }
+
+  /**
+   * Converts the `BadGateway` 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 `BadGateway` 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 { BadGateway };