@arkyn/server 3.0.1-beta.154 → 3.0.1-beta.156

package/dist/http/successResponses/_successResponse.js

@@ -1,75 +0,0 @@
-import { DebugService } from "../../services/debugService";
-import { flushDebugLogs } from "../../utilities/flushDebugLogs";
-/**
- * Base class for handling successful HTTP responses with debugging capabilities.
- * Provides logging functionality to track response and their context.
- */
-class SuccessResponse {
-    _body = null;
-    _name = "SuccessResponse";
-    _status = 200;
-    _statusText = "OK";
-    _debugColor = "green";
-    get body() {
-        return this._body;
-    }
-    set body(value) {
-        this._body = value ?? null;
-    }
-    get name() {
-        return this._name;
-    }
-    set name(value) {
-        this._name = value;
-    }
-    get status() {
-        return this._status;
-    }
-    set status(value) {
-        this._status = value;
-    }
-    get statusText() {
-        return this._statusText;
-    }
-    set statusText(value) {
-        this._statusText = value;
-    }
-    get debugColor() {
-        return this._debugColor;
-    }
-    set debugColor(value) {
-        if (!["green", "yellow", "cyan", "red"].includes(value))
-            return;
-        this._debugColor = value;
-    }
-    /**
-     * Logs debug information for success responses including caller context and response details.
-     *
-     * @param {any} body - The response body or success data to be logged
-     *
-     * @example
-     * ```typescript
-     * const SuccessResponse = new SuccessResponse();
-     * SuccessResponse.onDebug({ data: "Operation completed successfully" });
-     * ```
-     */
-    onDebug(body) {
-        const debugs = [];
-        const { callerInfo, functionName } = DebugService.getCaller();
-        debugs.push(`Caller Function: ${functionName}`);
-        debugs.push(`Caller Location: ${callerInfo}`);
-        if (this.statusText)
-            debugs.push(`Message: ${this.statusText}`);
-        if (body)
-            debugs.push(`Body: ${JSON.stringify(body)}`);
-        flushDebugLogs({ scheme: this._debugColor, name: this.name, debugs });
-    }
-    makeBody() {
-        return {
-            name: this.name,
-            message: this.statusText,
-            body: this.body,
-        };
-    }
-}
-export { SuccessResponse };

package/dist/http/successResponses/created.js

@@ -1,41 +0,0 @@
-import { SuccessResponse } from "./_successResponse";
-/**
- * HTTP 201 Created — the request succeeded and a new resource was created.
- *
- * @example
- * ```typescript
- * return new Created("User created successfully", { id: user.id }).toJson();
- * ```
- */
-class Created extends SuccessResponse {
-    /**
-     * @param message - Description included in the response status text.
-     * @param body - Data to include in the response body.
-     */
-    constructor(message, body) {
-        super();
-        this.name = "Created";
-        this.status = 201;
-        this.statusText = message;
-        this.body = body || undefined;
-        this.onDebug();
-    }
-    /** Converts to a `Response` with `Content-Type: application/json` header. */
-    toResponse() {
-        const responseInit = {
-            headers: { "Content-Type": "application/json" },
-            status: this.status,
-            statusText: this.statusText,
-        };
-        return new Response(JSON.stringify(this.body), responseInit);
-    }
-    /** Converts to a `Response` using `Response.json()`. Alternative to `toResponse()`. */
-    toJson() {
-        const responseInit = {
-            status: this.status,
-            statusText: this.statusText,
-        };
-        return Response.json(this.body, responseInit);
-    }
-}
-export { Created };

package/dist/http/successResponses/found.js

@@ -1,41 +0,0 @@
-import { SuccessResponse } from "./_successResponse";
-/**
- * HTTP 302 Found — the resource was located and the response includes it in the body.
- *
- * @example
- * ```typescript
- * return new Found("Products retrieved", { products }).toJson();
- * ```
- */
-class Found extends SuccessResponse {
-    /**
-     * @param message - Description included in the response status text.
-     * @param body - Data to include in the response body.
-     */
-    constructor(message, body) {
-        super();
-        this.name = "Found";
-        this.status = 302;
-        this.statusText = message;
-        this.body = body || undefined;
-        this.onDebug();
-    }
-    /** Converts to a `Response` with `Content-Type: application/json` header. */
-    toResponse() {
-        const responseInit = {
-            headers: { "Content-Type": "application/json" },
-            status: this.status,
-            statusText: this.statusText,
-        };
-        return new Response(JSON.stringify(this.body), responseInit);
-    }
-    /** Converts to a `Response` using `Response.json()`. Alternative to `toResponse()`. */
-    toJson() {
-        const responseInit = {
-            status: this.status,
-            statusText: this.statusText,
-        };
-        return Response.json(this.body, responseInit);
-    }
-}
-export { Found };

package/dist/http/successResponses/noContent.js

@@ -1,32 +0,0 @@
-import { SuccessResponse } from "./_successResponse";
-/**
- * HTTP 204 No Content — the request succeeded but there is no content to return.
- * Typically used for delete or update operations where a body is not needed.
- *
- * @example
- * ```typescript
- * return new NoContent("Record deleted").toResponse();
- * ```
- */
-class NoContent extends SuccessResponse {
-    /**
-     * @param message - Description included in the response status text.
-     */
-    constructor(message) {
-        super();
-        this.name = "NoContent";
-        this.status = 204;
-        this.statusText = message;
-        this.onDebug();
-    }
-    /** Converts to a `Response` with `Content-Type: application/json` header and no body. */
-    toResponse() {
-        const responseInit = {
-            headers: { "Content-Type": "application/json" },
-            status: this.status,
-            statusText: this.statusText,
-        };
-        return new Response(null, responseInit);
-    }
-}
-export { NoContent };

package/dist/http/successResponses/success.js

@@ -1,41 +0,0 @@
-import { SuccessResponse } from "./_successResponse";
-/**
- * HTTP 200 OK — the request succeeded and the response body contains the result.
- *
- * @example
- * ```typescript
- * return new Success("Order fetched", { order }).toJson();
- * ```
- */
-class Success extends SuccessResponse {
-    /**
-     * @param message - Description included in the response status text.
-     * @param body - Data to include in the response body.
-     */
-    constructor(message, body) {
-        super();
-        this.name = "Success";
-        this.status = 200;
-        this.statusText = message;
-        this.body = body || undefined;
-        this.onDebug();
-    }
-    /** Converts to a `Response` with `Content-Type: application/json` header. */
-    toResponse() {
-        const responseInit = {
-            headers: { "Content-Type": "application/json" },
-            status: this.status,
-            statusText: this.statusText,
-        };
-        return new Response(JSON.stringify(this.body), responseInit);
-    }
-    /** Converts to a `Response` using `Response.json()`. Alternative to `toResponse()`. */
-    toJson() {
-        const responseInit = {
-            status: this.status,
-            statusText: this.statusText,
-        };
-        return Response.json(this.body, responseInit);
-    }
-}
-export { Success };

package/dist/http/successResponses/updated.js

@@ -1,42 +0,0 @@
-import { SuccessResponse } from "./_successResponse";
-/**
- * HTTP 200 OK — the request succeeded and the resource was updated.
- * Semantically equivalent to `Success` but signals an update operation to consumers.
- *
- * @example
- * ```typescript
- * return new Updated("Profile updated", { user }).toJson();
- * ```
- */
-class Updated extends SuccessResponse {
-    /**
-     * @param message - Description included in the response status text.
-     * @param body - Data to include in the response body.
-     */
-    constructor(message, body) {
-        super();
-        this.name = "Updated";
-        this.status = 200;
-        this.statusText = message;
-        this.body = body || undefined;
-        this.onDebug();
-    }
-    /** Converts to a `Response` with `Content-Type: application/json` header. */
-    toResponse() {
-        const responseInit = {
-            headers: { "Content-Type": "application/json" },
-            status: this.status,
-            statusText: this.statusText,
-        };
-        return new Response(JSON.stringify(this.body), responseInit);
-    }
-    /** Converts to a `Response` using `Response.json()`. Alternative to `toResponse()`. */
-    toJson() {
-        const responseInit = {
-            status: this.status,
-            statusText: this.statusText,
-        };
-        return Response.json(this.body, responseInit);
-    }
-}
-export { Updated };

package/dist/services/apiService.js

@@ -1,174 +0,0 @@
-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";
-/**
- * HTTP client for external API calls. Wraps fetch with base URL, default headers, optional auth token,
- * and per-request overrides for all standard HTTP methods.
- *
- * @example
- * ```typescript
- * const api = new ApiService({
- *   baseUrl: "https://api.example.com",
- *   baseToken: session.token,
- *   enableDebug: true,
- * });
- *
- * const { data } = await api.get("/users/me");
- * const { data: created } = await api.post("/orders", { body: { productId: 1 } });
- * ```
- */
-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.js

@@ -1,82 +0,0 @@
-import path from "node:path";
-/**
- * Manages stack-trace configuration for debug output, allowing specific adapter/wrapper files
- * to be skipped so logs show the actual business-logic caller.
- *
- * @example
- * ```typescript
- * // Skip httpAdapter.ts so debug output shows the calling route instead
- * DebugService.setIgnoreFile("httpAdapter.ts");
- * ```
- */
-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 = [];
-    /**
-     * Adds a file name to the ignore list so it is skipped when resolving the caller in stack traces.
-     *
-     * @param file - File name to ignore (e.g. `"httpAdapter.ts"`).
-     */
-    static setIgnoreFile(file) {
-        this.ignoreFiles.push(file);
-    }
-    /** Resets the ignore list, restoring full stack trace analysis. */
-    static clearIgnoreFiles() {
-        this.ignoreFiles = [];
-    }
-    /**
-     * Resolves the file path and function name of the code that triggered the current debug call,
-     * skipping internal node modules and any files registered with `setIgnoreFile`.
-     *
-     * @returns `{ functionName, callerInfo }` — caller function name and file path relative to `process.cwd()`.
-     */
-    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.js

@@ -1,68 +0,0 @@
-/**
- * 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.js

@@ -1,35 +0,0 @@
-/**
- * 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 once. Subsequent calls are ignored.
-     *
-     * @param config.trafficSourceId - Traffic source identifier.
-     * @param config.userToken - User token for authentication.
-     * @param config.logBaseApiUrl - Override the default log ingestion base URL.
-     */
-    static setConfig(config) {
-        if (!!this.config)
-            return;
-        const { trafficSourceId, userToken, logBaseApiUrl } = config;
-        const baseUrl = logBaseApiUrl || `http://62.238.8.44:8081`;
-        const apiUrl = `${baseUrl}/ingest-log`;
-        this.config = { trafficSourceId, userToken, apiUrl };
-    }
-    /** Returns the stored configuration, or `undefined` if `setConfig` has not been called. */
-    static getConfig() {
-        return this.config;
-    }
-    /**
-     * Resets the stored configuration, allowing a new initialization.
-     */
-    static resetConfig() {
-        this.config = undefined;
-    }
-}
-export { LogService };

package/dist/utilities/decodeRequestBody.js

@@ -1,40 +0,0 @@
-import { BadRequest } from "../http/badResponses/badRequest";
-/**
- * Decodes a request body into a plain object, trying JSON first then URL-encoded form data.
- * Throws `BadRequest` if neither format can be parsed.
- *
- * @param request - The incoming request whose body will be decoded.
- * @returns The decoded body as a plain object.
- *
- * @example
- * ```typescript
- * export async function action({ request }: ActionFunctionArgs) {
- *   const body = await decodeRequestBody(request);
- *   // body is now a plain JS object
- * }
- * ```
- */
-async function decodeRequestBody(request) {
-    let data;
-    const arrayBuffer = await request.arrayBuffer();
-    const text = new TextDecoder().decode(arrayBuffer);
-    try {
-        data = JSON.parse(text);
-    }
-    catch (jsonError) {
-        try {
-            if (text.includes("=")) {
-                const formData = new URLSearchParams(text);
-                data = Object.fromEntries(formData.entries());
-            }
-            else {
-                throw new BadRequest("Invalid URLSearchParams format");
-            }
-        }
-        catch (formDataError) {
-            throw new BadRequest("Failed to extract data from request");
-        }
-    }
-    return data;
-}
-export { decodeRequestBody };