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

package/api/response/abstractions/Response.d.ts

@@ -0,0 +1,25 @@
+import type { ITaskEvent } from "../../../api/handler/types.js";
+import type { IResponseContinueParams, IResponseContinueResult } from "./ResponseContinueResult.js";
+import type { IResponseDoneParams, IResponseDoneResult } from "./ResponseDoneResult.js";
+import type { IResponseErrorParams, IResponseErrorResult } from "./ResponseErrorResult.js";
+import type { IResponseAbortedResult } from "./ResponseAbortedResult.js";
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+export type IResponseFromParams = IResponseDoneResult | IResponseContinueResult | IResponseErrorResult;
+export type IResponseResult = IResponseDoneResult | IResponseContinueResult | IResponseErrorResult | IResponseAbortedResult;
+export interface IResponse {
+    readonly event: ITaskEvent;
+    setEvent: (event: ITaskEvent) => void;
+    from: (params: IResponseFromParams) => IResponseResult;
+    done: <O extends TaskDefinition.TaskOutput = TaskDefinition.TaskOutput>(params?: IResponseDoneParams<O>) => IResponseDoneResult<O>;
+    aborted: () => IResponseAbortedResult;
+    continue: (params: IResponseContinueParams) => IResponseContinueResult;
+    error: (params: IResponseErrorParams) => IResponseErrorResult;
+}
+export interface IResponseAsync {
+    readonly response: IResponse;
+    from: (result: IResponseResult) => Promise<IResponseResult>;
+    done: (params: IResponseDoneParams) => Promise<IResponseDoneResult>;
+    continue: (params: IResponseContinueParams) => Promise<IResponseContinueResult | IResponseErrorResult>;
+    aborted: () => Promise<IResponseAbortedResult>;
+    error: (params: IResponseErrorParams) => Promise<IResponseErrorResult>;
+}

package/api/response/abstractions/ResponseAbortedResult.d.ts

@@ -0,0 +1,5 @@
+import type { IResponseBaseResult } from "../../../api/response/abstractions/ResponseBaseResult.js";
+import { TaskResultStatus } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+export interface IResponseAbortedResult extends IResponseBaseResult {
+    status: TaskResultStatus.ABORTED;
+}

package/api/response/abstractions/ResponseBaseResult.d.ts

@@ -0,0 +1,7 @@
+import { TaskResultStatus } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+export interface IResponseBaseResult {
+    status: TaskResultStatus;
+    webinyTaskId: string;
+    webinyTaskDefinitionId: string;
+    tenant: string;
+}

package/api/response/abstractions/ResponseContinueResult.d.ts

@@ -0,0 +1,21 @@
+import type { ITaskDataInput } from "../../../api/types.js";
+import type { IResponseBaseResult } from "./ResponseBaseResult.js";
+import { TaskResultStatus } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+/**
+ * Wait can be used to pause next iteration of the Lambda execution.
+ * For example, if the task is hammering the Elasticsearch cluster too much, you can use this to pause the execution for some time.
+ */
+export interface IResponseContinueParams<T = ITaskDataInput> {
+    message?: string;
+    tenant?: string;
+    webinyTaskId?: string;
+    input: T;
+    wait?: number;
+}
+export interface IResponseContinueResult<T = ITaskDataInput> extends IResponseBaseResult {
+    message?: string;
+    input: T;
+    wait?: number;
+    delay: -1;
+    status: TaskResultStatus.CONTINUE;
+}

package/api/response/abstractions/ResponseDoneResult.d.ts

@@ -0,0 +1,13 @@
+import type { IResponseBaseResult } from "./ResponseBaseResult.js";
+import { TaskDefinition, TaskResultStatus } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+export interface IResponseDoneParams<O extends TaskDefinition.TaskOutput = TaskDefinition.TaskOutput> {
+    tenant?: string;
+    webinyTaskId?: string;
+    message?: string;
+    output?: O;
+}
+export interface IResponseDoneResult<O extends TaskDefinition.TaskOutput = TaskDefinition.TaskOutput> extends IResponseBaseResult {
+    message?: string;
+    output?: O;
+    status: TaskResultStatus.DONE;
+}

package/api/response/abstractions/ResponseErrorResult.d.ts

@@ -0,0 +1,18 @@
+import type { IResponseBaseResult } from "./ResponseBaseResult.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+import { TaskResultStatus } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+export interface IResponseError {
+    message: string;
+    code?: string | null;
+    data?: GenericRecord | null;
+    stack?: string;
+}
+export interface IResponseErrorParams {
+    error: IResponseError | Error;
+    tenant?: string;
+    webinyTaskId?: string;
+}
+export interface IResponseErrorResult extends IResponseBaseResult {
+    error: IResponseError;
+    status: TaskResultStatus.ERROR;
+}

package/api/response/abstractions/TaskResponse.d.ts

@@ -0,0 +1,16 @@
+import type { IResponseError } from "./ResponseErrorResult.js";
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+export interface ITaskResponseContinueOptionsUntil {
+    date: Date;
+}
+export interface ITaskResponseContinueOptionsSeconds {
+    seconds: number;
+}
+export type ITaskResponseContinueOptions = ITaskResponseContinueOptionsUntil | ITaskResponseContinueOptionsSeconds;
+export interface ITaskResponse<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends TaskDefinition.TaskOutput = TaskDefinition.TaskOutput> {
+    done(output?: O): TaskDefinition.ResultDone<O>;
+    done(message?: string, output?: O): TaskDefinition.ResultDone<O>;
+    continue(data: I, options?: ITaskResponseContinueOptions): TaskDefinition.ResultContinue<I>;
+    error(error: IResponseError | Error | string): TaskDefinition.ResultError;
+    aborted(): TaskDefinition.ResultAborted;
+}

package/api/response/abstractions/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./Response.js";
+export * from "./ResponseContinueResult.js";
+export * from "./ResponseDoneResult.js";
+export * from "./ResponseErrorResult.js";
+export * from "./ResponseAbortedResult.js";
+export * from "./ResponseBaseResult.js";
+export * from "./TaskResponse.js";

package/api/response/abstractions/index.js

@@ -0,0 +1,7 @@
+export * from "./Response.js";
+export * from "./ResponseContinueResult.js";
+export * from "./ResponseDoneResult.js";
+export * from "./ResponseErrorResult.js";
+export * from "./ResponseAbortedResult.js";
+export * from "./ResponseBaseResult.js";
+export * from "./TaskResponse.js";

package/api/response/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./DatabaseResponse.js";
+export * from "./Response.js";
+export * from "./ResponseContinueResult.js";
+export * from "./ResponseDoneResult.js";
+export * from "./ResponseAbortedResult.js";
+export * from "./ResponseErrorResult.js";
+export * from "./TaskResponse.js";

package/api/response/index.js

@@ -0,0 +1,7 @@
+export * from "./DatabaseResponse.js";
+export * from "./Response.js";
+export * from "./ResponseContinueResult.js";
+export * from "./ResponseDoneResult.js";
+export * from "./ResponseAbortedResult.js";
+export * from "./ResponseErrorResult.js";
+export * from "./TaskResponse.js";

package/api/runner/TaskControl.d.ts

@@ -0,0 +1,48 @@
+import type { ITaskEvent } from "../../api/handler/types.js";
+import type { Context } from "../../api/types.js";
+import type { ITaskControl, ITaskRunner } from "./abstractions/index.js";
+import type { IResponse, IResponseResult } from "../../api/response/abstractions/index.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { TaskExecutionContext } from "../../api/features/TaskExecutionContext/index.js";
+import type { GetTaskUseCase } from "../../api/features/GetTask/index.js";
+import type { ListTasksUseCase } from "../../api/features/ListTasks/index.js";
+import type { CreateTaskLogUseCase } from "../../api/features/CreateTaskLog/index.js";
+import type { GetLatestTaskLogUseCase } from "../../api/features/GetLatestTaskLog/index.js";
+import type { UpdateTaskLogUseCase } from "../../api/features/UpdateTaskLog/index.js";
+import type { UpdateTaskUseCase } from "../../api/features/UpdateTask/index.js";
+import { GetRunnableTaskDefinitionUseCase } from "../../api/features/GetRunnableTaskDefinition/abstractions.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { TaskController } from "@webiny/api-core/features/task/TaskController/abstractions.js";
+/**
+ * What TaskControl needs from the container, declared in one place.
+ *
+ * TaskControl is built by hand (TaskRunner does it), so it cannot take these through DI the way a
+ * registered class would. Naming them here is the next best thing: the class states what it uses,
+ * TaskRunner resolves them once where it assembles the object, and a test can pass fakes. Reaching
+ * into `context.container` from inside a method instead would leave the class with dependencies
+ * nothing can see or substitute.
+ */
+export interface ITaskControlDependencies {
+    logger: Logger.Interface;
+    identityContext: IdentityContext.Interface;
+    taskExecutionContext: TaskExecutionContext.Interface;
+    getTask: GetTaskUseCase.Interface;
+    listTasks: ListTasksUseCase.Interface;
+    updateTask: UpdateTaskUseCase.Interface;
+    getLatestTaskLog: GetLatestTaskLogUseCase.Interface;
+    createTaskLog: CreateTaskLogUseCase.Interface;
+    updateTaskLog: UpdateTaskLogUseCase.Interface;
+    taskController: TaskController.Interface;
+    getRunnableTaskDefinition: GetRunnableTaskDefinitionUseCase.Interface;
+}
+export declare class TaskControl implements ITaskControl {
+    readonly runner: ITaskRunner;
+    readonly response: IResponse;
+    readonly context: Context;
+    private readonly deps;
+    constructor(runner: ITaskRunner, response: IResponse, context: Context, deps: ITaskControlDependencies);
+    run(event: Pick<ITaskEvent, "webinyTaskId">): Promise<IResponseResult>;
+    private runEvents;
+    private getTask;
+    private getTaskLog;
+}

package/api/runner/TaskControl.js

@@ -0,0 +1,186 @@
+import { TaskDataStatus } from "../types.js";
+import { TaskManager } from "./TaskManager.js";
+import { DatabaseResponse, TaskResponse } from "../response/index.js";
+import { TaskManagerStore } from "./TaskManagerStore.js";
+import { getErrorProperties } from "../utils/getErrorProperties.js";
+import { AuthenticatedIdentity } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { TaskResultStatus } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { TaskLogNotFoundError, TaskNotFoundError } from "../domain/errors.js";
+class TaskControl {
+    constructor(runner, response, context, deps){
+        this.runner = runner;
+        this.context = context;
+        this.response = response;
+        this.deps = deps;
+    }
+    async run(event) {
+        const taskId = event.webinyTaskId;
+        let task;
+        try {
+            task = await this.getTask(taskId);
+            this.deps.identityContext.setIdentity(new AuthenticatedIdentity({
+                id: task.createdBy.id,
+                type: task.createdBy.type,
+                displayName: task.createdBy.displayName || "",
+                context: {
+                    canAccessTenant: true
+                }
+            }));
+        } catch (error) {
+            return this.response.error({
+                ...getErrorProperties(error)
+            });
+        }
+        const definitionResult = this.deps.getRunnableTaskDefinition.execute(task.definitionId);
+        if (definitionResult.isFail()) return this.response.error({
+            error: {
+                message: `Task "${task.id}" cannot be executed because there is no "${task.definitionId}" definition plugin.`,
+                code: "TASK_DEFINITION_ERROR",
+                data: {
+                    definitionId: task.definitionId
+                }
+            }
+        });
+        const definition = definitionResult.value;
+        const databaseLogs = true === definition.databaseLogs;
+        let taskLog;
+        try {
+            taskLog = await this.getTaskLog({
+                task,
+                databaseLogs
+            });
+        } catch (error) {
+            return this.response.error({
+                error
+            });
+        }
+        if (task.taskStatus === TaskDataStatus.ABORTED) return this.response.aborted();
+        else if (task.taskStatus === TaskDataStatus.SUCCESS) return this.response.error({
+            error: {
+                message: "Task is already done, cannot run it again."
+            }
+        });
+        else if (task.taskStatus === TaskDataStatus.FAILED) return this.response.error({
+            error: {
+                message: "Task has failed, cannot run it again."
+            }
+        });
+        const store = new TaskManagerStore({
+            context: this.context,
+            listTasks: this.deps.listTasks,
+            updateTask: this.deps.updateTask,
+            updateTaskLog: this.deps.updateTaskLog,
+            logger: this.deps.logger,
+            task,
+            log: taskLog,
+            databaseLogs
+        });
+        const executionContext = this.deps.taskExecutionContext;
+        executionContext.setStore(store);
+        executionContext.setRunner(this.runner);
+        executionContext.setTimer(this.runner.timer);
+        executionContext.setResponse(new TaskResponse(this.response));
+        const manager = new TaskManager(this.context, this.response, store, {
+            taskController: this.deps.taskController,
+            identityContext: this.deps.identityContext
+        });
+        const databaseResponse = new DatabaseResponse(this.response, store);
+        try {
+            const result = await manager.run(definition);
+            const responseResult = await databaseResponse.from(result);
+            await this.runEvents(result, definition, store.getTask());
+            return responseResult;
+        } catch (ex) {
+            return await databaseResponse.from(this.response.error({
+                error: {
+                    message: ex.message,
+                    code: ex.code || "TASK_ERROR",
+                    stack: ex.stack,
+                    data: {
+                        ...ex.data,
+                        input: task.input
+                    }
+                }
+            }));
+        } finally{
+            executionContext.clear();
+        }
+    }
+    async runEvents(result, definition, task) {
+        if (result.status === TaskResultStatus.ERROR && definition.onError) try {
+            await definition.onError({
+                task,
+                definition
+            });
+        } catch (ex) {
+            this.deps.logger.error({
+                error: getErrorProperties(ex),
+                taskId: task.id,
+                hook: "onError"
+            }, "Error executing task lifecycle hook.");
+        }
+        else if (result.status === TaskResultStatus.DONE && definition.onDone) try {
+            await definition.onDone({
+                task,
+                definition
+            });
+        } catch (ex) {
+            this.deps.logger.error({
+                error: getErrorProperties(ex),
+                taskId: task.id,
+                hook: "onDone"
+            }, "Error executing task lifecycle hook.");
+        }
+    }
+    async getTask(id) {
+        const result = await this.deps.getTask.execute(id);
+        if (result.isOk()) return result.value;
+        else if (!(result.error instanceof TaskNotFoundError)) {
+            const error = result.error;
+            throw this.response.error({
+                error: {
+                    message: error.message,
+                    code: error.code || "TASK_ERROR",
+                    stack: error.stack,
+                    data: error.data
+                }
+            });
+        }
+        throw this.response.error({
+            error: {
+                message: `Task "${id}" cannot be executed because it does not exist.`,
+                code: "TASK_NOT_FOUND"
+            }
+        });
+    }
+    async getTaskLog(params) {
+        const { task, databaseLogs } = params;
+        if (!databaseLogs) return {
+            id: `${task.id}-log`,
+            createdOn: task.createdOn,
+            createdBy: task.createdBy,
+            executionName: task.executionName,
+            task: task.id,
+            iteration: task.iterations,
+            items: []
+        };
+        let taskLog = null;
+        const latest = await this.deps.getLatestTaskLog.execute(task.id);
+        if (latest.isOk()) taskLog = latest.value;
+        else if (!(latest.error instanceof TaskLogNotFoundError)) throw this.response.error({
+            error: latest.error
+        });
+        const currentIteration = taskLog?.iteration || 0;
+        const created = await this.deps.createTaskLog.execute(task, {
+            executionName: this.response.event.executionName,
+            iteration: currentIteration + 1
+        });
+        if (created.isFail()) throw this.response.error({
+            error: created.error
+        });
+        return created.value;
+    }
+}
+export { TaskControl };
+
+//# sourceMappingURL=TaskControl.js.map

package/api/runner/TaskControl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/runner/TaskControl.js","sources":["../../../src/api/runner/TaskControl.ts"],"sourcesContent":["import type { ITaskEvent } from \"~/api/handler/types.js\";\nimport type { Context, ITask, ITaskDataInput, ITaskLog } from \"~/api/types.js\";\nimport { TaskDataStatus } from \"~/api/types.js\";\nimport type { ITaskControl, ITaskRunner } from \"./abstractions/index.js\";\nimport { TaskManager } from \"./TaskManager.js\";\nimport type { IResponse, IResponseResult } from \"~/api/response/abstractions/index.js\";\nimport { DatabaseResponse, TaskResponse } from \"~/api/response/index.js\";\nimport { TaskManagerStore } from \"./TaskManagerStore.js\";\nimport { getErrorProperties } from \"~/api/utils/getErrorProperties.js\";\nimport {\n    AuthenticatedIdentity,\n    IdentityContext\n} from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { TaskExecutionContext } from \"~/api/features/TaskExecutionContext/index.js\";\nimport {\n    TaskDefinition,\n    TaskResultStatus\n} from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport type { GetTaskUseCase } from \"~/api/features/GetTask/index.js\";\nimport type { ListTasksUseCase } from \"~/api/features/ListTasks/index.js\";\nimport type { CreateTaskLogUseCase } from \"~/api/features/CreateTaskLog/index.js\";\nimport type { GetLatestTaskLogUseCase } from \"~/api/features/GetLatestTaskLog/index.js\";\nimport type { UpdateTaskLogUseCase } from \"~/api/features/UpdateTaskLog/index.js\";\nimport type { UpdateTaskUseCase } from \"~/api/features/UpdateTask/index.js\";\nimport { TaskLogNotFoundError } from \"~/api/domain/errors.js\";\nimport { TaskNotFoundError } from \"~/api/domain/errors.js\";\nimport { GetRunnableTaskDefinitionUseCase } from \"~/api/features/GetRunnableTaskDefinition/abstractions.js\";\nimport { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { TaskController } from \"@webiny/api-core/features/task/TaskController/abstractions.js\";\n\ninterface IGetTaskLogParams {\n    task: ITask;\n    databaseLogs: boolean;\n}\n\n/**\n * What TaskControl needs from the container, declared in one place.\n *\n * TaskControl is built by hand (TaskRunner does it), so it cannot take these through DI the way a\n * registered class would. Naming them here is the next best thing: the class states what it uses,\n * TaskRunner resolves them once where it assembles the object, and a test can pass fakes. Reaching\n * into `context.container` from inside a method instead would leave the class with dependencies\n * nothing can see or substitute.\n */\nexport interface ITaskControlDependencies {\n    logger: Logger.Interface;\n    identityContext: IdentityContext.Interface;\n    taskExecutionContext: TaskExecutionContext.Interface;\n    getTask: GetTaskUseCase.Interface;\n    listTasks: ListTasksUseCase.Interface;\n    updateTask: UpdateTaskUseCase.Interface;\n    getLatestTaskLog: GetLatestTaskLogUseCase.Interface;\n    createTaskLog: CreateTaskLogUseCase.Interface;\n    updateTaskLog: UpdateTaskLogUseCase.Interface;\n    taskController: TaskController.Interface;\n    getRunnableTaskDefinition: GetRunnableTaskDefinitionUseCase.Interface;\n}\n\nexport class TaskControl implements ITaskControl {\n    public readonly runner: ITaskRunner;\n    public readonly response: IResponse;\n    public readonly context: Context;\n    private readonly deps: ITaskControlDependencies;\n\n    public constructor(\n        runner: ITaskRunner,\n        response: IResponse,\n        context: Context,\n        deps: ITaskControlDependencies\n    ) {\n        this.runner = runner;\n        this.context = context;\n        this.response = response;\n        this.deps = deps;\n    }\n\n    public async run(event: Pick<ITaskEvent, \"webinyTaskId\">): Promise<IResponseResult> {\n        const taskId = event.webinyTaskId;\n        /**\n         * This is the initial getTask idea.\n         * We will need to take care of child tasks:\n         * * child tasks can be in multiple levels (child task creates a child task, etc...).\n         * * child tasks could be executed in parallel.\n         */\n        let task: ITask<ITaskDataInput>;\n        try {\n            task = await this.getTask(taskId);\n            this.deps.identityContext.setIdentity(\n                new AuthenticatedIdentity({\n                    id: task.createdBy.id,\n                    type: task.createdBy.type,\n                    displayName: task.createdBy.displayName || \"\",\n                    context: {\n                        canAccessTenant: true\n                    }\n                })\n            );\n        } catch (error) {\n            /**\n             * TODO Refactor error handling.\n             */\n            // @ts-expect-error\n            return this.response.error({\n                ...getErrorProperties(error)\n            });\n        }\n        /**\n         * Let's get the task definition.\n         */\n        const definitionResult = this.deps.getRunnableTaskDefinition.execute(task.definitionId);\n        if (definitionResult.isFail()) {\n            return this.response.error({\n                error: {\n                    message: `Task \"${task.id}\" cannot be executed because there is no \"${task.definitionId}\" definition plugin.`,\n                    code: \"TASK_DEFINITION_ERROR\",\n                    data: {\n                        definitionId: task.definitionId\n                    }\n                }\n            });\n        }\n        const definition = definitionResult.value;\n        /**\n         * Only enable logs if definition explicitly allows them.\n         */\n        const databaseLogs = definition.databaseLogs === true;\n\n        /**\n         * As this as a run of the task, we need to create a new log entry.\n         */\n        let taskLog: ITaskLog;\n        try {\n            taskLog = await this.getTaskLog({\n                task,\n                databaseLogs\n            });\n        } catch (error) {\n            return this.response.error({\n                error\n            });\n        }\n        /**\n         * Make sure that task does not run if it is aborted.\n         * This will effectively end the Step Function execution with a \"success\" status.\n         */\n        if (task.taskStatus === TaskDataStatus.ABORTED) {\n            return this.response.aborted();\n        }\n        /**\n         * Do not run if already a success (done).\n         */\n        //\n        else if (task.taskStatus === TaskDataStatus.SUCCESS) {\n            return this.response.error({\n                error: {\n                    message: \"Task is already done, cannot run it again.\"\n                }\n            });\n        }\n        /**\n         * Do not run if already failed.\n         */\n        //\n        else if (task.taskStatus === TaskDataStatus.FAILED) {\n            return this.response.error({\n                error: {\n                    message: \"Task has failed, cannot run it again.\"\n                }\n            });\n        }\n\n        const store = new TaskManagerStore({\n            context: this.context,\n            listTasks: this.deps.listTasks,\n            updateTask: this.deps.updateTask,\n            updateTaskLog: this.deps.updateTaskLog,\n            logger: this.deps.logger,\n            task,\n            log: taskLog,\n            databaseLogs\n        });\n\n        // Populate TaskExecutionContext BEFORE executing task\n        const executionContext = this.deps.taskExecutionContext;\n        executionContext.setStore(store);\n        executionContext.setRunner(this.runner);\n        executionContext.setTimer(this.runner.timer);\n        executionContext.setResponse(new TaskResponse(this.response));\n\n        const manager = new TaskManager(this.context, this.response, store, {\n            taskController: this.deps.taskController,\n            identityContext: this.deps.identityContext\n        });\n\n        const databaseResponse = new DatabaseResponse(this.response, store);\n\n        try {\n            const result = await manager.run(definition);\n\n            const responseResult = await databaseResponse.from(result);\n\n            // Get the updated task from store (no database read needed - store maintains local cache)\n            await this.runEvents(result, definition, store.getTask());\n\n            return responseResult;\n        } catch (ex) {\n            /**\n             * We always want to store the error in the task log.\n             */\n            return await databaseResponse.from(\n                this.response.error({\n                    error: {\n                        message: ex.message,\n                        code: ex.code || \"TASK_ERROR\",\n                        stack: ex.stack,\n                        data: {\n                            ...ex.data,\n                            input: task.input\n                        }\n                    }\n                })\n            );\n        } finally {\n            // Clear execution context after task completes\n            executionContext.clear();\n        }\n    }\n\n    private async runEvents(\n        result: IResponseResult,\n        definition: TaskDefinition.Runnable,\n        task: ITask\n    ): Promise<void> {\n        if (result.status === TaskResultStatus.ERROR && definition.onError) {\n            try {\n                await definition.onError({ task, definition });\n            } catch (ex) {\n                this.deps.logger.error(\n                    { error: getErrorProperties(ex), taskId: task.id, hook: \"onError\" },\n                    \"Error executing task lifecycle hook.\"\n                );\n            }\n        } else if (result.status === TaskResultStatus.DONE && definition.onDone) {\n            try {\n                await definition.onDone({ task, definition });\n            } catch (ex) {\n                this.deps.logger.error(\n                    { error: getErrorProperties(ex), taskId: task.id, hook: \"onDone\" },\n                    \"Error executing task lifecycle hook.\"\n                );\n            }\n        }\n    }\n\n    private async getTask<T extends TaskDefinition.TaskInput>(id: string): Promise<ITask<T>> {\n        const result = await this.deps.getTask.execute<T>(id);\n        if (result.isOk()) {\n            return result.value;\n        } else if (!(result.error instanceof TaskNotFoundError)) {\n            const error = result.error;\n            throw this.response.error({\n                error: {\n                    message: error.message,\n                    code: error.code || \"TASK_ERROR\",\n                    stack: error.stack,\n                    data: error.data\n                }\n            });\n        }\n        throw this.response.error({\n            error: {\n                message: `Task \"${id}\" cannot be executed because it does not exist.`,\n                code: \"TASK_NOT_FOUND\"\n            }\n        });\n    }\n\n    private async getTaskLog(params: IGetTaskLogParams): Promise<ITaskLog> {\n        const { task, databaseLogs } = params;\n        /**\n         * If logs are disabled, let's return a mocked one.\n         */\n        if (!databaseLogs) {\n            return {\n                id: `${task.id}-log`,\n                createdOn: task.createdOn,\n                createdBy: task.createdBy,\n                executionName: task.executionName,\n                task: task.id,\n                iteration: task.iterations,\n                items: []\n            };\n        }\n        let taskLog: ITaskLog | null = null;\n        /**\n         * First we are trying to get existing latest log.\n         */\n        const latest = await this.deps.getLatestTaskLog.execute(task.id);\n        if (latest.isOk()) {\n            taskLog = latest.value;\n        } else if (!(latest.error instanceof TaskLogNotFoundError)) {\n            // A task without a log yet is fine; any other failure is not.\n            throw this.response.error({\n                error: latest.error\n            });\n        }\n\n        const currentIteration = taskLog?.iteration || 0;\n\n        const created = await this.deps.createTaskLog.execute(task, {\n            executionName: this.response.event.executionName,\n            iteration: currentIteration + 1\n        });\n        if (created.isFail()) {\n            throw this.response.error({\n                error: created.error\n            });\n        }\n        return created.value;\n    }\n}\n"],"names":["TaskControl","runner","response","context","deps","event","taskId","task","AuthenticatedIdentity","error","getErrorProperties","definitionResult","definition","databaseLogs","taskLog","TaskDataStatus","store","TaskManagerStore","executionContext","TaskResponse","manager","TaskManager","databaseResponse","DatabaseResponse","result","responseResult","ex","TaskResultStatus","id","TaskNotFoundError","params","latest","TaskLogNotFoundError","currentIteration","created"],"mappings":"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"}

package/api/runner/TaskEventValidation.d.ts

@@ -0,0 +1,5 @@
+import type { ITaskEventValidation, ITaskEventValidationResult } from "./abstractions/index.js";
+import type { ITaskEvent } from "../../api/handler/types.js";
+export declare class TaskEventValidation implements ITaskEventValidation {
+    validate(event: Partial<ITaskEvent>): ITaskEventValidationResult;
+}

package/api/runner/TaskEventValidation.js

@@ -0,0 +1,20 @@
+import zod from "zod";
+import { createZodError } from "@webiny/utils";
+const validation = zod.object({
+    webinyTaskId: zod.string(),
+    webinyTaskDefinitionId: zod.string(),
+    endpoint: zod.string(),
+    tenant: zod.string(),
+    executionName: zod.string(),
+    stateMachineId: zod.string()
+}).required();
+class TaskEventValidation {
+    validate(event) {
+        const result = validation.safeParse(event);
+        if (result.success) return result.data;
+        throw createZodError(result.error);
+    }
+}
+export { TaskEventValidation };
+
+//# sourceMappingURL=TaskEventValidation.js.map

package/api/runner/TaskEventValidation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/runner/TaskEventValidation.js","sources":["../../../src/api/runner/TaskEventValidation.ts"],"sourcesContent":["import zod from \"zod\";\nimport { createZodError } from \"@webiny/utils\";\nimport type { ITaskEventValidation, ITaskEventValidationResult } from \"./abstractions/index.js\";\nimport type { ITaskEvent } from \"~/api/handler/types.js\";\n\nconst validation = zod\n    .object({\n        webinyTaskId: zod.string(),\n        webinyTaskDefinitionId: zod.string(),\n        endpoint: zod.string(),\n        tenant: zod.string(),\n        executionName: zod.string(),\n        stateMachineId: zod.string()\n    })\n    .required();\n\nexport class TaskEventValidation implements ITaskEventValidation {\n    public validate(event: Partial<ITaskEvent>): ITaskEventValidationResult {\n        const result = validation.safeParse(event);\n        if (result.success) {\n            return result.data;\n        }\n        throw createZodError(result.error);\n    }\n}\n"],"names":["validation","zod","TaskEventValidation","event","result","createZodError"],"mappings":";;AAKA,MAAMA,aAAaC,IAAAA,MACR,CAAC;IACJ,cAAcA,IAAI,MAAM;IACxB,wBAAwBA,IAAI,MAAM;IAClC,UAAUA,IAAI,MAAM;IACpB,QAAQA,IAAI,MAAM;IAClB,eAAeA,IAAI,MAAM;IACzB,gBAAgBA,IAAI,MAAM;AAC9B,GACC,QAAQ;AAEN,MAAMC;IACF,SAASC,KAA0B,EAA8B;QACpE,MAAMC,SAASJ,WAAW,SAAS,CAACG;QACpC,IAAIC,OAAO,OAAO,EACd,OAAOA,OAAO,IAAI;QAEtB,MAAMC,eAAeD,OAAO,KAAK;IACrC;AACJ"}

package/api/runner/TaskManager.d.ts

@@ -0,0 +1,22 @@
+import type { ITaskManager, ITaskManagerStorePrivate } from "./abstractions/index.js";
+import type { Context } from "../../api/types.js";
+import type { IResponse, IResponseResult } from "../../api/response/abstractions/index.js";
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { TaskController } from "@webiny/api-core/features/task/TaskController/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/abstractions.js";
+/**
+ * What TaskManager needs from the container. Same reasoning as ITaskControlDependencies: the class
+ * is built by hand, so it states what it uses and the caller supplies it.
+ */
+export interface ITaskManagerDependencies {
+    taskController: TaskController.Interface;
+    identityContext: IdentityContext.Interface;
+}
+export declare class TaskManager implements ITaskManager {
+    private readonly context;
+    private readonly response;
+    private readonly store;
+    private readonly deps;
+    constructor(context: Context, response: IResponse, store: ITaskManagerStorePrivate, deps: ITaskManagerDependencies);
+    run(definition: TaskDefinition.Runnable): Promise<IResponseResult>;
+}

package/api/runner/TaskManager.js

@@ -0,0 +1,83 @@
+import { TaskDataStatus } from "../types.js";
+import { getErrorProperties } from "../utils/getErrorProperties.js";
+import { TaskResultStatus } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+class TaskManager {
+    constructor(context, response, store, deps){
+        this.context = context;
+        this.response = response;
+        this.store = store;
+        this.deps = deps;
+    }
+    async run(definition) {
+        if (this.store.getStatus() === TaskDataStatus.ABORTED) return this.response.aborted();
+        else if (this.store.getStatus() === TaskDataStatus.PENDING) try {
+            await this.store.updateTask({
+                taskStatus: TaskDataStatus.RUNNING,
+                startedOn: new Date().toISOString(),
+                executionName: this.response.event.executionName,
+                iterations: 1
+            });
+            await this.store.save();
+        } catch (error) {
+            return this.response.error({
+                error
+            });
+        }
+        else if (this.store.getTask().iterations >= definition.maxIterations) try {
+            if (definition.onMaxIterations) await definition.onMaxIterations({
+                task: this.store.getTask(),
+                definition
+            });
+            return this.response.error({
+                error: {
+                    message: "Task reached max iterations."
+                }
+            });
+        } catch (ex) {
+            return this.response.error({
+                error: {
+                    message: "Failed to execute onMaxIterations handler.",
+                    data: getErrorProperties(ex)
+                }
+            });
+        }
+        else try {
+            await this.store.updateTask((task)=>({
+                    iterations: task.iterations + 1
+                }));
+        } catch (error) {
+            return this.response.error({
+                error
+            });
+        }
+        let result;
+        try {
+            const input = structuredClone(this.store.getInput());
+            const controller = this.deps.taskController;
+            result = await this.deps.identityContext.withoutAuthorization(async ()=>await definition.run({
+                    input,
+                    controller,
+                    definition
+                }));
+        } catch (ex) {
+            return this.response.error({
+                error: getErrorProperties(ex)
+            });
+        }
+        if (result.status === TaskResultStatus.CONTINUE) return this.response.continue({
+            input: result.input,
+            wait: result.wait
+        });
+        else if (result.status === TaskResultStatus.ERROR) return this.response.error({
+            error: result.error
+        });
+        else if (result.status === TaskResultStatus.ABORTED) return this.response.aborted();
+        return this.response.done({
+            message: result.message,
+            output: result.output
+        });
+    }
+}
+export { TaskManager };
+
+//# sourceMappingURL=TaskManager.js.map

package/api/runner/TaskManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/runner/TaskManager.js","sources":["../../../src/api/runner/TaskManager.ts"],"sourcesContent":["import type { ITaskManager, ITaskManagerStorePrivate } from \"./abstractions/index.js\";\nimport type { Context } from \"~/api/types.js\";\nimport { TaskDataStatus } from \"~/api/types.js\";\nimport type { IResponse, IResponseResult } from \"~/api/response/abstractions/index.js\";\nimport { getErrorProperties } from \"~/api/utils/getErrorProperties.js\";\nimport {\n    TaskDefinition,\n    TaskResultStatus\n} from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { TaskController } from \"@webiny/api-core/features/task/TaskController/abstractions.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/abstractions.js\";\n\n/**\n * What TaskManager needs from the container. Same reasoning as ITaskControlDependencies: the class\n * is built by hand, so it states what it uses and the caller supplies it.\n */\nexport interface ITaskManagerDependencies {\n    taskController: TaskController.Interface;\n    identityContext: IdentityContext.Interface;\n}\n\nexport class TaskManager implements ITaskManager {\n    private readonly context: Context;\n    private readonly response: IResponse;\n    private readonly store: ITaskManagerStorePrivate;\n\n    private readonly deps: ITaskManagerDependencies;\n\n    public constructor(\n        context: Context,\n        response: IResponse,\n        store: ITaskManagerStorePrivate,\n        deps: ITaskManagerDependencies\n    ) {\n        this.context = context;\n        this.response = response;\n        this.store = store;\n        this.deps = deps;\n    }\n\n    public async run(definition: TaskDefinition.Runnable): Promise<IResponseResult> {\n        /**\n         * If task was aborted, do not run it again, return as it was done.\n         */\n        if (this.store.getStatus() === TaskDataStatus.ABORTED) {\n            return this.response.aborted();\n        }\n        /**\n         * If the task status is pending, update it to running and add a log.\n         */\n        //\n        else if (this.store.getStatus() === TaskDataStatus.PENDING) {\n            try {\n                await this.store.updateTask({\n                    taskStatus: TaskDataStatus.RUNNING,\n                    startedOn: new Date().toISOString(),\n                    executionName: this.response.event.executionName,\n                    iterations: 1\n                });\n                await this.store.save();\n            } catch (error) {\n                return this.response.error({\n                    error\n                });\n            }\n        }\n        /**\n         * We do not want to run the task indefinitely.\n         * If the task has reached the max iterations, we will stop it and execute the onMaxIterations handler, if any.\n         */\n        //\n        else if (this.store.getTask().iterations >= definition.maxIterations) {\n            try {\n                if (definition.onMaxIterations) {\n                    await definition.onMaxIterations({\n                        task: this.store.getTask(),\n                        definition\n                    });\n                }\n                return this.response.error({\n                    error: {\n                        message: \"Task reached max iterations.\"\n                    }\n                });\n            } catch (ex) {\n                return this.response.error({\n                    error: {\n                        message: \"Failed to execute onMaxIterations handler.\",\n                        data: getErrorProperties(ex)\n                    }\n                });\n            }\n        }\n        /**\n         * Always update the task iteration.\n         */\n        //\n        else {\n            try {\n                await this.store.updateTask(task => {\n                    return {\n                        iterations: task.iterations + 1\n                    };\n                });\n            } catch (error) {\n                return this.response.error({\n                    error\n                });\n            }\n        }\n\n        let result: TaskDefinition.Result;\n\n        try {\n            const input = structuredClone(this.store.getInput());\n            const controller = this.deps.taskController;\n            /**\n             * We always run the task without authorization because we are running a task without a user - nothing to authorize against.\n             */\n            result = await this.deps.identityContext.withoutAuthorization(async () => {\n                return await definition.run({\n                    input,\n                    controller,\n                    definition\n                });\n            });\n        } catch (ex) {\n            return this.response.error({\n                error: getErrorProperties(ex)\n            });\n        }\n\n        // Convert TaskDefinition.Result to IResponseResult\n        if (result.status === TaskResultStatus.CONTINUE) {\n            return this.response.continue({\n                input: result.input,\n                wait: result.wait\n            });\n        } else if (result.status === TaskResultStatus.ERROR) {\n            return this.response.error({\n                error: result.error\n            });\n        } else if (result.status === TaskResultStatus.ABORTED) {\n            return this.response.aborted();\n        }\n        return this.response.done({\n            message: result.message,\n            output: result.output\n        });\n    }\n}\n"],"names":["TaskManager","context","response","store","deps","definition","TaskDataStatus","Date","error","ex","getErrorProperties","task","result","input","structuredClone","controller","TaskResultStatus"],"mappings":";;;AAqBO,MAAMA;IAOT,YACIC,OAAgB,EAChBC,QAAmB,EACnBC,KAA+B,EAC/BC,IAA8B,CAChC;QACE,IAAI,CAAC,OAAO,GAAGH;QACf,IAAI,CAAC,QAAQ,GAAGC;QAChB,IAAI,CAAC,KAAK,GAAGC;QACb,IAAI,CAAC,IAAI,GAAGC;IAChB;IAEA,MAAa,IAAIC,UAAmC,EAA4B;QAI5E,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,OAAOC,eAAe,OAAO,EACjD,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO;aAM3B,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,OAAOA,eAAe,OAAO,EACtD,IAAI;YACA,MAAM,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC;gBACxB,YAAYA,eAAe,OAAO;gBAClC,WAAW,IAAIC,OAAO,WAAW;gBACjC,eAAe,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,aAAa;gBAChD,YAAY;YAChB;YACA,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI;QACzB,EAAE,OAAOC,OAAO;YACZ,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;gBACvBA;YACJ;QACJ;aAOC,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,GAAG,UAAU,IAAIH,WAAW,aAAa,EAChE,IAAI;YACA,IAAIA,WAAW,eAAe,EAC1B,MAAMA,WAAW,eAAe,CAAC;gBAC7B,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO;gBACxBA;YACJ;YAEJ,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;gBACvB,OAAO;oBACH,SAAS;gBACb;YACJ;QACJ,EAAE,OAAOI,IAAI;YACT,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;gBACvB,OAAO;oBACH,SAAS;oBACT,MAAMC,mBAAmBD;gBAC7B;YACJ;QACJ;aAOA,IAAI;YACA,MAAM,IAAI,CAAC,KAAK,CAAC,UAAU,CAACE,CAAAA,OACjB;oBACH,YAAYA,KAAK,UAAU,GAAG;gBAClC;QAER,EAAE,OAAOH,OAAO;YACZ,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;gBACvBA;YACJ;QACJ;QAGJ,IAAII;QAEJ,IAAI;YACA,MAAMC,QAAQC,gBAAgB,IAAI,CAAC,KAAK,CAAC,QAAQ;YACjD,MAAMC,aAAa,IAAI,CAAC,IAAI,CAAC,cAAc;YAI3CH,SAAS,MAAM,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC,UACnD,MAAMP,WAAW,GAAG,CAAC;oBACxBQ;oBACAE;oBACAV;gBACJ;QAER,EAAE,OAAOI,IAAI;YACT,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;gBACvB,OAAOC,mBAAmBD;YAC9B;QACJ;QAGA,IAAIG,OAAO,MAAM,KAAKI,iBAAiB,QAAQ,EAC3C,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC;YAC1B,OAAOJ,OAAO,KAAK;YACnB,MAAMA,OAAO,IAAI;QACrB;aACG,IAAIA,OAAO,MAAM,KAAKI,iBAAiB,KAAK,EAC/C,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;YACvB,OAAOJ,OAAO,KAAK;QACvB;aACG,IAAIA,OAAO,MAAM,KAAKI,iBAAiB,OAAO,EACjD,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO;QAEhC,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;YACtB,SAASJ,OAAO,OAAO;YACvB,QAAQA,OAAO,MAAM;QACzB;IACJ;AACJ"}