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

package/api/domain/task/TasksRepository.js

@@ -0,0 +1,126 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries/index.js";
+import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/index.js";
+import { CmsWhereMapper } from "@webiny/api-headless-cms";
+import { TaskModelProvider, TasksRepository } from "./abstractions.js";
+import { entryToTask } from "./entryToTask.js";
+import { createRevisionId } from "./createRevisionId.js";
+import { BackgroundTaskPersistenceError, TaskNotFoundError } from "../errors.js";
+import { TaskDataStatus } from "../../types.js";
+const ENTRY_NOT_FOUND = "Cms/Entry/NotFound";
+const toTaskError = (error)=>{
+    if (error.code === ENTRY_NOT_FOUND) return new TaskNotFoundError();
+    return BackgroundTaskPersistenceError.from(error);
+};
+class TasksRepositoryImpl {
+    constructor(identityContext, modelProvider, getEntryById, listLatestEntries, createEntry, updateEntry, deleteEntry, whereMapper){
+        this.identityContext = identityContext;
+        this.modelProvider = modelProvider;
+        this.getEntryById = getEntryById;
+        this.listLatestEntries = listLatestEntries;
+        this.createEntry = createEntry;
+        this.updateEntry = updateEntry;
+        this.deleteEntry = deleteEntry;
+        this.whereMapper = whereMapper;
+    }
+    async get(id) {
+        try {
+            const result = await this.identityContext.withoutAuthorization(async ()=>{
+                const model = await this.modelProvider.get();
+                return this.getEntryById.execute(model, createRevisionId(id));
+            });
+            if (result.isFail()) return Result.fail(toTaskError(result.error));
+            return Result.ok(entryToTask(result.value));
+        } catch (error) {
+            return Result.fail(BackgroundTaskPersistenceError.from(error));
+        }
+    }
+    async list(params) {
+        try {
+            const result = await this.identityContext.withoutAuthorization(async ()=>{
+                const model = await this.modelProvider.get();
+                return this.listLatestEntries.execute(model, {
+                    ...params,
+                    where: this.whereMapper.map({
+                        input: params?.where,
+                        fields: model.fields
+                    })
+                });
+            });
+            if (result.isFail()) return Result.fail(BackgroundTaskPersistenceError.from(result.error));
+            const { entries, meta } = result.value;
+            return Result.ok({
+                items: entries.map((entry)=>entryToTask(entry)),
+                meta
+            });
+        } catch (error) {
+            return Result.fail(BackgroundTaskPersistenceError.from(error));
+        }
+    }
+    async create(data) {
+        try {
+            const result = await this.identityContext.withoutAuthorization(async ()=>{
+                const model = await this.modelProvider.get();
+                return this.createEntry.execute(model, {
+                    values: {
+                        ...data,
+                        iterations: 0,
+                        taskStatus: TaskDataStatus.PENDING
+                    }
+                });
+            });
+            if (result.isFail()) return Result.fail(BackgroundTaskPersistenceError.from(result.error));
+            return Result.ok(entryToTask(result.value));
+        } catch (error) {
+            return Result.fail(BackgroundTaskPersistenceError.from(error));
+        }
+    }
+    async update(id, data) {
+        try {
+            const result = await this.identityContext.withoutAuthorization(async ()=>{
+                const model = await this.modelProvider.get();
+                return this.updateEntry.execute(model, createRevisionId(id), {
+                    values: {
+                        ...data
+                    }
+                });
+            });
+            if (result.isFail()) return Result.fail(toTaskError(result.error));
+            return Result.ok(entryToTask(result.value));
+        } catch (error) {
+            return Result.fail(BackgroundTaskPersistenceError.from(error));
+        }
+    }
+    async delete(id) {
+        try {
+            const result = await this.identityContext.withoutAuthorization(async ()=>{
+                const model = await this.modelProvider.get();
+                return this.deleteEntry.execute(model, createRevisionId(id));
+            });
+            if (result.isFail()) return Result.fail(toTaskError(result.error));
+            return Result.ok();
+        } catch (error) {
+            return Result.fail(BackgroundTaskPersistenceError.from(error));
+        }
+    }
+}
+const TasksRepository_TasksRepository = TasksRepository.createImplementation({
+    implementation: TasksRepositoryImpl,
+    dependencies: [
+        IdentityContext,
+        TaskModelProvider,
+        GetEntryByIdUseCase,
+        ListLatestEntriesUseCase,
+        CreateEntryUseCase,
+        UpdateEntryUseCase,
+        DeleteEntryUseCase,
+        CmsWhereMapper
+    ]
+});
+export { TasksRepository_TasksRepository as TasksRepository };
+
+//# sourceMappingURL=TasksRepository.js.map

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":"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"}

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/events/TaskAfterCreateEvent.d.ts

@@ -0,0 +1,6 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import { TaskAfterCreatePayload } from "./abstractions.js";
+export declare class TaskAfterCreateEvent extends DomainEvent<TaskAfterCreatePayload> {
+    eventType: "task.afterCreate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher/abstractions.js").IEventHandler<DomainEvent<TaskAfterCreatePayload>>>;
+}

package/api/events/TaskAfterCreateEvent.js

@@ -0,0 +1,13 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import { TaskAfterCreateEventHandler } from "./abstractions.js";
+class TaskAfterCreateEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return TaskAfterCreateEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "task.afterCreate";
+    }
+}
+export { TaskAfterCreateEvent };
+
+//# sourceMappingURL=TaskAfterCreateEvent.js.map

package/api/events/TaskAfterCreateEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/events/TaskAfterCreateEvent.js","sources":["../../../src/api/events/TaskAfterCreateEvent.ts"],"sourcesContent":["import { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { TaskAfterCreateEventHandler, TaskAfterCreatePayload } from \"./abstractions.js\";\n\nexport class TaskAfterCreateEvent extends DomainEvent<TaskAfterCreatePayload> {\n    eventType = \"task.afterCreate\" as const;\n\n    getHandlerAbstraction() {\n        return TaskAfterCreateEventHandler;\n    }\n}\n"],"names":["TaskAfterCreateEvent","DomainEvent","TaskAfterCreateEventHandler"],"mappings":";;AAGO,MAAMA,6BAA6BC;IAGtC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB"}

package/api/events/TaskAfterDeleteEvent.d.ts

@@ -0,0 +1,6 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import { TaskAfterDeletePayload } from "./abstractions.js";
+export declare class TaskAfterDeleteEvent extends DomainEvent<TaskAfterDeletePayload> {
+    eventType: "task.afterDelete";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher/abstractions.js").IEventHandler<DomainEvent<TaskAfterDeletePayload>>>;
+}

package/api/events/TaskAfterDeleteEvent.js

@@ -0,0 +1,13 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import { TaskAfterDeleteEventHandler } from "./abstractions.js";
+class TaskAfterDeleteEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return TaskAfterDeleteEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "task.afterDelete";
+    }
+}
+export { TaskAfterDeleteEvent };
+
+//# sourceMappingURL=TaskAfterDeleteEvent.js.map

package/api/events/TaskAfterDeleteEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/events/TaskAfterDeleteEvent.js","sources":["../../../src/api/events/TaskAfterDeleteEvent.ts"],"sourcesContent":["import { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { TaskAfterDeleteEventHandler, TaskAfterDeletePayload } from \"./abstractions.js\";\n\nexport class TaskAfterDeleteEvent extends DomainEvent<TaskAfterDeletePayload> {\n    eventType = \"task.afterDelete\" as const;\n\n    getHandlerAbstraction() {\n        return TaskAfterDeleteEventHandler;\n    }\n}\n"],"names":["TaskAfterDeleteEvent","DomainEvent","TaskAfterDeleteEventHandler"],"mappings":";;AAGO,MAAMA,6BAA6BC;IAGtC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB"}

package/api/events/TaskAfterUpdateEvent.d.ts

@@ -0,0 +1,6 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import { TaskAfterUpdatePayload } from "./abstractions.js";
+export declare class TaskAfterUpdateEvent extends DomainEvent<TaskAfterUpdatePayload> {
+    eventType: "task.afterUpdate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher/abstractions.js").IEventHandler<DomainEvent<TaskAfterUpdatePayload>>>;
+}

package/api/events/TaskAfterUpdateEvent.js

@@ -0,0 +1,13 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import { TaskAfterUpdateEventHandler } from "./abstractions.js";
+class TaskAfterUpdateEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return TaskAfterUpdateEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "task.afterUpdate";
+    }
+}
+export { TaskAfterUpdateEvent };
+
+//# sourceMappingURL=TaskAfterUpdateEvent.js.map

package/api/events/TaskAfterUpdateEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/events/TaskAfterUpdateEvent.js","sources":["../../../src/api/events/TaskAfterUpdateEvent.ts"],"sourcesContent":["import { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { TaskAfterUpdateEventHandler, TaskAfterUpdatePayload } from \"./abstractions.js\";\n\nexport class TaskAfterUpdateEvent extends DomainEvent<TaskAfterUpdatePayload> {\n    eventType = \"task.afterUpdate\" as const;\n\n    getHandlerAbstraction() {\n        return TaskAfterUpdateEventHandler;\n    }\n}\n"],"names":["TaskAfterUpdateEvent","DomainEvent","TaskAfterUpdateEventHandler"],"mappings":";;AAGO,MAAMA,6BAA6BC;IAGtC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB"}

package/api/events/TaskBeforeCreateEvent.d.ts

@@ -0,0 +1,6 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import { TaskBeforeCreatePayload } from "./abstractions.js";
+export declare class TaskBeforeCreateEvent extends DomainEvent<TaskBeforeCreatePayload> {
+    eventType: "task.beforeCreate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher/abstractions.js").IEventHandler<DomainEvent<TaskBeforeCreatePayload>>>;
+}

package/api/events/TaskBeforeCreateEvent.js

@@ -0,0 +1,13 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import { TaskBeforeCreateEventHandler } from "./abstractions.js";
+class TaskBeforeCreateEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return TaskBeforeCreateEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "task.beforeCreate";
+    }
+}
+export { TaskBeforeCreateEvent };
+
+//# sourceMappingURL=TaskBeforeCreateEvent.js.map

package/api/events/TaskBeforeCreateEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/events/TaskBeforeCreateEvent.js","sources":["../../../src/api/events/TaskBeforeCreateEvent.ts"],"sourcesContent":["import { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { TaskBeforeCreateEventHandler, TaskBeforeCreatePayload } from \"./abstractions.js\";\n\nexport class TaskBeforeCreateEvent extends DomainEvent<TaskBeforeCreatePayload> {\n    eventType = \"task.beforeCreate\" as const;\n\n    getHandlerAbstraction() {\n        return TaskBeforeCreateEventHandler;\n    }\n}\n"],"names":["TaskBeforeCreateEvent","DomainEvent","TaskBeforeCreateEventHandler"],"mappings":";;AAGO,MAAMA,8BAA8BC;IAGvC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB"}

package/api/events/TaskBeforeDeleteEvent.d.ts

@@ -0,0 +1,6 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import { TaskBeforeDeletePayload } from "./abstractions.js";
+export declare class TaskBeforeDeleteEvent extends DomainEvent<TaskBeforeDeletePayload> {
+    eventType: "task.beforeDelete";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher/abstractions.js").IEventHandler<DomainEvent<TaskBeforeDeletePayload>>>;
+}

package/api/events/TaskBeforeDeleteEvent.js

@@ -0,0 +1,13 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import { TaskBeforeDeleteEventHandler } from "./abstractions.js";
+class TaskBeforeDeleteEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return TaskBeforeDeleteEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "task.beforeDelete";
+    }
+}
+export { TaskBeforeDeleteEvent };
+
+//# sourceMappingURL=TaskBeforeDeleteEvent.js.map

package/api/events/TaskBeforeDeleteEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/events/TaskBeforeDeleteEvent.js","sources":["../../../src/api/events/TaskBeforeDeleteEvent.ts"],"sourcesContent":["import { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { TaskBeforeDeleteEventHandler, TaskBeforeDeletePayload } from \"./abstractions.js\";\n\nexport class TaskBeforeDeleteEvent extends DomainEvent<TaskBeforeDeletePayload> {\n    eventType = \"task.beforeDelete\" as const;\n\n    getHandlerAbstraction() {\n        return TaskBeforeDeleteEventHandler;\n    }\n}\n"],"names":["TaskBeforeDeleteEvent","DomainEvent","TaskBeforeDeleteEventHandler"],"mappings":";;AAGO,MAAMA,8BAA8BC;IAGvC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB"}

package/api/events/TaskBeforeUpdateEvent.d.ts

@@ -0,0 +1,6 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import { TaskBeforeUpdatePayload } from "./abstractions.js";
+export declare class TaskBeforeUpdateEvent extends DomainEvent<TaskBeforeUpdatePayload> {
+    eventType: "task.beforeUpdate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher/abstractions.js").IEventHandler<DomainEvent<TaskBeforeUpdatePayload>>>;
+}

package/api/events/TaskBeforeUpdateEvent.js

@@ -0,0 +1,13 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import { TaskBeforeUpdateEventHandler } from "./abstractions.js";
+class TaskBeforeUpdateEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return TaskBeforeUpdateEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "task.beforeUpdate";
+    }
+}
+export { TaskBeforeUpdateEvent };
+
+//# sourceMappingURL=TaskBeforeUpdateEvent.js.map

package/api/events/TaskBeforeUpdateEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/events/TaskBeforeUpdateEvent.js","sources":["../../../src/api/events/TaskBeforeUpdateEvent.ts"],"sourcesContent":["import { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { TaskBeforeUpdateEventHandler, TaskBeforeUpdatePayload } from \"./abstractions.js\";\n\nexport class TaskBeforeUpdateEvent extends DomainEvent<TaskBeforeUpdatePayload> {\n    eventType = \"task.beforeUpdate\" as const;\n\n    getHandlerAbstraction() {\n        return TaskBeforeUpdateEventHandler;\n    }\n}\n"],"names":["TaskBeforeUpdateEvent","DomainEvent","TaskBeforeUpdateEventHandler"],"mappings":";;AAGO,MAAMA,8BAA8BC;IAGvC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB"}

package/api/events/abstractions.d.ts

@@ -0,0 +1,53 @@
+import type { DomainEvent, IEventHandler } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { ITask, ITaskCreateData, ITaskUpdateData } from "../../api/types.js";
+export interface TaskBeforeCreatePayload {
+    input: ITaskCreateData;
+}
+export declare const TaskBeforeCreateEventHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TaskBeforeCreatePayload>>>;
+export declare namespace TaskBeforeCreateEventHandler {
+    type Interface = IEventHandler<DomainEvent<TaskBeforeCreatePayload>>;
+    type Event = DomainEvent<TaskBeforeCreatePayload>;
+}
+export interface TaskAfterCreatePayload {
+    input: ITaskCreateData;
+    task: ITask;
+}
+export declare const TaskAfterCreateEventHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TaskAfterCreatePayload>>>;
+export declare namespace TaskAfterCreateEventHandler {
+    type Interface = IEventHandler<DomainEvent<TaskAfterCreatePayload>>;
+    type Event = DomainEvent<TaskAfterCreatePayload>;
+}
+export interface TaskBeforeUpdatePayload {
+    input: ITaskUpdateData;
+    original: ITask;
+}
+export declare const TaskBeforeUpdateEventHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TaskBeforeUpdatePayload>>>;
+export declare namespace TaskBeforeUpdateEventHandler {
+    type Interface = IEventHandler<DomainEvent<TaskBeforeUpdatePayload>>;
+    type Event = DomainEvent<TaskBeforeUpdatePayload>;
+}
+export interface TaskAfterUpdatePayload {
+    input: ITaskUpdateData;
+    task: ITask;
+}
+export declare const TaskAfterUpdateEventHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TaskAfterUpdatePayload>>>;
+export declare namespace TaskAfterUpdateEventHandler {
+    type Interface = IEventHandler<DomainEvent<TaskAfterUpdatePayload>>;
+    type Event = DomainEvent<TaskAfterUpdatePayload>;
+}
+export interface TaskBeforeDeletePayload {
+    task: ITask;
+}
+export declare const TaskBeforeDeleteEventHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TaskBeforeDeletePayload>>>;
+export declare namespace TaskBeforeDeleteEventHandler {
+    type Interface = IEventHandler<DomainEvent<TaskBeforeDeletePayload>>;
+    type Event = DomainEvent<TaskBeforeDeletePayload>;
+}
+export interface TaskAfterDeletePayload {
+    task: ITask;
+}
+export declare const TaskAfterDeleteEventHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TaskAfterDeletePayload>>>;
+export declare namespace TaskAfterDeleteEventHandler {
+    type Interface = IEventHandler<DomainEvent<TaskAfterDeletePayload>>;
+    type Event = DomainEvent<TaskAfterDeletePayload>;
+}

package/api/events/abstractions.js

@@ -0,0 +1,10 @@
+import { createAbstraction } from "@webiny/feature/api";
+const TaskBeforeCreateEventHandler = createAbstraction("TaskBeforeCreateEventHandler");
+const TaskAfterCreateEventHandler = createAbstraction("TaskAfterCreateEventHandler");
+const TaskBeforeUpdateEventHandler = createAbstraction("TaskBeforeUpdateEventHandler");
+const TaskAfterUpdateEventHandler = createAbstraction("TaskAfterUpdateEventHandler");
+const TaskBeforeDeleteEventHandler = createAbstraction("TaskBeforeDeleteEventHandler");
+const TaskAfterDeleteEventHandler = createAbstraction("TaskAfterDeleteEventHandler");
+export { TaskAfterCreateEventHandler, TaskAfterDeleteEventHandler, TaskAfterUpdateEventHandler, TaskBeforeCreateEventHandler, TaskBeforeDeleteEventHandler, TaskBeforeUpdateEventHandler };
+
+//# sourceMappingURL=abstractions.js.map

package/api/events/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/events/abstractions.js","sources":["../../../src/api/events/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { DomainEvent, IEventHandler } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { ITask, ITaskCreateData, ITaskUpdateData } from \"~/api/types.js\";\n\n// ============================================================================\n// TaskBeforeCreate Event\n// ============================================================================\n\nexport interface TaskBeforeCreatePayload {\n    input: ITaskCreateData;\n}\n\nexport const TaskBeforeCreateEventHandler = createAbstraction<\n    IEventHandler<DomainEvent<TaskBeforeCreatePayload>>\n>(\"TaskBeforeCreateEventHandler\");\n\nexport namespace TaskBeforeCreateEventHandler {\n    export type Interface = IEventHandler<DomainEvent<TaskBeforeCreatePayload>>;\n    export type Event = DomainEvent<TaskBeforeCreatePayload>;\n}\n\n// ============================================================================\n// TaskAfterCreate Event\n// ============================================================================\n\nexport interface TaskAfterCreatePayload {\n    input: ITaskCreateData;\n    task: ITask;\n}\n\nexport const TaskAfterCreateEventHandler = createAbstraction<\n    IEventHandler<DomainEvent<TaskAfterCreatePayload>>\n>(\"TaskAfterCreateEventHandler\");\n\nexport namespace TaskAfterCreateEventHandler {\n    export type Interface = IEventHandler<DomainEvent<TaskAfterCreatePayload>>;\n    export type Event = DomainEvent<TaskAfterCreatePayload>;\n}\n\n// ============================================================================\n// TaskBeforeUpdate Event\n// ============================================================================\n\nexport interface TaskBeforeUpdatePayload {\n    input: ITaskUpdateData;\n    original: ITask;\n}\n\nexport const TaskBeforeUpdateEventHandler = createAbstraction<\n    IEventHandler<DomainEvent<TaskBeforeUpdatePayload>>\n>(\"TaskBeforeUpdateEventHandler\");\n\nexport namespace TaskBeforeUpdateEventHandler {\n    export type Interface = IEventHandler<DomainEvent<TaskBeforeUpdatePayload>>;\n    export type Event = DomainEvent<TaskBeforeUpdatePayload>;\n}\n\n// ============================================================================\n// TaskAfterUpdate Event\n// ============================================================================\n\nexport interface TaskAfterUpdatePayload {\n    input: ITaskUpdateData;\n    task: ITask;\n}\n\nexport const TaskAfterUpdateEventHandler = createAbstraction<\n    IEventHandler<DomainEvent<TaskAfterUpdatePayload>>\n>(\"TaskAfterUpdateEventHandler\");\n\nexport namespace TaskAfterUpdateEventHandler {\n    export type Interface = IEventHandler<DomainEvent<TaskAfterUpdatePayload>>;\n    export type Event = DomainEvent<TaskAfterUpdatePayload>;\n}\n\n// ============================================================================\n// TaskBeforeDelete Event\n// ============================================================================\n\nexport interface TaskBeforeDeletePayload {\n    task: ITask;\n}\n\nexport const TaskBeforeDeleteEventHandler = createAbstraction<\n    IEventHandler<DomainEvent<TaskBeforeDeletePayload>>\n>(\"TaskBeforeDeleteEventHandler\");\n\nexport namespace TaskBeforeDeleteEventHandler {\n    export type Interface = IEventHandler<DomainEvent<TaskBeforeDeletePayload>>;\n    export type Event = DomainEvent<TaskBeforeDeletePayload>;\n}\n\n// ============================================================================\n// TaskAfterDelete Event\n// ============================================================================\n\nexport interface TaskAfterDeletePayload {\n    task: ITask;\n}\n\nexport const TaskAfterDeleteEventHandler = createAbstraction<\n    IEventHandler<DomainEvent<TaskAfterDeletePayload>>\n>(\"TaskAfterDeleteEventHandler\");\n\nexport namespace TaskAfterDeleteEventHandler {\n    export type Interface = IEventHandler<DomainEvent<TaskAfterDeletePayload>>;\n    export type Event = DomainEvent<TaskAfterDeletePayload>;\n}\n"],"names":["TaskBeforeCreateEventHandler","createAbstraction","TaskAfterCreateEventHandler","TaskBeforeUpdateEventHandler","TaskAfterUpdateEventHandler","TaskBeforeDeleteEventHandler","TaskAfterDeleteEventHandler"],"mappings":";AAYO,MAAMA,+BAA+BC,kBAE1C;AAgBK,MAAMC,8BAA8BD,kBAEzC;AAgBK,MAAME,+BAA+BF,kBAE1C;AAgBK,MAAMG,8BAA8BH,kBAEzC;AAeK,MAAMI,+BAA+BJ,kBAE1C;AAeK,MAAMK,8BAA8BL,kBAEzC"}

package/api/events/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./abstractions.js";
+export * from "./TaskBeforeCreateEvent.js";
+export * from "./TaskAfterCreateEvent.js";
+export * from "./TaskBeforeUpdateEvent.js";
+export * from "./TaskAfterUpdateEvent.js";
+export * from "./TaskBeforeDeleteEvent.js";
+export * from "./TaskAfterDeleteEvent.js";

package/api/events/index.js

@@ -0,0 +1,7 @@
+export * from "./abstractions.js";
+export * from "./TaskBeforeCreateEvent.js";
+export * from "./TaskAfterCreateEvent.js";
+export * from "./TaskBeforeUpdateEvent.js";
+export * from "./TaskAfterUpdateEvent.js";
+export * from "./TaskBeforeDeleteEvent.js";
+export * from "./TaskAfterDeleteEvent.js";

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

@@ -0,0 +1,9 @@
+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";
+export declare class AbortTaskUseCaseImpl implements UseCaseAbstraction.Interface {
+    private taskService;
+    constructor(taskService: TaskService.Interface);
+    execute<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends TaskService.GenericOutput = TaskService.GenericOutput>(params: UseCaseAbstraction.Params): Promise<Result<TaskService.Task<I, O>, UseCaseAbstraction.Error>>;
+}

package/api/features/AbortTask/AbortTaskUseCase.js

@@ -0,0 +1,12 @@
+class AbortTaskUseCaseImpl {
+    constructor(taskService){
+        this.taskService = taskService;
+    }
+    async execute(params) {
+        const result = await this.taskService.abort(params);
+        return result;
+    }
+}
+export { AbortTaskUseCaseImpl };
+
+//# sourceMappingURL=AbortTaskUseCase.js.map

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

@@ -0,0 +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\";\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"}