@webiny/api-elasticsearch-tasks 0.0.0-unstable.06b2ede40f

package/settings/IndexManager.js

@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IndexManager = void 0;
+var _IndexSettingsManager = require("./IndexSettingsManager");
+var _DisableIndexing = require("./DisableIndexing");
+var _EnableIndexing = require("./EnableIndexing");
+var _utils = require("@webiny/utils");
+const defaultIndexSettings = {
+  numberOfReplicas: 1,
+  refreshInterval: "1s"
+};
+const indexPrefix = process.env.ELASTIC_SEARCH_INDEX_PREFIX || "";
+const filterIndex = item => {
+  if (!item) {
+    return false;
+  } else if (item.startsWith(".")) {
+    return false;
+  } else if (indexPrefix) {
+    return item.startsWith(indexPrefix);
+  }
+  return true;
+};
+class IndexManager {
+  get settings() {
+    return this._settings;
+  }
+  constructor(client, settings, defaults) {
+    const indexSettings = new _IndexSettingsManager.IndexSettingsManager(client);
+    this.client = client;
+    this.disable = new _DisableIndexing.DisableIndexing(indexSettings);
+    this.enable = new _EnableIndexing.EnableIndexing(indexSettings);
+    this._settings = settings;
+    this.defaults = {
+      refreshInterval: defaults?.refreshInterval || defaultIndexSettings.refreshInterval,
+      numberOfReplicas: defaults?.numberOfReplicas || defaultIndexSettings.numberOfReplicas
+    };
+  }
+  async list() {
+    try {
+      const response = await this.client.cat.indices({
+        format: "json"
+      });
+      if (!Array.isArray(response.body)) {
+        return [];
+      }
+      return response.body.map(item => item.index).filter(filterIndex);
+    } catch (ex) {
+      console.error(JSON.stringify({
+        message: "Failed to list indices.",
+        error: (0, _utils.getObjectProperties)(ex)
+      }));
+      return [];
+    }
+  }
+  async disableIndexing(index) {
+    /**
+     * No need to disable indexing if it's already disabled.
+     */
+    if (this._settings[index]) {
+      return this._settings[index];
+    }
+    const settings = await this.disable.exec(index);
+    this._settings[index] = settings;
+    return settings;
+  }
+  async enableIndexing(index) {
+    if (!index) {
+      const indexes = Object.keys(this._settings);
+      for (const index of indexes) {
+        await this.enableIndexing(index);
+      }
+      return;
+    }
+    const settings = this._settings[index] || this.defaults;
+    await this.enable.exec(index, settings);
+  }
+  async createIndex(index, settings) {
+    await this.client.indices.create({
+      index,
+      body: settings
+    });
+  }
+  async indexExists(index) {
+    const response = await this.client.indices.exists({
+      index,
+      ignore_unavailable: false,
+      allow_no_indices: true,
+      include_defaults: true,
+      flat_settings: false,
+      local: false
+    });
+    return !!response.body;
+  }
+}
+exports.IndexManager = IndexManager;
+
+//# sourceMappingURL=IndexManager.js.map

package/settings/IndexManager.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_IndexSettingsManager","require","_DisableIndexing","_EnableIndexing","_utils","defaultIndexSettings","numberOfReplicas","refreshInterval","indexPrefix","process","env","ELASTIC_SEARCH_INDEX_PREFIX","filterIndex","item","startsWith","IndexManager","settings","_settings","constructor","client","defaults","indexSettings","IndexSettingsManager","disable","DisableIndexing","enable","EnableIndexing","list","response","cat","indices","format","Array","isArray","body","map","index","filter","ex","console","error","JSON","stringify","message","getObjectProperties","disableIndexing","exec","enableIndexing","indexes","Object","keys","createIndex","create","indexExists","exists","ignore_unavailable","allow_no_indices","include_defaults","flat_settings","local","exports"],"sources":["IndexManager.ts"],"sourcesContent":["import { IndexSettingsManager } from \"~/settings/IndexSettingsManager\";\nimport { DisableIndexing } from \"./DisableIndexing\";\nimport { EnableIndexing } from \"./EnableIndexing\";\nimport type { IElasticsearchIndexingTaskValuesSettings, IIndexSettingsValues } from \"~/types\";\nimport type { IIndexManager } from \"~/settings/types\";\nimport type { Client } from \"@webiny/api-elasticsearch\";\nimport { getObjectProperties } from \"@webiny/utils\";\n\nconst defaultIndexSettings: IIndexSettingsValues = {\n    numberOfReplicas: 1,\n    refreshInterval: \"1s\"\n};\n\nexport interface IListIndicesResponse {\n    index: string;\n}\n\nconst indexPrefix = process.env.ELASTIC_SEARCH_INDEX_PREFIX || \"\";\nconst filterIndex = (item?: string) => {\n    if (!item) {\n        return false;\n    } else if (item.startsWith(\".\")) {\n        return false;\n    } else if (indexPrefix) {\n        return item.startsWith(indexPrefix);\n    }\n    return true;\n};\n\nexport class IndexManager implements IIndexManager {\n    private readonly client: Client;\n    private readonly disable: DisableIndexing;\n    private readonly enable: EnableIndexing;\n    private readonly _settings: IElasticsearchIndexingTaskValuesSettings;\n\n    private readonly defaults: IIndexSettingsValues;\n\n    public get settings(): IElasticsearchIndexingTaskValuesSettings {\n        return this._settings;\n    }\n\n    public constructor(\n        client: Client,\n        settings: IElasticsearchIndexingTaskValuesSettings,\n        defaults?: Partial<IIndexSettingsValues>\n    ) {\n        const indexSettings = new IndexSettingsManager(client);\n        this.client = client;\n        this.disable = new DisableIndexing(indexSettings);\n        this.enable = new EnableIndexing(indexSettings);\n        this._settings = settings;\n        this.defaults = {\n            refreshInterval: defaults?.refreshInterval || defaultIndexSettings.refreshInterval,\n            numberOfReplicas: defaults?.numberOfReplicas || defaultIndexSettings.numberOfReplicas\n        };\n    }\n\n    public async list(): Promise<string[]> {\n        try {\n            const response = await this.client.cat.indices<IListIndicesResponse[]>({\n                format: \"json\"\n            });\n            if (!Array.isArray(response.body)) {\n                return [];\n            }\n            return response.body.map(item => item.index).filter(filterIndex);\n        } catch (ex) {\n            console.error(\n                JSON.stringify({\n                    message: \"Failed to list indices.\",\n                    error: getObjectProperties(ex)\n                })\n            );\n            return [];\n        }\n    }\n\n    public async disableIndexing(index: string) {\n        /**\n         * No need to disable indexing if it's already disabled.\n         */\n        if (this._settings[index]) {\n            return this._settings[index];\n        }\n        const settings = await this.disable.exec(index);\n        this._settings[index] = settings;\n        return settings;\n    }\n\n    public async enableIndexing(index?: string) {\n        if (!index) {\n            const indexes = Object.keys(this._settings);\n            for (const index of indexes) {\n                await this.enableIndexing(index);\n            }\n            return;\n        }\n        const settings = this._settings[index] || this.defaults;\n        await this.enable.exec(index, settings);\n    }\n\n    public async createIndex(index: string, settings?: Record<string, any>): Promise<void> {\n        await this.client.indices.create({\n            index,\n            body: settings\n        });\n    }\n\n    public async indexExists(index: string): Promise<boolean> {\n        const response = await this.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        return !!response.body;\n    }\n}\n"],"mappings":"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","ignoreList":[]}

package/settings/IndexSettingsManager.d.ts

@@ -0,0 +1,8 @@
+import type { Client } from "@webiny/api-elasticsearch";
+import type { IIndexSettingsValues } from "../types";
+export declare class IndexSettingsManager {
+    private readonly elasticsearch;
+    constructor(elasticsearch: Client);
+    getSettings(index: string): Promise<IIndexSettingsValues>;
+    setSettings(index: string, settings: IIndexSettingsValues): Promise<void>;
+}

package/settings/IndexSettingsManager.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IndexSettingsManager = void 0;
+var _errors = require("../errors");
+class IndexSettingsManager {
+  constructor(elasticsearch) {
+    this.elasticsearch = elasticsearch;
+  }
+  async getSettings(index) {
+    try {
+      const response = await this.elasticsearch.indices.getSettings({
+        index
+      });
+      const setting = response.body[index].settings.index;
+      return {
+        numberOfReplicas: setting.number_of_replicas,
+        refreshInterval: setting.refresh_interval
+      };
+    } catch (ex) {
+      throw new _errors.IndexSettingsGetError(ex, index);
+    }
+  }
+  async setSettings(index, settings) {
+    try {
+      await this.elasticsearch.indices.putSettings({
+        index,
+        body: {
+          index: {
+            number_of_replicas: settings.numberOfReplicas,
+            refresh_interval: settings.refreshInterval
+          }
+        }
+      });
+    } catch (ex) {
+      throw new _errors.IndexSettingsSetError(ex, index);
+    }
+  }
+}
+exports.IndexSettingsManager = IndexSettingsManager;
+
+//# sourceMappingURL=IndexSettingsManager.js.map

package/settings/IndexSettingsManager.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_errors","require","IndexSettingsManager","constructor","elasticsearch","getSettings","index","response","indices","setting","body","settings","numberOfReplicas","number_of_replicas","refreshInterval","refresh_interval","ex","IndexSettingsGetError","setSettings","putSettings","IndexSettingsSetError","exports"],"sources":["IndexSettingsManager.ts"],"sourcesContent":["import type { Client } from \"@webiny/api-elasticsearch\";\nimport { IndexSettingsGetError, IndexSettingsSetError } from \"~/errors\";\nimport type { IIndexSettingsValues } from \"~/types\";\n\nexport class IndexSettingsManager {\n    private readonly elasticsearch: Client;\n\n    public constructor(elasticsearch: Client) {\n        this.elasticsearch = elasticsearch;\n    }\n\n    public async getSettings(index: string): Promise<IIndexSettingsValues> {\n        try {\n            const response = await this.elasticsearch.indices.getSettings({\n                index\n            });\n\n            const setting = response.body[index].settings.index;\n\n            return {\n                numberOfReplicas: setting.number_of_replicas,\n                refreshInterval: setting.refresh_interval\n            };\n        } catch (ex) {\n            throw new IndexSettingsGetError(ex, index);\n        }\n    }\n\n    public async setSettings(index: string, settings: IIndexSettingsValues): Promise<void> {\n        try {\n            await this.elasticsearch.indices.putSettings({\n                index,\n                body: {\n                    index: {\n                        number_of_replicas: settings.numberOfReplicas,\n                        refresh_interval: settings.refreshInterval\n                    }\n                }\n            });\n        } catch (ex) {\n            throw new IndexSettingsSetError(ex, index);\n        }\n    }\n}\n"],"mappings":";;;;;;AACA,IAAAA,OAAA,GAAAC,OAAA;AAGO,MAAMC,oBAAoB,CAAC;EAGvBC,WAAWA,CAACC,aAAqB,EAAE;IACtC,IAAI,CAACA,aAAa,GAAGA,aAAa;EACtC;EAEA,MAAaC,WAAWA,CAACC,KAAa,EAAiC;IACnE,IAAI;MACA,MAAMC,QAAQ,GAAG,MAAM,IAAI,CAACH,aAAa,CAACI,OAAO,CAACH,WAAW,CAAC;QAC1DC;MACJ,CAAC,CAAC;MAEF,MAAMG,OAAO,GAAGF,QAAQ,CAACG,IAAI,CAACJ,KAAK,CAAC,CAACK,QAAQ,CAACL,KAAK;MAEnD,OAAO;QACHM,gBAAgB,EAAEH,OAAO,CAACI,kBAAkB;QAC5CC,eAAe,EAAEL,OAAO,CAACM;MAC7B,CAAC;IACL,CAAC,CAAC,OAAOC,EAAE,EAAE;MACT,MAAM,IAAIC,6BAAqB,CAACD,EAAE,EAAEV,KAAK,CAAC;IAC9C;EACJ;EAEA,MAAaY,WAAWA,CAACZ,KAAa,EAAEK,QAA8B,EAAiB;IACnF,IAAI;MACA,MAAM,IAAI,CAACP,aAAa,CAACI,OAAO,CAACW,WAAW,CAAC;QACzCb,KAAK;QACLI,IAAI,EAAE;UACFJ,KAAK,EAAE;YACHO,kBAAkB,EAAEF,QAAQ,CAACC,gBAAgB;YAC7CG,gBAAgB,EAAEJ,QAAQ,CAACG;UAC/B;QACJ;MACJ,CAAC,CAAC;IACN,CAAC,CAAC,OAAOE,EAAE,EAAE;MACT,MAAM,IAAII,6BAAqB,CAACJ,EAAE,EAAEV,KAAK,CAAC;IAC9C;EACJ;AACJ;AAACe,OAAA,CAAAnB,oBAAA,GAAAA,oBAAA","ignoreList":[]}

package/settings/index.d.ts

@@ -0,0 +1 @@
+export * from "./IndexManager";

package/settings/index.js

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

package/settings/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_IndexManager","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get"],"sources":["index.ts"],"sourcesContent":["export * from \"./IndexManager\";\n"],"mappings":";;;;;AAAA,IAAAA,aAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,aAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,aAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAT,aAAA,CAAAK,GAAA;IAAA;EAAA;AAAA","ignoreList":[]}

package/settings/types.d.ts

@@ -0,0 +1,9 @@
+import type { IElasticsearchIndexingTaskValuesSettings, IIndexSettingsValues } from "../types";
+export interface IIndexManager {
+    settings: IElasticsearchIndexingTaskValuesSettings;
+    list(): Promise<string[]>;
+    disableIndexing(index: string): Promise<IIndexSettingsValues>;
+    enableIndexing(index?: string): Promise<void>;
+    createIndex(index: string, settings?: Record<string, any>): Promise<void>;
+    indexExists(index: string): Promise<boolean>;
+}

package/settings/types.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+//# sourceMappingURL=types.js.map

package/settings/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import type { IElasticsearchIndexingTaskValuesSettings, IIndexSettingsValues } from \"~/types\";\n\nexport interface IIndexManager {\n    settings: IElasticsearchIndexingTaskValuesSettings;\n\n    list(): Promise<string[]>;\n    disableIndexing(index: string): Promise<IIndexSettingsValues>;\n    enableIndexing(index?: string): Promise<void>;\n    createIndex(index: string, settings?: Record<string, any>): Promise<void>;\n    indexExists(index: string): Promise<boolean>;\n}\n"],"mappings":"","ignoreList":[]}

package/tasks/Manager.d.ts

@@ -0,0 +1,33 @@
+import type { DynamoDBDocument } from "@webiny/aws-sdk/client-dynamodb";
+import type { Client } from "@webiny/api-elasticsearch";
+import { createTable } from "../definitions";
+import type { Context, IManager } from "../types";
+import type { ITaskResponse } from "@webiny/tasks/response/abstractions";
+import type { IIsCloseToTimeoutCallable, ITaskManagerStore } from "@webiny/tasks/runner/abstractions";
+import type { BatchReadItem, IEntity } from "@webiny/db-dynamodb";
+import type { ITimer } from "@webiny/handler-aws/utils";
+export interface ManagerParams<T> {
+    context: Context;
+    documentClient?: DynamoDBDocument;
+    elasticsearchClient?: Client;
+    isCloseToTimeout: IIsCloseToTimeoutCallable;
+    isAborted: () => boolean;
+    response: ITaskResponse;
+    store: ITaskManagerStore<T>;
+    timer: ITimer;
+}
+export declare class Manager<T> implements IManager<T> {
+    readonly documentClient: DynamoDBDocument;
+    readonly elasticsearch: Client;
+    readonly context: Context;
+    readonly table: ReturnType<typeof createTable>;
+    readonly isCloseToTimeout: IIsCloseToTimeoutCallable;
+    readonly isAborted: () => boolean;
+    readonly response: ITaskResponse;
+    readonly store: ITaskManagerStore<T>;
+    readonly timer: ITimer;
+    private readonly entities;
+    constructor(params: ManagerParams<T>);
+    getEntity(name: string): IEntity;
+    read<T>(items: BatchReadItem[]): Promise<T[]>;
+}

package/tasks/Manager.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Manager = void 0;
+var _clientDynamodb = require("@webiny/aws-sdk/client-dynamodb");
+var _apiElasticsearch = require("@webiny/api-elasticsearch");
+var _definitions = require("../definitions");
+var _entry = require("../definitions/entry");
+var _dbDynamodb = require("@webiny/db-dynamodb");
+class Manager {
+  entities = {};
+  constructor(params) {
+    this.context = params.context;
+    this.documentClient = params?.documentClient || (0, _clientDynamodb.getDocumentClient)();
+    this.elasticsearch = params?.elasticsearchClient || params.context.elasticsearch || (0, _apiElasticsearch.createElasticsearchClient)({
+      endpoint: `https://${process.env.ELASTIC_SEARCH_ENDPOINT}`
+    });
+    this.table = (0, _definitions.createTable)({
+      documentClient: this.documentClient
+    });
+    this.isCloseToTimeout = () => {
+      return params.isCloseToTimeout();
+    };
+    this.isAborted = () => {
+      return params.isAborted();
+    };
+    this.response = params.response;
+    this.store = params.store;
+    this.timer = params.timer;
+  }
+  getEntity(name) {
+    if (this.entities[name]) {
+      return this.entities[name];
+    }
+    return this.entities[name] = (0, _entry.createEntry)({
+      table: this.table,
+      entityName: name
+    });
+  }
+  async read(items) {
+    return await (0, _dbDynamodb.batchReadAll)({
+      table: this.table,
+      items
+    });
+  }
+}
+exports.Manager = Manager;
+
+//# sourceMappingURL=Manager.js.map

package/tasks/Manager.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_clientDynamodb","require","_apiElasticsearch","_definitions","_entry","_dbDynamodb","Manager","entities","constructor","params","context","documentClient","getDocumentClient","elasticsearch","elasticsearchClient","createElasticsearchClient","endpoint","process","env","ELASTIC_SEARCH_ENDPOINT","table","createTable","isCloseToTimeout","isAborted","response","store","timer","getEntity","name","createEntry","entityName","read","items","batchReadAll","exports"],"sources":["Manager.ts"],"sourcesContent":["import type { DynamoDBDocument } from \"@webiny/aws-sdk/client-dynamodb\";\nimport { getDocumentClient } from \"@webiny/aws-sdk/client-dynamodb\";\nimport type { Client } from \"@webiny/api-elasticsearch\";\nimport { createElasticsearchClient } from \"@webiny/api-elasticsearch\";\nimport { createTable } from \"~/definitions\";\nimport type { Context, IManager } from \"~/types\";\nimport { createEntry } from \"~/definitions/entry\";\nimport type { ITaskResponse } from \"@webiny/tasks/response/abstractions\";\nimport type {\n    IIsCloseToTimeoutCallable,\n    ITaskManagerStore\n} from \"@webiny/tasks/runner/abstractions\";\nimport type { BatchReadItem, IEntity } from \"@webiny/db-dynamodb\";\nimport { batchReadAll } from \"@webiny/db-dynamodb\";\nimport type { ITimer } from \"@webiny/handler-aws/utils\";\n\nexport interface ManagerParams<T> {\n    context: Context;\n    documentClient?: DynamoDBDocument;\n    elasticsearchClient?: Client;\n    isCloseToTimeout: IIsCloseToTimeoutCallable;\n    isAborted: () => boolean;\n    response: ITaskResponse;\n    store: ITaskManagerStore<T>;\n    timer: ITimer;\n}\n\nexport class Manager<T> implements IManager<T> {\n    public readonly documentClient: DynamoDBDocument;\n    public readonly elasticsearch: Client;\n    public readonly context: Context;\n    public readonly table: ReturnType<typeof createTable>;\n    public readonly isCloseToTimeout: IIsCloseToTimeoutCallable;\n    public readonly isAborted: () => boolean;\n    public readonly response: ITaskResponse;\n    public readonly store: ITaskManagerStore<T>;\n    public readonly timer: ITimer;\n\n    private readonly entities: Record<string, IEntity> = {};\n\n    public constructor(params: ManagerParams<T>) {\n        this.context = params.context;\n        this.documentClient = params?.documentClient || getDocumentClient();\n\n        this.elasticsearch =\n            params?.elasticsearchClient ||\n            params.context.elasticsearch ||\n            createElasticsearchClient({\n                endpoint: `https://${process.env.ELASTIC_SEARCH_ENDPOINT}`\n            });\n\n        this.table = createTable({\n            documentClient: this.documentClient\n        });\n        this.isCloseToTimeout = () => {\n            return params.isCloseToTimeout();\n        };\n        this.isAborted = () => {\n            return params.isAborted();\n        };\n        this.response = params.response;\n        this.store = params.store;\n        this.timer = params.timer;\n    }\n\n    public getEntity(name: string): IEntity {\n        if (this.entities[name]) {\n            return this.entities[name];\n        }\n\n        return (this.entities[name] = createEntry({\n            table: this.table,\n            entityName: name\n        }));\n    }\n\n    public async read<T>(items: BatchReadItem[]): Promise<T[]> {\n        return await batchReadAll<T>({\n            table: this.table,\n            items\n        });\n    }\n}\n"],"mappings":";;;;;;AACA,IAAAA,eAAA,GAAAC,OAAA;AAEA,IAAAC,iBAAA,GAAAD,OAAA;AACA,IAAAE,YAAA,GAAAF,OAAA;AAEA,IAAAG,MAAA,GAAAH,OAAA;AAOA,IAAAI,WAAA,GAAAJ,OAAA;AAcO,MAAMK,OAAO,CAA2B;EAW1BC,QAAQ,GAA4B,CAAC,CAAC;EAEhDC,WAAWA,CAACC,MAAwB,EAAE;IACzC,IAAI,CAACC,OAAO,GAAGD,MAAM,CAACC,OAAO;IAC7B,IAAI,CAACC,cAAc,GAAGF,MAAM,EAAEE,cAAc,IAAI,IAAAC,iCAAiB,EAAC,CAAC;IAEnE,IAAI,CAACC,aAAa,GACdJ,MAAM,EAAEK,mBAAmB,IAC3BL,MAAM,CAACC,OAAO,CAACG,aAAa,IAC5B,IAAAE,2CAAyB,EAAC;MACtBC,QAAQ,EAAE,WAAWC,OAAO,CAACC,GAAG,CAACC,uBAAuB;IAC5D,CAAC,CAAC;IAEN,IAAI,CAACC,KAAK,GAAG,IAAAC,wBAAW,EAAC;MACrBV,cAAc,EAAE,IAAI,CAACA;IACzB,CAAC,CAAC;IACF,IAAI,CAACW,gBAAgB,GAAG,MAAM;MAC1B,OAAOb,MAAM,CAACa,gBAAgB,CAAC,CAAC;IACpC,CAAC;IACD,IAAI,CAACC,SAAS,GAAG,MAAM;MACnB,OAAOd,MAAM,CAACc,SAAS,CAAC,CAAC;IAC7B,CAAC;IACD,IAAI,CAACC,QAAQ,GAAGf,MAAM,CAACe,QAAQ;IAC/B,IAAI,CAACC,KAAK,GAAGhB,MAAM,CAACgB,KAAK;IACzB,IAAI,CAACC,KAAK,GAAGjB,MAAM,CAACiB,KAAK;EAC7B;EAEOC,SAASA,CAACC,IAAY,EAAW;IACpC,IAAI,IAAI,CAACrB,QAAQ,CAACqB,IAAI,CAAC,EAAE;MACrB,OAAO,IAAI,CAACrB,QAAQ,CAACqB,IAAI,CAAC;IAC9B;IAEA,OAAQ,IAAI,CAACrB,QAAQ,CAACqB,IAAI,CAAC,GAAG,IAAAC,kBAAW,EAAC;MACtCT,KAAK,EAAE,IAAI,CAACA,KAAK;MACjBU,UAAU,EAAEF;IAChB,CAAC,CAAC;EACN;EAEA,MAAaG,IAAIA,CAAIC,KAAsB,EAAgB;IACvD,OAAO,MAAM,IAAAC,wBAAY,EAAI;MACzBb,KAAK,EAAE,IAAI,CAACA,KAAK;MACjBY;IACJ,CAAC,CAAC;EACN;AACJ;AAACE,OAAA,CAAA5B,OAAA,GAAAA,OAAA","ignoreList":[]}

package/tasks/createIndexes/CreateElasticsearchIndexTaskPlugin.d.ts

@@ -0,0 +1,23 @@
+import { Plugin } from "@webiny/plugins";
+import type { Context } from "@webiny/api/types";
+import type { ElasticsearchIndexRequestBody } from "@webiny/api-elasticsearch/types";
+export interface CreateElasticsearchIndexTaskPluginIndex {
+    index: string;
+    settings?: Partial<ElasticsearchIndexRequestBody>;
+}
+export interface CreateElasticsearchIndexTaskPluginConfigParams<C extends Context> {
+    context: C;
+    tenant: string;
+    locale: string;
+}
+export interface CreateElasticsearchIndexTaskPluginConfig<C extends Context> {
+    name?: string;
+    getIndexList(params: CreateElasticsearchIndexTaskPluginConfigParams<C>): Promise<CreateElasticsearchIndexTaskPluginIndex[]>;
+}
+export declare class CreateElasticsearchIndexTaskPlugin<C extends Context> extends Plugin {
+    static readonly type: string;
+    private readonly config;
+    constructor(config: CreateElasticsearchIndexTaskPluginConfig<C>);
+    getIndexList(params: CreateElasticsearchIndexTaskPluginConfigParams<C>): Promise<CreateElasticsearchIndexTaskPluginIndex[]>;
+}
+export declare const createElasticsearchIndexTaskPlugin: <C extends Context>(config: CreateElasticsearchIndexTaskPluginConfig<C>) => CreateElasticsearchIndexTaskPlugin<C>;

package/tasks/createIndexes/CreateElasticsearchIndexTaskPlugin.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createElasticsearchIndexTaskPlugin = exports.CreateElasticsearchIndexTaskPlugin = void 0;
+var _plugins = require("@webiny/plugins");
+class CreateElasticsearchIndexTaskPlugin extends _plugins.Plugin {
+  static type = "elasticsearch.createElasticsearchIndexTaskPlugin";
+  constructor(config) {
+    super();
+    this.name = config.name;
+    this.config = config;
+  }
+  getIndexList(params) {
+    return this.config.getIndexList(params);
+  }
+}
+exports.CreateElasticsearchIndexTaskPlugin = CreateElasticsearchIndexTaskPlugin;
+const createElasticsearchIndexTaskPlugin = config => {
+  return new CreateElasticsearchIndexTaskPlugin(config);
+};
+exports.createElasticsearchIndexTaskPlugin = createElasticsearchIndexTaskPlugin;
+
+//# sourceMappingURL=CreateElasticsearchIndexTaskPlugin.js.map

package/tasks/createIndexes/CreateElasticsearchIndexTaskPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_plugins","require","CreateElasticsearchIndexTaskPlugin","Plugin","type","constructor","config","name","getIndexList","params","exports","createElasticsearchIndexTaskPlugin"],"sources":["CreateElasticsearchIndexTaskPlugin.ts"],"sourcesContent":["import { Plugin } from \"@webiny/plugins\";\nimport type { Context } from \"@webiny/api/types\";\nimport type { ElasticsearchIndexRequestBody } from \"@webiny/api-elasticsearch/types\";\n\nexport interface CreateElasticsearchIndexTaskPluginIndex {\n    index: string;\n    settings?: Partial<ElasticsearchIndexRequestBody>;\n}\n\nexport interface CreateElasticsearchIndexTaskPluginConfigParams<C extends Context> {\n    context: C;\n    tenant: string;\n    locale: string;\n}\n\nexport interface CreateElasticsearchIndexTaskPluginConfig<C extends Context> {\n    name?: string;\n    getIndexList(\n        params: CreateElasticsearchIndexTaskPluginConfigParams<C>\n    ): Promise<CreateElasticsearchIndexTaskPluginIndex[]>;\n}\n\nexport class CreateElasticsearchIndexTaskPlugin<C extends Context> extends Plugin {\n    public static override readonly type: string =\n        \"elasticsearch.createElasticsearchIndexTaskPlugin\";\n\n    private readonly config: CreateElasticsearchIndexTaskPluginConfig<C>;\n\n    public constructor(config: CreateElasticsearchIndexTaskPluginConfig<C>) {\n        super();\n        this.name = config.name;\n        this.config = config;\n    }\n\n    public getIndexList(\n        params: CreateElasticsearchIndexTaskPluginConfigParams<C>\n    ): Promise<CreateElasticsearchIndexTaskPluginIndex[]> {\n        return this.config.getIndexList(params);\n    }\n}\n\nexport const createElasticsearchIndexTaskPlugin = <C extends Context>(\n    config: CreateElasticsearchIndexTaskPluginConfig<C>\n) => {\n    return new CreateElasticsearchIndexTaskPlugin<C>(config);\n};\n"],"mappings":";;;;;;AAAA,IAAAA,QAAA,GAAAC,OAAA;AAsBO,MAAMC,kCAAkC,SAA4BC,eAAM,CAAC;EAC9E,OAAgCC,IAAI,GAChC,kDAAkD;EAI/CC,WAAWA,CAACC,MAAmD,EAAE;IACpE,KAAK,CAAC,CAAC;IACP,IAAI,CAACC,IAAI,GAAGD,MAAM,CAACC,IAAI;IACvB,IAAI,CAACD,MAAM,GAAGA,MAAM;EACxB;EAEOE,YAAYA,CACfC,MAAyD,EACP;IAClD,OAAO,IAAI,CAACH,MAAM,CAACE,YAAY,CAACC,MAAM,CAAC;EAC3C;AACJ;AAACC,OAAA,CAAAR,kCAAA,GAAAA,kCAAA;AAEM,MAAMS,kCAAkC,GAC3CL,MAAmD,IAClD;EACD,OAAO,IAAIJ,kCAAkC,CAAII,MAAM,CAAC;AAC5D,CAAC;AAACI,OAAA,CAAAC,kCAAA,GAAAA,kCAAA","ignoreList":[]}

package/tasks/createIndexes/CreateIndexesTaskRunner.d.ts

@@ -0,0 +1,10 @@
+import type { Manager } from "../Manager";
+import type { IndexManager } from "../../settings";
+import type { ITaskResponseResult } from "@webiny/tasks";
+import type { IElasticsearchCreateIndexesTaskInput } from "./types";
+export declare class CreateIndexesTaskRunner {
+    private readonly manager;
+    private readonly indexManager;
+    constructor(manager: Manager<IElasticsearchCreateIndexesTaskInput>, indexManager: IndexManager);
+    execute(matching: string | undefined, done: string[]): Promise<ITaskResponseResult>;
+}

package/tasks/createIndexes/CreateIndexesTaskRunner.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CreateIndexesTaskRunner = void 0;
+var _listIndexes = require("./listIndexes");
+var _createIndex = require("./createIndex");
+var _listCreateElasticsearchIndexTaskPlugin = require("./listCreateElasticsearchIndexTaskPlugin");
+class CreateIndexesTaskRunner {
+  constructor(manager, indexManager) {
+    this.manager = manager;
+    this.indexManager = indexManager;
+  }
+  async execute(matching, done) {
+    const plugins = (0, _listCreateElasticsearchIndexTaskPlugin.listCreateElasticsearchIndexTaskPlugin)(this.manager.context.plugins);
+    if (plugins.length === 0) {
+      return this.manager.response.done("No index plugins found.");
+    }
+    const indexes = await (0, _listIndexes.listIndexes)({
+      context: this.manager.context,
+      plugins
+    });
+    if (indexes.length === 0) {
+      return this.manager.response.done("No indexes found.");
+    }
+    const isIndexAllowed = index => {
+      if (typeof matching !== "string" || !matching) {
+        return true;
+      }
+      return index.includes(matching);
+    };
+    const createIndex = (0, _createIndex.createIndexFactory)(this.indexManager);
+    for (const {
+      index,
+      settings
+    } of indexes) {
+      if (this.manager.isAborted()) {
+        return this.manager.response.aborted();
+      } else if (this.manager.isCloseToTimeout()) {
+        return this.manager.response.continue({
+          done
+        });
+      }
+      try {
+        if (done.includes(index)) {
+          continue;
+        } else if (isIndexAllowed(index) === false) {
+          continue;
+        }
+        const exists = await this.indexManager.indexExists(index);
+        if (exists) {
+          continue;
+        }
+        done.push(index);
+        await createIndex.create(index, settings);
+        await this.manager.store.addInfoLog({
+          message: `Index "${index}" created.`,
+          data: {
+            index
+          }
+        });
+      } catch (ex) {
+        await this.manager.store.addErrorLog({
+          message: `Failed to create index "${index}".`,
+          error: ex
+        });
+      }
+    }
+    return this.manager.response.done("Indexes created.", {
+      done
+    });
+  }
+}
+exports.CreateIndexesTaskRunner = CreateIndexesTaskRunner;
+
+//# sourceMappingURL=CreateIndexesTaskRunner.js.map

package/tasks/createIndexes/CreateIndexesTaskRunner.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_listIndexes","require","_createIndex","_listCreateElasticsearchIndexTaskPlugin","CreateIndexesTaskRunner","constructor","manager","indexManager","execute","matching","done","plugins","listCreateElasticsearchIndexTaskPlugin","context","length","response","indexes","listIndexes","isIndexAllowed","index","includes","createIndex","createIndexFactory","settings","isAborted","aborted","isCloseToTimeout","continue","exists","indexExists","push","create","store","addInfoLog","message","data","ex","addErrorLog","error","exports"],"sources":["CreateIndexesTaskRunner.ts"],"sourcesContent":["import type { Manager } from \"~/tasks/Manager\";\nimport type { IndexManager } from \"~/settings\";\nimport type { ITaskResponseResult } from \"@webiny/tasks\";\nimport type { IElasticsearchCreateIndexesTaskInput } from \"./types\";\nimport { listIndexes } from \"./listIndexes\";\nimport { createIndexFactory } from \"./createIndex\";\nimport type { Context } from \"~/types\";\nimport { listCreateElasticsearchIndexTaskPlugin } from \"./listCreateElasticsearchIndexTaskPlugin\";\n\nexport class CreateIndexesTaskRunner {\n    private readonly manager: Manager<IElasticsearchCreateIndexesTaskInput>;\n    private readonly indexManager: IndexManager;\n\n    public constructor(\n        manager: Manager<IElasticsearchCreateIndexesTaskInput>,\n        indexManager: IndexManager\n    ) {\n        this.manager = manager;\n\n        this.indexManager = indexManager;\n    }\n\n    public async execute(\n        matching: string | undefined,\n        done: string[]\n    ): Promise<ITaskResponseResult> {\n        const plugins = listCreateElasticsearchIndexTaskPlugin<Context>(\n            this.manager.context.plugins\n        );\n        if (plugins.length === 0) {\n            return this.manager.response.done(\"No index plugins found.\");\n        }\n\n        const indexes = await listIndexes({\n            context: this.manager.context,\n            plugins\n        });\n\n        if (indexes.length === 0) {\n            return this.manager.response.done(\"No indexes found.\");\n        }\n\n        const isIndexAllowed = (index: string): boolean => {\n            if (typeof matching !== \"string\" || !matching) {\n                return true;\n            }\n            return index.includes(matching);\n        };\n\n        const createIndex = createIndexFactory(this.indexManager);\n\n        for (const { index, settings } of indexes) {\n            if (this.manager.isAborted()) {\n                return this.manager.response.aborted();\n            } else if (this.manager.isCloseToTimeout()) {\n                return this.manager.response.continue({\n                    done\n                });\n            }\n            try {\n                if (done.includes(index)) {\n                    continue;\n                } else if (isIndexAllowed(index) === false) {\n                    continue;\n                }\n                const exists = await this.indexManager.indexExists(index);\n                if (exists) {\n                    continue;\n                }\n                done.push(index);\n                await createIndex.create(index, settings);\n                await this.manager.store.addInfoLog({\n                    message: `Index \"${index}\" created.`,\n                    data: {\n                        index\n                    }\n                });\n            } catch (ex) {\n                await this.manager.store.addErrorLog({\n                    message: `Failed to create index \"${index}\".`,\n                    error: ex\n                });\n            }\n        }\n\n        return this.manager.response.done(\"Indexes created.\", {\n            done\n        });\n    }\n}\n"],"mappings":";;;;;;AAIA,IAAAA,YAAA,GAAAC,OAAA;AACA,IAAAC,YAAA,GAAAD,OAAA;AAEA,IAAAE,uCAAA,GAAAF,OAAA;AAEO,MAAMG,uBAAuB,CAAC;EAI1BC,WAAWA,CACdC,OAAsD,EACtDC,YAA0B,EAC5B;IACE,IAAI,CAACD,OAAO,GAAGA,OAAO;IAEtB,IAAI,CAACC,YAAY,GAAGA,YAAY;EACpC;EAEA,MAAaC,OAAOA,CAChBC,QAA4B,EAC5BC,IAAc,EACc;IAC5B,MAAMC,OAAO,GAAG,IAAAC,8EAAsC,EAClD,IAAI,CAACN,OAAO,CAACO,OAAO,CAACF,OACzB,CAAC;IACD,IAAIA,OAAO,CAACG,MAAM,KAAK,CAAC,EAAE;MACtB,OAAO,IAAI,CAACR,OAAO,CAACS,QAAQ,CAACL,IAAI,CAAC,yBAAyB,CAAC;IAChE;IAEA,MAAMM,OAAO,GAAG,MAAM,IAAAC,wBAAW,EAAC;MAC9BJ,OAAO,EAAE,IAAI,CAACP,OAAO,CAACO,OAAO;MAC7BF;IACJ,CAAC,CAAC;IAEF,IAAIK,OAAO,CAACF,MAAM,KAAK,CAAC,EAAE;MACtB,OAAO,IAAI,CAACR,OAAO,CAACS,QAAQ,CAACL,IAAI,CAAC,mBAAmB,CAAC;IAC1D;IAEA,MAAMQ,cAAc,GAAIC,KAAa,IAAc;MAC/C,IAAI,OAAOV,QAAQ,KAAK,QAAQ,IAAI,CAACA,QAAQ,EAAE;QAC3C,OAAO,IAAI;MACf;MACA,OAAOU,KAAK,CAACC,QAAQ,CAACX,QAAQ,CAAC;IACnC,CAAC;IAED,MAAMY,WAAW,GAAG,IAAAC,+BAAkB,EAAC,IAAI,CAACf,YAAY,CAAC;IAEzD,KAAK,MAAM;MAAEY,KAAK;MAAEI;IAAS,CAAC,IAAIP,OAAO,EAAE;MACvC,IAAI,IAAI,CAACV,OAAO,CAACkB,SAAS,CAAC,CAAC,EAAE;QAC1B,OAAO,IAAI,CAAClB,OAAO,CAACS,QAAQ,CAACU,OAAO,CAAC,CAAC;MAC1C,CAAC,MAAM,IAAI,IAAI,CAACnB,OAAO,CAACoB,gBAAgB,CAAC,CAAC,EAAE;QACxC,OAAO,IAAI,CAACpB,OAAO,CAACS,QAAQ,CAACY,QAAQ,CAAC;UAClCjB;QACJ,CAAC,CAAC;MACN;MACA,IAAI;QACA,IAAIA,IAAI,CAACU,QAAQ,CAACD,KAAK,CAAC,EAAE;UACtB;QACJ,CAAC,MAAM,IAAID,cAAc,CAACC,KAAK,CAAC,KAAK,KAAK,EAAE;UACxC;QACJ;QACA,MAAMS,MAAM,GAAG,MAAM,IAAI,CAACrB,YAAY,CAACsB,WAAW,CAACV,KAAK,CAAC;QACzD,IAAIS,MAAM,EAAE;UACR;QACJ;QACAlB,IAAI,CAACoB,IAAI,CAACX,KAAK,CAAC;QAChB,MAAME,WAAW,CAACU,MAAM,CAACZ,KAAK,EAAEI,QAAQ,CAAC;QACzC,MAAM,IAAI,CAACjB,OAAO,CAAC0B,KAAK,CAACC,UAAU,CAAC;UAChCC,OAAO,EAAE,UAAUf,KAAK,YAAY;UACpCgB,IAAI,EAAE;YACFhB;UACJ;QACJ,CAAC,CAAC;MACN,CAAC,CAAC,OAAOiB,EAAE,EAAE;QACT,MAAM,IAAI,CAAC9B,OAAO,CAAC0B,KAAK,CAACK,WAAW,CAAC;UACjCH,OAAO,EAAE,2BAA2Bf,KAAK,IAAI;UAC7CmB,KAAK,EAAEF;QACX,CAAC,CAAC;MACN;IACJ;IAEA,OAAO,IAAI,CAAC9B,OAAO,CAACS,QAAQ,CAACL,IAAI,CAAC,kBAAkB,EAAE;MAClDA;IACJ,CAAC,CAAC;EACN;AACJ;AAAC6B,OAAA,CAAAnC,uBAAA,GAAAA,uBAAA","ignoreList":[]}

package/tasks/createIndexes/OnBeforeTrigger.d.ts

@@ -0,0 +1,12 @@
+import type { Context } from "../../types";
+import type { IndexManager } from "../../settings";
+export interface IOnBeforeTriggerParams {
+    indexManager: IndexManager;
+    context: Context;
+}
+export declare class OnBeforeTrigger {
+    private readonly context;
+    private readonly indexManager;
+    constructor(params: IOnBeforeTriggerParams);
+    run(targets: string[] | undefined): Promise<void>;
+}

package/tasks/createIndexes/OnBeforeTrigger.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OnBeforeTrigger = void 0;
+var _listIndexes = require("./listIndexes");
+var _createIndex = require("./createIndex");
+var _listCreateElasticsearchIndexTaskPlugin = require("./listCreateElasticsearchIndexTaskPlugin");
+class OnBeforeTrigger {
+  constructor(params) {
+    this.context = params.context;
+    this.indexManager = params.indexManager;
+  }
+  async run(targets) {
+    const plugins = (0, _listCreateElasticsearchIndexTaskPlugin.listCreateElasticsearchIndexTaskPlugin)(this.context.plugins);
+    const tenant = this.context.tenancy.getCurrentTenant();
+    if (!tenant?.id) {
+      throw new Error("Something went wrong, tenant not found when triggering a task.");
+    }
+    const locale = this.context.i18n.getContentLocale();
+    if (!locale) {
+      throw new Error("Something went wrong, locale not found when triggering a task.");
+    }
+    try {
+      const allIndexes = await (0, _listIndexes.listIndexes)({
+        context: this.context,
+        plugins,
+        tenants: [tenant],
+        locales: [locale]
+      });
+      const indexes = allIndexes.filter(index => {
+        if (!targets?.length) {
+          return true;
+        }
+        for (const t of targets) {
+          if (index.index.includes(t)) {
+            return true;
+          }
+        }
+        return false;
+      });
+      if (indexes.length === 0) {
+        console.warn("There are no indexes to create before triggering the Create indexes task.", {
+          targets
+        });
+        return;
+      }
+      const createIndex = (0, _createIndex.createIndexFactory)(this.indexManager);
+      for (const {
+        index,
+        settings
+      } of indexes) {
+        try {
+          console.log("Creating index", index);
+          await createIndex.createIfNotExists(index, settings);
+        } catch (ex) {
+          console.error(`Failed to create index "${index}".`, ex);
+        }
+      }
+    } catch (ex) {
+      console.error(ex);
+    }
+  }
+}
+exports.OnBeforeTrigger = OnBeforeTrigger;
+
+//# sourceMappingURL=OnBeforeTrigger.js.map

package/tasks/createIndexes/OnBeforeTrigger.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_listIndexes","require","_createIndex","_listCreateElasticsearchIndexTaskPlugin","OnBeforeTrigger","constructor","params","context","indexManager","run","targets","plugins","listCreateElasticsearchIndexTaskPlugin","tenant","tenancy","getCurrentTenant","id","Error","locale","i18n","getContentLocale","allIndexes","listIndexes","tenants","locales","indexes","filter","index","length","t","includes","console","warn","createIndex","createIndexFactory","settings","log","createIfNotExists","ex","error","exports"],"sources":["OnBeforeTrigger.ts"],"sourcesContent":["import type { Context } from \"~/types\";\nimport type { IndexManager } from \"~/settings\";\nimport { listIndexes } from \"./listIndexes\";\nimport { createIndexFactory } from \"~/tasks/createIndexes/createIndex\";\nimport { listCreateElasticsearchIndexTaskPlugin } from \"~/tasks/createIndexes/listCreateElasticsearchIndexTaskPlugin\";\n\nexport interface IOnBeforeTriggerParams {\n    indexManager: IndexManager;\n    context: Context;\n}\n\nexport class OnBeforeTrigger {\n    private readonly context: Context;\n    private readonly indexManager: IndexManager;\n\n    public constructor(params: IOnBeforeTriggerParams) {\n        this.context = params.context;\n        this.indexManager = params.indexManager;\n    }\n\n    public async run(targets: string[] | undefined): Promise<void> {\n        const plugins = listCreateElasticsearchIndexTaskPlugin<Context>(this.context.plugins);\n\n        const tenant = this.context.tenancy.getCurrentTenant();\n        if (!tenant?.id) {\n            throw new Error(\"Something went wrong, tenant not found when triggering a task.\");\n        }\n        const locale = this.context.i18n.getContentLocale();\n        if (!locale) {\n            throw new Error(\"Something went wrong, locale not found when triggering a task.\");\n        }\n        try {\n            const allIndexes = await listIndexes({\n                context: this.context,\n                plugins,\n                tenants: [tenant],\n                locales: [locale]\n            });\n            const indexes = allIndexes.filter(index => {\n                if (!targets?.length) {\n                    return true;\n                }\n                for (const t of targets) {\n                    if (index.index.includes(t)) {\n                        return true;\n                    }\n                }\n                return false;\n            });\n            if (indexes.length === 0) {\n                console.warn(\n                    \"There are no indexes to create before triggering the Create indexes task.\",\n                    {\n                        targets\n                    }\n                );\n                return;\n            }\n\n            const createIndex = createIndexFactory(this.indexManager);\n\n            for (const { index, settings } of indexes) {\n                try {\n                    console.log(\"Creating index\", index);\n                    await createIndex.createIfNotExists(index, settings);\n                } catch (ex) {\n                    console.error(`Failed to create index \"${index}\".`, ex);\n                }\n            }\n        } catch (ex) {\n            console.error(ex);\n        }\n    }\n}\n"],"mappings":";;;;;;AAEA,IAAAA,YAAA,GAAAC,OAAA;AACA,IAAAC,YAAA,GAAAD,OAAA;AACA,IAAAE,uCAAA,GAAAF,OAAA;AAOO,MAAMG,eAAe,CAAC;EAIlBC,WAAWA,CAACC,MAA8B,EAAE;IAC/C,IAAI,CAACC,OAAO,GAAGD,MAAM,CAACC,OAAO;IAC7B,IAAI,CAACC,YAAY,GAAGF,MAAM,CAACE,YAAY;EAC3C;EAEA,MAAaC,GAAGA,CAACC,OAA6B,EAAiB;IAC3D,MAAMC,OAAO,GAAG,IAAAC,8EAAsC,EAAU,IAAI,CAACL,OAAO,CAACI,OAAO,CAAC;IAErF,MAAME,MAAM,GAAG,IAAI,CAACN,OAAO,CAACO,OAAO,CAACC,gBAAgB,CAAC,CAAC;IACtD,IAAI,CAACF,MAAM,EAAEG,EAAE,EAAE;MACb,MAAM,IAAIC,KAAK,CAAC,gEAAgE,CAAC;IACrF;IACA,MAAMC,MAAM,GAAG,IAAI,CAACX,OAAO,CAACY,IAAI,CAACC,gBAAgB,CAAC,CAAC;IACnD,IAAI,CAACF,MAAM,EAAE;MACT,MAAM,IAAID,KAAK,CAAC,gEAAgE,CAAC;IACrF;IACA,IAAI;MACA,MAAMI,UAAU,GAAG,MAAM,IAAAC,wBAAW,EAAC;QACjCf,OAAO,EAAE,IAAI,CAACA,OAAO;QACrBI,OAAO;QACPY,OAAO,EAAE,CAACV,MAAM,CAAC;QACjBW,OAAO,EAAE,CAACN,MAAM;MACpB,CAAC,CAAC;MACF,MAAMO,OAAO,GAAGJ,UAAU,CAACK,MAAM,CAACC,KAAK,IAAI;QACvC,IAAI,CAACjB,OAAO,EAAEkB,MAAM,EAAE;UAClB,OAAO,IAAI;QACf;QACA,KAAK,MAAMC,CAAC,IAAInB,OAAO,EAAE;UACrB,IAAIiB,KAAK,CAACA,KAAK,CAACG,QAAQ,CAACD,CAAC,CAAC,EAAE;YACzB,OAAO,IAAI;UACf;QACJ;QACA,OAAO,KAAK;MAChB,CAAC,CAAC;MACF,IAAIJ,OAAO,CAACG,MAAM,KAAK,CAAC,EAAE;QACtBG,OAAO,CAACC,IAAI,CACR,2EAA2E,EAC3E;UACItB;QACJ,CACJ,CAAC;QACD;MACJ;MAEA,MAAMuB,WAAW,GAAG,IAAAC,+BAAkB,EAAC,IAAI,CAAC1B,YAAY,CAAC;MAEzD,KAAK,MAAM;QAAEmB,KAAK;QAAEQ;MAAS,CAAC,IAAIV,OAAO,EAAE;QACvC,IAAI;UACAM,OAAO,CAACK,GAAG,CAAC,gBAAgB,EAAET,KAAK,CAAC;UACpC,MAAMM,WAAW,CAACI,iBAAiB,CAACV,KAAK,EAAEQ,QAAQ,CAAC;QACxD,CAAC,CAAC,OAAOG,EAAE,EAAE;UACTP,OAAO,CAACQ,KAAK,CAAC,2BAA2BZ,KAAK,IAAI,EAAEW,EAAE,CAAC;QAC3D;MACJ;IACJ,CAAC,CAAC,OAAOA,EAAE,EAAE;MACTP,OAAO,CAACQ,KAAK,CAACD,EAAE,CAAC;IACrB;EACJ;AACJ;AAACE,OAAA,CAAApC,eAAA,GAAAA,eAAA","ignoreList":[]}

package/tasks/createIndexes/createIndex.d.ts

@@ -0,0 +1,5 @@
+import type { IndexManager } from "../../settings";
+export declare const createIndexFactory: (manager: IndexManager) => {
+    create: (index: string, settings?: Record<string, any>) => Promise<void>;
+    createIfNotExists: (index: string, settings?: Record<string, any>) => Promise<void>;
+};

package/tasks/createIndexes/createIndex.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createIndexFactory = void 0;
+const createIndexFactory = manager => {
+  return {
+    create: async (index, settings) => {
+      return manager.createIndex(index, settings);
+    },
+    createIfNotExists: async (index, settings) => {
+      try {
+        const exists = await manager.indexExists(index);
+        if (exists) {
+          return;
+        }
+      } catch (ex) {
+        return;
+      }
+      return await manager.createIndex(index, settings);
+    }
+  };
+};
+exports.createIndexFactory = createIndexFactory;
+
+//# sourceMappingURL=createIndex.js.map

package/tasks/createIndexes/createIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createIndexFactory","manager","create","index","settings","createIndex","createIfNotExists","exists","indexExists","ex","exports"],"sources":["createIndex.ts"],"sourcesContent":["import type { IndexManager } from \"~/settings\";\n\nexport const createIndexFactory = (manager: IndexManager) => {\n    return {\n        create: async (index: string, settings?: Record<string, any>): Promise<void> => {\n            return manager.createIndex(index, settings);\n        },\n        createIfNotExists: async (index: string, settings?: Record<string, any>): Promise<void> => {\n            try {\n                const exists = await manager.indexExists(index);\n                if (exists) {\n                    return;\n                }\n            } catch (ex) {\n                return;\n            }\n\n            return await manager.createIndex(index, settings);\n        }\n    };\n};\n"],"mappings":";;;;;;AAEO,MAAMA,kBAAkB,GAAIC,OAAqB,IAAK;EACzD,OAAO;IACHC,MAAM,EAAE,MAAAA,CAAOC,KAAa,EAAEC,QAA8B,KAAoB;MAC5E,OAAOH,OAAO,CAACI,WAAW,CAACF,KAAK,EAAEC,QAAQ,CAAC;IAC/C,CAAC;IACDE,iBAAiB,EAAE,MAAAA,CAAOH,KAAa,EAAEC,QAA8B,KAAoB;MACvF,IAAI;QACA,MAAMG,MAAM,GAAG,MAAMN,OAAO,CAACO,WAAW,CAACL,KAAK,CAAC;QAC/C,IAAII,MAAM,EAAE;UACR;QACJ;MACJ,CAAC,CAAC,OAAOE,EAAE,EAAE;QACT;MACJ;MAEA,OAAO,MAAMR,OAAO,CAACI,WAAW,CAACF,KAAK,EAAEC,QAAQ,CAAC;IACrD;EACJ,CAAC;AACL,CAAC;AAACM,OAAA,CAAAV,kBAAA,GAAAA,kBAAA","ignoreList":[]}

package/tasks/createIndexes/index.d.ts

@@ -0,0 +1,3 @@
+import type { Context, IElasticsearchTaskConfig } from "../../types";
+import type { IElasticsearchCreateIndexesTaskInput } from "./types";
+export declare const createIndexesTaskDefinition: (params?: IElasticsearchTaskConfig) => import("@webiny/tasks").TaskDefinitionPlugin<Context, IElasticsearchCreateIndexesTaskInput, import("@webiny/tasks").ITaskResponseDoneResultOutput>;