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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/task/TasksRepository.js","sources":["../../../../src/api/domain/task/TasksRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries/index.js\";\nimport { CreateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js\";\nimport { UpdateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js\";\nimport { DeleteEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry/index.js\";\nimport { CmsWhereMapper } from \"@webiny/api-headless-cms\";\nimport { TaskModelProvider, TasksRepository as Abstraction } from \"./abstractions.js\";\nimport { entryToTask } from \"./entryToTask.js\";\nimport { createRevisionId } from \"./createRevisionId.js\";\nimport { BackgroundTaskPersistenceError, TaskNotFoundError } from \"~/api/domain/errors.js\";\nimport { TaskDataStatus } from \"~/api/types.js\";\nimport type { IListTaskParams, ITaskCreateData, ITaskUpdateData } from \"~/api/types.js\";\nimport type { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\n\ntype TaskInput = TaskService.TaskInput;\ntype TaskOutput = TaskService.GenericOutput;\n\nconst ENTRY_NOT_FOUND = \"Cms/Entry/NotFound\";\n\nconst toTaskError = (error: {\n    code?: string;\n}): TaskNotFoundError | BackgroundTaskPersistenceError => {\n    if (error.code === ENTRY_NOT_FOUND) {\n        return new TaskNotFoundError();\n    }\n    return BackgroundTaskPersistenceError.from(error);\n};\n\n/*\n * Tasks are stored as entries of a private CMS model. The calls run without authorization: who may\n * see or run a task is decided by the task use cases and the GraphQL layer, not by CMS permissions.\n */\nclass TasksRepositoryImpl implements Abstraction.Interface {\n    constructor(\n        private readonly identityContext: IdentityContext.Interface,\n        private readonly modelProvider: TaskModelProvider.Interface,\n        private readonly getEntryById: GetEntryByIdUseCase.Interface,\n        private readonly listLatestEntries: ListLatestEntriesUseCase.Interface,\n        private readonly createEntry: CreateEntryUseCase.Interface,\n        private readonly updateEntry: UpdateEntryUseCase.Interface,\n        private readonly deleteEntry: DeleteEntryUseCase.Interface,\n        private readonly whereMapper: CmsWhereMapper.Interface\n    ) {}\n\n    async get<I extends TaskInput = TaskInput, O extends TaskOutput = TaskOutput>(id: string) {\n        try {\n            const result = await this.identityContext.withoutAuthorization(async () => {\n                const model = await this.modelProvider.get();\n                return this.getEntryById.execute(model, createRevisionId(id));\n            });\n            if (result.isFail()) {\n                return Result.fail(toTaskError(result.error));\n            }\n            return Result.ok(entryToTask<I, O>(result.value));\n        } catch (error) {\n            return Result.fail(BackgroundTaskPersistenceError.from(error));\n        }\n    }\n\n    async list<I extends TaskInput = TaskInput, O extends TaskOutput = TaskOutput>(\n        params?: IListTaskParams\n    ) {\n        try {\n            const result = await this.identityContext.withoutAuthorization(async () => {\n                const model = await this.modelProvider.get();\n                return this.listLatestEntries.execute(model, {\n                    ...params,\n                    where: this.whereMapper.map({\n                        input: params?.where,\n                        fields: model.fields\n                    })\n                });\n            });\n            if (result.isFail()) {\n                return Result.fail(BackgroundTaskPersistenceError.from(result.error));\n            }\n            const { entries, meta } = result.value;\n            return Result.ok({\n                items: entries.map(entry => entryToTask<I, O>(entry)),\n                meta\n            });\n        } catch (error) {\n            return Result.fail(BackgroundTaskPersistenceError.from(error));\n        }\n    }\n\n    async create<I extends TaskInput = TaskInput>(data: ITaskCreateData<I>) {\n        try {\n            const result = await this.identityContext.withoutAuthorization(async () => {\n                const model = await this.modelProvider.get();\n                return this.createEntry.execute(model, {\n                    values: {\n                        ...data,\n                        iterations: 0,\n                        taskStatus: TaskDataStatus.PENDING\n                    }\n                });\n            });\n            if (result.isFail()) {\n                return Result.fail(BackgroundTaskPersistenceError.from(result.error));\n            }\n            return Result.ok(entryToTask<I>(result.value));\n        } catch (error) {\n            return Result.fail(BackgroundTaskPersistenceError.from(error));\n        }\n    }\n\n    async update<I extends TaskInput = TaskInput, O extends TaskOutput = TaskOutput>(\n        id: string,\n        data: Partial<ITaskUpdateData<I, O>>\n    ) {\n        try {\n            const result = await this.identityContext.withoutAuthorization(async () => {\n                const model = await this.modelProvider.get();\n                return this.updateEntry.execute(model, createRevisionId(id), {\n                    values: { ...data }\n                });\n            });\n            if (result.isFail()) {\n                return Result.fail(toTaskError(result.error));\n            }\n            return Result.ok(entryToTask<I, O>(result.value));\n        } catch (error) {\n            return Result.fail(BackgroundTaskPersistenceError.from(error));\n        }\n    }\n\n    async delete(id: string) {\n        try {\n            const result = await this.identityContext.withoutAuthorization(async () => {\n                const model = await this.modelProvider.get();\n                return this.deleteEntry.execute(model, createRevisionId(id));\n            });\n            if (result.isFail()) {\n                return Result.fail(toTaskError(result.error));\n            }\n            return Result.ok();\n        } catch (error) {\n            return Result.fail(BackgroundTaskPersistenceError.from(error));\n        }\n    }\n}\n\nexport const TasksRepository = Abstraction.createImplementation({\n    implementation: TasksRepositoryImpl,\n    dependencies: [\n        IdentityContext,\n        TaskModelProvider,\n        GetEntryByIdUseCase,\n        ListLatestEntriesUseCase,\n        CreateEntryUseCase,\n        UpdateEntryUseCase,\n        DeleteEntryUseCase,\n        CmsWhereMapper\n    ]\n});\n"],"names":["ENTRY_NOT_FOUND","toTaskError","error","TaskNotFoundError","BackgroundTaskPersistenceError","TasksRepositoryImpl","identityContext","modelProvider","getEntryById","listLatestEntries","createEntry","updateEntry","deleteEntry","whereMapper","id","result","model","createRevisionId","Result","entryToTask","params","entries","meta","entry","data","TaskDataStatus","TasksRepository","Abstraction","IdentityContext","TaskModelProvider","GetEntryByIdUseCase","ListLatestEntriesUseCase","CreateEntryUseCase","UpdateEntryUseCase","DeleteEntryUseCase","CmsWhereMapper"],"mappings":";;;;;;;;;;;;;AAmBA,MAAMA,kBAAkB;AAExB,MAAMC,cAAc,CAACC;IAGjB,IAAIA,MAAM,IAAI,KAAKF,iBACf,OAAO,IAAIG;IAEf,OAAOC,+BAA+B,IAAI,CAACF;AAC/C;AAMA,MAAMG;IACF,YACqBC,eAA0C,EAC1CC,aAA0C,EAC1CC,YAA2C,EAC3CC,iBAAqD,EACrDC,WAAyC,EACzCC,WAAyC,EACzCC,WAAyC,EACzCC,WAAqC,CACxD;aARmBP,eAAe,GAAfA;aACAC,aAAa,GAAbA;aACAC,YAAY,GAAZA;aACAC,iBAAiB,GAAjBA;aACAC,WAAW,GAAXA;aACAC,WAAW,GAAXA;aACAC,WAAW,GAAXA;aACAC,WAAW,GAAXA;IAClB;IAEH,MAAM,IAAwEC,EAAU,EAAE;QACtF,IAAI;YACA,MAAMC,SAAS,MAAM,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC;gBAC3D,MAAMC,QAAQ,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG;gBAC1C,OAAO,IAAI,CAAC,YAAY,CAAC,OAAO,CAACA,OAAOC,iBAAiBH;YAC7D;YACA,IAAIC,OAAO,MAAM,IACb,OAAOG,OAAO,IAAI,CAACjB,YAAYc,OAAO,KAAK;YAE/C,OAAOG,OAAO,EAAE,CAACC,YAAkBJ,OAAO,KAAK;QACnD,EAAE,OAAOb,OAAO;YACZ,OAAOgB,OAAO,IAAI,CAACd,+BAA+B,IAAI,CAACF;QAC3D;IACJ;IAEA,MAAM,KACFkB,MAAwB,EAC1B;QACE,IAAI;YACA,MAAML,SAAS,MAAM,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC;gBAC3D,MAAMC,QAAQ,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG;gBAC1C,OAAO,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAACA,OAAO;oBACzC,GAAGI,MAAM;oBACT,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC;wBACxB,OAAOA,QAAQ;wBACf,QAAQJ,MAAM,MAAM;oBACxB;gBACJ;YACJ;YACA,IAAID,OAAO,MAAM,IACb,OAAOG,OAAO,IAAI,CAACd,+BAA+B,IAAI,CAACW,OAAO,KAAK;YAEvE,MAAM,EAAEM,OAAO,EAAEC,IAAI,EAAE,GAAGP,OAAO,KAAK;YACtC,OAAOG,OAAO,EAAE,CAAC;gBACb,OAAOG,QAAQ,GAAG,CAACE,CAAAA,QAASJ,YAAkBI;gBAC9CD;YACJ;QACJ,EAAE,OAAOpB,OAAO;YACZ,OAAOgB,OAAO,IAAI,CAACd,+BAA+B,IAAI,CAACF;QAC3D;IACJ;IAEA,MAAM,OAAwCsB,IAAwB,EAAE;QACpE,IAAI;YACA,MAAMT,SAAS,MAAM,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC;gBAC3D,MAAMC,QAAQ,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG;gBAC1C,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,CAACA,OAAO;oBACnC,QAAQ;wBACJ,GAAGQ,IAAI;wBACP,YAAY;wBACZ,YAAYC,eAAe,OAAO;oBACtC;gBACJ;YACJ;YACA,IAAIV,OAAO,MAAM,IACb,OAAOG,OAAO,IAAI,CAACd,+BAA+B,IAAI,CAACW,OAAO,KAAK;YAEvE,OAAOG,OAAO,EAAE,CAACC,YAAeJ,OAAO,KAAK;QAChD,EAAE,OAAOb,OAAO;YACZ,OAAOgB,OAAO,IAAI,CAACd,+BAA+B,IAAI,CAACF;QAC3D;IACJ;IAEA,MAAM,OACFY,EAAU,EACVU,IAAoC,EACtC;QACE,IAAI;YACA,MAAMT,SAAS,MAAM,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC;gBAC3D,MAAMC,QAAQ,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG;gBAC1C,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,CAACA,OAAOC,iBAAiBH,KAAK;oBACzD,QAAQ;wBAAE,GAAGU,IAAI;oBAAC;gBACtB;YACJ;YACA,IAAIT,OAAO,MAAM,IACb,OAAOG,OAAO,IAAI,CAACjB,YAAYc,OAAO,KAAK;YAE/C,OAAOG,OAAO,EAAE,CAACC,YAAkBJ,OAAO,KAAK;QACnD,EAAE,OAAOb,OAAO;YACZ,OAAOgB,OAAO,IAAI,CAACd,+BAA+B,IAAI,CAACF;QAC3D;IACJ;IAEA,MAAM,OAAOY,EAAU,EAAE;QACrB,IAAI;YACA,MAAMC,SAAS,MAAM,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC;gBAC3D,MAAMC,QAAQ,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG;gBAC1C,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,CAACA,OAAOC,iBAAiBH;YAC5D;YACA,IAAIC,OAAO,MAAM,IACb,OAAOG,OAAO,IAAI,CAACjB,YAAYc,OAAO,KAAK;YAE/C,OAAOG,OAAO,EAAE;QACpB,EAAE,OAAOhB,OAAO;YACZ,OAAOgB,OAAO,IAAI,CAACd,+BAA+B,IAAI,CAACF;QAC3D;IACJ;AACJ;AAEO,MAAMwB,kCAAkBC,gBAAAA,oBAAgC,CAAC;IAC5D,gBAAgBtB;IAChB,cAAc;QACVuB;QACAC;QACAC;QACAC;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

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

@@ -0,0 +1,50 @@
+import { type Result } from "@webiny/feature/api";
+import type { CmsModel } from "@webiny/api-headless-cms/types/index.js";
+import type { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import type { IListTaskLogParams, IListTaskLogsResponse, IListTaskParams, IListTasksResponse, ITaskCreateData, ITaskLog, ITaskLogCreateInput, ITaskLogUpdateInput, ITaskUpdateData } from "../../../api/types.js";
+import type { BackgroundTaskPersistenceError, TaskLogNotFoundError, TaskNotFoundError } from "../../../api/domain/errors.js";
+export interface ITaskModelProvider {
+    get(): Promise<CmsModel>;
+}
+/** The private CMS model that stores background tasks. */
+export declare const TaskModelProvider: import("@webiny/di").Abstraction<ITaskModelProvider>;
+export declare namespace TaskModelProvider {
+    type Interface = ITaskModelProvider;
+}
+export interface ITaskLogModelProvider {
+    get(): Promise<CmsModel>;
+}
+/** The private CMS model that stores background task logs. */
+export declare const TaskLogModelProvider: import("@webiny/di").Abstraction<ITaskLogModelProvider>;
+export declare namespace TaskLogModelProvider {
+    type Interface = ITaskLogModelProvider;
+}
+type TaskInput = TaskService.TaskInput;
+type TaskOutput = TaskService.GenericOutput;
+export interface ITasksRepository {
+    get<I extends TaskInput = TaskInput, O extends TaskOutput = TaskOutput>(id: string): Promise<Result<TaskService.Task<I, O>, TaskNotFoundError | BackgroundTaskPersistenceError>>;
+    list<I extends TaskInput = TaskInput, O extends TaskOutput = TaskOutput>(params?: IListTaskParams): Promise<Result<IListTasksResponse<I, O>, BackgroundTaskPersistenceError>>;
+    create<I extends TaskInput = TaskInput>(data: ITaskCreateData<I>): Promise<Result<TaskService.Task<I>, BackgroundTaskPersistenceError>>;
+    update<I extends TaskInput = TaskInput, O extends TaskOutput = TaskOutput>(id: string, data: Partial<ITaskUpdateData<I, O>>): Promise<Result<TaskService.Task<I, O>, TaskNotFoundError | BackgroundTaskPersistenceError>>;
+    delete(id: string): Promise<Result<void, TaskNotFoundError | BackgroundTaskPersistenceError>>;
+}
+/** Reads and writes background tasks. Publishes no events; the task use cases do that. */
+export declare const TasksRepository: import("@webiny/di").Abstraction<ITasksRepository>;
+export declare namespace TasksRepository {
+    type Interface = ITasksRepository;
+}
+type LogError = TaskLogNotFoundError | BackgroundTaskPersistenceError;
+export interface ITaskLogsRepository {
+    create(task: Pick<TaskService.Task, "id">, data: ITaskLogCreateInput): Promise<Result<ITaskLog, BackgroundTaskPersistenceError>>;
+    update(id: string, data: ITaskLogUpdateInput): Promise<Result<ITaskLog, LogError>>;
+    delete(id: string): Promise<Result<void, LogError>>;
+    get(id: string): Promise<Result<ITaskLog, LogError>>;
+    getLatest(taskId: string): Promise<Result<ITaskLog, LogError>>;
+    list(params: IListTaskLogParams): Promise<Result<IListTaskLogsResponse, BackgroundTaskPersistenceError>>;
+}
+/** Reads and writes the logs of background tasks. */
+export declare const TaskLogsRepository: import("@webiny/di").Abstraction<ITaskLogsRepository>;
+export declare namespace TaskLogsRepository {
+    type Interface = ITaskLogsRepository;
+}
+export {};

package/api/domain/task/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/task/abstractions.js","sources":["../../../../src/api/domain/task/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\nimport type { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport type {\n    IListTaskLogParams,\n    IListTaskLogsResponse,\n    IListTaskParams,\n    IListTasksResponse,\n    ITaskCreateData,\n    ITaskLog,\n    ITaskLogCreateInput,\n    ITaskLogUpdateInput,\n    ITaskUpdateData\n} from \"~/api/types.js\";\nimport type {\n    BackgroundTaskPersistenceError,\n    TaskLogNotFoundError,\n    TaskNotFoundError\n} from \"~/api/domain/errors.js\";\n\n// ============================================================================\n// Model providers\n// ============================================================================\n\nexport interface ITaskModelProvider {\n    get(): Promise<CmsModel>;\n}\n\n/** The private CMS model that stores background tasks. */\nexport const TaskModelProvider = createAbstraction<ITaskModelProvider>(\"Tasks/TaskModelProvider\");\n\nexport namespace TaskModelProvider {\n    export type Interface = ITaskModelProvider;\n}\n\nexport interface ITaskLogModelProvider {\n    get(): Promise<CmsModel>;\n}\n\n/** The private CMS model that stores background task logs. */\nexport const TaskLogModelProvider = createAbstraction<ITaskLogModelProvider>(\n    \"Tasks/TaskLogModelProvider\"\n);\n\nexport namespace TaskLogModelProvider {\n    export type Interface = ITaskLogModelProvider;\n}\n\n// ============================================================================\n// Tasks repository\n// ============================================================================\n\ntype TaskInput = TaskService.TaskInput;\ntype TaskOutput = TaskService.GenericOutput;\n\nexport interface ITasksRepository {\n    get<I extends TaskInput = TaskInput, O extends TaskOutput = TaskOutput>(\n        id: string\n    ): Promise<Result<TaskService.Task<I, O>, TaskNotFoundError | BackgroundTaskPersistenceError>>;\n    list<I extends TaskInput = TaskInput, O extends TaskOutput = TaskOutput>(\n        params?: IListTaskParams\n    ): Promise<Result<IListTasksResponse<I, O>, BackgroundTaskPersistenceError>>;\n    create<I extends TaskInput = TaskInput>(\n        data: ITaskCreateData<I>\n    ): Promise<Result<TaskService.Task<I>, BackgroundTaskPersistenceError>>;\n    update<I extends TaskInput = TaskInput, O extends TaskOutput = TaskOutput>(\n        id: string,\n        data: Partial<ITaskUpdateData<I, O>>\n    ): Promise<Result<TaskService.Task<I, O>, TaskNotFoundError | BackgroundTaskPersistenceError>>;\n    delete(id: string): Promise<Result<void, TaskNotFoundError | BackgroundTaskPersistenceError>>;\n}\n\n/** Reads and writes background tasks. Publishes no events; the task use cases do that. */\nexport const TasksRepository = createAbstraction<ITasksRepository>(\"Tasks/TasksRepository\");\n\nexport namespace TasksRepository {\n    export type Interface = ITasksRepository;\n}\n\n// ============================================================================\n// Task logs repository\n// ============================================================================\n\ntype LogError = TaskLogNotFoundError | BackgroundTaskPersistenceError;\n\nexport interface ITaskLogsRepository {\n    create(\n        task: Pick<TaskService.Task, \"id\">,\n        data: ITaskLogCreateInput\n    ): Promise<Result<ITaskLog, BackgroundTaskPersistenceError>>;\n    update(id: string, data: ITaskLogUpdateInput): Promise<Result<ITaskLog, LogError>>;\n    delete(id: string): Promise<Result<void, LogError>>;\n    get(id: string): Promise<Result<ITaskLog, LogError>>;\n    getLatest(taskId: string): Promise<Result<ITaskLog, LogError>>;\n    list(\n        params: IListTaskLogParams\n    ): Promise<Result<IListTaskLogsResponse, BackgroundTaskPersistenceError>>;\n}\n\n/** Reads and writes the logs of background tasks. */\nexport const TaskLogsRepository = createAbstraction<ITaskLogsRepository>(\n    \"Tasks/TaskLogsRepository\"\n);\n\nexport namespace TaskLogsRepository {\n    export type Interface = ITaskLogsRepository;\n}\n"],"names":["TaskModelProvider","createAbstraction","TaskLogModelProvider","TasksRepository","TaskLogsRepository"],"mappings":";AA6BO,MAAMA,oBAAoBC,kBAAsC;AAWhE,MAAMC,uBAAuBD,kBAChC;AAgCG,MAAME,kBAAkBF,kBAAoC;AA2B5D,MAAMG,qBAAqBH,kBAC9B"}

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

@@ -0,0 +1 @@
+export declare const createRevisionId: (id: string) => string;

package/api/domain/task/createRevisionId.js

@@ -0,0 +1,8 @@
+import { parseIdentifier } from "@webiny/utils";
+const createRevisionId = (id)=>{
+    const { id: entryId } = parseIdentifier(id);
+    return `${entryId}#0001`;
+};
+export { createRevisionId };
+
+//# sourceMappingURL=createRevisionId.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/task/createRevisionId.js","sources":["../../../../src/api/domain/task/createRevisionId.ts"],"sourcesContent":["import { parseIdentifier } from \"@webiny/utils\";\n\n// Tasks and logs are never revised, so every entry lives in its first revision.\nexport const createRevisionId = (id: string): string => {\n    const { id: entryId } = parseIdentifier(id);\n    return `${entryId}#0001`;\n};\n"],"names":["createRevisionId","id","entryId","parseIdentifier"],"mappings":";AAGO,MAAMA,mBAAmB,CAACC;IAC7B,MAAM,EAAE,IAAIC,OAAO,EAAE,GAAGC,gBAAgBF;IACxC,OAAO,GAAGC,QAAQ,KAAK,CAAC;AAC5B"}

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

@@ -0,0 +1,3 @@
+import type { CmsEntry } from "@webiny/api-headless-cms/types/index.js";
+import type { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+export declare const entryToTask: <I extends TaskService.TaskInput = TaskService.TaskInput, O extends TaskService.GenericOutput = TaskService.GenericOutput>(entry: CmsEntry) => TaskService.Task<I, O>;

package/api/domain/task/entryToTask.js

@@ -0,0 +1,20 @@
+const entryToTask = (entry)=>({
+        id: entry.entryId,
+        createdOn: entry.createdOn,
+        savedOn: entry.savedOn,
+        createdBy: entry.createdBy,
+        name: entry.values.name,
+        definitionId: entry.values.definitionId,
+        input: entry.values.input,
+        output: entry.values.output,
+        taskStatus: entry.values.taskStatus,
+        executionName: entry.values.executionName || "",
+        eventResponse: entry.values.eventResponse,
+        startedOn: entry.values.startedOn,
+        finishedOn: entry.values.finishedOn,
+        iterations: entry.values.iterations,
+        parentId: entry.values.parentId
+    });
+export { entryToTask };
+
+//# sourceMappingURL=entryToTask.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/task/entryToTask.js","sources":["../../../../src/api/domain/task/entryToTask.ts"],"sourcesContent":["import type { CmsEntry } from \"@webiny/api-headless-cms/types/index.js\";\nimport type { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\n\nexport const entryToTask = <\n    I extends TaskService.TaskInput = TaskService.TaskInput,\n    O extends TaskService.GenericOutput = TaskService.GenericOutput\n>(\n    entry: CmsEntry\n): TaskService.Task<I, O> => {\n    return {\n        id: entry.entryId,\n        createdOn: entry.createdOn,\n        savedOn: entry.savedOn,\n        createdBy: entry.createdBy,\n        name: entry.values.name,\n        definitionId: entry.values.definitionId,\n        input: entry.values.input,\n        output: entry.values.output,\n        taskStatus: entry.values.taskStatus,\n        executionName: entry.values.executionName || \"\",\n        eventResponse: entry.values.eventResponse,\n        startedOn: entry.values.startedOn,\n        finishedOn: entry.values.finishedOn,\n        iterations: entry.values.iterations,\n        parentId: entry.values.parentId\n    };\n};\n"],"names":["entryToTask","entry"],"mappings":"AAGO,MAAMA,cAAc,CAIvBC,QAEO;QACH,IAAIA,MAAM,OAAO;QACjB,WAAWA,MAAM,SAAS;QAC1B,SAASA,MAAM,OAAO;QACtB,WAAWA,MAAM,SAAS;QAC1B,MAAMA,MAAM,MAAM,CAAC,IAAI;QACvB,cAAcA,MAAM,MAAM,CAAC,YAAY;QACvC,OAAOA,MAAM,MAAM,CAAC,KAAK;QACzB,QAAQA,MAAM,MAAM,CAAC,MAAM;QAC3B,YAAYA,MAAM,MAAM,CAAC,UAAU;QACnC,eAAeA,MAAM,MAAM,CAAC,aAAa,IAAI;QAC7C,eAAeA,MAAM,MAAM,CAAC,aAAa;QACzC,WAAWA,MAAM,MAAM,CAAC,SAAS;QACjC,YAAYA,MAAM,MAAM,CAAC,UAAU;QACnC,YAAYA,MAAM,MAAM,CAAC,UAAU;QACnC,UAAUA,MAAM,MAAM,CAAC,QAAQ;IACnC"}

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

@@ -0,0 +1,3 @@
+import type { CmsEntry } from "@webiny/api-headless-cms/types/index.js";
+import type { ITaskLog } from "../../../api/types.js";
+export declare const entryToTaskLog: (entry: CmsEntry) => ITaskLog;

package/api/domain/task/entryToTaskLog.js

@@ -0,0 +1,12 @@
+const entryToTaskLog = (entry)=>({
+        id: entry.entryId,
+        createdOn: entry.createdOn,
+        createdBy: entry.createdBy,
+        executionName: entry.values.executionName,
+        task: entry.values.task,
+        iteration: entry.values.iteration,
+        items: entry.values.items || []
+    });
+export { entryToTaskLog };
+
+//# sourceMappingURL=entryToTaskLog.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/task/entryToTaskLog.js","sources":["../../../../src/api/domain/task/entryToTaskLog.ts"],"sourcesContent":["import type { CmsEntry } from \"@webiny/api-headless-cms/types/index.js\";\nimport type { ITaskLog } from \"~/api/types.js\";\n\nexport const entryToTaskLog = (entry: CmsEntry): ITaskLog => {\n    return {\n        id: entry.entryId,\n        createdOn: entry.createdOn,\n        createdBy: entry.createdBy,\n        executionName: entry.values.executionName,\n        task: entry.values.task,\n        iteration: entry.values.iteration,\n        items: entry.values.items || []\n    };\n};\n"],"names":["entryToTaskLog","entry"],"mappings":"AAGO,MAAMA,iBAAiB,CAACC,QACpB;QACH,IAAIA,MAAM,OAAO;QACjB,WAAWA,MAAM,SAAS;QAC1B,WAAWA,MAAM,SAAS;QAC1B,eAAeA,MAAM,MAAM,CAAC,aAAa;QACzC,MAAMA,MAAM,MAAM,CAAC,IAAI;QACvB,WAAWA,MAAM,MAAM,CAAC,SAAS;QACjC,OAAOA,MAAM,MAAM,CAAC,KAAK,IAAI,EAAE;IACnC"}

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

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

package/api/features/AbortTask/AbortTaskUseCase.js

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

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

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

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

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

package/api/features/AbortTask/feature.js

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

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

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

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

@@ -1,7 +1,27 @@
+import { Logger } from "@webiny/api-core/features/logger/index.js";
 import { CleanupTaskSubtreeUseCase as UseCaseAbstraction } from "./abstractions.js";
-import type { Context } from "../../../api/types.js";
-export declare class CleanupTaskSubtreeUseCaseImpl implements UseCaseAbstraction.Interface {
-    private readonly context;
-    constructor(context: Context);
-    execute(taskId: string): Promise<void>;
+import { TaskLogsRepository, TasksRepository } from "../../../api/domain/task/abstractions.js";
+import { DeleteTaskUseCase } from "../../../api/features/DeleteTask/index.js";
+/**
+ * Deletes the task identified by `rootId`, all its descendants, and their logs. The logs are listed
+ * by task id whatever the owning definition says (`databaseLogs`, or no registered definition): a
+ * self-cleaning task writes none of its own, but an abort still writes one log row, and cleanup
+ * removes whatever exists. Bottom-up and best-effort: a record that fails to delete is logged and
+ * skipped, and the use case never throws.
+ */
+declare class CleanupTaskSubtreeUseCaseImpl implements UseCaseAbstraction.Interface {
+    private readonly tasks;
+    private readonly logs;
+    private readonly deleteTask;
+    private readonly logger;
+    constructor(tasks: TasksRepository.Interface, logs: TaskLogsRepository.Interface, deleteTask: DeleteTaskUseCase.Interface, logger: Logger.Interface);
+    execute(rootId: string): Promise<void>;
+    private collectSubtree;
+    private listChildren;
+    private listLogs;
+    private deleteTaskLogs;
 }
+export declare const CleanupTaskSubtreeUseCase: typeof CleanupTaskSubtreeUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICleanupTaskSubtreeUseCase>;
+};
+export {};

package/api/features/CleanupTaskSubtree/CleanupTaskSubtreeUseCase.js

@@ -1,11 +1,117 @@
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { CleanupTaskSubtreeUseCase } from "./abstractions.js";
+import { TaskLogsRepository, TasksRepository } from "../../domain/task/abstractions.js";
+import { DeleteTaskUseCase } from "../DeleteTask/index.js";
+const PAGE_SIZE = 100;
 class CleanupTaskSubtreeUseCaseImpl {
-    constructor(context){
-        this.context = context;
+    constructor(tasks, logs, deleteTask, logger){
+        this.tasks = tasks;
+        this.logs = logs;
+        this.deleteTask = deleteTask;
+        this.logger = logger;
     }
-    async execute(taskId) {
-        await this.context.tasks.cleanupTaskSubtree(taskId);
+    async execute(rootId) {
+        let ordered;
+        try {
+            ordered = await this.collectSubtree(rootId);
+        } catch (error) {
+            this.logger.warn({
+                error
+            }, `cleanupTaskSubtree: failed to collect the subtree of task "${rootId}", skipping.`);
+            return;
+        }
+        for (const task of ordered){
+            await this.deleteTaskLogs(task);
+            const result = await this.deleteTask.execute(task.id);
+            if (result.isFail()) this.logger.warn({
+                error: result.error
+            }, `cleanupTaskSubtree: failed to delete task "${task.id}".`);
+        }
+    }
+    async collectSubtree(rootId) {
+        const root = await this.tasks.get(rootId);
+        if (root.isFail()) return [];
+        const order = [
+            root.value
+        ];
+        const seen = new Set([
+            root.value.id
+        ]);
+        let i = 0;
+        while(i < order.length){
+            const current = order[i++];
+            for (const child of (await this.listChildren(current.id)))if (!seen.has(child.id)) {
+                seen.add(child.id);
+                order.push(child);
+            }
+        }
+        return order.reverse();
+    }
+    async listChildren(parentId) {
+        const children = [];
+        let after = null;
+        do {
+            const params = {
+                where: {
+                    parentId
+                },
+                limit: PAGE_SIZE,
+                after
+            };
+            const result = await this.tasks.list(params);
+            if (result.isFail()) throw result.error;
+            const { items, meta } = result.value;
+            children.push(...items);
+            after = meta.hasMoreItems ? meta.cursor : null;
+        }while (after)
+        return children;
+    }
+    async listLogs(taskId) {
+        const logs = [];
+        let after = null;
+        do {
+            const params = {
+                where: {
+                    task: taskId
+                },
+                limit: PAGE_SIZE,
+                after
+            };
+            const result = await this.logs.list(params);
+            if (result.isFail()) throw result.error;
+            const { items, meta } = result.value;
+            logs.push(...items);
+            after = meta.hasMoreItems ? meta.cursor : null;
+        }while (after)
+        return logs;
+    }
+    async deleteTaskLogs(task) {
+        let logs;
+        try {
+            logs = await this.listLogs(task.id);
+        } catch (error) {
+            this.logger.warn({
+                error
+            }, `cleanupTaskSubtree: failed to list logs for task "${task.id}".`);
+            return;
+        }
+        for (const log of logs){
+            const result = await this.logs.delete(log.id);
+            if (result.isFail()) this.logger.warn({
+                error: result.error
+            }, `cleanupTaskSubtree: failed to delete log "${log.id}" for task "${task.id}".`);
+        }
     }
 }
-export { CleanupTaskSubtreeUseCaseImpl };
+const CleanupTaskSubtreeUseCase_CleanupTaskSubtreeUseCase = CleanupTaskSubtreeUseCase.createImplementation({
+    implementation: CleanupTaskSubtreeUseCaseImpl,
+    dependencies: [
+        TasksRepository,
+        TaskLogsRepository,
+        DeleteTaskUseCase,
+        Logger
+    ]
+});
+export { CleanupTaskSubtreeUseCase_CleanupTaskSubtreeUseCase as CleanupTaskSubtreeUseCase };
 
 //# sourceMappingURL=CleanupTaskSubtreeUseCase.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"api/features/CleanupTaskSubtree/CleanupTaskSubtreeUseCase.js","sources":["../../../../src/api/features/CleanupTaskSubtree/CleanupTaskSubtreeUseCase.ts"],"sourcesContent":["import { CleanupTaskSubtreeUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport type { Context } from \"~/api/types.js\";\n\nexport class CleanupTaskSubtreeUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(private readonly context: Context) {}\n\n    public async execute(taskId: string): Promise<void> {\n        await this.context.tasks.cleanupTaskSubtree(taskId);\n    }\n}\n"],"names":["CleanupTaskSubtreeUseCaseImpl","context","taskId"],"mappings":"AAGO,MAAMA;IACT,YAAoCC,OAAgB,CAAE;aAAlBA,OAAO,GAAPA;IAAmB;IAEvD,MAAa,QAAQC,MAAc,EAAiB;QAChD,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,kBAAkB,CAACA;IAChD;AACJ"}
+{"version":3,"file":"api/features/CleanupTaskSubtree/CleanupTaskSubtreeUseCase.js","sources":["../../../../src/api/features/CleanupTaskSubtree/CleanupTaskSubtreeUseCase.ts"],"sourcesContent":["import { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { CleanupTaskSubtreeUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { TaskLogsRepository, TasksRepository } from \"~/api/domain/task/abstractions.js\";\nimport { DeleteTaskUseCase } from \"~/api/features/DeleteTask/index.js\";\nimport type { ITask } from \"~/api/types.js\";\nimport type { ITaskLog } from \"~/api/types.js\";\nimport type { IListTaskParams } from \"~/api/types.js\";\nimport type { IListTaskLogParams } from \"~/api/types.js\";\n\nconst PAGE_SIZE = 100;\n\n/**\n * Deletes the task identified by `rootId`, all its descendants, and their logs. The logs are listed\n * by task id whatever the owning definition says (`databaseLogs`, or no registered definition): a\n * self-cleaning task writes none of its own, but an abort still writes one log row, and cleanup\n * removes whatever exists. Bottom-up and best-effort: a record that fails to delete is logged and\n * skipped, and the use case never throws.\n */\nclass CleanupTaskSubtreeUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(\n        private readonly tasks: TasksRepository.Interface,\n        private readonly logs: TaskLogsRepository.Interface,\n        private readonly deleteTask: DeleteTaskUseCase.Interface,\n        private readonly logger: Logger.Interface\n    ) {}\n\n    public async execute(rootId: string): Promise<void> {\n        let ordered: ITask[];\n        try {\n            ordered = await this.collectSubtree(rootId);\n        } catch (error) {\n            // Without the full subtree, deleting anything could orphan the tasks we didn't find.\n            this.logger.warn(\n                { error },\n                `cleanupTaskSubtree: failed to collect the subtree of task \"${rootId}\", skipping.`\n            );\n            return;\n        }\n        for (const task of ordered) {\n            await this.deleteTaskLogs(task);\n            const result = await this.deleteTask.execute(task.id);\n            if (result.isFail()) {\n                this.logger.warn(\n                    { error: result.error },\n                    `cleanupTaskSubtree: failed to delete task \"${task.id}\".`\n                );\n            }\n        }\n    }\n\n    // Breadth-first from the root, then reversed, so children are deleted before their parents.\n    private async collectSubtree(rootId: string): Promise<ITask[]> {\n        const root = await this.tasks.get(rootId);\n        if (root.isFail()) {\n            return [];\n        }\n        const order: ITask[] = [root.value];\n        const seen = new Set<string>([root.value.id]);\n        let i = 0;\n        while (i < order.length) {\n            const current = order[i++];\n            for (const child of await this.listChildren(current.id)) {\n                if (seen.has(child.id)) {\n                    continue;\n                }\n                seen.add(child.id);\n                order.push(child);\n            }\n        }\n        return order.reverse();\n    }\n\n    // Every page, not just the first: a parent can have more children than one page holds.\n    private async listChildren(parentId: string): Promise<ITask[]> {\n        const children: ITask[] = [];\n        let after: string | null = null;\n        do {\n            const params: IListTaskParams = { where: { parentId }, limit: PAGE_SIZE, after };\n            const result = await this.tasks.list(params);\n            if (result.isFail()) {\n                throw result.error;\n            }\n            const { items, meta } = result.value;\n            children.push(...items);\n            after = meta.hasMoreItems ? meta.cursor : null;\n        } while (after);\n        return children;\n    }\n\n    // All pages are read before anything is deleted, so deleting doesn't shift what a cursor sees.\n    private async listLogs(taskId: string): Promise<ITaskLog[]> {\n        const logs: ITaskLog[] = [];\n        let after: string | null = null;\n        do {\n            const params: IListTaskLogParams = { where: { task: taskId }, limit: PAGE_SIZE, after };\n            const result = await this.logs.list(params);\n            if (result.isFail()) {\n                throw result.error;\n            }\n            const { items, meta } = result.value;\n            logs.push(...items);\n            after = meta.hasMoreItems ? meta.cursor : null;\n        } while (after);\n        return logs;\n    }\n\n    private async deleteTaskLogs(task: ITask): Promise<void> {\n        let logs: ITaskLog[];\n        try {\n            logs = await this.listLogs(task.id);\n        } catch (error) {\n            this.logger.warn(\n                { error },\n                `cleanupTaskSubtree: failed to list logs for task \"${task.id}\".`\n            );\n            return;\n        }\n        for (const log of logs) {\n            const result = await this.logs.delete(log.id);\n            if (result.isFail()) {\n                this.logger.warn(\n                    { error: result.error },\n                    `cleanupTaskSubtree: failed to delete log \"${log.id}\" for task \"${task.id}\".`\n                );\n            }\n        }\n    }\n}\n\nexport const CleanupTaskSubtreeUseCase = UseCaseAbstraction.createImplementation({\n    implementation: CleanupTaskSubtreeUseCaseImpl,\n    dependencies: [TasksRepository, TaskLogsRepository, DeleteTaskUseCase, Logger]\n});\n"],"names":["PAGE_SIZE","CleanupTaskSubtreeUseCaseImpl","tasks","logs","deleteTask","logger","rootId","ordered","error","task","result","root","order","seen","Set","i","current","child","parentId","children","after","params","items","meta","taskId","log","CleanupTaskSubtreeUseCase","UseCaseAbstraction","TasksRepository","TaskLogsRepository","DeleteTaskUseCase","Logger"],"mappings":"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"}

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

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

package/api/features/CleanupTaskSubtree/feature.js

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

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

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

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

@@ -1,2 +1,2 @@
 export { CleanupTaskSubtreeUseCase } from "./abstractions.js";
-export { CleanupTaskSubtreeUseCaseImpl } from "./CleanupTaskSubtreeUseCase.js";
+export { CleanupTaskSubtreeFeature } from "./feature.js";

package/api/features/CleanupTaskSubtree/index.js

@@ -1,2 +1,2 @@
 export { CleanupTaskSubtreeUseCase } from "./abstractions.js";
-export { CleanupTaskSubtreeUseCaseImpl } from "./CleanupTaskSubtreeUseCase.js";
+export { CleanupTaskSubtreeFeature } from "./feature.js";

package/api/features/CreateTask/CreateTaskUseCase.d.ts

@@ -0,0 +1,17 @@
+import { Result } from "@webiny/feature/api";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import { CreateTaskUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { GetRunnableTaskDefinitionUseCase } from "../../../api/features/GetRunnableTaskDefinition/index.js";
+import { TasksRepository } from "../../../api/domain/task/abstractions.js";
+declare class CreateTaskUseCaseImpl implements UseCaseAbstraction.Interface {
+    private readonly getDefinition;
+    private readonly eventPublisher;
+    private readonly repository;
+    constructor(getDefinition: GetRunnableTaskDefinitionUseCase.Interface, eventPublisher: EventPublisher.Interface, repository: TasksRepository.Interface);
+    execute<I extends TaskService.TaskInput = TaskService.TaskInput>(data: UseCaseAbstraction.Params<I>): Promise<Result<TaskService.Task<I>, UseCaseAbstraction.Error>>;
+}
+export declare const CreateTaskUseCase: typeof CreateTaskUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateTaskUseCase>;
+};
+export {};

package/api/features/CreateTask/CreateTaskUseCase.js

@@ -0,0 +1,56 @@
+import zod from "zod";
+import { Result } from "@webiny/feature/api";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { CreateTaskUseCase } from "./abstractions.js";
+import { GetRunnableTaskDefinitionUseCase } from "../GetRunnableTaskDefinition/index.js";
+import { TasksRepository } from "../../domain/task/abstractions.js";
+import { TaskInputValidationError } from "../../domain/errors.js";
+import { TaskAfterCreateEvent, TaskBeforeCreateEvent } from "../../events/index.js";
+const toZodSchema = (schema)=>{
+    if (!schema) return zod.looseObject({});
+    if (schema instanceof zod.ZodObject) return schema.loose();
+    if (schema instanceof zod.ZodType) return schema;
+    return zod.looseObject(schema);
+};
+const validateInput = async (definition, input)=>{
+    if (!definition.createInputValidation) return null;
+    const schema = toZodSchema(definition.createInputValidation({
+        validator: zod
+    }));
+    const result = await schema.safeParseAsync(input);
+    return result.success ? null : result.error;
+};
+class CreateTaskUseCaseImpl {
+    constructor(getDefinition, eventPublisher, repository){
+        this.getDefinition = getDefinition;
+        this.eventPublisher = eventPublisher;
+        this.repository = repository;
+    }
+    async execute(data) {
+        const definition = this.getDefinition.execute(data.definitionId);
+        if (definition.isFail()) return Result.fail(definition.error);
+        const invalid = await validateInput(definition.value, data.input);
+        if (invalid) return Result.fail(new TaskInputValidationError(invalid));
+        await this.eventPublisher.publish(new TaskBeforeCreateEvent({
+            input: data
+        }));
+        const result = await this.repository.create(data);
+        if (result.isFail()) return Result.fail(result.error);
+        await this.eventPublisher.publish(new TaskAfterCreateEvent({
+            input: data,
+            task: result.value
+        }));
+        return Result.ok(result.value);
+    }
+}
+const CreateTaskUseCase_CreateTaskUseCase = CreateTaskUseCase.createImplementation({
+    implementation: CreateTaskUseCaseImpl,
+    dependencies: [
+        GetRunnableTaskDefinitionUseCase,
+        EventPublisher,
+        TasksRepository
+    ]
+});
+export { CreateTaskUseCase_CreateTaskUseCase as CreateTaskUseCase };
+
+//# sourceMappingURL=CreateTaskUseCase.js.map

package/api/features/CreateTask/CreateTaskUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/CreateTask/CreateTaskUseCase.js","sources":["../../../../src/api/features/CreateTask/CreateTaskUseCase.ts"],"sourcesContent":["import zod from \"zod\";\nimport { Result } from \"@webiny/feature/api\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport type { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport { CreateTaskUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { GetRunnableTaskDefinitionUseCase } from \"~/api/features/GetRunnableTaskDefinition/index.js\";\nimport { TasksRepository } from \"~/api/domain/task/abstractions.js\";\nimport { TaskInputValidationError } from \"~/api/domain/errors.js\";\nimport { TaskAfterCreateEvent, TaskBeforeCreateEvent } from \"~/api/events/index.js\";\n\ntype InputSchema = GenericRecord<string, zod.ZodTypeAny> | zod.ZodTypeAny;\n\nconst toZodSchema = (schema: InputSchema) => {\n    if (!schema) {\n        return zod.looseObject({});\n    } else if (schema instanceof zod.ZodObject) {\n        return schema.loose();\n    } else if (schema instanceof zod.ZodType) {\n        return schema;\n    }\n    return zod.looseObject(schema);\n};\n\nconst validateInput = async (\n    definition: Pick<TaskDefinition.Runnable, \"createInputValidation\">,\n    input: unknown\n): Promise<zod.ZodError | null> => {\n    if (!definition.createInputValidation) {\n        return null;\n    }\n    const schema = toZodSchema(definition.createInputValidation({ validator: zod }));\n    const result = await schema.safeParseAsync(input);\n    return result.success ? null : result.error;\n};\n\nclass CreateTaskUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private readonly getDefinition: GetRunnableTaskDefinitionUseCase.Interface,\n        private readonly eventPublisher: EventPublisher.Interface,\n        private readonly repository: TasksRepository.Interface\n    ) {}\n\n    async execute<I extends TaskService.TaskInput = TaskService.TaskInput>(\n        data: UseCaseAbstraction.Params<I>\n    ): Promise<Result<TaskService.Task<I>, UseCaseAbstraction.Error>> {\n        const definition = this.getDefinition.execute(data.definitionId);\n        if (definition.isFail()) {\n            return Result.fail(definition.error);\n        }\n\n        const invalid = await validateInput(definition.value, data.input);\n        if (invalid) {\n            return Result.fail(new TaskInputValidationError(invalid));\n        }\n\n        await this.eventPublisher.publish(new TaskBeforeCreateEvent({ input: data }));\n\n        const result = await this.repository.create<I>(data);\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        await this.eventPublisher.publish(\n            new TaskAfterCreateEvent({ input: data, task: result.value })\n        );\n\n        return Result.ok(result.value);\n    }\n}\n\nexport const CreateTaskUseCase = UseCaseAbstraction.createImplementation({\n    implementation: CreateTaskUseCaseImpl,\n    dependencies: [GetRunnableTaskDefinitionUseCase, EventPublisher, TasksRepository]\n});\n"],"names":["toZodSchema","schema","zod","validateInput","definition","input","result","CreateTaskUseCaseImpl","getDefinition","eventPublisher","repository","data","Result","invalid","TaskInputValidationError","TaskBeforeCreateEvent","TaskAfterCreateEvent","CreateTaskUseCase","UseCaseAbstraction","GetRunnableTaskDefinitionUseCase","EventPublisher","TasksRepository"],"mappings":";;;;;;;;AAcA,MAAMA,cAAc,CAACC;IACjB,IAAI,CAACA,QACD,OAAOC,IAAI,WAAW,CAAC,CAAC;IACrB,IAAID,kBAAkBC,IAAI,SAAS,EACtC,OAAOD,OAAO,KAAK;IAChB,IAAIA,kBAAkBC,IAAI,OAAO,EACpC,OAAOD;IAEX,OAAOC,IAAI,WAAW,CAACD;AAC3B;AAEA,MAAME,gBAAgB,OAClBC,YACAC;IAEA,IAAI,CAACD,WAAW,qBAAqB,EACjC,OAAO;IAEX,MAAMH,SAASD,YAAYI,WAAW,qBAAqB,CAAC;QAAE,WAAWF;IAAI;IAC7E,MAAMI,SAAS,MAAML,OAAO,cAAc,CAACI;IAC3C,OAAOC,OAAO,OAAO,GAAG,OAAOA,OAAO,KAAK;AAC/C;AAEA,MAAMC;IACF,YACqBC,aAAyD,EACzDC,cAAwC,EACxCC,UAAqC,CACxD;aAHmBF,aAAa,GAAbA;aACAC,cAAc,GAAdA;aACAC,UAAU,GAAVA;IAClB;IAEH,MAAM,QACFC,IAAkC,EAC4B;QAC9D,MAAMP,aAAa,IAAI,CAAC,aAAa,CAAC,OAAO,CAACO,KAAK,YAAY;QAC/D,IAAIP,WAAW,MAAM,IACjB,OAAOQ,OAAO,IAAI,CAACR,WAAW,KAAK;QAGvC,MAAMS,UAAU,MAAMV,cAAcC,WAAW,KAAK,EAAEO,KAAK,KAAK;QAChE,IAAIE,SACA,OAAOD,OAAO,IAAI,CAAC,IAAIE,yBAAyBD;QAGpD,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,IAAIE,sBAAsB;YAAE,OAAOJ;QAAK;QAE1E,MAAML,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAAIK;QAC/C,IAAIL,OAAO,MAAM,IACb,OAAOM,OAAO,IAAI,CAACN,OAAO,KAAK;QAGnC,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIU,qBAAqB;YAAE,OAAOL;YAAM,MAAML,OAAO,KAAK;QAAC;QAG/D,OAAOM,OAAO,EAAE,CAACN,OAAO,KAAK;IACjC;AACJ;AAEO,MAAMW,sCAAoBC,kBAAAA,oBAAuC,CAAC;IACrE,gBAAgBX;IAChB,cAAc;QAACY;QAAkCC;QAAgBC;KAAgB;AACrF"}

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

@@ -0,0 +1,21 @@
+import { type Result } from "@webiny/feature/api";
+import type { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import type { ITaskCreateData } from "../../../api/types.js";
+import type { BackgroundTaskPersistenceError, TaskDefinitionNotFoundError, TaskInputValidationError } from "../../../api/domain/errors.js";
+export interface ICreateTaskUseCase {
+    execute<I extends TaskService.TaskInput = TaskService.TaskInput>(data: ITaskCreateData<I>): Promise<Result<TaskService.Task<I>, UseCaseError>>;
+}
+export interface ICreateTaskUseCaseErrors {
+    definitionNotFound: TaskDefinitionNotFoundError;
+    validation: TaskInputValidationError;
+    persistence: BackgroundTaskPersistenceError;
+}
+type UseCaseError = ICreateTaskUseCaseErrors[keyof ICreateTaskUseCaseErrors];
+/** Store a new task in the pending state. Doesn't send it for execution; see TriggerTaskUseCase. */
+export declare const CreateTaskUseCase: import("@webiny/di").Abstraction<ICreateTaskUseCase>;
+export declare namespace CreateTaskUseCase {
+    type Interface = ICreateTaskUseCase;
+    type Params<I extends TaskService.TaskInput = TaskService.TaskInput> = ITaskCreateData<I>;
+    type Error = UseCaseError;
+}
+export {};

package/api/features/CreateTask/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/CreateTask/abstractions.js","sources":["../../../../src/api/features/CreateTask/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport type { ITaskCreateData } from \"~/api/types.js\";\nimport type {\n    BackgroundTaskPersistenceError,\n    TaskDefinitionNotFoundError,\n    TaskInputValidationError\n} from \"~/api/domain/errors.js\";\n\nexport interface ICreateTaskUseCase {\n    execute<I extends TaskService.TaskInput = TaskService.TaskInput>(\n        data: ITaskCreateData<I>\n    ): Promise<Result<TaskService.Task<I>, UseCaseError>>;\n}\n\nexport interface ICreateTaskUseCaseErrors {\n    definitionNotFound: TaskDefinitionNotFoundError;\n    validation: TaskInputValidationError;\n    persistence: BackgroundTaskPersistenceError;\n}\n\ntype UseCaseError = ICreateTaskUseCaseErrors[keyof ICreateTaskUseCaseErrors];\n\n/** Store a new task in the pending state. Doesn't send it for execution; see TriggerTaskUseCase. */\nexport const CreateTaskUseCase = createAbstraction<ICreateTaskUseCase>(\"Tasks/CreateTaskUseCase\");\n\nexport namespace CreateTaskUseCase {\n    export type Interface = ICreateTaskUseCase;\n    export type Params<I extends TaskService.TaskInput = TaskService.TaskInput> =\n        ITaskCreateData<I>;\n    export type Error = UseCaseError;\n}\n"],"names":["CreateTaskUseCase","createAbstraction"],"mappings":";AAwBO,MAAMA,oBAAoBC,kBAAsC"}

package/api/features/{GetTaskDefinition → CreateTask}/feature.d.ts

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

package/api/features/CreateTask/feature.js

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

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

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