@webiny/background-tasks 0.0.0-unstable.a4f3e4ea8b → 0.0.0-unstable.eb81deee7e

package/api/decorators/{SelfCleaningTaskDecorator.d.ts → SelfCleaningTaskHandlerDecorator.d.ts}

@@ -1,30 +1,33 @@
-import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+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 LifecycleHook = TaskDefinition.Interface["onDone"];
-type HookParams = Parameters<NonNullable<LifecycleHook>>[0];
-export declare class SelfCleaningTaskDecoratorImpl implements TaskDefinition.Interface {
+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 decoratee;
-    private readonly events;
-    constructor(cleanupTaskSubtree: CleanupTaskSubtreeUseCase.Interface, decoratee: TaskDefinition.Interface);
-    get id(): string;
-    get title(): string;
-    get description(): string | undefined;
-    get isPrivate(): boolean | undefined;
-    get maxIterations(): number | undefined;
-    get selfCleanup(): import("@webiny/api-core/features/task/TaskDefinition/abstractions").ISelfCleanup | undefined;
-    get createInputValidation(): ((params: import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskCreateInputValidationParams) => import("@webiny/api/types").GenericRecord<PropertyKey, import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>> | import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>) | undefined;
+    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 databaseLogs(): boolean | undefined;
+    get createInputValidation(): ((params: import("@webiny/api-core/features/task/TaskDefinition/abstractions").ITaskCreateInputValidationParams) => import("@webiny/api/types").GenericRecord<PropertyKey, import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>> | import("zod").ZodType<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 runCleanup;
+    private cleanUpIfAsked;
     private safeCall;
 }
-export declare const SelfCleaningTaskDecorator: typeof SelfCleaningTaskDecoratorImpl & {
-    __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>>;
+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/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/features/AbortTask/AbortTaskUseCase.d.ts

@@ -2,9 +2,8 @@ import { Result } from "@webiny/feature/api";
 import { AbortTaskUseCase as UseCaseAbstraction } from "./abstractions.js";
 import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
 import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
-import type { Context } from "../../../api/types.js";
 export declare class AbortTaskUseCaseImpl implements UseCaseAbstraction.Interface {
-    private context;
-    constructor(context: Context);
+    private taskService;
+    constructor(taskService: TaskService.Interface);
     execute<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends TaskService.GenericOutput = TaskService.GenericOutput>(params: UseCaseAbstraction.Params): Promise<Result<TaskService.Task<I, O>, UseCaseAbstraction.Error>>;
 }

package/api/features/AbortTask/AbortTaskUseCase.js

@@ -1,9 +1,9 @@
 class AbortTaskUseCaseImpl {
-    constructor(context){
-        this.context = context;
+    constructor(taskService){
+        this.taskService = taskService;
     }
     async execute(params) {
-        const result = await this.context.tasks.abort(params);
+        const result = await this.taskService.abort(params);
         return result;
     }
 }

package/api/features/AbortTask/AbortTaskUseCase.js.map

@@ -1 +1 @@
-{"version":3,"file":"api/features/AbortTask/AbortTaskUseCase.js","sources":["../../../../src/api/features/AbortTask/AbortTaskUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { AbortTaskUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport type { Context } from \"~/api/types.js\";\n\nexport class AbortTaskUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(private context: Context) {}\n\n    async execute<\n        I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends TaskService.GenericOutput = TaskService.GenericOutput\n    >(\n        params: UseCaseAbstraction.Params\n    ): Promise<Result<TaskService.Task<I, O>, UseCaseAbstraction.Error>> {\n        const result = await this.context.tasks.abort<I, O>(params);\n        return result as unknown as Promise<\n            Result<TaskService.Task<I, O>, UseCaseAbstraction.Error>\n        >;\n    }\n}\n"],"names":["AbortTaskUseCaseImpl","context","params","result"],"mappings":"AAMO,MAAMA;IACT,YAA2BC,OAAgB,CAAE;aAAlBA,OAAO,GAAPA;IAAmB;IAE9C,MAAM,QAIFC,MAAiC,EACgC;QACjE,MAAMC,SAAS,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAOD;QACpD,OAAOC;IAGX;AACJ"}
+{"version":3,"file":"api/features/AbortTask/AbortTaskUseCase.js","sources":["../../../../src/api/features/AbortTask/AbortTaskUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { AbortTaskUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nexport class AbortTaskUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(private taskService: TaskService.Interface) {}\n\n    async execute<\n        I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends TaskService.GenericOutput = TaskService.GenericOutput\n    >(\n        params: UseCaseAbstraction.Params\n    ): Promise<Result<TaskService.Task<I, O>, UseCaseAbstraction.Error>> {\n        const result = await this.taskService.abort<I, O>(params);\n        return result as unknown as Promise<\n            Result<TaskService.Task<I, O>, UseCaseAbstraction.Error>\n        >;\n    }\n}\n"],"names":["AbortTaskUseCaseImpl","taskService","params","result"],"mappings":"AAIO,MAAMA;IACT,YAA2BC,WAAkC,CAAE;aAApCA,WAAW,GAAXA;IAAqC;IAEhE,MAAM,QAIFC,MAAiC,EACgC;QACjE,MAAMC,SAAS,MAAM,IAAI,CAAC,WAAW,CAAC,KAAK,CAAOD;QAClD,OAAOC;IAGX;AACJ"}

package/api/features/AbortTask/feature.d.ts

@@ -1,5 +1,4 @@
-import type { Context } from "../../../api/types.js";
 export declare const AbortTaskFeature: {
     name: string;
-    register(container: import("@webiny/di").Container, context: Context): void;
+    register(container: import("@webiny/di").Container): void;
 };

package/api/features/AbortTask/feature.js

@@ -1,10 +1,11 @@
 import { createFeature } from "@webiny/feature/api";
 import { AbortTaskUseCaseImpl } from "./AbortTaskUseCase.js";
 import { AbortTaskUseCase } from "./abstractions.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
 const AbortTaskFeature = createFeature({
     name: "AbortTask",
-    register (container, context) {
-        container.registerInstance(AbortTaskUseCase, new AbortTaskUseCaseImpl(context));
+    register (container) {
+        container.registerFactory(AbortTaskUseCase, ()=>new AbortTaskUseCaseImpl(container.resolve(TaskService)));
     }
 });
 export { AbortTaskFeature };

package/api/features/AbortTask/feature.js.map

@@ -1 +1 @@
-{"version":3,"file":"api/features/AbortTask/feature.js","sources":["../../../../src/api/features/AbortTask/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { AbortTaskUseCaseImpl } from \"./AbortTaskUseCase.js\";\nimport type { Context } from \"~/api/types.js\";\nimport { AbortTaskUseCase } from \"./abstractions.js\";\n\nexport const AbortTaskFeature = createFeature<Context>({\n    name: \"AbortTask\",\n    register(container, context) {\n        container.registerInstance(AbortTaskUseCase, new AbortTaskUseCaseImpl(context!));\n    }\n});\n"],"names":["AbortTaskFeature","createFeature","container","context","AbortTaskUseCase","AbortTaskUseCaseImpl"],"mappings":";;;AAKO,MAAMA,mBAAmBC,cAAuB;IACnD,MAAM;IACN,UAASC,SAAS,EAAEC,OAAO;QACvBD,UAAU,gBAAgB,CAACE,kBAAkB,IAAIC,qBAAqBF;IAC1E;AACJ"}
+{"version":3,"file":"api/features/AbortTask/feature.js","sources":["../../../../src/api/features/AbortTask/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { AbortTaskUseCaseImpl } from \"./AbortTaskUseCase.js\";\nimport { AbortTaskUseCase } from \"./abstractions.js\";\nimport { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\n\nexport const AbortTaskFeature = createFeature({\n    name: \"AbortTask\",\n    register(container) {\n        container.registerFactory(AbortTaskUseCase, () => {\n            return new AbortTaskUseCaseImpl(container.resolve(TaskService));\n        });\n    }\n});\n"],"names":["AbortTaskFeature","createFeature","container","AbortTaskUseCase","AbortTaskUseCaseImpl","TaskService"],"mappings":";;;;AAKO,MAAMA,mBAAmBC,cAAc;IAC1C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,eAAe,CAACC,kBAAkB,IACjC,IAAIC,qBAAqBF,UAAU,OAAO,CAACG;IAE1D;AACJ"}

package/api/features/CleanupTaskSubtree/CleanupTaskSubtreeUseCase.d.ts

@@ -1,7 +1,7 @@
 import { CleanupTaskSubtreeUseCase as UseCaseAbstraction } from "./abstractions.js";
-import type { Context } from "../../../api/types.js";
+import type { TasksCrud } from "../../../api/TasksCrud.js";
 export declare class CleanupTaskSubtreeUseCaseImpl implements UseCaseAbstraction.Interface {
-    private readonly context;
-    constructor(context: Context);
+    private readonly tasksCrud;
+    constructor(tasksCrud: TasksCrud.Interface);
     execute(taskId: string): Promise<void>;
 }

package/api/features/CleanupTaskSubtree/CleanupTaskSubtreeUseCase.js

@@ -1,9 +1,9 @@
 class CleanupTaskSubtreeUseCaseImpl {
-    constructor(context){
-        this.context = context;
+    constructor(tasksCrud){
+        this.tasksCrud = tasksCrud;
     }
     async execute(taskId) {
-        await this.context.tasks.cleanupTaskSubtree(taskId);
+        await this.tasksCrud.cleanupTaskSubtree(taskId);
     }
 }
 export { CleanupTaskSubtreeUseCaseImpl };

package/api/features/CleanupTaskSubtree/CleanupTaskSubtreeUseCase.js.map

@@ -1 +1 @@
-{"version":3,"file":"api/features/CleanupTaskSubtree/CleanupTaskSubtreeUseCase.js","sources":["../../../../src/api/features/CleanupTaskSubtree/CleanupTaskSubtreeUseCase.ts"],"sourcesContent":["import { CleanupTaskSubtreeUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport type { Context } from \"~/api/types.js\";\n\nexport class CleanupTaskSubtreeUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(private readonly context: Context) {}\n\n    public async execute(taskId: string): Promise<void> {\n        await this.context.tasks.cleanupTaskSubtree(taskId);\n    }\n}\n"],"names":["CleanupTaskSubtreeUseCaseImpl","context","taskId"],"mappings":"AAGO,MAAMA;IACT,YAAoCC,OAAgB,CAAE;aAAlBA,OAAO,GAAPA;IAAmB;IAEvD,MAAa,QAAQC,MAAc,EAAiB;QAChD,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,kBAAkB,CAACA;IAChD;AACJ"}
+{"version":3,"file":"api/features/CleanupTaskSubtree/CleanupTaskSubtreeUseCase.js","sources":["../../../../src/api/features/CleanupTaskSubtree/CleanupTaskSubtreeUseCase.ts"],"sourcesContent":["import { CleanupTaskSubtreeUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport type { TasksCrud } from \"~/api/TasksCrud.js\";\n\nexport class CleanupTaskSubtreeUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(private readonly tasksCrud: TasksCrud.Interface) {}\n\n    public async execute(taskId: string): Promise<void> {\n        await this.tasksCrud.cleanupTaskSubtree(taskId);\n    }\n}\n"],"names":["CleanupTaskSubtreeUseCaseImpl","tasksCrud","taskId"],"mappings":"AAGO,MAAMA;IACT,YAAoCC,SAA8B,CAAE;aAAhCA,SAAS,GAATA;IAAiC;IAErE,MAAa,QAAQC,MAAc,EAAiB;QAChD,MAAM,IAAI,CAAC,SAAS,CAAC,kBAAkB,CAACA;IAC5C;AACJ"}

package/api/features/GetBackgroundTaskSettings/GetBackgroundTaskSettingsRepository.js

@@ -14,7 +14,7 @@ class GetBackgroundTaskSettingsRepositoryImpl {
         this.getLatestRevisionRepository = getLatestRevisionRepository;
         this.createEntryRepository = createEntryRepository;
         this.createEntryDataFactory = createEntryDataFactory;
-        this.defaultRetentionDays = buildParams.get("BackgroundTasks.RetentionDays") ?? BACKGROUND_TASK_DEFAULT_RETENTION_DAYS;
+        this.defaultRetentionDays = buildParams.get("BackgroundTasks.RetentionDays") || BACKGROUND_TASK_DEFAULT_RETENTION_DAYS;
     }
     async execute() {
         try {
@@ -26,9 +26,12 @@ class GetBackgroundTaskSettingsRepositoryImpl {
             const entryResult = await this.getLatestRevisionRepository.execute(model, {
                 id: entryId
             });
-            if (entryResult.isOk()) return Result.ok({
-                retentionDays: entryResult.value.values.retentionDays ?? this.defaultRetentionDays
-            });
+            if (entryResult.isOk()) {
+                const retentionDays = null != entryResult.value.values.retentionDays ? entryResult.value.values.retentionDays : this.defaultRetentionDays;
+                return Result.ok({
+                    retentionDays
+                });
+            }
             const { entry } = await this.createEntryDataFactory.create(model, {
                 id: singletonId,
                 values: {

package/api/features/GetBackgroundTaskSettings/GetBackgroundTaskSettingsRepository.js.map

@@ -1 +1 @@
-{"version":3,"file":"api/features/GetBackgroundTaskSettings/GetBackgroundTaskSettingsRepository.js","sources":["../../../../src/api/features/GetBackgroundTaskSettings/GetBackgroundTaskSettingsRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { createCacheKey } from \"@webiny/utils\";\nimport { GetModelRepository } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\nimport { GetLatestRevisionByEntryIdRepository } from \"@webiny/api-headless-cms/features/contentEntry/GetLatestRevisionByEntryId/index.js\";\nimport { CreateEntryRepository } from \"@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js\";\nimport { CreateEntryDataFactory } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\nimport { BuildParams } from \"@webiny/api-core/features/buildParams/index.js\";\nimport { GetBackgroundTaskSettingsRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport {\n    BackgroundTaskModelNotFoundError,\n    BackgroundTaskPersistenceError\n} from \"~/api/domain/errors.js\";\nimport {\n    BACKGROUND_TASK_SETTINGS_MODEL_ID,\n    BACKGROUND_TASK_DEFAULT_RETENTION_DAYS\n} from \"~/api/domain/constants.js\";\nimport type { IBackgroundTaskSettings } from \"~/api/domain/BackgroundTaskSettings.js\";\n\ninterface BackgroundTaskSettingsValues {\n    retentionDays?: number;\n}\n\nclass GetBackgroundTaskSettingsRepositoryImpl implements RepositoryAbstraction.Interface {\n    private readonly defaultRetentionDays: number;\n\n    constructor(\n        private readonly getModelRepository: GetModelRepository.Interface,\n        private readonly getLatestRevisionRepository: GetLatestRevisionByEntryIdRepository.Interface,\n        private readonly createEntryRepository: CreateEntryRepository.Interface,\n        private readonly createEntryDataFactory: CreateEntryDataFactory.Interface,\n        buildParams: BuildParams.Interface\n    ) {\n        this.defaultRetentionDays =\n            buildParams.get<number>(\"BackgroundTasks.RetentionDays\") ??\n            BACKGROUND_TASK_DEFAULT_RETENTION_DAYS;\n    }\n\n    async execute(): Promise<Result<IBackgroundTaskSettings, RepositoryAbstraction.Error>> {\n        try {\n            const modelResult = await this.getModelRepository.execute(\n                BACKGROUND_TASK_SETTINGS_MODEL_ID\n            );\n            if (modelResult.isFail()) {\n                return Result.fail(\n                    new BackgroundTaskModelNotFoundError(BACKGROUND_TASK_SETTINGS_MODEL_ID)\n                );\n            }\n\n            const model = modelResult.value;\n            const singletonId = createCacheKey(model.modelId);\n            const entryId = `${singletonId}#0001`;\n\n            const entryResult =\n                await this.getLatestRevisionRepository.execute<BackgroundTaskSettingsValues>(\n                    model,\n                    { id: entryId }\n                );\n\n            if (entryResult.isOk()) {\n                return Result.ok({\n                    retentionDays:\n                        entryResult.value.values.retentionDays ?? this.defaultRetentionDays\n                });\n            }\n\n            /* Entry doesn't exist yet — create it with the build-param default. */\n            const { entry } =\n                await this.createEntryDataFactory.create<BackgroundTaskSettingsValues>(model, {\n                    id: singletonId,\n                    values: {\n                        retentionDays: this.defaultRetentionDays\n                    }\n                });\n\n            const createResult = await this.createEntryRepository.execute(model, entry);\n            if (createResult.isFail()) {\n                return Result.fail(BackgroundTaskPersistenceError.from(createResult.error));\n            }\n\n            return Result.ok({ retentionDays: this.defaultRetentionDays });\n        } catch (error) {\n            return Result.fail(BackgroundTaskPersistenceError.from(error));\n        }\n    }\n}\n\nexport const GetBackgroundTaskSettingsRepository = RepositoryAbstraction.createImplementation({\n    implementation: GetBackgroundTaskSettingsRepositoryImpl,\n    dependencies: [\n        GetModelRepository,\n        GetLatestRevisionByEntryIdRepository,\n        CreateEntryRepository,\n        CreateEntryDataFactory,\n        BuildParams\n    ]\n});\n"],"names":["GetBackgroundTaskSettingsRepositoryImpl","getModelRepository","getLatestRevisionRepository","createEntryRepository","createEntryDataFactory","buildParams","BACKGROUND_TASK_DEFAULT_RETENTION_DAYS","modelResult","BACKGROUND_TASK_SETTINGS_MODEL_ID","Result","BackgroundTaskModelNotFoundError","model","singletonId","createCacheKey","entryId","entryResult","entry","createResult","BackgroundTaskPersistenceError","error","GetBackgroundTaskSettingsRepository","RepositoryAbstraction","GetModelRepository","GetLatestRevisionByEntryIdRepository","CreateEntryRepository","CreateEntryDataFactory","BuildParams"],"mappings":";;;;;;;;;;AAsBA,MAAMA;IAGF,YACqBC,kBAAgD,EAChDC,2BAA2E,EAC3EC,qBAAsD,EACtDC,sBAAwD,EACzEC,WAAkC,CACpC;aALmBJ,kBAAkB,GAAlBA;aACAC,2BAA2B,GAA3BA;aACAC,qBAAqB,GAArBA;aACAC,sBAAsB,GAAtBA;QAGjB,IAAI,CAAC,oBAAoB,GACrBC,YAAY,GAAG,CAAS,oCACxBC;IACR;IAEA,MAAM,UAAiF;QACnF,IAAI;YACA,MAAMC,cAAc,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CACrDC;YAEJ,IAAID,YAAY,MAAM,IAClB,OAAOE,OAAO,IAAI,CACd,IAAIC,iCAAiCF;YAI7C,MAAMG,QAAQJ,YAAY,KAAK;YAC/B,MAAMK,cAAcC,eAAeF,MAAM,OAAO;YAChD,MAAMG,UAAU,GAAGF,YAAY,KAAK,CAAC;YAErC,MAAMG,cACF,MAAM,IAAI,CAAC,2BAA2B,CAAC,OAAO,CAC1CJ,OACA;gBAAE,IAAIG;YAAQ;YAGtB,IAAIC,YAAY,IAAI,IAChB,OAAON,OAAO,EAAE,CAAC;gBACb,eACIM,YAAY,KAAK,CAAC,MAAM,CAAC,aAAa,IAAI,IAAI,CAAC,oBAAoB;YAC3E;YAIJ,MAAM,EAAEC,KAAK,EAAE,GACX,MAAM,IAAI,CAAC,sBAAsB,CAAC,MAAM,CAA+BL,OAAO;gBAC1E,IAAIC;gBACJ,QAAQ;oBACJ,eAAe,IAAI,CAAC,oBAAoB;gBAC5C;YACJ;YAEJ,MAAMK,eAAe,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAACN,OAAOK;YACrE,IAAIC,aAAa,MAAM,IACnB,OAAOR,OAAO,IAAI,CAACS,+BAA+B,IAAI,CAACD,aAAa,KAAK;YAG7E,OAAOR,OAAO,EAAE,CAAC;gBAAE,eAAe,IAAI,CAAC,oBAAoB;YAAC;QAChE,EAAE,OAAOU,OAAO;YACZ,OAAOV,OAAO,IAAI,CAACS,+BAA+B,IAAI,CAACC;QAC3D;IACJ;AACJ;AAEO,MAAMC,0EAAsCC,oCAAAA,oBAA0C,CAAC;IAC1F,gBAAgBrB;IAChB,cAAc;QACVsB;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}
+{"version":3,"file":"api/features/GetBackgroundTaskSettings/GetBackgroundTaskSettingsRepository.js","sources":["../../../../src/api/features/GetBackgroundTaskSettings/GetBackgroundTaskSettingsRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { createCacheKey } from \"@webiny/utils\";\nimport { GetModelRepository } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\nimport { GetLatestRevisionByEntryIdRepository } from \"@webiny/api-headless-cms/features/contentEntry/GetLatestRevisionByEntryId/index.js\";\nimport { CreateEntryRepository } from \"@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js\";\nimport { CreateEntryDataFactory } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\nimport { BuildParams } from \"@webiny/api-core/features/buildParams/index.js\";\nimport { GetBackgroundTaskSettingsRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport {\n    BackgroundTaskModelNotFoundError,\n    BackgroundTaskPersistenceError\n} from \"~/api/domain/errors.js\";\nimport {\n    BACKGROUND_TASK_SETTINGS_MODEL_ID,\n    BACKGROUND_TASK_DEFAULT_RETENTION_DAYS\n} from \"~/api/domain/constants.js\";\nimport type { IBackgroundTaskSettings } from \"~/api/domain/BackgroundTaskSettings.js\";\n\ninterface BackgroundTaskSettingsValues {\n    retentionDays?: number;\n}\n\nclass GetBackgroundTaskSettingsRepositoryImpl implements RepositoryAbstraction.Interface {\n    private readonly defaultRetentionDays: number;\n\n    constructor(\n        private readonly getModelRepository: GetModelRepository.Interface,\n        private readonly getLatestRevisionRepository: GetLatestRevisionByEntryIdRepository.Interface,\n        private readonly createEntryRepository: CreateEntryRepository.Interface,\n        private readonly createEntryDataFactory: CreateEntryDataFactory.Interface,\n        buildParams: BuildParams.Interface\n    ) {\n        this.defaultRetentionDays =\n            buildParams.get<number>(\"BackgroundTasks.RetentionDays\") ||\n            BACKGROUND_TASK_DEFAULT_RETENTION_DAYS;\n    }\n\n    async execute(): Promise<Result<IBackgroundTaskSettings, RepositoryAbstraction.Error>> {\n        try {\n            const modelResult = await this.getModelRepository.execute(\n                BACKGROUND_TASK_SETTINGS_MODEL_ID\n            );\n            if (modelResult.isFail()) {\n                return Result.fail(\n                    new BackgroundTaskModelNotFoundError(BACKGROUND_TASK_SETTINGS_MODEL_ID)\n                );\n            }\n\n            const model = modelResult.value;\n            const singletonId = createCacheKey(model.modelId);\n            const entryId = `${singletonId}#0001`;\n\n            const entryResult =\n                await this.getLatestRevisionRepository.execute<BackgroundTaskSettingsValues>(\n                    model,\n                    { id: entryId }\n                );\n\n            if (entryResult.isOk()) {\n                const retentionDays =\n                    entryResult.value.values.retentionDays != null\n                        ? entryResult.value.values.retentionDays\n                        : this.defaultRetentionDays;\n\n                return Result.ok({ retentionDays });\n            }\n\n            /* Entry doesn't exist yet — create it with the build-param default. */\n            const { entry } =\n                await this.createEntryDataFactory.create<BackgroundTaskSettingsValues>(model, {\n                    id: singletonId,\n                    values: {\n                        retentionDays: this.defaultRetentionDays\n                    }\n                });\n\n            const createResult = await this.createEntryRepository.execute(model, entry);\n            if (createResult.isFail()) {\n                return Result.fail(BackgroundTaskPersistenceError.from(createResult.error));\n            }\n\n            return Result.ok({ retentionDays: this.defaultRetentionDays });\n        } catch (error) {\n            return Result.fail(BackgroundTaskPersistenceError.from(error));\n        }\n    }\n}\n\nexport const GetBackgroundTaskSettingsRepository = RepositoryAbstraction.createImplementation({\n    implementation: GetBackgroundTaskSettingsRepositoryImpl,\n    dependencies: [\n        GetModelRepository,\n        GetLatestRevisionByEntryIdRepository,\n        CreateEntryRepository,\n        CreateEntryDataFactory,\n        BuildParams\n    ]\n});\n"],"names":["GetBackgroundTaskSettingsRepositoryImpl","getModelRepository","getLatestRevisionRepository","createEntryRepository","createEntryDataFactory","buildParams","BACKGROUND_TASK_DEFAULT_RETENTION_DAYS","modelResult","BACKGROUND_TASK_SETTINGS_MODEL_ID","Result","BackgroundTaskModelNotFoundError","model","singletonId","createCacheKey","entryId","entryResult","retentionDays","entry","createResult","BackgroundTaskPersistenceError","error","GetBackgroundTaskSettingsRepository","RepositoryAbstraction","GetModelRepository","GetLatestRevisionByEntryIdRepository","CreateEntryRepository","CreateEntryDataFactory","BuildParams"],"mappings":";;;;;;;;;;AAsBA,MAAMA;IAGF,YACqBC,kBAAgD,EAChDC,2BAA2E,EAC3EC,qBAAsD,EACtDC,sBAAwD,EACzEC,WAAkC,CACpC;aALmBJ,kBAAkB,GAAlBA;aACAC,2BAA2B,GAA3BA;aACAC,qBAAqB,GAArBA;aACAC,sBAAsB,GAAtBA;QAGjB,IAAI,CAAC,oBAAoB,GACrBC,YAAY,GAAG,CAAS,oCACxBC;IACR;IAEA,MAAM,UAAiF;QACnF,IAAI;YACA,MAAMC,cAAc,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CACrDC;YAEJ,IAAID,YAAY,MAAM,IAClB,OAAOE,OAAO,IAAI,CACd,IAAIC,iCAAiCF;YAI7C,MAAMG,QAAQJ,YAAY,KAAK;YAC/B,MAAMK,cAAcC,eAAeF,MAAM,OAAO;YAChD,MAAMG,UAAU,GAAGF,YAAY,KAAK,CAAC;YAErC,MAAMG,cACF,MAAM,IAAI,CAAC,2BAA2B,CAAC,OAAO,CAC1CJ,OACA;gBAAE,IAAIG;YAAQ;YAGtB,IAAIC,YAAY,IAAI,IAAI;gBACpB,MAAMC,gBACFD,AAA0C,QAA1CA,YAAY,KAAK,CAAC,MAAM,CAAC,aAAa,GAChCA,YAAY,KAAK,CAAC,MAAM,CAAC,aAAa,GACtC,IAAI,CAAC,oBAAoB;gBAEnC,OAAON,OAAO,EAAE,CAAC;oBAAEO;gBAAc;YACrC;YAGA,MAAM,EAAEC,KAAK,EAAE,GACX,MAAM,IAAI,CAAC,sBAAsB,CAAC,MAAM,CAA+BN,OAAO;gBAC1E,IAAIC;gBACJ,QAAQ;oBACJ,eAAe,IAAI,CAAC,oBAAoB;gBAC5C;YACJ;YAEJ,MAAMM,eAAe,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAACP,OAAOM;YACrE,IAAIC,aAAa,MAAM,IACnB,OAAOT,OAAO,IAAI,CAACU,+BAA+B,IAAI,CAACD,aAAa,KAAK;YAG7E,OAAOT,OAAO,EAAE,CAAC;gBAAE,eAAe,IAAI,CAAC,oBAAoB;YAAC;QAChE,EAAE,OAAOW,OAAO;YACZ,OAAOX,OAAO,IAAI,CAACU,+BAA+B,IAAI,CAACC;QAC3D;IACJ;AACJ;AAEO,MAAMC,0EAAsCC,oCAAAA,oBAA0C,CAAC;IAC1F,gBAAgBtB;IAChB,cAAc;QACVuB;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

package/api/features/GetRunnableTaskDefinition/GetRunnableTaskDefinitionUseCase.d.ts

@@ -0,0 +1,13 @@
+import { Result } from "@webiny/feature/api";
+import { GetRunnableTaskDefinitionUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { TaskHandlerResolver } from "../../../api/features/TaskHandlerResolver/index.js";
+export declare class GetRunnableTaskDefinitionUseCaseImpl implements UseCaseAbstraction.Interface {
+    private definitions;
+    private handlerResolver;
+    constructor(definitions: TaskDefinition.Interface[], handlerResolver: TaskHandlerResolver.Interface);
+    execute<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends TaskDefinition.TaskOutput = TaskDefinition.TaskOutput>(id: string): Result<TaskDefinition.Runnable<I, O>, UseCaseAbstraction.Error>;
+}
+export declare const GetRunnableTaskDefinitionUseCase: typeof GetRunnableTaskDefinitionUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetRunnableTaskDefinitionUseCase>;
+};

package/api/features/GetRunnableTaskDefinition/GetRunnableTaskDefinitionUseCase.js

@@ -0,0 +1,51 @@
+import { Result } from "@webiny/feature/api";
+import { GetRunnableTaskDefinitionUseCase } from "./abstractions.js";
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { TaskHandlerResolver } from "../TaskHandlerResolver/index.js";
+import { TaskDefinitionNotFoundError } from "../../domain/errors.js";
+class GetRunnableTaskDefinitionUseCaseImpl {
+    constructor(definitions, handlerResolver){
+        this.definitions = definitions;
+        this.handlerResolver = handlerResolver;
+    }
+    execute(id) {
+        for (const definition of this.definitions){
+            if (definition.id !== id) continue;
+            const handlerClass = definition.handler;
+            const handler = this.handlerResolver.resolve(handlerClass);
+            const runnable = {
+                id: definition.id,
+                title: definition.title,
+                description: definition.description,
+                isPrivate: definition.isPrivate,
+                databaseLogs: definition.databaseLogs,
+                maxIterations: definition.maxIterations,
+                selfCleanup: definition.selfCleanup,
+                run: handler.run.bind(handler),
+                onBeforeTrigger: handler.onBeforeTrigger?.bind(handler),
+                onDone: handler.onDone?.bind(handler),
+                onError: handler.onError?.bind(handler),
+                onAbort: handler.onAbort?.bind(handler),
+                onMaxIterations: handler.onMaxIterations?.bind(handler),
+                createInputValidation: handler.createInputValidation?.bind(handler)
+            };
+            return Result.ok(runnable);
+        }
+        return Result.fail(new TaskDefinitionNotFoundError(id));
+    }
+}
+const GetRunnableTaskDefinitionUseCase_GetRunnableTaskDefinitionUseCase = GetRunnableTaskDefinitionUseCase.createImplementation({
+    implementation: GetRunnableTaskDefinitionUseCaseImpl,
+    dependencies: [
+        [
+            TaskDefinition,
+            {
+                multiple: true
+            }
+        ],
+        TaskHandlerResolver
+    ]
+});
+export { GetRunnableTaskDefinitionUseCaseImpl, GetRunnableTaskDefinitionUseCase_GetRunnableTaskDefinitionUseCase as GetRunnableTaskDefinitionUseCase };
+
+//# sourceMappingURL=GetRunnableTaskDefinitionUseCase.js.map

package/api/features/GetRunnableTaskDefinition/GetRunnableTaskDefinitionUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/GetRunnableTaskDefinition/GetRunnableTaskDefinitionUseCase.js","sources":["../../../../src/api/features/GetRunnableTaskDefinition/GetRunnableTaskDefinitionUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport type { Constructor } from \"@webiny/di\";\nimport { GetRunnableTaskDefinitionUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { TaskHandlerResolver } from \"~/api/features/TaskHandlerResolver/index.js\";\nimport { TaskDefinitionNotFoundError } from \"~/api/domain/errors.js\";\n\nexport class GetRunnableTaskDefinitionUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private definitions: TaskDefinition.Interface[],\n        private handlerResolver: TaskHandlerResolver.Interface\n    ) {}\n\n    public execute<\n        I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends TaskDefinition.TaskOutput = TaskDefinition.TaskOutput\n    >(id: string): Result<TaskDefinition.Runnable<I, O>, UseCaseAbstraction.Error> {\n        for (const definition of this.definitions) {\n            if (definition.id !== id) {\n                continue;\n            }\n\n            // Every definition is free to build, so reaching this point cost nothing. The handler is\n            // the expensive half and it is built only now, for the one task that was asked for.\n            //\n            // The registered definition is stored under the abstraction's default generics, so its\n            // handler cannot be proven assignable to the caller's narrower <I, O>.\n            const handlerClass = definition.handler as Constructor<TaskDefinition.Handler<I, O>>;\n            const handler = this.handlerResolver.resolve(handlerClass);\n\n            // Present the two halves as the single object the runner and\n            // `context.tasks.getDefinition()` expect. Metadata from the definition, behaviour from\n            // the handler, bound so `this` inside a hook is still the instance that owns the\n            // injected dependencies.\n            const runnable: TaskDefinition.Runnable<I, O> = {\n                id: definition.id,\n                title: definition.title,\n                description: definition.description,\n                isPrivate: definition.isPrivate as boolean,\n                databaseLogs: definition.databaseLogs as boolean,\n                maxIterations: definition.maxIterations as number,\n                selfCleanup: definition.selfCleanup,\n\n                run: handler.run.bind(handler),\n                onBeforeTrigger: handler.onBeforeTrigger?.bind(handler),\n                onDone: handler.onDone?.bind(handler),\n                onError: handler.onError?.bind(handler),\n                onAbort: handler.onAbort?.bind(handler),\n                onMaxIterations: handler.onMaxIterations?.bind(handler),\n                createInputValidation: handler.createInputValidation?.bind(handler)\n            };\n\n            return Result.ok(runnable);\n        }\n\n        return Result.fail(new TaskDefinitionNotFoundError(id));\n    }\n}\n\nexport const GetRunnableTaskDefinitionUseCase = UseCaseAbstraction.createImplementation({\n    implementation: GetRunnableTaskDefinitionUseCaseImpl,\n    dependencies: [[TaskDefinition, { multiple: true }], TaskHandlerResolver]\n});\n"],"names":["GetRunnableTaskDefinitionUseCaseImpl","definitions","handlerResolver","id","definition","handlerClass","handler","runnable","Result","TaskDefinitionNotFoundError","GetRunnableTaskDefinitionUseCase","UseCaseAbstraction","TaskDefinition","TaskHandlerResolver"],"mappings":";;;;;AAOO,MAAMA;IACT,YACYC,WAAuC,EACvCC,eAA8C,CACxD;aAFUD,WAAW,GAAXA;aACAC,eAAe,GAAfA;IACT;IAEI,QAGLC,EAAU,EAAmE;QAC3E,KAAK,MAAMC,cAAc,IAAI,CAAC,WAAW,CAAE;YACvC,IAAIA,WAAW,EAAE,KAAKD,IAClB;YAQJ,MAAME,eAAeD,WAAW,OAAO;YACvC,MAAME,UAAU,IAAI,CAAC,eAAe,CAAC,OAAO,CAACD;YAM7C,MAAME,WAA0C;gBAC5C,IAAIH,WAAW,EAAE;gBACjB,OAAOA,WAAW,KAAK;gBACvB,aAAaA,WAAW,WAAW;gBACnC,WAAWA,WAAW,SAAS;gBAC/B,cAAcA,WAAW,YAAY;gBACrC,eAAeA,WAAW,aAAa;gBACvC,aAAaA,WAAW,WAAW;gBAEnC,KAAKE,QAAQ,GAAG,CAAC,IAAI,CAACA;gBACtB,iBAAiBA,QAAQ,eAAe,EAAE,KAAKA;gBAC/C,QAAQA,QAAQ,MAAM,EAAE,KAAKA;gBAC7B,SAASA,QAAQ,OAAO,EAAE,KAAKA;gBAC/B,SAASA,QAAQ,OAAO,EAAE,KAAKA;gBAC/B,iBAAiBA,QAAQ,eAAe,EAAE,KAAKA;gBAC/C,uBAAuBA,QAAQ,qBAAqB,EAAE,KAAKA;YAC/D;YAEA,OAAOE,OAAO,EAAE,CAACD;QACrB;QAEA,OAAOC,OAAO,IAAI,CAAC,IAAIC,4BAA4BN;IACvD;AACJ;AAEO,MAAMO,oEAAmCC,iCAAAA,oBAAuC,CAAC;IACpF,gBAAgBX;IAChB,cAAc;QAAC;YAACY;YAAgB;gBAAE,UAAU;YAAK;SAAE;QAAEC;KAAoB;AAC7E"}

package/api/features/{GetTaskDefinition → GetRunnableTaskDefinition}/abstractions.d.ts

@@ -1,16 +1,16 @@
 import type { Result } from "@webiny/feature/api";
 import type { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
 import type { TaskDefinitionNotFoundError } from "../../../api/domain/errors.js";
-export interface IGetTaskDefinitionUseCase {
+export interface IGetRunnableTaskDefinitionUseCase {
     execute<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends TaskDefinition.TaskOutput = TaskDefinition.TaskOutput>(id: string): Result<TaskDefinition.Runnable<I, O>, UseCaseError>;
 }
-export interface IGetTaskDefinitionUseCaseErrors {
+export interface IGetRunnableTaskDefinitionUseCaseErrors {
     notFound: TaskDefinitionNotFoundError;
 }
-type UseCaseError = IGetTaskDefinitionUseCaseErrors[keyof IGetTaskDefinitionUseCaseErrors];
-export declare const GetTaskDefinitionUseCase: import("@webiny/di").Abstraction<IGetTaskDefinitionUseCase>;
-export declare namespace GetTaskDefinitionUseCase {
-    type Interface = IGetTaskDefinitionUseCase;
+type UseCaseError = IGetRunnableTaskDefinitionUseCaseErrors[keyof IGetRunnableTaskDefinitionUseCaseErrors];
+export declare const GetRunnableTaskDefinitionUseCase: import("@webiny/di").Abstraction<IGetRunnableTaskDefinitionUseCase>;
+export declare namespace GetRunnableTaskDefinitionUseCase {
+    type Interface = IGetRunnableTaskDefinitionUseCase;
     type Error = UseCaseError;
     type Return<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends TaskDefinition.TaskOutput = TaskDefinition.TaskOutput> = Result<TaskDefinition.Runnable<I, O>, UseCaseError>;
 }

package/api/features/GetRunnableTaskDefinition/abstractions.js

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

package/api/features/GetRunnableTaskDefinition/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/GetRunnableTaskDefinition/abstractions.js","sources":["../../../../src/api/features/GetRunnableTaskDefinition/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport type { TaskDefinitionNotFoundError } from \"~/api/domain/errors.js\";\n\nexport interface IGetRunnableTaskDefinitionUseCase {\n    execute<\n        I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends TaskDefinition.TaskOutput = TaskDefinition.TaskOutput\n    >(\n        id: string\n    ): Result<TaskDefinition.Runnable<I, O>, UseCaseError>;\n}\n\nexport interface IGetRunnableTaskDefinitionUseCaseErrors {\n    notFound: TaskDefinitionNotFoundError;\n}\n\ntype UseCaseError =\n    IGetRunnableTaskDefinitionUseCaseErrors[keyof IGetRunnableTaskDefinitionUseCaseErrors];\n\nexport const GetRunnableTaskDefinitionUseCase =\n    createAbstraction<IGetRunnableTaskDefinitionUseCase>(\"Tasks/GetRunnableTaskDefinitionUseCase\");\n\nexport namespace GetRunnableTaskDefinitionUseCase {\n    export type Interface = IGetRunnableTaskDefinitionUseCase;\n\n    export type Error = UseCaseError;\n    export type Return<\n        I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends TaskDefinition.TaskOutput = TaskDefinition.TaskOutput\n    > = Result<TaskDefinition.Runnable<I, O>, UseCaseError>;\n}\n"],"names":["GetRunnableTaskDefinitionUseCase","createAbstraction"],"mappings":";AAqBO,MAAMA,mCACTC,kBAAqD"}

package/api/features/GetRunnableTaskDefinition/feature.d.ts

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

package/api/features/GetRunnableTaskDefinition/feature.js

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

package/api/features/GetRunnableTaskDefinition/feature.js.map

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

package/api/features/GetRunnableTaskDefinition/index.d.ts

@@ -0,0 +1,2 @@
+export { GetRunnableTaskDefinitionUseCase } from "./abstractions.js";
+export { GetRunnableTaskDefinitionFeature } from "./feature.js";

package/api/features/GetRunnableTaskDefinition/index.js

@@ -0,0 +1,2 @@
+export { GetRunnableTaskDefinitionUseCase } from "./abstractions.js";
+export { GetRunnableTaskDefinitionFeature } from "./feature.js";

package/api/features/GetTask/GetTaskUseCase.d.ts

@@ -1,9 +1,9 @@
 import { GetTaskUseCase as UseCaseAbstraction } from "./abstractions.js";
 import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
 import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
-import type { Context } from "../../../api/types.js";
+import type { TasksCrud } from "../../../api/TasksCrud.js";
 export declare class GetTaskUseCaseImpl implements UseCaseAbstraction.Interface {
-    private context;
-    constructor(context: Context);
+    private tasksCrud;
+    constructor(tasksCrud: TasksCrud.Interface);
     execute<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends TaskService.GenericOutput = TaskService.GenericOutput>(id: string): Promise<TaskService.Task<I, O> | null>;
 }

package/api/features/GetTask/GetTaskUseCase.js

@@ -1,9 +1,9 @@
 class GetTaskUseCaseImpl {
-    constructor(context){
-        this.context = context;
+    constructor(tasksCrud){
+        this.tasksCrud = tasksCrud;
     }
     async execute(id) {
-        return await this.context.tasks.getTask(id);
+        return await this.tasksCrud.getTask(id);
     }
 }
 export { GetTaskUseCaseImpl };