@webiny/api-headless-cms-bulk-actions 0.0.0-unstable.a4637c5ce6 → 0.0.0-unstable.a4f3e4ea8b

package/README.md

@@ -1,15 +1,11 @@
 # @webiny/api-headless-cms-bulk-actions
-[![](https://img.shields.io/npm/dw/@webiny/api-headless-cms-bulk-actions.svg)](https://www.npmjs.com/package/@webinyapi-headless-cms-bulk-actions) 
-[![](https://img.shields.io/npm/v/@webiny/api-headless-cms-bulk-actions.svg)](https://www.npmjs.com/package/@webiny/api-headless-cms-bulk-actions)
-[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
-[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
- 
-## Install
-```
-npm install --save @webiny/api-headless-cms-bulk-actions
-```
-
-Or if you prefer yarn: 
-```
-yarn add @webiny/api-headless-cms-bulk-actions
-```
+
+> [!NOTE]
+> This package is part of the [Webiny](https://www.webiny.com) monorepo.
+> It’s **included in every Webiny project by default** and is not meant to be used as a standalone package.
+
+📘 **Documentation:** [https://www.webiny.com/docs](https://www.webiny.com/docs)
+
+---
+
+_This README file is automatically generated during the publish process._

package/abstractions/IUseCase.js

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

package/abstractions/index.d.ts

@@ -1,3 +1 @@
-export * from "./IListEntries";
-export * from "./IProcessEntry";
-export * from "./IUseCase";
+export type { IUseCase } from "./IUseCase.js";

package/abstractions/index.js

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

package/domain/BulkActionName.d.ts

@@ -0,0 +1,3 @@
+export declare class BulkActionName {
+    static from(name: string): string;
+}

package/domain/BulkActionName.js

@@ -0,0 +1,14 @@
+function toPascalCase(str) {
+    str = str.replace(/[^a-zA-Z0-9]+/g, " ");
+    const words = str.split(" ");
+    const capitalizedWords = words.map((word)=>word.charAt(0).toUpperCase() + word.slice(1));
+    return capitalizedWords.join("");
+}
+class BulkActionName {
+    static from(name) {
+        return toPascalCase(name);
+    }
+}
+export { BulkActionName };
+
+//# sourceMappingURL=BulkActionName.js.map

package/domain/BulkActionName.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/BulkActionName.js","sources":["../../src/domain/BulkActionName.ts"],"sourcesContent":["function toPascalCase(str: string) {\n    // Step 1: Remove non-alphanumeric characters and replace them with spaces\n    str = str.replace(/[^a-zA-Z0-9]+/g, \" \");\n\n    // Step 2: Split the string into words\n    const words = str.split(\" \");\n\n    // Step 3: Capitalize the first letter of each word\n    const capitalizedWords = words.map(word => word.charAt(0).toUpperCase() + word.slice(1));\n\n    // Step 4: Join all the capitalized words together\n    return capitalizedWords.join(\"\");\n}\n\nexport class BulkActionName {\n    static from(name: string) {\n        return toPascalCase(name);\n    }\n}\n"],"names":["toPascalCase","str","words","capitalizedWords","word","BulkActionName","name"],"mappings":"AAAA,SAASA,aAAaC,GAAW;IAE7BA,MAAMA,IAAI,OAAO,CAAC,kBAAkB;IAGpC,MAAMC,QAAQD,IAAI,KAAK,CAAC;IAGxB,MAAME,mBAAmBD,MAAM,GAAG,CAACE,CAAAA,OAAQA,KAAK,MAAM,CAAC,GAAG,WAAW,KAAKA,KAAK,KAAK,CAAC;IAGrF,OAAOD,iBAAiB,IAAI,CAAC;AACjC;AAEO,MAAME;IACT,OAAO,KAAKC,IAAY,EAAE;QACtB,OAAON,aAAaM;IACxB;AACJ"}

package/exports/api/cms/entry.d.ts

@@ -0,0 +1 @@
+export { EntriesBulkAction } from "../../../features/EntriesBulkAction/abstractions.js";

package/exports/api/cms/entry.js

@@ -0,0 +1 @@
+export { EntriesBulkAction } from "../../../features/EntriesBulkAction/abstractions.js";

package/features/BulkActionContext/abstractions.d.ts

@@ -0,0 +1,5 @@
+import type { HcmsBulkActionsContext } from "../../types.js";
+export declare const BulkActionContext: import("@webiny/di").Abstraction<HcmsBulkActionsContext>;
+export declare namespace BulkActionContext {
+    type Interface = HcmsBulkActionsContext;
+}

package/features/BulkActionContext/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const BulkActionContext = createAbstraction("BulkActionContext");
+export { BulkActionContext };
+
+//# sourceMappingURL=abstractions.js.map

package/features/BulkActionContext/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/BulkActionContext/abstractions.js","sources":["../../../src/features/BulkActionContext/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { HcmsBulkActionsContext } from \"~/types.js\";\n\n// TODO: this is a bridge for legacy context; needs review and refactor of code that uses it.\n\nexport const BulkActionContext = createAbstraction<HcmsBulkActionsContext>(\"BulkActionContext\");\n\nexport namespace BulkActionContext {\n    export type Interface = HcmsBulkActionsContext;\n}\n"],"names":["BulkActionContext","createAbstraction"],"mappings":";AAKO,MAAMA,oBAAoBC,kBAA0C"}

package/features/BulkActionContext/index.d.ts

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

package/features/BulkActionContext/index.js

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

package/features/DeleteEntriesBulkAction/DeleteEntriesBulkAction.d.ts

@@ -0,0 +1,15 @@
+import { ListDeletedEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries/index.js";
+import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/index.js";
+import { EntriesBulkAction } from "../../features/EntriesBulkAction/abstractions.js";
+declare class DeleteEntriesBulkActionImpl implements EntriesBulkAction.Interface {
+    private listDeletedEntries;
+    private deleteEntry;
+    readonly name = "delete";
+    constructor(listDeletedEntries: ListDeletedEntriesUseCase.Interface, deleteEntry: DeleteEntryUseCase.Interface);
+    loadData(model: EntriesBulkAction.Model, params: EntriesBulkAction.LoadDataParams): Promise<EntriesBulkAction.LoadDataResult>;
+    processData(model: EntriesBulkAction.Model, params: EntriesBulkAction.ProcessParams): Promise<void>;
+}
+export declare const DeleteEntriesBulkAction: typeof DeleteEntriesBulkActionImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("~/features/EntriesBulkAction/abstractions.js").IEntriesBulkAction<Record<string, any>>>;
+};
+export {};

package/features/DeleteEntriesBulkAction/DeleteEntriesBulkAction.js

@@ -0,0 +1,32 @@
+import { ListDeletedEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries/index.js";
+import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/index.js";
+import { parseIdentifier } from "@webiny/utils";
+import { EntriesBulkAction } from "../EntriesBulkAction/abstractions.js";
+class DeleteEntriesBulkActionImpl {
+    constructor(listDeletedEntries, deleteEntry){
+        this.listDeletedEntries = listDeletedEntries;
+        this.deleteEntry = deleteEntry;
+        this.name = "delete";
+    }
+    async loadData(model, params) {
+        const entriesResult = await this.listDeletedEntries.execute(model, params);
+        if (entriesResult.isFail()) throw entriesResult.error;
+        return entriesResult.value;
+    }
+    async processData(model, params) {
+        const { id: entryId } = parseIdentifier(params.id);
+        await this.deleteEntry.execute(model, entryId, {
+            permanently: true
+        });
+    }
+}
+const DeleteEntriesBulkAction = EntriesBulkAction.createImplementation({
+    implementation: DeleteEntriesBulkActionImpl,
+    dependencies: [
+        ListDeletedEntriesUseCase,
+        DeleteEntryUseCase
+    ]
+});
+export { DeleteEntriesBulkAction };
+
+//# sourceMappingURL=DeleteEntriesBulkAction.js.map

package/features/DeleteEntriesBulkAction/DeleteEntriesBulkAction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/DeleteEntriesBulkAction/DeleteEntriesBulkAction.js","sources":["../../../src/features/DeleteEntriesBulkAction/DeleteEntriesBulkAction.ts"],"sourcesContent":["import { ListDeletedEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries/index.js\";\nimport { DeleteEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry/index.js\";\nimport { parseIdentifier } from \"@webiny/utils\";\nimport { EntriesBulkAction } from \"~/features/EntriesBulkAction/abstractions.js\";\n\nclass DeleteEntriesBulkActionImpl implements EntriesBulkAction.Interface {\n    readonly name = \"delete\";\n\n    constructor(\n        private listDeletedEntries: ListDeletedEntriesUseCase.Interface,\n        private deleteEntry: DeleteEntryUseCase.Interface\n    ) {}\n\n    async loadData(\n        model: EntriesBulkAction.Model,\n        params: EntriesBulkAction.LoadDataParams\n    ): Promise<EntriesBulkAction.LoadDataResult> {\n        const entriesResult = await this.listDeletedEntries.execute(model, params);\n        if (entriesResult.isFail()) {\n            throw entriesResult.error;\n        }\n\n        return entriesResult.value;\n    }\n\n    async processData(\n        model: EntriesBulkAction.Model,\n        params: EntriesBulkAction.ProcessParams\n    ): Promise<void> {\n        const { id: entryId } = parseIdentifier(params.id);\n\n        await this.deleteEntry.execute(model, entryId, {\n            permanently: true\n        });\n    }\n}\n\nexport const DeleteEntriesBulkAction = EntriesBulkAction.createImplementation({\n    implementation: DeleteEntriesBulkActionImpl,\n    dependencies: [ListDeletedEntriesUseCase, DeleteEntryUseCase]\n});\n"],"names":["DeleteEntriesBulkActionImpl","listDeletedEntries","deleteEntry","model","params","entriesResult","entryId","parseIdentifier","DeleteEntriesBulkAction","EntriesBulkAction","ListDeletedEntriesUseCase","DeleteEntryUseCase"],"mappings":";;;;AAKA,MAAMA;IAGF,YACYC,kBAAuD,EACvDC,WAAyC,CACnD;aAFUD,kBAAkB,GAAlBA;aACAC,WAAW,GAAXA;aAJH,IAAI,GAAG;IAKb;IAEH,MAAM,SACFC,KAA8B,EAC9BC,MAAwC,EACC;QACzC,MAAMC,gBAAgB,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAACF,OAAOC;QACnE,IAAIC,cAAc,MAAM,IACpB,MAAMA,cAAc,KAAK;QAG7B,OAAOA,cAAc,KAAK;IAC9B;IAEA,MAAM,YACFF,KAA8B,EAC9BC,MAAuC,EAC1B;QACb,MAAM,EAAE,IAAIE,OAAO,EAAE,GAAGC,gBAAgBH,OAAO,EAAE;QAEjD,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAACD,OAAOG,SAAS;YAC3C,aAAa;QACjB;IACJ;AACJ;AAEO,MAAME,0BAA0BC,kBAAkB,oBAAoB,CAAC;IAC1E,gBAAgBT;IAChB,cAAc;QAACU;QAA2BC;KAAmB;AACjE"}

package/features/DeleteEntriesBulkAction/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const DeleteEntriesBulkActionFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/DeleteEntriesBulkAction/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { DeleteEntriesBulkAction } from "./DeleteEntriesBulkAction.js";
+const DeleteEntriesBulkActionFeature = createFeature({
+    name: "HeadlessCms/BulkAction/DeleteEntries",
+    register (container) {
+        container.register(DeleteEntriesBulkAction);
+    }
+});
+export { DeleteEntriesBulkActionFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/DeleteEntriesBulkAction/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/DeleteEntriesBulkAction/feature.js","sources":["../../../src/features/DeleteEntriesBulkAction/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { DeleteEntriesBulkAction } from \"./DeleteEntriesBulkAction.js\";\n\nexport const DeleteEntriesBulkActionFeature = createFeature({\n    name: \"HeadlessCms/BulkAction/DeleteEntries\",\n    register(container) {\n        container.register(DeleteEntriesBulkAction);\n    }\n});\n"],"names":["DeleteEntriesBulkActionFeature","createFeature","container","DeleteEntriesBulkAction"],"mappings":";;AAGO,MAAMA,iCAAiCC,cAAc;IACxD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/features/EntriesBulkAction/abstractions.d.ts

@@ -0,0 +1,38 @@
+import type { CmsEntry, CmsEntryMeta, CmsModel } from "@webiny/api-headless-cms/types/index.js";
+export interface IBulkActionListParams {
+    where?: Record<string, any>;
+    search?: string;
+    after?: string | null;
+    limit?: number;
+}
+export interface IBulkActionListResult {
+    entries: CmsEntry[];
+    meta: CmsEntryMeta;
+}
+export interface IBulkActionProcessParams<TData = Record<string, any>> {
+    id: string;
+    data?: TData;
+}
+export interface IEntriesBulkAction<TData = Record<string, any>> {
+    readonly name: string;
+    readonly modelIds?: string[];
+    readonly batchSize?: number;
+    loadData(model: CmsModel, params: IBulkActionListParams): Promise<IBulkActionListResult>;
+    processData(model: CmsModel, params: IBulkActionProcessParams<TData>): Promise<void>;
+}
+export declare const EntriesBulkAction: import("@webiny/di").Abstraction<IEntriesBulkAction<Record<string, any>>>;
+export declare namespace EntriesBulkAction {
+    type Interface<TData = Record<string, any>> = IEntriesBulkAction<TData>;
+    type Model = CmsModel;
+    type LoadDataParams = IBulkActionListParams;
+    type LoadDataResult = IBulkActionListResult;
+    type ProcessParams<TData = Record<string, any>> = IBulkActionProcessParams<TData>;
+}
+interface IEntriesBulkActionConfig {
+    batchSize: number;
+}
+export declare const EntriesBulkActionConfig: import("@webiny/di").Abstraction<IEntriesBulkActionConfig>;
+export declare namespace EntriesBulkActionConfig {
+    type Interface = IEntriesBulkActionConfig;
+}
+export {};

package/features/EntriesBulkAction/abstractions.js

@@ -0,0 +1,6 @@
+import { createAbstraction } from "@webiny/feature/api";
+const EntriesBulkAction = createAbstraction("EntriesBulkAction");
+const EntriesBulkActionConfig = createAbstraction("EntriesBulkActionConfig");
+export { EntriesBulkAction, EntriesBulkActionConfig };
+
+//# sourceMappingURL=abstractions.js.map

package/features/EntriesBulkAction/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/EntriesBulkAction/abstractions.js","sources":["../../../src/features/EntriesBulkAction/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { CmsEntry, CmsEntryMeta, CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\n\nexport interface IBulkActionListParams {\n    where?: Record<string, any>;\n    search?: string;\n    after?: string | null;\n    limit?: number;\n}\n\nexport interface IBulkActionListResult {\n    entries: CmsEntry[];\n    meta: CmsEntryMeta;\n}\n\nexport interface IBulkActionProcessParams<TData = Record<string, any>> {\n    id: string;\n    // The `data` payload the Admin action sent along with the trigger. Type it by\n    // parameterizing `EntriesBulkAction.Interface<TData>` on your implementation.\n    data?: TData;\n}\n\nexport interface IEntriesBulkAction<TData = Record<string, any>> {\n    readonly name: string;\n    readonly modelIds?: string[]; // Optional: filter which models get GraphQL mutations\n    readonly batchSize?: number;\n    loadData(model: CmsModel, params: IBulkActionListParams): Promise<IBulkActionListResult>;\n    processData(model: CmsModel, params: IBulkActionProcessParams<TData>): Promise<void>;\n}\n\nexport const EntriesBulkAction = createAbstraction<IEntriesBulkAction>(\"EntriesBulkAction\");\n\nexport namespace EntriesBulkAction {\n    export type Interface<TData = Record<string, any>> = IEntriesBulkAction<TData>;\n    export type Model = CmsModel;\n    export type LoadDataParams = IBulkActionListParams;\n    export type LoadDataResult = IBulkActionListResult;\n    export type ProcessParams<TData = Record<string, any>> = IBulkActionProcessParams<TData>;\n}\n\ninterface IEntriesBulkActionConfig {\n    batchSize: number;\n}\n\nexport const EntriesBulkActionConfig =\n    createAbstraction<IEntriesBulkActionConfig>(\"EntriesBulkActionConfig\");\n\nexport namespace EntriesBulkActionConfig {\n    export type Interface = IEntriesBulkActionConfig;\n}\n"],"names":["EntriesBulkAction","createAbstraction","EntriesBulkActionConfig"],"mappings":";AA8BO,MAAMA,oBAAoBC,kBAAsC;AAchE,MAAMC,0BACTD,kBAA4C"}

package/features/EntriesBulkAction/createBulkActionTasks.d.ts

@@ -0,0 +1,5 @@
+import { EntriesBulkAction, EntriesBulkActionConfig } from "./abstractions.js";
+export declare const createBulkActionTasks: (bulkAction: EntriesBulkAction.Interface, bulkActionsConfig: EntriesBulkActionConfig.Interface) => {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/EntriesBulkAction/createBulkActionTasks.js

@@ -0,0 +1,132 @@
+import { createFeature } from "@webiny/feature/api";
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { BulkActionContext } from "../BulkActionContext/index.js";
+import { BulkActionName } from "../../domain/BulkActionName.js";
+import { ChildTasksCleanup } from "./internals/ChildTasksCleanup.js";
+import { ProcessTask } from "./internals/ProcessTask.js";
+import { CreateTasksByModel } from "./internals/CreateTasksByModel.js";
+import { ProcessTasksByModel } from "./internals/ProcessTasksByModel.js";
+const createBulkActionTasks = (bulkAction, bulkActionsConfig)=>{
+    const bulkActionName = BulkActionName.from(bulkAction.name);
+    const batchSize = bulkAction.batchSize ?? bulkActionsConfig.batchSize ?? 100;
+    const listTaskId = `hcmsBulkList${bulkActionName}Entries`;
+    const processTaskId = `hcmsBulkProcess${bulkActionName}Entries`;
+    class BulkActionListTask {
+        constructor(context, getModel){
+            this.id = listTaskId;
+            this.title = `Headless CMS: list "${bulkActionName}" entries by model`;
+            this.maxIterations = 500;
+            this.databaseLogs = false;
+            this.isPrivate = true;
+            this.selfCleanup = [
+                "onSuccess",
+                "onAbort"
+            ];
+            this.context = context;
+            this.getModel = getModel;
+        }
+        async run({ input, controller }) {
+            try {
+                if (!input.modelId) return controller.response.error('Missing "modelId" in the input.');
+                const action = input.action ?? "CREATE_SUBTASKS";
+                switch(action){
+                    case "PROCESS_SUBTASKS":
+                        {
+                            const processTasks = new ProcessTasksByModel(this.context, processTaskId);
+                            return await processTasks.execute({
+                                input,
+                                controller
+                            });
+                        }
+                    case "CREATE_SUBTASKS":
+                    case "CHECK_MORE_SUBTASKS":
+                        {
+                            const createTasks = new CreateTasksByModel(this.context, this.getModel, bulkAction, processTaskId, batchSize);
+                            return await createTasks.execute({
+                                input,
+                                controller
+                            });
+                        }
+                    case "END_TASK":
+                        return controller.response.done(`Task done: task "${processTaskId}" has been successfully processed for entries from "${input.modelId}" model.`);
+                    default:
+                        return controller.response.error(`Unknown action: ${action}`);
+                }
+            } catch (ex) {
+                return controller.response.error(ex.message ?? "Error while executing list task");
+            }
+        }
+        async onDone({ task }) {
+            await this.cleanup(task);
+        }
+        async onError({ task }) {
+            await this.cleanup(task);
+        }
+        async onAbort({ task }) {
+            await this.cleanup(task);
+        }
+        async onMaxIterations({ task }) {
+            await this.cleanup(task);
+        }
+        async cleanup(task) {
+            const childTasksCleanup = new ChildTasksCleanup();
+            try {
+                await childTasksCleanup.execute({
+                    context: this.context,
+                    task
+                });
+            } catch (ex) {
+                console.error(`Error while cleaning "${listTaskId}" child tasks.`, ex);
+            }
+        }
+    }
+    class BulkActionProcessTask {
+        constructor(getModel){
+            this.id = processTaskId;
+            this.title = `Headless CMS: process "${bulkActionName}" entries`;
+            this.maxIterations = 2;
+            this.databaseLogs = false;
+            this.isPrivate = true;
+            this.selfCleanup = [
+                "onSuccess",
+                "onAbort"
+            ];
+            this.getModel = getModel;
+        }
+        async run({ input, controller }) {
+            try {
+                const processTask = new ProcessTask(bulkAction, this.getModel);
+                return await processTask.execute({
+                    input,
+                    controller
+                });
+            } catch (ex) {
+                return controller.response.error(ex.message ?? "Error while executing process task");
+            }
+        }
+    }
+    const BulkListTask = TaskDefinition.createImplementation({
+        implementation: BulkActionListTask,
+        dependencies: [
+            BulkActionContext,
+            GetModelUseCase
+        ]
+    });
+    const BulkProcessTask = TaskDefinition.createImplementation({
+        implementation: BulkActionProcessTask,
+        dependencies: [
+            GetModelUseCase
+        ]
+    });
+    return createFeature({
+        name: `HeadlessCms/BulkActionTasks/${bulkActionName}`,
+        register (container) {
+            container.register(BulkListTask);
+            container.register(BulkProcessTask);
+        }
+    });
+};
+export { createBulkActionTasks };
+
+//# sourceMappingURL=createBulkActionTasks.js.map

package/features/EntriesBulkAction/createBulkActionTasks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/EntriesBulkAction/createBulkActionTasks.js","sources":["../../../src/features/EntriesBulkAction/createBulkActionTasks.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\nimport { BulkActionContext } from \"~/features/BulkActionContext/index.js\";\nimport type {\n    IBulkActionOperationByModelInput,\n    IBulkActionOperationByModelOutput,\n    IBulkActionOperationInput,\n    IBulkActionOperationOutput\n} from \"~/types.js\";\nimport { EntriesBulkAction, EntriesBulkActionConfig } from \"./abstractions.js\";\nimport { BulkActionName } from \"~/domain/BulkActionName.js\";\nimport { ChildTasksCleanup } from \"./internals/ChildTasksCleanup.js\";\nimport { ProcessTask } from \"./internals/ProcessTask.js\";\nimport { CreateTasksByModel } from \"./internals/CreateTasksByModel.js\";\nimport { ProcessTasksByModel } from \"./internals/ProcessTasksByModel.js\";\n\nenum BulkActionOperationByModelAction {\n    CREATE_SUBTASKS = \"CREATE_SUBTASKS\",\n    CHECK_MORE_SUBTASKS = \"CHECK_MORE_SUBTASKS\",\n    PROCESS_SUBTASKS = \"PROCESS_SUBTASKS\",\n    END_TASK = \"END_TASK\"\n}\n\nexport const createBulkActionTasks = (\n    bulkAction: EntriesBulkAction.Interface,\n    bulkActionsConfig: EntriesBulkActionConfig.Interface\n) => {\n    const bulkActionName = BulkActionName.from(bulkAction.name);\n    const batchSize = bulkAction.batchSize ?? bulkActionsConfig.batchSize ?? 100;\n    const listTaskId = `hcmsBulkList${bulkActionName}Entries`;\n    const processTaskId = `hcmsBulkProcess${bulkActionName}Entries`;\n\n    // List Task - manages pagination and creates subtasks\n    class BulkActionListTask implements TaskDefinition.Interface<\n        IBulkActionOperationByModelInput,\n        IBulkActionOperationByModelOutput\n    > {\n        public readonly id = listTaskId;\n        public readonly title = `Headless CMS: list \"${bulkActionName}\" entries by model`;\n        public readonly maxIterations = 500;\n        public readonly databaseLogs = false;\n        public readonly isPrivate = true;\n        public readonly context: BulkActionContext.Interface;\n        public readonly getModel: GetModelUseCase.Interface;\n\n        public readonly selfCleanup = [\"onSuccess\" as const, \"onAbort\" as const];\n\n        constructor(context: BulkActionContext.Interface, getModel: GetModelUseCase.Interface) {\n            this.context = context;\n            this.getModel = getModel;\n        }\n\n        async run({\n            input,\n            controller\n        }: TaskDefinition.RunParams<\n            IBulkActionOperationByModelInput,\n            IBulkActionOperationByModelOutput\n        >) {\n            try {\n                if (!input.modelId) {\n                    return controller.response.error(`Missing \"modelId\" in the input.`);\n                }\n\n                const action = input.action ?? BulkActionOperationByModelAction.CREATE_SUBTASKS;\n\n                switch (action) {\n                    case BulkActionOperationByModelAction.PROCESS_SUBTASKS: {\n                        const processTasks = new ProcessTasksByModel(this.context, processTaskId);\n                        return await processTasks.execute({ input, controller });\n                    }\n                    case BulkActionOperationByModelAction.CREATE_SUBTASKS:\n                    case BulkActionOperationByModelAction.CHECK_MORE_SUBTASKS: {\n                        const createTasks = new CreateTasksByModel(\n                            this.context,\n                            this.getModel,\n                            bulkAction,\n                            processTaskId,\n                            batchSize\n                        );\n                        return await createTasks.execute({ input, controller });\n                    }\n                    case BulkActionOperationByModelAction.END_TASK: {\n                        return controller.response.done(\n                            `Task done: task \"${processTaskId}\" has been successfully processed for entries from \"${\n                                input.modelId\n                            }\" model.`\n                        );\n                    }\n                    default:\n                        return controller.response.error(`Unknown action: ${action}`);\n                }\n            } catch (ex) {\n                return controller.response.error(ex.message ?? \"Error while executing list task\");\n            }\n        }\n\n        async onDone({ task }: TaskDefinition.LifecycleHookParams): Promise<void> {\n            await this.cleanup(task);\n        }\n\n        async onError({ task }: TaskDefinition.LifecycleHookParams) {\n            await this.cleanup(task);\n        }\n\n        async onAbort({ task }: TaskDefinition.LifecycleHookParams) {\n            await this.cleanup(task);\n        }\n\n        async onMaxIterations({ task }: TaskDefinition.LifecycleHookParams) {\n            await this.cleanup(task);\n        }\n\n        async cleanup(task: TaskDefinition.Task) {\n            const childTasksCleanup = new ChildTasksCleanup();\n            try {\n                await childTasksCleanup.execute({ context: this.context, task });\n            } catch (ex) {\n                console.error(`Error while cleaning \"${listTaskId}\" child tasks.`, ex);\n            }\n        }\n    }\n\n    // Process Task - processes individual batches of entries\n    class BulkActionProcessTask implements TaskDefinition.Interface<\n        IBulkActionOperationInput,\n        IBulkActionOperationOutput\n    > {\n        public readonly id = processTaskId;\n        public readonly title = `Headless CMS: process \"${bulkActionName}\" entries`;\n        public readonly maxIterations = 2;\n        public readonly databaseLogs = false;\n        public readonly isPrivate = true;\n        public readonly getModel: GetModelUseCase.Interface;\n\n        public readonly selfCleanup = [\"onSuccess\" as const, \"onAbort\" as const];\n\n        constructor(getModel: GetModelUseCase.Interface) {\n            this.getModel = getModel;\n        }\n\n        async run({\n            input,\n            controller\n        }: TaskDefinition.RunParams<IBulkActionOperationInput, IBulkActionOperationOutput>) {\n            try {\n                const processTask = new ProcessTask(bulkAction, this.getModel);\n                return await processTask.execute({ input, controller });\n            } catch (ex) {\n                return controller.response.error(\n                    ex.message ?? \"Error while executing process task\"\n                );\n            }\n        }\n    }\n\n    const BulkListTask = TaskDefinition.createImplementation({\n        implementation: BulkActionListTask,\n        dependencies: [BulkActionContext, GetModelUseCase]\n    });\n\n    const BulkProcessTask = TaskDefinition.createImplementation({\n        implementation: BulkActionProcessTask,\n        dependencies: [GetModelUseCase]\n    });\n\n    return createFeature({\n        name: `HeadlessCms/BulkActionTasks/${bulkActionName}`,\n        register(container) {\n            container.register(BulkListTask);\n            container.register(BulkProcessTask);\n        }\n    });\n};\n"],"names":["createBulkActionTasks","bulkAction","bulkActionsConfig","bulkActionName","BulkActionName","batchSize","listTaskId","processTaskId","BulkActionListTask","context","getModel","input","controller","action","processTasks","ProcessTasksByModel","createTasks","CreateTasksByModel","ex","task","childTasksCleanup","ChildTasksCleanup","console","BulkActionProcessTask","processTask","ProcessTask","BulkListTask","TaskDefinition","BulkActionContext","GetModelUseCase","BulkProcessTask","createFeature","container"],"mappings":"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"}

package/{useCases/internals/ChildTaskCleanup → features/EntriesBulkAction/internals}/ChildTasksCleanup.d.ts

@@ -1,5 +1,5 @@
-import type { ITask, Context } from "@webiny/tasks";
-import type { IUseCase } from "../../../abstractions";
+import type { ITask, Context } from "@webiny/background-tasks/api";
+import type { IUseCase } from "../../../abstractions/index.js";
 export interface IChildTasksCleanupExecuteParams {
     context: Context;
     task: ITask;

package/features/EntriesBulkAction/internals/ChildTasksCleanup.js

@@ -0,0 +1,33 @@
+import { TaskLogItemType } from "@webiny/background-tasks/api";
+class ChildTasksCleanup {
+    async execute(params) {
+        const { context, task } = params;
+        const { items: childTasks } = await context.tasks.listTasks({
+            where: {
+                parentId: task.id
+            },
+            limit: 10000
+        });
+        if (0 === childTasks.length) return;
+        const childTaskIdList = childTasks.map((childTask)=>childTask.id);
+        const { items: childLogs } = await context.tasks.listLogs({
+            where: {
+                task_in: childTaskIdList
+            },
+            limit: 10000
+        });
+        if (0 === childLogs.length) await this.deleteTasks(context, childTaskIdList);
+        const deletedChildTaskLogIdList = [];
+        for (const log of childLogs)if (!log.items.some((item)=>item.type === TaskLogItemType.ERROR)) {
+            await context.tasks.deleteLog(log.id);
+            if (!deletedChildTaskLogIdList.includes(log.task)) deletedChildTaskLogIdList.push(log.task);
+        }
+        await this.deleteTasks(context, deletedChildTaskLogIdList);
+    }
+    async deleteTasks(context, taskIds) {
+        for (const taskId of taskIds)await context.tasks.deleteTask(taskId);
+    }
+}
+export { ChildTasksCleanup };
+
+//# sourceMappingURL=ChildTasksCleanup.js.map

package/features/EntriesBulkAction/internals/ChildTasksCleanup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/EntriesBulkAction/internals/ChildTasksCleanup.js","sources":["../../../../src/features/EntriesBulkAction/internals/ChildTasksCleanup.ts"],"sourcesContent":["import type { ITask, Context } from \"@webiny/background-tasks/api\";\nimport { TaskLogItemType } from \"@webiny/background-tasks/api\";\nimport type { IUseCase } from \"~/abstractions/index.js\";\nimport type { HcmsBulkActionsContext } from \"~/types.js\";\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"],"names":["ChildTasksCleanup","params","context","task","childTasks","childTaskIdList","childTask","childLogs","deletedChildTaskLogIdList","log","item","TaskLogItemType","taskIds","taskId"],"mappings":";AAcO,MAAMA;IACT,MAAa,QAAQC,MAAuC,EAAiB;QACzE,MAAM,EAAEC,OAAO,EAAEC,IAAI,EAAE,GAAGF;QAE1B,MAAM,EAAE,OAAOG,UAAU,EAAE,GAAG,MAAMF,QAAQ,KAAK,CAAC,SAAS,CAAC;YACxD,OAAO;gBACH,UAAUC,KAAK,EAAE;YACrB;YAEA,OAAO;QACX;QAEA,IAAIC,AAAsB,MAAtBA,WAAW,MAAM,EACjB;QAGJ,MAAMC,kBAAkBD,WAAW,GAAG,CAACE,CAAAA,YAAaA,UAAU,EAAE;QAEhE,MAAM,EAAE,OAAOC,SAAS,EAAE,GAAG,MAAML,QAAQ,KAAK,CAAC,QAAQ,CAAC;YACtD,OAAO;gBACH,SAASG;YACb;YACA,OAAO;QACX;QAKA,IAAIE,AAAqB,MAArBA,UAAU,MAAM,EAChB,MAAM,IAAI,CAAC,WAAW,CAACL,SAASG;QAGpC,MAAMG,4BAAsC,EAAE;QAI9C,KAAK,MAAMC,OAAOF,UACd,KAAIE,IAAI,KAAK,CAAC,IAAI,CAACC,CAAAA,OAAQA,KAAK,IAAI,KAAKC,gBAAgB,KAAK;YAG9D,MAAMT,QAAQ,KAAK,CAAC,SAAS,CAACO,IAAI,EAAE;YACpC,KAAID,0BAA0B,QAAQ,CAACC,IAAI,IAAI,GAG/CD,0BAA0B,IAAI,CAACC,IAAI,IAAI;;QAK3C,MAAM,IAAI,CAAC,WAAW,CAACP,SAASM;IACpC;IAKA,MAAc,YAAYN,OAA+B,EAAEU,OAAiB,EAAiB;QACzF,KAAK,MAAMC,UAAUD,QACjB,MAAMV,QAAQ,KAAK,CAAC,UAAU,CAACW;IAEvC;AACJ"}

package/features/EntriesBulkAction/internals/CreateTasksByModel.d.ts

@@ -0,0 +1,16 @@
+import type { IBulkActionOperationByModelTaskParams } from "../../../types.js";
+import { EntriesBulkAction } from "../../../features/EntriesBulkAction/abstractions.js";
+import { BulkActionContext } from "../../../features/BulkActionContext/index.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+/**
+ * The `CreateTasksByModel` class handles the execution of a task to process entries in batches.
+ */
+export declare class CreateTasksByModel {
+    private readonly taskCache;
+    private readonly batchSize;
+    private readonly bulkAction;
+    private readonly context;
+    private readonly getModel;
+    constructor(context: BulkActionContext.Interface, getModel: GetModelUseCase.Interface, bulkAction: EntriesBulkAction.Interface, taskDefinition: string, batchSize: number);
+    execute(params: IBulkActionOperationByModelTaskParams): Promise<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskResultAborted | import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskResultError | import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").TaskDefinition.ResultContinue<import("~/types.js").IBulkActionOperationByModelInput>>;
+}

package/features/EntriesBulkAction/internals/CreateTasksByModel.js

@@ -0,0 +1,76 @@
+import { TaskCache } from "./TaskCache.js";
+import { BulkActionOperationByModelAction } from "../../../types.js";
+const MAX_TASK_LIST_LENGTH = 10;
+class CreateTasksByModel {
+    constructor(context, getModel, bulkAction, taskDefinition, batchSize){
+        this.getModel = getModel;
+        this.taskCache = new TaskCache(taskDefinition);
+        this.batchSize = batchSize;
+        this.bulkAction = bulkAction;
+        this.context = context;
+    }
+    async execute(params) {
+        const { input, controller } = params;
+        try {
+            const modelResult = await this.getModel.execute(input.modelId);
+            if (modelResult.isFail()) return controller.response.error(`Model with ${input.modelId} not found!`);
+            const model = modelResult.value;
+            const listEntriesParams = {
+                where: input.where,
+                search: input.search,
+                after: input.after,
+                limit: this.batchSize
+            };
+            while(true){
+                if (controller.runtime.isAborted()) return controller.response.aborted();
+                if (controller.runtime.isCloseToTimeout()) {
+                    await this.taskCache.triggerTask(this.context, controller.state.getTask());
+                    return controller.response.continue({
+                        ...input,
+                        action: BulkActionOperationByModelAction.PROCESS_SUBTASKS
+                    });
+                }
+                const { entries, meta } = await this.bulkAction.loadData(model, listEntriesParams);
+                if (0 === meta.totalCount) return controller.response.continue({
+                    ...input,
+                    action: BulkActionOperationByModelAction.END_TASK
+                });
+                if (this.taskCache.getTasksLength() === MAX_TASK_LIST_LENGTH) {
+                    await this.taskCache.triggerTask(this.context, controller.state.getTask());
+                    return controller.response.continue({
+                        ...input,
+                        action: BulkActionOperationByModelAction.PROCESS_SUBTASKS
+                    });
+                }
+                if (0 === entries.length) {
+                    await this.taskCache.triggerTask(this.context, controller.state.getTask());
+                    return controller.response.continue({
+                        ...input,
+                        action: BulkActionOperationByModelAction.PROCESS_SUBTASKS
+                    });
+                }
+                const ids = [];
+                for(let i = 0; i < entries.length; i++)ids.push(entries[i].id);
+                if (ids.length > 0) this.taskCache.cacheTask({
+                    modelId: input.modelId,
+                    identity: input.identity,
+                    data: input.data,
+                    ids
+                });
+                if (!meta.hasMoreItems || !meta.cursor) {
+                    await this.taskCache.triggerTask(this.context, controller.state.getTask());
+                    return controller.response.continue({
+                        ...input,
+                        action: BulkActionOperationByModelAction.PROCESS_SUBTASKS
+                    });
+                }
+                listEntriesParams.after = meta.cursor;
+            }
+        } catch (ex) {
+            return controller.response.error(ex.message ?? "Error while creating task.");
+        }
+    }
+}
+export { CreateTasksByModel };
+
+//# sourceMappingURL=CreateTasksByModel.js.map

package/features/EntriesBulkAction/internals/CreateTasksByModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/EntriesBulkAction/internals/CreateTasksByModel.js","sources":["../../../../src/features/EntriesBulkAction/internals/CreateTasksByModel.ts"],"sourcesContent":["import type { CmsEntryListParams } from \"@webiny/api-headless-cms/types/index.js\";\nimport { TaskCache } from \"./TaskCache.js\";\nimport type { IBulkActionOperationByModelTaskParams } from \"~/types.js\";\nimport { BulkActionOperationByModelAction } from \"~/types.js\";\nimport { EntriesBulkAction } from \"~/features/EntriesBulkAction/abstractions.js\";\nimport { BulkActionContext } from \"~/features/BulkActionContext/index.js\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\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 readonly batchSize: number;\n    private readonly bulkAction: EntriesBulkAction.Interface;\n    private readonly context: BulkActionContext.Interface;\n    private readonly getModel: GetModelUseCase.Interface;\n\n    constructor(\n        context: BulkActionContext.Interface,\n        getModel: GetModelUseCase.Interface,\n        bulkAction: EntriesBulkAction.Interface,\n        taskDefinition: string,\n        batchSize: number\n    ) {\n        this.getModel = getModel;\n        this.taskCache = new TaskCache(taskDefinition);\n        this.batchSize = batchSize;\n        this.bulkAction = bulkAction;\n        this.context = context;\n    }\n\n    async execute(params: IBulkActionOperationByModelTaskParams) {\n        const { input, controller } = params;\n\n        try {\n            const modelResult = await this.getModel.execute(input.modelId);\n\n            if (modelResult.isFail()) {\n                return controller.response.error(`Model with ${input.modelId} not found!`);\n            }\n\n            const model = modelResult.value;\n\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 (controller.runtime.isAborted()) {\n                    return controller.response.aborted();\n                } else if (controller.runtime.isCloseToTimeout()) {\n                    await this.taskCache.triggerTask(this.context, controller.state.getTask());\n                    return controller.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.bulkAction.loadData(model, listEntriesParams);\n\n                // End the task if no entries match the query\n                if (meta.totalCount === 0) {\n                    return controller.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(this.context, controller.state.getTask());\n                    return controller.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(this.context, controller.state.getTask());\n                    return controller.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(this.context, controller.state.getTask());\n\n                    return controller.response.continue({\n                        ...input,\n                        action: BulkActionOperationByModelAction.PROCESS_SUBTASKS\n                    });\n                }\n\n                listEntriesParams.after = meta.cursor;\n            }\n        } catch (ex) {\n            return controller.response.error(ex.message ?? `Error while creating task.`);\n        }\n    }\n}\n"],"names":["MAX_TASK_LIST_LENGTH","CreateTasksByModel","context","getModel","bulkAction","taskDefinition","batchSize","TaskCache","params","input","controller","modelResult","model","listEntriesParams","BulkActionOperationByModelAction","entries","meta","ids","i","ex"],"mappings":"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"}

package/features/EntriesBulkAction/internals/ProcessTask.d.ts

@@ -0,0 +1,16 @@
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { EntriesBulkAction } from "../../../features/EntriesBulkAction/abstractions.js";
+import type { IBulkActionOperationTaskParams } from "../../../types.js";
+/**
+ * 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 bulkAction;
+    private getModel;
+    private readonly result;
+    constructor(bulkAction: EntriesBulkAction.Interface, getModel: GetModelUseCase.Interface);
+    execute({ input, controller }: IBulkActionOperationTaskParams): Promise<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskResultAborted | import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskResultError | import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").TaskDefinition.ResultContinue<import("~/types.js").IBulkActionOperationInput> | import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").TaskDefinition.ResultDone<import("~/types.js").IBulkActionOperationOutput>>;
+}