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

package/api/features/TaskController/TaskController.d.ts

@@ -0,0 +1,49 @@
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/abstractions.js";
+import { TaskController as Abstraction } from "@webiny/api-core/features/task/TaskController/abstractions.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import { TaskExecutionContext } from "../TaskExecutionContext/abstractions.js";
+import { type ITaskTriggerParams, TaskDataStatus } from "../../../api/types.js";
+import "./augmentation.js";
+import { BaseError, Result } from "@webiny/feature/api/index.js";
+declare class TaskControllerImpl implements Abstraction.Interface {
+    private taskService;
+    private executionContext;
+    constructor(taskService: TaskService.Interface, executionContext: TaskExecutionContext.Interface);
+    private get store();
+    private get runner();
+    private get timer();
+    get response(): import("~/api/types.js").ITaskResponse<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskOutput>;
+    state: {
+        getTask: () => import("~/api/types.js").ITask<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskOutput>;
+        getStatus: () => TaskDataStatus;
+        getInput: () => import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskInput;
+        getOutput: () => import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskOutput;
+        updateInput: (input: any) => Promise<void>;
+        updateOutput: (output: any) => Promise<void>;
+    };
+    logger: {
+        info: (params: {
+            message: string;
+            data?: Record<string, any>;
+        }) => Promise<void>;
+        error: (params: {
+            message: string;
+            error?: Error | any;
+            data?: Record<string, any>;
+        }) => Promise<void>;
+    };
+    task: {
+        trigger: <CI extends TaskDefinition.TaskInput = import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskInput>(params: ITaskTriggerParams<CI>) => Promise<Result<TaskService.Task<CI>, BaseError>>;
+        listChildren: <CT extends TaskDefinition.TaskInput = import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskInput, CO extends TaskDefinition.TaskOutput = import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskOutput>(definitionId?: string) => Promise<TaskService.Task<CT, CO>[]>;
+    };
+    runtime: {
+        isCloseToTimeout: (seconds?: number) => boolean;
+        isAborted: () => boolean;
+        getRemainingSeconds: () => number;
+        getRemainingMilliseconds: () => number;
+    };
+}
+export declare const TaskController: typeof TaskControllerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/task/TaskController/abstractions.js").ITaskController<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskOutput>>;
+};
+export {};

package/api/features/TaskController/TaskController.js

@@ -0,0 +1,71 @@
+import { TaskController } from "@webiny/api-core/features/task/TaskController/abstractions.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import { TaskExecutionContext } from "../TaskExecutionContext/abstractions.js";
+import { TaskDataStatus } from "../../types.js";
+import "./augmentation.js";
+class TaskControllerImpl {
+    constructor(taskService, executionContext){
+        this.taskService = taskService;
+        this.executionContext = executionContext;
+        this.state = {
+            getTask: ()=>this.store.getTask(),
+            getStatus: ()=>this.store.getStatus(),
+            getInput: ()=>this.store.getInput(),
+            getOutput: ()=>this.store.getOutput(),
+            updateInput: async (input)=>await this.store.updateInput(input),
+            updateOutput: async (output)=>await this.store.updateOutput(output)
+        };
+        this.logger = {
+            info: async (params)=>{
+                await this.store.addInfoLog(params);
+            },
+            error: async (params)=>{
+                const error = params.error;
+                const errorObj = error instanceof Error ? {
+                    message: error.message,
+                    stack: error.stack
+                } : error;
+                await this.store.addErrorLog({
+                    message: params.message,
+                    error: errorObj,
+                    data: params.data
+                });
+            }
+        };
+        this.task = {
+            trigger: async (params)=>this.taskService.trigger({
+                    ...params,
+                    parent: this.store.getTask()
+                }),
+            listChildren: async (definitionId)=>this.store.listChildTasks(definitionId)
+        };
+        this.runtime = {
+            isCloseToTimeout: (seconds)=>this.runner.isCloseToTimeout(seconds),
+            isAborted: ()=>this.store.getStatus() === TaskDataStatus.ABORTED,
+            getRemainingSeconds: ()=>this.timer.getRemainingSeconds(),
+            getRemainingMilliseconds: ()=>this.timer.getRemainingMilliseconds()
+        };
+    }
+    get store() {
+        return this.executionContext.store;
+    }
+    get runner() {
+        return this.executionContext.runner;
+    }
+    get timer() {
+        return this.executionContext.timer;
+    }
+    get response() {
+        return this.executionContext.response;
+    }
+}
+const TaskController_TaskController = TaskController.createImplementation({
+    implementation: TaskControllerImpl,
+    dependencies: [
+        TaskService,
+        TaskExecutionContext
+    ]
+});
+export { TaskController_TaskController as TaskController };
+
+//# sourceMappingURL=TaskController.js.map

package/api/features/TaskController/TaskController.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/TaskController/TaskController.js","sources":["../../../../src/api/features/TaskController/TaskController.ts"],"sourcesContent":["import { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/abstractions.js\";\nimport { TaskController as Abstraction } from \"@webiny/api-core/features/task/TaskController/abstractions.js\";\nimport { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport { TaskExecutionContext } from \"../TaskExecutionContext/abstractions.js\";\nimport { type ITaskTriggerParams, TaskDataStatus } from \"~/api/types.js\";\nimport \"./augmentation.js\";\nimport { BaseError, Result } from \"@webiny/feature/api/index.js\";\n\nclass TaskControllerImpl implements Abstraction.Interface {\n    constructor(\n        private taskService: TaskService.Interface,\n        private executionContext: TaskExecutionContext.Interface\n    ) {}\n\n    private get store() {\n        return this.executionContext.store;\n    }\n\n    private get runner() {\n        return this.executionContext.runner;\n    }\n\n    private get timer() {\n        return this.executionContext.timer;\n    }\n\n    public get response() {\n        return this.executionContext.response;\n    }\n\n    state = {\n        getTask: () => this.store.getTask(),\n        getStatus: () => this.store.getStatus(),\n        getInput: () => this.store.getInput(),\n        getOutput: () => this.store.getOutput(),\n        updateInput: async (input: any) => await this.store.updateInput(input),\n        updateOutput: async (output: any) => await this.store.updateOutput(output)\n    };\n\n    logger = {\n        info: async (params: { message: string; data?: Record<string, any> }) => {\n            await this.store.addInfoLog(params);\n        },\n        error: async (params: {\n            message: string;\n            error?: Error | any;\n            data?: Record<string, any>;\n        }) => {\n            const error = params.error;\n            const errorObj =\n                error instanceof Error ? { message: error.message, stack: error.stack } : error;\n            await this.store.addErrorLog({\n                message: params.message,\n                error: errorObj,\n                data: params.data\n            });\n        }\n    };\n\n    task = {\n        trigger: async <CI extends TaskDefinition.TaskInput = TaskDefinition.TaskInput>(\n            params: ITaskTriggerParams<CI>\n        ): Promise<Result<TaskService.Task<CI>, BaseError>> => {\n            return this.taskService.trigger({ ...params, parent: this.store.getTask() });\n        },\n        listChildren: async <\n            CT extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n            CO extends TaskDefinition.TaskOutput = TaskDefinition.TaskOutput\n        >(\n            definitionId?: string\n        ): Promise<TaskService.Task<CT, CO>[]> => {\n            return this.store.listChildTasks(definitionId);\n        }\n    };\n\n    runtime = {\n        isCloseToTimeout: (seconds?: number) => this.runner.isCloseToTimeout(seconds),\n        isAborted: () => this.store.getStatus() === TaskDataStatus.ABORTED,\n        getRemainingSeconds: () => this.timer.getRemainingSeconds(),\n        getRemainingMilliseconds: () => this.timer.getRemainingMilliseconds()\n    };\n}\n\nexport const TaskController = Abstraction.createImplementation({\n    implementation: TaskControllerImpl,\n    dependencies: [TaskService, TaskExecutionContext]\n});\n"],"names":["TaskControllerImpl","taskService","executionContext","input","output","params","error","errorObj","Error","definitionId","seconds","TaskDataStatus","TaskController","Abstraction","TaskService","TaskExecutionContext"],"mappings":";;;;;AAQA,MAAMA;IACF,YACYC,WAAkC,EAClCC,gBAAgD,CAC1D;aAFUD,WAAW,GAAXA;aACAC,gBAAgB,GAAhBA;aAmBZ,KAAK,GAAG;YACJ,SAAS,IAAM,IAAI,CAAC,KAAK,CAAC,OAAO;YACjC,WAAW,IAAM,IAAI,CAAC,KAAK,CAAC,SAAS;YACrC,UAAU,IAAM,IAAI,CAAC,KAAK,CAAC,QAAQ;YACnC,WAAW,IAAM,IAAI,CAAC,KAAK,CAAC,SAAS;YACrC,aAAa,OAAOC,QAAe,MAAM,IAAI,CAAC,KAAK,CAAC,WAAW,CAACA;YAChE,cAAc,OAAOC,SAAgB,MAAM,IAAI,CAAC,KAAK,CAAC,YAAY,CAACA;QACvE;aAEA,MAAM,GAAG;YACL,MAAM,OAAOC;gBACT,MAAM,IAAI,CAAC,KAAK,CAAC,UAAU,CAACA;YAChC;YACA,OAAO,OAAOA;gBAKV,MAAMC,QAAQD,OAAO,KAAK;gBAC1B,MAAME,WACFD,iBAAiBE,QAAQ;oBAAE,SAASF,MAAM,OAAO;oBAAE,OAAOA,MAAM,KAAK;gBAAC,IAAIA;gBAC9E,MAAM,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC;oBACzB,SAASD,OAAO,OAAO;oBACvB,OAAOE;oBACP,MAAMF,OAAO,IAAI;gBACrB;YACJ;QACJ;aAEA,IAAI,GAAG;YACH,SAAS,OACLA,SAEO,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC;oBAAE,GAAGA,MAAM;oBAAE,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO;gBAAG;YAE9E,cAAc,OAIVI,eAEO,IAAI,CAAC,KAAK,CAAC,cAAc,CAACA;QAEzC;aAEA,OAAO,GAAG;YACN,kBAAkB,CAACC,UAAqB,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAACA;YACrE,WAAW,IAAM,IAAI,CAAC,KAAK,CAAC,SAAS,OAAOC,eAAe,OAAO;YAClE,qBAAqB,IAAM,IAAI,CAAC,KAAK,CAAC,mBAAmB;YACzD,0BAA0B,IAAM,IAAI,CAAC,KAAK,CAAC,wBAAwB;QACvE;IApEG;IAEH,IAAY,QAAQ;QAChB,OAAO,IAAI,CAAC,gBAAgB,CAAC,KAAK;IACtC;IAEA,IAAY,SAAS;QACjB,OAAO,IAAI,CAAC,gBAAgB,CAAC,MAAM;IACvC;IAEA,IAAY,QAAQ;QAChB,OAAO,IAAI,CAAC,gBAAgB,CAAC,KAAK;IACtC;IAEA,IAAW,WAAW;QAClB,OAAO,IAAI,CAAC,gBAAgB,CAAC,QAAQ;IACzC;AAqDJ;AAEO,MAAMC,gCAAiBC,eAAAA,oBAAgC,CAAC;IAC3D,gBAAgBb;IAChB,cAAc;QAACc;QAAaC;KAAqB;AACrD"}

package/api/features/TaskController/augmentation.d.ts

@@ -0,0 +1,60 @@
+import type { IResponseError } from "@webiny/api-core/features/task/TaskDefinition";
+import type { TaskDataStatus } from "../../../api/types.js";
+import { type ITaskTriggerParams, TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import type { ITaskResponse } from "../../../api/response/abstractions/index.js";
+import { Result } from "@webiny/feature/api";
+import { BaseError } from "@webiny/feature/api/index.js";
+/**
+ * Augment the TaskController interface from api-core with implementation details.
+ * This allows developers to import from @webiny/api-core but get the full interface.
+ */
+declare module "@webiny/api-core/features/task/TaskController/abstractions.js" {
+    interface ITaskController<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends TaskDefinition.TaskOutput = TaskDefinition.TaskOutput> {
+        /**
+         * Response object
+         */
+        response: ITaskResponse<I, O>;
+        /**
+         * State management - access and update task state
+         */
+        state: {
+            getTask(): TaskService.Task<I, O>;
+            getStatus(): TaskDataStatus;
+            getInput(): I;
+            getOutput(): O | undefined;
+            updateInput(input: Partial<I>): Promise<void>;
+            updateOutput(output: Partial<O>): Promise<void>;
+        };
+        /**
+         * Logging - add log entries to task
+         */
+        logger: {
+            info(params: {
+                message: string;
+                data?: Record<string, any>;
+            }): Promise<void>;
+            error(params: {
+                message: string;
+                error?: Error | IResponseError;
+                data?: Record<string, any>;
+            }): Promise<void>;
+        };
+        /**
+         * Task management - trigger and query child tasks
+         */
+        task: {
+            trigger<CI extends TaskDefinition.TaskInput = TaskDefinition.TaskInput>(params: ITaskTriggerParams<CI>): Promise<Result<TaskService.Task<CI>, BaseError>>;
+            listChildren<CT extends TaskDefinition.TaskInput = I, CO extends TaskDefinition.TaskOutput = O>(definitionId?: string): Promise<TaskService.Task<CT, CO>[]>;
+        };
+        /**
+         * Runtime checks
+         */
+        runtime: {
+            isCloseToTimeout(seconds?: number): boolean;
+            isAborted(): boolean;
+            getRemainingSeconds(): number;
+            getRemainingMilliseconds(): number;
+        };
+    }
+}

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

@@ -0,0 +1,2 @@
+import "./augmentation.js";
+export { TaskController } from "./TaskController.js";

package/api/features/TaskController/index.js

@@ -0,0 +1,2 @@
+import "./augmentation.js";
+export { TaskController } from "./TaskController.js";

package/api/features/TaskExecutionContext/TaskExecutionContext.d.ts

@@ -0,0 +1,24 @@
+import { TaskExecutionContext as Abstraction } from "./abstractions.js";
+import type { ITaskManagerStore } from "../../../api/runner/abstractions/TaskManagerStore.js";
+import type { ITaskRunner } from "../../../api/runner/abstractions/TaskRunner.js";
+import type { ITimer } from "@webiny/handler-aws";
+import type { ITaskResponse } from "../../../api/response/abstractions/index.js";
+declare class TaskExecutionContextImpl implements Abstraction.Interface {
+    private _store?;
+    private _runner?;
+    private _timer?;
+    private _response?;
+    get store(): ITaskManagerStore;
+    get runner(): ITaskRunner;
+    get timer(): ITimer;
+    get response(): ITaskResponse;
+    setStore(store: ITaskManagerStore): void;
+    setRunner(runner: ITaskRunner): void;
+    setTimer(timer: ITimer): void;
+    setResponse(response: ITaskResponse): void;
+    clear(): void;
+}
+export declare const TaskExecutionContext: typeof TaskExecutionContextImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ITaskExecutionContext>;
+};
+export {};

package/api/features/TaskExecutionContext/TaskExecutionContext.js

@@ -0,0 +1,43 @@
+import { TaskExecutionContext } from "./abstractions.js";
+class TaskExecutionContextImpl {
+    get store() {
+        if (!this._store) throw new Error("TaskExecutionContext: store not set. Task execution not started.");
+        return this._store;
+    }
+    get runner() {
+        if (!this._runner) throw new Error("TaskExecutionContext: runner not set. Task execution not started.");
+        return this._runner;
+    }
+    get timer() {
+        if (!this._timer) throw new Error("TaskExecutionContext: timer not set. Task execution not started.");
+        return this._timer;
+    }
+    get response() {
+        if (!this._response) throw new Error("TaskExecutionContext: response not set. Task execution not started.");
+        return this._response;
+    }
+    setStore(store) {
+        this._store = store;
+    }
+    setRunner(runner) {
+        this._runner = runner;
+    }
+    setTimer(timer) {
+        this._timer = timer;
+    }
+    setResponse(response) {
+        this._response = response;
+    }
+    clear() {
+        this._store = void 0;
+        this._runner = void 0;
+        this._timer = void 0;
+    }
+}
+const TaskExecutionContext_TaskExecutionContext = TaskExecutionContext.createImplementation({
+    implementation: TaskExecutionContextImpl,
+    dependencies: []
+});
+export { TaskExecutionContext_TaskExecutionContext as TaskExecutionContext };
+
+//# sourceMappingURL=TaskExecutionContext.js.map

package/api/features/TaskExecutionContext/TaskExecutionContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/TaskExecutionContext/TaskExecutionContext.js","sources":["../../../../src/api/features/TaskExecutionContext/TaskExecutionContext.ts"],"sourcesContent":["import { TaskExecutionContext as Abstraction } from \"./abstractions.js\";\nimport type { ITaskManagerStore } from \"~/api/runner/abstractions/TaskManagerStore.js\";\nimport type { ITaskRunner } from \"~/api/runner/abstractions/TaskRunner.js\";\nimport type { ITimer } from \"@webiny/handler-aws\";\nimport type { ITaskResponse } from \"~/api/response/abstractions/index.js\";\n\nclass TaskExecutionContextImpl implements Abstraction.Interface {\n    private _store?: ITaskManagerStore;\n    private _runner?: ITaskRunner;\n    private _timer?: ITimer;\n    private _response?: ITaskResponse;\n\n    get store(): ITaskManagerStore {\n        if (!this._store) {\n            throw new Error(\"TaskExecutionContext: store not set. Task execution not started.\");\n        }\n        return this._store;\n    }\n\n    get runner(): ITaskRunner {\n        if (!this._runner) {\n            throw new Error(\"TaskExecutionContext: runner not set. Task execution not started.\");\n        }\n        return this._runner;\n    }\n\n    get timer(): ITimer {\n        if (!this._timer) {\n            throw new Error(\"TaskExecutionContext: timer not set. Task execution not started.\");\n        }\n        return this._timer;\n    }\n\n    get response(): ITaskResponse {\n        if (!this._response) {\n            throw new Error(\"TaskExecutionContext: response not set. Task execution not started.\");\n        }\n        return this._response;\n    }\n\n    setStore(store: ITaskManagerStore): void {\n        this._store = store;\n    }\n\n    setRunner(runner: ITaskRunner): void {\n        this._runner = runner;\n    }\n\n    setTimer(timer: ITimer): void {\n        this._timer = timer;\n    }\n\n    setResponse(response: ITaskResponse): void {\n        this._response = response;\n    }\n\n    clear(): void {\n        this._store = undefined;\n        this._runner = undefined;\n        this._timer = undefined;\n    }\n}\n\nexport const TaskExecutionContext = Abstraction.createImplementation({\n    implementation: TaskExecutionContextImpl,\n    dependencies: []\n});\n"],"names":["TaskExecutionContextImpl","Error","store","runner","timer","response","undefined","TaskExecutionContext","Abstraction"],"mappings":";AAMA,MAAMA;IAMF,IAAI,QAA2B;QAC3B,IAAI,CAAC,IAAI,CAAC,MAAM,EACZ,MAAM,IAAIC,MAAM;QAEpB,OAAO,IAAI,CAAC,MAAM;IACtB;IAEA,IAAI,SAAsB;QACtB,IAAI,CAAC,IAAI,CAAC,OAAO,EACb,MAAM,IAAIA,MAAM;QAEpB,OAAO,IAAI,CAAC,OAAO;IACvB;IAEA,IAAI,QAAgB;QAChB,IAAI,CAAC,IAAI,CAAC,MAAM,EACZ,MAAM,IAAIA,MAAM;QAEpB,OAAO,IAAI,CAAC,MAAM;IACtB;IAEA,IAAI,WAA0B;QAC1B,IAAI,CAAC,IAAI,CAAC,SAAS,EACf,MAAM,IAAIA,MAAM;QAEpB,OAAO,IAAI,CAAC,SAAS;IACzB;IAEA,SAASC,KAAwB,EAAQ;QACrC,IAAI,CAAC,MAAM,GAAGA;IAClB;IAEA,UAAUC,MAAmB,EAAQ;QACjC,IAAI,CAAC,OAAO,GAAGA;IACnB;IAEA,SAASC,KAAa,EAAQ;QAC1B,IAAI,CAAC,MAAM,GAAGA;IAClB;IAEA,YAAYC,QAAuB,EAAQ;QACvC,IAAI,CAAC,SAAS,GAAGA;IACrB;IAEA,QAAc;QACV,IAAI,CAAC,MAAM,GAAGC;QACd,IAAI,CAAC,OAAO,GAAGA;QACf,IAAI,CAAC,MAAM,GAAGA;IAClB;AACJ;AAEO,MAAMC,4CAAuBC,qBAAAA,oBAAgC,CAAC;IACjE,gBAAgBR;IAChB,cAAc,EAAE;AACpB"}

package/api/features/TaskExecutionContext/abstractions.d.ts

@@ -0,0 +1,26 @@
+import type { ITimer } from "@webiny/handler-aws";
+import type { ITaskManagerStore } from "../../../api/runner/abstractions/TaskManagerStore.js";
+import type { ITaskRunner } from "../../../api/runner/abstractions/TaskRunner.js";
+import type { ITaskResponse } from "../../../api/response/abstractions/index.js";
+/**
+ * TaskExecutionContext holds runtime state for the currently executing task.
+ * Properties are set by TaskRunner before task execution.
+ *
+ * This is registered as a singleton in the DI container with empty values,
+ * then populated at runtime by TaskControl before executing each task.
+ */
+export interface ITaskExecutionContext {
+    readonly store: ITaskManagerStore;
+    readonly runner: ITaskRunner;
+    readonly timer: ITimer;
+    readonly response: ITaskResponse;
+    setStore(store: ITaskManagerStore): void;
+    setRunner(runner: ITaskRunner): void;
+    setTimer(timer: ITimer): void;
+    setResponse(response: ITaskResponse): void;
+    clear(): void;
+}
+export declare const TaskExecutionContext: import("@webiny/di").Abstraction<ITaskExecutionContext>;
+export declare namespace TaskExecutionContext {
+    type Interface = ITaskExecutionContext;
+}

package/api/features/TaskExecutionContext/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/TaskExecutionContext/abstractions.js","sources":["../../../../src/api/features/TaskExecutionContext/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { ITimer } from \"@webiny/handler-aws\";\nimport type { ITaskManagerStore } from \"~/api/runner/abstractions/TaskManagerStore.js\";\nimport type { ITaskRunner } from \"~/api/runner/abstractions/TaskRunner.js\";\nimport type { ITaskResponse } from \"~/api/response/abstractions/index.js\";\n\n/**\n * TaskExecutionContext holds runtime state for the currently executing task.\n * Properties are set by TaskRunner before task execution.\n *\n * This is registered as a singleton in the DI container with empty values,\n * then populated at runtime by TaskControl before executing each task.\n */\nexport interface ITaskExecutionContext {\n    // Getters - may throw if not set\n    readonly store: ITaskManagerStore;\n    readonly runner: ITaskRunner;\n    readonly timer: ITimer;\n    readonly response: ITaskResponse;\n\n    // Setters - called by TaskControl\n    setStore(store: ITaskManagerStore): void;\n    setRunner(runner: ITaskRunner): void;\n    setTimer(timer: ITimer): void;\n    setResponse(response: ITaskResponse): void;\n\n    // Clear after execution\n    clear(): void;\n}\n\nexport const TaskExecutionContext =\n    createAbstraction<ITaskExecutionContext>(\"TaskExecutionContext\");\n\nexport namespace TaskExecutionContext {\n    export type Interface = ITaskExecutionContext;\n}\n"],"names":["TaskExecutionContext","createAbstraction"],"mappings":";AA8BO,MAAMA,uBACTC,kBAAyC"}

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

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

package/api/features/TaskExecutionContext/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/TaskExecutionContext/feature.js","sources":["../../../../src/api/features/TaskExecutionContext/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { TaskExecutionContext } from \"./TaskExecutionContext.js\";\n\nexport const TaskExecutionContextFeature = createFeature({\n    name: \"TaskExecutionContext\",\n    register(container) {\n        container.register(TaskExecutionContext).inSingletonScope();\n    }\n});\n"],"names":["TaskExecutionContextFeature","createFeature","container","TaskExecutionContext"],"mappings":";;AAGO,MAAMA,8BAA8BC,cAAc;IACrD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,sBAAsB,gBAAgB;IAC7D;AACJ"}

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

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

package/api/features/TaskExecutionContext/index.js

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

package/api/features/TriggerTask/TriggerTaskUseCase.d.ts

@@ -0,0 +1,10 @@
+import { Result } from "@webiny/feature/api";
+import { TriggerTaskUseCase 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 TriggerTaskUseCaseImpl implements UseCaseAbstraction.Interface {
+    private context;
+    constructor(context: Context);
+    execute<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends TaskService.GenericOutput = TaskService.GenericOutput>(params: UseCaseAbstraction.Params<I>): Promise<Result<TaskService.Task<I, O>, UseCaseAbstraction.Error>>;
+}

package/api/features/TriggerTask/TriggerTaskUseCase.js

@@ -0,0 +1,12 @@
+class TriggerTaskUseCaseImpl {
+    constructor(context){
+        this.context = context;
+    }
+    async execute(params) {
+        const result = await this.context.tasks.trigger(params);
+        return result;
+    }
+}
+export { TriggerTaskUseCaseImpl };
+
+//# sourceMappingURL=TriggerTaskUseCase.js.map

package/api/features/TriggerTask/TriggerTaskUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/TriggerTask/TriggerTaskUseCase.js","sources":["../../../../src/api/features/TriggerTask/TriggerTaskUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { TriggerTaskUseCase 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 TriggerTaskUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(private context: Context) {}\n\n    public async execute<\n        I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends TaskService.GenericOutput = TaskService.GenericOutput\n    >(\n        params: UseCaseAbstraction.Params<I>\n    ): Promise<Result<TaskService.Task<I, O>, UseCaseAbstraction.Error>> {\n        const result = await this.context.tasks.trigger<I, O>(params);\n\n        return result as unknown as Promise<\n            Result<TaskService.Task<I, O>, UseCaseAbstraction.Error>\n        >;\n    }\n}\n"],"names":["TriggerTaskUseCaseImpl","context","params","result"],"mappings":"AAMO,MAAMA;IACT,YAA2BC,OAAgB,CAAE;aAAlBA,OAAO,GAAPA;IAAmB;IAE9C,MAAa,QAITC,MAAoC,EAC6B;QACjE,MAAMC,SAAS,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAOD;QAEtD,OAAOC;IAGX;AACJ"}

package/api/features/TriggerTask/abstractions.d.ts

@@ -0,0 +1,28 @@
+import { Result } from "@webiny/feature/api";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { TaskDefinitionNotFoundError, TaskNotFoundError, TaskServiceInfoError } from "../../../api/domain/errors.js";
+export interface ITriggerTaskUseCase {
+    execute<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends TaskService.GenericOutput = TaskService.GenericOutput>(params: TriggerTaskParams<I>): Promise<Result<TaskService.Task<I, O>, UseCaseError>>;
+}
+export interface TriggerTaskParams<I = TaskDefinition.TaskInput> {
+    definition: string;
+    input?: I;
+    name?: string;
+    parent?: Pick<TaskService.Task, "id">;
+    delay?: number;
+}
+export interface ITriggerTaskUseCaseErrors {
+    definitionNotFound: TaskDefinitionNotFoundError;
+    taskNotFound: TaskNotFoundError;
+    serviceError: TaskServiceInfoError;
+}
+type UseCaseError = ITriggerTaskUseCaseErrors[keyof ITriggerTaskUseCaseErrors];
+export declare const TriggerTaskUseCase: import("@webiny/di").Abstraction<ITriggerTaskUseCase>;
+export declare namespace TriggerTaskUseCase {
+    type Interface = ITriggerTaskUseCase;
+    type Params<I = TaskDefinition.TaskInput> = TriggerTaskParams<I>;
+    type Error = UseCaseError;
+    type Return<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends TaskService.GenericOutput = TaskService.GenericOutput> = Promise<Result<TaskService.Task<I, O>, UseCaseError>>;
+}
+export {};

package/api/features/TriggerTask/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/TriggerTask/abstractions.js","sources":["../../../../src/api/features/TriggerTask/abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport {\n    TaskDefinitionNotFoundError,\n    TaskNotFoundError,\n    TaskServiceInfoError\n} from \"~/api/domain/errors.js\";\n\nexport interface ITriggerTaskUseCase {\n    execute<\n        I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends TaskService.GenericOutput = TaskService.GenericOutput\n    >(\n        params: TriggerTaskParams<I>\n    ): Promise<Result<TaskService.Task<I, O>, UseCaseError>>;\n}\n\nexport interface TriggerTaskParams<I = TaskDefinition.TaskInput> {\n    definition: string;\n    input?: I;\n    name?: string;\n    parent?: Pick<TaskService.Task, \"id\">;\n    delay?: number;\n}\n\nexport interface ITriggerTaskUseCaseErrors {\n    definitionNotFound: TaskDefinitionNotFoundError;\n    taskNotFound: TaskNotFoundError;\n    serviceError: TaskServiceInfoError;\n}\n\ntype UseCaseError = ITriggerTaskUseCaseErrors[keyof ITriggerTaskUseCaseErrors];\n\nexport const TriggerTaskUseCase = createAbstraction<ITriggerTaskUseCase>(\n    \"Tasks/TriggerTaskUseCase\"\n);\n\nexport namespace TriggerTaskUseCase {\n    export type Interface = ITriggerTaskUseCase;\n    export type Params<I = TaskDefinition.TaskInput> = TriggerTaskParams<I>;\n\n    export type Error = UseCaseError;\n    export type Return<\n        I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends TaskService.GenericOutput = TaskService.GenericOutput\n    > = Promise<Result<TaskService.Task<I, O>, UseCaseError>>;\n}\n"],"names":["TriggerTaskUseCase","createAbstraction"],"mappings":";AAkCO,MAAMA,qBAAqBC,kBAC9B"}

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

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

package/api/features/TriggerTask/feature.js

@@ -0,0 +1,12 @@
+import { createFeature } from "@webiny/feature/api";
+import { TriggerTaskUseCase } from "./abstractions.js";
+import { TriggerTaskUseCaseImpl } from "./TriggerTaskUseCase.js";
+const TriggerTaskFeature = createFeature({
+    name: "TriggerTask",
+    register (container, context) {
+        container.registerInstance(TriggerTaskUseCase, new TriggerTaskUseCaseImpl(context));
+    }
+});
+export { TriggerTaskFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/TriggerTask/feature.js","sources":["../../../../src/api/features/TriggerTask/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { TriggerTaskUseCase } from \"./abstractions.js\";\nimport { TriggerTaskUseCaseImpl } from \"~/api/features/TriggerTask/TriggerTaskUseCase.js\";\nimport type { Context } from \"~/api/types.js\";\n\nexport const TriggerTaskFeature = createFeature<Context>({\n    name: \"TriggerTask\",\n    register(container, context) {\n        container.registerInstance(TriggerTaskUseCase, new TriggerTaskUseCaseImpl(context!));\n    }\n});\n"],"names":["TriggerTaskFeature","createFeature","container","context","TriggerTaskUseCase","TriggerTaskUseCaseImpl"],"mappings":";;;AAKO,MAAMA,qBAAqBC,cAAuB;IACrD,MAAM;IACN,UAASC,SAAS,EAAEC,OAAO;QACvBD,UAAU,gBAAgB,CAACE,oBAAoB,IAAIC,uBAAuBF;IAC9E;AACJ"}

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

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

package/api/features/TriggerTask/index.js

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

package/api/features/UpdateBackgroundTaskSettings/UpdateBackgroundTaskSettingsRepository.d.ts

@@ -0,0 +1,23 @@
+import { Result } from "@webiny/feature/api";
+import { GetModelRepository } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { GetLatestRevisionByEntryIdRepository } from "@webiny/api-headless-cms/features/contentEntry/GetLatestRevisionByEntryId/index.js";
+import { UpdateEntryRepository } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { UpdateEntryDataFactory } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+import { BuildParams } from "@webiny/api-core/features/buildParams/index.js";
+import { GetBackgroundTaskSettingsRepository } from "../../../api/features/GetBackgroundTaskSettings/abstractions.js";
+import { UpdateBackgroundTaskSettingsRepository as RepositoryAbstraction, type IUpdateBackgroundTaskSettingsInput } from "./abstractions.js";
+import type { IBackgroundTaskSettings } from "../../../api/domain/BackgroundTaskSettings.js";
+declare class UpdateBackgroundTaskSettingsRepositoryImpl implements RepositoryAbstraction.Interface {
+    private readonly getModelRepository;
+    private readonly getSettingsRepository;
+    private readonly getLatestRevisionRepository;
+    private readonly updateEntryRepository;
+    private readonly updateEntryDataFactory;
+    private readonly defaultRetentionDays;
+    constructor(getModelRepository: GetModelRepository.Interface, getSettingsRepository: GetBackgroundTaskSettingsRepository.Interface, getLatestRevisionRepository: GetLatestRevisionByEntryIdRepository.Interface, updateEntryRepository: UpdateEntryRepository.Interface, updateEntryDataFactory: UpdateEntryDataFactory.Interface, buildParams: BuildParams.Interface);
+    execute(input: IUpdateBackgroundTaskSettingsInput): Promise<Result<IBackgroundTaskSettings, RepositoryAbstraction.Error>>;
+}
+export declare const UpdateBackgroundTaskSettingsRepository: typeof UpdateBackgroundTaskSettingsRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateBackgroundTaskSettingsRepository>;
+};
+export {};

package/api/features/UpdateBackgroundTaskSettings/UpdateBackgroundTaskSettingsRepository.js

@@ -0,0 +1,64 @@
+import { Result } from "@webiny/feature/api";
+import { createCacheKey } from "@webiny/utils";
+import { GetModelRepository } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { GetLatestRevisionByEntryIdRepository } from "@webiny/api-headless-cms/features/contentEntry/GetLatestRevisionByEntryId/index.js";
+import { UpdateEntryRepository } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { UpdateEntryDataFactory } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+import { BuildParams } from "@webiny/api-core/features/buildParams/index.js";
+import { GetBackgroundTaskSettingsRepository } from "../GetBackgroundTaskSettings/abstractions.js";
+import { UpdateBackgroundTaskSettingsRepository } from "./abstractions.js";
+import { BackgroundTaskModelNotFoundError, BackgroundTaskPersistenceError } from "../../domain/errors.js";
+import { BACKGROUND_TASK_DEFAULT_RETENTION_DAYS, BACKGROUND_TASK_SETTINGS_MODEL_ID } from "../../domain/constants.js";
+class UpdateBackgroundTaskSettingsRepositoryImpl {
+    constructor(getModelRepository, getSettingsRepository, getLatestRevisionRepository, updateEntryRepository, updateEntryDataFactory, buildParams){
+        this.getModelRepository = getModelRepository;
+        this.getSettingsRepository = getSettingsRepository;
+        this.getLatestRevisionRepository = getLatestRevisionRepository;
+        this.updateEntryRepository = updateEntryRepository;
+        this.updateEntryDataFactory = updateEntryDataFactory;
+        this.defaultRetentionDays = buildParams.get("BackgroundTasks.RetentionDays") ?? BACKGROUND_TASK_DEFAULT_RETENTION_DAYS;
+    }
+    async execute(input) {
+        try {
+            const getResult = await this.getSettingsRepository.execute();
+            if (getResult.isFail()) return getResult;
+            const modelResult = await this.getModelRepository.execute(BACKGROUND_TASK_SETTINGS_MODEL_ID);
+            if (modelResult.isFail()) return Result.fail(new BackgroundTaskModelNotFoundError(BACKGROUND_TASK_SETTINGS_MODEL_ID));
+            const model = modelResult.value;
+            const singletonId = createCacheKey(model.modelId);
+            const entryId = `${singletonId}#0001`;
+            const entryResult = await this.getLatestRevisionRepository.execute(model, {
+                id: entryId
+            });
+            if (entryResult.isFail()) return Result.fail(BackgroundTaskPersistenceError.from(entryResult.error));
+            const storedValue = input.retentionDays === this.defaultRetentionDays ? null : input.retentionDays;
+            const { entry } = await this.updateEntryDataFactory.create(model, {
+                values: {
+                    retentionDays: storedValue
+                }
+            }, entryResult.value);
+            const updateResult = await this.updateEntryRepository.execute(model, entry);
+            if (updateResult.isFail()) return Result.fail(BackgroundTaskPersistenceError.from(updateResult.error));
+            const settings = {
+                retentionDays: entry.values.retentionDays ?? this.defaultRetentionDays
+            };
+            return Result.ok(settings);
+        } catch (error) {
+            return Result.fail(BackgroundTaskPersistenceError.from(error));
+        }
+    }
+}
+const UpdateBackgroundTaskSettingsRepository_UpdateBackgroundTaskSettingsRepository = UpdateBackgroundTaskSettingsRepository.createImplementation({
+    implementation: UpdateBackgroundTaskSettingsRepositoryImpl,
+    dependencies: [
+        GetModelRepository,
+        GetBackgroundTaskSettingsRepository,
+        GetLatestRevisionByEntryIdRepository,
+        UpdateEntryRepository,
+        UpdateEntryDataFactory,
+        BuildParams
+    ]
+});
+export { UpdateBackgroundTaskSettingsRepository_UpdateBackgroundTaskSettingsRepository as UpdateBackgroundTaskSettingsRepository };
+
+//# sourceMappingURL=UpdateBackgroundTaskSettingsRepository.js.map

package/api/features/UpdateBackgroundTaskSettings/UpdateBackgroundTaskSettingsRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/UpdateBackgroundTaskSettings/UpdateBackgroundTaskSettingsRepository.js","sources":["../../../../src/api/features/UpdateBackgroundTaskSettings/UpdateBackgroundTaskSettingsRepository.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 { UpdateEntryRepository } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js\";\nimport { UpdateEntryDataFactory } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\nimport { BuildParams } from \"@webiny/api-core/features/buildParams/index.js\";\nimport { GetBackgroundTaskSettingsRepository } from \"~/api/features/GetBackgroundTaskSettings/abstractions.js\";\nimport {\n    UpdateBackgroundTaskSettingsRepository as RepositoryAbstraction,\n    type IUpdateBackgroundTaskSettingsInput\n} 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 | null;\n}\n\nclass UpdateBackgroundTaskSettingsRepositoryImpl implements RepositoryAbstraction.Interface {\n    private readonly defaultRetentionDays: number;\n\n    constructor(\n        private readonly getModelRepository: GetModelRepository.Interface,\n        private readonly getSettingsRepository: GetBackgroundTaskSettingsRepository.Interface,\n        private readonly getLatestRevisionRepository: GetLatestRevisionByEntryIdRepository.Interface,\n        private readonly updateEntryRepository: UpdateEntryRepository.Interface,\n        private readonly updateEntryDataFactory: UpdateEntryDataFactory.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(\n        input: IUpdateBackgroundTaskSettingsInput\n    ): Promise<Result<IBackgroundTaskSettings, RepositoryAbstraction.Error>> {\n        try {\n            /* Ensure the singleton entry exists (creates if missing). */\n            const getResult = await this.getSettingsRepository.execute();\n            if (getResult.isFail()) {\n                return getResult;\n            }\n\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.isFail()) {\n                return Result.fail(BackgroundTaskPersistenceError.from(entryResult.error));\n            }\n\n            /* Store null when the value matches the default so the default stays in control. */\n            const storedValue =\n                input.retentionDays === this.defaultRetentionDays ? null : input.retentionDays;\n\n            const { entry } =\n                await this.updateEntryDataFactory.create<BackgroundTaskSettingsValues>(\n                    model,\n                    {\n                        values: {\n                            retentionDays: storedValue\n                        }\n                    },\n                    entryResult.value\n                );\n\n            const updateResult = await this.updateEntryRepository.execute(model, entry);\n            if (updateResult.isFail()) {\n                return Result.fail(BackgroundTaskPersistenceError.from(updateResult.error));\n            }\n\n            const settings: IBackgroundTaskSettings = {\n                retentionDays: entry.values.retentionDays ?? this.defaultRetentionDays\n            };\n\n            return Result.ok(settings);\n        } catch (error) {\n            return Result.fail(BackgroundTaskPersistenceError.from(error));\n        }\n    }\n}\n\nexport const UpdateBackgroundTaskSettingsRepository = RepositoryAbstraction.createImplementation({\n    implementation: UpdateBackgroundTaskSettingsRepositoryImpl,\n    dependencies: [\n        GetModelRepository,\n        GetBackgroundTaskSettingsRepository,\n        GetLatestRevisionByEntryIdRepository,\n        UpdateEntryRepository,\n        UpdateEntryDataFactory,\n        BuildParams\n    ]\n});\n"],"names":["UpdateBackgroundTaskSettingsRepositoryImpl","getModelRepository","getSettingsRepository","getLatestRevisionRepository","updateEntryRepository","updateEntryDataFactory","buildParams","BACKGROUND_TASK_DEFAULT_RETENTION_DAYS","input","getResult","modelResult","BACKGROUND_TASK_SETTINGS_MODEL_ID","Result","BackgroundTaskModelNotFoundError","model","singletonId","createCacheKey","entryId","entryResult","BackgroundTaskPersistenceError","storedValue","entry","updateResult","settings","error","UpdateBackgroundTaskSettingsRepository","RepositoryAbstraction","GetModelRepository","GetBackgroundTaskSettingsRepository","GetLatestRevisionByEntryIdRepository","UpdateEntryRepository","UpdateEntryDataFactory","BuildParams"],"mappings":";;;;;;;;;;;AA0BA,MAAMA;IAGF,YACqBC,kBAAgD,EAChDC,qBAAoE,EACpEC,2BAA2E,EAC3EC,qBAAsD,EACtDC,sBAAwD,EACzEC,WAAkC,CACpC;aANmBL,kBAAkB,GAAlBA;aACAC,qBAAqB,GAArBA;aACAC,2BAA2B,GAA3BA;aACAC,qBAAqB,GAArBA;aACAC,sBAAsB,GAAtBA;QAGjB,IAAI,CAAC,oBAAoB,GACrBC,YAAY,GAAG,CAAS,oCACxBC;IACR;IAEA,MAAM,QACFC,KAAyC,EAC4B;QACrE,IAAI;YAEA,MAAMC,YAAY,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO;YAC1D,IAAIA,UAAU,MAAM,IAChB,OAAOA;YAGX,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,MAAM,IAClB,OAAON,OAAO,IAAI,CAACO,+BAA+B,IAAI,CAACD,YAAY,KAAK;YAI5E,MAAME,cACFZ,MAAM,aAAa,KAAK,IAAI,CAAC,oBAAoB,GAAG,OAAOA,MAAM,aAAa;YAElF,MAAM,EAAEa,KAAK,EAAE,GACX,MAAM,IAAI,CAAC,sBAAsB,CAAC,MAAM,CACpCP,OACA;gBACI,QAAQ;oBACJ,eAAeM;gBACnB;YACJ,GACAF,YAAY,KAAK;YAGzB,MAAMI,eAAe,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAACR,OAAOO;YACrE,IAAIC,aAAa,MAAM,IACnB,OAAOV,OAAO,IAAI,CAACO,+BAA+B,IAAI,CAACG,aAAa,KAAK;YAG7E,MAAMC,WAAoC;gBACtC,eAAeF,MAAM,MAAM,CAAC,aAAa,IAAI,IAAI,CAAC,oBAAoB;YAC1E;YAEA,OAAOT,OAAO,EAAE,CAACW;QACrB,EAAE,OAAOC,OAAO;YACZ,OAAOZ,OAAO,IAAI,CAACO,+BAA+B,IAAI,CAACK;QAC3D;IACJ;AACJ;AAEO,MAAMC,gFAAyCC,uCAAAA,oBAA0C,CAAC;IAC7F,gBAAgB1B;IAChB,cAAc;QACV2B;QACAC;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

package/api/features/UpdateBackgroundTaskSettings/UpdateBackgroundTaskSettingsUseCase.d.ts

@@ -0,0 +1,14 @@
+import { Result } from "@webiny/feature/api";
+import { UpdateBackgroundTaskSettingsRepository, UpdateBackgroundTaskSettingsUseCase as UseCaseAbstraction } from "./abstractions.js";
+import type { IBackgroundTaskSettings } from "../../../api/domain/BackgroundTaskSettings.js";
+import { BackgroundTaskPermissions } from "../../../api/features/BackgroundTaskPermissions/abstractions.js";
+declare class UpdateBackgroundTaskSettingsUseCaseImpl implements UseCaseAbstraction.Interface {
+    private readonly permissions;
+    private readonly repository;
+    constructor(permissions: BackgroundTaskPermissions.Interface, repository: UpdateBackgroundTaskSettingsRepository.Interface);
+    execute(input: UseCaseAbstraction.Input): Promise<Result<IBackgroundTaskSettings, UseCaseAbstraction.Error>>;
+}
+export declare const UpdateBackgroundTaskSettingsUseCase: typeof UpdateBackgroundTaskSettingsUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateBackgroundTaskSettingsUseCase>;
+};
+export {};

package/api/features/UpdateBackgroundTaskSettings/UpdateBackgroundTaskSettingsUseCase.js

@@ -0,0 +1,27 @@
+import { Result } from "@webiny/feature/api";
+import { UpdateBackgroundTaskSettingsRepository, UpdateBackgroundTaskSettingsUseCase } from "./abstractions.js";
+import { UpdateBackgroundTaskSettingsInputSchema } from "./schema.js";
+import { BackgroundTaskNotAuthorizedError, BackgroundTaskValidationError } from "../../domain/errors.js";
+import { BackgroundTaskPermissions } from "../BackgroundTaskPermissions/abstractions.js";
+class UpdateBackgroundTaskSettingsUseCaseImpl {
+    constructor(permissions, repository){
+        this.permissions = permissions;
+        this.repository = repository;
+    }
+    async execute(input) {
+        if (!await this.permissions.canEdit("task")) return Result.fail(new BackgroundTaskNotAuthorizedError());
+        const parsed = UpdateBackgroundTaskSettingsInputSchema.safeParse(input);
+        if (!parsed.success) return Result.fail(new BackgroundTaskValidationError(parsed.error));
+        return this.repository.execute(parsed.data);
+    }
+}
+const UpdateBackgroundTaskSettingsUseCase_UpdateBackgroundTaskSettingsUseCase = UpdateBackgroundTaskSettingsUseCase.createImplementation({
+    implementation: UpdateBackgroundTaskSettingsUseCaseImpl,
+    dependencies: [
+        BackgroundTaskPermissions,
+        UpdateBackgroundTaskSettingsRepository
+    ]
+});
+export { UpdateBackgroundTaskSettingsUseCase_UpdateBackgroundTaskSettingsUseCase as UpdateBackgroundTaskSettingsUseCase };
+
+//# sourceMappingURL=UpdateBackgroundTaskSettingsUseCase.js.map