@webiny/background-tasks 0.0.0-unstable.0d717d18dd

package/admin/presentation/security/HasPermission.d.ts

@@ -0,0 +1,12 @@
+export declare const HasPermission: import("react").FC<import("@webiny/app-admin/permissions").HasPermissionProps<{
+    readonly prefix: "backgroundTasks";
+    readonly fullAccess: true;
+    readonly entities: [{
+        readonly id: "task";
+        readonly permission: "backgroundTasks.task";
+        readonly scopes: ["full"];
+        readonly actions: [{
+            readonly name: "rwd";
+        }];
+    }];
+}>>;

package/admin/presentation/security/HasPermission.js

@@ -0,0 +1,6 @@
+import { createHasPermission } from "@webiny/app-admin/exports/admin/security.js";
+import { TaskPermissions } from "../../features/permissions/abstractions.js";
+const HasPermission = createHasPermission(TaskPermissions);
+export { HasPermission };
+
+//# sourceMappingURL=HasPermission.js.map

package/admin/presentation/security/HasPermission.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/presentation/security/HasPermission.js","sources":["../../../../src/admin/presentation/security/HasPermission.tsx"],"sourcesContent":["import { createHasPermission } from \"@webiny/app-admin/exports/admin/security.js\";\nimport { TaskPermissions } from \"~/admin/features/permissions/abstractions.js\";\nimport { BACKGROUND_TASK_PERMISSIONS_SCHEMA } from \"~/admin/permissions.js\";\n\nexport const HasPermission =\n    createHasPermission<typeof BACKGROUND_TASK_PERMISSIONS_SCHEMA>(TaskPermissions);\n"],"names":["HasPermission","createHasPermission","TaskPermissions"],"mappings":";;AAIO,MAAMA,gBACTC,oBAA+DC"}

package/admin/presentation/security/usePermissions.d.ts

@@ -0,0 +1,12 @@
+export declare const usePermissions: () => {
+    canAccess: (entityId: "task") => boolean;
+    canAction: (action: string, entityId: "task") => boolean;
+} & {
+    canRead: (entityId: "task") => boolean;
+    canCreate: (entityId: "task") => boolean;
+    canEdit: (entityId: "task", item?: import("@webiny/app-admin/permissions").OwnableItem) => boolean;
+    canDelete: (entityId: "task", item?: import("@webiny/app-admin/permissions").OwnableItem) => boolean;
+} & {
+    canPublish: (entityId: string) => boolean;
+    canUnpublish: (entityId: string) => boolean;
+};

package/admin/presentation/security/usePermissions.js

@@ -0,0 +1,6 @@
+import { createUsePermissions } from "@webiny/app-admin/exports/admin/security.js";
+import { TaskPermissions } from "../../features/permissions/abstractions.js";
+const usePermissions = createUsePermissions(TaskPermissions);
+export { usePermissions };
+
+//# sourceMappingURL=usePermissions.js.map

package/admin/presentation/security/usePermissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/presentation/security/usePermissions.js","sources":["../../../../src/admin/presentation/security/usePermissions.ts"],"sourcesContent":["import { createUsePermissions } from \"@webiny/app-admin/exports/admin/security.js\";\nimport { TaskPermissions } from \"~/admin/features/permissions/abstractions.js\";\n\nexport const usePermissions = createUsePermissions(TaskPermissions);\n"],"names":["usePermissions","createUsePermissions","TaskPermissions"],"mappings":";;AAGO,MAAMA,iBAAiBC,qBAAqBC"}

package/admin/routes.d.ts

@@ -0,0 +1,6 @@
+import { Route } from "@webiny/app-admin";
+export declare const Routes: {
+    Definitions: Route<undefined>;
+    Executions: Route<undefined>;
+    Settings: Route<undefined>;
+};

package/admin/routes.js

@@ -0,0 +1,18 @@
+import { Route } from "@webiny/app-admin";
+const Routes = {
+    Definitions: new Route({
+        name: "BackgroundTasks/Definitions",
+        path: "/background-tasks/definitions"
+    }),
+    Executions: new Route({
+        name: "BackgroundTasks/Executions",
+        path: "/background-tasks/executions"
+    }),
+    Settings: new Route({
+        name: "BackgroundTasks/Settings",
+        path: "/background-tasks/settings"
+    })
+};
+export { Routes };
+
+//# sourceMappingURL=routes.js.map

package/admin/routes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/routes.js","sources":["../../src/admin/routes.ts"],"sourcesContent":["import { Route } from \"@webiny/app-admin\";\n\nexport const Routes = {\n    Definitions: new Route({\n        name: \"BackgroundTasks/Definitions\",\n        path: \"/background-tasks/definitions\"\n    }),\n    Executions: new Route({\n        name: \"BackgroundTasks/Executions\",\n        path: \"/background-tasks/executions\"\n    }),\n    Settings: new Route({\n        name: \"BackgroundTasks/Settings\",\n        path: \"/background-tasks/settings\"\n    })\n};\n"],"names":["Routes","Route"],"mappings":";AAEO,MAAMA,SAAS;IAClB,aAAa,IAAIC,MAAM;QACnB,MAAM;QACN,MAAM;IACV;IACA,YAAY,IAAIA,MAAM;QAClB,MAAM;QACN,MAAM;IACV;IACA,UAAU,IAAIA,MAAM;QAChB,MAAM;QACN,MAAM;IACV;AACJ"}

package/admin/shared/types.d.ts

@@ -0,0 +1,18 @@
+import type { TaskRun } from "@webiny/sdk";
+export type TaskStatus = "pending" | "running" | "success" | "failed" | "aborted";
+export type Task = Omit<TaskRun, "taskStatus"> & {
+    taskStatus: TaskStatus;
+    createdOn?: string;
+    savedOn?: string;
+    createdBy?: {
+        id: string;
+        displayName: string;
+        type?: string;
+    };
+};
+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/BackgroundTasksFeature.d.ts

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

package/api/BackgroundTasksFeature.js

@@ -0,0 +1,59 @@
+import { createFeature } from "@webiny/feature/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 { BackgroundTaskSettingsModel } from "./models/BackgroundTaskSettingsModel.js";
+import { createDefinitionCrud } from "./crud/definition.tasks.js";
+import { createServiceCrud } from "./crud/service.tasks.js";
+import { createTaskCrud } from "./crud/crud.tasks.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 { TasksCrud } from "./TasksCrud.js";
+import { TriggerTaskFeature } from "./features/TriggerTask/feature.js";
+import { AbortTaskFeature } from "./features/AbortTask/feature.js";
+import { GetTaskFeature } from "./features/GetTask/feature.js";
+import { ListTasksFeature } from "./features/ListTasks/feature.js";
+import { TestingRunTaskDefinition } from "./tasks/testingRunTask.js";
+import { BackgroundTaskPermissionsFeature } from "./features/BackgroundTaskPermissions/feature.js";
+import { GetBackgroundTaskSettingsFeature } from "./features/GetBackgroundTaskSettings/feature.js";
+import { UpdateBackgroundTaskSettingsFeature } from "./features/UpdateBackgroundTaskSettings/feature.js";
+import { BackgroundTasksContextualSchema } from "./graphql/BackgroundTasksContextualSchema.js";
+const BackgroundTasksFeature = createFeature({
+    name: "BackgroundTasks",
+    register (container) {
+        container.register(TaskPrivateModel);
+        container.register(TaskLogPrivateModel);
+        container.register(BackgroundTaskSettingsModel);
+        container.registerDecorator(RunnableTaskDecorator);
+        container.registerDecorator(SelfCleaningTaskDecorator);
+        GetTaskDefinitionFeature.register(container);
+        ListTaskDefinitionsFeature.register(container);
+        const tasksCrud = {
+            ...createDefinitionCrud(container),
+            ...createTaskCrud(container),
+            ...createServiceCrud(container)
+        };
+        container.registerInstance(TasksCrud, tasksCrud);
+        container.registerInstance(TaskService, tasksCrud);
+        TriggerTaskFeature.register(container);
+        AbortTaskFeature.register(container);
+        GetTaskFeature.register(container);
+        ListTasksFeature.register(container);
+        container.registerInstance(CleanupTaskSubtreeUseCase, new CleanupTaskSubtreeUseCaseImpl(container.resolve(TasksCrud)));
+        TaskExecutionContextFeature.register(container);
+        container.register(TaskController);
+        container.register(TestingRunTaskDefinition);
+        BackgroundTaskPermissionsFeature.register(container);
+        GetBackgroundTaskSettingsFeature.register(container);
+        UpdateBackgroundTaskSettingsFeature.register(container);
+        container.register(BackgroundTasksContextualSchema);
+    }
+});
+export { BackgroundTasksFeature };
+
+//# sourceMappingURL=BackgroundTasksFeature.js.map

package/api/BackgroundTasksFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/BackgroundTasksFeature.js","sources":["../../src/api/BackgroundTasksFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/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 { TaskPrivateModel } from \"./crud/TaskPrivateModel.js\";\nimport { TaskLogPrivateModel } from \"./crud/TaskLogPrivateModel.js\";\nimport { BackgroundTaskSettingsModel } from \"./models/BackgroundTaskSettingsModel.js\";\nimport { createDefinitionCrud } from \"./crud/definition.tasks.js\";\nimport { createServiceCrud } from \"./crud/service.tasks.js\";\nimport { createTaskCrud } from \"./crud/crud.tasks.js\";\nimport { TaskExecutionContextFeature } from \"./features/TaskExecutionContext/feature.js\";\nimport { GetTaskDefinitionFeature } from \"./features/GetTaskDefinition/feature.js\";\nimport { ListTaskDefinitionsFeature } from \"./features/ListTaskDefinitions/feature.js\";\nimport {\n    CleanupTaskSubtreeUseCase,\n    CleanupTaskSubtreeUseCaseImpl\n} from \"./features/CleanupTaskSubtree/index.js\";\nimport { TasksCrud } from \"./TasksCrud.js\";\nimport { TriggerTaskFeature } from \"./features/TriggerTask/feature.js\";\nimport { AbortTaskFeature } from \"./features/AbortTask/feature.js\";\nimport { GetTaskFeature } from \"./features/GetTask/feature.js\";\nimport { ListTasksFeature } from \"./features/ListTasks/feature.js\";\nimport { TestingRunTaskDefinition } from \"./tasks/testingRunTask.js\";\nimport { BackgroundTaskPermissionsFeature } from \"./features/BackgroundTaskPermissions/feature.js\";\nimport { GetBackgroundTaskSettingsFeature } from \"./features/GetBackgroundTaskSettings/feature.js\";\nimport { UpdateBackgroundTaskSettingsFeature } from \"./features/UpdateBackgroundTaskSettings/feature.js\";\nimport { BackgroundTasksContextualSchema } from \"./graphql/BackgroundTasksContextualSchema.js\";\n\nexport const BackgroundTasksFeature = createFeature({\n    name: \"BackgroundTasks\",\n    register(container) {\n        // Register models at register() time so they are available to GetModelUseCase when the\n        // ModelsFetcher cache is first filled (which may happen during an earlier feature's enhance).\n        container.register(TaskPrivateModel);\n        container.register(TaskLogPrivateModel);\n        container.register(BackgroundTaskSettingsModel);\n\n        // Decorators wrapping all TaskDefinition instances.\n        container.registerDecorator(RunnableTaskDecorator);\n        container.registerDecorator(SelfCleaningTaskDecorator);\n\n        // Task definition use cases.\n        GetTaskDefinitionFeature.register(container);\n        ListTaskDefinitionsFeature.register(container);\n\n        // Build the tasks CRUD facade from the container and register it as the canonical TasksCrud\n        // abstraction (plus the legacy TaskService alias). The factory methods resolve TasksCrud\n        // lazily for sibling calls, so registering the assembled object up front is sufficient.\n        const tasksCrud = {\n            ...createDefinitionCrud(container),\n            ...createTaskCrud(container),\n            ...createServiceCrud(container)\n        };\n        container.registerInstance(TasksCrud, tasksCrud);\n        container.registerInstance(TaskService, tasksCrud);\n\n        // Task CRUD use cases (must be after TasksCrud is registered).\n        TriggerTaskFeature.register(container);\n        AbortTaskFeature.register(container);\n        GetTaskFeature.register(container);\n        ListTasksFeature.register(container);\n        container.registerInstance(\n            CleanupTaskSubtreeUseCase,\n            new CleanupTaskSubtreeUseCaseImpl(container.resolve(TasksCrud))\n        );\n\n        // Execution context (singleton), controller, and the built-in test task.\n        TaskExecutionContextFeature.register(container);\n        container.register(TaskController);\n        container.register(TestingRunTaskDefinition);\n\n        // Permissions + settings features.\n        BackgroundTaskPermissionsFeature.register(container);\n        GetBackgroundTaskSettingsFeature.register(container);\n        UpdateBackgroundTaskSettingsFeature.register(container);\n\n        // GraphQL schema — rendered per-request from the CMS task/log content models.\n        container.register(BackgroundTasksContextualSchema);\n    }\n});\n"],"names":["BackgroundTasksFeature","createFeature","container","TaskPrivateModel","TaskLogPrivateModel","BackgroundTaskSettingsModel","RunnableTaskDecorator","SelfCleaningTaskDecorator","GetTaskDefinitionFeature","ListTaskDefinitionsFeature","tasksCrud","createDefinitionCrud","createTaskCrud","createServiceCrud","TasksCrud","TaskService","TriggerTaskFeature","AbortTaskFeature","GetTaskFeature","ListTasksFeature","CleanupTaskSubtreeUseCase","CleanupTaskSubtreeUseCaseImpl","TaskExecutionContextFeature","TaskController","TestingRunTaskDefinition","BackgroundTaskPermissionsFeature","GetBackgroundTaskSettingsFeature","UpdateBackgroundTaskSettingsFeature","BackgroundTasksContextualSchema"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA6BO,MAAMA,yBAAyBC,cAAc;IAChD,MAAM;IACN,UAASC,SAAS;QAGdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG;QAGnBH,UAAU,iBAAiB,CAACI;QAC5BJ,UAAU,iBAAiB,CAACK;QAG5BC,yBAAyB,QAAQ,CAACN;QAClCO,2BAA2B,QAAQ,CAACP;QAKpC,MAAMQ,YAAY;YACd,GAAGC,qBAAqBT,UAAU;YAClC,GAAGU,eAAeV,UAAU;YAC5B,GAAGW,kBAAkBX,UAAU;QACnC;QACAA,UAAU,gBAAgB,CAACY,WAAWJ;QACtCR,UAAU,gBAAgB,CAACa,aAAaL;QAGxCM,mBAAmB,QAAQ,CAACd;QAC5Be,iBAAiB,QAAQ,CAACf;QAC1BgB,eAAe,QAAQ,CAAChB;QACxBiB,iBAAiB,QAAQ,CAACjB;QAC1BA,UAAU,gBAAgB,CACtBkB,2BACA,IAAIC,8BAA8BnB,UAAU,OAAO,CAACY;QAIxDQ,4BAA4B,QAAQ,CAACpB;QACrCA,UAAU,QAAQ,CAACqB;QACnBrB,UAAU,QAAQ,CAACsB;QAGnBC,iCAAiC,QAAQ,CAACvB;QAC1CwB,iCAAiC,QAAQ,CAACxB;QAC1CyB,oCAAoC,QAAQ,CAACzB;QAG7CA,UAAU,QAAQ,CAAC0B;IACvB;AACJ"}

package/api/TasksCrud.d.ts

@@ -0,0 +1,10 @@
+import type { ITasksContextObject } from "../api/types.js";
+/**
+ * At runtime this is the full tasks facade (CRUD + definition + service methods), assembled and
+ * registered by BackgroundTasksFeature. Typed as the full `ITasksContextObject` so sibling calls
+ * (e.g. `getDefinition`, `trigger`) type-check.
+ */
+export declare const TasksCrud: import("@webiny/di").Abstraction<ITasksContextObject>;
+export declare namespace TasksCrud {
+    type Interface = ITasksContextObject;
+}

package/api/TasksCrud.js

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

package/api/TasksCrud.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/TasksCrud.js","sources":["../../src/api/TasksCrud.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { ITasksContextObject } from \"~/api/types.js\";\n\n/**\n * At runtime this is the full tasks facade (CRUD + definition + service methods), assembled and\n * registered by BackgroundTasksFeature. Typed as the full `ITasksContextObject` so sibling calls\n * (e.g. `getDefinition`, `trigger`) type-check.\n */\nexport const TasksCrud = createAbstraction<ITasksContextObject>(\"Tasks/TasksCrud\");\n\nexport namespace TasksCrud {\n    export type Interface = ITasksContextObject;\n}\n"],"names":["TasksCrud","createAbstraction"],"mappings":";AAQO,MAAMA,YAAYC,kBAAuC"}

package/api/abstractions/Timer.d.ts

@@ -0,0 +1 @@
+export type { Timer } from "@webiny/utils/features/Timer/abstraction.js";

package/api/abstractions/index.d.ts

@@ -0,0 +1 @@
+export { Timer } from "./Timer.js";

package/api/abstractions/index.js

@@ -0,0 +1 @@
+export { Timer } from "./Timer.js";

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 { Container } from "@webiny/di";
+/**
+ * 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: (container: Container) => (rootId: string) => Promise<void>;

package/api/crud/cleanupTaskSubtree.js

@@ -0,0 +1,63 @@
+import { TasksCrud } from "../TasksCrud.js";
+const createCleanupTaskSubtree = (container)=>{
+    const listChildren = async (parentId)=>{
+        const { items } = await container.resolve(TasksCrud).listTasks({
+            where: {
+                parentId
+            }
+        });
+        return items;
+    };
+    const collectSubtree = async (rootId)=>{
+        const root = await container.resolve(TasksCrud).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 = container.resolve(TasksCrud).getDefinition(task.definitionId);
+        if (!definition || true !== definition.databaseLogs) return;
+        try {
+            const { items } = await container.resolve(TasksCrud).listLogs({
+                where: {
+                    task: task.id
+                }
+            });
+            for (const log of items)try {
+                await container.resolve(TasksCrud).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 container.resolve(TasksCrud).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 { Container } from \"@webiny/di\";\nimport type { ITask } from \"~/api/types.js\";\nimport { TasksCrud } from \"~/api/TasksCrud.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 = (container: Container) => {\n    const listChildren = async (parentId: string): Promise<ITask[]> => {\n        const { items } = await container.resolve(TasksCrud).listTasks({\n            where: { parentId }\n        });\n        return items;\n    };\n\n    const collectSubtree = async (rootId: string): Promise<ITask[]> => {\n        const root = await container.resolve(TasksCrud).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 = container.resolve(TasksCrud).getDefinition(task.definitionId);\n        if (!definition || definition.databaseLogs !== true) {\n            return;\n        }\n        try {\n            const { items } = await container.resolve(TasksCrud).listLogs({\n                where: { task: task.id }\n            });\n            for (const log of items) {\n                try {\n                    await container.resolve(TasksCrud).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 container.resolve(TasksCrud).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","container","listChildren","parentId","items","TasksCrud","collectSubtree","rootId","root","order","seen","Set","i","current","kids","kid","deleteTaskLogs","task","definition","log","ex","console","ordered"],"mappings":";AAUO,MAAMA,2BAA2B,CAACC;IACrC,MAAMC,eAAe,OAAOC;QACxB,MAAM,EAAEC,KAAK,EAAE,GAAG,MAAMH,UAAU,OAAO,CAACI,WAAW,SAAS,CAAC;YAC3D,OAAO;gBAAEF;YAAS;QACtB;QACA,OAAOC;IACX;IAEA,MAAME,iBAAiB,OAAOC;QAC1B,MAAMC,OAAO,MAAMP,UAAU,OAAO,CAACI,WAAW,OAAO,CAACE;QACxD,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,MAAMZ,aAAaW,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,aAAajB,UAAU,OAAO,CAACI,WAAW,aAAa,CAACY,KAAK,YAAY;QAC/E,IAAI,CAACC,cAAcA,AAA4B,SAA5BA,WAAW,YAAY,EACtC;QAEJ,IAAI;YACA,MAAM,EAAEd,KAAK,EAAE,GAAG,MAAMH,UAAU,OAAO,CAACI,WAAW,QAAQ,CAAC;gBAC1D,OAAO;oBAAE,MAAMY,KAAK,EAAE;gBAAC;YAC3B;YACA,KAAK,MAAME,OAAOf,MACd,IAAI;gBACA,MAAMH,UAAU,OAAO,CAACI,WAAW,SAAS,CAACc,IAAI,EAAE;YACvD,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,MAAMhB,UAAU,OAAO,CAACI,WAAW,UAAU,CAACY,KAAK,EAAE;YACzD,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,3 @@
+import type { Container } from "@webiny/di";
+import type { ITasksContextCrudObject } from "../../api/types.js";
+export declare const createTaskCrud: (container: Container) => ITasksContextCrudObject;