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

package/tasks/reindexing/ReindexingTaskRunner.js

@@ -0,0 +1,137 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ReindexingTaskRunner = void 0;
+var _scan = require("../../helpers/scan");
+var _dbDynamodb = require("@webiny/db-dynamodb");
+const getKeys = results => {
+  if (results.lastEvaluatedKey?.PK && results.lastEvaluatedKey?.SK) {
+    return {
+      PK: results.lastEvaluatedKey.PK,
+      SK: results.lastEvaluatedKey.SK
+    };
+  }
+  return undefined;
+};
+class ReindexingTaskRunner {
+  constructor(manager, indexManager) {
+    this.manager = manager;
+    this.response = manager.response;
+    this.indexManager = indexManager;
+  }
+
+  /**
+   * When running the task, we always must check:
+   * * if task is close to timeout
+   * * if task was aborted
+   */
+  async exec(keys = undefined, limit) {
+    this.keys = keys;
+    const isIndexAllowed = index => {
+      const input = this.manager.store.getInput();
+      if (typeof input.matching !== "string" || !input.matching) {
+        return true;
+      }
+      return index.includes(input.matching);
+    };
+    try {
+      while (this.manager.isCloseToTimeout() === false) {
+        if (this.manager.isAborted()) {
+          return this.response.aborted();
+        }
+        const results = await (0, _scan.scan)({
+          table: this.manager.table,
+          keys: this.keys,
+          options: {
+            limit
+          }
+        });
+        if (results.items.length === 0) {
+          await this.indexManager.enableIndexing();
+          return this.response.done("No more items to process.");
+        }
+        const tableWriteBatch = (0, _dbDynamodb.createTableWriteBatch)({
+          table: this.manager.table
+        });
+        for (const item of results.items) {
+          /**
+           * No index defined? Impossible but let's skip if really happens.
+           */
+          if (!item.index) {
+            continue;
+          }
+          if (isIndexAllowed(item.index) === false) {
+            continue;
+          }
+          const exists = await this.indexManager.indexExists(item.index);
+          if (!exists) {
+            await this.manager.store.addInfoLog({
+              message: `Index "${item.index}" does not exist. Skipping the item.`
+            });
+            continue;
+          }
+          /**
+           * Is there a possibility that entityName does not exist? What do we do at that point?
+           */
+          const entityName = item._et || item.entity;
+          /**
+           * Let's skip for now.
+           */
+          if (!entityName) {
+            continue;
+          }
+          const entity = this.manager.getEntity(entityName);
+          /**
+           * Disable the indexing for the current index.
+           * Method does nothing if indexing is already disabled.
+           */
+          await this.indexManager.disableIndexing(item.index);
+          /**
+           * Reindexing will be triggered by the `putBatch` method.
+           */
+          tableWriteBatch.put(entity.entity, {
+            ...item,
+            TYPE: item.TYPE || "unknown",
+            modified: new Date().toISOString()
+          });
+        }
+        await tableWriteBatch.execute();
+        /**
+         * We always store the index settings, so we can restore them later.
+         * Also, we always want to store what was the last key we processed, just in case something breaks, so we can continue from this point.
+         */
+        this.keys = getKeys(results);
+        await this.manager.store.updateInput({
+          settings: this.indexManager.settings,
+          keys: this.keys
+        });
+        /**
+         * We want to make sure that, if there are no last evaluated keys, we enable indexing.
+         */
+        if (!this.keys) {
+          await this.indexManager.enableIndexing();
+          return this.response.done("No more items to process - no last evaluated keys.");
+        }
+      }
+      return this.response.continue({
+        keys: this.keys
+      });
+    } catch (ex) {
+      /**
+       * We want to enable indexing if there was an error.
+       */
+      try {
+        await this.indexManager.enableIndexing();
+      } catch (er) {
+        er.data = ex;
+        return this.response.error(er);
+      }
+      return this.response.error(ex);
+    }
+  }
+}
+exports.ReindexingTaskRunner = ReindexingTaskRunner;
+
+//# sourceMappingURL=ReindexingTaskRunner.js.map

package/tasks/reindexing/ReindexingTaskRunner.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_scan","require","_dbDynamodb","getKeys","results","lastEvaluatedKey","PK","SK","undefined","ReindexingTaskRunner","constructor","manager","indexManager","response","exec","keys","limit","isIndexAllowed","index","input","store","getInput","matching","includes","isCloseToTimeout","isAborted","aborted","scan","table","options","items","length","enableIndexing","done","tableWriteBatch","createTableWriteBatch","item","exists","indexExists","addInfoLog","message","entityName","_et","entity","getEntity","disableIndexing","put","TYPE","modified","Date","toISOString","execute","updateInput","settings","continue","ex","er","data","error","exports"],"sources":["ReindexingTaskRunner.ts"],"sourcesContent":["import type {\n    IDynamoDbElasticsearchRecord,\n    IElasticsearchIndexingTaskValues,\n    IElasticsearchIndexingTaskValuesKeys,\n    IManager\n} from \"~/types\";\nimport type { ITaskResponse, ITaskResponseResult } from \"@webiny/tasks/response/abstractions\";\nimport { scan } from \"~/helpers/scan\";\nimport type { ScanResponse } from \"@webiny/db-dynamodb\";\nimport { createTableWriteBatch } from \"@webiny/db-dynamodb\";\nimport type { IndexManager } from \"~/settings\";\nimport type { IIndexManager } from \"~/settings/types\";\n\nconst getKeys = (results: ScanResponse): IElasticsearchIndexingTaskValuesKeys | undefined => {\n    if (results.lastEvaluatedKey?.PK && results.lastEvaluatedKey?.SK) {\n        return {\n            PK: results.lastEvaluatedKey.PK as unknown as string,\n            SK: results.lastEvaluatedKey.SK as unknown as string\n        };\n    }\n    return undefined;\n};\n\nexport class ReindexingTaskRunner {\n    private readonly manager: IManager<IElasticsearchIndexingTaskValues>;\n    private keys?: IElasticsearchIndexingTaskValuesKeys;\n\n    private readonly indexManager: IIndexManager;\n    private readonly response: ITaskResponse;\n\n    public constructor(\n        manager: IManager<IElasticsearchIndexingTaskValues>,\n        indexManager: IndexManager\n    ) {\n        this.manager = manager;\n        this.response = manager.response;\n        this.indexManager = indexManager;\n    }\n\n    /**\n     * When running the task, we always must check:\n     * * if task is close to timeout\n     * * if task was aborted\n     */\n    public async exec(\n        keys: IElasticsearchIndexingTaskValuesKeys | undefined = undefined,\n        limit: number\n    ): Promise<ITaskResponseResult> {\n        this.keys = keys;\n\n        const isIndexAllowed = (index: string): boolean => {\n            const input = this.manager.store.getInput();\n            if (typeof input.matching !== \"string\" || !input.matching) {\n                return true;\n            }\n            return index.includes(input.matching);\n        };\n\n        try {\n            while (this.manager.isCloseToTimeout() === false) {\n                if (this.manager.isAborted()) {\n                    return this.response.aborted();\n                }\n\n                const results = await scan<IDynamoDbElasticsearchRecord>({\n                    table: this.manager.table,\n                    keys: this.keys,\n                    options: {\n                        limit\n                    }\n                });\n                if (results.items.length === 0) {\n                    await this.indexManager.enableIndexing();\n                    return this.response.done(\"No more items to process.\");\n                }\n\n                const tableWriteBatch = createTableWriteBatch({\n                    table: this.manager.table\n                });\n\n                for (const item of results.items) {\n                    /**\n                     * No index defined? Impossible but let's skip if really happens.\n                     */\n                    if (!item.index) {\n                        continue;\n                    }\n                    if (isIndexAllowed(item.index) === false) {\n                        continue;\n                    }\n                    const exists = await this.indexManager.indexExists(item.index);\n                    if (!exists) {\n                        await this.manager.store.addInfoLog({\n                            message: `Index \"${item.index}\" does not exist. Skipping the item.`\n                        });\n                        continue;\n                    }\n                    /**\n                     * Is there a possibility that entityName does not exist? What do we do at that point?\n                     */\n                    const entityName = item._et || item.entity;\n                    /**\n                     * Let's skip for now.\n                     */\n                    if (!entityName) {\n                        continue;\n                    }\n                    const entity = this.manager.getEntity(entityName);\n                    /**\n                     * Disable the indexing for the current index.\n                     * Method does nothing if indexing is already disabled.\n                     */\n                    await this.indexManager.disableIndexing(item.index);\n                    /**\n                     * Reindexing will be triggered by the `putBatch` method.\n                     */\n                    tableWriteBatch.put(entity.entity, {\n                        ...item,\n                        TYPE: item.TYPE || \"unknown\",\n                        modified: new Date().toISOString()\n                    });\n                }\n                await tableWriteBatch.execute();\n                /**\n                 * We always store the index settings, so we can restore them later.\n                 * Also, we always want to store what was the last key we processed, just in case something breaks, so we can continue from this point.\n                 */\n                this.keys = getKeys(results);\n                await this.manager.store.updateInput({\n                    settings: this.indexManager.settings,\n                    keys: this.keys\n                });\n                /**\n                 * We want to make sure that, if there are no last evaluated keys, we enable indexing.\n                 */\n                if (!this.keys) {\n                    await this.indexManager.enableIndexing();\n                    return this.response.done(\"No more items to process - no last evaluated keys.\");\n                }\n            }\n            return this.response.continue({\n                keys: this.keys\n            });\n        } catch (ex) {\n            /**\n             * We want to enable indexing if there was an error.\n             */\n            try {\n                await this.indexManager.enableIndexing();\n            } catch (er) {\n                er.data = ex;\n                return this.response.error(er);\n            }\n            return this.response.error(ex);\n        }\n    }\n}\n"],"mappings":"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","ignoreList":[]}

package/tasks/reindexing/index.d.ts

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

package/tasks/reindexing/index.js

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

package/tasks/reindexing/index.js.map

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

package/tasks/reindexing/reindexingTaskDefinition.d.ts

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

package/tasks/reindexing/reindexingTaskDefinition.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createElasticsearchReindexingTask = void 0;
+var _tasks = require("@webiny/tasks");
+const createElasticsearchReindexingTask = params => {
+  return (0, _tasks.createTaskDefinition)({
+    id: "elasticsearchReindexing",
+    title: "Elasticsearch reindexing",
+    run: async ({
+      context,
+      isCloseToTimeout,
+      response,
+      input,
+      isAborted,
+      store,
+      timer
+    }) => {
+      const {
+        Manager
+      } = await import(/* webpackChunkName: "Manager" */"../Manager");
+      const {
+        IndexManager
+      } = await import(/* webpackChunkName: "IndexManager" */"../../settings");
+      const {
+        ReindexingTaskRunner
+      } = await import(/* webpackChunkName: "ReindexingTaskRunner" */"./ReindexingTaskRunner");
+      const manager = new Manager({
+        elasticsearchClient: params?.elasticsearchClient,
+        documentClient: params?.documentClient,
+        response,
+        context,
+        isAborted,
+        isCloseToTimeout,
+        store,
+        timer
+      });
+      const indexManager = new IndexManager(manager.elasticsearch, input.settings || {});
+      const reindexing = new ReindexingTaskRunner(manager, indexManager);
+      const keys = input.keys || undefined;
+      return reindexing.exec(keys, input.limit || 100);
+    }
+  });
+};
+exports.createElasticsearchReindexingTask = createElasticsearchReindexingTask;
+
+//# sourceMappingURL=reindexingTaskDefinition.js.map

package/tasks/reindexing/reindexingTaskDefinition.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_tasks","require","createElasticsearchReindexingTask","params","createTaskDefinition","id","title","run","context","isCloseToTimeout","response","input","isAborted","store","timer","Manager","IndexManager","ReindexingTaskRunner","manager","elasticsearchClient","documentClient","indexManager","elasticsearch","settings","reindexing","keys","undefined","exec","limit","exports"],"sources":["reindexingTaskDefinition.ts"],"sourcesContent":["import { createTaskDefinition } from \"@webiny/tasks\";\nimport type { Context, IElasticsearchIndexingTaskValues, IElasticsearchTaskConfig } from \"~/types\";\n\nexport const createElasticsearchReindexingTask = (params?: IElasticsearchTaskConfig) => {\n    return createTaskDefinition<Context, IElasticsearchIndexingTaskValues>({\n        id: \"elasticsearchReindexing\",\n        title: \"Elasticsearch reindexing\",\n        run: async ({ context, isCloseToTimeout, response, input, isAborted, store, timer }) => {\n            const { Manager } = await import(\n                /* webpackChunkName: \"Manager\" */\n                \"../Manager\"\n            );\n            const { IndexManager } = await import(\n                /* webpackChunkName: \"IndexManager\" */ \"~/settings\"\n            );\n            const { ReindexingTaskRunner } = await import(\n                /* webpackChunkName: \"ReindexingTaskRunner\" */ \"./ReindexingTaskRunner\"\n            );\n\n            const manager = new Manager<IElasticsearchIndexingTaskValues>({\n                elasticsearchClient: params?.elasticsearchClient,\n                documentClient: params?.documentClient,\n                response,\n                context,\n                isAborted,\n                isCloseToTimeout,\n                store,\n                timer\n            });\n\n            const indexManager = new IndexManager(manager.elasticsearch, input.settings || {});\n            const reindexing = new ReindexingTaskRunner(manager, indexManager);\n\n            const keys = input.keys || undefined;\n            return reindexing.exec(keys, input.limit || 100);\n        }\n    });\n};\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAGO,MAAMC,iCAAiC,GAAIC,MAAiC,IAAK;EACpF,OAAO,IAAAC,2BAAoB,EAA4C;IACnEC,EAAE,EAAE,yBAAyB;IAC7BC,KAAK,EAAE,0BAA0B;IACjCC,GAAG,EAAE,MAAAA,CAAO;MAAEC,OAAO;MAAEC,gBAAgB;MAAEC,QAAQ;MAAEC,KAAK;MAAEC,SAAS;MAAEC,KAAK;MAAEC;IAAM,CAAC,KAAK;MACpF,MAAM;QAAEC;MAAQ,CAAC,GAAG,MAAM,MAAM,CAC5B,6CAEJ,CAAC;MACD,MAAM;QAAEC;MAAa,CAAC,GAAG,MAAM,MAAM,CACjC,sDACJ,CAAC;MACD,MAAM;QAAEC;MAAqB,CAAC,GAAG,MAAM,MAAM,CACzC,sEACJ,CAAC;MAED,MAAMC,OAAO,GAAG,IAAIH,OAAO,CAAmC;QAC1DI,mBAAmB,EAAEhB,MAAM,EAAEgB,mBAAmB;QAChDC,cAAc,EAAEjB,MAAM,EAAEiB,cAAc;QACtCV,QAAQ;QACRF,OAAO;QACPI,SAAS;QACTH,gBAAgB;QAChBI,KAAK;QACLC;MACJ,CAAC,CAAC;MAEF,MAAMO,YAAY,GAAG,IAAIL,YAAY,CAACE,OAAO,CAACI,aAAa,EAAEX,KAAK,CAACY,QAAQ,IAAI,CAAC,CAAC,CAAC;MAClF,MAAMC,UAAU,GAAG,IAAIP,oBAAoB,CAACC,OAAO,EAAEG,YAAY,CAAC;MAElE,MAAMI,IAAI,GAAGd,KAAK,CAACc,IAAI,IAAIC,SAAS;MACpC,OAAOF,UAAU,CAACG,IAAI,CAACF,IAAI,EAAEd,KAAK,CAACiB,KAAK,IAAI,GAAG,CAAC;IACpD;EACJ,CAAC,CAAC;AACN,CAAC;AAACC,OAAA,CAAA3B,iCAAA,GAAAA,iCAAA","ignoreList":[]}

package/types.d.ts

@@ -0,0 +1,59 @@
+import type { ElasticsearchContext } from "@webiny/api-elasticsearch/types";
+import type { Context as TasksContext, IIsCloseToTimeoutCallable, ITaskManagerStore, ITaskResponse, ITaskResponseDoneResultOutput } from "@webiny/tasks/types";
+import type { DynamoDBDocument } from "@webiny/aws-sdk/client-dynamodb";
+import type { Client } from "@webiny/api-elasticsearch";
+import type { createTable } from "./definitions";
+import type { BatchReadItem, IEntity } from "@webiny/db-dynamodb";
+import type { ITimer } from "@webiny/handler-aws";
+import type { GenericRecord } from "@webiny/api/types";
+import type { Context as LoggerContext } from "@webiny/api-log/types";
+export interface Context extends ElasticsearchContext, TasksContext, LoggerContext {
+}
+export interface IElasticsearchTaskConfig {
+    documentClient?: DynamoDBDocument;
+    elasticsearchClient?: Client;
+}
+export interface IElasticsearchIndexingTaskValuesKeys {
+    PK: string;
+    SK: string;
+}
+export interface IIndexSettingsValues {
+    numberOfReplicas: number;
+    refreshInterval: string;
+}
+export interface IElasticsearchIndexingTaskValuesSettings {
+    [key: string]: IIndexSettingsValues;
+}
+export interface IElasticsearchIndexingTaskValues {
+    matching?: string;
+    limit?: number;
+    keys?: IElasticsearchIndexingTaskValuesKeys;
+    settings?: IElasticsearchIndexingTaskValuesSettings;
+}
+export interface AugmentedError extends Error {
+    data?: GenericRecord;
+    [key: string]: any;
+}
+export interface IDynamoDbElasticsearchRecord {
+    PK: string;
+    SK: string;
+    TYPE?: string;
+    index: string;
+    _et?: string;
+    entity: string;
+    data: GenericRecord;
+    modified: string;
+}
+export interface IManager<T, O extends ITaskResponseDoneResultOutput = ITaskResponseDoneResultOutput> {
+    readonly documentClient: DynamoDBDocument;
+    readonly elasticsearch: Client;
+    readonly context: Context;
+    readonly table: ReturnType<typeof createTable>;
+    readonly isCloseToTimeout: IIsCloseToTimeoutCallable;
+    readonly isAborted: () => boolean;
+    readonly response: ITaskResponse<T, O>;
+    readonly store: ITaskManagerStore<T>;
+    readonly timer: ITimer;
+    getEntity: (name: string) => IEntity;
+    read<T>(items: BatchReadItem[]): Promise<T[]>;
+}

package/types.js

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

package/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import type { ElasticsearchContext } from \"@webiny/api-elasticsearch/types\";\nimport type {\n    Context as TasksContext,\n    IIsCloseToTimeoutCallable,\n    ITaskManagerStore,\n    ITaskResponse,\n    ITaskResponseDoneResultOutput\n} from \"@webiny/tasks/types\";\nimport type { DynamoDBDocument } from \"@webiny/aws-sdk/client-dynamodb\";\nimport type { Client } from \"@webiny/api-elasticsearch\";\nimport type { createTable } from \"~/definitions\";\nimport type { BatchReadItem, IEntity } from \"@webiny/db-dynamodb\";\nimport type { ITimer } from \"@webiny/handler-aws\";\nimport type { GenericRecord } from \"@webiny/api/types\";\nimport type { Context as LoggerContext } from \"@webiny/api-log/types\";\n\nexport interface Context extends ElasticsearchContext, TasksContext, LoggerContext {}\n\nexport interface IElasticsearchTaskConfig {\n    documentClient?: DynamoDBDocument;\n    elasticsearchClient?: Client;\n}\n\nexport interface IElasticsearchIndexingTaskValuesKeys {\n    PK: string;\n    SK: string;\n}\n\nexport interface IIndexSettingsValues {\n    numberOfReplicas: number;\n    refreshInterval: string;\n}\n\nexport interface IElasticsearchIndexingTaskValuesSettings {\n    [key: string]: IIndexSettingsValues;\n}\n\nexport interface IElasticsearchIndexingTaskValues {\n    matching?: string;\n    limit?: number;\n    keys?: IElasticsearchIndexingTaskValuesKeys;\n    settings?: IElasticsearchIndexingTaskValuesSettings;\n}\n\nexport interface AugmentedError extends Error {\n    data?: GenericRecord;\n    [key: string]: any;\n}\n\nexport interface IDynamoDbElasticsearchRecord {\n    PK: string;\n    SK: string;\n    TYPE?: string;\n    index: string;\n    _et?: string;\n    entity: string;\n    data: GenericRecord;\n    modified: string;\n}\n\nexport interface IManager<\n    T,\n    O extends ITaskResponseDoneResultOutput = ITaskResponseDoneResultOutput\n> {\n    readonly documentClient: DynamoDBDocument;\n    readonly elasticsearch: Client;\n    readonly context: Context;\n    readonly table: ReturnType<typeof createTable>;\n    readonly isCloseToTimeout: IIsCloseToTimeoutCallable;\n    readonly isAborted: () => boolean;\n    readonly response: ITaskResponse<T, O>;\n    readonly store: ITaskManagerStore<T>;\n    readonly timer: ITimer;\n\n    getEntity: (name: string) => IEntity;\n\n    read<T>(items: BatchReadItem[]): Promise<T[]>;\n}\n"],"mappings":"","ignoreList":[]}