@arkyn/server 3.0.1-beta.12 → 3.0.1-beta.121

package/dist/services/apiService.js

@@ -0,0 +1,158 @@
+import { deleteRequest } from "../http/api/deleteRequest";
+import { getRequest } from "../http/api/getRequest";
+import { patchRequest } from "../http/api/patchRequest";
+import { postRequest } from "../http/api/postRequest";
+import { putRequest } from "../http/api/putRequest";
+import { flushDebugLogs } from "../utilities/flushDebugLogs";
+class ApiService {
+    baseUrl;
+    baseHeaders;
+    baseToken;
+    enableDebug;
+    constructor(props) {
+        this.baseUrl = props.baseUrl;
+        this.baseHeaders = props.baseHeaders || undefined;
+        this.baseToken = props.baseToken || undefined;
+        this.enableDebug = props.enableDebug || false;
+    }
+    onDebug(endpoint, method, data) {
+        if (this.enableDebug) {
+            const debugs = [];
+            const json = (data) => JSON.stringify(data, null, 2);
+            debugs.push(`Base URL: ${this.baseUrl}`);
+            debugs.push(`Endpoint: ${endpoint}`);
+            debugs.push(`Status/Method: ${method} => ${data.status}`);
+            debugs.push(`Message: ${data.message}`);
+            if (data.headers)
+                debugs.push(`Headers: ${json(data.headers)}`);
+            if (data.body)
+                debugs.push(`Body: ${json(data.body)}`);
+            flushDebugLogs({ debugs, name: "ApiDebug", scheme: "yellow" });
+        }
+    }
+    generateHeaders(initHeaders, token) {
+        let headers = {};
+        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 endpoint.
+     * @param endpoint - The API endpoint to send the get request to.
+     * @param data - The request data, including optional headers and token.
+     * @returns The API response data.
+     */
+    async get(endpoint, data) {
+        const headers = this.generateHeaders(data?.headers || {}, data?.token);
+        const response = await getRequest({
+            url: this.baseUrl + endpoint,
+            urlParams: data?.urlParams || {},
+            headers,
+        });
+        this.onDebug(endpoint, "get", {
+            headers,
+            message: response.message,
+            status: response.status,
+        });
+        return response;
+    }
+    /**
+     * Sends a post request to the specified endpoint.
+     * @param endpoint - The API endpoint to send the post request to.
+     * @param data - The request data, including body, optional headers, and token.
+     * @returns The API response data.
+     */
+    async post(endpoint, data) {
+        const headers = this.generateHeaders(data?.headers || {}, data?.token);
+        const body = data?.body;
+        const response = await postRequest({
+            url: this.baseUrl + endpoint,
+            urlParams: data?.urlParams || {},
+            headers,
+            body,
+        });
+        this.onDebug(endpoint, "post", {
+            headers,
+            body,
+            message: response.message,
+            status: response.status,
+        });
+        return response;
+    }
+    /**
+     * Sends a put request to the specified endpoint.
+     * @param endpoint - The API endpoint to send the put request to.
+     * @param data - The request data, including body, optional headers, and token.
+     * @returns The API response data.
+     */
+    async put(endpoint, data) {
+        const headers = this.generateHeaders(data?.headers || {}, data?.token);
+        const body = data?.body;
+        const response = await putRequest({
+            url: this.baseUrl + endpoint,
+            urlParams: data?.urlParams || {},
+            headers,
+            body,
+        });
+        this.onDebug(endpoint, "put", {
+            headers,
+            body,
+            message: response.message,
+            status: response.status,
+        });
+        return response;
+    }
+    /**
+     * Sends a patch request to the specified endpoint.
+     * @param endpoint - The API endpoint to send the patch request to.
+     * @param data - The request data, including body, optional headers, and token.
+     * @returns The API response data.
+     */
+    async patch(endpoint, data) {
+        const headers = this.generateHeaders(data?.headers || {}, data?.token);
+        const body = data?.body;
+        const response = await patchRequest({
+            url: this.baseUrl + endpoint,
+            urlParams: data?.urlParams || {},
+            headers,
+            body,
+        });
+        this.onDebug(endpoint, "patch", {
+            headers,
+            body,
+            message: response.message,
+            status: response.status,
+        });
+        return response;
+    }
+    /**
+     * Sends a delete request to the specified endpoint.
+     * @param endpoint - The API endpoint to send the delete request to.
+     * @param data - The request data, including body, optional headers, and token.
+     * @returns The API response data.
+     */
+    async delete(endpoint, data) {
+        const headers = this.generateHeaders(data?.headers || {}, data?.token);
+        const body = data?.body;
+        const response = await deleteRequest({
+            url: this.baseUrl + endpoint,
+            urlParams: data?.urlParams || {},
+            headers,
+            body,
+        });
+        this.onDebug(endpoint, "delete", {
+            headers,
+            body,
+            message: response.message,
+            status: response.status,
+        });
+        return response;
+    }
+}
+export { ApiService };

package/dist/services/debugService.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Service for managing HTTP debug configuration and behavior.
+ *
+ * This service provides functionality to configure how the `getCaller` function
+ * identifies the actual caller in the stack trace by allowing specific files
+ * to be ignored during stack trace analysis.
+ *
+ * @example
+ * ```typescript
+ * // Configure to ignore httpAdapter.ts in stack traces
+ * HttpDebugService.setIgnoreFile("httpAdapter.ts");
+ *
+ * // Now when httpDebug is called from within httpAdapter.ts,
+ * // it will show the actual caller (e.g., cart.ts) instead
+ * ```
+ */
+declare class DebugService {
+    /**
+     * The name of the file to ignore when analyzing the stack trace.
+     * When set, the `getCaller` function will skip stack frames containing this file name.
+     */
+    static ignoreFiles: string[];
+    /**
+     * Sets the file name to be ignored during stack trace analysis.
+     *
+     * This method configures the debug service to skip specific files when
+     * determining the actual caller of a function. This is useful when you have
+     * adapter or wrapper functions that you want to be transparent in the debug output.
+     *
+     * @param {string} file - The name of the file to ignore in stack traces (e.g., "httpAdapter.ts")
+     *
+     * @example
+     * ```typescript
+     * // Ignore the HTTP adapter file so debug shows the actual business logic caller
+     * DebugService.setIgnoreFile("httpAdapter.ts");
+     * ```
+     */
+    static setIgnoreFile(file: string): void;
+    /**
+     * Clears all configured ignore files.
+     *
+     * This method resets the ignore file configuration, allowing all files to be
+     * considered in stack trace analysis again.
+     *
+     * @example
+     * ```typescript
+     * // Clear all ignore file configurations
+     * DebugService.clearIgnoreFiles();
+     * ```
+     */
+    static clearIgnoreFiles(): void;
+    /**
+     * Retrieves information about the caller of the current function.
+     *
+     * This function analyzes the stack trace to determine the file path and function name
+     * of the caller. It excludes stack trace entries related to the `@arkyn/server` package
+     * and attempts to resolve the file path relative to the project root directory.
+     *
+     * @returns An object containing:
+     * - `functionName`: The name of the function that called the current function, or "Unknown function" if it cannot be determined.
+     * - `callerInfo`: The file path of the caller relative to the project root, or "Unknown caller" if it cannot be determined.
+     */
+    static getCaller(): {
+        functionName: string;
+        callerInfo: string;
+    };
+}
+export { DebugService };
+//# sourceMappingURL=debugService.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"debugService.d.ts","sourceRoot":"","sources":["../../src/services/debugService.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AAEH,cAAM,YAAY;IAChB;;;OAGG;IACH,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,CAAM;IAElC;;;;;;;;;;;;;;OAcG;IAEH,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAIxC;;;;;;;;;;;OAWG;IAEH,MAAM,CAAC,gBAAgB,IAAI,IAAI;IAI/B;;;;;;;;;;OAUG;IAEH,MAAM,CAAC,SAAS;;;;CAgEjB;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/services/debugService.js

@@ -0,0 +1,114 @@
+import path from "path";
+/**
+ * Service for managing HTTP debug configuration and behavior.
+ *
+ * This service provides functionality to configure how the `getCaller` function
+ * identifies the actual caller in the stack trace by allowing specific files
+ * to be ignored during stack trace analysis.
+ *
+ * @example
+ * ```typescript
+ * // Configure to ignore httpAdapter.ts in stack traces
+ * HttpDebugService.setIgnoreFile("httpAdapter.ts");
+ *
+ * // Now when httpDebug is called from within httpAdapter.ts,
+ * // it will show the actual caller (e.g., cart.ts) instead
+ * ```
+ */
+class DebugService {
+    /**
+     * The name of the file to ignore when analyzing the stack trace.
+     * When set, the `getCaller` function will skip stack frames containing this file name.
+     */
+    static ignoreFiles = [];
+    /**
+     * Sets the file name to be ignored during stack trace analysis.
+     *
+     * This method configures the debug service to skip specific files when
+     * determining the actual caller of a function. This is useful when you have
+     * adapter or wrapper functions that you want to be transparent in the debug output.
+     *
+     * @param {string} file - The name of the file to ignore in stack traces (e.g., "httpAdapter.ts")
+     *
+     * @example
+     * ```typescript
+     * // Ignore the HTTP adapter file so debug shows the actual business logic caller
+     * DebugService.setIgnoreFile("httpAdapter.ts");
+     * ```
+     */
+    static setIgnoreFile(file) {
+        this.ignoreFiles.push(file);
+    }
+    /**
+     * Clears all configured ignore files.
+     *
+     * This method resets the ignore file configuration, allowing all files to be
+     * considered in stack trace analysis again.
+     *
+     * @example
+     * ```typescript
+     * // Clear all ignore file configurations
+     * DebugService.clearIgnoreFiles();
+     * ```
+     */
+    static clearIgnoreFiles() {
+        this.ignoreFiles = [];
+    }
+    /**
+     * Retrieves information about the caller of the current function.
+     *
+     * This function analyzes the stack trace to determine the file path and function name
+     * of the caller. It excludes stack trace entries related to the `@arkyn/server` package
+     * and attempts to resolve the file path relative to the project root directory.
+     *
+     * @returns An object containing:
+     * - `functionName`: The name of the function that called the current function, or "Unknown function" if it cannot be determined.
+     * - `callerInfo`: The file path of the caller relative to the project root, or "Unknown caller" if it cannot be determined.
+     */
+    static getCaller() {
+        const projectRoot = process.cwd();
+        const err = new Error();
+        const stack = err.stack || "";
+        const stackLines = stack.split("\n").map((line) => line.trim());
+        let callerIndex = 2;
+        while (callerIndex < stackLines.length &&
+            (stackLines[callerIndex].includes("node:internal") ||
+                stackLines[callerIndex].includes("/node_modules/"))) {
+            callerIndex++;
+        }
+        if (this.ignoreFiles.length > 0) {
+            while (callerIndex < stackLines.length &&
+                this.ignoreFiles.some((ignoreFile) => stackLines[callerIndex].includes(ignoreFile))) {
+                callerIndex++;
+            }
+        }
+        const callerLine = stackLines[callerIndex] || "";
+        let functionName = "Unknown function";
+        let callerInfo = "Unknown caller";
+        const namedFunctionMatch = callerLine.match(/at\s+([^(\s]+)\s+\(([^)]+)\)/);
+        if (namedFunctionMatch) {
+            functionName = namedFunctionMatch[1];
+            callerInfo = namedFunctionMatch[2];
+        }
+        else {
+            const anonymousFunctionMatch = callerLine.match(/at\s+(.+)/);
+            if (anonymousFunctionMatch) {
+                callerInfo = anonymousFunctionMatch[1];
+                const objectMethodMatch = callerInfo.match(/at\s+([^(\s]+)\s+/);
+                if (objectMethodMatch && objectMethodMatch[1] !== "new") {
+                    functionName = objectMethodMatch[1];
+                }
+            }
+        }
+        if (callerInfo.includes("(")) {
+            callerInfo = callerInfo.substring(callerInfo.indexOf("(") + 1, callerInfo.lastIndexOf(")"));
+        }
+        callerInfo = callerInfo.split(":").slice(0, -2).join(":");
+        try {
+            callerInfo = path.relative(projectRoot, callerInfo);
+        }
+        catch (e) { }
+        return { functionName, callerInfo };
+    }
+}
+export { DebugService };

package/dist/services/logMapperService.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Input properties for log mapping.
+ *
+ * @typedef {object} InputProps
+ * @property {number} status - HTTP response status code.
+ * @property {string} url - The request URL.
+ * @property {"GET" | "POST" | "PUT" | "DELETE" | "PATCH"} method - HTTP method used.
+ * @property {HeadersInit} requestHeaders - Headers sent with the request.
+ * @property {HeadersInit} responseHeaders - Headers received in the response.
+ * @property {any} requestBody - Body of the request.
+ * @property {number} elapsedTime - Time elapsed for the request in milliseconds.
+ * @property {any} responseBody - Body of the response.
+ * @property {URLSearchParams} queryParams - Query parameters from the URL.
+ */
+type InputProps = {
+    status: number;
+    rawUrl: string;
+    urlParams?: Record<string, string>;
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    requestHeaders: HeadersInit;
+    responseHeaders: HeadersInit;
+    requestBody: any;
+    elapsedTime: number;
+    responseBody: any;
+    queryParams: URLSearchParams;
+};
+/**
+ * Output properties after log mapping transformation.
+ *
+ * @typedef {object} OutputProps
+ * @property {string} rawUrl - The original request URL.
+ * @property {number} status - HTTP response status code.
+ * @property {"GET" | "POST" | "PUT" | "DELETE" | "PATCH"} method - HTTP method used.
+ * @property {string | null} token - Authentication token (if present).
+ * @property {number} elapsedTime - Time elapsed for the request in milliseconds.
+ * @property {Record<string, string>} requestHeaders - Mapped request headers.
+ * @property {Record<string, string>} requestBody - Mapped request body.
+ * @property {Record<string, string>} queryParams - Mapped query parameters.
+ * @property {Record<string, string>} responseHeaders - Mapped response headers.
+ * @property {any} responseBody - The response body.
+ */
+type OutputProps = {
+    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: any;
+};
+/**
+ * Static service for mapping HTTP request/response data into a standardized log format.
+ *
+ * Provides utilities to transform headers and query parameters into plain objects,
+ * and produces a unified output structure for logging purposes.
+ */
+declare class LogMapperService {
+    /**
+     * Converts various header formats into a plain key-value object.
+     *
+     * @param {HeadersInit} headers - The headers to map.
+     * @returns {Record<string, string>} A plain object with header key-value pairs.
+     * @private
+     */
+    private static mapHeaders;
+    /**
+     * Converts URLSearchParams into a plain key-value object.
+     *
+     * @param {URLSearchParams} queryParams - The query parameters to map.
+     * @returns {Record<string, string>} A plain object with query parameter key-value pairs.
+     * @private
+     */
+    private static mapQueryParams;
+    /**
+     * Transforms raw HTTP request/response data into a standardized log output format.
+     *
+     * @param {InputProps} props - The input properties containing request/response data.
+     * @returns {OutputProps} The mapped output object ready for logging.
+     */
+    static handle(props: InputProps): OutputProps;
+}
+export { LogMapperService };
+//# sourceMappingURL=logMapperService.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logMapperService.d.ts","sourceRoot":"","sources":["../../src/services/logMapperService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,KAAK,UAAU,GAAG;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAC;IACpD,cAAc,EAAE,WAAW,CAAC;IAC5B,eAAe,EAAE,WAAW,CAAC;IAC7B,WAAW,EAAE,GAAG,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,GAAG,CAAC;IAClB,WAAW,EAAE,eAAe,CAAC;CAC9B,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,CAAC;IACpD,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,YAAY,EAAE,GAAG,CAAC;CACnB,CAAC;AAEF;;;;;GAKG;AACH,cAAM,gBAAgB;IACpB;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,UAAU;IAiBzB;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;IAQ7B;;;;;OAKG;IACH,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW;CAiB9C;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/services/logMapperService.js

@@ -0,0 +1,68 @@
+/**
+ * Static service for mapping HTTP request/response data into a standardized log format.
+ *
+ * Provides utilities to transform headers and query parameters into plain objects,
+ * and produces a unified output structure for logging purposes.
+ */
+class LogMapperService {
+    /**
+     * Converts various header formats into a plain key-value object.
+     *
+     * @param {HeadersInit} headers - The headers to map.
+     * @returns {Record<string, string>} A plain object with header key-value pairs.
+     * @private
+     */
+    static mapHeaders(headers) {
+        if (headers instanceof Headers) {
+            return Object.fromEntries(headers.entries());
+        }
+        else if (typeof headers === "object") {
+            return Object.entries(headers).reduce((acc, [key, value]) => {
+                if (typeof value === "string")
+                    acc[key] = value;
+                else if (Array.isArray(value))
+                    acc[key] = value.join(", ");
+                else
+                    acc[key] = JSON.stringify(value);
+                return acc;
+            }, {});
+        }
+        return {};
+    }
+    /**
+     * Converts URLSearchParams into a plain key-value object.
+     *
+     * @param {URLSearchParams} queryParams - The query parameters to map.
+     * @returns {Record<string, string>} A plain object with query parameter key-value pairs.
+     * @private
+     */
+    static mapQueryParams(queryParams) {
+        const params = {};
+        queryParams.forEach((value, key) => (params[key] = value));
+        return params;
+    }
+    /**
+     * Transforms raw HTTP request/response data into a standardized log output format.
+     *
+     * @param {InputProps} props - The input properties containing request/response data.
+     * @returns {OutputProps} The mapped output object ready for logging.
+     */
+    static handle(props) {
+        return {
+            rawUrl: props.rawUrl,
+            status: props.status,
+            method: props.method,
+            token: null,
+            elapsedTime: props.elapsedTime,
+            requestHeaders: this.mapHeaders(props.requestHeaders),
+            requestBody: props.requestBody || null,
+            queryParams: {
+                ...this.mapQueryParams(props.queryParams),
+                ...props.urlParams,
+            },
+            responseHeaders: this.mapHeaders(props.responseHeaders),
+            responseBody: props.responseBody || null,
+        };
+    }
+}
+export { LogMapperService };

package/dist/services/logService.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Static service for log endpoint configuration and access.
+ *
+ * Stores a singleton configuration containing the traffic source identifier,
+ * user token, and log ingestion URL.
+ */
+declare class LogService {
+    private static config?;
+    /**
+     * Sets the log service configuration only once.
+     * If the configuration is already set, the call is ignored.
+     *
+     * @param {object} config - Service configuration parameters.
+     * @param {string} config.trafficSourceId - Traffic source identifier.
+     * @param {string} config.userToken - User token for authentication.
+     * @param {string} [config.logBaseApiUrl] - Optional base URL for the log service.
+     */
+    static setConfig(config: {
+        trafficSourceId: string;
+        userToken: string;
+        logBaseApiUrl?: string;
+    }): void;
+    /**
+     * Returns the current service configuration, if it exists.
+     * @returns {{ trafficSourceId: string; userToken: string; apiUrl: string } | undefined} The stored configuration or `undefined` if not set.
+     */
+    static getConfig(): {
+        trafficSourceId: string;
+        userToken: string;
+        apiUrl: string;
+    } | undefined;
+    /**
+     * Resets the stored configuration, allowing a new initialization.
+     */
+    static resetConfig(): void;
+}
+export { LogService };
+//# sourceMappingURL=logService.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logService.d.ts","sourceRoot":"","sources":["../../src/services/logService.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,cAAM,UAAU;IACd,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAIpB;IAEF;;;;;;;;OAQG;IACH,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE;QACvB,eAAe,EAAE,MAAM,CAAC;QACxB,SAAS,EAAE,MAAM,CAAC;QAClB,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,GAAG,IAAI;IAUR;;;OAGG;IACH,MAAM,CAAC,SAAS,IACZ;QAAE,eAAe,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAC9D,SAAS;IAIb;;OAEG;IACH,MAAM,CAAC,WAAW;CAGnB;AAED,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/services/logService.js

@@ -0,0 +1,40 @@
+/**
+ * Static service for log endpoint configuration and access.
+ *
+ * Stores a singleton configuration containing the traffic source identifier,
+ * user token, and log ingestion URL.
+ */
+class LogService {
+    static config;
+    /**
+     * Sets the log service configuration only once.
+     * If the configuration is already set, the call is ignored.
+     *
+     * @param {object} config - Service configuration parameters.
+     * @param {string} config.trafficSourceId - Traffic source identifier.
+     * @param {string} config.userToken - User token for authentication.
+     * @param {string} [config.logBaseApiUrl] - Optional base URL for the log service.
+     */
+    static setConfig(config) {
+        if (!!this.config)
+            return;
+        const { trafficSourceId, userToken, logBaseApiUrl } = config;
+        const baseUrl = logBaseApiUrl || `http://95.216.190.158:8081`;
+        const apiUrl = `${baseUrl}/ingest-log`;
+        this.config = { trafficSourceId, userToken, apiUrl };
+    }
+    /**
+     * Returns the current service configuration, if it exists.
+     * @returns {{ trafficSourceId: string; userToken: string; apiUrl: string } | undefined} The stored configuration or `undefined` if not set.
+     */
+    static getConfig() {
+        return this.config;
+    }
+    /**
+     * Resets the stored configuration, allowing a new initialization.
+     */
+    static resetConfig() {
+        this.config = undefined;
+    }
+}
+export { LogService };

package/dist/{services → utilities}/decodeRequestBody.d.ts

@@ -1,4 +1,3 @@
-type DecodeRequestBodyFunction = (request: Request) => Promise<any>;
 /**
  * Decodes the body of an incoming request into a JavaScript object.
  *
@@ -7,11 +6,11 @@ type DecodeRequestBodyFunction = (request: Request) => Promise<any>;
  * 2. If JSON parsing fails, attempts to parse the body as URL-encoded form data.
  * 3. If both parsing attempts fail, logs the errors and returns an empty object.
  *
- * @param req - The incoming request object containing the body to decode.
- * @returns A promise that resolves to the decoded data as a JavaScript object.
+ * @param {Request} request - The incoming request object containing the body to decode.
+ * @returns {Promise<any>} A promise that resolves to the decoded data as a JavaScript object.
  *
  * @throws Logs errors to the console if the request body cannot be read or parsed.
  */
-declare const decodeRequestBody: DecodeRequestBodyFunction;
+declare function decodeRequestBody(request: Request): Promise<any>;
 export { decodeRequestBody };
 //# sourceMappingURL=decodeRequestBody.d.ts.map

package/dist/utilities/decodeRequestBody.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decodeRequestBody.d.ts","sourceRoot":"","sources":["../../src/utilities/decodeRequestBody.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AAEH,iBAAe,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,CAsB/D;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/{services → utilities}/decodeRequestBody.js

@@ -7,14 +7,14 @@ import { BadRequest } from "../http/badResponses/badRequest";
  * 2. If JSON parsing fails, attempts to parse the body as URL-encoded form data.
  * 3. If both parsing attempts fail, logs the errors and returns an empty object.
  *
- * @param req - The incoming request object containing the body to decode.
- * @returns A promise that resolves to the decoded data as a JavaScript object.
+ * @param {Request} request - The incoming request object containing the body to decode.
+ * @returns {Promise<any>} A promise that resolves to the decoded data as a JavaScript object.
  *
  * @throws Logs errors to the console if the request body cannot be read or parsed.
  */
-const decodeRequestBody = async (req) => {
+async function decodeRequestBody(request) {
     let data;
-    const arrayBuffer = await req.arrayBuffer();
+    const arrayBuffer = await request.arrayBuffer();
     const text = new TextDecoder().decode(arrayBuffer);
     try {
         data = JSON.parse(text);
@@ -34,5 +34,5 @@ const decodeRequestBody = async (req) => {
         }
     }
     return data;
-};
+}
 export { decodeRequestBody };

package/dist/{services/decodeErrorMessageFromRequest.d.ts → utilities/decodeRequestErrorMessage.d.ts}

@@ -5,13 +5,13 @@
  * `data` or `response` objects by checking various properties in a specific order.
  * If no valid error message is found, it returns a default message: "Missing error message".
  *
- * @param data - The data object that may contain error information. It can have properties
+ * @param {any} data - The data object that may contain error information. It can have properties
  * such as `message`, `error`, or `error.message` that are checked for a string value.
- * @param response - The response object that may contain a `statusText` property
+ * @param {Response} response - The response object that may contain a `statusText` property
  * representing the HTTP status text.
- * @returns A string representing the decoded error message, or a default message
+ * @returns {string} A string representing the decoded error message, or a default message
  * if no error message is found.
  */
-declare function decodeErrorMessageFromRequest(data: any, response: Response): string;
-export { decodeErrorMessageFromRequest };
-//# sourceMappingURL=decodeErrorMessageFromRequest.d.ts.map
+declare function decodeRequestErrorMessage(data: any, response: Response): string;
+export { decodeRequestErrorMessage };
+//# sourceMappingURL=decodeRequestErrorMessage.d.ts.map

package/dist/utilities/decodeRequestErrorMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decodeRequestErrorMessage.d.ts","sourceRoot":"","sources":["../../src/utilities/decodeRequestErrorMessage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,iBAAS,yBAAyB,CAAC,IAAI,EAAE,GAAG,EAAE,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAkBxE;AAED,OAAO,EAAE,yBAAyB,EAAE,CAAC"}