oneentry 1.0.142 → 1.0.143

package/dist/base/asyncModules.js

@@ -0,0 +1,448 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable jsdoc/no-undefined-types */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const buffer_1 = require("buffer");
+const syncModules_1 = __importDefault(require("./syncModules"));
+const validation_1 = require("./validation");
+/**
+ * Abstract class AsyncModules extends SyncModules to provide asynchronous HTTP request functionalities.
+ * @description Abstract class AsyncModules extends SyncModules to provide asynchronous HTTP request functionalities.
+ */
+class AsyncModules extends syncModules_1.default {
+    /**
+     * Constructor initializes the AsyncModules with a given state.
+     * @param {StateModule} state - Instance of StateModule containing configuration and state data.
+     * @description Constructor initializes the AsyncModules with a given state.
+     */
+    constructor(state) {
+        var _a;
+        super(state);
+        this.state = state;
+        this._url = this.state.url;
+        this._NO_FETCH = state._NO_FETCH;
+        this._https = (_a = state._https) !== null && _a !== void 0 ? _a : null;
+    }
+    /**
+     * Validates API response against a Zod schema (optional)
+     * @param {unknown} data - The data to validate
+     * @param {z.ZodSchema<T>} [schema] - Optional Zod schema for validation
+     * @returns {T | IError} Validated data or error object
+     * @description Validates response data if validation is enabled in config
+     */
+    _validateResponse(data, schema) {
+        // Skip validation if not enabled or no schema provided
+        if (!this.state.validationEnabled || !schema) {
+            return data;
+        }
+        // Skip validation for error responses (statusCode indicates API error)
+        if (data !== null &&
+            typeof data === 'object' &&
+            'statusCode' in data &&
+            typeof data.statusCode === 'number' &&
+            data.statusCode >= 400) {
+            return data;
+        }
+        // Use strict or safe validation based on config
+        if (this.state.validationStrictMode) {
+            const result = (0, validation_1.validateResponse)(schema, data, {
+                logErrors: this.state.validationLogErrors,
+            });
+            if (!result.success) {
+                // Return error object compatible with IError interface
+                return {
+                    statusCode: 422,
+                    message: 'Response validation failed',
+                    pageData: null,
+                    timestamp: new Date().toISOString(),
+                    localizeMessage: result.error.issues
+                        .map((e) => `${e.path.join('.')}: ${e.message}`)
+                        .join(', '),
+                    validationErrors: result.error.issues,
+                };
+            }
+            return result.data;
+        }
+        else {
+            // Non-strict mode: log errors but return original data
+            return (0, validation_1.validateResponseSafe)(schema, data, this.state.validationLogErrors);
+        }
+    }
+    /**
+     * Performs an HTTP GET request.
+     * @param {string} path - The path to append to the base URL.
+     * @returns {Promise<T>} A promise resolving to the response data.
+     * @description Define a protected asynchronous method '_fetchGet' that performs a GET request
+     */
+    async _fetchGet(path) {
+        // Create options for the GET request using the 'makeOptions' method
+        const options = this.makeOptions('GET');
+        // Check if the fetch operation should be performed using the Fetch API or an alternative method
+        if (!this._NO_FETCH) {
+            // If Fetch API is allowed, use 'browserResponse' to perform the request and return the result
+            return await this.browserResponse(path, options);
+        }
+        else {
+            // If Fetch API is not allowed, perform the request using Node.js HTTPS module
+            // Return a new promise to handle the asynchronous nature of the HTTPS request
+            return new Promise((resolve, reject) => {
+                // Use the HTTPS module to send a GET request to the specified path with the given options
+                const req = this._https.get(this._getFullPath(path), // Get the full URL path for the request
+                options, // Pass the options for the request
+                (res) => {
+                    // Handle the response from the server
+                    let responseData = ''; // Initialize a variable to accumulate response data
+                    // Listen for 'data' events to receive chunks of data from the response
+                    res.on('data', (chunk) => {
+                        responseData += chunk; // Append each chunk to the accumulated response data
+                    });
+                    // Listen for the 'end' event to know when the response has been fully received
+                    res.on('end', () => {
+                        try {
+                            // Attempt to parse the accumulated response data as JSON and resolve the promise with it
+                            resolve(JSON.parse(responseData));
+                            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                        }
+                        catch (error) {
+                            // If parsing fails, resolve the promise with the raw response data
+                            resolve(responseData);
+                        }
+                    });
+                });
+                // Listen for 'error' events on the request to handle any errors that occur
+                req.on('error', (error) => {
+                    // Reject the promise with the error
+                    reject(error);
+                });
+            });
+        }
+    }
+    /**
+     * Performs an HTTP POST request.
+     * @param {string} path   - The path to append to the base URL.
+     * @param {unknown} [data] - The data to send in the request body.
+     * @returns {Promise<T>} A promise resolving to the response data.
+     * @description Define a protected asynchronous method '_fetchPost' that performs a POST request
+     */
+    async _fetchPost(path, data) {
+        // Create options for the POST request using the 'makeOptions' method, including the data to be sent
+        const options = this.makeOptions('POST', data);
+        // Check if the fetch operation should be performed using the Fetch API or an alternative method
+        if (!this._NO_FETCH) {
+            // If Fetch API is allowed, use 'browserResponse' to perform the request and return the result
+            return await this.browserResponse(path, options);
+        }
+        else {
+            // If Fetch API is not allowed, perform the request using Node.js HTTPS module
+            // Return a new promise to handle the asynchronous nature of the HTTPS request
+            return new Promise((resolve, reject) => {
+                // Use the HTTPS module to send a POST request to the specified path with the given options
+                const req = this._https.request(this._getFullPath(path), // Get the full URL path for the request
+                options, // Pass the options for the request
+                (res) => {
+                    // Handle the response from the server
+                    // Accumulate response chunks in an array for efficient memory usage
+                    const chunks = [];
+                    // Listen for 'data' events to receive chunks of data from the response
+                    res.on('data', (chunk) => {
+                        chunks.push(buffer_1.Buffer.isBuffer(chunk) ? chunk : buffer_1.Buffer.from(chunk));
+                    });
+                    // Listen for the 'end' event to know when the response has been fully received
+                    res.on('end', () => {
+                        try {
+                            // Concatenate all chunks efficiently and parse as JSON
+                            const responseData = buffer_1.Buffer.concat(chunks).toString('utf8');
+                            resolve(JSON.parse(responseData));
+                            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                        }
+                        catch (error) {
+                            // If parsing fails, resolve the promise with the raw response data
+                            const responseData = buffer_1.Buffer.concat(chunks).toString('utf8');
+                            resolve(responseData);
+                        }
+                    });
+                });
+                // Listen for 'error' events on the request to handle any errors that occur
+                req.on('error', (error) => {
+                    // Reject the promise with the error
+                    reject(error);
+                });
+                // Write the provided data to the request body in JSON format
+                req.write(JSON.stringify(data));
+                // End the request to signal that all data has been sent
+                req.end();
+            });
+        }
+    }
+    /**
+     * Performs an HTTP PUT request.
+     * @param {string} path - The path to append to the base URL.
+     * @param {unknown} body - The data to send in the request body.
+     * @returns {Promise<T>} A promise resolving to the response data.
+     * @description Define a protected asynchronous method '_fetchPut' that performs a PUT request
+     */
+    async _fetchPut(path, body) {
+        // Create options for the PUT request using the 'makeOptions' method, including the data to be sent
+        const options = this.makeOptions('PUT', body);
+        // Check if the fetch operation should be performed using the Fetch API or an alternative method
+        if (!this._NO_FETCH) {
+            // If Fetch API is allowed, use 'browserResponse' to perform the request and return the result
+            return await this.browserResponse(path, options);
+        }
+        else {
+            // If Fetch API is not allowed, perform the request using Node.js HTTPS module
+            // Return a new promise to handle the asynchronous nature of the HTTPS request
+            return new Promise((resolve, reject) => {
+                // Use the HTTPS module to send a PUT request to the specified path with the given options
+                const req = this._https.request(this._getFullPath(path), // Get the full URL path for the request
+                options, // Pass the options for the request
+                (res) => {
+                    // Handle the response from the server
+                    let responseData = ''; // Initialize a variable to accumulate response data
+                    // Listen for 'data' events to receive chunks of data from the response
+                    res.on('data', (chunk) => {
+                        responseData += chunk; // Append each chunk to the accumulated response data
+                    });
+                    // Listen for the 'end' event to know when the response has been fully received
+                    res.on('end', () => {
+                        try {
+                            // Attempt to parse the accumulated response data as JSON and resolve the promise with it
+                            resolve(JSON.parse(responseData));
+                            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                        }
+                        catch (error) {
+                            // If parsing fails, resolve the promise with the raw response data
+                            resolve(responseData);
+                        }
+                    });
+                });
+                // Listen for 'error' events on the request to handle any errors that occur
+                req.on('error', (error) => {
+                    // Reject the promise with the error
+                    reject(error);
+                });
+                // Write the provided data to the request body in JSON format
+                req.write(JSON.stringify(body));
+                // End the request to signal that all data has been sent
+                req.end();
+            });
+        }
+    }
+    /**
+     * Performs an HTTP DELETE request.
+     * @param {string} path - The path to append to the base URL.
+     * @param {unknown} body - The body of the request.
+     * @returns {Promise<T>} A promise resolving to the response data.
+     * @description Define a protected asynchronous method '_fetchDelete' that performs a DELETE request
+     */
+    async _fetchDelete(path, body) {
+        // Create options for the DELETE request using the 'makeOptions' method
+        const options = this.makeOptions('DELETE', body);
+        // Check if the fetch operation should be performed using the Fetch API or an alternative method
+        if (!this._NO_FETCH) {
+            // If Fetch API is allowed, use 'browserResponse' to perform the request and return the result
+            return await this.browserResponse(path, options);
+        }
+        else {
+            // If Fetch API is not allowed, perform the request using Node.js HTTPS module
+            // Return a new promise to handle the asynchronous nature of the HTTPS request
+            return new Promise((resolve, reject) => {
+                // Use the HTTPS module to send a DELETE request to the specified path with the given options
+                const req = this._https.delete(this._getFullPath(path), // Get the full URL path for the request
+                options, // Pass the options for the request
+                (res) => {
+                    // Handle the response from the server
+                    let responseData = ''; // Initialize a variable to accumulate response data
+                    // Listen for 'data' events to receive chunks of data from the response
+                    res.on('data', (chunk) => {
+                        responseData += chunk; // Append each chunk to the accumulated response data
+                    });
+                    // Listen for the 'end' event to know when the response has been fully received
+                    res.on('end', () => {
+                        try {
+                            // Attempt to parse the accumulated response data as JSON and resolve the promise with it
+                            resolve(JSON.parse(responseData));
+                            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                        }
+                        catch (error) {
+                            // If parsing fails, resolve the promise with the raw response data
+                            resolve(responseData);
+                        }
+                    });
+                });
+                // Listen for 'error' events on the request to handle any errors that occur
+                req.on('error', (error) => {
+                    // Reject the promise with the error
+                    reject(error);
+                });
+            });
+        }
+    }
+    /**
+     * Refreshes the authentication token.
+     * @returns {Promise<boolean>} A promise resolving to a boolean indicating success or failure.
+     * @description Define an asynchronous method 'refreshToken' that attempts to refresh the authentication token
+     */
+    async refreshToken() {
+        const url = this.state.url +
+            `/api/content/users-auth-providers/marker/` +
+            this.state.providerMarker +
+            `/users/refresh`;
+        /**
+         * Perform a fetch request to the specified URL to refresh the token
+         * @param {string} url - The URL to which the request will be sent
+         * @param {object} options - The options for the fetch request
+         * @param {string} options.method - The HTTP method to use for the request (default: 'POST')
+         * @param {object} options.headers - Set the necessary headers for the request
+         * @param {object} options.body - Send the current refresh token in the request body as a JSON string
+         */
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                // Indicate that the request body is in JSON format
+                'Content-Type': 'application/json',
+                // Include the application token from the state
+                'x-app-token': this.state.token,
+                // Include the device fingerprint
+                'x-device-metadata': this._getDeviceMetadata(),
+            },
+            body: JSON.stringify({ refreshToken: this.state.refreshToken }),
+        });
+        // Check if the response status is OK (status code 200-299)
+        if (response.ok) {
+            // Parse the response body as JSON and store the result
+            const result = await response.json();
+            // Update the state's refreshToken and accessToken with the new tokens from the response
+            this.state.refreshToken = result.refreshToken;
+            this.state.accessToken = result.accessToken;
+            // If a save function is defined in the state, call it with the new refresh token
+            if (this.state.saveFunction) {
+                this.state.saveFunction(result.refreshToken);
+            }
+            // Return true to indicate that the token refresh was successful
+            return true;
+        }
+        else {
+            // Return false to indicate that the token refresh failed
+            return false;
+        }
+    }
+    /**
+     * Creates options for HTTP requests.
+     * @param {string} method - The HTTP method (GET, POST, PUT, DELETE, etc.).
+     * @param {unknown} data - Optional data to include in the request body.
+     * @returns {IHttpOptions} An object representing the request options.
+     */
+    makeOptions(method, data) {
+        const options = {
+            method: method,
+            headers: {
+                'Content-Type': 'application/json',
+                'x-app-token': this.state.token,
+            },
+        };
+        // if method = 'POST' add x-device-metadata
+        if (method === 'POST') {
+            options.headers = {
+                ...options.headers,
+                'x-device-metadata': this._getDeviceMetadata(),
+            };
+        }
+        // Check if 'data' is an instance of FormData or Blob
+        if (data instanceof FormData || data instanceof Blob) {
+            // Remove the 'Content-Type' header from options.headers
+            delete options.headers['Content-Type'];
+            // Set the 'accept' header to 'application/json', while preserving existing headers
+            options.headers = {
+                ...options.headers,
+                accept: 'application/json',
+            };
+            // Assign 'data' to options.body for sending as request payload
+            options.body = data;
+        }
+        else if (data) {
+            // If 'data' exists and is not FormData or Blob, convert it to a JSON string
+            // and assign it to options.body
+            options.body = JSON.stringify(data);
+        }
+        // Check if there is an access token available in the state
+        if (this.state.accessToken) {
+            // Add an 'Authorization' header with the Bearer token to options.headers
+            options.headers['Authorization'] = 'Bearer ' + this.state.accessToken;
+        }
+        return options;
+    }
+    /**
+     * Handles responses from the browser's fetch API.
+     * @param {string} path - The path to append to the base URL.
+     * @param {IHttpOptions} options - The options for the fetch request.
+     * @returns {Promise<T>} A promise resolving to the response data.
+     * @description Define an asynchronous method 'browserResponse' that takes a path and options as parameters
+     */
+    async browserResponse(path, options) {
+        try {
+            // Perform a fetch request using the full URL obtained from '_getFullPath' and the provided options
+            const response = await fetch(this._getFullPath(path), options);
+            // Check if the response status is OK (status code 200-299)
+            if (response.ok) {
+                try {
+                    // Attempt to read the response body as text
+                    const text = await response.text();
+                    // If the response body is not empty, parse it as JSON; otherwise, return an empty object
+                    return (text ? JSON.parse(text) : {});
+                    // Alternatively, you could directly return the parsed JSON with 'await response.json()'
+                }
+                catch (e) {
+                    // If parsing the response fails, return the error
+                    return e;
+                }
+            }
+            else {
+                // Handle non-OK responses
+                // Check if the status is 401 (Unauthorized) and custom authentication is not used
+                if (response.status === 401 && !this.state.customAuth) {
+                    // Attempt to refresh the access token
+                    const refresh = await this.refreshToken();
+                    if (refresh) {
+                        // Update the Authorization header with the new access token
+                        options.headers['Authorization'] =
+                            'Bearer ' + this.state.accessToken;
+                        // Retry the fetch request with updated headers
+                        const secondResponse = await fetch(this._getFullPath(path), options);
+                        // Return the JSON-parsed response of the retry request
+                        return (await secondResponse.json());
+                    }
+                }
+                // Store the response status and parse the response body as JSON
+                const status = response.status;
+                const res = await response.json();
+                const statusKey = status;
+                if (this.state.errorsFunctions &&
+                    this.state.errorsFunctions[statusKey]) {
+                    this.state.errorsFunctions[statusKey](res);
+                }
+                // Determine whether to return or throw the response based on 'isShell' state
+                if (this.state.isShell) {
+                    return res;
+                }
+                else {
+                    throw res;
+                }
+            }
+        }
+        catch (e) {
+            // Handle any errors that occur during the fetch process
+            // Determine whether to return or throw the error based on 'isShell' state
+            if (this.state.isShell) {
+                return e;
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+}
+exports.default = AsyncModules;

package/dist/base/result.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Result class for handling response data.
+ * @description Result class for handling response data.
+ */
+export default class Result {
+    body: any;
+    /**
+     * Constructor that initializes the class with a given data.
+     * @param {Response | string} data - Response or string data.
+     * @description Constructor that initializes the class with a given data, which can be of type Response or string.
+     */
+    constructor(data: Response | string);
+    /**
+     * Asynchronously converts the body to a blob and returns the current instance.
+     * @returns {Promise<Result>} Current instance.
+     * @description Asynchronously converts the body to a blob and returns the current instance.
+     */
+    blob(): Promise<Result>;
+    /**
+     * Asynchronously parses the body as JSON and returns the current instance.
+     * @returns {Promise<Result>} Current instance.
+     * @description Asynchronously parses the body as JSON and returns the current instance.
+     */
+    json(): Promise<Result>;
+    /**
+     * Recursively removes language-specific data from the provided data or the body.
+     * @param {string} langCode - Language code.
+     * @param {any} [data] - Data to process.
+     * @returns {any} Processed data.
+     * @description Recursively removes language-specific data from the provided data or the body.
+     */
+    makeDataWithoutLang(langCode: string, data?: any): any;
+    /**
+     * Recursively simplifies arrays in the provided data or the body by removing single-element arrays.
+     * @param {any} data - The data to simplify.
+     * @returns {any} The simplified data.
+     */
+    makeDataWithoutArray(data?: any): any;
+}

package/dist/base/result.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable jsdoc/reject-any-type */
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Result class for handling response data.
+ * @description Result class for handling response data.
+ */
+class Result {
+    /**
+     * Constructor that initializes the class with a given data.
+     * @param {Response | string} data - Response or string data.
+     * @description Constructor that initializes the class with a given data, which can be of type Response or string.
+     */
+    constructor(data) {
+        this.body = data;
+    }
+    /**
+     * Asynchronously converts the body to a blob and returns the current instance.
+     * @returns {Promise<Result>} Current instance.
+     * @description Asynchronously converts the body to a blob and returns the current instance.
+     */
+    async blob() {
+        // Convert the body to a blob using the blob() method.
+        this.body = await this.body.blob();
+        return this;
+    }
+    /**
+     * Asynchronously parses the body as JSON and returns the current instance.
+     * @returns {Promise<Result>} Current instance.
+     * @description Asynchronously parses the body as JSON and returns the current instance.
+     */
+    async json() {
+        // Check if the body is a string, then parse it as JSON, otherwise call the json() method.
+        this.body =
+            (await typeof this.body) === 'string'
+                ? JSON.parse(this.body)
+                : this.body.json();
+        return this;
+    }
+    /**
+     * Recursively removes language-specific data from the provided data or the body.
+     * @param {string} langCode - Language code.
+     * @param {any} [data] - Data to process.
+     * @returns {any} Processed data.
+     * @description Recursively removes language-specific data from the provided data or the body.
+     */
+    makeDataWithoutLang(langCode, data) {
+        if (data) {
+            // If data is an array, recursively process each item.
+            if (Array.isArray(data)) {
+                return data.map((item) => this.makeDataWithoutLang(langCode, item));
+            }
+            else {
+                // Iterate through each key in the data object.
+                for (const key in data) {
+                    // If the value is an object containing the specified language code, replace it with the language-specific value.
+                    if (typeof data[key] === 'object' &&
+                        data[key] &&
+                        langCode in data[key]) {
+                        data[key] = data[key][langCode];
+                    }
+                    else if (typeof data[key] === 'object' && data[key] != null) {
+                        // If the value is an object, recursively process it.
+                        data[key] = this.makeDataWithoutLang(langCode, data[key]);
+                    }
+                    else if (Array.isArray(data[key])) {
+                        // If the value is an array, recursively process each item.
+                        data[key] = data.map((item) => this.makeDataWithoutLang(langCode, item));
+                    }
+                }
+                // Return the processed data.
+                return data;
+            }
+        }
+        else {
+            // Process the body if no specific data is provided.
+            if (Array.isArray(this.body)) {
+                this.body = this.body.map((item) => this.makeDataWithoutLang(langCode, item));
+            }
+            else {
+                // Iterate through each key in the body object.
+                for (const key in this.body) {
+                    // Similar processing as above but applied to the body.
+                    if (typeof this.body[key] === 'object' &&
+                        this.body[key] &&
+                        langCode in this.body[key]) {
+                        this.body[key] = this.body[key][langCode];
+                    }
+                    else if (typeof this.body[key] === 'object' &&
+                        this.body[key] != null) {
+                        this.body[key] = this.makeDataWithoutLang(langCode, this.body[key]);
+                    }
+                    else if (Array.isArray(this.body[key])) {
+                        this.body[key] = this.body[key].map((item) => this.makeDataWithoutLang(langCode, item));
+                    }
+                }
+            }
+            return this;
+        }
+    }
+    /**
+     * Recursively simplifies arrays in the provided data or the body by removing single-element arrays.
+     * @param {any} data - The data to simplify.
+     * @returns {any} The simplified data.
+     */
+    makeDataWithoutArray(data) {
+        if (data) {
+            // If data is an array, recursively process each item.
+            if (Array.isArray(data)) {
+                return data.map((item) => this.makeDataWithoutArray(item));
+            }
+            else {
+                // Iterate through each key in the data object.
+                for (const key in data) {
+                    // If the value is a single-element array, replace it with the element itself.
+                    if (Array.isArray(data[key]) && data[key].length === 1) {
+                        data[key] = data[key][0];
+                    }
+                    else if (typeof data[key] === 'object' &&
+                        data[key] &&
+                        !Array.isArray(data[key])) {
+                        // If the value is an object, recursively process it.
+                        data[key] = this.makeDataWithoutArray(data[key]);
+                    }
+                }
+                return data;
+            }
+        }
+        else {
+            // Process the body if no specific data is provided.
+            if (Array.isArray(this.body)) {
+                return this.body.map((item) => this.makeDataWithoutArray(item));
+            }
+            else {
+                // Iterate through each key in the body object.
+                for (const key in this.body) {
+                    // Similar processing as above but applied to the body.
+                    if (Array.isArray(this.body[key]) && this.body[key].length === 1) {
+                        this.body[key] = this.body[key][0];
+                    }
+                    else if (typeof this.body[key] === 'object' &&
+                        this.body[key] &&
+                        !Array.isArray(this.body[key])) {
+                        this.body[key] = this.makeDataWithoutArray(this.body[key]);
+                    }
+                }
+                return this;
+            }
+        }
+    }
+}
+exports.default = Result;