@webiny/api-elasticsearch 0.0.0-mt-3 → 0.0.0-unstable.06b2ede40f

package/types.js

@@ -3,11 +3,20 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-
+var _exportNames = {
+  ApiResponse: true
+};
+Object.defineProperty(exports, "ApiResponse", {
+  enumerable: true,
+  get: function () {
+    return _elasticsearch.ApiResponse;
+  }
+});
+var _elasticsearch = require("@elastic/elasticsearch");
 var _elasticTs = require("elastic-ts");
-
 Object.keys(_elasticTs).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   if (key in exports && exports[key] === _elasticTs[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
@@ -15,4 +24,6 @@ Object.keys(_elasticTs).forEach(function (key) {
       return _elasticTs[key];
     }
   });
-});
+});
+
+//# sourceMappingURL=types.js.map

package/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_elasticsearch","require","_elasticTs","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get"],"sources":["types.ts"],"sourcesContent":["import type { Client } from \"@elastic/elasticsearch\";\nimport { ApiResponse } from \"@elastic/elasticsearch\";\nimport type { BoolQueryConfig, PrimitiveValue, Query as esQuery } from \"elastic-ts\";\nimport type { Context, GenericRecord } from \"@webiny/api/types\";\n/**\n * Re-export some dep lib types.\n */\nexport * from \"elastic-ts\";\nexport { ApiResponse };\n\nexport interface ElasticsearchContext extends Context {\n    elasticsearch: Client;\n}\n\n/**\n * To simplify our plugins, we say that query contains arrays of objects, not single objects.\n * And that they all are defined as empty arrays at the start.\n */\nexport interface ElasticsearchBoolQueryConfig extends BoolQueryConfig {\n    must: esQuery[];\n    filter: esQuery[];\n    should: esQuery[];\n    must_not: esQuery[];\n}\n\n/**\n * Definitions of possible Elasticsearch operators.\n *\n * @category Elasticsearch\n */\nexport type ElasticsearchQueryOperator =\n    | \"eq\"\n    | \"not\"\n    | \"in\"\n    | \"not_in\"\n    | \"contains\"\n    | \"not_contains\"\n    | \"between\"\n    | \"not_between\"\n    | \"gt\"\n    | \"gte\"\n    | \"lt\"\n    | \"lte\"\n    | string;\n\n/**\n * Definition for arguments of the ElasticsearchQueryBuilderOperatorPlugin.apply method.\n *\n * @see ElasticsearchQueryBuilderOperatorPlugin.apply\n *\n * @category Plugin\n * @category Elasticsearch\n */\nexport interface ElasticsearchQueryBuilderArgsPlugin {\n    /**\n     * Name of the field.\n     */\n    name: string;\n    /**\n     * A full path to the field. Including the \".keyword\" if it is added.\n     */\n    path: string;\n    /**\n     * A path to the field, plain.\n     */\n    basePath: string;\n    /**\n     * Value to apply.\n     */\n    value: any;\n    /**\n     * Is path containing the \".keyword\"\n     */\n    keyword: boolean;\n}\n\n/**\n * Elasticsearch responses.\n */\nexport interface ElasticsearchSearchResponseHit<T> {\n    _index: string;\n    _type: string;\n    _id: string;\n    _score: number | null;\n    _source: T;\n    sort: PrimitiveValue[];\n}\nexport interface ElasticsearchSearchResponseAggregationBucket<T> {\n    key: T;\n    doc_count: number;\n}\n\nexport interface ElasticsearchSearchResponseBodyHits<T> {\n    hits: ElasticsearchSearchResponseHit<T>[];\n    total: {\n        value: number;\n    };\n}\n\nexport interface ElasticsearchSearchResponseBodyAggregations<T> {\n    [key: string]: {\n        buckets: ElasticsearchSearchResponseAggregationBucket<T>[];\n    };\n}\n\nexport interface ElasticsearchSearchResponseBody<T> {\n    hits: ElasticsearchSearchResponseBodyHits<T>;\n    aggregations: ElasticsearchSearchResponseBodyAggregations<T>;\n}\n\nexport interface ElasticsearchSearchResponse<T = GenericRecord> {\n    body: ElasticsearchSearchResponseBody<T>;\n}\n\nexport interface ElasticsearchIndexRequestBodyMappingsDynamicTemplate {\n    [key: string]: {\n        path_match?: string;\n        path_unmatch?: string;\n        match_mapping_type?: string;\n        match?: string;\n        unmatch?: string;\n        mapping?: {\n            numeric_detection?: boolean;\n            date_detection?: boolean;\n            type?:\n                | \"string\"\n                | \"date\"\n                | \"binary\"\n                | \"boolean\"\n                | \"object\"\n                | \"ip\"\n                | \"geo\"\n                | \"long\"\n                | \"integer\"\n                | \"short\"\n                | \"byte\"\n                | \"double\"\n                | \"float\"\n                | \"half_float\"\n                | \"scaled_float\"\n                | \"unsigned_long\"\n                | string;\n            search_analyzer?: string;\n            analyzer?: string;\n            fields?: {\n                [key: string]:\n                    | {\n                          type: string;\n                          search_analyzer?: string;\n                          analyzer?: string;\n                          ignore_above?: number;\n                          [key: string]: any;\n                      }\n                    | undefined;\n            };\n            [key: string]: any;\n        };\n        [key: string]: any;\n    };\n}\n\nexport interface ElasticsearchIndexRequestBodySettingsTotalFields {\n    limit?: number;\n}\n\ninterface ElasticsearchIndexRequestBodySettings {\n    analysis?: {\n        [key: string]: any;\n    };\n    number_of_shards?: number;\n    number_of_routing_shards?: number;\n    codec?: string;\n    routing_partition_size?: number;\n    soft_deletes?: {\n        enabled?: boolean;\n        retention_lease?: {\n            period?: string;\n        };\n    };\n    load_fixed_bitset_filters_eagerly?: boolean;\n    shard?: {\n        check_on_startup?: boolean | \"checksum\";\n    };\n    number_of_replicas?: number;\n    auto_expand_replicas?: string | \"all\" | false;\n    search?: {\n        idle?: {\n            after?: string;\n        };\n    };\n    refresh_interval?: string;\n    max_result_window?: number;\n    max_inner_result_window?: number;\n    max_rescore_window?: number;\n    max_docvalue_fields_search?: number;\n    max_script_fields?: number;\n    max_ngram_diff?: number;\n    max_shingle_diff?: number;\n    max_refresh_listeners?: number;\n    analyze?: {\n        max_token_count?: number;\n    };\n    highlight?: {\n        max_analyzed_offset?: number;\n    };\n    max_terms_count?: number;\n    max_regex_length?: number;\n    query?: {\n        default_field?: string;\n    };\n    routing?: {\n        allocation?: {\n            enable?: \"all\" | \"primaries\" | \"new_primaries\" | \"none\";\n        };\n        rebalance?: {\n            enable?: \"all\" | \"primaries\" | \"new_primaries\" | \"none\";\n        };\n    };\n    gc_deletes?: string;\n    default_pipeline?: string;\n    final_pipeline?: string;\n    hidden?: boolean;\n    total_fields?: ElasticsearchIndexRequestBodySettingsTotalFields;\n    [key: string]: any;\n}\n\nexport interface ElasticsearchIndexRequestBody {\n    settings?: {\n        index?: Partial<ElasticsearchIndexRequestBodySettings>;\n    };\n    mappings: {\n        numeric_detection?: boolean;\n        dynamic_templates?: ElasticsearchIndexRequestBodyMappingsDynamicTemplate[];\n        properties?: {\n            [key: string]: {\n                analyzer?: string;\n                type?: string;\n                normalizer?: string;\n                index?: string;\n                fields?: {\n                    [key: string]: {\n                        type: string;\n                        ignore_above?: number;\n                        search_analyzer?: string;\n                        analyzer?: string;\n                        [key: string]: any;\n                    };\n                };\n                [key: string]: any;\n            };\n        };\n        [key: string]: any;\n    };\n    aliases?: {\n        [key: string]: {\n            filter?: {\n                [key: string]: any;\n            };\n            index_routing?: string;\n            is_hidden?: boolean;\n            is_write_index?: boolean;\n            routing?: string;\n            search_routing?: string;\n        };\n    };\n}\n"],"mappings":";;;;;;;;;;;;;;AACA,IAAAA,cAAA,GAAAC,OAAA;AAMA,IAAAC,UAAA,GAAAD,OAAA;AAAAE,MAAA,CAAAC,IAAA,CAAAF,UAAA,EAAAG,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAJ,UAAA,CAAAI,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAZ,UAAA,CAAAI,GAAA;IAAA;EAAA;AAAA","ignoreList":[]}

package/utils/createIndex.d.ts

@@ -0,0 +1,20 @@
+import type { Client } from "@elastic/elasticsearch";
+import type { PluginsContainer } from "@webiny/plugins";
+interface OnExists {
+    (): void;
+}
+interface OnError {
+    (ex: Error): Error;
+}
+interface CreateIndexParams {
+    client: Client;
+    plugins: PluginsContainer;
+    type: string;
+    tenant: string;
+    locale: string;
+    index: string;
+    onExists?: OnExists;
+    onError?: OnError;
+}
+export declare const createIndex: (params: CreateIndexParams) => Promise<void>;
+export {};

package/utils/createIndex.js

@@ -0,0 +1,100 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createIndex = void 0;
+var _indices = require("../indices");
+var _error = _interopRequireDefault(require("@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 (ex) {
+    console.error(`Could not determine if the index "${index}" exists.`);
+  }
+  return false;
+};
+const indexCreate = async params => {
+  const {
+    client,
+    index,
+    plugin,
+    tenant,
+    locale,
+    type,
+    onError
+  } = params;
+  try {
+    await client.indices.create({
+      index,
+      body: {
+        ...plugin.body
+      }
+    });
+  } catch (ex) {
+    let error = ex;
+    if (onError) {
+      error = onError(ex);
+    }
+    throw new _error.default(error.message || `Could not create Elasticsearch index for the ${type}.`, error.code || "CREATE_ELASTICSEARCH_INDEX_ERROR", {
+      error: {
+        ...error,
+        message: error.message,
+        code: error.code,
+        data: error.data
+      },
+      type,
+      locale,
+      tenant,
+      index,
+      body: plugin.body
+    });
+  }
+};
+const createIndex = async params => {
+  const {
+    plugins,
+    type,
+    locale,
+    onExists
+  } = params;
+  const plugin = (0, _indices.getLastAddedIndexPlugin)({
+    container: plugins,
+    type,
+    locale
+  });
+  const exists = await indexExists(params);
+  if (exists) {
+    if (onExists) {
+      onExists();
+    }
+    return;
+  }
+  await indexCreate({
+    ...params,
+    plugin
+  });
+};
+exports.createIndex = createIndex;
+
+//# sourceMappingURL=createIndex.js.map

package/utils/createIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_indices","require","_error","_interopRequireDefault","indexExists","params","client","index","onExists","response","indices","exists","ignore_unavailable","allow_no_indices","include_defaults","flat_settings","local","body","ex","console","error","indexCreate","plugin","tenant","locale","type","onError","create","WebinyError","message","code","data","createIndex","plugins","getLastAddedIndexPlugin","container","exports"],"sources":["createIndex.ts"],"sourcesContent":["import type { Client } from \"@elastic/elasticsearch\";\nimport type { PluginsContainer } from \"@webiny/plugins\";\nimport { getLastAddedIndexPlugin } from \"~/indices\";\nimport type { ElasticsearchIndexPlugin } from \"~/plugins\";\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 (ex) {\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    locale: string;\n    plugin: ElasticsearchIndexPlugin;\n    onError?: OnError;\n}\n\nconst indexCreate = async (params: IndexCreateParams): Promise<void> => {\n    const { client, index, plugin, tenant, locale, 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 Elasticsearch index for the ${type}.`,\n            error.code || \"CREATE_ELASTICSEARCH_INDEX_ERROR\",\n            {\n                error: {\n                    ...error,\n                    message: error.message,\n                    code: error.code,\n                    data: error.data\n                },\n                type,\n                locale,\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    locale: string;\n    index: string;\n    onExists?: OnExists;\n    onError?: OnError;\n}\n\nexport const createIndex = async (params: CreateIndexParams): Promise<void> => {\n    const { plugins, type, locale, onExists } = params;\n    const plugin = getLastAddedIndexPlugin<ElasticsearchIndexPlugin>({\n        container: plugins,\n        type,\n        locale\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,IAAAA,QAAA,GAAAC,OAAA;AAEA,IAAAC,MAAA,GAAAC,sBAAA,CAAAF,OAAA;AAgBA,MAAMG,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,OAAOU,EAAE,EAAE;IACTC,OAAO,CAACC,KAAK,CAAC,qCAAqCb,KAAK,WAAW,CAAC;EACxE;EACA,OAAO,KAAK;AAChB,CAAC;AAYD,MAAMc,WAAW,GAAG,MAAOhB,MAAyB,IAAoB;EACpE,MAAM;IAAEC,MAAM;IAAEC,KAAK;IAAEe,MAAM;IAAEC,MAAM;IAAEC,MAAM;IAAEC,IAAI;IAAEC;EAAQ,CAAC,GAAGrB,MAAM;EAEvE,IAAI;IACA,MAAMC,MAAM,CAACI,OAAO,CAACiB,MAAM,CAAC;MACxBpB,KAAK;MACLU,IAAI,EAAE;QACF,GAAGK,MAAM,CAACL;MACd;IACJ,CAAC,CAAC;EACN,CAAC,CAAC,OAAOC,EAAE,EAAE;IACT,IAAIE,KAAK,GAAGF,EAAE;IACd,IAAIQ,OAAO,EAAE;MACTN,KAAK,GAAGM,OAAO,CAACR,EAAE,CAAC;IACvB;IACA,MAAM,IAAIU,cAAW,CACjBR,KAAK,CAACS,OAAO,IAAI,gDAAgDJ,IAAI,GAAG,EACxEL,KAAK,CAACU,IAAI,IAAI,kCAAkC,EAChD;MACIV,KAAK,EAAE;QACH,GAAGA,KAAK;QACRS,OAAO,EAAET,KAAK,CAACS,OAAO;QACtBC,IAAI,EAAEV,KAAK,CAACU,IAAI;QAChBC,IAAI,EAAEX,KAAK,CAACW;MAChB,CAAC;MACDN,IAAI;MACJD,MAAM;MACND,MAAM;MACNhB,KAAK;MACLU,IAAI,EAAEK,MAAM,CAACL;IACjB,CACJ,CAAC;EACL;AACJ,CAAC;AAaM,MAAMe,WAAW,GAAG,MAAO3B,MAAyB,IAAoB;EAC3E,MAAM;IAAE4B,OAAO;IAAER,IAAI;IAAED,MAAM;IAAEhB;EAAS,CAAC,GAAGH,MAAM;EAClD,MAAMiB,MAAM,GAAG,IAAAY,gCAAuB,EAA2B;IAC7DC,SAAS,EAAEF,OAAO;IAClBR,IAAI;IACJD;EACJ,CAAC,CAAC;EAEF,MAAMb,MAAM,GAAG,MAAMP,WAAW,CAACC,MAAM,CAAC;EACxC,IAAIM,MAAM,EAAE;IACR,IAAIH,QAAQ,EAAE;MACVA,QAAQ,CAAC,CAAC;IACd;IACA;EACJ;EAEA,MAAMa,WAAW,CAAC;IACd,GAAGhB,MAAM;IACTiB;EACJ,CAAC,CAAC;AACN,CAAC;AAACc,OAAA,CAAAJ,WAAA,GAAAA,WAAA","ignoreList":[]}

package/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./waitUntilHealthy";
+export * from "./createIndex";
+export * from "./waitUntilHealthy";

package/utils/index.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _waitUntilHealthy = require("./waitUntilHealthy");
+Object.keys(_waitUntilHealthy).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _waitUntilHealthy[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _waitUntilHealthy[key];
+    }
+  });
+});
+var _createIndex = require("./createIndex");
+Object.keys(_createIndex).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _createIndex[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _createIndex[key];
+    }
+  });
+});
+
+//# sourceMappingURL=index.js.map

package/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_waitUntilHealthy","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get","_createIndex"],"sources":["index.ts"],"sourcesContent":["export * from \"./waitUntilHealthy\";\nexport * from \"./createIndex\";\nexport * from \"./waitUntilHealthy\";\n"],"mappings":";;;;;AAAA,IAAAA,iBAAA,GAAAC,OAAA;AAEAC,MAAA,CAAAC,IAAA,CAAAH,iBAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,iBAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAT,iBAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AADA,IAAAK,YAAA,GAAAT,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAO,YAAA,EAAAN,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAK,YAAA,CAAAL,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAC,YAAA,CAAAL,GAAA;IAAA;EAAA;AAAA","ignoreList":[]}

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,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UnhealthyClusterError = void 0;
+var _error = require("@webiny/error");
+class UnhealthyClusterError extends _error.WebinyError {
+  constructor(maxWaitingTime) {
+    super({
+      message: `Cluster did not become healthy in ${maxWaitingTime} seconds.`,
+      code: "UNHEALTHY_CLUSTER"
+    });
+  }
+}
+exports.UnhealthyClusterError = UnhealthyClusterError;
+
+//# sourceMappingURL=UnhealthyClusterError.js.map

package/utils/waitUntilHealthy/UnhealthyClusterError.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_error","require","UnhealthyClusterError","WebinyError","constructor","maxWaitingTime","message","code","exports"],"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,IAAAA,MAAA,GAAAC,OAAA;AAEO,MAAMC,qBAAqB,SAASC,kBAAW,CAAC;EAC5CC,WAAWA,CAACC,cAAsB,EAAE;IACvC,KAAK,CAAC;MACFC,OAAO,EAAE,qCAAqCD,cAAc,WAAW;MACvEE,IAAI,EAAE;IACV,CAAC,CAAC;EACN;AACJ;AAACC,OAAA,CAAAN,qBAAA,GAAAA,qBAAA","ignoreList":[]}

package/utils/waitUntilHealthy/WaitUntilHealthy.d.ts

@@ -0,0 +1,71 @@
+import type { Client } from "../../client";
+import { ElasticsearchCatClusterHealthStatus } from "../../operations/types";
+import type { ClusterHealthReason, MemoryReason, ProcessorReason } from "./reason";
+export type WaitingReason = ProcessorReason | MemoryReason | ClusterHealthReason;
+export interface IWaitUntilHealthyParams {
+    /**
+     * Minimum status allowed, otherwise the cluster is considered unhealthy.
+     */
+    minClusterHealthStatus: ElasticsearchCatClusterHealthStatus.Green | ElasticsearchCatClusterHealthStatus.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 transformClusterHealthStatus;
+}
+export type { WaitUntilHealthy };
+export declare const createWaitUntilHealthy: (client: Client, params: IWaitUntilHealthyParams) => WaitUntilHealthy;

package/utils/waitUntilHealthy/WaitUntilHealthy.js

@@ -0,0 +1,157 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createWaitUntilHealthy = void 0;
+var _ElasticsearchCatHealth = require("../../operations/ElasticsearchCatHealth");
+var _ElasticsearchCatNodes = require("../../operations/ElasticsearchCatNodes");
+var _types = require("../../operations/types");
+var _UnhealthyClusterError = require("./UnhealthyClusterError");
+var _reason = require("./reason");
+var _WaitingHealthyClusterAbortedError = require("./WaitingHealthyClusterAbortedError");
+const WAITING_TIME_STEP = 10;
+class WaitUntilHealthy {
+  aborted = false;
+  constructor(client, options) {
+    this.client = client;
+    this.options = options;
+    this.catHealth = new _ElasticsearchCatHealth.ElasticsearchCatHealth(this.client);
+    this.catNodes = new _ElasticsearchCatNodes.ElasticsearchCatNodes(this.client);
+  }
+  abort() {
+    this.aborted = true;
+  }
+  /**
+   * @throws UnhealthyClusterError
+   * @throws WaitingHealthyClusterAbortedError
+   */
+  async wait(options) {
+    if (this.aborted) {
+      throw new _WaitingHealthyClusterAbortedError.WaitingHealthyClusterAbortedError(`Waiting for the cluster to become healthy was aborted even before it started.`);
+    }
+    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,
+            runs
+          });
+        }
+        throw new _UnhealthyClusterError.UnhealthyClusterError(this.options.maxWaitingTime);
+      } else if (options?.onUnhealthy) {
+        await options.onUnhealthy({
+          startedAt,
+          mustEndAt,
+          waitingTimeStep,
+          waitingReason,
+          runs
+        });
+      }
+      /**
+       * Abort check is separated from other IFs because it can be aborted in onUnhealthy callback.
+       */
+      if (this.aborted) {
+        throw new _WaitingHealthyClusterAbortedError.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 (0, _reason.createClusterHealthStatusReason)({
+        description: ex.message,
+        minimum: this.options.minClusterHealthStatus,
+        current: _types.ElasticsearchCatClusterHealthStatus.Red
+      });
+    }
+    try {
+      nodes = await this.catNodes.getNodes();
+    } catch (ex) {
+      return (0, _reason.createClusterHealthStatusReason)({
+        description: ex.message,
+        minimum: this.options.minClusterHealthStatus,
+        current: _types.ElasticsearchCatClusterHealthStatus.Red
+      });
+    }
+    const clusterHealthStatus = this.transformClusterHealthStatus(health.status);
+    const minClusterHealthStatus = this.transformClusterHealthStatus(this.options.minClusterHealthStatus);
+    if (clusterHealthStatus > minClusterHealthStatus) {
+      return (0, _reason.createClusterHealthStatusReason)({
+        minimum: this.options.minClusterHealthStatus,
+        current: health.status
+      });
+    }
+    const processorPercent = this.getProcessorPercent(nodes);
+    if (processorPercent > this.options.maxProcessorPercent) {
+      return (0, _reason.createProcessorReason)({
+        maximum: this.options.maxProcessorPercent,
+        current: processorPercent
+      });
+    }
+    /**
+     * Possibly no max ram definition?
+     */
+    if (this.options.maxRamPercent === undefined) {
+      return false;
+    }
+    const ramPercent = this.getRamPercent(nodes);
+    if (ramPercent > this.options.maxRamPercent) {
+      return (0, _reason.createMemoryReason)({
+        maximum: this.options.maxRamPercent,
+        current: ramPercent
+      });
+    }
+    return false;
+  }
+  getProcessorPercent(nodes) {
+    const total = nodes.reduce((total, node) => {
+      return total + parseFloat(node.cpu);
+    }, 0);
+    return total / nodes.length;
+  }
+  getRamPercent(nodes) {
+    const total = nodes.reduce((total, node) => {
+      return total + parseFloat(node["ram.percent"]);
+    }, 0);
+    return total / nodes.length;
+  }
+  transformClusterHealthStatus(status) {
+    switch (status) {
+      case _types.ElasticsearchCatClusterHealthStatus.Green:
+        return 1;
+      case _types.ElasticsearchCatClusterHealthStatus.Yellow:
+        return 2;
+      case _types.ElasticsearchCatClusterHealthStatus.Red:
+        return 3;
+      default:
+        return 99;
+    }
+  }
+}
+const createWaitUntilHealthy = (client, params) => {
+  return new WaitUntilHealthy(client, params);
+};
+exports.createWaitUntilHealthy = createWaitUntilHealthy;
+
+//# sourceMappingURL=WaitUntilHealthy.js.map

package/utils/waitUntilHealthy/WaitUntilHealthy.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_ElasticsearchCatHealth","require","_ElasticsearchCatNodes","_types","_UnhealthyClusterError","_reason","_WaitingHealthyClusterAbortedError","WAITING_TIME_STEP","WaitUntilHealthy","aborted","constructor","client","options","catHealth","ElasticsearchCatHealth","catNodes","ElasticsearchCatNodes","abort","wait","WaitingHealthyClusterAbortedError","startedAt","Date","mustEndAt","getTime","maxWaitingTime","waitingTimeStep","runs","waitingReason","shouldWait","onTimeout","UnhealthyClusterError","onUnhealthy","Promise","resolve","setTimeout","runningTime","health","nodes","getHealth","ex","createClusterHealthStatusReason","description","message","minimum","minClusterHealthStatus","current","ElasticsearchCatClusterHealthStatus","Red","getNodes","clusterHealthStatus","transformClusterHealthStatus","status","processorPercent","getProcessorPercent","maxProcessorPercent","createProcessorReason","maximum","maxRamPercent","undefined","ramPercent","getRamPercent","createMemoryReason","total","reduce","node","parseFloat","cpu","length","Green","Yellow","createWaitUntilHealthy","params","exports"],"sources":["WaitUntilHealthy.ts"],"sourcesContent":["import type { Client } from \"~/client\";\nimport { ElasticsearchCatHealth } from \"~/operations/ElasticsearchCatHealth\";\nimport { ElasticsearchCatNodes } from \"~/operations/ElasticsearchCatNodes\";\nimport type {\n    IElasticsearchCatHealthResponse,\n    IElasticsearchCatNodesResponse\n} from \"~/operations/types\";\nimport { ElasticsearchCatClusterHealthStatus } from \"~/operations/types\";\nimport { UnhealthyClusterError } from \"~/utils/waitUntilHealthy/UnhealthyClusterError\";\nimport type { ClusterHealthReason, MemoryReason, ProcessorReason } from \"./reason\";\nimport {\n    createClusterHealthStatusReason,\n    createMemoryReason,\n    createProcessorReason\n} from \"./reason\";\nimport { WaitingHealthyClusterAbortedError } from \"./WaitingHealthyClusterAbortedError\";\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        | ElasticsearchCatClusterHealthStatus.Green\n        | ElasticsearchCatClusterHealthStatus.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: ElasticsearchCatHealth;\n    private readonly catNodes: ElasticsearchCatNodes;\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 ElasticsearchCatHealth(this.client);\n        this.catNodes = new ElasticsearchCatNodes(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: IElasticsearchCatHealthResponse;\n        let nodes: IElasticsearchCatNodesResponse;\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: ElasticsearchCatClusterHealthStatus.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: ElasticsearchCatClusterHealthStatus.Red\n            });\n        }\n\n        const clusterHealthStatus = this.transformClusterHealthStatus(health.status);\n        const minClusterHealthStatus = this.transformClusterHealthStatus(\n            this.options.minClusterHealthStatus\n        );\n        if (clusterHealthStatus > minClusterHealthStatus) {\n            return createClusterHealthStatusReason({\n                minimum: this.options.minClusterHealthStatus,\n                current: health.status\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: IElasticsearchCatNodesResponse): number {\n        const total = nodes.reduce<number>((total, node) => {\n            return total + parseFloat(node.cpu);\n        }, 0);\n        return total / nodes.length;\n    }\n\n    private getRamPercent(nodes: IElasticsearchCatNodesResponse): number {\n        const total = nodes.reduce<number>((total, node) => {\n            return total + parseFloat(node[\"ram.percent\"]);\n        }, 0);\n        return total / nodes.length;\n    }\n\n    private transformClusterHealthStatus(status: ElasticsearchCatClusterHealthStatus): number {\n        switch (status) {\n            case ElasticsearchCatClusterHealthStatus.Green:\n                return 1;\n            case ElasticsearchCatClusterHealthStatus.Yellow:\n                return 2;\n            case ElasticsearchCatClusterHealthStatus.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":[]}

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,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WaitingHealthyClusterAbortedError = void 0;
+var _error = require("@webiny/error");
+class WaitingHealthyClusterAbortedError extends _error.WebinyError {
+  constructor(message) {
+    super({
+      message: message || `Waiting for the cluster to become healthy was aborted.`,
+      code: "WAITING_HEALTHY_CLUSTER_ABORTED"
+    });
+  }
+}
+exports.WaitingHealthyClusterAbortedError = WaitingHealthyClusterAbortedError;
+
+//# sourceMappingURL=WaitingHealthyClusterAbortedError.js.map

package/utils/waitUntilHealthy/WaitingHealthyClusterAbortedError.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_error","require","WaitingHealthyClusterAbortedError","WebinyError","constructor","message","code","exports"],"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,IAAAA,MAAA,GAAAC,OAAA;AAEO,MAAMC,iCAAiC,SAASC,kBAAW,CAAC;EACxDC,WAAWA,CAACC,OAAgB,EAAE;IACjC,KAAK,CAAC;MACFA,OAAO,EAAEA,OAAO,IAAI,wDAAwD;MAC5EC,IAAI,EAAE;IACV,CAAC,CAAC;EACN;AACJ;AAACC,OAAA,CAAAL,iCAAA,GAAAA,iCAAA","ignoreList":[]}

package/utils/waitUntilHealthy/index.d.ts

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

package/utils/waitUntilHealthy/index.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _WaitingHealthyClusterAbortedError = require("./WaitingHealthyClusterAbortedError");
+Object.keys(_WaitingHealthyClusterAbortedError).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _WaitingHealthyClusterAbortedError[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _WaitingHealthyClusterAbortedError[key];
+    }
+  });
+});
+var _UnhealthyClusterError = require("./UnhealthyClusterError");
+Object.keys(_UnhealthyClusterError).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _UnhealthyClusterError[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _UnhealthyClusterError[key];
+    }
+  });
+});
+var _WaitUntilHealthy = require("./WaitUntilHealthy");
+Object.keys(_WaitUntilHealthy).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _WaitUntilHealthy[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _WaitUntilHealthy[key];
+    }
+  });
+});
+var _reason = require("./reason");
+Object.keys(_reason).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _reason[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _reason[key];
+    }
+  });
+});
+
+//# sourceMappingURL=index.js.map

package/utils/waitUntilHealthy/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_WaitingHealthyClusterAbortedError","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get","_UnhealthyClusterError","_WaitUntilHealthy","_reason"],"sources":["index.ts"],"sourcesContent":["export * from \"./WaitingHealthyClusterAbortedError\";\nexport * from \"./UnhealthyClusterError\";\nexport * from \"./WaitUntilHealthy\";\nexport * from \"./UnhealthyClusterError\";\nexport * from \"./WaitUntilHealthy\";\nexport * from \"./reason\";\n"],"mappings":";;;;;AAAA,IAAAA,kCAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,kCAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,kCAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAT,kCAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AACA,IAAAK,sBAAA,GAAAT,OAAA;AAEAC,MAAA,CAAAC,IAAA,CAAAO,sBAAA,EAAAN,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAK,sBAAA,CAAAL,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAC,sBAAA,CAAAL,GAAA;IAAA;EAAA;AAAA;AADA,IAAAM,iBAAA,GAAAV,OAAA;AAEAC,MAAA,CAAAC,IAAA,CAAAQ,iBAAA,EAAAP,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAM,iBAAA,CAAAN,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAE,iBAAA,CAAAN,GAAA;IAAA;EAAA;AAAA;AACA,IAAAO,OAAA,GAAAX,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAS,OAAA,EAAAR,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAO,OAAA,CAAAP,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAG,OAAA,CAAAP,GAAA;IAAA;EAAA;AAAA","ignoreList":[]}

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

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

package/utils/waitUntilHealthy/reason/ClusterHealthReason.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createClusterHealthStatusReason = exports.ClusterHealthReason = void 0;
+class ClusterHealthReason {
+  name = "clusterHealth";
+  constructor(params) {
+    this.minimum = params.minimum;
+    this.current = params.current;
+    this.description = params.description;
+  }
+}
+exports.ClusterHealthReason = ClusterHealthReason;
+const createClusterHealthStatusReason = params => {
+  return new ClusterHealthReason(params);
+};
+exports.createClusterHealthStatusReason = createClusterHealthStatusReason;
+
+//# sourceMappingURL=ClusterHealthReason.js.map