@webiny/api-opensearch 6.3.0 → 6.4.0-beta.0

package/utils/createIndex.js

@@ -1,88 +1,66 @@
 import { getLastAddedIndexPlugin } from "../indices.js";
-import WebinyError from "@webiny/error";
-const indexExists = async params => {
-  const {
-    client,
-    index,
-    onExists
-  } = 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;
+import _webiny_error from "@webiny/error";
+const indexExists = async (params)=>{
+    const { client, index, onExists } = 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;
+        if (onExists) onExists();
+        return true;
+    } catch  {
+        console.error(`Could not determine if the index "${index}" exists.`);
     }
-    if (onExists) {
-      onExists();
+    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
+        });
     }
-    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
-      }
+const createIndex = async (params)=>{
+    const { plugins, type, onExists } = params;
+    const plugin = getLastAddedIndexPlugin({
+        container: plugins,
+        type
     });
-  } catch (ex) {
-    let error = ex;
-    if (onError) {
-      error = onError(ex);
+    const exists = await indexExists(params);
+    if (exists) {
+        if (onExists) onExists();
+        return;
     }
-    throw new WebinyError(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
+    await indexCreate({
+        ...params,
+        plugin
     });
-  }
-};
-export const createIndex = async params => {
-  const {
-    plugins,
-    type,
-    onExists
-  } = params;
-  const plugin = getLastAddedIndexPlugin({
-    container: plugins,
-    type
-  });
-  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

@@ -1 +1 @@
-{"version":3,"names":["getLastAddedIndexPlugin","WebinyError","indexExists","params","client","index","onExists","response","indices","exists","ignore_unavailable","allow_no_indices","include_defaults","flat_settings","local","body","console","error","indexCreate","plugin","tenant","type","onError","create","ex","message","code","data","createIndex","plugins","container"],"sources":["createIndex.ts"],"sourcesContent":["import type { Client } from \"~/client.js\";\nimport type { PluginsContainer } from \"@webiny/plugins\";\nimport { getLastAddedIndexPlugin } from \"~/indices.js\";\nimport type { OpenSearchIndexPlugin } from \"~/plugins/index.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    onExists?: OnExists;\n}\n\nconst indexExists = async (params: ExistsIndexParams): Promise<boolean> => {\n    const { client, index, onExists } = 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        if (onExists) {\n            onExists();\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: OpenSearchIndexPlugin;\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    plugins: PluginsContainer;\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 { plugins, type, onExists } = params;\n    const plugin = getLastAddedIndexPlugin<OpenSearchIndexPlugin>({\n        container: plugins,\n        type\n    });\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"],"mappings":"AAEA,SAASA,uBAAuB;AAEhC,OAAOC,WAAW,MAAM,eAAe;AAgBvC,MAAMC,WAAW,GAAG,MAAOC,MAAyB,IAAuB;EACvE,MAAM;IAAEC,MAAM;IAAEC,KAAK;IAAEC;EAAS,CAAC,GAAGH,MAAM;EAE1C,IAAI;IACA,MAAMI,QAAQ,GAAG,MAAMH,MAAM,CAACI,OAAO,CAACC,MAAM,CAAC;MACzCJ,KAAK;MACLK,kBAAkB,EAAE,KAAK;MACzBC,gBAAgB,EAAE,IAAI;MACtBC,gBAAgB,EAAE,IAAI;MACtBC,aAAa,EAAE,KAAK;MACpBC,KAAK,EAAE;IACX,CAAC,CAAC;IACF,IAAI,CAACP,QAAQ,CAACQ,IAAI,EAAE;MAChB,OAAO,KAAK;IAChB;IACA,IAAIT,QAAQ,EAAE;MACVA,QAAQ,CAAC,CAAC;IACd;IACA,OAAO,IAAI;EACf,CAAC,CAAC,MAAM;IACJU,OAAO,CAACC,KAAK,CAAC,qCAAqCZ,KAAK,WAAW,CAAC;EACxE;EACA,OAAO,KAAK;AAChB,CAAC;AAWD,MAAMa,WAAW,GAAG,MAAOf,MAAyB,IAAoB;EACpE,MAAM;IAAEC,MAAM;IAAEC,KAAK;IAAEc,MAAM;IAAEC,MAAM;IAAEC,IAAI;IAAEC;EAAQ,CAAC,GAAGnB,MAAM;EAE/D,IAAI;IACA,MAAMC,MAAM,CAACI,OAAO,CAACe,MAAM,CAAC;MACxBlB,KAAK;MACLU,IAAI,EAAE;QACF,GAAGI,MAAM,CAACJ;MACd;IACJ,CAAC,CAAC;EACN,CAAC,CAAC,OAAOS,EAAE,EAAE;IACT,IAAIP,KAAK,GAAGO,EAAE;IACd,IAAIF,OAAO,EAAE;MACTL,KAAK,GAAGK,OAAO,CAACE,EAAE,CAAC;IACvB;IACA,MAAM,IAAIvB,WAAW,CACjBgB,KAAK,CAACQ,OAAO,IAAI,6CAA6CJ,IAAI,GAAG,EACrEJ,KAAK,CAACS,IAAI,IAAI,+BAA+B,EAC7C;MACIT,KAAK,EAAE;QACH,GAAGA,KAAK;QACRQ,OAAO,EAAER,KAAK,CAACQ,OAAO;QACtBC,IAAI,EAAET,KAAK,CAACS,IAAI;QAChBC,IAAI,EAAEV,KAAK,CAACU;MAChB,CAAC;MACDN,IAAI;MACJD,MAAM;MACNf,KAAK;MACLU,IAAI,EAAEI,MAAM,CAACJ;IACjB,CACJ,CAAC;EACL;AACJ,CAAC;AAYD,OAAO,MAAMa,WAAW,GAAG,MAAOzB,MAAyB,IAAoB;EAC3E,MAAM;IAAE0B,OAAO;IAAER,IAAI;IAAEf;EAAS,CAAC,GAAGH,MAAM;EAC1C,MAAMgB,MAAM,GAAGnB,uBAAuB,CAAwB;IAC1D8B,SAAS,EAAED,OAAO;IAClBR;EACJ,CAAC,CAAC;EAEF,MAAMZ,MAAM,GAAG,MAAMP,WAAW,CAACC,MAAM,CAAC;EACxC,IAAIM,MAAM,EAAE;IACR,IAAIH,QAAQ,EAAE;MACVA,QAAQ,CAAC,CAAC;IACd;IACA;EACJ;EAEA,MAAMY,WAAW,CAAC;IACd,GAAGf,MAAM;IACTgB;EACJ,CAAC,CAAC;AACN,CAAC","ignoreList":[]}
+{"version":3,"file":"utils/createIndex.js","sources":["../../src/utils/createIndex.ts"],"sourcesContent":["import type { Client } from \"~/client.js\";\nimport type { PluginsContainer } from \"@webiny/plugins\";\nimport { getLastAddedIndexPlugin } from \"~/indices.js\";\nimport type { OpenSearchIndexPlugin } from \"~/plugins/index.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    onExists?: OnExists;\n}\n\nconst indexExists = async (params: ExistsIndexParams): Promise<boolean> => {\n    const { client, index, onExists } = 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        if (onExists) {\n            onExists();\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: OpenSearchIndexPlugin;\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    plugins: PluginsContainer;\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 { plugins, type, onExists } = params;\n    const plugin = getLastAddedIndexPlugin<OpenSearchIndexPlugin>({\n        container: plugins,\n        type\n    });\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","onExists","response","console","indexCreate","plugin","tenant","type","onError","ex","error","WebinyError","createIndex","plugins","getLastAddedIndexPlugin","exists"],"mappings":";;AAoBA,MAAMA,cAAc,OAAOC;IACvB,MAAM,EAAEC,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAE,GAAGH;IAEpC,IAAI;QACA,MAAMI,WAAW,MAAMH,OAAO,OAAO,CAAC,MAAM,CAAC;YACzCC;YACA,oBAAoB;YACpB,kBAAkB;YAClB,kBAAkB;YAClB,eAAe;YACf,OAAO;QACX;QACA,IAAI,CAACE,SAAS,IAAI,EACd,OAAO;QAEX,IAAID,UACAA;QAEJ,OAAO;IACX,EAAE,OAAM;QACJE,QAAQ,KAAK,CAAC,CAAC,kCAAkC,EAAEH,MAAM,SAAS,CAAC;IACvE;IACA,OAAO;AACX;AAWA,MAAMI,cAAc,OAAON;IACvB,MAAM,EAAEC,MAAM,EAAEC,KAAK,EAAEK,MAAM,EAAEC,MAAM,EAAEC,IAAI,EAAEC,OAAO,EAAE,GAAGV;IAEzD,IAAI;QACA,MAAMC,OAAO,OAAO,CAAC,MAAM,CAAC;YACxBC;YACA,MAAM;gBACF,GAAGK,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;YACAN;YACA,MAAMK,OAAO,IAAI;QACrB;IAER;AACJ;AAYO,MAAMO,cAAc,OAAOd;IAC9B,MAAM,EAAEe,OAAO,EAAEN,IAAI,EAAEN,QAAQ,EAAE,GAAGH;IACpC,MAAMO,SAASS,wBAA+C;QAC1D,WAAWD;QACXN;IACJ;IAEA,MAAMQ,SAAS,MAAMlB,YAAYC;IACjC,IAAIiB,QAAQ;QACR,IAAId,UACAA;QAEJ;IACJ;IAEA,MAAMG,YAAY;QACd,GAAGN,MAAM;QACTO;IACJ;AACJ"}

package/utils/index.js

@@ -1,4 +1,2 @@
 export * from "./waitUntilHealthy/index.js";
 export * from "./createIndex.js";
-
-//# sourceMappingURL=index.js.map

package/utils/waitUntilHealthy/UnhealthyClusterError.js

@@ -1,11 +1,12 @@
 import { WebinyError } from "@webiny/error";
-export class UnhealthyClusterError extends WebinyError {
-  constructor(maxWaitingTime) {
-    super({
-      message: `Cluster did not become healthy in ${maxWaitingTime} seconds.`,
-      code: "UNHEALTHY_CLUSTER"
-    });
-  }
+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

@@ -1 +1 @@
-{"version":3,"names":["WebinyError","UnhealthyClusterError","constructor","maxWaitingTime","message","code"],"sources":["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"],"mappings":"AAAA,SAASA,WAAW,QAAQ,eAAe;AAE3C,OAAO,MAAMC,qBAAqB,SAASD,WAAW,CAAC;EAC5CE,WAAWA,CAACC,cAAsB,EAAE;IACvC,KAAK,CAAC;MACFC,OAAO,EAAE,qCAAqCD,cAAc,WAAW;MACvEE,IAAI,EAAE;IACV,CAAC,CAAC;EACN;AACJ","ignoreList":[]}
+{"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.js

@@ -6,156 +6,126 @@ import { createClusterHealthStatusReason, createMemoryReason, createProcessorRea
 import { WaitingHealthyClusterAbortedError } from "./WaitingHealthyClusterAbortedError.js";
 const WAITING_TIME_STEP = 10;
 class WaitUntilHealthy {
-  aborted = false;
-  constructor(client, options) {
-    this.client = client;
-    this.options = options;
-    this.catHealth = new OpenSearchCatHealth(this.client);
-    this.catNodes = new OpenSearchCatNodes(this.client);
-  }
-  abort() {
-    this.aborted = true;
-  }
-  /**
-   * @throws UnhealthyClusterError
-   * @throws WaitingHealthyClusterAbortedError
-   */
-  async wait(options) {
-    if (this.aborted) {
-      throw new WaitingHealthyClusterAbortedError(`Waiting for the cluster to become healthy was aborted even before it started.`);
+    constructor(client, options){
+        this.aborted = false;
+        this.client = client;
+        this.options = options;
+        this.catHealth = new OpenSearchCatHealth(this.client);
+        this.catNodes = new OpenSearchCatNodes(this.client);
     }
-    const startedAt = new Date();
-    const mustEndAt = new Date(startedAt.getTime() + this.options.maxWaitingTime * 1000);
-    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,
+    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);
+            }
+            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
+            });
         }
-        throw new UnhealthyClusterError(this.options.maxWaitingTime);
-      } else if (options?.onUnhealthy) {
-        await options.onUnhealthy({
-          startedAt,
-          mustEndAt,
-          waitingTimeStep,
-          waitingReason,
-          runs
+        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
         });
-      }
-      /**
-       * Abort check is separated from other IFs because it can be aborted in onUnhealthy callback.
-       */
-      if (this.aborted) {
-        throw new WaitingHealthyClusterAbortedError();
-      }
-      runs++;
-      await new Promise(resolve => {
-        setTimeout(resolve, waitingTimeStep * 1000);
-      });
-    }
-    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
-      });
+        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;
     }
-    /**
-     * Possibly no max ram definition?
-     */
-    if (this.options.maxRamPercent === undefined) {
-      return false;
+    getProcessorPercent(nodes) {
+        const total = nodes.reduce((total, node)=>total + parseFloat(node.cpu || "0"), 0);
+        return total / nodes.length;
     }
-    const ramPercent = this.getRamPercent(nodes);
-    if (ramPercent > this.options.maxRamPercent) {
-      return createMemoryReason({
-        maximum: this.options.maxRamPercent,
-        current: ramPercent
-      });
+    getRamPercent(nodes) {
+        const total = nodes.reduce((total, node)=>total + parseFloat(node["ram.percent"] || "0"), 0);
+        return total / nodes.length;
     }
-    return false;
-  }
-  getProcessorPercent(nodes) {
-    const total = nodes.reduce((total, node) => {
-      return total + parseFloat(node.cpu || "0");
-    }, 0);
-    return total / nodes.length;
-  }
-  getRamPercent(nodes) {
-    const total = nodes.reduce((total, node) => {
-      return 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;
+    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;
+    transformClusterHealthStatus(status) {
+        switch(status){
+            case OpenSearchCatClusterHealthStatus.Green:
+                return 1;
+            case OpenSearchCatClusterHealthStatus.Yellow:
+                return 2;
+            case OpenSearchCatClusterHealthStatus.Red:
+                return 3;
+            default:
+                return 99;
+        }
     }
-  }
 }
-export const createWaitUntilHealthy = (client, params) => {
-  return new WaitUntilHealthy(client, params);
-};
+const createWaitUntilHealthy = (client, params)=>new WaitUntilHealthy(client, params);
+export { createWaitUntilHealthy };
 
 //# sourceMappingURL=WaitUntilHealthy.js.map

package/utils/waitUntilHealthy/WaitUntilHealthy.js.map

@@ -1 +1 @@
-{"version":3,"names":["OpenSearchCatHealth","OpenSearchCatNodes","OpenSearchCatClusterHealthStatus","UnhealthyClusterError","createClusterHealthStatusReason","createMemoryReason","createProcessorReason","WaitingHealthyClusterAbortedError","WAITING_TIME_STEP","WaitUntilHealthy","aborted","constructor","client","options","catHealth","catNodes","abort","wait","startedAt","Date","mustEndAt","getTime","maxWaitingTime","waitingTimeStep","runs","waitingReason","shouldWait","onTimeout","onUnhealthy","Promise","resolve","setTimeout","runningTime","health","nodes","getHealth","ex","description","message","minimum","minClusterHealthStatus","current","Red","getNodes","currentStatus","toClusterHealthStatus","status","clusterHealthStatus","transformClusterHealthStatus","processorPercent","getProcessorPercent","maxProcessorPercent","maximum","maxRamPercent","undefined","ramPercent","getRamPercent","total","reduce","node","parseFloat","cpu","length","Green","Yellow","createWaitUntilHealthy","params"],"sources":["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"],"mappings":"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","ignoreList":[]}
+{"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.js

@@ -1,11 +1,12 @@
 import { WebinyError } from "@webiny/error";
-export class WaitingHealthyClusterAbortedError extends WebinyError {
-  constructor(message) {
-    super({
-      message: message || `Waiting for the cluster to become healthy was aborted.`,
-      code: "WAITING_HEALTHY_CLUSTER_ABORTED"
-    });
-  }
+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

@@ -1 +1 @@
-{"version":3,"names":["WebinyError","WaitingHealthyClusterAbortedError","constructor","message","code"],"sources":["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"],"mappings":"AAAA,SAASA,WAAW,QAAQ,eAAe;AAE3C,OAAO,MAAMC,iCAAiC,SAASD,WAAW,CAAC;EACxDE,WAAWA,CAACC,OAAgB,EAAE;IACjC,KAAK,CAAC;MACFA,OAAO,EAAEA,OAAO,IAAI,wDAAwD;MAC5EC,IAAI,EAAE;IACV,CAAC,CAAC;EACN;AACJ","ignoreList":[]}
+{"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.js

@@ -2,5 +2,3 @@ export * from "./WaitingHealthyClusterAbortedError.js";
 export * from "./UnhealthyClusterError.js";
 export * from "./WaitUntilHealthy.js";
 export * from "./reason/index.js";
-
-//# sourceMappingURL=index.js.map

package/utils/waitUntilHealthy/reason/ClusterHealthReason.js

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

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

@@ -1 +1 @@
-{"version":3,"names":["ClusterHealthReason","name","constructor","params","minimum","current","description","createClusterHealthStatusReason"],"sources":["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"],"mappings":"AASA,OAAO,MAAMA,mBAAmB,CAAoB;EAChCC,IAAI,GAAG,eAAe;EAK/BC,WAAWA,CAACC,MAAkC,EAAE;IACnD,IAAI,CAACC,OAAO,GAAGD,MAAM,CAACC,OAAO;IAC7B,IAAI,CAACC,OAAO,GAAGF,MAAM,CAACE,OAAO;IAC7B,IAAI,CAACC,WAAW,GAAGH,MAAM,CAACG,WAAW;EACzC;AACJ;AAEA,OAAO,MAAMC,+BAA+B,GACxCJ,MAAkC,IACZ;EACtB,OAAO,IAAIH,mBAAmB,CAACG,MAAM,CAAC;AAC1C,CAAC","ignoreList":[]}
+{"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.js

@@ -1,3 +0,0 @@
-export {};
-
-//# sourceMappingURL=IReason.js.map