@webiny/api-headless-cms-bulk-actions 0.0.0-unstable.e53eceafb5

package/useCases/internals/ChildTaskCleanup/ChildTasksCleanup.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ChildTasksCleanup = void 0;
+var _tasks = require("@webiny/tasks");
+/**
+ * Cleanup of the child tasks.
+ * This code will remove all the child tasks and their logs, which have no errors in them.
+ */
+class ChildTasksCleanup {
+  async execute(params) {
+    const {
+      context,
+      task
+    } = params;
+    const {
+      items: childTasks
+    } = await context.tasks.listTasks({
+      where: {
+        parentId: task.id
+      },
+      // Really doubtful there will be more than 10k of child tasks.
+      limit: 10000
+    });
+    if (childTasks.length === 0) {
+      return;
+    }
+    const childTaskIdList = childTasks.map(childTask => childTask.id);
+    const {
+      items: childLogs
+    } = await context.tasks.listLogs({
+      where: {
+        task_in: childTaskIdList
+      },
+      limit: 10000
+    });
+
+    /**
+     * No logs found. Proceed with deleting the child tasks.
+     */
+    if (childLogs.length === 0) {
+      await this.deleteTasks(context, childTaskIdList);
+    }
+    const deletedChildTaskLogIdList = [];
+    /**
+     * First, we need to remove all the logs which have no errors.
+     */
+    for (const log of childLogs) {
+      if (log.items.some(item => item.type === _tasks.TaskLogItemType.ERROR)) {
+        continue;
+      }
+      await context.tasks.deleteLog(log.id);
+      if (deletedChildTaskLogIdList.includes(log.task)) {
+        continue;
+      }
+      deletedChildTaskLogIdList.push(log.task);
+    }
+    /**
+     * Now we can remove the tasks.
+     */
+    await this.deleteTasks(context, deletedChildTaskLogIdList);
+  }
+
+  /**
+   * Helper method to delete tasks by ID.
+   */
+  async deleteTasks(context, taskIds) {
+    for (const taskId of taskIds) {
+      await context.tasks.deleteTask(taskId);
+    }
+  }
+}
+exports.ChildTasksCleanup = ChildTasksCleanup;
+
+//# sourceMappingURL=ChildTasksCleanup.js.map

package/useCases/internals/ChildTaskCleanup/ChildTasksCleanup.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_tasks","require","ChildTasksCleanup","execute","params","context","task","items","childTasks","tasks","listTasks","where","parentId","id","limit","length","childTaskIdList","map","childTask","childLogs","listLogs","task_in","deleteTasks","deletedChildTaskLogIdList","log","some","item","type","TaskLogItemType","ERROR","deleteLog","includes","push","taskIds","taskId","deleteTask","exports"],"sources":["ChildTasksCleanup.ts"],"sourcesContent":["import type { ITask, Context } from \"@webiny/tasks\";\nimport { TaskLogItemType } from \"@webiny/tasks\";\nimport type { IUseCase } from \"~/abstractions\";\nimport type { HcmsBulkActionsContext } from \"~/types\";\n\nexport interface IChildTasksCleanupExecuteParams {\n    context: Context;\n    task: ITask;\n}\n\n/**\n * Cleanup of the child tasks.\n * This code will remove all the child tasks and their logs, which have no errors in them.\n */\nexport class ChildTasksCleanup implements IUseCase<IChildTasksCleanupExecuteParams, void> {\n    public async execute(params: IChildTasksCleanupExecuteParams): Promise<void> {\n        const { context, task } = params;\n\n        const { items: childTasks } = await context.tasks.listTasks({\n            where: {\n                parentId: task.id\n            },\n            // Really doubtful there will be more than 10k of child tasks.\n            limit: 10000\n        });\n\n        if (childTasks.length === 0) {\n            return;\n        }\n\n        const childTaskIdList = childTasks.map(childTask => childTask.id);\n\n        const { items: childLogs } = await context.tasks.listLogs({\n            where: {\n                task_in: childTaskIdList\n            },\n            limit: 10000\n        });\n\n        /**\n         * No logs found. Proceed with deleting the child tasks.\n         */\n        if (childLogs.length === 0) {\n            await this.deleteTasks(context, childTaskIdList);\n        }\n\n        const deletedChildTaskLogIdList: string[] = [];\n        /**\n         * First, we need to remove all the logs which have no errors.\n         */\n        for (const log of childLogs) {\n            if (log.items.some(item => item.type === TaskLogItemType.ERROR)) {\n                continue;\n            }\n            await context.tasks.deleteLog(log.id);\n            if (deletedChildTaskLogIdList.includes(log.task)) {\n                continue;\n            }\n            deletedChildTaskLogIdList.push(log.task);\n        }\n        /**\n         * Now we can remove the tasks.\n         */\n        await this.deleteTasks(context, deletedChildTaskLogIdList);\n    }\n\n    /**\n     * Helper method to delete tasks by ID.\n     */\n    private async deleteTasks(context: HcmsBulkActionsContext, taskIds: string[]): Promise<void> {\n        for (const taskId of taskIds) {\n            await context.tasks.deleteTask(taskId);\n        }\n    }\n}\n"],"mappings":";;;;;;AACA,IAAAA,MAAA,GAAAC,OAAA;AASA;AACA;AACA;AACA;AACO,MAAMC,iBAAiB,CAA4D;EACtF,MAAaC,OAAOA,CAACC,MAAuC,EAAiB;IACzE,MAAM;MAAEC,OAAO;MAAEC;IAAK,CAAC,GAAGF,MAAM;IAEhC,MAAM;MAAEG,KAAK,EAAEC;IAAW,CAAC,GAAG,MAAMH,OAAO,CAACI,KAAK,CAACC,SAAS,CAAC;MACxDC,KAAK,EAAE;QACHC,QAAQ,EAAEN,IAAI,CAACO;MACnB,CAAC;MACD;MACAC,KAAK,EAAE;IACX,CAAC,CAAC;IAEF,IAAIN,UAAU,CAACO,MAAM,KAAK,CAAC,EAAE;MACzB;IACJ;IAEA,MAAMC,eAAe,GAAGR,UAAU,CAACS,GAAG,CAACC,SAAS,IAAIA,SAAS,CAACL,EAAE,CAAC;IAEjE,MAAM;MAAEN,KAAK,EAAEY;IAAU,CAAC,GAAG,MAAMd,OAAO,CAACI,KAAK,CAACW,QAAQ,CAAC;MACtDT,KAAK,EAAE;QACHU,OAAO,EAAEL;MACb,CAAC;MACDF,KAAK,EAAE;IACX,CAAC,CAAC;;IAEF;AACR;AACA;IACQ,IAAIK,SAAS,CAACJ,MAAM,KAAK,CAAC,EAAE;MACxB,MAAM,IAAI,CAACO,WAAW,CAACjB,OAAO,EAAEW,eAAe,CAAC;IACpD;IAEA,MAAMO,yBAAmC,GAAG,EAAE;IAC9C;AACR;AACA;IACQ,KAAK,MAAMC,GAAG,IAAIL,SAAS,EAAE;MACzB,IAAIK,GAAG,CAACjB,KAAK,CAACkB,IAAI,CAACC,IAAI,IAAIA,IAAI,CAACC,IAAI,KAAKC,sBAAe,CAACC,KAAK,CAAC,EAAE;QAC7D;MACJ;MACA,MAAMxB,OAAO,CAACI,KAAK,CAACqB,SAAS,CAACN,GAAG,CAACX,EAAE,CAAC;MACrC,IAAIU,yBAAyB,CAACQ,QAAQ,CAACP,GAAG,CAAClB,IAAI,CAAC,EAAE;QAC9C;MACJ;MACAiB,yBAAyB,CAACS,IAAI,CAACR,GAAG,CAAClB,IAAI,CAAC;IAC5C;IACA;AACR;AACA;IACQ,MAAM,IAAI,CAACgB,WAAW,CAACjB,OAAO,EAAEkB,yBAAyB,CAAC;EAC9D;;EAEA;AACJ;AACA;EACI,MAAcD,WAAWA,CAACjB,OAA+B,EAAE4B,OAAiB,EAAiB;IACzF,KAAK,MAAMC,MAAM,IAAID,OAAO,EAAE;MAC1B,MAAM5B,OAAO,CAACI,KAAK,CAAC0B,UAAU,CAACD,MAAM,CAAC;IAC1C;EACJ;AACJ;AAACE,OAAA,CAAAlC,iBAAA,GAAAA,iBAAA","ignoreList":[]}

package/useCases/internals/ChildTaskCleanup/index.d.ts

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

package/useCases/internals/ChildTaskCleanup/index.js

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

package/useCases/internals/ChildTaskCleanup/index.js.map

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

package/useCases/internals/CreateTasksByModel/CreateTasksByModel.d.ts

@@ -0,0 +1,13 @@
+import type { ITaskResponseResult } from "@webiny/tasks";
+import type { IListEntries } from "../../../abstractions";
+import type { IBulkActionOperationByModelTaskParams } from "../../../types";
+/**
+ * The `CreateTasksByModel` class handles the execution of a task to process entries in batches.
+ */
+export declare class CreateTasksByModel {
+    private readonly taskCache;
+    private listEntriesGateway;
+    private readonly batchSize;
+    constructor(taskDefinition: string, listEntriesGateway: IListEntries, batchSize: number);
+    execute(params: IBulkActionOperationByModelTaskParams): Promise<ITaskResponseResult>;
+}

package/useCases/internals/CreateTasksByModel/CreateTasksByModel.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CreateTasksByModel = void 0;
+var _TaskCache = require("./TaskCache");
+var _types = require("../../../types");
+const MAX_TASK_LIST_LENGTH = 10;
+
+/**
+ * The `CreateTasksByModel` class handles the execution of a task to process entries in batches.
+ */
+class CreateTasksByModel {
+  constructor(taskDefinition, listEntriesGateway, batchSize) {
+    this.taskCache = new _TaskCache.TaskCache(taskDefinition);
+    this.listEntriesGateway = listEntriesGateway;
+    this.batchSize = batchSize;
+  }
+  async execute(params) {
+    const {
+      response,
+      input,
+      isAborted,
+      isCloseToTimeout,
+      context,
+      store
+    } = params;
+    try {
+      const listEntriesParams = {
+        where: input.where,
+        search: input.search,
+        after: input.after,
+        limit: this.batchSize
+      };
+      while (true) {
+        if (isAborted()) {
+          return response.aborted();
+        } else if (isCloseToTimeout()) {
+          await this.taskCache.triggerTask(context, store.getTask());
+          return response.continue({
+            ...input,
+            action: _types.BulkActionOperationByModelAction.PROCESS_SUBTASKS
+          });
+        }
+
+        // List entries from the HCMS based on the provided query
+        const {
+          entries,
+          meta
+        } = await this.listEntriesGateway.execute(input.modelId, listEntriesParams);
+
+        // End the task if no entries match the query
+        if (meta.totalCount === 0) {
+          return response.continue({
+            ...input,
+            action: _types.BulkActionOperationByModelAction.END_TASK
+          });
+        }
+
+        // Continue processing if we are reached the task list length limit
+        if (this.taskCache.getTasksLength() === MAX_TASK_LIST_LENGTH) {
+          await this.taskCache.triggerTask(context, store.getTask());
+          return response.continue({
+            ...input,
+            action: _types.BulkActionOperationByModelAction.PROCESS_SUBTASKS
+          });
+        }
+
+        // Continue processing if no entries are returned in the current batch
+        if (entries.length === 0) {
+          await this.taskCache.triggerTask(context, store.getTask());
+          return response.continue({
+            ...input,
+            action: _types.BulkActionOperationByModelAction.PROCESS_SUBTASKS
+          });
+        }
+
+        // Extract entry IDs
+        const ids = [];
+        for (let i = 0; i < entries.length; i++) {
+          ids.push(entries[i].id);
+        }
+        if (ids.length > 0) {
+          // Cache the task with the entry IDs
+          this.taskCache.cacheTask({
+            modelId: input.modelId,
+            identity: input.identity,
+            data: input.data,
+            ids
+          });
+        }
+
+        // Continue processing if there are no more entries or pagination is complete
+        if (!meta.hasMoreItems || !meta.cursor) {
+          await this.taskCache.triggerTask(context, store.getTask());
+          return response.continue({
+            ...input,
+            action: _types.BulkActionOperationByModelAction.PROCESS_SUBTASKS
+          });
+        }
+        listEntriesParams.after = meta.cursor;
+      }
+    } catch (ex) {
+      return response.error(ex.message ?? `Error while creating task.`);
+    }
+  }
+}
+exports.CreateTasksByModel = CreateTasksByModel;
+
+//# sourceMappingURL=CreateTasksByModel.js.map

package/useCases/internals/CreateTasksByModel/CreateTasksByModel.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_TaskCache","require","_types","MAX_TASK_LIST_LENGTH","CreateTasksByModel","constructor","taskDefinition","listEntriesGateway","batchSize","taskCache","TaskCache","execute","params","response","input","isAborted","isCloseToTimeout","context","store","listEntriesParams","where","search","after","limit","aborted","triggerTask","getTask","continue","action","BulkActionOperationByModelAction","PROCESS_SUBTASKS","entries","meta","modelId","totalCount","END_TASK","getTasksLength","length","ids","i","push","id","cacheTask","identity","data","hasMoreItems","cursor","ex","error","message","exports"],"sources":["CreateTasksByModel.ts"],"sourcesContent":["import type { ITaskResponseResult } from \"@webiny/tasks\";\nimport { TaskCache } from \"./TaskCache\";\nimport type { CmsEntryListParams } from \"@webiny/api-headless-cms/types\";\nimport type { IListEntries } from \"~/abstractions\";\nimport type { IBulkActionOperationByModelTaskParams } from \"~/types\";\nimport { BulkActionOperationByModelAction } from \"~/types\";\n\nconst MAX_TASK_LIST_LENGTH = 10;\n\n/**\n * The `CreateTasksByModel` class handles the execution of a task to process entries in batches.\n */\nexport class CreateTasksByModel {\n    private readonly taskCache: TaskCache;\n    private listEntriesGateway: IListEntries;\n    private readonly batchSize: number;\n\n    constructor(taskDefinition: string, listEntriesGateway: IListEntries, batchSize: number) {\n        this.taskCache = new TaskCache(taskDefinition);\n        this.listEntriesGateway = listEntriesGateway;\n        this.batchSize = batchSize;\n    }\n\n    async execute(params: IBulkActionOperationByModelTaskParams): Promise<ITaskResponseResult> {\n        const { response, input, isAborted, isCloseToTimeout, context, store } = params;\n\n        try {\n            const listEntriesParams: CmsEntryListParams = {\n                where: input.where,\n                search: input.search,\n                after: input.after,\n                limit: this.batchSize\n            };\n\n            while (true) {\n                if (isAborted()) {\n                    return response.aborted();\n                } else if (isCloseToTimeout()) {\n                    await this.taskCache.triggerTask(context, store.getTask());\n                    return response.continue({\n                        ...input,\n                        action: BulkActionOperationByModelAction.PROCESS_SUBTASKS\n                    });\n                }\n\n                // List entries from the HCMS based on the provided query\n                const { entries, meta } = await this.listEntriesGateway.execute(\n                    input.modelId,\n                    listEntriesParams\n                );\n\n                // End the task if no entries match the query\n                if (meta.totalCount === 0) {\n                    return response.continue({\n                        ...input,\n                        action: BulkActionOperationByModelAction.END_TASK\n                    });\n                }\n\n                // Continue processing if we are reached the task list length limit\n                if (this.taskCache.getTasksLength() === MAX_TASK_LIST_LENGTH) {\n                    await this.taskCache.triggerTask(context, store.getTask());\n                    return response.continue({\n                        ...input,\n                        action: BulkActionOperationByModelAction.PROCESS_SUBTASKS\n                    });\n                }\n\n                // Continue processing if no entries are returned in the current batch\n                if (entries.length === 0) {\n                    await this.taskCache.triggerTask(context, store.getTask());\n                    return response.continue({\n                        ...input,\n                        action: BulkActionOperationByModelAction.PROCESS_SUBTASKS\n                    });\n                }\n\n                // Extract entry IDs\n                const ids: string[] = [];\n                for (let i = 0; i < entries.length; i++) {\n                    ids.push(entries[i].id);\n                }\n\n                if (ids.length > 0) {\n                    // Cache the task with the entry IDs\n                    this.taskCache.cacheTask({\n                        modelId: input.modelId,\n                        identity: input.identity,\n                        data: input.data,\n                        ids\n                    });\n                }\n\n                // Continue processing if there are no more entries or pagination is complete\n                if (!meta.hasMoreItems || !meta.cursor) {\n                    await this.taskCache.triggerTask(context, store.getTask());\n\n                    return response.continue({\n                        ...input,\n                        action: BulkActionOperationByModelAction.PROCESS_SUBTASKS\n                    });\n                }\n\n                listEntriesParams.after = meta.cursor;\n            }\n        } catch (ex) {\n            return response.error(ex.message ?? `Error while creating task.`);\n        }\n    }\n}\n"],"mappings":"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","ignoreList":[]}

package/useCases/internals/CreateTasksByModel/TaskCache.d.ts

@@ -0,0 +1,36 @@
+import type { HcmsBulkActionsContext } from "../../../types";
+import type { ITask, ITaskDataInput } from "@webiny/tasks";
+/**
+ * TaskCache class for managing and triggering cached tasks.
+ * @template TTask - Task input data.
+ */
+export declare class TaskCache<TTask = ITaskDataInput> {
+    private readonly taskDefinition;
+    private taskCache;
+    constructor(taskDefinition: string);
+    /**
+     * Adds a task to the cache.
+     * @param {TTask} item - The task input data to be cached.
+     */
+    cacheTask(item: TTask): void;
+    /**
+     * Triggers all cached tasks using the provided context and parent task.
+     * @param {HcmsBulkActionsContext} context - The context used to trigger the tasks.
+     * @param {ITask} parent - The parent task to associate with the triggered tasks.
+     */
+    triggerTask(context: HcmsBulkActionsContext, parent: ITask): Promise<void>;
+    /**
+     * Retrieves the cached tasks length.
+     * @returns number
+     */
+    getTasksLength(): number;
+    /**
+     * Retrieves the cached tasks.
+     * @returns {TTask[]} The list of cached tasks.
+     */
+    private getTasks;
+    /**
+     * Clears all cached tasks.
+     */
+    private clearTasks;
+}

package/useCases/internals/CreateTasksByModel/TaskCache.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TaskCache = void 0;
+/**
+ * TaskCache class for managing and triggering cached tasks.
+ * @template TTask - Task input data.
+ */
+class TaskCache {
+  taskCache = [];
+  constructor(taskDefinition) {
+    this.taskDefinition = taskDefinition;
+  }
+
+  /**
+   * Adds a task to the cache.
+   * @param {TTask} item - The task input data to be cached.
+   */
+  cacheTask(item) {
+    this.taskCache.push(item);
+  }
+
+  /**
+   * Triggers all cached tasks using the provided context and parent task.
+   * @param {HcmsBulkActionsContext} context - The context used to trigger the tasks.
+   * @param {ITask} parent - The parent task to associate with the triggered tasks.
+   */
+  async triggerTask(context, parent) {
+    const tasks = this.getTasks();
+    if (tasks.length === 0) {
+      return;
+    }
+    for (const task of tasks) {
+      try {
+        await context.tasks.trigger({
+          definition: this.taskDefinition,
+          parent,
+          input: task
+        });
+      } catch (error) {
+        console.error(`Error triggering task.`, error);
+      }
+    }
+
+    // Clear the cache after processing
+    this.clearTasks();
+  }
+
+  /**
+   * Retrieves the cached tasks length.
+   * @returns number
+   */
+  getTasksLength() {
+    return this.getTasks().length;
+  }
+
+  /**
+   * Retrieves the cached tasks.
+   * @returns {TTask[]} The list of cached tasks.
+   */
+  getTasks() {
+    return this.taskCache;
+  }
+
+  /**
+   * Clears all cached tasks.
+   */
+  clearTasks() {
+    this.taskCache = [];
+  }
+}
+exports.TaskCache = TaskCache;
+
+//# sourceMappingURL=TaskCache.js.map

package/useCases/internals/CreateTasksByModel/TaskCache.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TaskCache","taskCache","constructor","taskDefinition","cacheTask","item","push","triggerTask","context","parent","tasks","getTasks","length","task","trigger","definition","input","error","console","clearTasks","getTasksLength","exports"],"sources":["TaskCache.ts"],"sourcesContent":["import type { HcmsBulkActionsContext } from \"~/types\";\nimport type { ITask, ITaskDataInput } from \"@webiny/tasks\";\n\n/**\n * TaskCache class for managing and triggering cached tasks.\n * @template TTask - Task input data.\n */\nexport class TaskCache<TTask = ITaskDataInput> {\n    private readonly taskDefinition: string;\n    private taskCache: TTask[] = [];\n\n    constructor(taskDefinition: string) {\n        this.taskDefinition = taskDefinition;\n    }\n\n    /**\n     * Adds a task to the cache.\n     * @param {TTask} item - The task input data to be cached.\n     */\n    cacheTask(item: TTask) {\n        this.taskCache.push(item);\n    }\n\n    /**\n     * Triggers all cached tasks using the provided context and parent task.\n     * @param {HcmsBulkActionsContext} context - The context used to trigger the tasks.\n     * @param {ITask} parent - The parent task to associate with the triggered tasks.\n     */\n    async triggerTask(context: HcmsBulkActionsContext, parent: ITask) {\n        const tasks = this.getTasks();\n\n        if (tasks.length === 0) {\n            return;\n        }\n\n        for (const task of tasks) {\n            try {\n                await context.tasks.trigger<TTask>({\n                    definition: this.taskDefinition,\n                    parent,\n                    input: task\n                });\n            } catch (error) {\n                console.error(`Error triggering task.`, error);\n            }\n        }\n\n        // Clear the cache after processing\n        this.clearTasks();\n    }\n\n    /**\n     * Retrieves the cached tasks length.\n     * @returns number\n     */\n    getTasksLength() {\n        return this.getTasks().length;\n    }\n\n    /**\n     * Retrieves the cached tasks.\n     * @returns {TTask[]} The list of cached tasks.\n     */\n    private getTasks() {\n        return this.taskCache;\n    }\n\n    /**\n     * Clears all cached tasks.\n     */\n    private clearTasks() {\n        this.taskCache = [];\n    }\n}\n"],"mappings":";;;;;;AAGA;AACA;AACA;AACA;AACO,MAAMA,SAAS,CAAyB;EAEnCC,SAAS,GAAY,EAAE;EAE/BC,WAAWA,CAACC,cAAsB,EAAE;IAChC,IAAI,CAACA,cAAc,GAAGA,cAAc;EACxC;;EAEA;AACJ;AACA;AACA;EACIC,SAASA,CAACC,IAAW,EAAE;IACnB,IAAI,CAACJ,SAAS,CAACK,IAAI,CAACD,IAAI,CAAC;EAC7B;;EAEA;AACJ;AACA;AACA;AACA;EACI,MAAME,WAAWA,CAACC,OAA+B,EAAEC,MAAa,EAAE;IAC9D,MAAMC,KAAK,GAAG,IAAI,CAACC,QAAQ,CAAC,CAAC;IAE7B,IAAID,KAAK,CAACE,MAAM,KAAK,CAAC,EAAE;MACpB;IACJ;IAEA,KAAK,MAAMC,IAAI,IAAIH,KAAK,EAAE;MACtB,IAAI;QACA,MAAMF,OAAO,CAACE,KAAK,CAACI,OAAO,CAAQ;UAC/BC,UAAU,EAAE,IAAI,CAACZ,cAAc;UAC/BM,MAAM;UACNO,KAAK,EAAEH;QACX,CAAC,CAAC;MACN,CAAC,CAAC,OAAOI,KAAK,EAAE;QACZC,OAAO,CAACD,KAAK,CAAC,wBAAwB,EAAEA,KAAK,CAAC;MAClD;IACJ;;IAEA;IACA,IAAI,CAACE,UAAU,CAAC,CAAC;EACrB;;EAEA;AACJ;AACA;AACA;EACIC,cAAcA,CAAA,EAAG;IACb,OAAO,IAAI,CAACT,QAAQ,CAAC,CAAC,CAACC,MAAM;EACjC;;EAEA;AACJ;AACA;AACA;EACYD,QAAQA,CAAA,EAAG;IACf,OAAO,IAAI,CAACV,SAAS;EACzB;;EAEA;AACJ;AACA;EACYkB,UAAUA,CAAA,EAAG;IACjB,IAAI,CAAClB,SAAS,GAAG,EAAE;EACvB;AACJ;AAACoB,OAAA,CAAArB,SAAA,GAAAA,SAAA","ignoreList":[]}

package/useCases/internals/CreateTasksByModel/index.d.ts

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

package/useCases/internals/CreateTasksByModel/index.js

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

package/useCases/internals/CreateTasksByModel/index.js.map

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

package/useCases/internals/ProcessTask/ProcessTask.d.ts

@@ -0,0 +1,14 @@
+import type { IBulkActionOperationTaskParams } from "../../../types";
+import type { IProcessEntry } from "../../../abstractions";
+/**
+ * The `ProcessTask` class is responsible for processing a batch of entries
+ * based on the provided parameters. It uses a gateway to perform the actual
+ * processing and maintains the results of the operations, including successfully
+ * processed and failed entries.
+ */
+export declare class ProcessTask {
+    private readonly result;
+    private gateway;
+    constructor(gateway: IProcessEntry);
+    execute(params: IBulkActionOperationTaskParams): Promise<import("@webiny/tasks").ITaskResponseErrorResult | import("@webiny/tasks").ITaskResponseAbortedResult | import("@webiny/tasks").ITaskResponseContinueResult<import("../../../types").IBulkActionOperationInput> | import("@webiny/tasks").ITaskResponseDoneResult<import("../../../types").IBulkActionOperationOutput>>;
+}

package/useCases/internals/ProcessTask/ProcessTask.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ProcessTask = void 0;
+var _Result = require("./Result");
+/**
+ * The `ProcessTask` class is responsible for processing a batch of entries
+ * based on the provided parameters. It uses a gateway to perform the actual
+ * processing and maintains the results of the operations, including successfully
+ * processed and failed entries.
+ */
+class ProcessTask {
+  constructor(gateway) {
+    this.result = new _Result.Result();
+    this.gateway = gateway;
+  }
+  async execute(params) {
+    const {
+      input,
+      response,
+      isAborted,
+      isCloseToTimeout,
+      context
+    } = params;
+    try {
+      if (isAborted()) {
+        return response.aborted();
+      } else if (isCloseToTimeout()) {
+        return response.continue({
+          ...input
+        });
+      }
+
+      // Check if the input contains a model ID.
+      if (!input.modelId) {
+        return response.error(`Missing "modelId" in the input.`);
+      }
+
+      // Check if the model exists.
+      const model = await context.cms.getModel(input.modelId);
+      if (!model) {
+        return response.error(`Model with ${input.modelId} not found!`);
+      }
+
+      // Check if there are any IDs to process.
+      if (!input.ids || input.ids.length === 0) {
+        return response.done(`Task done: no entries to process for "${input.modelId}" model.`);
+      }
+
+      // Set the security identity in the context.
+      context.security.setIdentity(input.identity);
+
+      // Process each ID in the input.
+      for (const id of input.ids) {
+        try {
+          // Execute the gateway operation for the current ID.
+          await this.gateway.execute(model, id, input.data);
+          // Add the ID to the list of successfully processed entries.
+          this.result.addDone(id);
+        } catch (ex) {
+          console.error(ex.message || `Failed to process entry with id "${id}".`);
+          // Add the ID to the list of failed entries.
+          this.result.addFailed(id);
+        }
+      }
+
+      // Return a done response with the results of the processing.
+      return response.done(`Task done: all entries processed for "${model.name}" model.`, {
+        done: this.result.getDone(),
+        failed: this.result.getFailed()
+      });
+    } catch (ex) {
+      return response.error(ex.message ?? `Error while processing task.`);
+    }
+  }
+}
+exports.ProcessTask = ProcessTask;
+
+//# sourceMappingURL=ProcessTask.js.map

package/useCases/internals/ProcessTask/ProcessTask.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_Result","require","ProcessTask","constructor","gateway","result","Result","execute","params","input","response","isAborted","isCloseToTimeout","context","aborted","continue","modelId","error","model","cms","getModel","ids","length","done","security","setIdentity","identity","id","data","addDone","ex","console","message","addFailed","name","getDone","failed","getFailed","exports"],"sources":["ProcessTask.ts"],"sourcesContent":["import { Result } from \"./Result\";\nimport type { IBulkActionOperationTaskParams } from \"~/types\";\nimport type { IProcessEntry } from \"~/abstractions\";\n\n/**\n * The `ProcessTask` class is responsible for processing a batch of entries\n * based on the provided parameters. It uses a gateway to perform the actual\n * processing and maintains the results of the operations, including successfully\n * processed and failed entries.\n */\nexport class ProcessTask {\n    private readonly result: Result;\n    private gateway: IProcessEntry;\n\n    constructor(gateway: IProcessEntry) {\n        this.result = new Result();\n        this.gateway = gateway;\n    }\n\n    async execute(params: IBulkActionOperationTaskParams) {\n        const { input, response, isAborted, isCloseToTimeout, context } = params;\n\n        try {\n            if (isAborted()) {\n                return response.aborted();\n            } else if (isCloseToTimeout()) {\n                return response.continue({\n                    ...input\n                });\n            }\n\n            // Check if the input contains a model ID.\n            if (!input.modelId) {\n                return response.error(`Missing \"modelId\" in the input.`);\n            }\n\n            // Check if the model exists.\n            const model = await context.cms.getModel(input.modelId);\n\n            if (!model) {\n                return response.error(`Model with ${input.modelId} not found!`);\n            }\n\n            // Check if there are any IDs to process.\n            if (!input.ids || input.ids.length === 0) {\n                return response.done(\n                    `Task done: no entries to process for \"${input.modelId}\" model.`\n                );\n            }\n\n            // Set the security identity in the context.\n            context.security.setIdentity(input.identity);\n\n            // Process each ID in the input.\n            for (const id of input.ids) {\n                try {\n                    // Execute the gateway operation for the current ID.\n                    await this.gateway.execute(model, id, input.data);\n                    // Add the ID to the list of successfully processed entries.\n                    this.result.addDone(id);\n                } catch (ex) {\n                    console.error(ex.message || `Failed to process entry with id \"${id}\".`);\n                    // Add the ID to the list of failed entries.\n                    this.result.addFailed(id);\n                }\n            }\n\n            // Return a done response with the results of the processing.\n            return response.done(`Task done: all entries processed for \"${model.name}\" model.`, {\n                done: this.result.getDone(),\n                failed: this.result.getFailed()\n            });\n        } catch (ex) {\n            return response.error(ex.message ?? `Error while processing task.`);\n        }\n    }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AAIA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMC,WAAW,CAAC;EAIrBC,WAAWA,CAACC,OAAsB,EAAE;IAChC,IAAI,CAACC,MAAM,GAAG,IAAIC,cAAM,CAAC,CAAC;IAC1B,IAAI,CAACF,OAAO,GAAGA,OAAO;EAC1B;EAEA,MAAMG,OAAOA,CAACC,MAAsC,EAAE;IAClD,MAAM;MAAEC,KAAK;MAAEC,QAAQ;MAAEC,SAAS;MAAEC,gBAAgB;MAAEC;IAAQ,CAAC,GAAGL,MAAM;IAExE,IAAI;MACA,IAAIG,SAAS,CAAC,CAAC,EAAE;QACb,OAAOD,QAAQ,CAACI,OAAO,CAAC,CAAC;MAC7B,CAAC,MAAM,IAAIF,gBAAgB,CAAC,CAAC,EAAE;QAC3B,OAAOF,QAAQ,CAACK,QAAQ,CAAC;UACrB,GAAGN;QACP,CAAC,CAAC;MACN;;MAEA;MACA,IAAI,CAACA,KAAK,CAACO,OAAO,EAAE;QAChB,OAAON,QAAQ,CAACO,KAAK,CAAC,iCAAiC,CAAC;MAC5D;;MAEA;MACA,MAAMC,KAAK,GAAG,MAAML,OAAO,CAACM,GAAG,CAACC,QAAQ,CAACX,KAAK,CAACO,OAAO,CAAC;MAEvD,IAAI,CAACE,KAAK,EAAE;QACR,OAAOR,QAAQ,CAACO,KAAK,CAAC,cAAcR,KAAK,CAACO,OAAO,aAAa,CAAC;MACnE;;MAEA;MACA,IAAI,CAACP,KAAK,CAACY,GAAG,IAAIZ,KAAK,CAACY,GAAG,CAACC,MAAM,KAAK,CAAC,EAAE;QACtC,OAAOZ,QAAQ,CAACa,IAAI,CAChB,yCAAyCd,KAAK,CAACO,OAAO,UAC1D,CAAC;MACL;;MAEA;MACAH,OAAO,CAACW,QAAQ,CAACC,WAAW,CAAChB,KAAK,CAACiB,QAAQ,CAAC;;MAE5C;MACA,KAAK,MAAMC,EAAE,IAAIlB,KAAK,CAACY,GAAG,EAAE;QACxB,IAAI;UACA;UACA,MAAM,IAAI,CAACjB,OAAO,CAACG,OAAO,CAACW,KAAK,EAAES,EAAE,EAAElB,KAAK,CAACmB,IAAI,CAAC;UACjD;UACA,IAAI,CAACvB,MAAM,CAACwB,OAAO,CAACF,EAAE,CAAC;QAC3B,CAAC,CAAC,OAAOG,EAAE,EAAE;UACTC,OAAO,CAACd,KAAK,CAACa,EAAE,CAACE,OAAO,IAAI,oCAAoCL,EAAE,IAAI,CAAC;UACvE;UACA,IAAI,CAACtB,MAAM,CAAC4B,SAAS,CAACN,EAAE,CAAC;QAC7B;MACJ;;MAEA;MACA,OAAOjB,QAAQ,CAACa,IAAI,CAAC,yCAAyCL,KAAK,CAACgB,IAAI,UAAU,EAAE;QAChFX,IAAI,EAAE,IAAI,CAAClB,MAAM,CAAC8B,OAAO,CAAC,CAAC;QAC3BC,MAAM,EAAE,IAAI,CAAC/B,MAAM,CAACgC,SAAS,CAAC;MAClC,CAAC,CAAC;IACN,CAAC,CAAC,OAAOP,EAAE,EAAE;MACT,OAAOpB,QAAQ,CAACO,KAAK,CAACa,EAAE,CAACE,OAAO,IAAI,8BAA8B,CAAC;IACvE;EACJ;AACJ;AAACM,OAAA,CAAApC,WAAA,GAAAA,WAAA","ignoreList":[]}

package/useCases/internals/ProcessTask/Result.d.ts

@@ -0,0 +1,9 @@
+export declare class Result {
+    private readonly done;
+    private readonly failed;
+    constructor();
+    addDone(entryId: string): void;
+    addFailed(entryId: string): void;
+    getFailed(): string[];
+    getDone(): string[];
+}

package/useCases/internals/ProcessTask/Result.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Result = void 0;
+class Result {
+  constructor() {
+    this.done = new Set();
+    this.failed = new Set();
+  }
+  addDone(entryId) {
+    this.failed.delete(entryId);
+    this.done.add(entryId);
+  }
+  addFailed(entryId) {
+    this.failed.add(entryId);
+    this.done.delete(entryId);
+  }
+  getFailed() {
+    return Array.from(this.failed);
+  }
+  getDone() {
+    return Array.from(this.done);
+  }
+}
+exports.Result = Result;
+
+//# sourceMappingURL=Result.js.map

package/useCases/internals/ProcessTask/Result.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","constructor","done","Set","failed","addDone","entryId","delete","add","addFailed","getFailed","Array","from","getDone","exports"],"sources":["Result.ts"],"sourcesContent":["export class Result {\n    private readonly done: Set<string>;\n    private readonly failed: Set<string>;\n\n    public constructor() {\n        this.done = new Set();\n        this.failed = new Set();\n    }\n\n    public addDone(entryId: string): void {\n        this.failed.delete(entryId);\n        this.done.add(entryId);\n    }\n\n    public addFailed(entryId: string): void {\n        this.failed.add(entryId);\n        this.done.delete(entryId);\n    }\n\n    public getFailed() {\n        return Array.from(this.failed);\n    }\n\n    public getDone() {\n        return Array.from(this.done);\n    }\n}\n"],"mappings":";;;;;;AAAO,MAAMA,MAAM,CAAC;EAITC,WAAWA,CAAA,EAAG;IACjB,IAAI,CAACC,IAAI,GAAG,IAAIC,GAAG,CAAC,CAAC;IACrB,IAAI,CAACC,MAAM,GAAG,IAAID,GAAG,CAAC,CAAC;EAC3B;EAEOE,OAAOA,CAACC,OAAe,EAAQ;IAClC,IAAI,CAACF,MAAM,CAACG,MAAM,CAACD,OAAO,CAAC;IAC3B,IAAI,CAACJ,IAAI,CAACM,GAAG,CAACF,OAAO,CAAC;EAC1B;EAEOG,SAASA,CAACH,OAAe,EAAQ;IACpC,IAAI,CAACF,MAAM,CAACI,GAAG,CAACF,OAAO,CAAC;IACxB,IAAI,CAACJ,IAAI,CAACK,MAAM,CAACD,OAAO,CAAC;EAC7B;EAEOI,SAASA,CAAA,EAAG;IACf,OAAOC,KAAK,CAACC,IAAI,CAAC,IAAI,CAACR,MAAM,CAAC;EAClC;EAEOS,OAAOA,CAAA,EAAG;IACb,OAAOF,KAAK,CAACC,IAAI,CAAC,IAAI,CAACV,IAAI,CAAC;EAChC;AACJ;AAACY,OAAA,CAAAd,MAAA,GAAAA,MAAA","ignoreList":[]}

package/useCases/internals/ProcessTask/index.d.ts

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

package/useCases/internals/ProcessTask/index.js

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

package/useCases/internals/ProcessTask/index.js.map

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

package/useCases/internals/ProcessTasksByModel/ProcessTasksByModel.d.ts

@@ -0,0 +1,11 @@
+import type { IBulkActionOperationByModelTaskParams } from "../../../types";
+/**
+ * The `ProcessTasksByModel` class is responsible for processing tasks for a specific model.
+ * It checks for any running or pending tasks from the parent task and continues or completes
+ * the task based on the status.
+ */
+export declare class ProcessTasksByModel {
+    private taskDefinition;
+    constructor(taskDefinition: string);
+    execute(params: IBulkActionOperationByModelTaskParams): Promise<import("@webiny/tasks").ITaskResponseErrorResult | import("@webiny/tasks").ITaskResponseAbortedResult | import("@webiny/tasks").ITaskResponseContinueResult<import("../../../types").IBulkActionOperationByModelInput>>;
+}