@webiny/api-opensearch 0.0.0-unstable.0156a4c312

package/utils/createIndex.js

@@ -0,0 +1,60 @@
+import _webiny_error from "@webiny/error";
+const indexExists = async (params)=>{
+    const { client, index } = params;
+    try {
+        const response = await client.indices.exists({
+            index,
+            ignore_unavailable: false,
+            allow_no_indices: true,
+            include_defaults: true,
+            flat_settings: false,
+            local: false
+        });
+        if (!response.body) return false;
+        return true;
+    } catch  {
+        console.error(`Could not determine if the index "${index}" exists.`);
+    }
+    return false;
+};
+const indexCreate = async (params)=>{
+    const { client, index, plugin, tenant, type, onError } = params;
+    try {
+        await client.indices.create({
+            index,
+            body: {
+                ...plugin.body
+            }
+        });
+    } catch (ex) {
+        let error = ex;
+        if (onError) error = onError(ex);
+        throw new _webiny_error(error.message || `Could not create OpenSearch index for the ${type}.`, error.code || "CREATE_OPENSEARCH_INDEX_ERROR", {
+            error: {
+                ...error,
+                message: error.message,
+                code: error.code,
+                data: error.data
+            },
+            type,
+            tenant,
+            index,
+            body: plugin.body
+        });
+    }
+};
+const createIndex = async (params)=>{
+    const { plugin, onExists } = params;
+    const exists = await indexExists(params);
+    if (exists) {
+        if (onExists) onExists();
+        return;
+    }
+    await indexCreate({
+        ...params,
+        plugin
+    });
+};
+export { createIndex };
+
+//# sourceMappingURL=createIndex.js.map

package/utils/createIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/createIndex.js","sources":["../../src/utils/createIndex.ts"],"sourcesContent":["import type { Client } from \"~/client.js\";\nimport type { OpenSearchIndex } from \"~/features/OpenSearchIndex/abstractions/OpenSearchIndex.js\";\nimport WebinyError from \"@webiny/error\";\n\ninterface OnExists {\n    (): void;\n}\n\ninterface OnError {\n    (ex: Error): Error;\n}\n\ninterface ExistsIndexParams {\n    client: Client;\n    index: string;\n}\n\nconst indexExists = async (params: ExistsIndexParams): Promise<boolean> => {\n    const { client, index } = params;\n\n    try {\n        const response = await client.indices.exists({\n            index,\n            ignore_unavailable: false,\n            allow_no_indices: true,\n            include_defaults: true,\n            flat_settings: false,\n            local: false\n        });\n        if (!response.body) {\n            return false;\n        }\n        return true;\n    } catch {\n        console.error(`Could not determine if the index \"${index}\" exists.`);\n    }\n    return false;\n};\n\ninterface IndexCreateParams {\n    client: Client;\n    index: string;\n    type: string;\n    tenant: string;\n    plugin: OpenSearchIndex.Interface;\n    onError?: OnError;\n}\n\nconst indexCreate = async (params: IndexCreateParams): Promise<void> => {\n    const { client, index, plugin, tenant, type, onError } = params;\n\n    try {\n        await client.indices.create({\n            index,\n            body: {\n                ...plugin.body\n            }\n        });\n    } catch (ex) {\n        let error = ex;\n        if (onError) {\n            error = onError(ex);\n        }\n        throw new WebinyError(\n            error.message || `Could not create OpenSearch index for the ${type}.`,\n            error.code || \"CREATE_OPENSEARCH_INDEX_ERROR\",\n            {\n                error: {\n                    ...error,\n                    message: error.message,\n                    code: error.code,\n                    data: error.data\n                },\n                type,\n                tenant,\n                index,\n                body: plugin.body\n            }\n        );\n    }\n};\n\ninterface CreateIndexParams {\n    client: Client;\n    plugin: OpenSearchIndex.Interface;\n    type: string;\n    tenant: string;\n    index: string;\n    onExists?: OnExists;\n    onError?: OnError;\n}\n\nexport const createIndex = async (params: CreateIndexParams): Promise<void> => {\n    const { plugin, onExists } = params;\n\n    const exists = await indexExists(params);\n    if (exists) {\n        if (onExists) {\n            onExists();\n        }\n        return;\n    }\n\n    await indexCreate({\n        ...params,\n        plugin\n    });\n};\n"],"names":["indexExists","params","client","index","response","console","indexCreate","plugin","tenant","type","onError","ex","error","WebinyError","createIndex","onExists","exists"],"mappings":";AAiBA,MAAMA,cAAc,OAAOC;IACvB,MAAM,EAAEC,MAAM,EAAEC,KAAK,EAAE,GAAGF;IAE1B,IAAI;QACA,MAAMG,WAAW,MAAMF,OAAO,OAAO,CAAC,MAAM,CAAC;YACzCC;YACA,oBAAoB;YACpB,kBAAkB;YAClB,kBAAkB;YAClB,eAAe;YACf,OAAO;QACX;QACA,IAAI,CAACC,SAAS,IAAI,EACd,OAAO;QAEX,OAAO;IACX,EAAE,OAAM;QACJC,QAAQ,KAAK,CAAC,CAAC,kCAAkC,EAAEF,MAAM,SAAS,CAAC;IACvE;IACA,OAAO;AACX;AAWA,MAAMG,cAAc,OAAOL;IACvB,MAAM,EAAEC,MAAM,EAAEC,KAAK,EAAEI,MAAM,EAAEC,MAAM,EAAEC,IAAI,EAAEC,OAAO,EAAE,GAAGT;IAEzD,IAAI;QACA,MAAMC,OAAO,OAAO,CAAC,MAAM,CAAC;YACxBC;YACA,MAAM;gBACF,GAAGI,OAAO,IAAI;YAClB;QACJ;IACJ,EAAE,OAAOI,IAAI;QACT,IAAIC,QAAQD;QACZ,IAAID,SACAE,QAAQF,QAAQC;QAEpB,MAAM,IAAIE,cACND,MAAM,OAAO,IAAI,CAAC,0CAA0C,EAAEH,KAAK,CAAC,CAAC,EACrEG,MAAM,IAAI,IAAI,iCACd;YACI,OAAO;gBACH,GAAGA,KAAK;gBACR,SAASA,MAAM,OAAO;gBACtB,MAAMA,MAAM,IAAI;gBAChB,MAAMA,MAAM,IAAI;YACpB;YACAH;YACAD;YACAL;YACA,MAAMI,OAAO,IAAI;QACrB;IAER;AACJ;AAYO,MAAMO,cAAc,OAAOb;IAC9B,MAAM,EAAEM,MAAM,EAAEQ,QAAQ,EAAE,GAAGd;IAE7B,MAAMe,SAAS,MAAMhB,YAAYC;IACjC,IAAIe,QAAQ;QACR,IAAID,UACAA;QAEJ;IACJ;IAEA,MAAMT,YAAY;QACd,GAAGL,MAAM;QACTM;IACJ;AACJ"}

package/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./waitUntilHealthy/index.js";
+export * from "./createIndex.js";

package/utils/index.js

@@ -0,0 +1,2 @@
+export * from "./waitUntilHealthy/index.js";
+export * from "./createIndex.js";

package/utils/waitUntilHealthy/UnhealthyClusterError.d.ts

@@ -0,0 +1,4 @@
+import { WebinyError } from "@webiny/error";
+export declare class UnhealthyClusterError extends WebinyError {
+    constructor(maxWaitingTime: number);
+}

package/utils/waitUntilHealthy/UnhealthyClusterError.js

@@ -0,0 +1,12 @@
+import { WebinyError } from "@webiny/error";
+class UnhealthyClusterError extends WebinyError {
+    constructor(maxWaitingTime){
+        super({
+            message: `Cluster did not become healthy in ${maxWaitingTime} seconds.`,
+            code: "UNHEALTHY_CLUSTER"
+        });
+    }
+}
+export { UnhealthyClusterError };
+
+//# sourceMappingURL=UnhealthyClusterError.js.map

package/utils/waitUntilHealthy/UnhealthyClusterError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/waitUntilHealthy/UnhealthyClusterError.js","sources":["../../../src/utils/waitUntilHealthy/UnhealthyClusterError.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\n\nexport class UnhealthyClusterError extends WebinyError {\n    public constructor(maxWaitingTime: number) {\n        super({\n            message: `Cluster did not become healthy in ${maxWaitingTime} seconds.`,\n            code: \"UNHEALTHY_CLUSTER\"\n        });\n    }\n}\n"],"names":["UnhealthyClusterError","WebinyError","maxWaitingTime"],"mappings":";AAEO,MAAMA,8BAA8BC;IACvC,YAAmBC,cAAsB,CAAE;QACvC,KAAK,CAAC;YACF,SAAS,CAAC,kCAAkC,EAAEA,eAAe,SAAS,CAAC;YACvE,MAAM;QACV;IACJ;AACJ"}

package/utils/waitUntilHealthy/WaitUntilHealthy.d.ts

@@ -0,0 +1,72 @@
+import type { Client } from "../../client.js";
+import { OpenSearchCatClusterHealthStatus } from "../../operations/types.js";
+import type { ClusterHealthReason, MemoryReason, ProcessorReason } from "./reason/index.js";
+export type WaitingReason = ProcessorReason | MemoryReason | ClusterHealthReason;
+export interface IWaitUntilHealthyParams {
+    /**
+     * Minimum status allowed, otherwise the cluster is considered unhealthy.
+     */
+    minClusterHealthStatus: OpenSearchCatClusterHealthStatus.Green | OpenSearchCatClusterHealthStatus.Yellow;
+    /**
+     * Maximum processor percent allowed, otherwise the cluster is considered unhealthy.
+     */
+    maxProcessorPercent: number;
+    /**
+     * Maximum RAM percent allowed, otherwise the cluster is considered unhealthy.
+     */
+    maxRamPercent?: number;
+    /**
+     * Maximum time to wait in seconds.
+     * This is to prevent infinite waiting in case the cluster never becomes healthy.
+     */
+    maxWaitingTime: number;
+    /**
+     * Time in seconds to wait between each check.
+     * This is to prevent spamming the cluster with requests.
+     * Default is WAITING_TIME_STEP seconds.
+     */
+    waitingTimeStep?: number;
+}
+export interface IWaitOptionsOnUnhealthyParams {
+    startedAt: Date;
+    mustEndAt: Date;
+    waitingTimeStep: number;
+    runs: number;
+    waitingReason: WaitingReason;
+}
+export interface IWaitOptionsOnTimeoutParams {
+    startedAt: Date;
+    mustEndAt: Date;
+    waitingTimeStep: number;
+    runs: number;
+    waitingReason: WaitingReason;
+}
+export interface IWaitOptions {
+    onUnhealthy?(params: IWaitOptionsOnUnhealthyParams): Promise<void>;
+    onTimeout?(params: IWaitOptionsOnTimeoutParams): Promise<void>;
+}
+export interface IWaitUntilHealthyWaitResponse {
+    runningTime: number;
+    runs: number;
+}
+declare class WaitUntilHealthy {
+    private readonly client;
+    private readonly options;
+    private readonly catHealth;
+    private readonly catNodes;
+    private aborted;
+    constructor(client: Client, options: IWaitUntilHealthyParams);
+    abort(): void;
+    /**
+     * @throws UnhealthyClusterError
+     * @throws WaitingHealthyClusterAbortedError
+     */
+    wait(options?: IWaitOptions): Promise<IWaitUntilHealthyWaitResponse>;
+    private shouldWait;
+    private getProcessorPercent;
+    private getRamPercent;
+    private toClusterHealthStatus;
+    private transformClusterHealthStatus;
+}
+export type { WaitUntilHealthy };
+export declare const createWaitUntilHealthy: (client: Client, params: IWaitUntilHealthyParams) => WaitUntilHealthy;

package/utils/waitUntilHealthy/WaitUntilHealthy.js

@@ -0,0 +1,130 @@
+import { OpenSearchCatHealth } from "../../operations/OpenSearchCatHealth.js";
+import { OpenSearchCatNodes } from "../../operations/OpenSearchCatNodes.js";
+import { OpenSearchCatClusterHealthStatus } from "../../operations/types.js";
+import { UnhealthyClusterError } from "./UnhealthyClusterError.js";
+import { createClusterHealthStatusReason, createMemoryReason, createProcessorReason } from "./reason/index.js";
+import { WaitingHealthyClusterAbortedError } from "./WaitingHealthyClusterAbortedError.js";
+const WAITING_TIME_STEP = 10;
+class WaitUntilHealthy {
+    constructor(client, options){
+        this.aborted = false;
+        this.client = client;
+        this.options = options;
+        this.catHealth = new OpenSearchCatHealth(this.client);
+        this.catNodes = new OpenSearchCatNodes(this.client);
+    }
+    abort() {
+        this.aborted = true;
+    }
+    async wait(options) {
+        if (this.aborted) throw new WaitingHealthyClusterAbortedError("Waiting for the cluster to become healthy was aborted even before it started.");
+        const startedAt = new Date();
+        const mustEndAt = new Date(startedAt.getTime() + 1000 * this.options.maxWaitingTime);
+        const waitingTimeStep = this.options.waitingTimeStep || WAITING_TIME_STEP;
+        let runs = 1;
+        let waitingReason;
+        while(waitingReason = await this.shouldWait()){
+            if (new Date() >= mustEndAt) {
+                if (options?.onTimeout) await options.onTimeout({
+                    startedAt,
+                    mustEndAt,
+                    waitingTimeStep,
+                    waitingReason,
+                    runs
+                });
+                throw new UnhealthyClusterError(this.options.maxWaitingTime);
+            } else if (options?.onUnhealthy) await options.onUnhealthy({
+                startedAt,
+                mustEndAt,
+                waitingTimeStep,
+                waitingReason,
+                runs
+            });
+            if (this.aborted) throw new WaitingHealthyClusterAbortedError();
+            runs++;
+            await new Promise((resolve)=>{
+                setTimeout(resolve, 1000 * waitingTimeStep);
+            });
+        }
+        const runningTime = new Date().getTime() - startedAt.getTime();
+        return {
+            runningTime,
+            runs
+        };
+    }
+    async shouldWait() {
+        let health;
+        let nodes;
+        try {
+            health = await this.catHealth.getHealth();
+        } catch (ex) {
+            return createClusterHealthStatusReason({
+                description: ex.message,
+                minimum: this.options.minClusterHealthStatus,
+                current: OpenSearchCatClusterHealthStatus.Red
+            });
+        }
+        try {
+            nodes = await this.catNodes.getNodes();
+        } catch (ex) {
+            return createClusterHealthStatusReason({
+                description: ex.message,
+                minimum: this.options.minClusterHealthStatus,
+                current: OpenSearchCatClusterHealthStatus.Red
+            });
+        }
+        const currentStatus = this.toClusterHealthStatus(health.status);
+        const clusterHealthStatus = this.transformClusterHealthStatus(currentStatus);
+        const minClusterHealthStatus = this.transformClusterHealthStatus(this.options.minClusterHealthStatus);
+        if (clusterHealthStatus > minClusterHealthStatus) return createClusterHealthStatusReason({
+            minimum: this.options.minClusterHealthStatus,
+            current: currentStatus
+        });
+        const processorPercent = this.getProcessorPercent(nodes);
+        if (processorPercent > this.options.maxProcessorPercent) return createProcessorReason({
+            maximum: this.options.maxProcessorPercent,
+            current: processorPercent
+        });
+        if (void 0 === this.options.maxRamPercent) return false;
+        const ramPercent = this.getRamPercent(nodes);
+        if (ramPercent > this.options.maxRamPercent) return createMemoryReason({
+            maximum: this.options.maxRamPercent,
+            current: ramPercent
+        });
+        return false;
+    }
+    getProcessorPercent(nodes) {
+        const total = nodes.reduce((total, node)=>total + parseFloat(node.cpu || "0"), 0);
+        return total / nodes.length;
+    }
+    getRamPercent(nodes) {
+        const total = nodes.reduce((total, node)=>total + parseFloat(node["ram.percent"] || "0"), 0);
+        return total / nodes.length;
+    }
+    toClusterHealthStatus(status) {
+        switch(status){
+            case "green":
+                return OpenSearchCatClusterHealthStatus.Green;
+            case "yellow":
+                return OpenSearchCatClusterHealthStatus.Yellow;
+            default:
+                return OpenSearchCatClusterHealthStatus.Red;
+        }
+    }
+    transformClusterHealthStatus(status) {
+        switch(status){
+            case OpenSearchCatClusterHealthStatus.Green:
+                return 1;
+            case OpenSearchCatClusterHealthStatus.Yellow:
+                return 2;
+            case OpenSearchCatClusterHealthStatus.Red:
+                return 3;
+            default:
+                return 99;
+        }
+    }
+}
+const createWaitUntilHealthy = (client, params)=>new WaitUntilHealthy(client, params);
+export { createWaitUntilHealthy };
+
+//# sourceMappingURL=WaitUntilHealthy.js.map

package/utils/waitUntilHealthy/WaitUntilHealthy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/waitUntilHealthy/WaitUntilHealthy.js","sources":["../../../src/utils/waitUntilHealthy/WaitUntilHealthy.ts"],"sourcesContent":["import type { Client } from \"~/client.js\";\nimport { OpenSearchCatHealth } from \"~/operations/OpenSearchCatHealth.js\";\nimport { OpenSearchCatNodes } from \"~/operations/OpenSearchCatNodes.js\";\nimport type {\n    IOpenSearchCatHealthResponse,\n    IOpenSearchCatNodesResponse\n} from \"~/operations/types.js\";\nimport { OpenSearchCatClusterHealthStatus } from \"~/operations/types.js\";\nimport { UnhealthyClusterError } from \"~/utils/waitUntilHealthy/UnhealthyClusterError.js\";\nimport type { ClusterHealthReason, MemoryReason, ProcessorReason } from \"./reason/index.js\";\nimport {\n    createClusterHealthStatusReason,\n    createMemoryReason,\n    createProcessorReason\n} from \"./reason/index.js\";\nimport { WaitingHealthyClusterAbortedError } from \"./WaitingHealthyClusterAbortedError.js\";\n\nconst WAITING_TIME_STEP = 10;\n\nexport type WaitingReason = ProcessorReason | MemoryReason | ClusterHealthReason;\n\nexport interface IWaitUntilHealthyParams {\n    /**\n     * Minimum status allowed, otherwise the cluster is considered unhealthy.\n     */\n    minClusterHealthStatus:\n        | OpenSearchCatClusterHealthStatus.Green\n        | OpenSearchCatClusterHealthStatus.Yellow;\n    /**\n     * Maximum processor percent allowed, otherwise the cluster is considered unhealthy.\n     */\n    maxProcessorPercent: number;\n    /**\n     * Maximum RAM percent allowed, otherwise the cluster is considered unhealthy.\n     */\n    maxRamPercent?: number;\n    /**\n     * Maximum time to wait in seconds.\n     * This is to prevent infinite waiting in case the cluster never becomes healthy.\n     */\n    maxWaitingTime: number;\n    /**\n     * Time in seconds to wait between each check.\n     * This is to prevent spamming the cluster with requests.\n     * Default is WAITING_TIME_STEP seconds.\n     */\n    waitingTimeStep?: number;\n}\n\nexport interface IWaitOptionsOnUnhealthyParams {\n    startedAt: Date;\n    mustEndAt: Date;\n    waitingTimeStep: number;\n    runs: number;\n    waitingReason: WaitingReason;\n}\n\nexport interface IWaitOptionsOnTimeoutParams {\n    startedAt: Date;\n    mustEndAt: Date;\n    waitingTimeStep: number;\n    runs: number;\n    waitingReason: WaitingReason;\n}\n\nexport interface IWaitOptions {\n    onUnhealthy?(params: IWaitOptionsOnUnhealthyParams): Promise<void>;\n    onTimeout?(params: IWaitOptionsOnTimeoutParams): Promise<void>;\n}\n\nexport interface IWaitUntilHealthyWaitResponse {\n    runningTime: number;\n    runs: number;\n}\n\nclass WaitUntilHealthy {\n    private readonly client: Client;\n    private readonly options: IWaitUntilHealthyParams;\n\n    private readonly catHealth: OpenSearchCatHealth;\n    private readonly catNodes: OpenSearchCatNodes;\n\n    private aborted = false;\n\n    public constructor(client: Client, options: IWaitUntilHealthyParams) {\n        this.client = client;\n        this.options = options;\n\n        this.catHealth = new OpenSearchCatHealth(this.client);\n        this.catNodes = new OpenSearchCatNodes(this.client);\n    }\n\n    public abort(): void {\n        this.aborted = true;\n    }\n    /**\n     * @throws UnhealthyClusterError\n     * @throws WaitingHealthyClusterAbortedError\n     */\n    public async wait(options?: IWaitOptions): Promise<IWaitUntilHealthyWaitResponse> {\n        if (this.aborted) {\n            throw new WaitingHealthyClusterAbortedError(\n                `Waiting for the cluster to become healthy was aborted even before it started.`\n            );\n        }\n        const startedAt = new Date();\n        const mustEndAt = new Date(startedAt.getTime() + this.options.maxWaitingTime * 1000);\n        const waitingTimeStep = this.options.waitingTimeStep || WAITING_TIME_STEP;\n        let runs = 1;\n        let waitingReason: WaitingReason | false;\n        while ((waitingReason = await this.shouldWait())) {\n            if (new Date() >= mustEndAt) {\n                if (options?.onTimeout) {\n                    await options.onTimeout({\n                        startedAt,\n                        mustEndAt,\n                        waitingTimeStep,\n                        waitingReason,\n                        runs\n                    });\n                }\n                throw new UnhealthyClusterError(this.options.maxWaitingTime);\n            } else if (options?.onUnhealthy) {\n                await options.onUnhealthy({\n                    startedAt,\n                    mustEndAt,\n                    waitingTimeStep,\n                    waitingReason,\n                    runs\n                });\n            }\n            /**\n             * Abort check is separated from other IFs because it can be aborted in onUnhealthy callback.\n             */\n            if (this.aborted) {\n                throw new WaitingHealthyClusterAbortedError();\n            }\n            runs++;\n            await new Promise(resolve => {\n                setTimeout(resolve, waitingTimeStep * 1000);\n            });\n        }\n\n        const runningTime = new Date().getTime() - startedAt.getTime();\n\n        return {\n            runningTime,\n            runs\n        };\n    }\n\n    private async shouldWait(): Promise<WaitingReason | false> {\n        let health: IOpenSearchCatHealthResponse;\n        let nodes: IOpenSearchCatNodesResponse;\n        try {\n            health = await this.catHealth.getHealth();\n        } catch (ex) {\n            return createClusterHealthStatusReason({\n                description: ex.message,\n                minimum: this.options.minClusterHealthStatus,\n                current: OpenSearchCatClusterHealthStatus.Red\n            });\n        }\n        try {\n            nodes = await this.catNodes.getNodes();\n        } catch (ex) {\n            return createClusterHealthStatusReason({\n                description: ex.message,\n                minimum: this.options.minClusterHealthStatus,\n                current: OpenSearchCatClusterHealthStatus.Red\n            });\n        }\n\n        const currentStatus = this.toClusterHealthStatus(health.status);\n        const clusterHealthStatus = this.transformClusterHealthStatus(currentStatus);\n        const minClusterHealthStatus = this.transformClusterHealthStatus(\n            this.options.minClusterHealthStatus\n        );\n        if (clusterHealthStatus > minClusterHealthStatus) {\n            return createClusterHealthStatusReason({\n                minimum: this.options.minClusterHealthStatus,\n                current: currentStatus\n            });\n        }\n\n        const processorPercent = this.getProcessorPercent(nodes);\n        if (processorPercent > this.options.maxProcessorPercent) {\n            return createProcessorReason({\n                maximum: this.options.maxProcessorPercent,\n                current: processorPercent\n            });\n        }\n        /**\n         * Possibly no max ram definition?\n         */\n        if (this.options.maxRamPercent === undefined) {\n            return false;\n        }\n\n        const ramPercent = this.getRamPercent(nodes);\n        if (ramPercent > this.options.maxRamPercent) {\n            return createMemoryReason({\n                maximum: this.options.maxRamPercent,\n                current: ramPercent\n            });\n        }\n        return false;\n    }\n\n    private getProcessorPercent(nodes: IOpenSearchCatNodesResponse): number {\n        const total = nodes.reduce<number>((total, node) => {\n            return total + parseFloat(node.cpu || \"0\");\n        }, 0);\n        return total / nodes.length;\n    }\n\n    private getRamPercent(nodes: IOpenSearchCatNodesResponse): number {\n        const total = nodes.reduce<number>((total, node) => {\n            return total + parseFloat(node[\"ram.percent\"] || \"0\");\n        }, 0);\n        return total / nodes.length;\n    }\n\n    private toClusterHealthStatus(status?: string): OpenSearchCatClusterHealthStatus {\n        switch (status) {\n            case \"green\":\n                return OpenSearchCatClusterHealthStatus.Green;\n            case \"yellow\":\n                return OpenSearchCatClusterHealthStatus.Yellow;\n            default:\n                return OpenSearchCatClusterHealthStatus.Red;\n        }\n    }\n\n    private transformClusterHealthStatus(status: OpenSearchCatClusterHealthStatus): number {\n        switch (status) {\n            case OpenSearchCatClusterHealthStatus.Green:\n                return 1;\n            case OpenSearchCatClusterHealthStatus.Yellow:\n                return 2;\n            case OpenSearchCatClusterHealthStatus.Red:\n                return 3;\n            default:\n                return 99;\n        }\n    }\n}\n\nexport type { WaitUntilHealthy };\n\nexport const createWaitUntilHealthy = (\n    client: Client,\n    params: IWaitUntilHealthyParams\n): WaitUntilHealthy => {\n    return new WaitUntilHealthy(client, params);\n};\n"],"names":["WAITING_TIME_STEP","WaitUntilHealthy","client","options","OpenSearchCatHealth","OpenSearchCatNodes","WaitingHealthyClusterAbortedError","startedAt","Date","mustEndAt","waitingTimeStep","runs","waitingReason","UnhealthyClusterError","Promise","resolve","setTimeout","runningTime","health","nodes","ex","createClusterHealthStatusReason","OpenSearchCatClusterHealthStatus","currentStatus","clusterHealthStatus","minClusterHealthStatus","processorPercent","createProcessorReason","undefined","ramPercent","createMemoryReason","total","node","parseFloat","status","createWaitUntilHealthy","params"],"mappings":"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"}

package/utils/waitUntilHealthy/WaitingHealthyClusterAbortedError.d.ts

@@ -0,0 +1,4 @@
+import { WebinyError } from "@webiny/error";
+export declare class WaitingHealthyClusterAbortedError extends WebinyError {
+    constructor(message?: string);
+}

package/utils/waitUntilHealthy/WaitingHealthyClusterAbortedError.js

@@ -0,0 +1,12 @@
+import { WebinyError } from "@webiny/error";
+class WaitingHealthyClusterAbortedError extends WebinyError {
+    constructor(message){
+        super({
+            message: message || "Waiting for the cluster to become healthy was aborted.",
+            code: "WAITING_HEALTHY_CLUSTER_ABORTED"
+        });
+    }
+}
+export { WaitingHealthyClusterAbortedError };
+
+//# sourceMappingURL=WaitingHealthyClusterAbortedError.js.map

package/utils/waitUntilHealthy/WaitingHealthyClusterAbortedError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/waitUntilHealthy/WaitingHealthyClusterAbortedError.js","sources":["../../../src/utils/waitUntilHealthy/WaitingHealthyClusterAbortedError.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\n\nexport class WaitingHealthyClusterAbortedError extends WebinyError {\n    public constructor(message?: string) {\n        super({\n            message: message || `Waiting for the cluster to become healthy was aborted.`,\n            code: \"WAITING_HEALTHY_CLUSTER_ABORTED\"\n        });\n    }\n}\n"],"names":["WaitingHealthyClusterAbortedError","WebinyError","message"],"mappings":";AAEO,MAAMA,0CAA0CC;IACnD,YAAmBC,OAAgB,CAAE;QACjC,KAAK,CAAC;YACF,SAASA,WAAW;YACpB,MAAM;QACV;IACJ;AACJ"}

package/utils/waitUntilHealthy/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./WaitingHealthyClusterAbortedError.js";
+export * from "./UnhealthyClusterError.js";
+export * from "./WaitUntilHealthy.js";
+export * from "./reason/index.js";

package/utils/waitUntilHealthy/index.js

@@ -0,0 +1,4 @@
+export * from "./WaitingHealthyClusterAbortedError.js";
+export * from "./UnhealthyClusterError.js";
+export * from "./WaitUntilHealthy.js";
+export * from "./reason/index.js";

package/utils/waitUntilHealthy/reason/ClusterHealthReason.d.ts

@@ -0,0 +1,15 @@
+import type { OpenSearchCatClusterHealthStatus } from "../../../operations/index.js";
+import type { IReason } from "../../../utils/waitUntilHealthy/reason/IReason.js";
+export interface IClusterHealthReasonParams {
+    minimum: OpenSearchCatClusterHealthStatus;
+    current: OpenSearchCatClusterHealthStatus;
+    description?: string;
+}
+export declare class ClusterHealthReason implements IReason {
+    readonly name = "clusterHealth";
+    readonly minimum: OpenSearchCatClusterHealthStatus;
+    readonly current: OpenSearchCatClusterHealthStatus;
+    readonly description?: string;
+    constructor(params: IClusterHealthReasonParams);
+}
+export declare const createClusterHealthStatusReason: (params: IClusterHealthReasonParams) => ClusterHealthReason;

package/utils/waitUntilHealthy/reason/ClusterHealthReason.js

@@ -0,0 +1,12 @@
+class ClusterHealthReason {
+    constructor(params){
+        this.name = "clusterHealth";
+        this.minimum = params.minimum;
+        this.current = params.current;
+        this.description = params.description;
+    }
+}
+const createClusterHealthStatusReason = (params)=>new ClusterHealthReason(params);
+export { ClusterHealthReason, createClusterHealthStatusReason };
+
+//# sourceMappingURL=ClusterHealthReason.js.map

package/utils/waitUntilHealthy/reason/ClusterHealthReason.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/waitUntilHealthy/reason/ClusterHealthReason.js","sources":["../../../../src/utils/waitUntilHealthy/reason/ClusterHealthReason.ts"],"sourcesContent":["import type { OpenSearchCatClusterHealthStatus } from \"~/operations/index.js\";\nimport type { IReason } from \"~/utils/waitUntilHealthy/reason/IReason.js\";\n\nexport interface IClusterHealthReasonParams {\n    minimum: OpenSearchCatClusterHealthStatus;\n    current: OpenSearchCatClusterHealthStatus;\n    description?: string;\n}\n\nexport class ClusterHealthReason implements IReason {\n    public readonly name = \"clusterHealth\";\n    public readonly minimum: OpenSearchCatClusterHealthStatus;\n    public readonly current: OpenSearchCatClusterHealthStatus;\n    public readonly description?: string;\n\n    public constructor(params: IClusterHealthReasonParams) {\n        this.minimum = params.minimum;\n        this.current = params.current;\n        this.description = params.description;\n    }\n}\n\nexport const createClusterHealthStatusReason = (\n    params: IClusterHealthReasonParams\n): ClusterHealthReason => {\n    return new ClusterHealthReason(params);\n};\n"],"names":["ClusterHealthReason","params","createClusterHealthStatusReason"],"mappings":"AASO,MAAMA;IAMT,YAAmBC,MAAkC,CAAE;aALvC,IAAI,GAAG;QAMnB,IAAI,CAAC,OAAO,GAAGA,OAAO,OAAO;QAC7B,IAAI,CAAC,OAAO,GAAGA,OAAO,OAAO;QAC7B,IAAI,CAAC,WAAW,GAAGA,OAAO,WAAW;IACzC;AACJ;AAEO,MAAMC,kCAAkC,CAC3CD,SAEO,IAAID,oBAAoBC"}

package/utils/waitUntilHealthy/reason/IReason.d.ts

@@ -0,0 +1,4 @@
+export interface IReason {
+    name: string;
+    description?: string;
+}

package/utils/waitUntilHealthy/reason/MemoryReason.d.ts

@@ -0,0 +1,14 @@
+import type { IReason } from "../../../utils/waitUntilHealthy/reason/IReason.js";
+export interface IMemoryReasonParams {
+    maximum: number;
+    current: number;
+    description?: string;
+}
+export declare class MemoryReason implements IReason {
+    readonly name = "memory";
+    readonly maximum: number;
+    readonly current: number;
+    readonly description?: string;
+    constructor(params: IMemoryReasonParams);
+}
+export declare const createMemoryReason: (params: IMemoryReasonParams) => MemoryReason;

package/utils/waitUntilHealthy/reason/MemoryReason.js

@@ -0,0 +1,12 @@
+class MemoryReason {
+    constructor(params){
+        this.name = "memory";
+        this.maximum = params.maximum;
+        this.current = params.current;
+        this.description = params.description;
+    }
+}
+const createMemoryReason = (params)=>new MemoryReason(params);
+export { MemoryReason, createMemoryReason };
+
+//# sourceMappingURL=MemoryReason.js.map

package/utils/waitUntilHealthy/reason/MemoryReason.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/waitUntilHealthy/reason/MemoryReason.js","sources":["../../../../src/utils/waitUntilHealthy/reason/MemoryReason.ts"],"sourcesContent":["import type { IReason } from \"~/utils/waitUntilHealthy/reason/IReason.js\";\n\nexport interface IMemoryReasonParams {\n    maximum: number;\n    current: number;\n    description?: string;\n}\n\nexport class MemoryReason implements IReason {\n    public readonly name = \"memory\";\n    public readonly maximum: number;\n    public readonly current: number;\n    public readonly description?: string;\n\n    public constructor(params: IMemoryReasonParams) {\n        this.maximum = params.maximum;\n        this.current = params.current;\n        this.description = params.description;\n    }\n}\n\nexport const createMemoryReason = (params: IMemoryReasonParams): MemoryReason => {\n    return new MemoryReason(params);\n};\n"],"names":["MemoryReason","params","createMemoryReason"],"mappings":"AAQO,MAAMA;IAMT,YAAmBC,MAA2B,CAAE;aALhC,IAAI,GAAG;QAMnB,IAAI,CAAC,OAAO,GAAGA,OAAO,OAAO;QAC7B,IAAI,CAAC,OAAO,GAAGA,OAAO,OAAO;QAC7B,IAAI,CAAC,WAAW,GAAGA,OAAO,WAAW;IACzC;AACJ;AAEO,MAAMC,qBAAqB,CAACD,SACxB,IAAID,aAAaC"}

package/utils/waitUntilHealthy/reason/ProcessorReason.d.ts

@@ -0,0 +1,14 @@
+import type { IReason } from "../../../utils/waitUntilHealthy/reason/IReason.js";
+export interface IProcessorReasonParams {
+    maximum: number;
+    current: number;
+    description?: string;
+}
+export declare class ProcessorReason implements IReason {
+    readonly name = "processor";
+    readonly maximum: number;
+    readonly current: number;
+    readonly description?: string;
+    constructor(params: IProcessorReasonParams);
+}
+export declare const createProcessorReason: (params: IProcessorReasonParams) => ProcessorReason;

package/utils/waitUntilHealthy/reason/ProcessorReason.js

@@ -0,0 +1,12 @@
+class ProcessorReason {
+    constructor(params){
+        this.name = "processor";
+        this.maximum = params.maximum;
+        this.current = params.current;
+        this.description = params.description;
+    }
+}
+const createProcessorReason = (params)=>new ProcessorReason(params);
+export { ProcessorReason, createProcessorReason };
+
+//# sourceMappingURL=ProcessorReason.js.map

package/utils/waitUntilHealthy/reason/ProcessorReason.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/waitUntilHealthy/reason/ProcessorReason.js","sources":["../../../../src/utils/waitUntilHealthy/reason/ProcessorReason.ts"],"sourcesContent":["import type { IReason } from \"~/utils/waitUntilHealthy/reason/IReason.js\";\n\nexport interface IProcessorReasonParams {\n    maximum: number;\n    current: number;\n    description?: string;\n}\n\nexport class ProcessorReason implements IReason {\n    public readonly name = \"processor\";\n    public readonly maximum: number;\n    public readonly current: number;\n    public readonly description?: string;\n\n    public constructor(params: IProcessorReasonParams) {\n        this.maximum = params.maximum;\n        this.current = params.current;\n        this.description = params.description;\n    }\n}\n\nexport const createProcessorReason = (params: IProcessorReasonParams): ProcessorReason => {\n    return new ProcessorReason(params);\n};\n"],"names":["ProcessorReason","params","createProcessorReason"],"mappings":"AAQO,MAAMA;IAMT,YAAmBC,MAA8B,CAAE;aALnC,IAAI,GAAG;QAMnB,IAAI,CAAC,OAAO,GAAGA,OAAO,OAAO;QAC7B,IAAI,CAAC,OAAO,GAAGA,OAAO,OAAO;QAC7B,IAAI,CAAC,WAAW,GAAGA,OAAO,WAAW;IACzC;AACJ;AAEO,MAAMC,wBAAwB,CAACD,SAC3B,IAAID,gBAAgBC"}

package/utils/waitUntilHealthy/reason/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ClusterHealthReason.js";
+export * from "./MemoryReason.js";
+export * from "./ProcessorReason.js";

package/utils/waitUntilHealthy/reason/index.js

@@ -0,0 +1,3 @@
+export * from "./ClusterHealthReason.js";
+export * from "./MemoryReason.js";
+export * from "./ProcessorReason.js";

package/where.d.ts

@@ -0,0 +1,17 @@
+import type { OpenSearchBoolQueryConfig } from "./types.js";
+import { OpenSearchField } from "./features/OpenSearchField/abstractions/OpenSearchField.js";
+import type { OpenSearchQueryBuilderOperator } from "./features/OpenSearchQueryBuilderOperator/abstractions/OpenSearchQueryBuilderOperator.js";
+type Records<T> = Record<string, T>;
+export interface ApplyWhereParams {
+    query: OpenSearchBoolQueryConfig;
+    where: Records<any>;
+    fields: Records<OpenSearchField.Interface>;
+    operators: Records<OpenSearchQueryBuilderOperator.Interface>;
+}
+export interface ParseWhereKeyResult {
+    field: string;
+    operator: string;
+}
+export declare const parseWhereKey: (key: string) => ParseWhereKeyResult;
+export declare const applyWhere: (params: ApplyWhereParams) => void;
+export {};

package/where.js

@@ -0,0 +1,49 @@
+import { OpenSearchFieldAll } from "./features/OpenSearchField/abstractions/OpenSearchField.js";
+import error from "@webiny/error";
+const parseWhereKeyRegExp = new RegExp(/^((?:wbyAco_)?[a-zA-Z0-9]+)(_[a-zA-Z0-9_]+)?$/);
+const parseWhereKey = (key)=>{
+    const match = key.match(parseWhereKeyRegExp);
+    if (!match) throw new Error(`It is not possible to search by key "${key}"`);
+    const [, field, operation = "eq"] = match;
+    if (!field.match(/^(?:wbyAco_)?([a-zA-Z0-9]+)$/)) throw new Error(`Cannot filter by "${field}".`);
+    const operator = operation.match(/^_/) ? operation.slice(1) : operation;
+    return {
+        field,
+        operator
+    };
+};
+const ALL = OpenSearchFieldAll;
+const applyWhere = (params)=>{
+    const { query, where, fields, operators } = params;
+    for(const key in where){
+        if (false === where.hasOwnProperty(key)) continue;
+        const initialValue = where[key];
+        if (void 0 === initialValue) continue;
+        const { field, operator } = parseWhereKey(key);
+        const fieldPlugin = fields[field] || fields[ALL];
+        if (!fieldPlugin) throw new error(`Missing plugin for the field "${field}".`, "PLUGIN_WHERE_ERROR", {
+            field
+        });
+        const operatorInstance = operators[operator];
+        if (!operatorInstance) throw new error(`Missing plugin for the operator "${operator}"`, "PLUGIN_WHERE_ERROR", {
+            operator
+        });
+        const path = fieldPlugin.getPath(field);
+        const basePath = fieldPlugin.getBasePath(field);
+        const value = fieldPlugin.toSearchValue({
+            value: initialValue,
+            path,
+            basePath
+        });
+        operatorInstance.apply(query, {
+            name: field,
+            value,
+            path,
+            basePath,
+            keyword: fieldPlugin.keyword
+        });
+    }
+};
+export { applyWhere, parseWhereKey };
+
+//# sourceMappingURL=where.js.map

package/where.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"where.js","sources":["../src/where.ts"],"sourcesContent":["import type { OpenSearchBoolQueryConfig } from \"~/types.js\";\nimport {\n    OpenSearchField,\n    OpenSearchFieldAll\n} from \"~/features/OpenSearchField/abstractions/OpenSearchField.js\";\nimport type { OpenSearchQueryBuilderOperator } from \"~/features/OpenSearchQueryBuilderOperator/abstractions/OpenSearchQueryBuilderOperator.js\";\nimport WebinyError from \"@webiny/error\";\n\ntype Records<T> = Record<string, T>;\n\nexport interface ApplyWhereParams {\n    query: OpenSearchBoolQueryConfig;\n    where: Records<any>;\n    fields: Records<OpenSearchField.Interface>;\n    operators: Records<OpenSearchQueryBuilderOperator.Interface>;\n}\n\nexport interface ParseWhereKeyResult {\n    field: string;\n    operator: string;\n}\n\nconst parseWhereKeyRegExp = new RegExp(/^((?:wbyAco_)?[a-zA-Z0-9]+)(_[a-zA-Z0-9_]+)?$/);\n\nexport const parseWhereKey = (key: string): ParseWhereKeyResult => {\n    const match = key.match(parseWhereKeyRegExp);\n\n    if (!match) {\n        throw new Error(`It is not possible to search by key \"${key}\"`);\n    }\n\n    const [, field, operation = \"eq\"] = match;\n\n    if (!field.match(/^(?:wbyAco_)?([a-zA-Z0-9]+)$/)) {\n        throw new Error(`Cannot filter by \"${field}\".`);\n    }\n\n    const operator = operation.match(/^_/) ? operation.slice(1) : operation;\n\n    return { field, operator };\n};\n\nconst ALL = OpenSearchFieldAll;\n\nexport const applyWhere = (params: ApplyWhereParams): void => {\n    const { query, where, fields, operators } = params;\n\n    for (const key in where) {\n        if (where.hasOwnProperty(key) === false) {\n            continue;\n        }\n        const initialValue = where[key];\n        if (initialValue === undefined) {\n            continue;\n        }\n        const { field, operator } = parseWhereKey(key);\n        const fieldPlugin: OpenSearchField.Interface = fields[field] || fields[ALL];\n        if (!fieldPlugin) {\n            throw new WebinyError(\n                `Missing plugin for the field \"${field}\".`,\n                \"PLUGIN_WHERE_ERROR\",\n                {\n                    field\n                }\n            );\n        }\n        const operatorInstance = operators[operator];\n        if (!operatorInstance) {\n            throw new WebinyError(\n                `Missing plugin for the operator \"${operator}\"`,\n                \"PLUGIN_WHERE_ERROR\",\n                {\n                    operator\n                }\n            );\n        }\n\n        const path = fieldPlugin.getPath(field);\n        const basePath = fieldPlugin.getBasePath(field);\n        const value = fieldPlugin.toSearchValue({\n            value: initialValue,\n            path,\n            basePath\n        });\n\n        operatorInstance.apply(query, {\n            name: field,\n            value,\n            path,\n            basePath,\n            keyword: fieldPlugin.keyword\n        });\n    }\n};\n"],"names":["parseWhereKeyRegExp","RegExp","parseWhereKey","key","match","Error","field","operation","operator","ALL","OpenSearchFieldAll","applyWhere","params","query","where","fields","operators","initialValue","undefined","fieldPlugin","WebinyError","operatorInstance","path","basePath","value"],"mappings":";;AAsBA,MAAMA,sBAAsB,IAAIC,OAAO;AAEhC,MAAMC,gBAAgB,CAACC;IAC1B,MAAMC,QAAQD,IAAI,KAAK,CAACH;IAExB,IAAI,CAACI,OACD,MAAM,IAAIC,MAAM,CAAC,qCAAqC,EAAEF,IAAI,CAAC,CAAC;IAGlE,MAAM,GAAGG,OAAOC,YAAY,IAAI,CAAC,GAAGH;IAEpC,IAAI,CAACE,MAAM,KAAK,CAAC,iCACb,MAAM,IAAID,MAAM,CAAC,kBAAkB,EAAEC,MAAM,EAAE,CAAC;IAGlD,MAAME,WAAWD,UAAU,KAAK,CAAC,QAAQA,UAAU,KAAK,CAAC,KAAKA;IAE9D,OAAO;QAAED;QAAOE;IAAS;AAC7B;AAEA,MAAMC,MAAMC;AAEL,MAAMC,aAAa,CAACC;IACvB,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAEC,MAAM,EAAEC,SAAS,EAAE,GAAGJ;IAE5C,IAAK,MAAMT,OAAOW,MAAO;QACrB,IAAIA,AAA8B,UAA9BA,MAAM,cAAc,CAACX,MACrB;QAEJ,MAAMc,eAAeH,KAAK,CAACX,IAAI;QAC/B,IAAIc,AAAiBC,WAAjBD,cACA;QAEJ,MAAM,EAAEX,KAAK,EAAEE,QAAQ,EAAE,GAAGN,cAAcC;QAC1C,MAAMgB,cAAyCJ,MAAM,CAACT,MAAM,IAAIS,MAAM,CAACN,IAAI;QAC3E,IAAI,CAACU,aACD,MAAM,IAAIC,MACN,CAAC,8BAA8B,EAAEd,MAAM,EAAE,CAAC,EAC1C,sBACA;YACIA;QACJ;QAGR,MAAMe,mBAAmBL,SAAS,CAACR,SAAS;QAC5C,IAAI,CAACa,kBACD,MAAM,IAAID,MACN,CAAC,iCAAiC,EAAEZ,SAAS,CAAC,CAAC,EAC/C,sBACA;YACIA;QACJ;QAIR,MAAMc,OAAOH,YAAY,OAAO,CAACb;QACjC,MAAMiB,WAAWJ,YAAY,WAAW,CAACb;QACzC,MAAMkB,QAAQL,YAAY,aAAa,CAAC;YACpC,OAAOF;YACPK;YACAC;QACJ;QAEAF,iBAAiB,KAAK,CAACR,OAAO;YAC1B,MAAMP;YACNkB;YACAF;YACAC;YACA,SAASJ,YAAY,OAAO;QAChC;IACJ;AACJ"}