@webiny/api-sync-to-opensearch 0.0.0-unstable.0d717d18dd

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NotEnoughRemainingTimeError.d.ts

@@ -0,0 +1,3 @@
+import { WebinyError } from "@webiny/error";
+export declare class NotEnoughRemainingTimeError extends WebinyError {
+}

package/NotEnoughRemainingTimeError.js

@@ -0,0 +1,6 @@
+import { WebinyError } from "@webiny/error";
+class NotEnoughRemainingTimeError extends WebinyError {
+}
+export { NotEnoughRemainingTimeError };
+
+//# sourceMappingURL=NotEnoughRemainingTimeError.js.map

package/NotEnoughRemainingTimeError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotEnoughRemainingTimeError.js","sources":["../src/NotEnoughRemainingTimeError.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\n\nexport class NotEnoughRemainingTimeError extends WebinyError {}\n"],"names":["NotEnoughRemainingTimeError","WebinyError"],"mappings":";AAEO,MAAMA,oCAAoCC;AAAa"}

package/README.md

@@ -0,0 +1,11 @@
+# @webiny/api-sync-to-opensearch
+
+> [!NOTE]
+> This package is part of the [Webiny](https://www.webiny.com) monorepo.
+> It’s **included in every Webiny project by default** and is not meant to be used as a standalone package.
+
+📘 **Documentation:** [https://www.webiny.com/docs](https://www.webiny.com/docs)
+
+---
+
+_This README file is automatically generated during the publish process._

package/features/ExecuteSync/ExecuteSync.d.ts

@@ -0,0 +1,16 @@
+import { ExecuteSync as ExecuteSyncAbstraction } from "./abstraction.js";
+import { Env } from "@webiny/stdlib";
+import { Timer } from "@webiny/utils/features/Timer/abstraction.js";
+import { OpenSearchClient } from "@webiny/api-opensearch/exports/api/opensearch.js";
+declare class ExecuteSyncImpl implements ExecuteSyncAbstraction.Interface {
+    private readonly env;
+    private readonly timer;
+    private readonly openSearchClient;
+    constructor(env: Env.Interface, timer: Timer.Interface, openSearchClient: OpenSearchClient.Interface);
+    execute(params: ExecuteSyncAbstraction.Params): Promise<void>;
+    private shouldShowLogs;
+}
+export declare const ExecuteSync: typeof ExecuteSyncImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstraction.js").IExecuteSync>;
+};
+export {};

package/features/ExecuteSync/ExecuteSync.js

@@ -0,0 +1,103 @@
+import { OpenSearchCatClusterHealthStatus, UnhealthyClusterError, WaitingHealthyClusterAbortedError, createWaitUntilHealthy } from "@webiny/api-opensearch";
+import { WebinyError } from "@webiny/error";
+import { ExecuteSync } from "./abstraction.js";
+import { Env } from "@webiny/stdlib";
+import { Timer } from "@webiny/utils/features/Timer/abstraction.js";
+import { OpenSearchClient } from "@webiny/api-opensearch/exports/api/opensearch.js";
+const getError = (item)=>{
+    if (!item.index?.error?.reason) return null;
+    const reason = item.index.error.reason;
+    if (null !== reason.match(/no such index \[([a-zA-Z0-9_-]+)\]/)) return "index";
+    return reason;
+};
+const checkErrors = (result)=>{
+    if (!result || !result.body || !result.body.items) return;
+    for (const item of result.body.items){
+        const err = getError(item);
+        if (err) {
+            if ("index" === err) {
+                if ("true" === process.env.DEBUG) console.error("Bulk response", JSON.stringify(result, null, 2));
+                continue;
+            }
+            console.error("Body item with error", item);
+            throw new WebinyError(err, "TO_OPENSEARCH_ERROR", item);
+        }
+    }
+};
+class ExecuteSyncImpl {
+    constructor(env, timer, openSearchClient){
+        this.env = env;
+        this.timer = timer;
+        this.openSearchClient = openSearchClient;
+    }
+    async execute(params) {
+        const { maxProcessorPercent, maxRunningTime, operations } = params;
+        if (0 === operations.total) return;
+        const remainingTime = this.timer.getRemainingSeconds();
+        const runningTime = maxRunningTime - remainingTime;
+        const maxWaitingTime = remainingTime - 90;
+        if (this.shouldShowLogs()) console.debug(`The Lambda is already running for ${runningTime}s. Setting Health Check max waiting time: ${maxWaitingTime}s`);
+        const healthCheck = createWaitUntilHealthy(this.openSearchClient.use(), {
+            minClusterHealthStatus: OpenSearchCatClusterHealthStatus.Yellow,
+            waitingTimeStep: 30,
+            maxProcessorPercent,
+            maxWaitingTime
+        });
+        try {
+            await healthCheck.wait({
+                async onUnhealthy ({ startedAt, runs, mustEndAt, waitingTimeStep, waitingReason }) {
+                    console.debug(`Cluster is unhealthy on run #${runs}.`, {
+                        startedAt,
+                        mustEndAt,
+                        waitingTimeStep,
+                        waitingReason
+                    });
+                },
+                async onTimeout ({ startedAt, runs, waitingTimeStep, mustEndAt, waitingReason }) {
+                    console.error(`Cluster health check timeout on run #${runs}.`, {
+                        startedAt,
+                        mustEndAt,
+                        waitingTimeStep,
+                        waitingReason
+                    });
+                }
+            });
+        } catch (ex) {
+            if (ex instanceof UnhealthyClusterError || ex instanceof WaitingHealthyClusterAbortedError) throw ex;
+            console.error("Cluster health check failed.", ex);
+            throw ex;
+        }
+        try {
+            const res = await this.openSearchClient.use().bulk({
+                body: operations.items
+            });
+            checkErrors(res);
+        } catch (error) {
+            console.error(error, {
+                tenant: "root"
+            });
+            if (this.shouldShowLogs()) {
+                const meta = error?.meta || {};
+                delete meta["meta"];
+                console.error("Bulk error", JSON.stringify(error, null, 2));
+            }
+            throw error;
+        }
+        if (this.shouldShowLogs()) console.info(`Transferred ${operations.total} record operations to OpenSearch.`);
+    }
+    shouldShowLogs() {
+        if (this.env.getBoolean("TESTING")) return false;
+        return this.env.getBoolean("DEBUG", false);
+    }
+}
+const ExecuteSync_ExecuteSync = ExecuteSync.createImplementation({
+    implementation: ExecuteSyncImpl,
+    dependencies: [
+        Env,
+        Timer,
+        OpenSearchClient
+    ]
+});
+export { ExecuteSync_ExecuteSync as ExecuteSync };
+
+//# sourceMappingURL=ExecuteSync.js.map

package/features/ExecuteSync/ExecuteSync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ExecuteSync/ExecuteSync.js","sources":["../../../src/features/ExecuteSync/ExecuteSync.ts"],"sourcesContent":["import {\n    createWaitUntilHealthy,\n    OpenSearchCatClusterHealthStatus,\n    UnhealthyClusterError,\n    WaitingHealthyClusterAbortedError\n} from \"@webiny/api-opensearch\";\nimport type { ApiResponse } from \"@webiny/api-opensearch/types.js\";\nimport { WebinyError } from \"@webiny/error\";\nimport { ExecuteSync as ExecuteSyncAbstraction } from \"./abstraction.js\";\nimport { Env } from \"@webiny/stdlib\";\nimport { Timer } from \"@webiny/utils/features/Timer/abstraction.js\";\nimport { OpenSearchClient } from \"@webiny/api-opensearch/exports/api/opensearch.js\";\n\ninterface BulkOperationsResponseBodyItemIndexError {\n    reason?: string;\n}\n\ninterface BulkOperationsResponseBodyItemIndex {\n    error?: BulkOperationsResponseBodyItemIndexError;\n}\n\ninterface BulkOperationsResponseBodyItem {\n    index?: BulkOperationsResponseBodyItemIndex;\n    error?: string;\n}\n\nconst getError = (item: BulkOperationsResponseBodyItem): string | null => {\n    if (!item.index?.error?.reason) {\n        return null;\n    }\n    const reason = item.index.error.reason;\n    if (reason.match(/no such index \\[([a-zA-Z0-9_-]+)\\]/) !== null) {\n        return \"index\";\n    }\n    return reason;\n};\n\nconst checkErrors = (result?: ApiResponse): void => {\n    if (!result || !result.body || !result.body.items) {\n        return;\n    }\n    for (const item of result.body.items) {\n        const err = getError(item);\n        if (!err) {\n            continue;\n        } else if (err === \"index\") {\n            if (process.env.DEBUG === \"true\") {\n                console.error(\"Bulk response\", JSON.stringify(result, null, 2));\n            }\n            continue;\n        }\n        console.error(\"Body item with error\", item);\n        throw new WebinyError(err, \"TO_OPENSEARCH_ERROR\", item);\n    }\n};\n\nclass ExecuteSyncImpl implements ExecuteSyncAbstraction.Interface {\n    public constructor(\n        private readonly env: Env.Interface,\n        private readonly timer: Timer.Interface,\n        private readonly openSearchClient: OpenSearchClient.Interface\n    ) {}\n\n    public async execute(params: ExecuteSyncAbstraction.Params): Promise<void> {\n        const { maxProcessorPercent, maxRunningTime, operations } = params;\n\n        if (operations.total === 0) {\n            return;\n        }\n\n        const remainingTime = this.timer.getRemainingSeconds();\n        const runningTime = maxRunningTime - remainingTime;\n        const maxWaitingTime = remainingTime - 90;\n\n        if (this.shouldShowLogs()) {\n            console.debug(\n                `The Lambda is already running for ${runningTime}s. Setting Health Check max waiting time: ${maxWaitingTime}s`\n            );\n        }\n\n        const healthCheck = createWaitUntilHealthy(this.openSearchClient.use(), {\n            minClusterHealthStatus: OpenSearchCatClusterHealthStatus.Yellow,\n            waitingTimeStep: 30,\n            maxProcessorPercent,\n            maxWaitingTime\n        });\n\n        try {\n            await healthCheck.wait({\n                async onUnhealthy({ startedAt, runs, mustEndAt, waitingTimeStep, waitingReason }) {\n                    console.debug(`Cluster is unhealthy on run #${runs}.`, {\n                        startedAt,\n                        mustEndAt,\n                        waitingTimeStep,\n                        waitingReason\n                    });\n                },\n                async onTimeout({ startedAt, runs, waitingTimeStep, mustEndAt, waitingReason }) {\n                    console.error(`Cluster health check timeout on run #${runs}.`, {\n                        startedAt,\n                        mustEndAt,\n                        waitingTimeStep,\n                        waitingReason\n                    });\n                }\n            });\n        } catch (ex) {\n            if (\n                ex instanceof UnhealthyClusterError ||\n                ex instanceof WaitingHealthyClusterAbortedError\n            ) {\n                throw ex;\n            }\n            console.error(`Cluster health check failed.`, ex);\n            throw ex;\n        }\n\n        try {\n            const res = await this.openSearchClient.use().bulk({\n                body: operations.items\n            });\n            checkErrors(res);\n        } catch (error) {\n            console.error(error, { tenant: \"root\" });\n\n            if (this.shouldShowLogs()) {\n                const meta = error?.meta || {};\n                delete meta[\"meta\"];\n                console.error(\"Bulk error\", JSON.stringify(error, null, 2));\n            }\n            throw error;\n        }\n        if (this.shouldShowLogs()) {\n            console.info(`Transferred ${operations.total} record operations to OpenSearch.`);\n        }\n    }\n\n    private shouldShowLogs(): boolean {\n        /**\n         * Don't show logs during tests, really no point.\n         */\n        if (this.env.getBoolean(\"TESTING\")) {\n            return false;\n        }\n        return this.env.getBoolean(\"DEBUG\", false);\n    }\n}\n\nexport const ExecuteSync = ExecuteSyncAbstraction.createImplementation({\n    implementation: ExecuteSyncImpl,\n    dependencies: [Env, Timer, OpenSearchClient]\n});\n"],"names":["getError","item","reason","checkErrors","result","err","process","console","JSON","WebinyError","ExecuteSyncImpl","env","timer","openSearchClient","params","maxProcessorPercent","maxRunningTime","operations","remainingTime","runningTime","maxWaitingTime","healthCheck","createWaitUntilHealthy","OpenSearchCatClusterHealthStatus","startedAt","runs","mustEndAt","waitingTimeStep","waitingReason","ex","UnhealthyClusterError","WaitingHealthyClusterAbortedError","res","error","meta","ExecuteSync","ExecuteSyncAbstraction","Env","Timer","OpenSearchClient"],"mappings":"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"}

package/features/ExecuteSync/abstraction.d.ts

@@ -0,0 +1,14 @@
+import type { Operations } from "../Operations/abstractions/Operations.js";
+export interface IExecuteSyncParams {
+    maxRunningTime: number;
+    maxProcessorPercent: number;
+    operations: Pick<Operations.Interface, "items" | "total">;
+}
+export interface IExecuteSync {
+    execute(params: IExecuteSyncParams): Promise<void>;
+}
+export declare const ExecuteSync: import("@webiny/di").Abstraction<IExecuteSync>;
+export declare namespace ExecuteSync {
+    type Interface = IExecuteSync;
+    type Params = IExecuteSyncParams;
+}

package/features/ExecuteSync/abstraction.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const ExecuteSync = createAbstraction("Sync/ExecuteSync");
+export { ExecuteSync };
+
+//# sourceMappingURL=abstraction.js.map

package/features/ExecuteSync/abstraction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ExecuteSync/abstraction.js","sources":["../../../src/features/ExecuteSync/abstraction.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Operations } from \"../Operations/abstractions/Operations.js\";\n\nexport interface IExecuteSyncParams {\n    maxRunningTime: number;\n    maxProcessorPercent: number;\n    operations: Pick<Operations.Interface, \"items\" | \"total\">;\n}\n\nexport interface IExecuteSync {\n    execute(params: IExecuteSyncParams): Promise<void>;\n}\n\nexport const ExecuteSync = createAbstraction<IExecuteSync>(\"Sync/ExecuteSync\");\n\nexport namespace ExecuteSync {\n    export type Interface = IExecuteSync;\n    export type Params = IExecuteSyncParams;\n}\n"],"names":["ExecuteSync","createAbstraction"],"mappings":";AAaO,MAAMA,cAAcC,kBAAgC"}

package/features/ExecuteSync/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const ExecuteSyncFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/ExecuteSync/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { ExecuteSync } from "./ExecuteSync.js";
+const ExecuteSyncFeature = createFeature({
+    name: "sync.executeSync",
+    register (container) {
+        container.register(ExecuteSync);
+    }
+});
+export { ExecuteSyncFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/ExecuteSync/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ExecuteSync/feature.js","sources":["../../../src/features/ExecuteSync/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ExecuteSync } from \"./ExecuteSync.js\";\n\nexport const ExecuteSyncFeature = createFeature({\n    name: \"sync.executeSync\",\n    register(container) {\n        container.register(ExecuteSync);\n    }\n});\n"],"names":["ExecuteSyncFeature","createFeature","container","ExecuteSync"],"mappings":";;AAGO,MAAMA,qBAAqBC,cAAc;IAC5C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/features/ExecuteSyncWithRetry/ExecuteSyncWithRetry.d.ts

@@ -0,0 +1,15 @@
+import { ExecuteSync } from "../ExecuteSync/abstraction.js";
+import { ExecuteSyncWithRetry as ExecuteSyncWithRetryAbstraction } from "./abstraction.js";
+import { Env } from "@webiny/stdlib";
+import { Timer } from "@webiny/utils/features/Timer/abstraction.js";
+declare class ExecuteSyncWithRetryImpl implements ExecuteSyncWithRetryAbstraction.Interface {
+    private readonly timer;
+    private readonly executeSync;
+    private readonly env;
+    constructor(timer: Timer.Interface, executeSync: ExecuteSync.Interface, env: Env.Interface);
+    execute(params: ExecuteSyncWithRetryAbstraction.Params): Promise<void>;
+}
+export declare const ExecuteSyncWithRetry: typeof ExecuteSyncWithRetryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstraction.js").IExecuteSyncWithRetry>;
+};
+export {};

package/features/ExecuteSyncWithRetry/ExecuteSyncWithRetry.js

@@ -0,0 +1,54 @@
+import p_retry from "p-retry";
+import { ExecuteSync } from "../ExecuteSync/abstraction.js";
+import { NotEnoughRemainingTimeError } from "../../NotEnoughRemainingTimeError.js";
+import { ExecuteSyncWithRetry } from "./abstraction.js";
+import { Env } from "@webiny/stdlib";
+import { Timer } from "@webiny/utils/features/Timer/abstraction.js";
+const minRemainingSecondsToTimeout = 120;
+class ExecuteSyncWithRetryImpl {
+    constructor(timer, executeSync, env){
+        this.timer = timer;
+        this.executeSync = executeSync;
+        this.env = env;
+    }
+    async execute(params) {
+        const maxProcessorPercent = this.env.getNumber("MAX_ES_PROCESSOR", "test" === process.env.NODE_ENV ? 101 : 98);
+        const maxRetryTime = this.env.getNumber("WEBINY_TO_OPENSEARCH_MAX_RETRY_TIME", params.maxRetryTime || 300000);
+        const retries = this.env.getNumber("WEBINY_TO_OPENSEARCH_RETRIES", params.retries || 20);
+        const minTimeout = this.env.getNumber("WEBINY_TO_OPENSEARCH_MIN_TIMEOUT", params.minTimeout || 1500);
+        const maxTimeout = this.env.getNumber("WEBINY_TO_OPENSEARCH_MAX_TIMEOUT", params.maxTimeout || 30000);
+        try {
+            await p_retry(async ()=>{
+                await this.executeSync.execute({
+                    maxRunningTime: params.maxRunningTime,
+                    maxProcessorPercent: params.maxProcessorPercent || maxProcessorPercent,
+                    operations: params.operations
+                });
+            }, {
+                maxRetryTime,
+                retries,
+                minTimeout,
+                maxTimeout,
+                onFailedAttempt: ({ error, attemptNumber })=>{
+                    if (this.timer.getRemainingSeconds() < minRemainingSecondsToTimeout) throw new NotEnoughRemainingTimeError(error);
+                    if (attemptNumber < 0.75 * retries) return;
+                    console.error(`Attempt #${attemptNumber} failed.`);
+                    console.error(error);
+                }
+            });
+        } catch (ex) {
+            throw ex;
+        }
+    }
+}
+const ExecuteSyncWithRetry_ExecuteSyncWithRetry = ExecuteSyncWithRetry.createImplementation({
+    implementation: ExecuteSyncWithRetryImpl,
+    dependencies: [
+        Timer,
+        ExecuteSync,
+        Env
+    ]
+});
+export { ExecuteSyncWithRetry_ExecuteSyncWithRetry as ExecuteSyncWithRetry };
+
+//# sourceMappingURL=ExecuteSyncWithRetry.js.map

package/features/ExecuteSyncWithRetry/ExecuteSyncWithRetry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ExecuteSyncWithRetry/ExecuteSyncWithRetry.js","sources":["../../../src/features/ExecuteSyncWithRetry/ExecuteSyncWithRetry.ts"],"sourcesContent":["import pRetry from \"p-retry\";\nimport { ExecuteSync } from \"../ExecuteSync/abstraction.js\";\nimport { NotEnoughRemainingTimeError } from \"~/NotEnoughRemainingTimeError.js\";\nimport { ExecuteSyncWithRetry as ExecuteSyncWithRetryAbstraction } from \"./abstraction.js\";\nimport { Env } from \"@webiny/stdlib\";\nimport { Timer } from \"@webiny/utils/features/Timer/abstraction.js\";\n\nconst minRemainingSecondsToTimeout = 120;\n\nclass ExecuteSyncWithRetryImpl implements ExecuteSyncWithRetryAbstraction.Interface {\n    public constructor(\n        private readonly timer: Timer.Interface,\n        private readonly executeSync: ExecuteSync.Interface,\n        private readonly env: Env.Interface\n    ) {}\n\n    public async execute(params: ExecuteSyncWithRetryAbstraction.Params): Promise<void> {\n        const maxProcessorPercent = this.env.getNumber(\n            \"MAX_ES_PROCESSOR\",\n            process.env.NODE_ENV === \"test\" ? 101 : 98\n        );\n\n        const maxRetryTime = this.env.getNumber(\n            \"WEBINY_TO_OPENSEARCH_MAX_RETRY_TIME\",\n            params.maxRetryTime || 300000\n        );\n        const retries = this.env.getNumber(\"WEBINY_TO_OPENSEARCH_RETRIES\", params.retries || 20);\n        const minTimeout = this.env.getNumber(\n            \"WEBINY_TO_OPENSEARCH_MIN_TIMEOUT\",\n            params.minTimeout || 1500\n        );\n        const maxTimeout = this.env.getNumber(\n            \"WEBINY_TO_OPENSEARCH_MAX_TIMEOUT\",\n            params.maxTimeout || 30000\n        );\n\n        try {\n            await pRetry(\n                async () => {\n                    await this.executeSync.execute({\n                        maxRunningTime: params.maxRunningTime,\n                        maxProcessorPercent: params.maxProcessorPercent || maxProcessorPercent,\n                        operations: params.operations\n                    });\n                },\n                {\n                    maxRetryTime,\n                    retries,\n                    minTimeout,\n                    maxTimeout,\n                    onFailedAttempt: ({ error, attemptNumber }) => {\n                        if (this.timer.getRemainingSeconds() < minRemainingSecondsToTimeout) {\n                            throw new NotEnoughRemainingTimeError(error);\n                        }\n                        if (attemptNumber < retries * 0.75) {\n                            return;\n                        }\n                        console.error(`Attempt #${attemptNumber} failed.`);\n                        console.error(error);\n                    }\n                }\n            );\n        } catch (ex) {\n            throw ex;\n        }\n    }\n}\n\nexport const ExecuteSyncWithRetry = ExecuteSyncWithRetryAbstraction.createImplementation({\n    implementation: ExecuteSyncWithRetryImpl,\n    dependencies: [Timer, ExecuteSync, Env]\n});\n"],"names":["minRemainingSecondsToTimeout","ExecuteSyncWithRetryImpl","timer","executeSync","env","params","maxProcessorPercent","process","maxRetryTime","retries","minTimeout","maxTimeout","pRetry","error","attemptNumber","NotEnoughRemainingTimeError","console","ex","ExecuteSyncWithRetry","ExecuteSyncWithRetryAbstraction","Timer","ExecuteSync","Env"],"mappings":";;;;;;AAOA,MAAMA,+BAA+B;AAErC,MAAMC;IACF,YACqBC,KAAsB,EACtBC,WAAkC,EAClCC,GAAkB,CACrC;aAHmBF,KAAK,GAALA;aACAC,WAAW,GAAXA;aACAC,GAAG,GAAHA;IAClB;IAEH,MAAa,QAAQC,MAA8C,EAAiB;QAChF,MAAMC,sBAAsB,IAAI,CAAC,GAAG,CAAC,SAAS,CAC1C,oBACAC,AAAyB,WAAzBA,QAAQ,GAAG,CAAC,QAAQ,GAAc,MAAM;QAG5C,MAAMC,eAAe,IAAI,CAAC,GAAG,CAAC,SAAS,CACnC,uCACAH,OAAO,YAAY,IAAI;QAE3B,MAAMI,UAAU,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,gCAAgCJ,OAAO,OAAO,IAAI;QACrF,MAAMK,aAAa,IAAI,CAAC,GAAG,CAAC,SAAS,CACjC,oCACAL,OAAO,UAAU,IAAI;QAEzB,MAAMM,aAAa,IAAI,CAAC,GAAG,CAAC,SAAS,CACjC,oCACAN,OAAO,UAAU,IAAI;QAGzB,IAAI;YACA,MAAMO,QACF;gBACI,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC;oBAC3B,gBAAgBP,OAAO,cAAc;oBACrC,qBAAqBA,OAAO,mBAAmB,IAAIC;oBACnD,YAAYD,OAAO,UAAU;gBACjC;YACJ,GACA;gBACIG;gBACAC;gBACAC;gBACAC;gBACA,iBAAiB,CAAC,EAAEE,KAAK,EAAEC,aAAa,EAAE;oBACtC,IAAI,IAAI,CAAC,KAAK,CAAC,mBAAmB,KAAKd,8BACnC,MAAM,IAAIe,4BAA4BF;oBAE1C,IAAIC,gBAAgBL,AAAU,OAAVA,SAChB;oBAEJO,QAAQ,KAAK,CAAC,CAAC,SAAS,EAAEF,cAAc,QAAQ,CAAC;oBACjDE,QAAQ,KAAK,CAACH;gBAClB;YACJ;QAER,EAAE,OAAOI,IAAI;YACT,MAAMA;QACV;IACJ;AACJ;AAEO,MAAMC,4CAAuBC,qBAAAA,oBAAoD,CAAC;IACrF,gBAAgBlB;IAChB,cAAc;QAACmB;QAAOC;QAAaC;KAAI;AAC3C"}

package/features/ExecuteSyncWithRetry/abstraction.d.ts

@@ -0,0 +1,16 @@
+import type { ExecuteSync } from "../ExecuteSync/abstraction.js";
+export interface IExecuteSyncWithRetryParams extends Omit<ExecuteSync.Params, "maxProcessorPercent"> {
+    maxRetryTime?: number;
+    retries?: number;
+    minTimeout?: number;
+    maxTimeout?: number;
+    maxProcessorPercent?: number;
+}
+export interface IExecuteSyncWithRetry {
+    execute(params: IExecuteSyncWithRetryParams): Promise<void>;
+}
+export declare const ExecuteSyncWithRetry: import("@webiny/di").Abstraction<IExecuteSyncWithRetry>;
+export declare namespace ExecuteSyncWithRetry {
+    type Interface = IExecuteSyncWithRetry;
+    type Params = IExecuteSyncWithRetryParams;
+}

package/features/ExecuteSyncWithRetry/abstraction.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const ExecuteSyncWithRetry = createAbstraction("Sync/ExecuteSyncWithRetry");
+export { ExecuteSyncWithRetry };
+
+//# sourceMappingURL=abstraction.js.map

package/features/ExecuteSyncWithRetry/abstraction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ExecuteSyncWithRetry/abstraction.js","sources":["../../../src/features/ExecuteSyncWithRetry/abstraction.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { ExecuteSync } from \"../ExecuteSync/abstraction.js\";\n\nexport interface IExecuteSyncWithRetryParams extends Omit<\n    ExecuteSync.Params,\n    \"maxProcessorPercent\"\n> {\n    maxRetryTime?: number;\n    retries?: number;\n    minTimeout?: number;\n    maxTimeout?: number;\n    maxProcessorPercent?: number;\n}\n\nexport interface IExecuteSyncWithRetry {\n    execute(params: IExecuteSyncWithRetryParams): Promise<void>;\n}\n\nexport const ExecuteSyncWithRetry = createAbstraction<IExecuteSyncWithRetry>(\n    \"Sync/ExecuteSyncWithRetry\"\n);\n\nexport namespace ExecuteSyncWithRetry {\n    export type Interface = IExecuteSyncWithRetry;\n    export type Params = IExecuteSyncWithRetryParams;\n}\n"],"names":["ExecuteSyncWithRetry","createAbstraction"],"mappings":";AAkBO,MAAMA,uBAAuBC,kBAChC"}

package/features/ExecuteSyncWithRetry/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const ExecuteSyncWithRetryFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/ExecuteSyncWithRetry/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { ExecuteSyncWithRetry } from "./ExecuteSyncWithRetry.js";
+const ExecuteSyncWithRetryFeature = createFeature({
+    name: "sync.executeSyncWithRetry",
+    register (container) {
+        container.register(ExecuteSyncWithRetry);
+    }
+});
+export { ExecuteSyncWithRetryFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/ExecuteSyncWithRetry/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ExecuteSyncWithRetry/feature.js","sources":["../../../src/features/ExecuteSyncWithRetry/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ExecuteSyncWithRetry } from \"./ExecuteSyncWithRetry.js\";\n\nexport const ExecuteSyncWithRetryFeature = createFeature({\n    name: \"sync.executeSyncWithRetry\",\n    register(container) {\n        container.register(ExecuteSyncWithRetry);\n    }\n});\n"],"names":["ExecuteSyncWithRetryFeature","createFeature","container","ExecuteSyncWithRetry"],"mappings":";;AAGO,MAAMA,8BAA8BC,cAAc;IACrD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/features/Operations/Operations.d.ts

@@ -0,0 +1,18 @@
+import type { GenericRecord } from "@webiny/api/types.js";
+import { Operations as OperationsAbstraction } from "./abstractions/Operations.js";
+export declare enum OperationType {
+    INSERT = "INSERT",
+    MODIFY = "MODIFY",
+    REMOVE = "REMOVE"
+}
+export declare class Operations implements OperationsAbstraction.Interface {
+    private _items;
+    private _count;
+    get items(): GenericRecord[];
+    get total(): number;
+    get count(): number;
+    clear(): void;
+    insert(params: OperationsAbstraction.InsertParams): void;
+    modify(params: OperationsAbstraction.ModifyParams): void;
+    delete(params: OperationsAbstraction.DeleteParams): void;
+}

package/features/Operations/Operations.js

@@ -0,0 +1,49 @@
+var Operations_OperationType = /*#__PURE__*/ function(OperationType) {
+    OperationType["INSERT"] = "INSERT";
+    OperationType["MODIFY"] = "MODIFY";
+    OperationType["REMOVE"] = "REMOVE";
+    return OperationType;
+}({});
+class Operations {
+    get items() {
+        return this._items;
+    }
+    get total() {
+        return this.items.length;
+    }
+    get count() {
+        return this._count;
+    }
+    clear() {
+        this._items = [];
+        this._count = 0;
+    }
+    insert(params) {
+        this._count++;
+        this.items.push({
+            index: {
+                _id: params.id,
+                _index: params.index
+            }
+        }, params.data);
+    }
+    modify(params) {
+        this.insert(params);
+    }
+    delete(params) {
+        this._count++;
+        this.items.push({
+            delete: {
+                _id: params.id,
+                _index: params.index
+            }
+        });
+    }
+    constructor(){
+        this._items = [];
+        this._count = 0;
+    }
+}
+export { Operations, Operations_OperationType as OperationType };
+
+//# sourceMappingURL=Operations.js.map

package/features/Operations/Operations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/Operations/Operations.js","sources":["../../../src/features/Operations/Operations.ts"],"sourcesContent":["import type { GenericRecord } from \"@webiny/api/types.js\";\nimport { Operations as OperationsAbstraction } from \"./abstractions/Operations.js\";\n\nexport enum OperationType {\n    INSERT = \"INSERT\",\n    MODIFY = \"MODIFY\",\n    REMOVE = \"REMOVE\"\n}\n\nexport class Operations implements OperationsAbstraction.Interface {\n    private _items: GenericRecord[] = [];\n    private _count = 0;\n\n    public get items(): GenericRecord[] {\n        return this._items;\n    }\n\n    public get total(): number {\n        return this.items.length;\n    }\n\n    public get count(): number {\n        return this._count;\n    }\n\n    public clear() {\n        this._items = [];\n        this._count = 0;\n    }\n\n    public insert(params: OperationsAbstraction.InsertParams): void {\n        this._count++;\n        this.items.push(\n            {\n                index: {\n                    _id: params.id,\n                    _index: params.index\n                }\n            },\n            params.data\n        );\n    }\n\n    public modify(params: OperationsAbstraction.ModifyParams): void {\n        this.insert(params);\n    }\n\n    public delete(params: OperationsAbstraction.DeleteParams): void {\n        this._count++;\n        this.items.push({\n            delete: {\n                _id: params.id,\n                _index: params.index\n            }\n        });\n    }\n}\n"],"names":["OperationType","Operations","params"],"mappings":"AAGO,IAAKA,2BAAaA,WAAAA,GAAAA,SAAbA,aAAa;;;;WAAbA;;AAML,MAAMC;IAIT,IAAW,QAAyB;QAChC,OAAO,IAAI,CAAC,MAAM;IACtB;IAEA,IAAW,QAAgB;QACvB,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM;IAC5B;IAEA,IAAW,QAAgB;QACvB,OAAO,IAAI,CAAC,MAAM;IACtB;IAEO,QAAQ;QACX,IAAI,CAAC,MAAM,GAAG,EAAE;QAChB,IAAI,CAAC,MAAM,GAAG;IAClB;IAEO,OAAOC,MAA0C,EAAQ;QAC5D,IAAI,CAAC,MAAM;QACX,IAAI,CAAC,KAAK,CAAC,IAAI,CACX;YACI,OAAO;gBACH,KAAKA,OAAO,EAAE;gBACd,QAAQA,OAAO,KAAK;YACxB;QACJ,GACAA,OAAO,IAAI;IAEnB;IAEO,OAAOA,MAA0C,EAAQ;QAC5D,IAAI,CAAC,MAAM,CAACA;IAChB;IAEO,OAAOA,MAA0C,EAAQ;QAC5D,IAAI,CAAC,MAAM;QACX,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;YACZ,QAAQ;gBACJ,KAAKA,OAAO,EAAE;gBACd,QAAQA,OAAO,KAAK;YACxB;QACJ;IACJ;;aA7CQ,MAAM,GAAoB,EAAE;aAC5B,MAAM,GAAG;;AA6CrB"}

package/features/Operations/OperationsFactory.d.ts

@@ -0,0 +1,9 @@
+import { OperationsFactory as OperationsFactoryAbstraction } from "./abstractions/OperationsFactory.js";
+import { Operations } from "./Operations.js";
+declare class OperationsFactoryImpl implements OperationsFactoryAbstraction.Interface {
+    create(): Operations;
+}
+export declare const OperationsFactory: typeof OperationsFactoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/OperationsFactory.js").IOperationsFactory>;
+};
+export {};

package/features/Operations/OperationsFactory.js

@@ -0,0 +1,14 @@
+import { OperationsFactory } from "./abstractions/OperationsFactory.js";
+import { Operations } from "./Operations.js";
+class OperationsFactoryImpl {
+    create() {
+        return new Operations();
+    }
+}
+const OperationsFactory_OperationsFactory = OperationsFactory.createImplementation({
+    implementation: OperationsFactoryImpl,
+    dependencies: []
+});
+export { OperationsFactory_OperationsFactory as OperationsFactory };
+
+//# sourceMappingURL=OperationsFactory.js.map

package/features/Operations/OperationsFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/Operations/OperationsFactory.js","sources":["../../../src/features/Operations/OperationsFactory.ts"],"sourcesContent":["import { OperationsFactory as OperationsFactoryAbstraction } from \"./abstractions/OperationsFactory.js\";\nimport { Operations } from \"./Operations.js\";\n\nclass OperationsFactoryImpl implements OperationsFactoryAbstraction.Interface {\n    public create() {\n        return new Operations();\n    }\n}\n\nexport const OperationsFactory = OperationsFactoryAbstraction.createImplementation({\n    implementation: OperationsFactoryImpl,\n    dependencies: []\n});\n"],"names":["OperationsFactoryImpl","Operations","OperationsFactory","OperationsFactoryAbstraction"],"mappings":";;AAGA,MAAMA;IACK,SAAS;QACZ,OAAO,IAAIC;IACf;AACJ;AAEO,MAAMC,sCAAoBC,kBAAAA,oBAAiD,CAAC;IAC/E,gBAAgBH;IAChB,cAAc,EAAE;AACpB"}

package/features/Operations/abstractions/Operations.d.ts

@@ -0,0 +1,27 @@
+import type { GenericRecord } from "@webiny/api/types.js";
+export interface IInsertOperationParams {
+    id: string;
+    index: string;
+    data: GenericRecord;
+}
+export type IModifyOperationParams = IInsertOperationParams;
+export interface IDeleteOperationParams {
+    id: string;
+    index: string;
+}
+export interface IOperations {
+    items: GenericRecord[];
+    total: number;
+    count: number;
+    clear(): void;
+    insert(params: IInsertOperationParams): void;
+    modify(params: IModifyOperationParams): void;
+    delete(params: IDeleteOperationParams): void;
+}
+export declare const Operations: import("@webiny/di").Abstraction<IOperations>;
+export declare namespace Operations {
+    type Interface = IOperations;
+    type InsertParams = IInsertOperationParams;
+    type ModifyParams = IModifyOperationParams;
+    type DeleteParams = IDeleteOperationParams;
+}

package/features/Operations/abstractions/Operations.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const Operations = createAbstraction("Sync/Operations");
+export { Operations };
+
+//# sourceMappingURL=Operations.js.map

package/features/Operations/abstractions/Operations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/Operations/abstractions/Operations.js","sources":["../../../../src/features/Operations/abstractions/Operations.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\nexport interface IInsertOperationParams {\n    id: string;\n    index: string;\n    data: GenericRecord;\n}\n\nexport type IModifyOperationParams = IInsertOperationParams;\n\nexport interface IDeleteOperationParams {\n    id: string;\n    index: string;\n}\n\nexport interface IOperations {\n    items: GenericRecord[];\n    total: number;\n    count: number;\n    clear(): void;\n    insert(params: IInsertOperationParams): void;\n    modify(params: IModifyOperationParams): void;\n    delete(params: IDeleteOperationParams): void;\n}\n\nexport const Operations = createAbstraction<IOperations>(\"Sync/Operations\");\n\nexport namespace Operations {\n    export type Interface = IOperations;\n    export type InsertParams = IInsertOperationParams;\n    export type ModifyParams = IModifyOperationParams;\n    export type DeleteParams = IDeleteOperationParams;\n}\n"],"names":["Operations","createAbstraction"],"mappings":";AA0BO,MAAMA,aAAaC,kBAA+B"}

package/features/Operations/abstractions/OperationsFactory.d.ts

@@ -0,0 +1,8 @@
+import type { Operations } from "./Operations.js";
+export interface IOperationsFactory {
+    create(): Operations.Interface;
+}
+export declare const OperationsFactory: import("@webiny/di").Abstraction<IOperationsFactory>;
+export declare namespace OperationsFactory {
+    type Interface = IOperationsFactory;
+}

package/features/Operations/abstractions/OperationsFactory.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const OperationsFactory = createAbstraction("Sync/OperationsFactory");
+export { OperationsFactory };
+
+//# sourceMappingURL=OperationsFactory.js.map

package/features/Operations/abstractions/OperationsFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/Operations/abstractions/OperationsFactory.js","sources":["../../../../src/features/Operations/abstractions/OperationsFactory.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Operations } from \"./Operations.js\";\n\nexport interface IOperationsFactory {\n    create(): Operations.Interface;\n}\n\nexport const OperationsFactory = createAbstraction<IOperationsFactory>(\"Sync/OperationsFactory\");\n\nexport namespace OperationsFactory {\n    export type Interface = IOperationsFactory;\n}\n"],"names":["OperationsFactory","createAbstraction"],"mappings":";AAOO,MAAMA,oBAAoBC,kBAAsC"}

package/features/Operations/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const OperationsFactoryFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/Operations/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { OperationsFactory } from "./OperationsFactory.js";
+const OperationsFactoryFeature = createFeature({
+    name: "sync.operationsFactory",
+    register (container) {
+        container.register(OperationsFactory);
+    }
+});
+export { OperationsFactoryFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/Operations/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/Operations/feature.js","sources":["../../../src/features/Operations/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { OperationsFactory } from \"./OperationsFactory.js\";\n\nexport const OperationsFactoryFeature = createFeature({\n    name: \"sync.operationsFactory\",\n    register(container) {\n        container.register(OperationsFactory);\n    }\n});\n"],"names":["OperationsFactoryFeature","createFeature","container","OperationsFactory"],"mappings":";;AAGO,MAAMA,2BAA2BC,cAAc;IAClD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/features/OperationsBuilder/abstraction.d.ts

@@ -0,0 +1,11 @@
+import type { Operations } from "../Operations/abstractions/Operations.js";
+export interface IOperationsBuilderBuildParams<TRecord = unknown> {
+    records: TRecord[];
+}
+export interface IOperationsBuilder<TRecord = unknown> {
+    build(params: IOperationsBuilderBuildParams<TRecord>): Promise<Operations.Interface>;
+}
+export declare const OperationsBuilder: import("@webiny/di").Abstraction<IOperationsBuilder<unknown>>;
+export declare namespace OperationsBuilder {
+    type Interface<TRecord = unknown> = IOperationsBuilder<TRecord>;
+}

package/features/OperationsBuilder/abstraction.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const OperationsBuilder = createAbstraction("Sync/OperationsBuilder");
+export { OperationsBuilder };
+
+//# sourceMappingURL=abstraction.js.map

package/features/OperationsBuilder/abstraction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/OperationsBuilder/abstraction.js","sources":["../../../src/features/OperationsBuilder/abstraction.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Operations } from \"../Operations/abstractions/Operations.js\";\n\nexport interface IOperationsBuilderBuildParams<TRecord = unknown> {\n    records: TRecord[];\n}\n\nexport interface IOperationsBuilder<TRecord = unknown> {\n    build(params: IOperationsBuilderBuildParams<TRecord>): Promise<Operations.Interface>;\n}\n\nexport const OperationsBuilder = createAbstraction<IOperationsBuilder>(\"Sync/OperationsBuilder\");\n\nexport namespace OperationsBuilder {\n    export type Interface<TRecord = unknown> = IOperationsBuilder<TRecord>;\n}\n"],"names":["OperationsBuilder","createAbstraction"],"mappings":";AAWO,MAAMA,oBAAoBC,kBAAsC"}

package/features/SynchronizationBuilder/SynchronizationBuilder.d.ts

@@ -0,0 +1,20 @@
+import { Operations } from "../Operations/abstractions/Operations.js";
+import { OperationsFactory } from "../Operations/abstractions/OperationsFactory.js";
+import { Timer } from "@webiny/utils/features/Timer/abstraction.js";
+import { ExecuteSyncWithRetry } from "../ExecuteSyncWithRetry/abstraction.js";
+import { SynchronizationBuilder as SynchronizationBuilderAbstraction } from "./abstraction.js";
+declare class SynchronizationBuilderImpl implements SynchronizationBuilderAbstraction.Interface {
+    private readonly timer;
+    private readonly executeSyncWithRetry;
+    private readonly operationsFactory;
+    private readonly operations;
+    constructor(timer: Timer.Interface, executeSyncWithRetry: ExecuteSyncWithRetry.Interface, operationsFactory: OperationsFactory.Interface);
+    insert(params: Operations.InsertParams): void;
+    modify(params: Operations.ModifyParams): void;
+    delete(params: Operations.DeleteParams): void;
+    build(): (params?: Partial<ExecuteSyncWithRetry.Params>) => Promise<void>;
+}
+export declare const SynchronizationBuilder: typeof SynchronizationBuilderImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstraction.js").ISynchronizationBuilder>;
+};
+export {};

package/features/SynchronizationBuilder/SynchronizationBuilder.js

@@ -0,0 +1,43 @@
+import { OperationsFactory } from "../Operations/abstractions/OperationsFactory.js";
+import { Timer } from "@webiny/utils/features/Timer/abstraction.js";
+import { ExecuteSyncWithRetry } from "../ExecuteSyncWithRetry/abstraction.js";
+import { SynchronizationBuilder } from "./abstraction.js";
+class SynchronizationBuilderImpl {
+    constructor(timer, executeSyncWithRetry, operationsFactory){
+        this.timer = timer;
+        this.executeSyncWithRetry = executeSyncWithRetry;
+        this.operationsFactory = operationsFactory;
+        this.operations = this.operationsFactory.create();
+    }
+    insert(params) {
+        this.operations.insert(params);
+    }
+    modify(params) {
+        this.operations.modify(params);
+    }
+    delete(params) {
+        this.operations.delete(params);
+    }
+    build() {
+        return async (params)=>{
+            if (0 === this.operations.total) return;
+            await this.executeSyncWithRetry.execute({
+                ...params,
+                maxRunningTime: this.timer.getRemainingSeconds(),
+                operations: this.operations
+            });
+            this.operations.clear();
+        };
+    }
+}
+const SynchronizationBuilder_SynchronizationBuilder = SynchronizationBuilder.createImplementation({
+    implementation: SynchronizationBuilderImpl,
+    dependencies: [
+        Timer,
+        ExecuteSyncWithRetry,
+        OperationsFactory
+    ]
+});
+export { SynchronizationBuilder_SynchronizationBuilder as SynchronizationBuilder };
+
+//# sourceMappingURL=SynchronizationBuilder.js.map

package/features/SynchronizationBuilder/SynchronizationBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/SynchronizationBuilder/SynchronizationBuilder.js","sources":["../../../src/features/SynchronizationBuilder/SynchronizationBuilder.ts"],"sourcesContent":["import { Operations } from \"../Operations/abstractions/Operations.js\";\nimport { OperationsFactory } from \"../Operations/abstractions/OperationsFactory.js\";\nimport { Timer } from \"@webiny/utils/features/Timer/abstraction.js\";\nimport { ExecuteSyncWithRetry } from \"../ExecuteSyncWithRetry/abstraction.js\";\nimport { SynchronizationBuilder as SynchronizationBuilderAbstraction } from \"./abstraction.js\";\n\nclass SynchronizationBuilderImpl implements SynchronizationBuilderAbstraction.Interface {\n    private readonly operations: Operations.Interface;\n\n    public constructor(\n        private readonly timer: Timer.Interface,\n        private readonly executeSyncWithRetry: ExecuteSyncWithRetry.Interface,\n        private readonly operationsFactory: OperationsFactory.Interface\n    ) {\n        this.operations = this.operationsFactory.create();\n    }\n\n    public insert(params: Operations.InsertParams): void {\n        this.operations.insert(params);\n    }\n\n    public modify(params: Operations.ModifyParams): void {\n        this.operations.modify(params);\n    }\n\n    public delete(params: Operations.DeleteParams): void {\n        this.operations.delete(params);\n    }\n\n    public build() {\n        return async (params?: Partial<ExecuteSyncWithRetry.Params>) => {\n            if (this.operations.total === 0) {\n                return;\n            }\n            await this.executeSyncWithRetry.execute({\n                ...params,\n                maxRunningTime: this.timer.getRemainingSeconds(),\n                operations: this.operations\n            });\n            this.operations.clear();\n        };\n    }\n}\n\nexport const SynchronizationBuilder = SynchronizationBuilderAbstraction.createImplementation({\n    implementation: SynchronizationBuilderImpl,\n    dependencies: [Timer, ExecuteSyncWithRetry, OperationsFactory]\n});\n"],"names":["SynchronizationBuilderImpl","timer","executeSyncWithRetry","operationsFactory","params","SynchronizationBuilder","SynchronizationBuilderAbstraction","Timer","ExecuteSyncWithRetry","OperationsFactory"],"mappings":";;;;AAMA,MAAMA;IAGF,YACqBC,KAAsB,EACtBC,oBAAoD,EACpDC,iBAA8C,CACjE;aAHmBF,KAAK,GAALA;aACAC,oBAAoB,GAApBA;aACAC,iBAAiB,GAAjBA;QAEjB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,iBAAiB,CAAC,MAAM;IACnD;IAEO,OAAOC,MAA+B,EAAQ;QACjD,IAAI,CAAC,UAAU,CAAC,MAAM,CAACA;IAC3B;IAEO,OAAOA,MAA+B,EAAQ;QACjD,IAAI,CAAC,UAAU,CAAC,MAAM,CAACA;IAC3B;IAEO,OAAOA,MAA+B,EAAQ;QACjD,IAAI,CAAC,UAAU,CAAC,MAAM,CAACA;IAC3B;IAEO,QAAQ;QACX,OAAO,OAAOA;YACV,IAAI,AAA0B,MAA1B,IAAI,CAAC,UAAU,CAAC,KAAK,EACrB;YAEJ,MAAM,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC;gBACpC,GAAGA,MAAM;gBACT,gBAAgB,IAAI,CAAC,KAAK,CAAC,mBAAmB;gBAC9C,YAAY,IAAI,CAAC,UAAU;YAC/B;YACA,IAAI,CAAC,UAAU,CAAC,KAAK;QACzB;IACJ;AACJ;AAEO,MAAMC,gDAAyBC,uBAAAA,oBAAsD,CAAC;IACzF,gBAAgBN;IAChB,cAAc;QAACO;QAAOC;QAAsBC;KAAkB;AAClE"}

package/features/SynchronizationBuilder/abstraction.d.ts

@@ -0,0 +1,12 @@
+import type { Operations } from "../Operations/abstractions/Operations.js";
+import type { ExecuteSyncWithRetry } from "../ExecuteSyncWithRetry/abstraction.js";
+export interface ISynchronizationBuilder {
+    insert(params: Operations.InsertParams): void;
+    modify(params: Operations.ModifyParams): void;
+    delete(params: Operations.DeleteParams): void;
+    build(): (params?: Partial<ExecuteSyncWithRetry.Params>) => Promise<void>;
+}
+export declare const SynchronizationBuilder: import("@webiny/di").Abstraction<ISynchronizationBuilder>;
+export declare namespace SynchronizationBuilder {
+    type Interface = ISynchronizationBuilder;
+}

package/features/SynchronizationBuilder/abstraction.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const SynchronizationBuilder = createAbstraction("Sync/SynchronizationBuilder");
+export { SynchronizationBuilder };
+
+//# sourceMappingURL=abstraction.js.map

package/features/SynchronizationBuilder/abstraction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/SynchronizationBuilder/abstraction.js","sources":["../../../src/features/SynchronizationBuilder/abstraction.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Operations } from \"../Operations/abstractions/Operations.js\";\nimport type { ExecuteSyncWithRetry } from \"../ExecuteSyncWithRetry/abstraction.js\";\n\nexport interface ISynchronizationBuilder {\n    insert(params: Operations.InsertParams): void;\n    modify(params: Operations.ModifyParams): void;\n    delete(params: Operations.DeleteParams): void;\n    build(): (params?: Partial<ExecuteSyncWithRetry.Params>) => Promise<void>;\n}\n\nexport const SynchronizationBuilder = createAbstraction<ISynchronizationBuilder>(\n    \"Sync/SynchronizationBuilder\"\n);\n\nexport namespace SynchronizationBuilder {\n    export type Interface = ISynchronizationBuilder;\n}\n"],"names":["SynchronizationBuilder","createAbstraction"],"mappings":";AAWO,MAAMA,yBAAyBC,kBAClC"}

package/features/SynchronizationBuilder/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const SynchronizationBuilderFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/SynchronizationBuilder/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { SynchronizationBuilder } from "./SynchronizationBuilder.js";
+const SynchronizationBuilderFeature = createFeature({
+    name: "sync.synchronizationBuilder",
+    register (container) {
+        container.register(SynchronizationBuilder);
+    }
+});
+export { SynchronizationBuilderFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/SynchronizationBuilder/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/SynchronizationBuilder/feature.js","sources":["../../../src/features/SynchronizationBuilder/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { SynchronizationBuilder } from \"./SynchronizationBuilder.js\";\n\nexport const SynchronizationBuilderFeature = createFeature({\n    name: \"sync.synchronizationBuilder\",\n    register(container) {\n        container.register(SynchronizationBuilder);\n    }\n});\n"],"names":["SynchronizationBuilderFeature","createFeature","container","SynchronizationBuilder"],"mappings":";;AAGO,MAAMA,gCAAgCC,cAAc;IACvD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/index.d.ts

@@ -0,0 +1,12 @@
+export { Operations } from "./features/Operations/abstractions/Operations.js";
+export { OperationType } from "./features/Operations/Operations.js";
+export { OperationsFactory } from "./features/Operations/abstractions/OperationsFactory.js";
+export { OperationsFactoryFeature } from "./features/Operations/feature.js";
+export { OperationsBuilder } from "./features/OperationsBuilder/abstraction.js";
+export { ExecuteSync } from "./features/ExecuteSync/abstraction.js";
+export { ExecuteSyncFeature } from "./features/ExecuteSync/feature.js";
+export { ExecuteSyncWithRetry } from "./features/ExecuteSyncWithRetry/abstraction.js";
+export { ExecuteSyncWithRetryFeature } from "./features/ExecuteSyncWithRetry/feature.js";
+export { SynchronizationBuilder } from "./features/SynchronizationBuilder/abstraction.js";
+export { SynchronizationBuilderFeature } from "./features/SynchronizationBuilder/feature.js";
+export { NotEnoughRemainingTimeError } from "./NotEnoughRemainingTimeError.js";

package/index.js

@@ -0,0 +1,12 @@
+export { Operations } from "./features/Operations/abstractions/Operations.js";
+export { OperationType } from "./features/Operations/Operations.js";
+export { OperationsFactory } from "./features/Operations/abstractions/OperationsFactory.js";
+export { OperationsFactoryFeature } from "./features/Operations/feature.js";
+export { OperationsBuilder } from "./features/OperationsBuilder/abstraction.js";
+export { ExecuteSync } from "./features/ExecuteSync/abstraction.js";
+export { ExecuteSyncFeature } from "./features/ExecuteSync/feature.js";
+export { ExecuteSyncWithRetry } from "./features/ExecuteSyncWithRetry/abstraction.js";
+export { ExecuteSyncWithRetryFeature } from "./features/ExecuteSyncWithRetry/feature.js";
+export { SynchronizationBuilder } from "./features/SynchronizationBuilder/abstraction.js";
+export { SynchronizationBuilderFeature } from "./features/SynchronizationBuilder/feature.js";
+export { NotEnoughRemainingTimeError } from "./NotEnoughRemainingTimeError.js";

package/package.json

@@ -0,0 +1,42 @@
+{
+	"name": "@webiny/api-sync-to-opensearch",
+	"version": "0.0.0-unstable.0d717d18dd",
+	"type": "module",
+	"exports": {
+		".": "./index.js",
+		"./*": "./*"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git",
+		"directory": "packages/api-sync-to-opensearch"
+	},
+	"description": "Platform-agnostic OpenSearch synchronization with DI abstractions.",
+	"license": "MIT",
+	"author": "Webiny Ltd.",
+	"dependencies": {
+		"@webiny/api": "0.0.0-unstable.0d717d18dd",
+		"@webiny/api-opensearch": "0.0.0-unstable.0d717d18dd",
+		"@webiny/error": "0.0.0-unstable.0d717d18dd",
+		"@webiny/feature": "0.0.0-unstable.0d717d18dd",
+		"@webiny/stdlib": "0.0.15",
+		"@webiny/utils": "0.0.0-unstable.0d717d18dd",
+		"p-retry": "8.0.0"
+	},
+	"devDependencies": {
+		"@webiny/build-tools": "0.0.0-unstable.0d717d18dd",
+		"@webiny/plugins": "0.0.0-unstable.0d717d18dd",
+		"typescript": "7.0.2"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"adio": {
+		"ignoreDirs": [
+			"__tests__"
+		]
+	},
+	"webiny": {
+		"publishFrom": "dist"
+	}
+}