@arkyn/server 3.0.1-beta.2 → 3.0.1-beta.21

package/dist/services/formParse.js

@@ -39,10 +39,10 @@
 function formParse([formData, schema,]) {
     const zodResponse = schema.safeParse(formData);
     if (zodResponse.success === false) {
-        const errorsObject = Object.fromEntries(zodResponse.error.errors.map((item) => [
-            item.path.join("."),
-            item.message,
-        ]));
+        const errorsObject = Object.fromEntries(zodResponse.error.issues.map((item) => {
+            console.log(item);
+            return [item.path.join("."), item.message];
+        }));
         return {
             success: zodResponse.success,
             fieldErrors: errorsObject,
@@ -50,7 +50,10 @@ function formParse([formData, schema,]) {
         };
     }
     else {
-        return { success: zodResponse.success, data: zodResponse.data };
+        return {
+            success: zodResponse.success,
+            data: zodResponse.data,
+        };
     }
 }
 export { formParse };

package/dist/services/getCaller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getCaller.d.ts","sourceRoot":"","sources":["../../src/services/getCaller.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAEH,iBAAS,SAAS;;;EA+BjB;AAED,OAAO,EAAE,SAAS,EAAE,CAAC"}
+{"version":3,"file":"getCaller.d.ts","sourceRoot":"","sources":["../../src/services/getCaller.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,iBAAS,SAAS;;;EAkEjB;AAED,OAAO,EAAE,SAAS,EAAE,CAAC"}

package/dist/services/getCaller.js

@@ -15,25 +15,51 @@ function getCaller() {
     const err = new Error();
     const stack = err.stack || "";
     const stackLines = stack.split("\n").map((line) => line.trim());
-    const callerLine = stackLines[4] || "";
-    let functionName = "unknown";
-    let callerInfo = "unknown location";
-    const functionMatch = callerLine.match(/at\s+([^\s]+)\s+\((.*)\)/);
-    if (functionMatch) {
-        functionName = functionMatch[1];
-        callerInfo = functionMatch[2];
+    // The first line is the error message
+    // The second line is this function (getCaller)
+    // The third line should be the direct caller
+    // We start from 2 because indexes are zero-based
+    let callerIndex = 2;
+    // Ignore internal or infrastructure lines if necessary
+    while (callerIndex < stackLines.length &&
+        (stackLines[callerIndex].includes("node:internal") ||
+            stackLines[callerIndex].includes("/node_modules/"))) {
+        callerIndex++;
     }
+    const callerLine = stackLines[callerIndex] || "";
+    let functionName = "Unknown function";
+    let callerInfo = "Unknown caller";
+    // Default for named functions: "at functionName (file:line:column)"
+    const namedFunctionMatch = callerLine.match(/at\s+([^(\s]+)\s+\(([^)]+)\)/);
+    if (namedFunctionMatch) {
+        functionName = namedFunctionMatch[1];
+        callerInfo = namedFunctionMatch[2];
+    }
+    // Default for anonymous functions or methods: "at file:line:column"
     else {
-        const locationMatch = callerLine.match(/at\s+(.*)/);
-        if (locationMatch) {
-            callerInfo = locationMatch[1];
-            const pathParts = callerInfo.split("/");
-            const lastPart = pathParts[pathParts.length - 1] || "";
-            const fileParts = lastPart.split(":");
-            functionName = fileParts[0] || "unknown";
+        const anonymousFunctionMatch = callerLine.match(/at\s+(.+)/);
+        if (anonymousFunctionMatch) {
+            callerInfo = anonymousFunctionMatch[1];
+            // Tenta extrair nome da função de padrões como Object.method ou Class.method
+            const objectMethodMatch = callerInfo.match(/at\s+([^(\s]+)\s+/);
+            if (objectMethodMatch && objectMethodMatch[1] !== "new") {
+                functionName = objectMethodMatch[1];
+            }
         }
     }
-    callerInfo = path.relative(projectRoot, callerInfo);
+    // Handles file paths
+    if (callerInfo.includes("(")) {
+        callerInfo = callerInfo.substring(callerInfo.indexOf("(") + 1, callerInfo.lastIndexOf(")"));
+    }
+    // Remove the line:column part of the file path
+    callerInfo = callerInfo.split(":").slice(0, -2).join(":");
+    // Make the path relative to the project
+    try {
+        callerInfo = path.relative(projectRoot, callerInfo);
+    }
+    catch (e) {
+        // If it fails to relativize, use the original path
+    }
     return { functionName, callerInfo };
 }
 export { getCaller };

package/dist/services/httpDebug.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"httpDebug.d.ts","sourceRoot":"","sources":["../../src/services/httpDebug.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,iBAAS,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,GAAG,QAuBtD;AAED,OAAO,EAAE,SAAS,EAAE,CAAC"}
+{"version":3,"file":"httpDebug.d.ts","sourceRoot":"","sources":["../../src/services/httpDebug.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,iBAAS,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,GAAG,QAuBtD;AAED,OAAO,EAAE,SAAS,EAAE,CAAC"}

package/dist/services/httpDebug.js

@@ -1,4 +1,3 @@
-import { InboxFlowInstance } from "../config/inboxFlowInstance";
 import { getCaller } from "../services/getCaller";
 /**
  * Logs debug information to the console when in development mode or when the

package/dist/services/measureRouteExecution.d.ts

@@ -0,0 +1,3 @@
+declare function measureRouteExecution<T = unknown>(handler: (props: any) => Promise<T>): (props: any) => Promise<T>;
+export { measureRouteExecution };
+//# sourceMappingURL=measureRouteExecution.d.ts.map

package/dist/services/measureRouteExecution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"measureRouteExecution.d.ts","sourceRoot":"","sources":["../../src/services/measureRouteExecution.ts"],"names":[],"mappings":"AAAA,iBAAS,qBAAqB,CAAC,CAAC,GAAG,OAAO,EACxC,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,OAAO,CAAC,CAAC,CAAC,IAEG,OAAO,GAAG,KAAG,OAAO,CAAC,CAAC,CAAC,CAyB9D;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/services/measureRouteExecution.js

@@ -0,0 +1,24 @@
+function measureRouteExecution(handler) {
+    return async function measuredHandler(props) {
+        const startTime = performance.now();
+        try {
+            const result = await handler(props);
+            const url = new URL(props.request.url);
+            const endTime = performance.now();
+            const duration = (endTime - startTime).toFixed(2);
+            console.log({
+                domain: url.hostname,
+                pathname: url.pathname,
+                method: props.request.method,
+                duration,
+            });
+            return result;
+        }
+        catch (error) {
+            const endTime = performance.now();
+            console.error("");
+            throw error;
+        }
+    };
+}
+export { measureRouteExecution };

package/dist/services/schemaValidator.d.ts

@@ -1,11 +1,11 @@
-import { Schema, z } from "zod";
-declare class SchemaValidator<T extends Schema> {
+import { ZodType, z } from "zod";
+declare class SchemaValidator<T extends ZodType> {
     readonly schema: T;
     functionName: string;
     callerInfo: string;
     constructor(schema: T);
     isValid(data: any): boolean;
-    safeValidate(data: any): z.SafeParseReturnType<z.infer<T>, z.infer<T>>;
+    safeValidate(data: any): z.ZodSafeParseResult<z.infer<T>>;
     validate(data: any): z.infer<T>;
     formValidate(data: any, message?: string): z.infer<T>;
 }

package/dist/services/schemaValidator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemaValidator.d.ts","sourceRoot":"","sources":["../../src/services/schemaValidator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAiBhC,cAAM,eAAe,CAAC,CAAC,SAAS,MAAM;IAIxB,QAAQ,CAAC,MAAM,EAAE,CAAC;IAH9B,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;gBAEE,MAAM,EAAE,CAAC;IAM9B,OAAO,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO;IAI3B,YAAY,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAItE,QAAQ,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;IAQ/B,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;CAoBtD;AAED,OAAO,EAAE,eAAe,EAAE,CAAC"}
+{"version":3,"file":"schemaValidator.d.ts","sourceRoot":"","sources":["../../src/services/schemaValidator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAiBjC,cAAM,eAAe,CAAC,CAAC,SAAS,OAAO;IAIzB,QAAQ,CAAC,MAAM,EAAE,CAAC;IAH9B,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;gBAEE,MAAM,EAAE,CAAC;IAM9B,OAAO,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO;IAI3B,YAAY,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAIzD,QAAQ,CAAC,IAAI,EAAE,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;IAQ/B,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;CAoBtD;AAED,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/services/schemaValidator.js

@@ -1,4 +1,4 @@
-import { Schema, z } from "zod";
+import { ZodType, z } from "zod";
 import { ServerError } from "../http/badResponses/serverError";
 import { UnprocessableEntity } from "../http/badResponses/unprocessableEntity";
 import { formParse } from "./formParse";

package/package.json

@@ -1,32 +1,29 @@
 {
   "name": "@arkyn/server",
-  "version": "3.0.1-beta.2",
+  "version": "3.0.1-beta.21",
   "author": "Arkyn | Lucas Gonçalves",
   "main": "./dist/bundle.js",
   "module": "./src/index.ts",
-  "dependencies": {
-    "@arkyn/shared": "*",
-    "@aws-sdk/client-s3": "^3.782.0",
-    "@mjackson/multipart-parser": "^0.8.2",
-    "sharp": "^0.33.5",
-    "zod": "^3.24.2"
-  },
-  "devDependencies": {
-    "bun-types": "latest",
-    "vitest": "^3.1.1",
-    "typescript": "^5.8.3"
-  },
-  "peerDependencies": {
-    "@react-router/node": ">=7.6.0"
-  },
-  "description": "Server-side utilities for projects.",
+  "type": "module",
+  "types": "./dist/index.d.ts",
   "license": "Apache-2.0",
+  "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"
   },
-  "type": "module",
-  "types": "./dist/index.d.ts"
+  "dependencies": {
+    "@arkyn/shared": "*",
+    "zod": "^4.0.17"
+  },
+  "devDependencies": {
+    "bun-types": "latest",
+    "vitest": "^3.2.4",
+    "typescript": "^5.9.2"
+  },
+  "peerDependencies": {
+    "@react-router/node": "^7.6.2"
+  }
 }

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

@@ -1,5 +1,7 @@
+import { ArkynLogRequestMapper } from "../mapper/arkynLogRequestMapper";
+import { httpDebug } from "../services/httpDebug";
 import type { ApiResponseDTO } from "../types/ApiResponseDTO";
-import { inboxFlowRequest } from "./inboxFlowRequest";
+import { arkynLogRequest } from "./arkynLogRequest";
 
 /**
  * Makes an HTTP request using the Fetch API and returns a standardized response.
@@ -39,7 +41,7 @@ import { inboxFlowRequest } from "./inboxFlowRequest";
 async function makeRequest<T = any>(
   method: "POST" | "PUT" | "DELETE" | "PATCH" | "GET",
   url: string,
-  headers: HeadersInit = {},
+  rawHeaders: HeadersInit = {},
   body?: any
 ): Promise<ApiResponseDTO<T>> {
   const successMessage = {
@@ -51,15 +53,16 @@ async function makeRequest<T = any>(
   };
 
   try {
+    const startTime = performance.now();
+
+    const headers = { ...rawHeaders, "Content-Type": "application/json" };
     const response = await fetch(url, {
       method,
-      headers: {
-        ...headers,
-        "Content-Type": "application/json",
-      },
+      headers,
       body: body ? JSON.stringify(body) : undefined,
     });
 
+    const elapsedTime = performance.now() - startTime;
     const status = response.status;
 
     let data: any = null;
@@ -69,14 +72,20 @@ async function makeRequest<T = any>(
       data = null;
     }
 
-    inboxFlowRequest({
+    const logData = ArkynLogRequestMapper.handle({
+      elapsedTime,
       method,
+      queryParams: new URL(url).searchParams,
+      requestHeaders: headers,
+      requestBody: body,
+      responseBody: data,
+      responseHeaders: response.headers,
       status,
-      request: JSON.stringify(response.headers),
-      response: JSON.stringify(data),
-      token: (headers as any)?.Authorization || "TOKEN_NOT_FOUND",
+      url,
     });
 
+    arkynLogRequest(logData);
+
     if (!response.ok) {
       return {
         success: false,
@@ -95,14 +104,7 @@ async function makeRequest<T = any>(
       cause: null,
     };
   } catch (err) {
-    inboxFlowRequest({
-      method,
-      request: JSON.stringify(headers),
-      response: String(err),
-      status: 500,
-      token: "TOKEN_NOT_FOUND",
-    });
-
+    httpDebug("Network error or request failed", null, err);
     return {
       success: false,
       status: 0,

package/src/config/apiInstance.ts

@@ -4,7 +4,7 @@ import { patchRequest } from "../api/patchRequest";
 import { postRequest } from "../api/postRequest";
 import { putRequest } from "../api/putRequest";
 
-type ApiInstanceContructorProps = {
+type ApiInstanceConstructorProps = {
   baseUrl: string;
   baseHeaders?: HeadersInit;
   baseToken?: string | null;
@@ -38,7 +38,7 @@ class ApiInstance {
    * @param props.baseToken - Optional base token for authorization.
    */
 
-  constructor(props: ApiInstanceContructorProps) {
+  constructor(props: ApiInstanceConstructorProps) {
     this.baseUrl = props.baseUrl;
     this.baseHeaders = props.baseHeaders || undefined;
     this.baseToken = props.baseToken || undefined;
@@ -76,26 +76,26 @@ class ApiInstance {
   }
 
   /**
-   * Sends a GET request to the specified route.
-   * @param route - The API route to send the GET request to.
+   * 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) {
+  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.
+   * 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) {
+  async post(route: string, data?: ApiRequestDataWithBodyProps) {
     const url = this.generateURL(route);
     const headers = this.generateHeaders(data?.headers || {}, data?.token);
     const body = data?.body;
@@ -103,13 +103,13 @@ class ApiInstance {
   }
 
   /**
-   * Sends a PUT request to the specified route.
-   * @param route - The API route to send the PUT request to.
+   * 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) {
+  async put(route: string, data?: ApiRequestDataWithBodyProps) {
     const url = this.generateURL(route);
     const headers = this.generateHeaders(data?.headers || {}, data?.token);
     const body = data?.body;
@@ -117,13 +117,13 @@ class ApiInstance {
   }
 
   /**
-   * Sends a PATCH request to the specified route.
-   * @param route - The API route to send the PATCH request to.
+   * 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) {
+  async patch(route: string, data?: ApiRequestDataWithBodyProps) {
     const url = this.generateURL(route);
     const headers = this.generateHeaders(data?.headers || {}, data?.token);
     const body = data?.body;
@@ -131,13 +131,13 @@ class ApiInstance {
   }
 
   /**
-   * Sends a DELETE request to the specified route.
-   * @param route - The API route to send the DELETE request to.
+   * 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) {
+  async delete(route: string, data?: ApiRequestDataWithBodyProps) {
     const url = this.generateURL(route);
     const headers = this.generateHeaders(data?.headers || {}, data?.token);
     const body = data?.body;

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

@@ -1,6 +1,6 @@
 // config
 export { ApiInstance } from "./config/apiInstance";
-export { InboxFlowInstance } from "./config/inboxFlowInstance";
+export { ArkynLogInstance } from "./config/arkynLogInstance";
 
 // http bad responses
 export { BadGateway } from "./http/badResponses/badGateway";