12304255045

Committed 12 Dec 2024 08:28PM UTC coverage: 94.258% (-1.5%) from 95.726%

Build # 12304255045

Build Type

push

github

Committed by

bodrovis

Commit Message

prettify

Run Details

67 of 72 branches covered (93.06%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

4 existing lines in 2 files now uncovered.

130 of 137 relevant lines covered (94.89%)

86.72 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.56

/lib/services/LokaliseFileExchange.ts

import { LokaliseApi } from "@lokalise/node-api";
import type { ClientParams } from "@lokalise/node-api";
import { ApiError as LokaliseApiError } from "@lokalise/node-api";
import { LokaliseError } from "../errors/LokaliseError.js";
import type { LokaliseExchangeConfig } from "../interfaces/LokaliseExchangeConfig.js";
import type { RetryParams } from "../interfaces/index.js";

/**
 * A utility class for exchanging files with the Lokalise API.
 */
export class LokaliseFileExchange {
        /**
         * The Lokalise API client instance.
         */
        public readonly apiClient: LokaliseApi;

        /**
         * The ID of the project in Lokalise.
         */
        protected readonly projectId: string;

        /**
         * Retry parameters for API requests.
         */
        protected readonly retryParams: RetryParams;

        /**
         * Default retry parameters for API requests.
         */
        private static readonly defaultRetryParams: RetryParams = {
                maxRetries: 3,
                initialSleepTime: 1000,
        };

        /**
         * Creates a new instance of LokaliseFileExchange.
         *
         * @param {ClientParams} clientConfig - Configuration for Lokalise SDK.
         * @param {LokaliseExchangeConfig} exchangeConfig - The configuration object.
         * @throws {Error} If the provided configuration is invalid.
         */
        constructor(
                clientConfig: ClientParams,
                exchangeConfig: LokaliseExchangeConfig,
        ) {
                // Validate the API key
                if (!clientConfig.apiKey || typeof clientConfig.apiKey !== "string") {
                        throw new Error("Invalid or missing API token.");
                }

                // Validate the project ID
                if (
                        !exchangeConfig.projectId ||
                        typeof exchangeConfig.projectId !== "string"
                ) {
                        throw new Error("Invalid or missing Project ID.");
                }

                // Validate and sanitize retryParams
                const mergedRetryParams = {
                        ...LokaliseFileExchange.defaultRetryParams,
                        ...exchangeConfig.retryParams,
                };
                if (mergedRetryParams.maxRetries < 0) {
                        throw new Error("maxRetries must be greater than or equal to zero.");
                }

                this.apiClient = new LokaliseApi(clientConfig);
                this.projectId = exchangeConfig.projectId;
                this.retryParams = mergedRetryParams;
        }

        /**
         * Executes an asynchronous operation with exponential backoff retry logic.
         *
         * This method retries the provided operation in the event of specific retryable errors (e.g., 429 Too Many Requests,
         * 408 Request Timeout) using an exponential backoff strategy. If the maximum number of retries is exceeded,
         * it throws an error. Non-retryable errors are immediately propagated.
         *
         * @template T The type of the value returned by the operation.
         * @param {() => Promise<T>} operation - The asynchronous operation to be executed.
         * @returns {Promise<T>} A promise that resolves to the result of the operation if successful.
         * @throws {LokaliseError} Throws a LokaliseError if the maximum number of retries is reached or for non-retryable errors.
         */
        protected async withExponentialBackoff<T>(
                operation: () => Promise<T>,
        ): Promise<T> {
                const { maxRetries, initialSleepTime } = this.retryParams;

                for (let attempt = 1; attempt <= maxRetries + 1; attempt++) {
                        try {
                                return await operation();
                        } catch (error: unknown) {
                                if (
                                        error instanceof LokaliseApiError &&
                                        (error.code === 429 || error.code === 408)
                                ) {
                                        if (attempt === maxRetries + 1) {
                                                throw new LokaliseError(
                                                        `Maximum retries reached: ${error instanceof Error ? error.message : "Unknown error"}`,
                                                        error.code,
                                                        error.details,
                                                );
                                        }
                                        await this.sleep(initialSleepTime * 2 ** (attempt - 1));
                                } else if (error instanceof LokaliseApiError) {
                                        throw new LokaliseError(error.message, error.code, error.details);
                                } else {
                                        throw error;
                                }
                        }
                }

                throw new LokaliseError("Unexpected error", 500);
        }

        /**
         * Pauses execution for the specified number of milliseconds.
         *
         * @param ms - The time to sleep in milliseconds.
         * @returns A promise that resolves after the specified time.
         * @internal This is a utility method used for retrying failed requests.
         */
        protected sleep(ms: number): Promise<void> {
                return new Promise((resolve) => setTimeout(resolve, ms));
        }
}

1	import { LokaliseApi } from "@lokalise/node-api";
2	import type { ClientParams } from "@lokalise/node-api";
3	import { ApiError as LokaliseApiError } from "@lokalise/node-api";
4	import { LokaliseError } from "../errors/LokaliseError.js";
5	import type { LokaliseExchangeConfig } from "../interfaces/LokaliseExchangeConfig.js";
6	import type { RetryParams } from "../interfaces/index.js";
7
8	/**
9	* A utility class for exchanging files with the Lokalise API.
10	*/
11	export class LokaliseFileExchange {
12	/**
13	* The Lokalise API client instance.
14	*/
15	public readonly apiClient: LokaliseApi;
16
17	/**
18	* The ID of the project in Lokalise.
19	*/
20	protected readonly projectId: string;
21
22	/**
23	* Retry parameters for API requests.
24	*/
25	protected readonly retryParams: RetryParams;
26
27	/**
28	* Default retry parameters for API requests.
29	*/
30	private static readonly defaultRetryParams: RetryParams = {	54✔
31	maxRetries: 3,
32	initialSleepTime: 1000,
33	};
34
35	/**
36	* Creates a new instance of LokaliseFileExchange.
37	*
38	* @param {ClientParams} clientConfig - Configuration for Lokalise SDK.
39	* @param {LokaliseExchangeConfig} exchangeConfig - The configuration object.
40	* @throws {Error} If the provided configuration is invalid.
41	*/
42	constructor(
43	clientConfig: ClientParams,
44	exchangeConfig: LokaliseExchangeConfig,
45	) {
46	// Validate the API key
47	if (!clientConfig.apiKey \|\| typeof clientConfig.apiKey !== "string") {	252✔
48	throw new Error("Invalid or missing API token.");	12✔
49	}
50
51	// Validate the project ID
52	if (	240✔
53	!exchangeConfig.projectId \|\|	474✔
54	typeof exchangeConfig.projectId !== "string"
55	) {
56	throw new Error("Invalid or missing Project ID.");	12✔
57	}
58
59	// Validate and sanitize retryParams
60	const mergedRetryParams = {	228✔
61	...LokaliseFileExchange.defaultRetryParams,
62	...exchangeConfig.retryParams,
63	};
64	if (mergedRetryParams.maxRetries < 0) {	228✔
65	throw new Error("maxRetries must be greater than or equal to zero.");	6✔
66	}
67
68	this.apiClient = new LokaliseApi(clientConfig);	222✔
69	this.projectId = exchangeConfig.projectId;	222✔
70	this.retryParams = mergedRetryParams;	222✔
71	}
72
73	/**
74	* Executes an asynchronous operation with exponential backoff retry logic.
75	*
76	* This method retries the provided operation in the event of specific retryable errors (e.g., 429 Too Many Requests,
77	* 408 Request Timeout) using an exponential backoff strategy. If the maximum number of retries is exceeded,
78	* it throws an error. Non-retryable errors are immediately propagated.
79	*
80	* @template T The type of the value returned by the operation.
81	* @param {() => Promise<T>} operation - The asynchronous operation to be executed.
82	* @returns {Promise<T>} A promise that resolves to the result of the operation if successful.
83	* @throws {LokaliseError} Throws a LokaliseError if the maximum number of retries is reached or for non-retryable errors.
84	*/
85	protected async withExponentialBackoff<T>(
86	operation: () => Promise<T>,
87	): Promise<T> {
88	const { maxRetries, initialSleepTime } = this.retryParams;	168✔
89
90	for (let attempt = 1; attempt <= maxRetries + 1; attempt++) {	168✔
91	try {	246✔
92	return await operation();	246✔
93	} catch (error: unknown) {
94	if (	120✔
95	error instanceof LokaliseApiError &&	300✔
96	(error.code === 429 \|\| error.code === 408)
97	) {
98	if (attempt === maxRetries + 1) {	90✔
99	throw new LokaliseError(	12✔
100	`Maximum retries reached: ${error instanceof Error ? error.message : "Unknown error"}`,	12!
101	error.code,
102	error.details,
103	);
104	}
105	await this.sleep(initialSleepTime * 2 ** (attempt - 1));	78✔
106	} else if (error instanceof LokaliseApiError) {	30✔
107	throw new LokaliseError(error.message, error.code, error.details);	24✔
108	} else {
109	throw error;	6✔
110	}
111	}
112	}
113
UNCOV 114	throw new LokaliseError("Unexpected error", 500);	×
115	}
116
117	/**
118	* Pauses execution for the specified number of milliseconds.
119	*
120	* @param ms - The time to sleep in milliseconds.
121	* @returns A promise that resolves after the specified time.
122	* @internal This is a utility method used for retrying failed requests.
123	*/
124	protected sleep(ms: number): Promise<void> {
125	return new Promise((resolve) => setTimeout(resolve, ms));	12✔
126	}
127	}

bodrovis / lokalise-node-file-exchange / 12304255045

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous