@arkyn/server 2.0.1-beta.3 → 2.0.1-beta.30

package/dist/services/schemaValidator.js

@@ -0,0 +1,51 @@
+import { Schema, z } from "zod";
+import { ServerError } from "../http/badResponses/serverError";
+import { UnprocessableEntity } from "../http/badResponses/unprocessableEntity";
+import { formParse } from "./formParse";
+import { getCaller } from "./getCaller";
+import { httpDebug } from "./httpDebug";
+function formatErrorMessage(error) {
+    const title = "Error validating:";
+    const lines = error.issues.map(({ path, message }) => `-> ${path.join(".")}: ${message}`);
+    return [title, ...lines].join("\n");
+}
+class SchemaValidator {
+    schema;
+    functionName;
+    callerInfo;
+    constructor(schema) {
+        this.schema = schema;
+        const { callerInfo, functionName } = getCaller();
+        this.callerInfo = callerInfo;
+        this.functionName = functionName;
+    }
+    isValid(data) {
+        return this.schema.safeParse(data).success;
+    }
+    safeValidate(data) {
+        return this.schema.safeParse(data);
+    }
+    validate(data) {
+        try {
+            return this.schema.parse(data);
+        }
+        catch (error) {
+            throw new ServerError(formatErrorMessage(error));
+        }
+    }
+    formValidate(data, message) {
+        const formParsed = formParse([data, this.schema]);
+        if (!formParsed.success) {
+            httpDebug("UnprocessableEntity", formParsed);
+            const firstErrorKey = Object.keys(formParsed.fieldErrors)[0];
+            throw new UnprocessableEntity({
+                fields: formParsed.fields,
+                fieldErrors: formParsed.fieldErrors,
+                data: { scrollTo: firstErrorKey },
+                message,
+            }, false);
+        }
+        return formParsed.data;
+    }
+}
+export { SchemaValidator };

package/package.json

@@ -1,24 +1,31 @@
 {
   "name": "@arkyn/server",
-  "version": "2.0.1-beta.3",
+  "version": "2.0.1-beta.30",
   "main": "./dist/bundle.js",
   "module": "./src/index.ts",
   "type": "module",
   "types": "./dist/index.d.ts",
+  "license": "Apache-2.0",
+  "author": "Arkyn | Lucas Gonçalves",
+  "description": "Server-side utilities for projects.",
   "scripts": {
     "clean": "rm -rf dist",
     "build": "bun run clean && bunx tsc --project tsconfig.json",
+    "test": "vitest --config vitest.config.ts",
     "typecheck": "bunx tsc --project tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@arkyn/server": "*",
     "@arkyn/shared": "*",
-    "@aws-sdk/client-s3": "^3.775.0",
-    "@remix-run/node": "^2.16.2",
-    "sharp": "^0.33.5"
+    "@aws-sdk/client-s3": "^3.782.0",
+    "sharp": "^0.33.5",
+    "zod": "^3.24.2"
+  },
+  "peerDependencies": {
+    "@remix-run/node": "^2.16.4"
   },
   "devDependencies": {
     "bun-types": "latest",
-    "typescript": "^5.8.2"
+    "vitest": "^3.1.1",
+    "typescript": "^5.8.3"
   }
 }

package/src/api/deleteRequest.ts

@@ -0,0 +1,22 @@
+import type { ApiResponseDTO } from "@arkyn/types";
+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 "@arkyn/types";
+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/inboxFlowRequest.ts

@@ -0,0 +1,76 @@
+import { InboxFlowInstance } from "../config/inboxFlowInstance";
+import { httpDebug } from "../services/httpDebug";
+
+type ConfigProps = {
+  status: number;
+  method: "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | "ERROR";
+  request: string;
+  response: string;
+  token: string;
+};
+
+/**
+ * Sends a request to the inbox flow API with the provided configuration.
+ *
+ * @param config - The configuration object for 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", "PATCH", or "ERROR".
+ * @param config.request - The request payload or details as a string.
+ * @param config.response - The response payload or details as a string.
+ * @param config.token - The token associated with the request for authentication or identification.
+ *
+ * @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 = {
+ *   status: 200,
+ *   method: "POST",
+ *   request: JSON.stringify({ key: "value" }),
+ *   response: JSON.stringify({ success: true }),
+ *   token: "example-token",
+ * };
+ *
+ * await inboxFlowRequest(config);
+ * ```
+ */
+
+async function inboxFlowRequest(config: ConfigProps) {
+  const inboxFlowInstance = InboxFlowInstance.getInboxConfig();
+  if (!inboxFlowInstance) return;
+
+  const { inboxChannelId, inboxUserToken, inboxApiUrl } = inboxFlowInstance;
+
+  const { status, method, request, response, token } = config;
+
+  if (process.env.NODE_ENV === "development") return;
+
+  try {
+    const body = JSON.stringify({
+      status,
+      channelId: inboxChannelId,
+      method,
+      token,
+      request,
+      response,
+    });
+
+    await fetch(inboxApiUrl, {
+      method: "POST",
+      body,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${inboxUserToken}`,
+      },
+    });
+  } catch (err) {
+    httpDebug("inboxFlowRequest", "Error sending inbox flow request", err);
+  }
+}
+
+export { inboxFlowRequest };

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/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/badGateway.ts

@@ -1,4 +1,10 @@
-import { httpDebug } from "../httpDebug";
+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;
@@ -6,6 +12,13 @@ class BadGateway {
   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;
@@ -13,7 +26,14 @@ class BadGateway {
     httpDebug("BadGateway", this.body, this.cause);
   }
 
-  toResponse() {
+  /**
+   * 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,
@@ -23,7 +43,14 @@ class BadGateway {
     return new Response(JSON.stringify(this.body), responseInit);
   }
 
-  toJson() {
+  /**
+   * 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,