@webiny/background-tasks 0.0.0-unstable.0156a4c312

package/api/features/TaskService/BackgroundTaskService.js

@@ -0,0 +1,191 @@
+import error from "@webiny/error";
+import { Result } from "@webiny/feature/api";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import { NotFoundError } from "@webiny/api-graphql";
+import { TaskService as TaskService_js_TaskService } from "../../domain/TaskService.js";
+import { GetTaskUseCase } from "../GetTask/index.js";
+import { CreateTaskLogUseCase } from "../CreateTaskLog/index.js";
+import { GetLatestTaskLogUseCase } from "../GetLatestTaskLog/index.js";
+import { UpdateTaskLogUseCase } from "../UpdateTaskLog/index.js";
+import { CreateTaskUseCase } from "../CreateTask/index.js";
+import { UpdateTaskUseCase } from "../UpdateTask/index.js";
+import { DeleteTaskUseCase } from "../DeleteTask/index.js";
+import { GetRunnableTaskDefinitionUseCase } from "../GetRunnableTaskDefinition/index.js";
+import { TaskAbortError, TaskDefinitionNotFoundError, TaskNotFoundError, TaskServiceInfoError } from "../../domain/errors.js";
+import { TaskDataStatus, TaskLogItemType } from "../../types.js";
+const MAX_DELAY_DAYS = 355;
+const MAX_DELAY_SECONDS = 24 * MAX_DELAY_DAYS * 3600;
+const validateDelay = (input, delay)=>{
+    if (!delay || delay < 0 || false === Number.isInteger(delay)) return;
+    else if (delay < MAX_DELAY_SECONDS) return;
+    throw new error(`The maximum delay for a task is ${MAX_DELAY_DAYS} days.`, "MAX_DELAY_ERROR", {
+        ...input,
+        delay
+    });
+};
+class BackgroundTaskServiceImpl {
+    constructor(getDefinition, createTask, updateTask, deleteTask, getTask, getLatestTaskLog, createTaskLog, updateTaskLog, transports, logger){
+        this.getDefinition = getDefinition;
+        this.createTask = createTask;
+        this.updateTask = updateTask;
+        this.deleteTask = deleteTask;
+        this.getTask = getTask;
+        this.getLatestTaskLog = getLatestTaskLog;
+        this.createTaskLog = createTaskLog;
+        this.updateTaskLog = updateTaskLog;
+        this.transports = transports;
+        this.logger = logger;
+    }
+    async trigger(params) {
+        const transport = this.getTransport();
+        const { definition: id, input: inputValues, name, parent, delay = 0 } = params;
+        const definitionResult = this.getDefinition.execute(id);
+        if (definitionResult.isFail()) throw new error("Task definition was not found!", "TASK_DEFINITION_ERROR", {
+            id
+        });
+        const definition = definitionResult.value;
+        const input = {
+            name: name || definition.title,
+            definitionId: id,
+            input: inputValues || {},
+            parentId: parent?.id
+        };
+        if (definition.onBeforeTrigger) await definition.onBeforeTrigger({
+            data: input,
+            definition
+        });
+        validateDelay(input, delay);
+        const created = await this.createTask.execute(input);
+        if (created.isFail()) {
+            this.logger.error({
+                error: created.error
+            }, "Could not create the task.");
+            throw created.error;
+        }
+        const task = created.value;
+        let response = null;
+        try {
+            response = await transport.send(task, delay);
+            if (!response) throw new error("Could not trigger the step function!", "TRIGGER_STEP_FUNCTION_ERROR", {
+                task
+            });
+        } catch (ex) {
+            this.logger.error({
+                error: ex
+            }, "Could not trigger the step function.");
+            await this.deleteTask.execute(task.id);
+            throw ex;
+        }
+        const updated = await this.updateTask.execute(task.id, {
+            eventResponse: response
+        });
+        if (updated.isFail()) throw updated.error;
+        return Result.ok(updated.value);
+    }
+    async fetchServiceInfo(input) {
+        const transport = this.getTransport();
+        const task = "object" == typeof input ? input : await this.findTask(input);
+        if (task || "string" != typeof input) {
+            if (!task) throw new error("Task was not found!", "TASK_FETCH_ERROR", {
+                input
+            });
+        } else throw new NotFoundError(`Task "${input}" was not found!`);
+        try {
+            const info = await transport.fetch(task);
+            if (info) return Result.ok(info);
+            return Result.fail(new TaskServiceInfoError());
+        } catch (ex) {
+            this.logger.error({
+                error: ex
+            }, "Service fetch error.");
+            return Result.fail(new TaskServiceInfoError());
+        }
+    }
+    async abort(params) {
+        const taskResult = await this.getTask.execute(params.id);
+        if (taskResult.isFail()) return Result.fail(taskResult.error);
+        const task = taskResult.value;
+        const definitionResult = this.getDefinition.execute(task.definitionId);
+        if (definitionResult.isFail()) return Result.fail(new TaskDefinitionNotFoundError(task.definitionId));
+        const definition = definitionResult.value;
+        if (false === [
+            TaskDataStatus.PENDING,
+            TaskDataStatus.RUNNING
+        ].includes(task.taskStatus)) return Result.fail(new TaskAbortError({
+            id: params.id,
+            status: task.taskStatus
+        }));
+        const taskLog = await this.getOrCreateLog(task);
+        try {
+            const updated = await this.updateTask.execute(task.id, {
+                taskStatus: TaskDataStatus.ABORTED
+            });
+            if (updated.isFail()) throw updated.error;
+            const logUpdate = await this.updateTaskLog.execute(taskLog.id, {
+                items: taskLog.items.concat([
+                    {
+                        message: params.message || "Task aborted.",
+                        type: TaskLogItemType.INFO,
+                        createdOn: new Date().toISOString()
+                    }
+                ])
+            });
+            if (logUpdate.isFail()) throw logUpdate.error;
+            if (definition.onAbort) await definition.onAbort({
+                task: updated.value,
+                definition
+            });
+            return Result.ok(updated.value);
+        } catch (ex) {
+            throw new error("Could not abort the task!", "TASK_ABORT_ERROR", {
+                id: params.id,
+                message: ex.message
+            });
+        }
+    }
+    async findTask(id) {
+        const result = await this.getTask.execute(id);
+        if (result.isOk()) return result.value;
+        else if (result.error instanceof TaskNotFoundError) return null;
+        throw result.error;
+    }
+    getTransport() {
+        const transport = this.transports[this.transports.length - 1];
+        if (!transport) throw new error("Missing TaskService.", "TASK_SERVICE_ERROR");
+        return transport;
+    }
+    async getOrCreateLog(task) {
+        const latest = await this.getLatestTaskLog.execute(task.id);
+        if (latest.isOk()) return latest.value;
+        const created = await this.createTaskLog.execute(task, {
+            iteration: 1,
+            executionName: task.executionName
+        });
+        if (created.isFail()) throw created.error;
+        return created.value;
+    }
+}
+const BackgroundTaskService = TaskService.createImplementation({
+    implementation: BackgroundTaskServiceImpl,
+    dependencies: [
+        GetRunnableTaskDefinitionUseCase,
+        CreateTaskUseCase,
+        UpdateTaskUseCase,
+        DeleteTaskUseCase,
+        GetTaskUseCase,
+        GetLatestTaskLogUseCase,
+        CreateTaskLogUseCase,
+        UpdateTaskLogUseCase,
+        [
+            TaskService_js_TaskService,
+            {
+                multiple: true
+            }
+        ],
+        Logger
+    ]
+});
+export { BackgroundTaskService };
+
+//# sourceMappingURL=BackgroundTaskService.js.map

package/api/features/TaskService/BackgroundTaskService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/TaskService/BackgroundTaskService.js","sources":["../../../../src/api/features/TaskService/BackgroundTaskService.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { BaseError, Result } from \"@webiny/feature/api\";\nimport { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport type {\n    IServiceInfo,\n    ITaskAbortParams,\n    ITaskTriggerParams\n} from \"@webiny/api-core/features/task/TaskService/abstractions.js\";\nimport type { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { NotFoundError } from \"@webiny/api-graphql\";\nimport { TaskService as TaskTransport } from \"~/api/domain/TaskService.js\";\nimport { GetTaskUseCase } from \"~/api/features/GetTask/index.js\";\nimport { CreateTaskLogUseCase } from \"~/api/features/CreateTaskLog/index.js\";\nimport { GetLatestTaskLogUseCase } from \"~/api/features/GetLatestTaskLog/index.js\";\nimport { UpdateTaskLogUseCase } from \"~/api/features/UpdateTaskLog/index.js\";\nimport { CreateTaskUseCase } from \"~/api/features/CreateTask/index.js\";\nimport { UpdateTaskUseCase } from \"~/api/features/UpdateTask/index.js\";\nimport { DeleteTaskUseCase } from \"~/api/features/DeleteTask/index.js\";\nimport { GetRunnableTaskDefinitionUseCase } from \"~/api/features/GetRunnableTaskDefinition/index.js\";\nimport {\n    TaskAbortError,\n    TaskDefinitionNotFoundError,\n    TaskNotFoundError,\n    TaskServiceInfoError\n} from \"~/api/domain/errors.js\";\nimport { TaskDataStatus, TaskLogItemType } from \"~/api/types.js\";\nimport type { ITaskLog } from \"~/api/types.js\";\n\ntype TaskInput = TaskService.TaskInput;\ntype TaskOutput = TaskService.GenericOutput;\n\nconst MAX_DELAY_DAYS = 355;\nconst MAX_DELAY_SECONDS = MAX_DELAY_DAYS * 24 * 60 * 60;\n\nconst validateDelay = (input: TaskDefinition.TaskCreateData<any>, delay: number): void => {\n    if (!delay || delay < 0 || Number.isInteger(delay) === false) {\n        return;\n    } else if (delay < MAX_DELAY_SECONDS) {\n        return;\n    }\n    throw new WebinyError(\n        `The maximum delay for a task is ${MAX_DELAY_DAYS} days.`,\n        \"MAX_DELAY_ERROR\",\n        { ...input, delay }\n    );\n};\n\n/**\n * The public TaskService: stores a task and hands it to the transport (Step Functions, the worker),\n * aborts a running task, and reads what the transport knows about one.\n */\nclass BackgroundTaskServiceImpl implements TaskService.Interface {\n    constructor(\n        private readonly getDefinition: GetRunnableTaskDefinitionUseCase.Interface,\n        private readonly createTask: CreateTaskUseCase.Interface,\n        private readonly updateTask: UpdateTaskUseCase.Interface,\n        private readonly deleteTask: DeleteTaskUseCase.Interface,\n        private readonly getTask: GetTaskUseCase.Interface,\n        private readonly getLatestTaskLog: GetLatestTaskLogUseCase.Interface,\n        private readonly createTaskLog: CreateTaskLogUseCase.Interface,\n        private readonly updateTaskLog: UpdateTaskLogUseCase.Interface,\n        private readonly transports: TaskTransport.Interface[],\n        private readonly logger: Logger.Interface\n    ) {}\n\n    async trigger<I extends TaskInput = TaskInput, O extends TaskOutput = TaskOutput>(\n        params: ITaskTriggerParams<I>\n    ): Promise<Result<TaskService.Task<I, O>, BaseError>> {\n        const transport = this.getTransport();\n        const { definition: id, input: inputValues, name, parent, delay = 0 } = params;\n        const definitionResult = this.getDefinition.execute(id);\n        if (definitionResult.isFail()) {\n            throw new WebinyError(`Task definition was not found!`, \"TASK_DEFINITION_ERROR\", {\n                id\n            });\n        }\n        const definition = definitionResult.value;\n        const input: TaskDefinition.TaskCreateData<I> = {\n            name: name || definition.title,\n            definitionId: id,\n            input: inputValues || ({} as I),\n            parentId: parent?.id\n        };\n\n        if (definition.onBeforeTrigger) {\n            await definition.onBeforeTrigger({ data: input, definition });\n        }\n        validateDelay(input, delay);\n\n        const created = await this.createTask.execute<I>(input);\n        if (created.isFail()) {\n            this.logger.error({ error: created.error }, \"Could not create the task.\");\n            throw created.error;\n        }\n        const task = created.value;\n\n        let response: unknown = null;\n        try {\n            response = await transport.send(task, delay);\n            if (!response) {\n                throw new WebinyError(\n                    `Could not trigger the step function!`,\n                    \"TRIGGER_STEP_FUNCTION_ERROR\",\n                    { task }\n                );\n            }\n        } catch (ex) {\n            this.logger.error({ error: ex }, \"Could not trigger the step function.\");\n            // The task can't run, so don't leave it behind as pending.\n            await this.deleteTask.execute(task.id);\n            throw ex;\n        }\n\n        const updated = await this.updateTask.execute<I, O>(task.id, {\n            eventResponse: response as Record<string, any>\n        });\n        if (updated.isFail()) {\n            throw updated.error;\n        }\n\n        return Result.ok(updated.value);\n    }\n\n    async fetchServiceInfo(\n        input: TaskService.Task | string\n    ): Promise<Result<IServiceInfo, BaseError>> {\n        const transport = this.getTransport();\n        const task = typeof input === \"object\" ? input : await this.findTask(input);\n        if (!task && typeof input === \"string\") {\n            throw new NotFoundError(`Task \"${input}\" was not found!`);\n        } else if (!task) {\n            throw new WebinyError(`Task was not found!`, \"TASK_FETCH_ERROR\", { input });\n        }\n\n        try {\n            const info = (await transport.fetch(task)) as IServiceInfo | null;\n            if (info) {\n                return Result.ok(info);\n            }\n            return Result.fail(new TaskServiceInfoError());\n        } catch (ex) {\n            this.logger.error({ error: ex }, \"Service fetch error.\");\n            return Result.fail(new TaskServiceInfoError());\n        }\n    }\n\n    async abort<I extends TaskInput = TaskInput, O extends TaskOutput = TaskOutput>(\n        params: ITaskAbortParams\n    ): Promise<Result<TaskService.Task<I, O>, BaseError<any>>> {\n        const taskResult = await this.getTask.execute<I, O>(params.id);\n        if (taskResult.isFail()) {\n            return Result.fail(taskResult.error);\n        }\n        const task = taskResult.value;\n\n        const definitionResult = this.getDefinition.execute<I, O>(task.definitionId);\n        if (definitionResult.isFail()) {\n            return Result.fail(new TaskDefinitionNotFoundError(task.definitionId));\n        }\n        const definition = definitionResult.value;\n\n        // Only a pending or running task can be aborted.\n        if ([TaskDataStatus.PENDING, TaskDataStatus.RUNNING].includes(task.taskStatus) === false) {\n            return Result.fail(new TaskAbortError({ id: params.id, status: task.taskStatus }));\n        }\n\n        const taskLog = await this.getOrCreateLog(task);\n        try {\n            const updated = await this.updateTask.execute<I, O>(task.id, {\n                taskStatus: TaskDataStatus.ABORTED\n            });\n            if (updated.isFail()) {\n                throw updated.error;\n            }\n            const logUpdate = await this.updateTaskLog.execute(taskLog.id, {\n                items: taskLog.items.concat([\n                    {\n                        message: params.message || \"Task aborted.\",\n                        type: TaskLogItemType.INFO,\n                        createdOn: new Date().toISOString()\n                    }\n                ])\n            });\n            if (logUpdate.isFail()) {\n                throw logUpdate.error;\n            }\n            // TODO: determine when to kick off the onAbort hook\n            if (definition.onAbort) {\n                await definition.onAbort({ task: updated.value, definition });\n            }\n\n            return Result.ok(updated.value);\n        } catch (ex) {\n            throw new WebinyError(`Could not abort the task!`, \"TASK_ABORT_ERROR\", {\n                id: params.id,\n                message: ex.message\n            });\n        }\n    }\n\n    // A missing task is null; any other failure is thrown, so it isn't mistaken for a missing one.\n    private async findTask(id: string): Promise<TaskService.Task | null> {\n        const result = await this.getTask.execute(id);\n        if (result.isOk()) {\n            return result.value;\n        } else if (result.error instanceof TaskNotFoundError) {\n            return null;\n        }\n        throw result.error;\n    }\n\n    private getTransport(): TaskTransport.Interface {\n        // The last registration wins, so a test or a deployment can swap the transport.\n        const transport = this.transports[this.transports.length - 1];\n        if (!transport) {\n            throw new WebinyError(\"Missing TaskService.\", \"TASK_SERVICE_ERROR\");\n        }\n        return transport;\n    }\n\n    private async getOrCreateLog(task: TaskService.Task<any, any>): Promise<ITaskLog> {\n        const latest = await this.getLatestTaskLog.execute(task.id);\n        if (latest.isOk()) {\n            return latest.value;\n        }\n        const created = await this.createTaskLog.execute(task, {\n            iteration: 1,\n            executionName: task.executionName\n        });\n        if (created.isFail()) {\n            throw created.error;\n        }\n        return created.value;\n    }\n}\n\nexport const BackgroundTaskService = TaskService.createImplementation({\n    implementation: BackgroundTaskServiceImpl,\n    dependencies: [\n        GetRunnableTaskDefinitionUseCase,\n        CreateTaskUseCase,\n        UpdateTaskUseCase,\n        DeleteTaskUseCase,\n        GetTaskUseCase,\n        GetLatestTaskLogUseCase,\n        CreateTaskLogUseCase,\n        UpdateTaskLogUseCase,\n        [TaskTransport, { multiple: true }],\n        Logger\n    ]\n});\n"],"names":["MAX_DELAY_DAYS","MAX_DELAY_SECONDS","validateDelay","input","delay","Number","WebinyError","BackgroundTaskServiceImpl","getDefinition","createTask","updateTask","deleteTask","getTask","getLatestTaskLog","createTaskLog","updateTaskLog","transports","logger","params","transport","id","inputValues","name","parent","definitionResult","definition","created","task","response","ex","updated","Result","NotFoundError","info","TaskServiceInfoError","taskResult","TaskDefinitionNotFoundError","TaskDataStatus","TaskAbortError","taskLog","logUpdate","TaskLogItemType","Date","result","TaskNotFoundError","latest","BackgroundTaskService","TaskService","GetRunnableTaskDefinitionUseCase","CreateTaskUseCase","UpdateTaskUseCase","DeleteTaskUseCase","GetTaskUseCase","GetLatestTaskLogUseCase","CreateTaskLogUseCase","UpdateTaskLogUseCase","TaskTransport","Logger"],"mappings":"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"}

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

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

package/api/features/TaskService/feature.js

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

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

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

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

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

package/api/features/TaskService/index.js

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

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

@@ -0,0 +1,9 @@
+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";
+export declare class TriggerTaskUseCaseImpl implements UseCaseAbstraction.Interface {
+    private taskService;
+    constructor(taskService: TaskService.Interface);
+    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(taskService){
+        this.taskService = taskService;
+    }
+    async execute(params) {
+        const result = await this.taskService.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\";\n\nexport class TriggerTaskUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(private taskService: TaskService.Interface) {}\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.taskService.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","taskService","params","result"],"mappings":"AAKO,MAAMA;IACT,YAA2BC,WAAkC,CAAE;aAApCA,WAAW,GAAXA;IAAqC;IAEhE,MAAa,QAITC,MAAoC,EAC6B;QACjE,MAAMC,SAAS,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAOD;QAEpD,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,4 @@
+export declare const TriggerTaskFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/api/features/TriggerTask/feature.js

@@ -0,0 +1,13 @@
+import { createFeature } from "@webiny/feature/api";
+import { TriggerTaskUseCase } from "./abstractions.js";
+import { TriggerTaskUseCaseImpl } from "./TriggerTaskUseCase.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+const TriggerTaskFeature = createFeature({
+    name: "TriggerTask",
+    register (container) {
+        container.registerFactory(TriggerTaskUseCase, ()=>new TriggerTaskUseCaseImpl(container.resolve(TaskService)));
+    }
+});
+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 { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\n\nexport const TriggerTaskFeature = createFeature({\n    name: \"TriggerTask\",\n    register(container) {\n        container.registerFactory(TriggerTaskUseCase, () => {\n            return new TriggerTaskUseCaseImpl(container.resolve(TaskService));\n        });\n    }\n});\n"],"names":["TriggerTaskFeature","createFeature","container","TriggerTaskUseCase","TriggerTaskUseCaseImpl","TaskService"],"mappings":";;;;AAKO,MAAMA,qBAAqBC,cAAc;IAC5C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,eAAe,CAACC,oBAAoB,IACnC,IAAIC,uBAAuBF,UAAU,OAAO,CAACG;IAE5D;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/TriggerVisibleTask/TriggerVisibleTaskUseCase.d.ts

@@ -0,0 +1,15 @@
+import { Result } from "@webiny/feature/api";
+import { TriggerVisibleTaskUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { TriggerTaskUseCase } from "../../../api/features/TriggerTask/abstractions.js";
+import { GetRunnableTaskDefinitionUseCase } from "../../../api/features/GetRunnableTaskDefinition/abstractions.js";
+import { TaskDefinitionNotFoundError } from "../../../api/domain/errors.js";
+declare class TriggerVisibleTaskUseCaseImpl implements UseCaseAbstraction.Interface {
+    private readonly triggerTask;
+    private readonly getRunnableTaskDefinition;
+    constructor(triggerTask: TriggerTaskUseCase.Interface, getRunnableTaskDefinition: GetRunnableTaskDefinitionUseCase.Interface);
+    execute(params: TriggerTaskUseCase.Params): Promise<Result<import("@webiny/api-core/features/task/TaskService/abstractions.js").TaskService.Task<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskInput, import("@webiny/api-core/features/task/TaskService/abstractions.js").IGenericOutput>, TaskDefinitionNotFoundError | import("~/api/domain/errors.js").TaskNotFoundError | import("~/api/domain/errors.js").TaskServiceInfoError>>;
+}
+export declare const TriggerVisibleTaskUseCase: typeof TriggerVisibleTaskUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ITriggerVisibleTaskUseCase>;
+};
+export {};

package/api/features/TriggerVisibleTask/TriggerVisibleTaskUseCase.js

@@ -0,0 +1,26 @@
+import { Result } from "@webiny/feature/api";
+import { TriggerVisibleTaskUseCase } from "./abstractions.js";
+import { TriggerTaskUseCase } from "../TriggerTask/abstractions.js";
+import { GetRunnableTaskDefinitionUseCase } from "../GetRunnableTaskDefinition/abstractions.js";
+import { TaskDefinitionNotFoundError } from "../../domain/errors.js";
+class TriggerVisibleTaskUseCaseImpl {
+    constructor(triggerTask, getRunnableTaskDefinition){
+        this.triggerTask = triggerTask;
+        this.getRunnableTaskDefinition = getRunnableTaskDefinition;
+    }
+    async execute(params) {
+        const definition = this.getRunnableTaskDefinition.execute(params.definition);
+        if (definition.isFail() || definition.value.isPrivate) return Result.fail(new TaskDefinitionNotFoundError(params.definition));
+        return this.triggerTask.execute(params);
+    }
+}
+const TriggerVisibleTaskUseCase_TriggerVisibleTaskUseCase = TriggerVisibleTaskUseCase.createImplementation({
+    implementation: TriggerVisibleTaskUseCaseImpl,
+    dependencies: [
+        TriggerTaskUseCase,
+        GetRunnableTaskDefinitionUseCase
+    ]
+});
+export { TriggerVisibleTaskUseCase_TriggerVisibleTaskUseCase as TriggerVisibleTaskUseCase };
+
+//# sourceMappingURL=TriggerVisibleTaskUseCase.js.map

package/api/features/TriggerVisibleTask/TriggerVisibleTaskUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/TriggerVisibleTask/TriggerVisibleTaskUseCase.js","sources":["../../../../src/api/features/TriggerVisibleTask/TriggerVisibleTaskUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { TriggerVisibleTaskUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { TriggerTaskUseCase } from \"~/api/features/TriggerTask/abstractions.js\";\nimport { GetRunnableTaskDefinitionUseCase } from \"~/api/features/GetRunnableTaskDefinition/abstractions.js\";\nimport { TaskDefinitionNotFoundError } from \"~/api/domain/errors.js\";\n\nclass TriggerVisibleTaskUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private readonly triggerTask: TriggerTaskUseCase.Interface,\n        private readonly getRunnableTaskDefinition: GetRunnableTaskDefinitionUseCase.Interface\n    ) {}\n\n    public async execute(params: TriggerTaskUseCase.Params) {\n        const definition = this.getRunnableTaskDefinition.execute(params.definition);\n        if (definition.isFail() || definition.value.isPrivate) {\n            return Result.fail(new TaskDefinitionNotFoundError(params.definition));\n        }\n        return this.triggerTask.execute(params);\n    }\n}\n\nexport const TriggerVisibleTaskUseCase = UseCaseAbstraction.createImplementation({\n    implementation: TriggerVisibleTaskUseCaseImpl,\n    dependencies: [TriggerTaskUseCase, GetRunnableTaskDefinitionUseCase]\n});\n"],"names":["TriggerVisibleTaskUseCaseImpl","triggerTask","getRunnableTaskDefinition","params","definition","Result","TaskDefinitionNotFoundError","TriggerVisibleTaskUseCase","UseCaseAbstraction","TriggerTaskUseCase","GetRunnableTaskDefinitionUseCase"],"mappings":";;;;;AAMA,MAAMA;IACF,YACqBC,WAAyC,EACzCC,yBAAqE,CACxF;aAFmBD,WAAW,GAAXA;aACAC,yBAAyB,GAAzBA;IAClB;IAEH,MAAa,QAAQC,MAAiC,EAAE;QACpD,MAAMC,aAAa,IAAI,CAAC,yBAAyB,CAAC,OAAO,CAACD,OAAO,UAAU;QAC3E,IAAIC,WAAW,MAAM,MAAMA,WAAW,KAAK,CAAC,SAAS,EACjD,OAAOC,OAAO,IAAI,CAAC,IAAIC,4BAA4BH,OAAO,UAAU;QAExE,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,CAACA;IACpC;AACJ;AAEO,MAAMI,sDAA4BC,0BAAAA,oBAAuC,CAAC;IAC7E,gBAAgBR;IAChB,cAAc;QAACS;QAAoBC;KAAiC;AACxE"}

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

@@ -0,0 +1,17 @@
+import type { Result } from "@webiny/feature/api";
+import type { ITask } from "../../../api/types.js";
+import type { TriggerTaskUseCase } from "../../../api/features/TriggerTask/abstractions.js";
+type UseCaseError = TriggerTaskUseCase.Error;
+export interface ITriggerVisibleTaskUseCase {
+    execute(params: TriggerTaskUseCase.Params): Promise<Result<ITask, UseCaseError>>;
+}
+/**
+ * Trigger a task from the GraphQL API. A private definition is refused exactly like an unknown
+ * one, so a caller cannot tell the two apart and cannot start it with input of their choice.
+ */
+export declare const TriggerVisibleTaskUseCase: import("@webiny/di").Abstraction<ITriggerVisibleTaskUseCase>;
+export declare namespace TriggerVisibleTaskUseCase {
+    type Interface = ITriggerVisibleTaskUseCase;
+    type Error = UseCaseError;
+}
+export {};

package/api/features/TriggerVisibleTask/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/TriggerVisibleTask/abstractions.js","sources":["../../../../src/api/features/TriggerVisibleTask/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { ITask } from \"~/api/types.js\";\nimport type { TriggerTaskUseCase } from \"~/api/features/TriggerTask/abstractions.js\";\n\ntype UseCaseError = TriggerTaskUseCase.Error;\n\nexport interface ITriggerVisibleTaskUseCase {\n    execute(params: TriggerTaskUseCase.Params): Promise<Result<ITask, UseCaseError>>;\n}\n\n/**\n * Trigger a task from the GraphQL API. A private definition is refused exactly like an unknown\n * one, so a caller cannot tell the two apart and cannot start it with input of their choice.\n */\nexport const TriggerVisibleTaskUseCase = createAbstraction<ITriggerVisibleTaskUseCase>(\n    \"Tasks/TriggerVisibleTaskUseCase\"\n);\n\nexport namespace TriggerVisibleTaskUseCase {\n    export type Interface = ITriggerVisibleTaskUseCase;\n    export type Error = UseCaseError;\n}\n"],"names":["TriggerVisibleTaskUseCase","createAbstraction"],"mappings":";AAeO,MAAMA,4BAA4BC,kBACrC"}

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

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

package/api/features/TriggerVisibleTask/feature.js

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

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

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

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

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

package/api/features/TriggerVisibleTask/index.js

@@ -0,0 +1,2 @@
+export { TriggerVisibleTaskUseCase } from "./abstractions.js";
+export { TriggerVisibleTaskFeature } 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,67 @@
+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 dataResult = await this.updateEntryDataFactory.create(model, {
+                values: {
+                    retentionDays: storedValue
+                }
+            }, entryResult.value);
+            if (dataResult.isFail()) return Result.fail(BackgroundTaskPersistenceError.from(dataResult.error));
+            const { entry } = dataResult.value;
+            const updateResult = await this.updateEntryRepository.execute(model, entry);
+            if (updateResult.isFail()) return Result.fail(BackgroundTaskPersistenceError.from(updateResult.error));
+            const retentionDays = null != entry.values.retentionDays ? entry.values.retentionDays : this.defaultRetentionDays;
+            const settings = {
+                retentionDays
+            };
+            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 dataResult =\n                await this.updateEntryDataFactory.create<BackgroundTaskSettingsValues>(\n                    model,\n                    {\n                        values: {\n                            retentionDays: storedValue\n                        }\n                    },\n                    entryResult.value\n                );\n            if (dataResult.isFail()) {\n                return Result.fail(BackgroundTaskPersistenceError.from(dataResult.error));\n            }\n            const { entry } = dataResult.value;\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 retentionDays =\n                entry.values.retentionDays != null\n                    ? entry.values.retentionDays\n                    : this.defaultRetentionDays;\n\n            const settings: IBackgroundTaskSettings = {\n                retentionDays\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","dataResult","entry","updateResult","retentionDays","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,MAAMa,aACF,MAAM,IAAI,CAAC,sBAAsB,CAAC,MAAM,CACpCP,OACA;gBACI,QAAQ;oBACJ,eAAeM;gBACnB;YACJ,GACAF,YAAY,KAAK;YAEzB,IAAIG,WAAW,MAAM,IACjB,OAAOT,OAAO,IAAI,CAACO,+BAA+B,IAAI,CAACE,WAAW,KAAK;YAE3E,MAAM,EAAEC,KAAK,EAAE,GAAGD,WAAW,KAAK;YAElC,MAAME,eAAe,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAACT,OAAOQ;YACrE,IAAIC,aAAa,MAAM,IACnB,OAAOX,OAAO,IAAI,CAACO,+BAA+B,IAAI,CAACI,aAAa,KAAK;YAG7E,MAAMC,gBACFF,AAA8B,QAA9BA,MAAM,MAAM,CAAC,aAAa,GACpBA,MAAM,MAAM,CAAC,aAAa,GAC1B,IAAI,CAAC,oBAAoB;YAEnC,MAAMG,WAAoC;gBACtCD;YACJ;YAEA,OAAOZ,OAAO,EAAE,CAACa;QACrB,EAAE,OAAOC,OAAO;YACZ,OAAOd,OAAO,IAAI,CAACO,+BAA+B,IAAI,CAACO;QAC3D;IACJ;AACJ;AAEO,MAAMC,gFAAyCC,uCAAAA,oBAA0C,CAAC;IAC7F,gBAAgB5B;IAChB,cAAc;QACV6B;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 {};