@webiny/api-opensearch 6.1.0-beta.0

package/types.d.ts

@@ -0,0 +1,179 @@
+import type { Client } from "@opensearch-project/opensearch";
+import type { QueryDslQueryContainer, QueryDslBoolQuery, SearchFieldSort, SearchSortOrder, SearchSort, SearchRequest } from "@opensearch-project/opensearch/api/types";
+import type { Context, GenericRecord } from "@webiny/api/types.js";
+export type { ApiResponse } from "@opensearch-project/opensearch";
+export type { Client };
+/** Replaces elastic-ts PrimitiveValue */
+export type PrimitiveValue = null | number | string | boolean;
+/** Replaces elastic-ts Query */
+export type { QueryDslQueryContainer };
+/** Replaces elastic-ts BoolQueryConfig */
+export type { QueryDslBoolQuery };
+/** Replaces elastic-ts FieldSortOptions */
+export type FieldSortOptions = SearchFieldSort;
+/** Replaces elastic-ts SortOrder. Narrowed to "asc" | "desc" (excludes "_doc"). */
+export type SortOrder = "asc" | "desc";
+/** Replaces elastic-ts Sort */
+export type { SearchSort as Sort };
+/** Single sort entry as an object map. Replaces elastic-ts SortType. */
+export type SortType = Record<string, FieldSortOptions>;
+/** Replaces elastic-ts SearchBody. Overrides search_after to allow PrimitiveValue[] (null | boolean | string | number). */
+export type SearchBody = Omit<NonNullable<SearchRequest["body"]>, "search_after"> & {
+    search_after?: PrimitiveValue[];
+};
+export interface OpenSearchContext extends Context {
+    /**
+     * @deprecated Use `context.opensearch` instead.
+     */
+    elasticsearch: Client;
+    opensearch: Client;
+}
+export interface OpenSearchBoolQueryConfig extends QueryDslBoolQuery {
+    must: QueryDslQueryContainer[];
+    filter: QueryDslQueryContainer[];
+    should: QueryDslQueryContainer[];
+    must_not: QueryDslQueryContainer[];
+}
+export type OpenSearchQueryOperator = "eq" | "not" | "in" | "not_in" | "contains" | "not_contains" | "between" | "not_between" | "gt" | "gte" | "lt" | "lte" | string;
+export interface OpenSearchQueryBuilderArgsPlugin {
+    name: string;
+    path: string;
+    basePath: string;
+    value: any;
+    keyword: boolean;
+}
+export interface OpenSearchSearchResponseHit<T> {
+    _index: string;
+    _type: string;
+    _id: string;
+    _score: number | null;
+    _source: T;
+    sort: PrimitiveValue[];
+}
+export interface OpenSearchSearchResponseAggregationBucket<T> {
+    key: T;
+    doc_count: number;
+}
+export interface OpenSearchSearchResponseBodyHits<T> {
+    hits: OpenSearchSearchResponseHit<T>[];
+    total: {
+        value: number;
+    };
+}
+export interface OpenSearchSearchResponseBodyAggregations<T> {
+    [key: string]: {
+        buckets: OpenSearchSearchResponseAggregationBucket<T>[];
+    };
+}
+export interface OpenSearchSearchResponseBody<T> {
+    hits: OpenSearchSearchResponseBodyHits<T>;
+    aggregations: OpenSearchSearchResponseBodyAggregations<T>;
+}
+export interface OpenSearchSearchResponse<T = GenericRecord> {
+    body: OpenSearchSearchResponseBody<T>;
+}
+export interface OpenSearchIndexRequestBodyMappingsDynamicTemplate {
+    [key: string]: {
+        path_match?: string;
+        path_unmatch?: string;
+        match_mapping_type?: string;
+        match?: string;
+        unmatch?: string;
+        mapping?: {
+            numeric_detection?: boolean;
+            date_detection?: boolean;
+            type?: string;
+            search_analyzer?: string;
+            analyzer?: string;
+            fields?: {
+                [key: string]: {
+                    type: string;
+                    search_analyzer?: string;
+                    analyzer?: string;
+                    ignore_above?: number;
+                    [key: string]: any;
+                } | undefined;
+            };
+            [key: string]: any;
+        };
+        [key: string]: any;
+    };
+}
+export interface OpenSearchIndexRequestBody {
+    settings?: {
+        index?: {
+            analysis?: {
+                [key: string]: any;
+            };
+            number_of_shards?: number;
+            number_of_routing_shards?: number;
+            codec?: string;
+            soft_deletes?: {
+                enabled?: boolean;
+                retention_lease?: {
+                    period?: string;
+                };
+            };
+            number_of_replicas?: number;
+            auto_expand_replicas?: string | "all" | false;
+            refresh_interval?: string;
+            max_result_window?: number;
+            max_inner_result_window?: number;
+            max_rescore_window?: number;
+            max_script_fields?: number;
+            max_ngram_diff?: number;
+            max_shingle_diff?: number;
+            max_terms_count?: number;
+            max_regex_length?: number;
+            routing?: {
+                allocation?: {
+                    enable?: "all" | "primaries" | "new_primaries" | "none";
+                };
+                rebalance?: {
+                    enable?: "all" | "primaries" | "new_primaries" | "none";
+                };
+            };
+            hidden?: boolean;
+            total_fields?: {
+                limit?: number;
+            };
+            [key: string]: any;
+        };
+    };
+    mappings: {
+        numeric_detection?: boolean;
+        dynamic_templates?: OpenSearchIndexRequestBodyMappingsDynamicTemplate[];
+        properties?: {
+            [key: string]: {
+                analyzer?: string;
+                type?: string;
+                normalizer?: string;
+                index?: string;
+                fields?: {
+                    [key: string]: {
+                        type: string;
+                        ignore_above?: number;
+                        search_analyzer?: string;
+                        analyzer?: string;
+                        [key: string]: any;
+                    };
+                };
+                [key: string]: any;
+            };
+        };
+        [key: string]: any;
+    };
+    aliases?: {
+        [key: string]: {
+            filter?: {
+                [key: string]: any;
+            };
+            index_routing?: string;
+            is_hidden?: boolean;
+            is_write_index?: boolean;
+            routing?: string;
+            search_routing?: string;
+        };
+    };
+}
+export type { SearchSortOrder };

package/types.js

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

package/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import type { Client } from \"@opensearch-project/opensearch\";\nimport type {\n    QueryDslQueryContainer,\n    QueryDslBoolQuery,\n    SearchFieldSort,\n    SearchSortOrder,\n    SearchSort,\n    SearchRequest\n} from \"@opensearch-project/opensearch/api/types\";\nimport type { Context, GenericRecord } from \"@webiny/api/types.js\";\n\nexport type { ApiResponse } from \"@opensearch-project/opensearch\";\n\nexport type { Client };\n\n// ---------------------------------------------------------------------------\n// Local type aliases replacing elastic-ts\n// ---------------------------------------------------------------------------\n\n/** Replaces elastic-ts PrimitiveValue */\nexport type PrimitiveValue = null | number | string | boolean;\n\n/** Replaces elastic-ts Query */\nexport type { QueryDslQueryContainer };\n\n/** Replaces elastic-ts BoolQueryConfig */\nexport type { QueryDslBoolQuery };\n\n/** Replaces elastic-ts FieldSortOptions */\nexport type FieldSortOptions = SearchFieldSort;\n\n/** Replaces elastic-ts SortOrder. Narrowed to \"asc\" | \"desc\" (excludes \"_doc\"). */\nexport type SortOrder = \"asc\" | \"desc\";\n\n/** Replaces elastic-ts Sort */\nexport type { SearchSort as Sort };\n\n/** Single sort entry as an object map. Replaces elastic-ts SortType. */\nexport type SortType = Record<string, FieldSortOptions>;\n\n/** Replaces elastic-ts SearchBody. Overrides search_after to allow PrimitiveValue[] (null | boolean | string | number). */\nexport type SearchBody = Omit<NonNullable<SearchRequest[\"body\"]>, \"search_after\"> & {\n    search_after?: PrimitiveValue[];\n};\n\n// ---------------------------------------------------------------------------\n// Context\n// ---------------------------------------------------------------------------\n\nexport interface OpenSearchContext extends Context {\n    /**\n     * @deprecated Use `context.opensearch` instead.\n     */\n    elasticsearch: Client;\n    opensearch: Client;\n}\n\n// ---------------------------------------------------------------------------\n// Bool query with required arrays (our convention)\n// ---------------------------------------------------------------------------\n\nexport interface OpenSearchBoolQueryConfig extends QueryDslBoolQuery {\n    must: QueryDslQueryContainer[];\n    filter: QueryDslQueryContainer[];\n    should: QueryDslQueryContainer[];\n    must_not: QueryDslQueryContainer[];\n}\n\n// ---------------------------------------------------------------------------\n// Operator plugin types\n// ---------------------------------------------------------------------------\n\nexport type OpenSearchQueryOperator =\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\nexport interface OpenSearchQueryBuilderArgsPlugin {\n    name: string;\n    path: string;\n    basePath: string;\n    value: any;\n    keyword: boolean;\n}\n\n// ---------------------------------------------------------------------------\n// Search response shapes\n// ---------------------------------------------------------------------------\n\nexport interface OpenSearchSearchResponseHit<T> {\n    _index: string;\n    _type: string;\n    _id: string;\n    _score: number | null;\n    _source: T;\n    sort: PrimitiveValue[];\n}\n\nexport interface OpenSearchSearchResponseAggregationBucket<T> {\n    key: T;\n    doc_count: number;\n}\n\nexport interface OpenSearchSearchResponseBodyHits<T> {\n    hits: OpenSearchSearchResponseHit<T>[];\n    total: {\n        value: number;\n    };\n}\n\nexport interface OpenSearchSearchResponseBodyAggregations<T> {\n    [key: string]: {\n        buckets: OpenSearchSearchResponseAggregationBucket<T>[];\n    };\n}\n\nexport interface OpenSearchSearchResponseBody<T> {\n    hits: OpenSearchSearchResponseBodyHits<T>;\n    aggregations: OpenSearchSearchResponseBodyAggregations<T>;\n}\n\nexport interface OpenSearchSearchResponse<T = GenericRecord> {\n    body: OpenSearchSearchResponseBody<T>;\n}\n\n// ---------------------------------------------------------------------------\n// Index request body shapes (our own definitions, not from opensearch package)\n// ---------------------------------------------------------------------------\n\nexport interface OpenSearchIndexRequestBodyMappingsDynamicTemplate {\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?: 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 OpenSearchIndexRequestBody {\n    settings?: {\n        index?: {\n            analysis?: { [key: string]: any };\n            number_of_shards?: number;\n            number_of_routing_shards?: number;\n            codec?: string;\n            soft_deletes?: { enabled?: boolean; retention_lease?: { period?: string } };\n            number_of_replicas?: number;\n            auto_expand_replicas?: string | \"all\" | false;\n            refresh_interval?: string;\n            max_result_window?: number;\n            max_inner_result_window?: number;\n            max_rescore_window?: number;\n            max_script_fields?: number;\n            max_ngram_diff?: number;\n            max_shingle_diff?: number;\n            max_terms_count?: number;\n            max_regex_length?: number;\n            routing?: {\n                allocation?: { enable?: \"all\" | \"primaries\" | \"new_primaries\" | \"none\" };\n                rebalance?: { enable?: \"all\" | \"primaries\" | \"new_primaries\" | \"none\" };\n            };\n            hidden?: boolean;\n            total_fields?: { limit?: number };\n            [key: string]: any;\n        };\n    };\n    mappings: {\n        numeric_detection?: boolean;\n        dynamic_templates?: OpenSearchIndexRequestBodyMappingsDynamicTemplate[];\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?: { [key: string]: any };\n            index_routing?: string;\n            is_hidden?: boolean;\n            is_write_index?: boolean;\n            routing?: string;\n            search_routing?: string;\n        };\n    };\n}\n\n// Re-export SearchSortOrder for consumers that need it (including \"_doc\")\nexport type { SearchSortOrder };\n"],"mappings":"","ignoreList":[]}

package/utils/createIndex.d.ts

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

package/utils/createIndex.js

@@ -0,0 +1,88 @@
+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;
+    }
+    if (onExists) {
+      onExists();
+    }
+    return true;
+  } catch {
+    console.error(`Could not determine if the index "${index}" exists.`);
+  }
+  return false;
+};
+const indexCreate = async params => {
+  const {
+    client,
+    index,
+    plugin,
+    tenant,
+    type,
+    onError
+  } = params;
+  try {
+    await client.indices.create({
+      index,
+      body: {
+        ...plugin.body
+      }
+    });
+  } catch (ex) {
+    let error = ex;
+    if (onError) {
+      error = onError(ex);
+    }
+    throw new 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
+    });
+  }
+};
+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
+  });
+};
+
+//# sourceMappingURL=createIndex.js.map

package/utils/createIndex.js.map

@@ -0,0 +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":[]}

package/utils/index.d.ts

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

package/utils/index.js

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

package/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export * from \"./waitUntilHealthy/index.js\";\nexport * from \"./createIndex.js\";\n"],"mappings":"AAAA;AACA","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,11 @@
+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"
+    });
+  }
+}
+
+//# sourceMappingURL=UnhealthyClusterError.js.map

package/utils/waitUntilHealthy/UnhealthyClusterError.js.map

@@ -0,0 +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":[]}

package/utils/waitUntilHealthy/WaitUntilHealthy.d.ts

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

package/utils/waitUntilHealthy/WaitUntilHealthy.js

@@ -0,0 +1,150 @@
+import { OpenSearchCatHealth } from "../../operations/OpenSearchCatHealth.js";
+import { OpenSearchCatNodes } from "../../operations/OpenSearchCatNodes.js";
+import { OpenSearchCatClusterHealthStatus } from "../../operations/types.js";
+import { UnhealthyClusterError } from "./UnhealthyClusterError.js";
+import { createClusterHealthStatusReason, createMemoryReason, createProcessorReason } from "./reason/index.js";
+import { WaitingHealthyClusterAbortedError } from "./WaitingHealthyClusterAbortedError.js";
+const WAITING_TIME_STEP = 10;
+class WaitUntilHealthy {
+  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.`);
+    }
+    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(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();
+      }
+      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 clusterHealthStatus = this.transformClusterHealthStatus(health.status);
+    const minClusterHealthStatus = this.transformClusterHealthStatus(this.options.minClusterHealthStatus);
+    if (clusterHealthStatus > minClusterHealthStatus) {
+      return createClusterHealthStatusReason({
+        minimum: this.options.minClusterHealthStatus,
+        current: health.status
+      });
+    }
+    const processorPercent = this.getProcessorPercent(nodes);
+    if (processorPercent > this.options.maxProcessorPercent) {
+      return 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 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 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);
+};
+
+//# sourceMappingURL=WaitUntilHealthy.js.map

package/utils/waitUntilHealthy/WaitUntilHealthy.js.map

@@ -0,0 +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","clusterHealthStatus","transformClusterHealthStatus","status","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 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: IOpenSearchCatNodesResponse): 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: IOpenSearchCatNodesResponse): 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: 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":"AACA,SAASA,mBAAmB;AAC5B,SAASC,kBAAkB;AAK3B,SAASC,gCAAgC;AACzC,SAASC,qBAAqB;AAE9B,SACIC,+BAA+B,EAC/BC,kBAAkB,EAClBC,qBAAqB;AAEzB,SAASC,iCAAiC;AAE1C,MAAMC,iBAAiB,GAAG,EAAE;AA0D5B,MAAMC,gBAAgB,CAAC;EAOXC,OAAO,GAAG,KAAK;EAEhBC,WAAWA,CAACC,MAAc,EAAEC,OAAgC,EAAE;IACjE,IAAI,CAACD,MAAM,GAAGA,MAAM;IACpB,IAAI,CAACC,OAAO,GAAGA,OAAO;IAEtB,IAAI,CAACC,SAAS,GAAG,IAAId,mBAAmB,CAAC,IAAI,CAACY,MAAM,CAAC;IACrD,IAAI,CAACG,QAAQ,GAAG,IAAId,kBAAkB,CAAC,IAAI,CAACW,MAAM,CAAC;EACvD;EAEOI,KAAKA,CAAA,EAAS;IACjB,IAAI,CAACN,OAAO,GAAG,IAAI;EACvB;EACA;AACJ;AACA;AACA;EACI,MAAaO,IAAIA,CAACJ,OAAsB,EAA0C;IAC9E,IAAI,IAAI,CAACH,OAAO,EAAE;MACd,MAAM,IAAIH,iCAAiC,CACvC,+EACJ,CAAC;IACL;IACA,MAAMW,SAAS,GAAG,IAAIC,IAAI,CAAC,CAAC;IAC5B,MAAMC,SAAS,GAAG,IAAID,IAAI,CAACD,SAAS,CAACG,OAAO,CAAC,CAAC,GAAG,IAAI,CAACR,OAAO,CAACS,cAAc,GAAG,IAAI,CAAC;IACpF,MAAMC,eAAe,GAAG,IAAI,CAACV,OAAO,CAACU,eAAe,IAAIf,iBAAiB;IACzE,IAAIgB,IAAI,GAAG,CAAC;IACZ,IAAIC,aAAoC;IACxC,OAAQA,aAAa,GAAG,MAAM,IAAI,CAACC,UAAU,CAAC,CAAC,EAAG;MAC9C,IAAI,IAAIP,IAAI,CAAC,CAAC,IAAIC,SAAS,EAAE;QACzB,IAAIP,OAAO,EAAEc,SAAS,EAAE;UACpB,MAAMd,OAAO,CAACc,SAAS,CAAC;YACpBT,SAAS;YACTE,SAAS;YACTG,eAAe;YACfE,aAAa;YACbD;UACJ,CAAC,CAAC;QACN;QACA,MAAM,IAAIrB,qBAAqB,CAAC,IAAI,CAACU,OAAO,CAACS,cAAc,CAAC;MAChE,CAAC,MAAM,IAAIT,OAAO,EAAEe,WAAW,EAAE;QAC7B,MAAMf,OAAO,CAACe,WAAW,CAAC;UACtBV,SAAS;UACTE,SAAS;UACTG,eAAe;UACfE,aAAa;UACbD;QACJ,CAAC,CAAC;MACN;MACA;AACZ;AACA;MACY,IAAI,IAAI,CAACd,OAAO,EAAE;QACd,MAAM,IAAIH,iCAAiC,CAAC,CAAC;MACjD;MACAiB,IAAI,EAAE;MACN,MAAM,IAAIK,OAAO,CAACC,OAAO,IAAI;QACzBC,UAAU,CAACD,OAAO,EAAEP,eAAe,GAAG,IAAI,CAAC;MAC/C,CAAC,CAAC;IACN;IAEA,MAAMS,WAAW,GAAG,IAAIb,IAAI,CAAC,CAAC,CAACE,OAAO,CAAC,CAAC,GAAGH,SAAS,CAACG,OAAO,CAAC,CAAC;IAE9D,OAAO;MACHW,WAAW;MACXR;IACJ,CAAC;EACL;EAEA,MAAcE,UAAUA,CAAA,EAAmC;IACvD,IAAIO,MAAoC;IACxC,IAAIC,KAAkC;IACtC,IAAI;MACAD,MAAM,GAAG,MAAM,IAAI,CAACnB,SAAS,CAACqB,SAAS,CAAC,CAAC;IAC7C,CAAC,CAAC,OAAOC,EAAE,EAAE;MACT,OAAOhC,+BAA+B,CAAC;QACnCiC,WAAW,EAAED,EAAE,CAACE,OAAO;QACvBC,OAAO,EAAE,IAAI,CAAC1B,OAAO,CAAC2B,sBAAsB;QAC5CC,OAAO,EAAEvC,gCAAgC,CAACwC;MAC9C,CAAC,CAAC;IACN;IACA,IAAI;MACAR,KAAK,GAAG,MAAM,IAAI,CAACnB,QAAQ,CAAC4B,QAAQ,CAAC,CAAC;IAC1C,CAAC,CAAC,OAAOP,EAAE,EAAE;MACT,OAAOhC,+BAA+B,CAAC;QACnCiC,WAAW,EAAED,EAAE,CAACE,OAAO;QACvBC,OAAO,EAAE,IAAI,CAAC1B,OAAO,CAAC2B,sBAAsB;QAC5CC,OAAO,EAAEvC,gCAAgC,CAACwC;MAC9C,CAAC,CAAC;IACN;IAEA,MAAME,mBAAmB,GAAG,IAAI,CAACC,4BAA4B,CAACZ,MAAM,CAACa,MAAM,CAAC;IAC5E,MAAMN,sBAAsB,GAAG,IAAI,CAACK,4BAA4B,CAC5D,IAAI,CAAChC,OAAO,CAAC2B,sBACjB,CAAC;IACD,IAAII,mBAAmB,GAAGJ,sBAAsB,EAAE;MAC9C,OAAOpC,+BAA+B,CAAC;QACnCmC,OAAO,EAAE,IAAI,CAAC1B,OAAO,CAAC2B,sBAAsB;QAC5CC,OAAO,EAAER,MAAM,CAACa;MACpB,CAAC,CAAC;IACN;IAEA,MAAMC,gBAAgB,GAAG,IAAI,CAACC,mBAAmB,CAACd,KAAK,CAAC;IACxD,IAAIa,gBAAgB,GAAG,IAAI,CAAClC,OAAO,CAACoC,mBAAmB,EAAE;MACrD,OAAO3C,qBAAqB,CAAC;QACzB4C,OAAO,EAAE,IAAI,CAACrC,OAAO,CAACoC,mBAAmB;QACzCR,OAAO,EAAEM;MACb,CAAC,CAAC;IACN;IACA;AACR;AACA;IACQ,IAAI,IAAI,CAAClC,OAAO,CAACsC,aAAa,KAAKC,SAAS,EAAE;MAC1C,OAAO,KAAK;IAChB;IAEA,MAAMC,UAAU,GAAG,IAAI,CAACC,aAAa,CAACpB,KAAK,CAAC;IAC5C,IAAImB,UAAU,GAAG,IAAI,CAACxC,OAAO,CAACsC,aAAa,EAAE;MACzC,OAAO9C,kBAAkB,CAAC;QACtB6C,OAAO,EAAE,IAAI,CAACrC,OAAO,CAACsC,aAAa;QACnCV,OAAO,EAAEY;MACb,CAAC,CAAC;IACN;IACA,OAAO,KAAK;EAChB;EAEQL,mBAAmBA,CAACd,KAAkC,EAAU;IACpE,MAAMqB,KAAK,GAAGrB,KAAK,CAACsB,MAAM,CAAS,CAACD,KAAK,EAAEE,IAAI,KAAK;MAChD,OAAOF,KAAK,GAAGG,UAAU,CAACD,IAAI,CAACE,GAAG,CAAC;IACvC,CAAC,EAAE,CAAC,CAAC;IACL,OAAOJ,KAAK,GAAGrB,KAAK,CAAC0B,MAAM;EAC/B;EAEQN,aAAaA,CAACpB,KAAkC,EAAU;IAC9D,MAAMqB,KAAK,GAAGrB,KAAK,CAACsB,MAAM,CAAS,CAACD,KAAK,EAAEE,IAAI,KAAK;MAChD,OAAOF,KAAK,GAAGG,UAAU,CAACD,IAAI,CAAC,aAAa,CAAC,CAAC;IAClD,CAAC,EAAE,CAAC,CAAC;IACL,OAAOF,KAAK,GAAGrB,KAAK,CAAC0B,MAAM;EAC/B;EAEQf,4BAA4BA,CAACC,MAAwC,EAAU;IACnF,QAAQA,MAAM;MACV,KAAK5C,gCAAgC,CAAC2D,KAAK;QACvC,OAAO,CAAC;MACZ,KAAK3D,gCAAgC,CAAC4D,MAAM;QACxC,OAAO,CAAC;MACZ,KAAK5D,gCAAgC,CAACwC,GAAG;QACrC,OAAO,CAAC;MACZ;QACI,OAAO,EAAE;IACjB;EACJ;AACJ;AAIA,OAAO,MAAMqB,sBAAsB,GAAGA,CAClCnD,MAAc,EACdoD,MAA+B,KACZ;EACnB,OAAO,IAAIvD,gBAAgB,CAACG,MAAM,EAAEoD,MAAM,CAAC;AAC/C,CAAC","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,11 @@
+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"
+    });
+  }
+}
+
+//# sourceMappingURL=WaitingHealthyClusterAbortedError.js.map

package/utils/waitUntilHealthy/WaitingHealthyClusterAbortedError.js.map

@@ -0,0 +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":[]}

package/utils/waitUntilHealthy/index.d.ts

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

package/utils/waitUntilHealthy/index.js

@@ -0,0 +1,6 @@
+export * from "./WaitingHealthyClusterAbortedError.js";
+export * from "./UnhealthyClusterError.js";
+export * from "./WaitUntilHealthy.js";
+export * from "./reason/index.js";
+
+//# sourceMappingURL=index.js.map

package/utils/waitUntilHealthy/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export * from \"./WaitingHealthyClusterAbortedError.js\";\nexport * from \"./UnhealthyClusterError.js\";\nexport * from \"./WaitUntilHealthy.js\";\nexport * from \"./reason/index.js\";\n"],"mappings":"AAAA;AACA;AACA;AACA","ignoreList":[]}