@webiny/background-tasks 0.0.0-unstable.7be00a75a9 → 6.4.0-beta.5

package/admin/shared/types.d.ts

@@ -13,3 +13,6 @@ export type Task = Omit<TaskRun, "taskStatus"> & {
 export type { TaskLog } from "@webiny/sdk";
 export type { TaskLogItem } from "@webiny/sdk";
 export type { TaskDefinition } from "@webiny/sdk";
+export interface BackgroundTaskSettings {
+    retentionDays: number | undefined;
+}

package/api/context.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "@webiny/plugins";
+export declare const createBackgroundTaskContext: () => Plugin[];

package/api/context.js

@@ -0,0 +1,66 @@
+import { ContextPlugin } from "@webiny/api";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import { RunnableTaskDecorator } from "./decorators/RunnableTaskDecorator.js";
+import { SelfCleaningTaskDecorator } from "./decorators/SelfCleaningTaskDecorator.js";
+import { TaskController } from "./features/TaskController/index.js";
+import { TaskPrivateModel } from "./crud/TaskPrivateModel.js";
+import { TaskLogPrivateModel } from "./crud/TaskLogPrivateModel.js";
+import { createDefinitionCrud } from "./crud/definition.tasks.js";
+import { createServiceCrud } from "./crud/service.tasks.js";
+import { createTaskCrud } from "./crud/crud.tasks.js";
+import { createServicePlugins } from "./service/index.js";
+import { TaskExecutionContextFeature } from "./features/TaskExecutionContext/feature.js";
+import { GetTaskDefinitionFeature } from "./features/GetTaskDefinition/feature.js";
+import { ListTaskDefinitionsFeature } from "./features/ListTaskDefinitions/feature.js";
+import { CleanupTaskSubtreeUseCase, CleanupTaskSubtreeUseCaseImpl } from "./features/CleanupTaskSubtree/index.js";
+import { TestingRunTaskDefinition } from "./tasks/testingRunTask.js";
+import { createRegisterExtensionPlugin } from "@webiny/handler";
+import { BackgroundTaskSettingsModel } from "./models/BackgroundTaskSettingsModel.js";
+import { GetBackgroundTaskSettingsFeature } from "./features/GetBackgroundTaskSettings/feature.js";
+import { UpdateBackgroundTaskSettingsFeature } from "./features/UpdateBackgroundTaskSettings/feature.js";
+import { BackgroundTaskPermissionsFeature } from "./features/BackgroundTaskPermissions/feature.js";
+import { createBackgroundTaskSettingsGraphQL } from "./graphql/BackgroundTaskSettingsSchema.js";
+const createTasksCrud = ()=>{
+    const tasksCrudPlugin = new ContextPlugin(async (context)=>{
+        context.container.registerDecorator(RunnableTaskDecorator);
+        context.container.registerDecorator(SelfCleaningTaskDecorator);
+        GetTaskDefinitionFeature.register(context.container);
+        ListTaskDefinitionsFeature.register(context.container);
+        context.tasks = {
+            ...createDefinitionCrud(context),
+            ...createTaskCrud(context),
+            ...createServiceCrud(context)
+        };
+        context.container.registerInstance(CleanupTaskSubtreeUseCase, new CleanupTaskSubtreeUseCaseImpl(context));
+    });
+    tasksCrudPlugin.name = "tasks.context";
+    return tasksCrudPlugin;
+};
+const createTasksContext = ()=>{
+    const modelsPlugin = createRegisterExtensionPlugin((context)=>{
+        context.container.register(TaskPrivateModel);
+        context.container.register(TaskLogPrivateModel);
+        context.container.register(BackgroundTaskSettingsModel);
+    });
+    return [
+        ...createServicePlugins(),
+        createTasksCrud(),
+        modelsPlugin
+    ];
+};
+const createBackgroundTaskContext = ()=>[
+        ...createTasksContext(),
+        ...createBackgroundTaskSettingsGraphQL(),
+        new ContextPlugin((context)=>{
+            context.container.registerInstance(TaskService, context.tasks);
+            TaskExecutionContextFeature.register(context.container);
+            context.container.register(TaskController);
+            context.container.register(TestingRunTaskDefinition);
+            BackgroundTaskPermissionsFeature.register(context.container);
+            GetBackgroundTaskSettingsFeature.register(context.container);
+            UpdateBackgroundTaskSettingsFeature.register(context.container);
+        })
+    ];
+export { createBackgroundTaskContext };
+
+//# sourceMappingURL=context.js.map

package/api/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/context.js","sources":["../../src/api/context.ts"],"sourcesContent":["import type { Plugin } from \"@webiny/plugins\";\nimport { ContextPlugin } from \"@webiny/api\";\nimport { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport { RunnableTaskDecorator } from \"./decorators/RunnableTaskDecorator.js\";\nimport { SelfCleaningTaskDecorator } from \"./decorators/SelfCleaningTaskDecorator.js\";\nimport { TaskController } from \"./features/TaskController/index.js\";\nimport type { Context } from \"~/api/types.js\";\nimport { TaskPrivateModel } from \"./crud/TaskPrivateModel.js\";\nimport { TaskLogPrivateModel } from \"./crud/TaskLogPrivateModel.js\";\nimport { createDefinitionCrud } from \"./crud/definition.tasks.js\";\nimport { createServiceCrud } from \"~/api/crud/service.tasks.js\";\nimport { createTaskCrud } from \"./crud/crud.tasks.js\";\nimport { createServicePlugins } from \"~/api/service/index.js\";\nimport { TaskExecutionContextFeature } from \"~/api/features/TaskExecutionContext/feature.js\";\nimport { GetTaskDefinitionFeature } from \"~/api/features/GetTaskDefinition/feature.js\";\nimport { ListTaskDefinitionsFeature } from \"~/api/features/ListTaskDefinitions/feature.js\";\nimport {\n    CleanupTaskSubtreeUseCase,\n    CleanupTaskSubtreeUseCaseImpl\n} from \"~/api/features/CleanupTaskSubtree/index.js\";\nimport { TestingRunTaskDefinition } from \"~/api/tasks/testingRunTask.js\";\nimport { createRegisterExtensionPlugin } from \"@webiny/handler\";\nimport { BackgroundTaskSettingsModel } from \"~/api/models/BackgroundTaskSettingsModel.js\";\nimport { GetBackgroundTaskSettingsFeature } from \"~/api/features/GetBackgroundTaskSettings/feature.js\";\nimport { UpdateBackgroundTaskSettingsFeature } from \"~/api/features/UpdateBackgroundTaskSettings/feature.js\";\nimport { BackgroundTaskPermissionsFeature } from \"~/api/features/BackgroundTaskPermissions/feature.js\";\nimport { createBackgroundTaskSettingsGraphQL } from \"~/api/graphql/BackgroundTaskSettingsSchema.js\";\n\nconst createTasksCrud = () => {\n    const tasksCrudPlugin = new ContextPlugin<Context>(async context => {\n        // Register the RunnableTaskDecorator to wrap all TaskDefinition instances\n        context.container.registerDecorator(RunnableTaskDecorator);\n        context.container.registerDecorator(SelfCleaningTaskDecorator);\n\n        // Register task definition use cases\n        GetTaskDefinitionFeature.register(context.container);\n        ListTaskDefinitionsFeature.register(context.container);\n\n        context.tasks = {\n            ...createDefinitionCrud(context),\n            ...createTaskCrud(context),\n            ...createServiceCrud(context)\n        };\n\n        // The cleanup use case is a thin wrapper around `context.tasks.cleanupTaskSubtree`,\n        // so it must register AFTER the CRUD is wired onto the context.\n        context.container.registerInstance(\n            CleanupTaskSubtreeUseCase,\n            new CleanupTaskSubtreeUseCaseImpl(context)\n        );\n    });\n\n    tasksCrudPlugin.name = \"tasks.context\";\n\n    return tasksCrudPlugin;\n};\n\nconst createTasksContext = (): Plugin[] => {\n    const modelsPlugin = createRegisterExtensionPlugin(context => {\n        context.container.register(TaskPrivateModel);\n        context.container.register(TaskLogPrivateModel);\n        context.container.register(BackgroundTaskSettingsModel);\n    });\n\n    return [...createServicePlugins(), createTasksCrud(), modelsPlugin];\n};\n\nexport const createBackgroundTaskContext = (): Plugin[] => {\n    return [\n        ...createTasksContext(),\n        ...createBackgroundTaskSettingsGraphQL(),\n        new ContextPlugin<Context>(context => {\n            // Register legacy tasks context via a new abstraction\n            context.container.registerInstance(TaskService, context.tasks);\n\n            // Register TaskExecutionContext EARLY (singleton, empty)\n            TaskExecutionContextFeature.register(context.container);\n\n            // Register TaskController (depends on TaskExecutionContext)\n            context.container.register(TaskController);\n\n            // Register a test task\n            context.container.register(TestingRunTaskDefinition);\n\n            // Permissions.\n            BackgroundTaskPermissionsFeature.register(context.container);\n\n            // Settings features.\n            GetBackgroundTaskSettingsFeature.register(context.container);\n            UpdateBackgroundTaskSettingsFeature.register(context.container);\n        })\n    ];\n};\n"],"names":["createTasksCrud","tasksCrudPlugin","ContextPlugin","context","RunnableTaskDecorator","SelfCleaningTaskDecorator","GetTaskDefinitionFeature","ListTaskDefinitionsFeature","createDefinitionCrud","createTaskCrud","createServiceCrud","CleanupTaskSubtreeUseCase","CleanupTaskSubtreeUseCaseImpl","createTasksContext","modelsPlugin","createRegisterExtensionPlugin","TaskPrivateModel","TaskLogPrivateModel","BackgroundTaskSettingsModel","createServicePlugins","createBackgroundTaskContext","createBackgroundTaskSettingsGraphQL","TaskService","TaskExecutionContextFeature","TaskController","TestingRunTaskDefinition","BackgroundTaskPermissionsFeature","GetBackgroundTaskSettingsFeature","UpdateBackgroundTaskSettingsFeature"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA4BA,MAAMA,kBAAkB;IACpB,MAAMC,kBAAkB,IAAIC,cAAuB,OAAMC;QAErDA,QAAQ,SAAS,CAAC,iBAAiB,CAACC;QACpCD,QAAQ,SAAS,CAAC,iBAAiB,CAACE;QAGpCC,yBAAyB,QAAQ,CAACH,QAAQ,SAAS;QACnDI,2BAA2B,QAAQ,CAACJ,QAAQ,SAAS;QAErDA,QAAQ,KAAK,GAAG;YACZ,GAAGK,qBAAqBL,QAAQ;YAChC,GAAGM,eAAeN,QAAQ;YAC1B,GAAGO,kBAAkBP,QAAQ;QACjC;QAIAA,QAAQ,SAAS,CAAC,gBAAgB,CAC9BQ,2BACA,IAAIC,8BAA8BT;IAE1C;IAEAF,gBAAgB,IAAI,GAAG;IAEvB,OAAOA;AACX;AAEA,MAAMY,qBAAqB;IACvB,MAAMC,eAAeC,8BAA8BZ,CAAAA;QAC/CA,QAAQ,SAAS,CAAC,QAAQ,CAACa;QAC3Bb,QAAQ,SAAS,CAAC,QAAQ,CAACc;QAC3Bd,QAAQ,SAAS,CAAC,QAAQ,CAACe;IAC/B;IAEA,OAAO;WAAIC;QAAwBnB;QAAmBc;KAAa;AACvE;AAEO,MAAMM,8BAA8B,IAChC;WACAP;WACAQ;QACH,IAAInB,cAAuBC,CAAAA;YAEvBA,QAAQ,SAAS,CAAC,gBAAgB,CAACmB,aAAanB,QAAQ,KAAK;YAG7DoB,4BAA4B,QAAQ,CAACpB,QAAQ,SAAS;YAGtDA,QAAQ,SAAS,CAAC,QAAQ,CAACqB;YAG3BrB,QAAQ,SAAS,CAAC,QAAQ,CAACsB;YAG3BC,iCAAiC,QAAQ,CAACvB,QAAQ,SAAS;YAG3DwB,iCAAiC,QAAQ,CAACxB,QAAQ,SAAS;YAC3DyB,oCAAoC,QAAQ,CAACzB,QAAQ,SAAS;QAClE;KACH"}

package/api/crud/TaskLogPrivateModel.d.ts

@@ -0,0 +1,9 @@
+import { ModelFactory } from "@webiny/api-headless-cms/features/modelBuilder/index.js";
+export declare const WEBINY_TASK_LOG_MODEL_ID = "wbyTaskLog";
+declare class TaskLogPrivateModelImpl implements ModelFactory.Interface {
+    execute(builder: ModelFactory.Builder): Promise<import("@webiny/api-headless-cms/features/modelBuilder/index.js").PrivateModelBuilder[]>;
+}
+export declare const TaskLogPrivateModel: typeof TaskLogPrivateModelImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-headless-cms/features/modelBuilder/abstractions").IModelFactory>;
+};
+export {};

package/api/crud/TaskLogPrivateModel.js

@@ -0,0 +1,40 @@
+import { ModelFactory } from "@webiny/api-headless-cms/features/modelBuilder/index.js";
+import { TaskLogItemType } from "../types.js";
+const WEBINY_TASK_LOG_MODEL_ID = "wbyTaskLog";
+class TaskLogPrivateModelImpl {
+    async execute(builder) {
+        return [
+            builder.private({
+                modelId: WEBINY_TASK_LOG_MODEL_ID,
+                name: "Webiny Task Log"
+            }).fields((fields)=>({
+                    executionName: fields.text().label("Execution Name"),
+                    task: fields.text().label("Task").required("Task is required."),
+                    iteration: fields.number().label("Iteration").required("Iteration is required."),
+                    items: fields.object().label("Items").list().required("Items is required.").fields((fields)=>({
+                            message: fields.text().label("Message").required("Message is required."),
+                            createdOn: fields.datetime().label("Created On").required("Created On is required."),
+                            type: fields.text().label("Type").required("Type is required.").predefinedValues([
+                                {
+                                    value: TaskLogItemType.INFO,
+                                    label: "Info"
+                                },
+                                {
+                                    value: TaskLogItemType.ERROR,
+                                    label: "Error"
+                                }
+                            ]),
+                            data: fields.json().label("Data"),
+                            error: fields.json().label("Error")
+                        }))
+                }))
+        ];
+    }
+}
+const TaskLogPrivateModel = ModelFactory.createImplementation({
+    implementation: TaskLogPrivateModelImpl,
+    dependencies: []
+});
+export { TaskLogPrivateModel, WEBINY_TASK_LOG_MODEL_ID };
+
+//# sourceMappingURL=TaskLogPrivateModel.js.map

package/api/crud/TaskLogPrivateModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/crud/TaskLogPrivateModel.js","sources":["../../../src/api/crud/TaskLogPrivateModel.ts"],"sourcesContent":["import { ModelFactory } from \"@webiny/api-headless-cms/features/modelBuilder/index.js\";\nimport { TaskLogItemType } from \"~/api/types.js\";\n\nexport const WEBINY_TASK_LOG_MODEL_ID = \"wbyTaskLog\";\n\nclass TaskLogPrivateModelImpl implements ModelFactory.Interface {\n    public async execute(builder: ModelFactory.Builder) {\n        return [\n            builder\n                .private({\n                    modelId: WEBINY_TASK_LOG_MODEL_ID,\n                    name: \"Webiny Task Log\"\n                })\n                .fields(fields => ({\n                    executionName: fields.text().label(\"Execution Name\"),\n                    task: fields.text().label(\"Task\").required(\"Task is required.\"),\n                    iteration: fields\n                        .number()\n                        .label(\"Iteration\")\n                        .required(\"Iteration is required.\"),\n                    items: fields\n                        .object()\n                        .label(\"Items\")\n                        .list()\n                        .required(\"Items is required.\")\n                        .fields(fields => ({\n                            message: fields\n                                .text()\n                                .label(\"Message\")\n                                .required(\"Message is required.\"),\n                            createdOn: fields\n                                .datetime()\n                                .label(\"Created On\")\n                                .required(\"Created On is required.\"),\n                            type: fields\n                                .text()\n                                .label(\"Type\")\n                                .required(\"Type is required.\")\n                                .predefinedValues([\n                                    {\n                                        value: TaskLogItemType.INFO,\n                                        label: \"Info\"\n                                    },\n                                    {\n                                        value: TaskLogItemType.ERROR,\n                                        label: \"Error\"\n                                    }\n                                ]),\n                            data: fields.json().label(\"Data\"),\n                            error: fields.json().label(\"Error\")\n                        }))\n                }))\n        ];\n    }\n}\n\nexport const TaskLogPrivateModel = ModelFactory.createImplementation({\n    implementation: TaskLogPrivateModelImpl,\n    dependencies: []\n});\n"],"names":["WEBINY_TASK_LOG_MODEL_ID","TaskLogPrivateModelImpl","builder","fields","TaskLogItemType","TaskLogPrivateModel","ModelFactory"],"mappings":";;AAGO,MAAMA,2BAA2B;AAExC,MAAMC;IACF,MAAa,QAAQC,OAA6B,EAAE;QAChD,OAAO;YACHA,QACK,OAAO,CAAC;gBACL,SAASF;gBACT,MAAM;YACV,GACC,MAAM,CAACG,CAAAA,SAAW;oBACf,eAAeA,OAAO,IAAI,GAAG,KAAK,CAAC;oBACnC,MAAMA,OAAO,IAAI,GAAG,KAAK,CAAC,QAAQ,QAAQ,CAAC;oBAC3C,WAAWA,OACN,MAAM,GACN,KAAK,CAAC,aACN,QAAQ,CAAC;oBACd,OAAOA,OACF,MAAM,GACN,KAAK,CAAC,SACN,IAAI,GACJ,QAAQ,CAAC,sBACT,MAAM,CAACA,CAAAA,SAAW;4BACf,SAASA,OACJ,IAAI,GACJ,KAAK,CAAC,WACN,QAAQ,CAAC;4BACd,WAAWA,OACN,QAAQ,GACR,KAAK,CAAC,cACN,QAAQ,CAAC;4BACd,MAAMA,OACD,IAAI,GACJ,KAAK,CAAC,QACN,QAAQ,CAAC,qBACT,gBAAgB,CAAC;gCACd;oCACI,OAAOC,gBAAgB,IAAI;oCAC3B,OAAO;gCACX;gCACA;oCACI,OAAOA,gBAAgB,KAAK;oCAC5B,OAAO;gCACX;6BACH;4BACL,MAAMD,OAAO,IAAI,GAAG,KAAK,CAAC;4BAC1B,OAAOA,OAAO,IAAI,GAAG,KAAK,CAAC;wBAC/B;gBACR;SACP;IACL;AACJ;AAEO,MAAME,sBAAsBC,aAAa,oBAAoB,CAAC;IACjE,gBAAgBL;IAChB,cAAc,EAAE;AACpB"}

package/api/crud/TaskPrivateModel.d.ts

@@ -0,0 +1,9 @@
+import { ModelFactory } from "@webiny/api-headless-cms/features/modelBuilder/index.js";
+export declare const WEBINY_TASK_MODEL_ID = "wbyTask";
+declare class TaskPrivateModelImpl implements ModelFactory.Interface {
+    execute(builder: ModelFactory.Builder): Promise<import("@webiny/api-headless-cms/features/modelBuilder/index.js").PrivateModelBuilder[]>;
+}
+export declare const TaskPrivateModel: typeof TaskPrivateModelImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-headless-cms/features/modelBuilder/abstractions").IModelFactory>;
+};
+export {};

package/api/crud/TaskPrivateModel.js

@@ -0,0 +1,55 @@
+import { ModelFactory } from "@webiny/api-headless-cms/features/modelBuilder/index.js";
+import { TaskDataStatus } from "../types.js";
+const WEBINY_TASK_MODEL_ID = "wbyTask";
+class TaskPrivateModelImpl {
+    async execute(builder) {
+        return [
+            builder.private({
+                modelId: WEBINY_TASK_MODEL_ID,
+                name: "Webiny Task"
+            }).fields((fields)=>({
+                    name: fields.text().label("Name").required("Name is required."),
+                    definitionId: fields.text().label("Definition ID").required("Definition ID is required."),
+                    parentId: fields.text().label("Parent ID"),
+                    executionName: fields.text().label("Execution Name"),
+                    iterations: fields.number().label("Iterations"),
+                    input: fields.json().label("Input"),
+                    output: fields.json().label("Output"),
+                    taskStatus: fields.text().label("Status").predefinedValues([
+                        {
+                            value: TaskDataStatus.PENDING,
+                            label: "Pending"
+                        },
+                        {
+                            value: TaskDataStatus.RUNNING,
+                            label: "Running"
+                        },
+                        {
+                            value: TaskDataStatus.FAILED,
+                            label: "Failed"
+                        },
+                        {
+                            value: TaskDataStatus.SUCCESS,
+                            label: "Success"
+                        },
+                        {
+                            value: TaskDataStatus.ABORTED,
+                            label: "Aborted"
+                        }
+                    ]).settings({
+                        defaultValue: TaskDataStatus.PENDING
+                    }),
+                    startedOn: fields.datetime().label("Started On"),
+                    finishedOn: fields.datetime().label("Finished On"),
+                    eventResponse: fields.json().label("Event Response")
+                }))
+        ];
+    }
+}
+const TaskPrivateModel = ModelFactory.createImplementation({
+    implementation: TaskPrivateModelImpl,
+    dependencies: []
+});
+export { TaskPrivateModel, WEBINY_TASK_MODEL_ID };
+
+//# sourceMappingURL=TaskPrivateModel.js.map

package/api/crud/TaskPrivateModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/crud/TaskPrivateModel.js","sources":["../../../src/api/crud/TaskPrivateModel.ts"],"sourcesContent":["import { ModelFactory } from \"@webiny/api-headless-cms/features/modelBuilder/index.js\";\nimport { TaskDataStatus } from \"~/api/types.js\";\n\nexport const WEBINY_TASK_MODEL_ID = \"wbyTask\";\n\nclass TaskPrivateModelImpl implements ModelFactory.Interface {\n    public async execute(builder: ModelFactory.Builder) {\n        return [\n            builder\n                .private({\n                    modelId: WEBINY_TASK_MODEL_ID,\n                    name: \"Webiny Task\"\n                })\n                .fields(fields => ({\n                    name: fields.text().label(\"Name\").required(\"Name is required.\"),\n                    definitionId: fields\n                        .text()\n                        .label(\"Definition ID\")\n                        .required(\"Definition ID is required.\"),\n                    parentId: fields.text().label(\"Parent ID\"),\n                    executionName: fields.text().label(\"Execution Name\"),\n                    iterations: fields.number().label(\"Iterations\"),\n                    input: fields.json().label(\"Input\"),\n                    output: fields.json().label(\"Output\"),\n                    taskStatus: fields\n                        .text()\n                        .label(\"Status\")\n                        .predefinedValues([\n                            {\n                                value: TaskDataStatus.PENDING,\n                                label: \"Pending\"\n                            },\n                            {\n                                value: TaskDataStatus.RUNNING,\n                                label: \"Running\"\n                            },\n                            {\n                                value: TaskDataStatus.FAILED,\n                                label: \"Failed\"\n                            },\n                            {\n                                value: TaskDataStatus.SUCCESS,\n                                label: \"Success\"\n                            },\n                            {\n                                value: TaskDataStatus.ABORTED,\n                                label: \"Aborted\"\n                            }\n                        ])\n                        .settings({ defaultValue: TaskDataStatus.PENDING }),\n                    startedOn: fields.datetime().label(\"Started On\"),\n                    finishedOn: fields.datetime().label(\"Finished On\"),\n                    eventResponse: fields.json().label(\"Event Response\")\n                }))\n        ];\n    }\n}\n\nexport const TaskPrivateModel = ModelFactory.createImplementation({\n    implementation: TaskPrivateModelImpl,\n    dependencies: []\n});\n"],"names":["WEBINY_TASK_MODEL_ID","TaskPrivateModelImpl","builder","fields","TaskDataStatus","TaskPrivateModel","ModelFactory"],"mappings":";;AAGO,MAAMA,uBAAuB;AAEpC,MAAMC;IACF,MAAa,QAAQC,OAA6B,EAAE;QAChD,OAAO;YACHA,QACK,OAAO,CAAC;gBACL,SAASF;gBACT,MAAM;YACV,GACC,MAAM,CAACG,CAAAA,SAAW;oBACf,MAAMA,OAAO,IAAI,GAAG,KAAK,CAAC,QAAQ,QAAQ,CAAC;oBAC3C,cAAcA,OACT,IAAI,GACJ,KAAK,CAAC,iBACN,QAAQ,CAAC;oBACd,UAAUA,OAAO,IAAI,GAAG,KAAK,CAAC;oBAC9B,eAAeA,OAAO,IAAI,GAAG,KAAK,CAAC;oBACnC,YAAYA,OAAO,MAAM,GAAG,KAAK,CAAC;oBAClC,OAAOA,OAAO,IAAI,GAAG,KAAK,CAAC;oBAC3B,QAAQA,OAAO,IAAI,GAAG,KAAK,CAAC;oBAC5B,YAAYA,OACP,IAAI,GACJ,KAAK,CAAC,UACN,gBAAgB,CAAC;wBACd;4BACI,OAAOC,eAAe,OAAO;4BAC7B,OAAO;wBACX;wBACA;4BACI,OAAOA,eAAe,OAAO;4BAC7B,OAAO;wBACX;wBACA;4BACI,OAAOA,eAAe,MAAM;4BAC5B,OAAO;wBACX;wBACA;4BACI,OAAOA,eAAe,OAAO;4BAC7B,OAAO;wBACX;wBACA;4BACI,OAAOA,eAAe,OAAO;4BAC7B,OAAO;wBACX;qBACH,EACA,QAAQ,CAAC;wBAAE,cAAcA,eAAe,OAAO;oBAAC;oBACrD,WAAWD,OAAO,QAAQ,GAAG,KAAK,CAAC;oBACnC,YAAYA,OAAO,QAAQ,GAAG,KAAK,CAAC;oBACpC,eAAeA,OAAO,IAAI,GAAG,KAAK,CAAC;gBACvC;SACP;IACL;AACJ;AAEO,MAAME,mBAAmBC,aAAa,oBAAoB,CAAC;IAC9D,gBAAgBL;IAChB,cAAc,EAAE;AACpB"}

package/api/crud/cleanupTaskSubtree.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from "../../api/types.js";
+/**
+ * Recursively deletes the task identified by `rootId`, all its descendants, and
+ * their logs (when the owning definition has databaseLogs=true). Bottom-up,
+ * best-effort: per-record errors are logged and swallowed, the function never
+ * throws.
+ */
+export declare const createCleanupTaskSubtree: (context: Context) => (rootId: string) => Promise<void>;

package/api/crud/cleanupTaskSubtree.js

@@ -0,0 +1,62 @@
+const createCleanupTaskSubtree = (context)=>{
+    const listChildren = async (parentId)=>{
+        const { items } = await context.tasks.listTasks({
+            where: {
+                parentId
+            }
+        });
+        return items;
+    };
+    const collectSubtree = async (rootId)=>{
+        const root = await context.tasks.getTask(rootId);
+        if (!root) return [];
+        const order = [
+            root
+        ];
+        const seen = new Set([
+            root.id
+        ]);
+        let i = 0;
+        while(i < order.length){
+            const current = order[i++];
+            const kids = await listChildren(current.id);
+            for (const kid of kids)if (!seen.has(kid.id)) {
+                seen.add(kid.id);
+                order.push(kid);
+            }
+        }
+        return order.reverse();
+    };
+    const deleteTaskLogs = async (task)=>{
+        const definition = context.tasks.getDefinition(task.definitionId);
+        if (!definition || true !== definition.databaseLogs) return;
+        try {
+            const { items } = await context.tasks.listLogs({
+                where: {
+                    task: task.id
+                }
+            });
+            for (const log of items)try {
+                await context.tasks.deleteLog(log.id);
+            } catch (ex) {
+                console.warn(`cleanupTaskSubtree: failed to delete log "${log.id}" for task "${task.id}": ${ex.message}`);
+            }
+        } catch (ex) {
+            console.warn(`cleanupTaskSubtree: failed to list logs for task "${task.id}": ${ex.message}`);
+        }
+    };
+    return async (rootId)=>{
+        const ordered = await collectSubtree(rootId);
+        for (const task of ordered){
+            await deleteTaskLogs(task);
+            try {
+                await context.tasks.deleteTask(task.id);
+            } catch (ex) {
+                console.warn(`cleanupTaskSubtree: failed to delete task "${task.id}": ${ex.message}`);
+            }
+        }
+    };
+};
+export { createCleanupTaskSubtree };
+
+//# sourceMappingURL=cleanupTaskSubtree.js.map

package/api/crud/cleanupTaskSubtree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/crud/cleanupTaskSubtree.js","sources":["../../../src/api/crud/cleanupTaskSubtree.ts"],"sourcesContent":["import type { Context, ITask } from \"~/api/types.js\";\n\n/**\n * Recursively deletes the task identified by `rootId`, all its descendants, and\n * their logs (when the owning definition has databaseLogs=true). Bottom-up,\n * best-effort: per-record errors are logged and swallowed, the function never\n * throws.\n */\nexport const createCleanupTaskSubtree = (context: Context) => {\n    const listChildren = async (parentId: string): Promise<ITask[]> => {\n        const { items } = await context.tasks.listTasks({\n            where: { parentId }\n        });\n        return items;\n    };\n\n    const collectSubtree = async (rootId: string): Promise<ITask[]> => {\n        const root = await context.tasks.getTask(rootId);\n        if (!root) {\n            return [];\n        }\n        const order: ITask[] = [root];\n        const seen = new Set<string>([root.id]);\n        let i = 0;\n        while (i < order.length) {\n            const current = order[i++];\n            const kids = await listChildren(current.id);\n            for (const kid of kids) {\n                if (seen.has(kid.id)) {\n                    continue;\n                }\n                seen.add(kid.id);\n                order.push(kid);\n            }\n        }\n        return order.reverse();\n    };\n\n    const deleteTaskLogs = async (task: ITask): Promise<void> => {\n        const definition = context.tasks.getDefinition(task.definitionId);\n        if (!definition || definition.databaseLogs !== true) {\n            return;\n        }\n        try {\n            const { items } = await context.tasks.listLogs({\n                where: { task: task.id }\n            });\n            for (const log of items) {\n                try {\n                    await context.tasks.deleteLog(log.id);\n                } catch (ex: any) {\n                    console.warn(\n                        `cleanupTaskSubtree: failed to delete log \"${log.id}\" for task \"${task.id}\": ${ex.message}`\n                    );\n                }\n            }\n        } catch (ex: any) {\n            console.warn(\n                `cleanupTaskSubtree: failed to list logs for task \"${task.id}\": ${ex.message}`\n            );\n        }\n    };\n\n    return async (rootId: string): Promise<void> => {\n        const ordered = await collectSubtree(rootId);\n        for (const task of ordered) {\n            await deleteTaskLogs(task);\n            try {\n                await context.tasks.deleteTask(task.id);\n            } catch (ex: any) {\n                console.warn(\n                    `cleanupTaskSubtree: failed to delete task \"${task.id}\": ${ex.message}`\n                );\n            }\n        }\n    };\n};\n"],"names":["createCleanupTaskSubtree","context","listChildren","parentId","items","collectSubtree","rootId","root","order","seen","Set","i","current","kids","kid","deleteTaskLogs","task","definition","log","ex","console","ordered"],"mappings":"AAQO,MAAMA,2BAA2B,CAACC;IACrC,MAAMC,eAAe,OAAOC;QACxB,MAAM,EAAEC,KAAK,EAAE,GAAG,MAAMH,QAAQ,KAAK,CAAC,SAAS,CAAC;YAC5C,OAAO;gBAAEE;YAAS;QACtB;QACA,OAAOC;IACX;IAEA,MAAMC,iBAAiB,OAAOC;QAC1B,MAAMC,OAAO,MAAMN,QAAQ,KAAK,CAAC,OAAO,CAACK;QACzC,IAAI,CAACC,MACD,OAAO,EAAE;QAEb,MAAMC,QAAiB;YAACD;SAAK;QAC7B,MAAME,OAAO,IAAIC,IAAY;YAACH,KAAK,EAAE;SAAC;QACtC,IAAII,IAAI;QACR,MAAOA,IAAIH,MAAM,MAAM,CAAE;YACrB,MAAMI,UAAUJ,KAAK,CAACG,IAAI;YAC1B,MAAME,OAAO,MAAMX,aAAaU,QAAQ,EAAE;YAC1C,KAAK,MAAME,OAAOD,KACd,KAAIJ,KAAK,GAAG,CAACK,IAAI,EAAE;gBAGnBL,KAAK,GAAG,CAACK,IAAI,EAAE;gBACfN,MAAM,IAAI,CAACM;;QAEnB;QACA,OAAON,MAAM,OAAO;IACxB;IAEA,MAAMO,iBAAiB,OAAOC;QAC1B,MAAMC,aAAahB,QAAQ,KAAK,CAAC,aAAa,CAACe,KAAK,YAAY;QAChE,IAAI,CAACC,cAAcA,AAA4B,SAA5BA,WAAW,YAAY,EACtC;QAEJ,IAAI;YACA,MAAM,EAAEb,KAAK,EAAE,GAAG,MAAMH,QAAQ,KAAK,CAAC,QAAQ,CAAC;gBAC3C,OAAO;oBAAE,MAAMe,KAAK,EAAE;gBAAC;YAC3B;YACA,KAAK,MAAME,OAAOd,MACd,IAAI;gBACA,MAAMH,QAAQ,KAAK,CAAC,SAAS,CAACiB,IAAI,EAAE;YACxC,EAAE,OAAOC,IAAS;gBACdC,QAAQ,IAAI,CACR,CAAC,0CAA0C,EAAEF,IAAI,EAAE,CAAC,YAAY,EAAEF,KAAK,EAAE,CAAC,GAAG,EAAEG,GAAG,OAAO,EAAE;YAEnG;QAER,EAAE,OAAOA,IAAS;YACdC,QAAQ,IAAI,CACR,CAAC,kDAAkD,EAAEJ,KAAK,EAAE,CAAC,GAAG,EAAEG,GAAG,OAAO,EAAE;QAEtF;IACJ;IAEA,OAAO,OAAOb;QACV,MAAMe,UAAU,MAAMhB,eAAeC;QACrC,KAAK,MAAMU,QAAQK,QAAS;YACxB,MAAMN,eAAeC;YACrB,IAAI;gBACA,MAAMf,QAAQ,KAAK,CAAC,UAAU,CAACe,KAAK,EAAE;YAC1C,EAAE,OAAOG,IAAS;gBACdC,QAAQ,IAAI,CACR,CAAC,2CAA2C,EAAEJ,KAAK,EAAE,CAAC,GAAG,EAAEG,GAAG,OAAO,EAAE;YAE/E;QACJ;IACJ;AACJ"}

package/api/crud/crud.tasks.d.ts

@@ -0,0 +1,2 @@
+import type { Context, ITasksContextCrudObject } from "../../api/types.js";
+export declare const createTaskCrud: (context: Context) => ITasksContextCrudObject;

package/api/crud/crud.tasks.js

@@ -0,0 +1,318 @@
+import error from "@webiny/error";
+import { TaskDataStatus } from "../types.js";
+import { WEBINY_TASK_MODEL_ID } from "./TaskPrivateModel.js";
+import { WEBINY_TASK_LOG_MODEL_ID } from "./TaskLogPrivateModel.js";
+import { NotFoundError } from "@webiny/handler-graphql";
+import { createZodError, parseIdentifier } from "@webiny/utils";
+import zod from "zod";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
+import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry";
+import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { TaskDefinitionNotFoundError, TaskLogNotFoundError, TaskNotFoundError } from "../domain/errors.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { TaskAfterCreateEvent, TaskAfterDeleteEvent, TaskAfterUpdateEvent, TaskBeforeCreateEvent, TaskBeforeDeleteEvent, TaskBeforeUpdateEvent } from "../events/index.js";
+import { CmsWhereMapper } from "@webiny/api-headless-cms";
+import { createCleanupTaskSubtree } from "./cleanupTaskSubtree.js";
+const createRevisionId = (id)=>{
+    const { id: entryId } = parseIdentifier(id);
+    return `${entryId}#0001`;
+};
+const convertToTask = (entry)=>({
+        id: entry.entryId,
+        createdOn: entry.createdOn,
+        savedOn: entry.savedOn,
+        createdBy: entry.createdBy,
+        name: entry.values.name,
+        definitionId: entry.values.definitionId,
+        input: entry.values.input,
+        output: entry.values.output,
+        taskStatus: entry.values.taskStatus,
+        executionName: entry.values.executionName || "",
+        eventResponse: entry.values.eventResponse,
+        startedOn: entry.values.startedOn,
+        finishedOn: entry.values.finishedOn,
+        iterations: entry.values.iterations,
+        parentId: entry.values.parentId
+    });
+const convertToLog = (entry)=>({
+        id: entry.entryId,
+        createdOn: entry.createdOn,
+        createdBy: entry.createdBy,
+        executionName: entry.values.executionName,
+        task: entry.values.task,
+        iteration: entry.values.iteration,
+        items: entry.values.items || []
+    });
+const getZodSchema = (schema)=>{
+    if (!schema) return zod.looseObject({});
+    if (schema instanceof zod.ZodObject) return schema.loose();
+    if (schema instanceof zod.ZodType) return schema;
+    return zod.looseObject(schema);
+};
+const validateTaskInput = async (params)=>{
+    const { definition, data } = params;
+    if (!definition.createInputValidation) return;
+    const schema = definition.createInputValidation({
+        validator: zod
+    });
+    const validate = getZodSchema(schema);
+    const result = await validate.safeParseAsync(data.input);
+    if (result.success) return;
+    throw createZodError(result.error);
+};
+const createTaskCrud = (context)=>{
+    const cmsWhereMapper = context.container.resolve(CmsWhereMapper);
+    const getTaskModel = async ()=>{
+        const identityContext = context.container.resolve(IdentityContext);
+        return await identityContext.withoutAuthorization(async ()=>{
+            const getModel = context.container.resolve(GetModelUseCase);
+            const result = await getModel.execute(WEBINY_TASK_MODEL_ID);
+            if (result.isFail()) throw new error(`There is no model "${WEBINY_TASK_MODEL_ID}".`);
+            return result.value;
+        });
+    };
+    const getLogModel = async ()=>{
+        const identityContext = context.container.resolve(IdentityContext);
+        return await identityContext.withoutAuthorization(async ()=>{
+            const getModel = context.container.resolve(GetModelUseCase);
+            const result = await getModel.execute(WEBINY_TASK_LOG_MODEL_ID);
+            if (result.isFail()) throw new error(`There is no model "${WEBINY_TASK_LOG_MODEL_ID}".`);
+            return result.value;
+        });
+    };
+    const getTask = async (id)=>{
+        const identityContext = context.container.resolve(IdentityContext);
+        const entry = await identityContext.withoutAuthorization(async ()=>{
+            const model = await getTaskModel();
+            const getEntryById = context.container.resolve(GetEntryByIdUseCase);
+            const result = await getEntryById.execute(model, createRevisionId(id));
+            if (result.isFail()) return null;
+            return result.value;
+        });
+        if (!entry) return null;
+        return convertToTask(entry);
+    };
+    const listTasks = async (params)=>{
+        const identityContext = context.container.resolve(IdentityContext);
+        const { entries, meta } = await identityContext.withoutAuthorization(async ()=>{
+            const model = await getTaskModel();
+            const listLatestEntries = context.container.resolve(ListLatestEntriesUseCase);
+            const result = await listLatestEntries.execute(model, {
+                ...params,
+                where: cmsWhereMapper.map({
+                    input: params?.where,
+                    fields: model.fields
+                })
+            });
+            if (result.isFail()) throw result.error;
+            return result.value;
+        });
+        return {
+            items: entries.map((item)=>convertToTask(item)),
+            meta
+        };
+    };
+    const createTask = async (data)=>{
+        const definition = context.tasks.getDefinition(data.definitionId);
+        if (!definition) throw new TaskDefinitionNotFoundError(data.definitionId);
+        await validateTaskInput({
+            context,
+            definition,
+            data
+        });
+        const identityContext = context.container.resolve(IdentityContext);
+        const eventPublisher = context.container.resolve(EventPublisher);
+        const beforeCreateEvent = new TaskBeforeCreateEvent({
+            input: data
+        });
+        await eventPublisher.publish(beforeCreateEvent);
+        const result = await identityContext.withoutAuthorization(async ()=>{
+            const model = await getTaskModel();
+            const createEntry = context.container.resolve(CreateEntryUseCase);
+            return createEntry.execute(model, {
+                values: {
+                    ...data,
+                    iterations: 0,
+                    taskStatus: TaskDataStatus.PENDING
+                }
+            });
+        });
+        if (result.isFail()) throw result.error;
+        const task = convertToTask(result.value);
+        const afterCreateEvent = new TaskAfterCreateEvent({
+            input: data,
+            task
+        });
+        await eventPublisher.publish(afterCreateEvent);
+        return task;
+    };
+    const updateTask = async (id, data)=>{
+        const original = await getTask(id);
+        if (!original) throw new TaskNotFoundError();
+        const identityContext = context.container.resolve(IdentityContext);
+        const eventPublisher = context.container.resolve(EventPublisher);
+        const beforeUpdateEvent = new TaskBeforeUpdateEvent({
+            input: data,
+            original
+        });
+        await eventPublisher.publish(beforeUpdateEvent);
+        const result = await identityContext.withoutAuthorization(async ()=>{
+            const model = await getTaskModel();
+            const updateEntry = context.container.resolve(UpdateEntryUseCase);
+            return updateEntry.execute(model, createRevisionId(id), {
+                values: {
+                    ...data
+                }
+            });
+        });
+        if (result.isFail()) throw result.error;
+        const task = convertToTask(result.value);
+        const afterUpdateEvent = new TaskAfterUpdateEvent({
+            input: data,
+            task
+        });
+        await eventPublisher.publish(afterUpdateEvent);
+        return task;
+    };
+    const deleteTask = async (id)=>{
+        const task = await getTask(id);
+        if (!task) throw new TaskNotFoundError();
+        const identityContext = context.container.resolve(IdentityContext);
+        const eventPublisher = context.container.resolve(EventPublisher);
+        const beforeDeleteEvent = new TaskBeforeDeleteEvent({
+            task
+        });
+        await eventPublisher.publish(beforeDeleteEvent);
+        const result = await identityContext.withoutAuthorization(async ()=>{
+            const model = await getTaskModel();
+            const deleteEntry = context.container.resolve(DeleteEntryUseCase);
+            return deleteEntry.execute(model, createRevisionId(id));
+        });
+        if (result.isFail()) throw new TaskNotFoundError();
+        const afterDeleteEvent = new TaskAfterDeleteEvent({
+            task
+        });
+        await eventPublisher.publish(afterDeleteEvent);
+        return true;
+    };
+    const createLog = async (task, data)=>{
+        const identityContext = context.container.resolve(IdentityContext);
+        const result = await identityContext.withoutAuthorization(async ()=>{
+            const model = await getLogModel();
+            const createEntry = context.container.resolve(CreateEntryUseCase);
+            return createEntry.execute(model, {
+                values: {
+                    ...data,
+                    task: task.id
+                }
+            });
+        });
+        if (result.isFail()) throw result.error;
+        return convertToLog(result.value);
+    };
+    const updateLog = async (id, data)=>{
+        const identityContext = context.container.resolve(IdentityContext);
+        const result = await identityContext.withoutAuthorization(async ()=>{
+            const model = await getLogModel();
+            const updateEntry = context.container.resolve(UpdateEntryUseCase);
+            return updateEntry.execute(model, createRevisionId(id), {
+                values: data
+            });
+        });
+        if (result.isFail()) throw new TaskLogNotFoundError();
+        return convertToLog(result.value);
+    };
+    const deleteLog = async (id)=>{
+        const identityContext = context.container.resolve(IdentityContext);
+        const result = await identityContext.withoutAuthorization(async ()=>{
+            const model = await getLogModel();
+            const deleteEntry = context.container.resolve(DeleteEntryUseCase);
+            return deleteEntry.execute(model, id);
+        });
+        if (result.isFail()) throw new TaskLogNotFoundError();
+        return true;
+    };
+    const getLog = async (id)=>{
+        const identityContext = context.container.resolve(IdentityContext);
+        try {
+            const result = await identityContext.withoutAuthorization(async ()=>{
+                const model = await getLogModel();
+                const getEntryById = context.container.resolve(GetEntryByIdUseCase);
+                return getEntryById.execute(model, id);
+            });
+            if (result.isFail()) throw result.error;
+            return convertToLog(result.value);
+        } catch (ex) {
+            if (ex instanceof NotFoundError) return null;
+            throw ex;
+        }
+    };
+    const getLatestLog = async (taskId)=>{
+        const identityContext = context.container.resolve(IdentityContext);
+        const entry = await identityContext.withoutAuthorization(async ()=>{
+            const model = await getLogModel();
+            const listLatestEntries = context.container.resolve(ListLatestEntriesUseCase);
+            const result = await listLatestEntries.execute(model, {
+                where: {
+                    values: {
+                        task: taskId
+                    }
+                },
+                sort: [
+                    "createdOn_DESC"
+                ],
+                limit: 1
+            });
+            if (result.isFail()) throw result.error;
+            const { entries } = result.value;
+            const [item] = entries;
+            if (!item) throw new NotFoundError(`No existing latest log found for task "${taskId}".`);
+            return item;
+        });
+        return convertToLog(entry);
+    };
+    const cleanupTaskSubtree = createCleanupTaskSubtree(context);
+    const listLogs = async (params)=>{
+        const identityContext = context.container.resolve(IdentityContext);
+        const { entries, meta } = await identityContext.withoutAuthorization(async ()=>{
+            const model = await getLogModel();
+            const listLatestEntries = context.container.resolve(ListLatestEntriesUseCase);
+            const result = await listLatestEntries.execute(model, {
+                ...params,
+                where: cmsWhereMapper.map({
+                    input: params.where,
+                    fields: model.fields
+                })
+            });
+            if (result.isFail()) throw result.error;
+            return result.value;
+        });
+        return {
+            items: entries.map((item)=>convertToLog(item)),
+            meta
+        };
+    };
+    return {
+        getTask,
+        listTasks,
+        createTask,
+        updateTask,
+        deleteTask,
+        cleanupTaskSubtree,
+        createLog,
+        updateLog,
+        deleteLog,
+        getLog,
+        listLogs,
+        getLatestLog,
+        getTaskModel,
+        getLogModel
+    };
+};
+export { createTaskCrud };
+
+//# sourceMappingURL=crud.tasks.js.map