@webiny/background-tasks 0.0.0-unstable.7be00a75a9 → 0.0.0-unstable.9609e4e0c9

package/api/crud/TaskLogPrivateModel.js

@@ -0,0 +1,41 @@
+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",
+                lifecycleEvents: false
+            }).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                    lifecycleEvents: false\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;gBACN,iBAAiB;YACrB,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,56 @@
+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",
+                lifecycleEvents: false
+            }).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                    lifecycleEvents: false\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;gBACN,iBAAiB;YACrB,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/decorators/SelfCleaningTaskHandlerDecorator.d.ts

@@ -0,0 +1,33 @@
+import { TaskHandler } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { CleanupTaskSubtreeUseCase } from "../../api/features/CleanupTaskSubtree/index.js";
+type HookParams = TaskHandler.LifecycleHookParams;
+/**
+ * Deletes a finished task, and its descendants, for the events its definition asked for.
+ *
+ * Registered against `TaskHandler`, so it wraps every task's handler. Which task it is wrapping, and
+ * whether that task wants cleaning up, both come from `params.definition` rather than from anything
+ * captured at construction: one decorator instance serves whichever handler is resolved.
+ *
+ * The user's hook runs first and its failure is swallowed, so a task that throws on the way out is
+ * still cleaned up. That is what the previous single-object implementation did.
+ */
+export declare class SelfCleaningTaskHandlerDecoratorImpl implements TaskHandler.Interface {
+    private readonly cleanupTaskSubtree;
+    private readonly logger;
+    private readonly decoratee;
+    constructor(cleanupTaskSubtree: CleanupTaskSubtreeUseCase.Interface, logger: Logger.Interface, decoratee: TaskHandler.Interface);
+    get run(): (params: import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskRunParams<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput>) => Promise<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskResult<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput>>;
+    get onBeforeTrigger(): ((params: import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskBeforeTriggerParams<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskInput>) => Promise<void>) | undefined;
+    get onMaxIterations(): ((params: import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskLifecycleHook<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput>) => Promise<void>) | undefined;
+    get createInputValidation(): ((params: import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskCreateInputValidationParams) => import("@webiny/api/types").GenericRecord<PropertyKey, import("zod").Schema<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>> | import("zod").Schema<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>) | undefined;
+    get onDone(): (params: HookParams) => Promise<void>;
+    get onError(): (params: HookParams) => Promise<void>;
+    get onAbort(): (params: HookParams) => Promise<void>;
+    private cleanUpIfAsked;
+    private safeCall;
+}
+export declare const SelfCleaningTaskHandlerDecorator: typeof SelfCleaningTaskHandlerDecoratorImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskHandler<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput>>;
+};
+export {};

package/api/decorators/SelfCleaningTaskHandlerDecorator.js

@@ -0,0 +1,69 @@
+import { TaskHandler } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { normalizeSelfCleanup } from "../utils/normalizeSelfCleanup.js";
+import { CleanupTaskSubtreeUseCase } from "../features/CleanupTaskSubtree/index.js";
+import { getErrorProperties } from "../utils/getErrorProperties.js";
+class SelfCleaningTaskHandlerDecoratorImpl {
+    constructor(cleanupTaskSubtree, logger, decoratee){
+        this.cleanupTaskSubtree = cleanupTaskSubtree;
+        this.logger = logger;
+        this.decoratee = decoratee;
+    }
+    get run() {
+        return this.decoratee.run.bind(this.decoratee);
+    }
+    get onBeforeTrigger() {
+        return this.decoratee.onBeforeTrigger?.bind(this.decoratee);
+    }
+    get onMaxIterations() {
+        return this.decoratee.onMaxIterations?.bind(this.decoratee);
+    }
+    get createInputValidation() {
+        return this.decoratee.createInputValidation?.bind(this.decoratee);
+    }
+    get onDone() {
+        return async (params)=>{
+            await this.safeCall(this.decoratee.onDone, params, "onDone");
+            await this.cleanUpIfAsked(params, "onSuccess");
+        };
+    }
+    get onError() {
+        return async (params)=>{
+            await this.safeCall(this.decoratee.onError, params, "onError");
+            await this.cleanUpIfAsked(params, "onError");
+        };
+    }
+    get onAbort() {
+        return async (params)=>{
+            await this.safeCall(this.decoratee.onAbort, params, "onAbort");
+            await this.cleanUpIfAsked(params, "onAbort");
+        };
+    }
+    async cleanUpIfAsked(params, event) {
+        const events = normalizeSelfCleanup(params.definition.selfCleanup);
+        if (!events.has(event)) return;
+        await this.cleanupTaskSubtree.execute(params.task.id);
+    }
+    async safeCall(hook, params, name) {
+        if (!hook) return;
+        try {
+            await hook.call(this.decoratee, params);
+        } catch (ex) {
+            this.logger.error({
+                error: getErrorProperties(ex),
+                taskId: params.task.id,
+                hook: name
+            }, "Error executing task lifecycle hook.");
+        }
+    }
+}
+const SelfCleaningTaskHandlerDecorator = TaskHandler.createDecorator({
+    decorator: SelfCleaningTaskHandlerDecoratorImpl,
+    dependencies: [
+        CleanupTaskSubtreeUseCase,
+        Logger
+    ]
+});
+export { SelfCleaningTaskHandlerDecorator, SelfCleaningTaskHandlerDecoratorImpl };
+
+//# sourceMappingURL=SelfCleaningTaskHandlerDecorator.js.map

package/api/decorators/SelfCleaningTaskHandlerDecorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/decorators/SelfCleaningTaskHandlerDecorator.js","sources":["../../../src/api/decorators/SelfCleaningTaskHandlerDecorator.ts"],"sourcesContent":["import { TaskHandler } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { normalizeSelfCleanup } from \"~/api/utils/normalizeSelfCleanup.js\";\nimport { CleanupTaskSubtreeUseCase } from \"~/api/features/CleanupTaskSubtree/index.js\";\nimport { getErrorProperties } from \"~/api/utils/getErrorProperties.js\";\n\ntype HookParams = TaskHandler.LifecycleHookParams;\n\n/**\n * Deletes a finished task, and its descendants, for the events its definition asked for.\n *\n * Registered against `TaskHandler`, so it wraps every task's handler. Which task it is wrapping, and\n * whether that task wants cleaning up, both come from `params.definition` rather than from anything\n * captured at construction: one decorator instance serves whichever handler is resolved.\n *\n * The user's hook runs first and its failure is swallowed, so a task that throws on the way out is\n * still cleaned up. That is what the previous single-object implementation did.\n */\nexport class SelfCleaningTaskHandlerDecoratorImpl implements TaskHandler.Interface {\n    public constructor(\n        private readonly cleanupTaskSubtree: CleanupTaskSubtreeUseCase.Interface,\n        private readonly logger: Logger.Interface,\n        private readonly decoratee: TaskHandler.Interface\n    ) {}\n\n    get run() {\n        return this.decoratee.run.bind(this.decoratee);\n    }\n\n    get onBeforeTrigger() {\n        return this.decoratee.onBeforeTrigger?.bind(this.decoratee);\n    }\n\n    get onMaxIterations() {\n        return this.decoratee.onMaxIterations?.bind(this.decoratee);\n    }\n\n    get createInputValidation() {\n        return this.decoratee.createInputValidation?.bind(this.decoratee);\n    }\n\n    get onDone() {\n        return async (params: HookParams) => {\n            await this.safeCall(this.decoratee.onDone, params, \"onDone\");\n            await this.cleanUpIfAsked(params, \"onSuccess\");\n        };\n    }\n\n    get onError() {\n        return async (params: HookParams) => {\n            await this.safeCall(this.decoratee.onError, params, \"onError\");\n            await this.cleanUpIfAsked(params, \"onError\");\n        };\n    }\n\n    get onAbort() {\n        return async (params: HookParams) => {\n            await this.safeCall(this.decoratee.onAbort, params, \"onAbort\");\n            await this.cleanUpIfAsked(params, \"onAbort\");\n        };\n    }\n\n    private async cleanUpIfAsked(\n        params: HookParams,\n        event: \"onSuccess\" | \"onError\" | \"onAbort\"\n    ): Promise<void> {\n        const events = normalizeSelfCleanup(params.definition.selfCleanup);\n        if (!events.has(event)) {\n            return;\n        }\n\n        await this.cleanupTaskSubtree.execute(params.task.id);\n    }\n\n    private async safeCall(\n        hook: TaskHandler.Interface[\"onDone\"],\n        params: HookParams,\n        name: string\n    ): Promise<void> {\n        if (!hook) {\n            return;\n        }\n\n        try {\n            await hook.call(this.decoratee, params);\n        } catch (ex) {\n            this.logger.error(\n                { error: getErrorProperties(ex), taskId: params.task.id, hook: name },\n                \"Error executing task lifecycle hook.\"\n            );\n        }\n    }\n}\n\nexport const SelfCleaningTaskHandlerDecorator = TaskHandler.createDecorator({\n    decorator: SelfCleaningTaskHandlerDecoratorImpl,\n    dependencies: [CleanupTaskSubtreeUseCase, Logger]\n});\n"],"names":["SelfCleaningTaskHandlerDecoratorImpl","cleanupTaskSubtree","logger","decoratee","params","event","events","normalizeSelfCleanup","hook","name","ex","getErrorProperties","SelfCleaningTaskHandlerDecorator","TaskHandler","CleanupTaskSubtreeUseCase","Logger"],"mappings":";;;;;AAkBO,MAAMA;IACT,YACqBC,kBAAuD,EACvDC,MAAwB,EACxBC,SAAgC,CACnD;aAHmBF,kBAAkB,GAAlBA;aACAC,MAAM,GAANA;aACAC,SAAS,GAATA;IAClB;IAEH,IAAI,MAAM;QACN,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS;IACjD;IAEA,IAAI,kBAAkB;QAClB,OAAO,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,KAAK,IAAI,CAAC,SAAS;IAC9D;IAEA,IAAI,kBAAkB;QAClB,OAAO,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,KAAK,IAAI,CAAC,SAAS;IAC9D;IAEA,IAAI,wBAAwB;QACxB,OAAO,IAAI,CAAC,SAAS,CAAC,qBAAqB,EAAE,KAAK,IAAI,CAAC,SAAS;IACpE;IAEA,IAAI,SAAS;QACT,OAAO,OAAOC;YACV,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,EAAEA,QAAQ;YACnD,MAAM,IAAI,CAAC,cAAc,CAACA,QAAQ;QACtC;IACJ;IAEA,IAAI,UAAU;QACV,OAAO,OAAOA;YACV,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,EAAEA,QAAQ;YACpD,MAAM,IAAI,CAAC,cAAc,CAACA,QAAQ;QACtC;IACJ;IAEA,IAAI,UAAU;QACV,OAAO,OAAOA;YACV,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,EAAEA,QAAQ;YACpD,MAAM,IAAI,CAAC,cAAc,CAACA,QAAQ;QACtC;IACJ;IAEA,MAAc,eACVA,MAAkB,EAClBC,KAA0C,EAC7B;QACb,MAAMC,SAASC,qBAAqBH,OAAO,UAAU,CAAC,WAAW;QACjE,IAAI,CAACE,OAAO,GAAG,CAACD,QACZ;QAGJ,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAACD,OAAO,IAAI,CAAC,EAAE;IACxD;IAEA,MAAc,SACVI,IAAqC,EACrCJ,MAAkB,EAClBK,IAAY,EACC;QACb,IAAI,CAACD,MACD;QAGJ,IAAI;YACA,MAAMA,KAAK,IAAI,CAAC,IAAI,CAAC,SAAS,EAAEJ;QACpC,EAAE,OAAOM,IAAI;YACT,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;gBAAE,OAAOC,mBAAmBD;gBAAK,QAAQN,OAAO,IAAI,CAAC,EAAE;gBAAE,MAAMK;YAAK,GACpE;QAER;IACJ;AACJ;AAEO,MAAMG,mCAAmCC,YAAY,eAAe,CAAC;IACxE,WAAWb;IACX,cAAc;QAACc;QAA2BC;KAAO;AACrD"}

package/api/decorators/TaskDefinitionDefaultsDecorator.d.ts

@@ -0,0 +1,27 @@
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+/**
+ * Fills in the defaults a definition is allowed to leave out, applies the one rule that overrides
+ * what a definition asked for (self-cleanup forces `databaseLogs` off), and rejects an id that is
+ * not camelCase.
+ *
+ * Everything here is metadata. A definition carries no behaviour, so there is nothing to forward:
+ * `GetRunnableTaskDefinitionUseCase` takes `run` and the hooks from the handler that `handler` names, after
+ * this decorator has run.
+ */
+export declare class TaskDefinitionDefaultsDecoratorImpl implements TaskDefinition.Interface {
+    private decoratee;
+    private readonly cleansUp;
+    constructor(decoratee: TaskDefinition.Interface);
+    get id(): string;
+    get title(): string;
+    get description(): string | undefined;
+    get handler(): import("@webiny/di").Constructor<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskHandler<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput>>;
+    get isPrivate(): boolean;
+    get databaseLogs(): boolean;
+    get maxIterations(): number;
+    get selfCleanup(): import("@webiny/api-core/features/task/TaskDefinition/abstractions").ISelfCleanup | undefined;
+    private validate;
+}
+export declare const TaskDefinitionDefaultsDecorator: typeof TaskDefinitionDefaultsDecoratorImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskDefinition<import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskOutput>>;
+};

package/api/decorators/TaskDefinitionDefaultsDecorator.js

@@ -0,0 +1,47 @@
+import camelCase from "lodash/camelCase.js";
+import error from "@webiny/error";
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { normalizeSelfCleanup } from "../utils/normalizeSelfCleanup.js";
+const DEFAULT_MAX_ITERATIONS = 50;
+class TaskDefinitionDefaultsDecoratorImpl {
+    constructor(decoratee){
+        this.decoratee = decoratee;
+        this.validate();
+        this.cleansUp = normalizeSelfCleanup(decoratee.selfCleanup).size > 0;
+    }
+    get id() {
+        return this.decoratee.id;
+    }
+    get title() {
+        return this.decoratee.title;
+    }
+    get description() {
+        return this.decoratee.description;
+    }
+    get handler() {
+        return this.decoratee.handler;
+    }
+    get isPrivate() {
+        return this.decoratee.isPrivate || false;
+    }
+    get databaseLogs() {
+        if (this.cleansUp) return false;
+        return this.decoratee.databaseLogs || false;
+    }
+    get maxIterations() {
+        return this.decoratee.maxIterations || DEFAULT_MAX_ITERATIONS;
+    }
+    get selfCleanup() {
+        return this.decoratee.selfCleanup;
+    }
+    validate() {
+        if (camelCase(this.decoratee.id) !== this.decoratee.id) throw new error(`Task ID "${this.decoratee.id}" is invalid. It must be in camelCase format, for example: "myCustomTask".`);
+    }
+}
+const TaskDefinitionDefaultsDecorator = TaskDefinition.createDecorator({
+    decorator: TaskDefinitionDefaultsDecoratorImpl,
+    dependencies: []
+});
+export { TaskDefinitionDefaultsDecorator, TaskDefinitionDefaultsDecoratorImpl };
+
+//# sourceMappingURL=TaskDefinitionDefaultsDecorator.js.map

package/api/decorators/TaskDefinitionDefaultsDecorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/decorators/TaskDefinitionDefaultsDecorator.js","sources":["../../../src/api/decorators/TaskDefinitionDefaultsDecorator.ts"],"sourcesContent":["import camelCase from \"lodash/camelCase.js\";\nimport WebinyError from \"@webiny/error\";\nimport { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { normalizeSelfCleanup } from \"~/api/utils/normalizeSelfCleanup.js\";\n\nconst DEFAULT_MAX_ITERATIONS = 50;\n\n/**\n * Fills in the defaults a definition is allowed to leave out, applies the one rule that overrides\n * what a definition asked for (self-cleanup forces `databaseLogs` off), and rejects an id that is\n * not camelCase.\n *\n * Everything here is metadata. A definition carries no behaviour, so there is nothing to forward:\n * `GetRunnableTaskDefinitionUseCase` takes `run` and the hooks from the handler that `handler` names, after\n * this decorator has run.\n */\nexport class TaskDefinitionDefaultsDecoratorImpl implements TaskDefinition.Interface {\n    private readonly cleansUp: boolean;\n\n    constructor(private decoratee: TaskDefinition.Interface) {\n        this.validate();\n        this.cleansUp = normalizeSelfCleanup(decoratee.selfCleanup).size > 0;\n    }\n\n    get id() {\n        return this.decoratee.id;\n    }\n\n    get title() {\n        return this.decoratee.title;\n    }\n\n    get description() {\n        return this.decoratee.description;\n    }\n\n    get handler() {\n        return this.decoratee.handler;\n    }\n\n    // The three defaults.\n    get isPrivate() {\n        return this.decoratee.isPrivate || false;\n    }\n\n    get databaseLogs() {\n        // A task that deletes itself on the way out has nowhere to keep logs, so asking for any\n        // cleanup event overrides the task's own choice.\n        if (this.cleansUp) {\n            return false;\n        }\n        return this.decoratee.databaseLogs || false;\n    }\n\n    get maxIterations() {\n        return this.decoratee.maxIterations || DEFAULT_MAX_ITERATIONS;\n    }\n\n    get selfCleanup() {\n        return this.decoratee.selfCleanup;\n    }\n\n    private validate(): void {\n        if (camelCase(this.decoratee.id) !== this.decoratee.id) {\n            throw new WebinyError(\n                `Task ID \"${this.decoratee.id}\" is invalid. It must be in camelCase format, for example: \"myCustomTask\".`\n            );\n        }\n    }\n}\n\nexport const TaskDefinitionDefaultsDecorator = TaskDefinition.createDecorator({\n    decorator: TaskDefinitionDefaultsDecoratorImpl,\n    dependencies: []\n});\n"],"names":["DEFAULT_MAX_ITERATIONS","TaskDefinitionDefaultsDecoratorImpl","decoratee","normalizeSelfCleanup","camelCase","WebinyError","TaskDefinitionDefaultsDecorator","TaskDefinition"],"mappings":";;;;AAKA,MAAMA,yBAAyB;AAWxB,MAAMC;IAGT,YAAoBC,SAAmC,CAAE;aAArCA,SAAS,GAATA;QAChB,IAAI,CAAC,QAAQ;QACb,IAAI,CAAC,QAAQ,GAAGC,qBAAqBD,UAAU,WAAW,EAAE,IAAI,GAAG;IACvE;IAEA,IAAI,KAAK;QACL,OAAO,IAAI,CAAC,SAAS,CAAC,EAAE;IAC5B;IAEA,IAAI,QAAQ;QACR,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK;IAC/B;IAEA,IAAI,cAAc;QACd,OAAO,IAAI,CAAC,SAAS,CAAC,WAAW;IACrC;IAEA,IAAI,UAAU;QACV,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO;IACjC;IAGA,IAAI,YAAY;QACZ,OAAO,IAAI,CAAC,SAAS,CAAC,SAAS,IAAI;IACvC;IAEA,IAAI,eAAe;QAGf,IAAI,IAAI,CAAC,QAAQ,EACb,OAAO;QAEX,OAAO,IAAI,CAAC,SAAS,CAAC,YAAY,IAAI;IAC1C;IAEA,IAAI,gBAAgB;QAChB,OAAO,IAAI,CAAC,SAAS,CAAC,aAAa,IAAIF;IAC3C;IAEA,IAAI,cAAc;QACd,OAAO,IAAI,CAAC,SAAS,CAAC,WAAW;IACrC;IAEQ,WAAiB;QACrB,IAAII,UAAU,IAAI,CAAC,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC,SAAS,CAAC,EAAE,EAClD,MAAM,IAAIC,MACN,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,0EAA0E,CAAC;IAGrH;AACJ;AAEO,MAAMC,kCAAkCC,eAAe,eAAe,CAAC;IAC1E,WAAWN;IACX,cAAc,EAAE;AACpB"}

package/api/domain/BackgroundTaskSettings.d.ts

@@ -0,0 +1,3 @@
+export interface IBackgroundTaskSettings {
+    retentionDays: number | undefined;
+}

package/api/domain/TaskService.d.ts

@@ -0,0 +1,12 @@
+import type { ITask } from "../../api/types.js";
+export type ITaskServiceTask = Pick<ITask, "id" | "definitionId">;
+export interface ITaskService {
+    send(task: ITaskServiceTask, delay: number): Promise<unknown | null>;
+    fetch(task: ITask): Promise<unknown | null>;
+}
+export declare const TaskService: import("@webiny/di").Abstraction<ITaskService>;
+export declare namespace TaskService {
+    type Interface = ITaskService;
+    type SendTaskParams = ITaskServiceTask;
+    type Task = ITask;
+}

package/api/domain/TaskService.js

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

package/api/domain/TaskService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/TaskService.js","sources":["../../../src/api/domain/TaskService.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { ITask } from \"~/api/types.js\";\n\nexport type ITaskServiceTask = Pick<ITask, \"id\" | \"definitionId\">;\n\nexport interface ITaskService {\n    send(task: ITaskServiceTask, delay: number): Promise<unknown | null>;\n    fetch(task: ITask): Promise<unknown | null>;\n}\n\nexport const TaskService = createAbstraction<ITaskService>(\"BackgroundTasks/TaskService\");\n\nexport namespace TaskService {\n    export type Interface = ITaskService;\n    export type SendTaskParams = ITaskServiceTask;\n    export type Task = ITask;\n}\n"],"names":["TaskService","createAbstraction"],"mappings":";AAUO,MAAMA,cAAcC,kBAAgC"}

package/api/domain/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const BACKGROUND_TASK_SETTINGS_MODEL_ID = "backgroundTaskSettings";
+export declare const BACKGROUND_TASK_MAX_RETENTION_DAYS = 3650;
+export declare const BACKGROUND_TASK_DEFAULT_RETENTION_DAYS = 90;

package/api/domain/constants.js

@@ -0,0 +1,6 @@
+const BACKGROUND_TASK_SETTINGS_MODEL_ID = "backgroundTaskSettings";
+const BACKGROUND_TASK_MAX_RETENTION_DAYS = 3650;
+const BACKGROUND_TASK_DEFAULT_RETENTION_DAYS = 90;
+export { BACKGROUND_TASK_DEFAULT_RETENTION_DAYS, BACKGROUND_TASK_MAX_RETENTION_DAYS, BACKGROUND_TASK_SETTINGS_MODEL_ID };
+
+//# sourceMappingURL=constants.js.map

package/api/domain/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/constants.js","sources":["../../../src/api/domain/constants.ts"],"sourcesContent":["export const BACKGROUND_TASK_SETTINGS_MODEL_ID = \"backgroundTaskSettings\";\nexport const BACKGROUND_TASK_MAX_RETENTION_DAYS = 3650;\nexport const BACKGROUND_TASK_DEFAULT_RETENTION_DAYS = 90;\n"],"names":["BACKGROUND_TASK_SETTINGS_MODEL_ID","BACKGROUND_TASK_MAX_RETENTION_DAYS","BACKGROUND_TASK_DEFAULT_RETENTION_DAYS"],"mappings":"AAAO,MAAMA,oCAAoC;AAC1C,MAAMC,qCAAqC;AAC3C,MAAMC,yCAAyC"}

package/api/domain/errors.d.ts

@@ -0,0 +1,61 @@
+import { BaseError } from "@webiny/feature/api";
+import type { ZodError } from "zod";
+import type { ValidationIssue } from "@webiny/utils";
+export declare class TaskDefinitionNotFoundError extends BaseError<{
+    id: string;
+}> {
+    readonly code: "BackgroundTasks/TaskDefinition/NotFoundError";
+    constructor(id: string);
+}
+export declare class TaskNotFoundError extends BaseError {
+    readonly code: "BackgroundTasks/Task/NotFoundError";
+    constructor();
+}
+export declare class TaskAbortError extends BaseError<{
+    id: string;
+    status: string;
+}> {
+    readonly code: "BackgroundTasks/Task/Abort";
+    constructor(data: {
+        id: string;
+        status: string;
+    });
+}
+export declare class TaskLogNotFoundError extends BaseError {
+    readonly code: "BackgroundTasks/Log/NotFoundError";
+    constructor();
+}
+export declare class TaskServiceInfoError extends BaseError {
+    readonly code: "BackgroundTasks/Service/InfoUnavailable";
+    constructor();
+}
+interface BackgroundTaskValidationErrorData {
+    issues: ValidationIssue[];
+}
+export declare class BackgroundTaskValidationError extends BaseError<BackgroundTaskValidationErrorData> {
+    readonly code: "BackgroundTasks/ValidationError";
+    constructor(error: string | ZodError);
+}
+interface BackgroundTaskPersistenceErrorData {
+    originalMessage: string;
+    originalCode?: string;
+    originalData?: unknown;
+}
+export declare class BackgroundTaskPersistenceError extends BaseError<BackgroundTaskPersistenceErrorData> {
+    readonly code: "BackgroundTasks/PersistenceError";
+    constructor(error: Error);
+    static from(error: unknown): BackgroundTaskPersistenceError;
+}
+export declare class BackgroundTaskModelNotFoundError extends BaseError {
+    readonly code: "BackgroundTasks/ModelNotFound";
+    constructor(modelId: string);
+}
+export declare class BackgroundTaskNotAuthorizedError extends BaseError {
+    readonly code: "BackgroundTasks/NotAuthorized";
+    constructor();
+}
+export declare class TaskInputValidationError extends BaseError<Record<string, any>> {
+    readonly code: "VALIDATION_FAILED_INVALID_FIELDS";
+    constructor(error: ZodError);
+}
+export {};

package/api/domain/errors.js

@@ -0,0 +1,109 @@
+import { BaseError } from "@webiny/feature/api";
+import { createZodError, parseZodError } from "@webiny/utils";
+class TaskDefinitionNotFoundError extends BaseError {
+    constructor(id){
+        super({
+            message: "Task definition not found.",
+            data: {
+                id
+            }
+        }), this.code = "BackgroundTasks/TaskDefinition/NotFoundError";
+    }
+}
+class TaskNotFoundError extends BaseError {
+    constructor(){
+        super({
+            message: "Task not found."
+        }), this.code = "BackgroundTasks/Task/NotFoundError";
+    }
+}
+class TaskAbortError extends BaseError {
+    constructor(data){
+        super({
+            message: "Cannot abort a task that is not pending or running!",
+            data
+        }), this.code = "BackgroundTasks/Task/Abort";
+    }
+}
+class TaskLogNotFoundError extends BaseError {
+    constructor(){
+        super({
+            message: "Task log not found."
+        }), this.code = "BackgroundTasks/Log/NotFoundError";
+    }
+}
+class TaskServiceInfoError extends BaseError {
+    constructor(){
+        super({
+            message: "Unable to fetch service info."
+        }), this.code = "BackgroundTasks/Service/InfoUnavailable";
+    }
+}
+class BackgroundTaskValidationError extends BaseError {
+    constructor(error){
+        if ("string" == typeof error) super({
+            message: error,
+            data: {
+                issues: []
+            }
+        }), this.code = "BackgroundTasks/ValidationError";
+        else {
+            const issues = parseZodError(error);
+            super({
+                message: "Validation failed.",
+                data: {
+                    issues
+                }
+            }), this.code = "BackgroundTasks/ValidationError";
+        }
+    }
+}
+class BackgroundTaskPersistenceError extends BaseError {
+    constructor(error){
+        super({
+            message: error.message,
+            data: {
+                originalMessage: error.message
+            }
+        }), this.code = "BackgroundTasks/PersistenceError";
+    }
+    static from(error) {
+        if (error instanceof Error) {
+            const instance = new BackgroundTaskPersistenceError(error);
+            const data = {
+                originalMessage: error.message,
+                originalCode: error.code,
+                originalData: error.data
+            };
+            instance.data = data;
+            instance.stack = error.stack;
+            return instance;
+        }
+        return new BackgroundTaskPersistenceError(new Error(String(error)));
+    }
+}
+class BackgroundTaskModelNotFoundError extends BaseError {
+    constructor(modelId){
+        super({
+            message: `Background task model "${modelId}" was not found.`
+        }), this.code = "BackgroundTasks/ModelNotFound";
+    }
+}
+class BackgroundTaskNotAuthorizedError extends BaseError {
+    constructor(){
+        super({
+            message: "Not authorized!"
+        }), this.code = "BackgroundTasks/NotAuthorized";
+    }
+}
+class TaskInputValidationError extends BaseError {
+    constructor(error){
+        super({
+            message: "Validation failed.",
+            data: createZodError(error).data ?? {}
+        }), this.code = "VALIDATION_FAILED_INVALID_FIELDS";
+    }
+}
+export { BackgroundTaskModelNotFoundError, BackgroundTaskNotAuthorizedError, BackgroundTaskPersistenceError, BackgroundTaskValidationError, TaskAbortError, TaskDefinitionNotFoundError, TaskInputValidationError, TaskLogNotFoundError, TaskNotFoundError, TaskServiceInfoError };
+
+//# sourceMappingURL=errors.js.map

package/api/domain/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/errors.js","sources":["../../../src/api/domain/errors.ts"],"sourcesContent":["import { BaseError } from \"@webiny/feature/api\";\nimport type { ZodError } from \"zod\";\nimport { createZodError, parseZodError } from \"@webiny/utils\";\nimport type { ValidationIssue } from \"@webiny/utils\";\n\nexport class TaskDefinitionNotFoundError extends BaseError<{ id: string }> {\n    override readonly code = \"BackgroundTasks/TaskDefinition/NotFoundError\" as const;\n\n    constructor(id: string) {\n        super({\n            message: \"Task definition not found.\",\n            data: {\n                id\n            }\n        });\n    }\n}\n\nexport class TaskNotFoundError extends BaseError {\n    override readonly code = \"BackgroundTasks/Task/NotFoundError\" as const;\n\n    constructor() {\n        super({\n            message: \"Task not found.\"\n        });\n    }\n}\n\nexport class TaskAbortError extends BaseError<{ id: string; status: string }> {\n    override readonly code = \"BackgroundTasks/Task/Abort\" as const;\n\n    constructor(data: { id: string; status: string }) {\n        super({\n            message: \"Cannot abort a task that is not pending or running!\",\n            data\n        });\n    }\n}\n\nexport class TaskLogNotFoundError extends BaseError {\n    override readonly code = \"BackgroundTasks/Log/NotFoundError\" as const;\n\n    constructor() {\n        super({\n            message: \"Task log not found.\"\n        });\n    }\n}\n\nexport class TaskServiceInfoError extends BaseError {\n    override readonly code = \"BackgroundTasks/Service/InfoUnavailable\" as const;\n\n    constructor() {\n        super({\n            message: \"Unable to fetch service info.\"\n        });\n    }\n}\n\ninterface BackgroundTaskValidationErrorData {\n    issues: ValidationIssue[];\n}\n\nexport class BackgroundTaskValidationError extends BaseError<BackgroundTaskValidationErrorData> {\n    override readonly code = \"BackgroundTasks/ValidationError\" as const;\n\n    constructor(error: string | ZodError) {\n        if (typeof error === \"string\") {\n            super({ message: error, data: { issues: [] } });\n        } else {\n            const issues = parseZodError(error);\n            super({ message: \"Validation failed.\", data: { issues } });\n        }\n    }\n}\n\ninterface BackgroundTaskPersistenceErrorData {\n    originalMessage: string;\n    originalCode?: string;\n    originalData?: unknown;\n}\n\nexport class BackgroundTaskPersistenceError extends BaseError<BackgroundTaskPersistenceErrorData> {\n    override readonly code = \"BackgroundTasks/PersistenceError\" as const;\n\n    constructor(error: Error) {\n        super({ message: error.message, data: { originalMessage: error.message } });\n    }\n\n    static from(error: unknown): BackgroundTaskPersistenceError {\n        if (error instanceof Error) {\n            const instance = new BackgroundTaskPersistenceError(error);\n            const data: BackgroundTaskPersistenceErrorData = {\n                originalMessage: error.message,\n                originalCode: (error as any).code,\n                originalData: (error as any).data\n            };\n            (instance as any).data = data;\n            instance.stack = error.stack;\n            return instance;\n        }\n\n        return new BackgroundTaskPersistenceError(new Error(String(error)));\n    }\n}\n\nexport class BackgroundTaskModelNotFoundError extends BaseError {\n    override readonly code = \"BackgroundTasks/ModelNotFound\" as const;\n\n    constructor(modelId: string) {\n        super({ message: `Background task model \"${modelId}\" was not found.` });\n    }\n}\n\nexport class BackgroundTaskNotAuthorizedError extends BaseError {\n    override readonly code = \"BackgroundTasks/NotAuthorized\" as const;\n\n    constructor() {\n        super({ message: \"Not authorized!\" });\n    }\n}\n\n/*\n * Keeps the code, message and `invalidFields` data that `createZodError` produced before task input\n * validation moved into a use case, so clients that read them see no difference.\n */\nexport class TaskInputValidationError extends BaseError<Record<string, any>> {\n    override readonly code = \"VALIDATION_FAILED_INVALID_FIELDS\" as const;\n\n    constructor(error: ZodError) {\n        super({\n            message: \"Validation failed.\",\n            data: createZodError(error).data ?? {}\n        });\n    }\n}\n"],"names":["TaskDefinitionNotFoundError","BaseError","id","TaskNotFoundError","TaskAbortError","data","TaskLogNotFoundError","TaskServiceInfoError","BackgroundTaskValidationError","error","issues","parseZodError","BackgroundTaskPersistenceError","Error","instance","String","BackgroundTaskModelNotFoundError","modelId","BackgroundTaskNotAuthorizedError","TaskInputValidationError","createZodError"],"mappings":";;AAKO,MAAMA,oCAAoCC;IAG7C,YAAYC,EAAU,CAAE;QACpB,KAAK,CAAC;YACF,SAAS;YACT,MAAM;gBACFA;YACJ;QACJ,SARc,IAAI,GAAG;IASzB;AACJ;AAEO,MAAMC,0BAA0BF;IAGnC,aAAc;QACV,KAAK,CAAC;YACF,SAAS;QACb,SALc,IAAI,GAAG;IAMzB;AACJ;AAEO,MAAMG,uBAAuBH;IAGhC,YAAYI,IAAoC,CAAE;QAC9C,KAAK,CAAC;YACF,SAAS;YACTA;QACJ,SANc,IAAI,GAAG;IAOzB;AACJ;AAEO,MAAMC,6BAA6BL;IAGtC,aAAc;QACV,KAAK,CAAC;YACF,SAAS;QACb,SALc,IAAI,GAAG;IAMzB;AACJ;AAEO,MAAMM,6BAA6BN;IAGtC,aAAc;QACV,KAAK,CAAC;YACF,SAAS;QACb,SALc,IAAI,GAAG;IAMzB;AACJ;AAMO,MAAMO,sCAAsCP;IAG/C,YAAYQ,KAAwB,CAAE;QAClC,IAAI,AAAiB,YAAjB,OAAOA,OACP,KAAK,CAAC;YAAE,SAASA;YAAO,MAAM;gBAAE,QAAQ,EAAE;YAAC;QAAE,SAJnC,IAAI,GAAG;aAKd;YACH,MAAMC,SAASC,cAAcF;YAC7B,KAAK,CAAC;gBAAE,SAAS;gBAAsB,MAAM;oBAAEC;gBAAO;YAAE,SAP9C,IAAI,GAAG;QAQrB;IACJ;AACJ;AAQO,MAAME,uCAAuCX;IAGhD,YAAYQ,KAAY,CAAE;QACtB,KAAK,CAAC;YAAE,SAASA,MAAM,OAAO;YAAE,MAAM;gBAAE,iBAAiBA,MAAM,OAAO;YAAC;QAAE,SAH3D,IAAI,GAAG;IAIzB;IAEA,OAAO,KAAKA,KAAc,EAAkC;QACxD,IAAIA,iBAAiBI,OAAO;YACxB,MAAMC,WAAW,IAAIF,+BAA+BH;YACpD,MAAMJ,OAA2C;gBAC7C,iBAAiBI,MAAM,OAAO;gBAC9B,cAAeA,MAAc,IAAI;gBACjC,cAAeA,MAAc,IAAI;YACrC;YACCK,SAAiB,IAAI,GAAGT;YACzBS,SAAS,KAAK,GAAGL,MAAM,KAAK;YAC5B,OAAOK;QACX;QAEA,OAAO,IAAIF,+BAA+B,IAAIC,MAAME,OAAON;IAC/D;AACJ;AAEO,MAAMO,yCAAyCf;IAGlD,YAAYgB,OAAe,CAAE;QACzB,KAAK,CAAC;YAAE,SAAS,CAAC,uBAAuB,EAAEA,QAAQ,gBAAgB,CAAC;QAAC,SAHvD,IAAI,GAAG;IAIzB;AACJ;AAEO,MAAMC,yCAAyCjB;IAGlD,aAAc;QACV,KAAK,CAAC;YAAE,SAAS;QAAkB,SAHrB,IAAI,GAAG;IAIzB;AACJ;AAMO,MAAMkB,iCAAiClB;IAG1C,YAAYQ,KAAe,CAAE;QACzB,KAAK,CAAC;YACF,SAAS;YACT,MAAMW,eAAeX,OAAO,IAAI,IAAI,CAAC;QACzC,SANc,IAAI,GAAG;IAOzB;AACJ"}

package/api/domain/task/TaskLogModelProvider.d.ts

@@ -0,0 +1,12 @@
+import type { CmsModel } from "@webiny/api-headless-cms/types/index.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { TaskLogModelProvider as Abstraction } from "./abstractions.js";
+declare class TaskLogModelProviderImpl implements Abstraction.Interface {
+    private readonly getModel;
+    constructor(getModel: GetModelUseCase.Interface);
+    get(): Promise<CmsModel>;
+}
+export declare const TaskLogModelProvider: typeof TaskLogModelProviderImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ITaskLogModelProvider>;
+};
+export {};

package/api/domain/task/TaskLogModelProvider.js

@@ -0,0 +1,23 @@
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { TaskLogModelProvider } from "./abstractions.js";
+import { BackgroundTaskModelNotFoundError } from "../errors.js";
+import { WEBINY_TASK_LOG_MODEL_ID } from "../../crud/TaskLogPrivateModel.js";
+class TaskLogModelProviderImpl {
+    constructor(getModel){
+        this.getModel = getModel;
+    }
+    async get() {
+        const result = await this.getModel.execute(WEBINY_TASK_LOG_MODEL_ID);
+        if (result.isFail()) throw new BackgroundTaskModelNotFoundError(WEBINY_TASK_LOG_MODEL_ID);
+        return result.value;
+    }
+}
+const TaskLogModelProvider_TaskLogModelProvider = TaskLogModelProvider.createImplementation({
+    implementation: TaskLogModelProviderImpl,
+    dependencies: [
+        GetModelUseCase
+    ]
+});
+export { TaskLogModelProvider_TaskLogModelProvider as TaskLogModelProvider };
+
+//# sourceMappingURL=TaskLogModelProvider.js.map

package/api/domain/task/TaskLogModelProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/task/TaskLogModelProvider.js","sources":["../../../../src/api/domain/task/TaskLogModelProvider.ts"],"sourcesContent":["import type { CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\nimport { TaskLogModelProvider as Abstraction } from \"./abstractions.js\";\nimport { BackgroundTaskModelNotFoundError } from \"~/api/domain/errors.js\";\nimport { WEBINY_TASK_LOG_MODEL_ID } from \"~/api/crud/TaskLogPrivateModel.js\";\n\nclass TaskLogModelProviderImpl implements Abstraction.Interface {\n    constructor(private readonly getModel: GetModelUseCase.Interface) {}\n\n    async get(): Promise<CmsModel> {\n        const result = await this.getModel.execute(WEBINY_TASK_LOG_MODEL_ID);\n        if (result.isFail()) {\n            throw new BackgroundTaskModelNotFoundError(WEBINY_TASK_LOG_MODEL_ID);\n        }\n        return result.value;\n    }\n}\n\nexport const TaskLogModelProvider = Abstraction.createImplementation({\n    implementation: TaskLogModelProviderImpl,\n    dependencies: [GetModelUseCase]\n});\n"],"names":["TaskLogModelProviderImpl","getModel","result","WEBINY_TASK_LOG_MODEL_ID","BackgroundTaskModelNotFoundError","TaskLogModelProvider","Abstraction","GetModelUseCase"],"mappings":";;;;AAMA,MAAMA;IACF,YAA6BC,QAAmC,CAAE;aAArCA,QAAQ,GAARA;IAAsC;IAEnE,MAAM,MAAyB;QAC3B,MAAMC,SAAS,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAACC;QAC3C,IAAID,OAAO,MAAM,IACb,MAAM,IAAIE,iCAAiCD;QAE/C,OAAOD,OAAO,KAAK;IACvB;AACJ;AAEO,MAAMG,4CAAuBC,qBAAAA,oBAAgC,CAAC;IACjE,gBAAgBN;IAChB,cAAc;QAACO;KAAgB;AACnC"}