@rabbitio/ui-kit 1.0.0-beta.64 → 1.0.0-beta.66

package/src/robustExteranlApiCallerService/cachedRobustExternalApiCallerService.js

@@ -34,11 +34,7 @@ export class CachedRobustExternalApiCallerService {
         maxCallAttemptsToWaitForAlreadyRunningRequest = 100,
         timeoutBetweenAttemptsToCheckWhetherAlreadyRunningRequestFinished = 1000
     ) {
-        this._provider = new RobustExternalAPICallerService(
-            `cached_${bio}`,
-            providersData,
-            Logger.logError
-        );
+        this._provider = new RobustExternalAPICallerService(`cached_${bio}`, providersData, Logger.logError);
         this._cacheTtlMs = cacheTtlMs;
         this._cahceAndRequestsResolver = new CacheAndConcurrentRequestsResolver(
             bio,
@@ -49,8 +45,7 @@ export class CachedRobustExternalApiCallerService {
             timeoutBetweenAttemptsToCheckWhetherAlreadyRunningRequestFinished
         );
         this._cahceIds = [];
-        this._mergeCachedAndNewlyRetrievedData =
-            mergeCachedAndNewlyRetrievedData;
+        this._mergeCachedAndNewlyRetrievedData = mergeCachedAndNewlyRetrievedData;
     }
 
     /**
@@ -79,14 +74,8 @@ export class CachedRobustExternalApiCallerService {
         let cacheId;
         let result;
         try {
-            cacheId = this._calculateCacheId(
-                parametersValues,
-                customHashFunctionForParams
-            );
-            result =
-                await this._cahceAndRequestsResolver.getCachedOrWaitForCachedOrAcquireLock(
-                    cacheId
-                );
+            cacheId = this._calculateCacheId(parametersValues, customHashFunctionForParams);
+            result = await this._cahceAndRequestsResolver.getCachedOrWaitForCachedOrAcquireLock(cacheId);
             if (!result?.canStartDataRetrieval) {
                 return result?.cachedData;
             }
@@ -99,27 +88,14 @@ export class CachedRobustExternalApiCallerService {
                 doNotFailForNowData
             );
 
-            const canPerformMerge =
-                typeof this._mergeCachedAndNewlyRetrievedData === "function";
+            const canPerformMerge = typeof this._mergeCachedAndNewlyRetrievedData === "function";
             if (canPerformMerge) {
-                const mostRecentCached =
-                    this._cahceAndRequestsResolver.getCached(cacheId);
-                data = this._mergeCachedAndNewlyRetrievedData(
-                    mostRecentCached,
-                    data,
-                    parametersValues
-                );
+                const mostRecentCached = this._cahceAndRequestsResolver.getCached(cacheId);
+                data = this._mergeCachedAndNewlyRetrievedData(mostRecentCached, data, parametersValues);
             }
             if (data != null) {
-                this._cahceAndRequestsResolver.saveCachedData(
-                    cacheId,
-                    result?.lockId,
-                    data,
-                    true,
-                    canPerformMerge
-                );
-                this._cahceIds.indexOf(cacheId) < 0 &&
-                    this._cahceIds.push(cacheId);
+                this._cahceAndRequestsResolver.saveCachedData(cacheId, result?.lockId, data, true, canPerformMerge);
+                this._cahceIds.indexOf(cacheId) < 0 && this._cahceIds.push(cacheId);
             }
 
             return data;
@@ -131,9 +107,7 @@ export class CachedRobustExternalApiCallerService {
     }
 
     invalidateCaches() {
-        this._cahceIds.forEach((key) =>
-            this._cahceAndRequestsResolver.invalidate(key)
-        );
+        this._cahceIds.forEach(key => this._cahceAndRequestsResolver.invalidate(key));
     }
 
     actualizeCachedData(
@@ -143,27 +117,14 @@ export class CachedRobustExternalApiCallerService {
         sessionDependent = true,
         actualizedAtTimestamp
     ) {
-        const cacheId = this._calculateCacheId(
-            params,
-            customHashFunctionForParams
-        );
-        this._cahceAndRequestsResolver.actualizeCachedData(
-            cacheId,
-            synchronousCurrentCacheProcessor,
-            sessionDependent
-        );
+        const cacheId = this._calculateCacheId(params, customHashFunctionForParams);
+        this._cahceAndRequestsResolver.actualizeCachedData(cacheId, synchronousCurrentCacheProcessor, sessionDependent);
     }
 
-    markCacheAsExpiredButDontRemove(
-        parametersValues,
-        customHashFunctionForParams
-    ) {
+    markCacheAsExpiredButDontRemove(parametersValues, customHashFunctionForParams) {
         try {
             this._cahceAndRequestsResolver.markAsExpiredButDontRemove(
-                this._calculateCacheId(
-                    parametersValues,
-                    customHashFunctionForParams
-                )
+                this._calculateCacheId(parametersValues, customHashFunctionForParams)
             );
         } catch (e) {
             improveAndRethrow(e, "markCacheAsExpiredButDontRemove");
@@ -177,9 +138,7 @@ export class CachedRobustExternalApiCallerService {
                     ? customHashFunctionForParams(parametersValues)
                     : !parametersValues
                       ? ""
-                      : new Hashes.SHA512().hex(
-                            safeStringify(parametersValues)
-                        );
+                      : new Hashes.SHA512().hex(safeStringify(parametersValues));
             return `${this._provider.bio}-${hash}`;
         } catch (e) {
             improveAndRethrow(e, this._provider.bio + "_calculateCacheId");

package/src/robustExteranlApiCallerService/concurrentCalculationsMetadataHolder.js

@@ -32,26 +32,14 @@ export class ConcurrentCalculationsMetadataHolder {
 
     endCalculation(domain, uuid, isFailed = false) {
         try {
-            const calculation = this._calculations[domain].find(
-                (calculation) => calculation?.uuid === uuid
-            );
+            const calculation = this._calculations[domain].find(calculation => calculation?.uuid === uuid);
             if (calculation) {
                 calculation.endTimestamp = Date.now();
                 calculation.isFiled = isFailed;
             }
 
-            const elapsed = (
-                ((calculation?.endTimestamp ?? 0) -
-                    (calculation?.startTimestamp ?? 0)) /
-                1000
-            ).toFixed(1);
-            Logger.log(
-                "endCalculation",
-                `${elapsed} ms: ${domain}.${(calculation?.uuid ?? "").slice(
-                    0,
-                    7
-                )}`
-            );
+            const elapsed = (((calculation?.endTimestamp ?? 0) - (calculation?.startTimestamp ?? 0)) / 1000).toFixed(1);
+            Logger.log("endCalculation", `${elapsed} ms: ${domain}.${(calculation?.uuid ?? "").slice(0, 7)}`);
 
             return calculation;
         } catch (e) {
@@ -61,43 +49,27 @@ export class ConcurrentCalculationsMetadataHolder {
 
     isCalculationLate(domain, uuid) {
         const queue = this._calculations[domain];
-        const analysingCalculation = queue.find((item) => item.uuid === uuid);
+        const analysingCalculation = queue.find(item => item.uuid === uuid);
         return (
             analysingCalculation &&
             !!queue.find(
-                (calculation) =>
-                    calculation.endTimestamp != null &&
-                    calculation.startTimestamp >
-                        analysingCalculation.startTimestamp
+                calculation =>
+                    calculation.endTimestamp != null && calculation.startTimestamp > analysingCalculation.startTimestamp
             )
         );
     }
 
     printCalculationsWaitingMoreThanSpecifiedSeconds(waitingLastsMs = 2000) {
         const calculations = Object.keys(this._calculations)
-            .map((domain) =>
-                this._calculations[domain].map((c) => ({ ...c, domain }))
-            )
+            .map(domain => this._calculations[domain].map(c => ({ ...c, domain })))
             .flat()
-            .filter(
-                (c) =>
-                    c.endTimestamp === null &&
-                    Date.now() - c.startTimestamp > waitingLastsMs
-            );
+            .filter(c => c.endTimestamp === null && Date.now() - c.startTimestamp > waitingLastsMs);
         Logger.log(
             "printCalculationsWaitingMoreThanSpecifiedSeconds",
-            `Calculations waiting more than ${(waitingLastsMs / 1000).toFixed(
-                1
-            )}s:\n` +
-                calculations.map(
-                    (c) =>
-                        `${c.domain}.${c.uuid.slice(0, 8)}: ${
-                            Date.now() - c.startTimestamp
-                        }\n`
-                )
+            `Calculations waiting more than ${(waitingLastsMs / 1000).toFixed(1)}s:\n` +
+                calculations.map(c => `${c.domain}.${c.uuid.slice(0, 8)}: ${Date.now() - c.startTimestamp}\n`)
         );
     }
 }
 
-export const concurrentCalculationsMetadataHolder =
-    new ConcurrentCalculationsMetadataHolder();
+export const concurrentCalculationsMetadataHolder = new ConcurrentCalculationsMetadataHolder();

package/src/robustExteranlApiCallerService/externalServicesStatsCollector.js

@@ -14,8 +14,7 @@ export class ExternalServicesStatsCollector {
                 if (errorMessage.match(/.*network.+error.*/i)) {
                     errors["networkError"] = (errors["networkError"] || 0) + 1;
                 } else if (errorMessage.match(/.*timeout.+exceeded.*/i)) {
-                    errors["timeoutExceeded"] =
-                        (errors["timeoutExceeded"] || 0) + 1;
+                    errors["timeoutExceeded"] = (errors["timeoutExceeded"] || 0) + 1;
                 } else if (errors["other"]) {
                     errors["other"].push(message);
                 } else {
@@ -62,14 +61,11 @@ export class ExternalServicesStatsCollector {
     getStats() {
         try {
             return Array.from(this.stats.keys())
-                .map((key) => {
+                .map(key => {
                     const stat = this.stats.get(key);
                     return {
                         url: key,
-                        failsPerCent: (
-                            (stat.failsCount / stat.callsCount) *
-                            100
-                        ).toFixed(2),
+                        failsPerCent: ((stat.failsCount / stat.callsCount) * 100).toFixed(2),
                         calls: stat.callsCount,
                         errors: stat.errors ?? [],
                     };

package/src/robustExteranlApiCallerService/robustExternalAPICallerService.js

@@ -28,23 +28,16 @@ export class RobustExternalAPICallerService {
      * @param [logger] {function} function to be used for logging
      */
     constructor(bio, providersData, logger = Logger.logError) {
-        providersData.forEach((provider) => {
-            if (
-                (!provider.endpoint && provider.endpoint !== "") ||
-                !provider.httpMethod
-            ) {
-                throw new Error(
-                    `Wrong format of providers data for: ${JSON.stringify(
-                        provider
-                    )}`
-                );
+        providersData.forEach(provider => {
+            if ((!provider.endpoint && provider.endpoint !== "") || !provider.httpMethod) {
+                throw new Error(`Wrong format of providers data for: ${JSON.stringify(provider)}`);
             }
         });
 
         // We add niceFactor - just number to order the providers array by. It is helpful to call
         // less robust APIs only if more robust fails
         this.providers = providersData;
-        providersData.forEach((provider) => provider.resetNiceFactor());
+        providersData.forEach(provider => provider.resetNiceFactor());
         this.bio = bio;
         this._logger = (...args) => {
             Logger.logError(...args);
@@ -74,24 +67,16 @@ export class RobustExternalAPICallerService {
         doNotFailForNowData = false
     ) {
         let result;
-        const calculationUuid =
-            concurrentCalculationsMetadataHolder.startCalculation(this.bio);
+        const calculationUuid = concurrentCalculationsMetadataHolder.startCalculation(this.bio);
 
         try {
-            for (
-                let i = 0;
-                (i < attemptsCount || result?.shouldBeForceRetried) &&
-                result?.data == null;
-                ++i
-            ) {
+            for (let i = 0; (i < attemptsCount || result?.shouldBeForceRetried) && result?.data == null; ++i) {
                 /**
                  * We use rpsFactor to improve re-attempting to call the providers if the last attempt resulted with
                  * the fail due to abused RPSes of some (most part of) providers.
                  * The _performCallAttempt in such a case will return increased rpsFactor inside the result object.
                  */
-                const rpsFactor = result
-                    ? result.rpsFactor
-                    : RobustExternalAPICallerService.defaultRPSFactor;
+                const rpsFactor = result ? result.rpsFactor : RobustExternalAPICallerService.defaultRPSFactor;
 
                 result = null;
 
@@ -105,14 +90,8 @@ export class RobustExternalAPICallerService {
                             doNotFailForNowData
                         );
                     } else {
-                        const maxRps = Math.max(
-                            ...this.providers.map(
-                                (provider) => provider.getRps() ?? 0
-                            )
-                        );
-                        const waitingTimeMs = maxRps
-                            ? 1000 / (maxRps / rpsFactor)
-                            : 0;
+                        const maxRps = Math.max(...this.providers.map(provider => provider.getRps() ?? 0));
+                        const waitingTimeMs = maxRps ? 1000 / (maxRps / rpsFactor) : 0;
 
                         result = await new Promise((resolve, reject) => {
                             setTimeout(async () => {
@@ -136,10 +115,8 @@ export class RobustExternalAPICallerService {
                         const errors = result.errors;
                         this._logger(
                             new Error(
-                                `Failed at attempt ${i}. ${
-                                    errors.length
-                                } errors. Messages: ${safeStringify(
-                                    errors.map((error) => error.message)
+                                `Failed at attempt ${i}. ${errors.length} errors. Messages: ${safeStringify(
+                                    errors.map(error => error.message)
                                 )}: ${safeStringify(errors)}.`
                             ),
                             `${this.bio}.callExternalAPI`,
@@ -148,11 +125,7 @@ export class RobustExternalAPICallerService {
                         );
                     }
                 } catch (e) {
-                    this._logger(
-                        e,
-                        `${this.bio}.callExternalAPI`,
-                        "Failed to perform external providers calling"
-                    );
+                    this._logger(e, `${this.bio}.callExternalAPI`, "Failed to perform external providers calling");
                 }
             }
 
@@ -172,20 +145,11 @@ export class RobustExternalAPICallerService {
         } catch (e) {
             improveAndRethrow(e, `${this.bio}.callExternalAPI`);
         } finally {
-            concurrentCalculationsMetadataHolder.endCalculation(
-                this.bio,
-                calculationUuid
-            );
+            concurrentCalculationsMetadataHolder.endCalculation(this.bio, calculationUuid);
         }
     }
 
-    async _performCallAttempt(
-        parametersValues,
-        timeoutMS,
-        cancelToken,
-        rpsFactor,
-        doNotFailForNowData
-    ) {
+    async _performCallAttempt(parametersValues, timeoutMS, cancelToken, rpsFactor, doNotFailForNowData) {
         const providers = this._reorderProvidersByNiceFactor();
         let data = undefined,
             providerIndex = 0,
@@ -209,31 +173,14 @@ export class RobustExternalAPICallerService {
                     timeout: provider.timeout || timeoutMS,
                     headers: provider.specificHeaders ?? {},
                 };
-                const httpMethods = Array.isArray(provider.httpMethod)
-                    ? provider.httpMethod
-                    : [provider.httpMethod];
+                const httpMethods = Array.isArray(provider.httpMethod) ? provider.httpMethod : [provider.httpMethod];
                 const iterationsData = [];
-                for (
-                    let subRequestIndex = 0;
-                    subRequestIndex < httpMethods.length;
-                    ++subRequestIndex
-                ) {
-                    const query = provider.composeQueryString(
-                        parametersValues,
-                        subRequestIndex
-                    );
+                for (let subRequestIndex = 0; subRequestIndex < httpMethods.length; ++subRequestIndex) {
+                    const query = provider.composeQueryString(parametersValues, subRequestIndex);
                     const endpoint = `${provider.endpoint}${query}`;
                     const axiosParams = [endpoint, axiosConfig];
-                    if (
-                        ["post", "put", "patch"].find(
-                            (method) => method === httpMethods[subRequestIndex]
-                        )
-                    ) {
-                        const body =
-                            provider.composeBody(
-                                parametersValues,
-                                subRequestIndex
-                            ) ?? null;
+                    if (["post", "put", "patch"].find(method => method === httpMethods[subRequestIndex])) {
+                        const body = provider.composeBody(parametersValues, subRequestIndex) ?? null;
                         axiosParams.splice(1, 0, body);
                     }
 
@@ -243,27 +190,22 @@ export class RobustExternalAPICallerService {
                     do {
                         if (subRequestIndex === 0 && pageNumber === 0) {
                             provider.actualizeLastCalledTimestamp();
-                            responsesForPages[pageNumber] =
-                                await AxiosAdapter.call(
-                                    httpMethods[subRequestIndex],
-                                    ...axiosParams
-                                );
+                            responsesForPages[pageNumber] = await AxiosAdapter.call(
+                                httpMethods[subRequestIndex],
+                                ...axiosParams
+                            );
                             RobustExternalAPICallerService.statsCollector.externalServiceCalledWithoutError(
                                 provider.getApiGroupId()
                             );
                         } else {
                             if (pageNumber > 0) {
-                                const actualizedParams =
-                                    provider.changeQueryParametersForPageNumber(
-                                        parametersValues,
-                                        responsesForPages[pageNumber - 1],
-                                        pageNumber,
-                                        subRequestIndex
-                                    );
-                                const query = provider.composeQueryString(
-                                    actualizedParams,
+                                const actualizedParams = provider.changeQueryParametersForPageNumber(
+                                    parametersValues,
+                                    responsesForPages[pageNumber - 1],
+                                    pageNumber,
                                     subRequestIndex
                                 );
+                                const query = provider.composeQueryString(actualizedParams, subRequestIndex);
                                 axiosParams[0] = `${provider.endpoint}${query}`;
                             }
                             /**
@@ -273,56 +215,35 @@ export class RobustExternalAPICallerService {
                              * TODO: [dev] test RPS factor logic (units or integration)
                              */
 
-                            const waitingTimeMS = provider.getRps()
-                                ? 1000 / (provider.getRps() / rpsFactor)
-                                : 0;
+                            const waitingTimeMS = provider.getRps() ? 1000 / (provider.getRps() / rpsFactor) : 0;
 
-                            const postponeUntilRpsExceeded = async (
-                                recursionLevel = 0
-                            ) => {
+                            const postponeUntilRpsExceeded = async (recursionLevel = 0) => {
                                 return await postponeExecution(async () => {
                                     const maxCountOfPostponingAttempts = 2;
-                                    if (
-                                        provider.isRpsExceeded() &&
-                                        recursionLevel <
-                                            maxCountOfPostponingAttempts
-                                    ) {
-                                        return await postponeUntilRpsExceeded(
-                                            recursionLevel + 1
-                                        );
+                                    if (provider.isRpsExceeded() && recursionLevel < maxCountOfPostponingAttempts) {
+                                        return await postponeUntilRpsExceeded(recursionLevel + 1);
                                     }
                                     provider.actualizeLastCalledTimestamp();
-                                    return await AxiosAdapter.call(
-                                        httpMethods[subRequestIndex],
-                                        ...axiosParams
-                                    );
+                                    return await AxiosAdapter.call(httpMethods[subRequestIndex], ...axiosParams);
                                 }, waitingTimeMS);
                             };
 
-                            responsesForPages[pageNumber] =
-                                await postponeUntilRpsExceeded();
+                            responsesForPages[pageNumber] = await postponeUntilRpsExceeded();
                         }
 
                         if (hasNextPage) {
-                            hasNextPage =
-                                !provider.checkWhetherResponseIsForLastPage(
-                                    responsesForPages[pageNumber - 1],
-                                    responsesForPages[pageNumber],
-                                    pageNumber,
-                                    subRequestIndex
-                                );
+                            hasNextPage = !provider.checkWhetherResponseIsForLastPage(
+                                responsesForPages[pageNumber - 1],
+                                responsesForPages[pageNumber],
+                                pageNumber,
+                                subRequestIndex
+                            );
                         }
                         pageNumber++;
                     } while (hasNextPage);
 
-                    const responsesDataForPages = responsesForPages.map(
-                        (response) =>
-                            provider.getDataByResponse(
-                                response,
-                                parametersValues,
-                                subRequestIndex,
-                                iterationsData
-                            )
+                    const responsesDataForPages = responsesForPages.map(response =>
+                        provider.getDataByResponse(response, parametersValues, subRequestIndex, iterationsData)
                     );
 
                     let allData = responsesDataForPages;
@@ -336,8 +257,7 @@ export class RobustExternalAPICallerService {
                 }
                 if (iterationsData.length) {
                     if (httpMethods.length > 1) {
-                        data =
-                            provider.incorporateIterationsData(iterationsData);
+                        data = provider.incorporateIterationsData(iterationsData);
                     } else {
                         data = iterationsData[0];
                     }
@@ -361,12 +281,8 @@ export class RobustExternalAPICallerService {
         }
 
         // If we are declining more than 50% of providers (by exceeding RPS) then we note that it better to retry the whole process of providers requesting
-        const shouldBeForceRetried =
-            data == null &&
-            countOfRequestsDeclinedByRps > Math.floor(providers.length * 0.5);
-        const rpsMultiplier = shouldBeForceRetried
-            ? RobustExternalAPICallerService.rpsMultiplier
-            : 1;
+        const shouldBeForceRetried = data == null && countOfRequestsDeclinedByRps > Math.floor(providers.length * 0.5);
+        const rpsMultiplier = shouldBeForceRetried ? RobustExternalAPICallerService.rpsMultiplier : 1;
 
         return {
             data: data ?? null,