@webiny/background-tasks 0.0.0-unstable.7be00a75a9 → 0.0.0-unstable.7c2def32a7

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

@@ -0,0 +1,34 @@
+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 { TaskLogModelProvider, TaskLogsRepository as Abstraction } from "./abstractions.js";
+import { BackgroundTaskPersistenceError, TaskLogNotFoundError } from "../../../api/domain/errors.js";
+declare class TaskLogsRepositoryImpl implements Abstraction.Interface {
+    private readonly identityContext;
+    private readonly modelProvider;
+    private readonly getEntryById;
+    private readonly listLatestEntries;
+    private readonly createEntry;
+    private readonly updateEntry;
+    private readonly deleteEntry;
+    private readonly whereMapper;
+    constructor(identityContext: IdentityContext.Interface, modelProvider: TaskLogModelProvider.Interface, getEntryById: GetEntryByIdUseCase.Interface, listLatestEntries: ListLatestEntriesUseCase.Interface, createEntry: CreateEntryUseCase.Interface, updateEntry: UpdateEntryUseCase.Interface, deleteEntry: DeleteEntryUseCase.Interface, whereMapper: CmsWhereMapper.Interface);
+    create(task: Parameters<Abstraction.Interface["create"]>[0], data: Parameters<Abstraction.Interface["create"]>[1]): Promise<Result<never, BackgroundTaskPersistenceError> | Result<import("../../types.js").ITaskLog, never>>;
+    update(id: string, data: Parameters<Abstraction.Interface["update"]>[1]): Promise<Result<never, BackgroundTaskPersistenceError | TaskLogNotFoundError> | Result<import("../../types.js").ITaskLog, never>>;
+    delete(id: string): Promise<Result<void, never> | Result<never, BackgroundTaskPersistenceError | TaskLogNotFoundError>>;
+    get(id: string): Promise<Result<never, BackgroundTaskPersistenceError | TaskLogNotFoundError> | Result<import("../../types.js").ITaskLog, never>>;
+    getLatest(taskId: string): Promise<Result<never, BackgroundTaskPersistenceError> | Result<never, TaskLogNotFoundError> | Result<import("../../types.js").ITaskLog, never>>;
+    list(params: Parameters<Abstraction.Interface["list"]>[0]): Promise<Result<never, BackgroundTaskPersistenceError> | Result<{
+        items: import("../../types.js").ITaskLog[];
+        meta: import("@webiny/api-headless-cms/types/types.js").CmsEntryMeta;
+    }, never>>;
+}
+export declare const TaskLogsRepository: typeof TaskLogsRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ITaskLogsRepository>;
+};
+export {};

package/api/domain/task/TaskLogsRepository.js

@@ -0,0 +1,146 @@
+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 { TaskLogModelProvider, TaskLogsRepository } from "./abstractions.js";
+import { entryToTaskLog } from "./entryToTaskLog.js";
+import { createRevisionId } from "./createRevisionId.js";
+import { BackgroundTaskPersistenceError, TaskLogNotFoundError } from "../errors.js";
+const ENTRY_NOT_FOUND = "Cms/Entry/NotFound";
+const toLogError = (error)=>{
+    if (error.code === ENTRY_NOT_FOUND) return new TaskLogNotFoundError();
+    return BackgroundTaskPersistenceError.from(error);
+};
+class TaskLogsRepositoryImpl {
+    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 create(task, data) {
+        try {
+            const result = await this.identityContext.withoutAuthorization(async ()=>{
+                const model = await this.modelProvider.get();
+                return this.createEntry.execute(model, {
+                    values: {
+                        ...data,
+                        task: task.id
+                    }
+                });
+            });
+            if (result.isFail()) return Result.fail(BackgroundTaskPersistenceError.from(result.error));
+            return Result.ok(entryToTaskLog(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(toLogError(result.error));
+            return Result.ok(entryToTaskLog(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, id);
+            });
+            if (result.isFail()) return Result.fail(toLogError(result.error));
+            return Result.ok();
+        } catch (error) {
+            return Result.fail(BackgroundTaskPersistenceError.from(error));
+        }
+    }
+    async get(id) {
+        try {
+            const result = await this.identityContext.withoutAuthorization(async ()=>{
+                const model = await this.modelProvider.get();
+                return this.getEntryById.execute(model, id);
+            });
+            if (result.isFail()) return Result.fail(toLogError(result.error));
+            return Result.ok(entryToTaskLog(result.value));
+        } catch (error) {
+            return Result.fail(BackgroundTaskPersistenceError.from(error));
+        }
+    }
+    async getLatest(taskId) {
+        try {
+            const result = await this.identityContext.withoutAuthorization(async ()=>{
+                const model = await this.modelProvider.get();
+                return this.listLatestEntries.execute(model, {
+                    where: {
+                        values: {
+                            task: taskId
+                        }
+                    },
+                    sort: [
+                        "createdOn_DESC"
+                    ],
+                    limit: 1
+                });
+            });
+            if (result.isFail()) return Result.fail(BackgroundTaskPersistenceError.from(result.error));
+            const [entry] = result.value.entries;
+            if (!entry) return Result.fail(new TaskLogNotFoundError());
+            return Result.ok(entryToTaskLog(entry));
+        } 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)=>entryToTaskLog(entry)),
+                meta
+            });
+        } catch (error) {
+            return Result.fail(BackgroundTaskPersistenceError.from(error));
+        }
+    }
+}
+const TaskLogsRepository_TaskLogsRepository = TaskLogsRepository.createImplementation({
+    implementation: TaskLogsRepositoryImpl,
+    dependencies: [
+        IdentityContext,
+        TaskLogModelProvider,
+        GetEntryByIdUseCase,
+        ListLatestEntriesUseCase,
+        CreateEntryUseCase,
+        UpdateEntryUseCase,
+        DeleteEntryUseCase,
+        CmsWhereMapper
+    ]
+});
+export { TaskLogsRepository_TaskLogsRepository as TaskLogsRepository };
+
+//# sourceMappingURL=TaskLogsRepository.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/task/TaskLogsRepository.js","sources":["../../../../src/api/domain/task/TaskLogsRepository.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 { TaskLogModelProvider, TaskLogsRepository as Abstraction } from \"./abstractions.js\";\nimport { entryToTaskLog } from \"./entryToTaskLog.js\";\nimport { createRevisionId } from \"./createRevisionId.js\";\nimport { BackgroundTaskPersistenceError, TaskLogNotFoundError } from \"~/api/domain/errors.js\";\n\nconst ENTRY_NOT_FOUND = \"Cms/Entry/NotFound\";\n\nconst toLogError = (error: {\n    code?: string;\n}): TaskLogNotFoundError | BackgroundTaskPersistenceError => {\n    if (error.code === ENTRY_NOT_FOUND) {\n        return new TaskLogNotFoundError();\n    }\n    return BackgroundTaskPersistenceError.from(error);\n};\n\n/*\n * Task logs are stored as entries of a private CMS model, and like tasks, they're read and written\n * without authorization.\n */\nclass TaskLogsRepositoryImpl implements Abstraction.Interface {\n    constructor(\n        private readonly identityContext: IdentityContext.Interface,\n        private readonly modelProvider: TaskLogModelProvider.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 create(\n        task: Parameters<Abstraction.Interface[\"create\"]>[0],\n        data: Parameters<Abstraction.Interface[\"create\"]>[1]\n    ) {\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                        task: task.id\n                    }\n                });\n            });\n            if (result.isFail()) {\n                return Result.fail(BackgroundTaskPersistenceError.from(result.error));\n            }\n            return Result.ok(entryToTaskLog(result.value));\n        } catch (error) {\n            return Result.fail(BackgroundTaskPersistenceError.from(error));\n        }\n    }\n\n    async update(id: string, data: Parameters<Abstraction.Interface[\"update\"]>[1]) {\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(toLogError(result.error));\n            }\n            return Result.ok(entryToTaskLog(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, id);\n            });\n            if (result.isFail()) {\n                return Result.fail(toLogError(result.error));\n            }\n            return Result.ok();\n        } catch (error) {\n            return Result.fail(BackgroundTaskPersistenceError.from(error));\n        }\n    }\n\n    async get(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, id);\n            });\n            if (result.isFail()) {\n                return Result.fail(toLogError(result.error));\n            }\n            return Result.ok(entryToTaskLog(result.value));\n        } catch (error) {\n            return Result.fail(BackgroundTaskPersistenceError.from(error));\n        }\n    }\n\n    async getLatest(taskId: string) {\n        try {\n            const result = await this.identityContext.withoutAuthorization(async () => {\n                const model = await this.modelProvider.get();\n                return this.listLatestEntries.execute(model, {\n                    where: {\n                        values: {\n                            task: taskId\n                        }\n                    },\n                    sort: [\"createdOn_DESC\"],\n                    limit: 1\n                });\n            });\n            if (result.isFail()) {\n                return Result.fail(BackgroundTaskPersistenceError.from(result.error));\n            }\n            const [entry] = result.value.entries;\n            if (!entry) {\n                return Result.fail(new TaskLogNotFoundError());\n            }\n            return Result.ok(entryToTaskLog(entry));\n        } catch (error) {\n            return Result.fail(BackgroundTaskPersistenceError.from(error));\n        }\n    }\n\n    async list(params: Parameters<Abstraction.Interface[\"list\"]>[0]) {\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 => entryToTaskLog(entry)),\n                meta\n            });\n        } catch (error) {\n            return Result.fail(BackgroundTaskPersistenceError.from(error));\n        }\n    }\n}\n\nexport const TaskLogsRepository = Abstraction.createImplementation({\n    implementation: TaskLogsRepositoryImpl,\n    dependencies: [\n        IdentityContext,\n        TaskLogModelProvider,\n        GetEntryByIdUseCase,\n        ListLatestEntriesUseCase,\n        CreateEntryUseCase,\n        UpdateEntryUseCase,\n        DeleteEntryUseCase,\n        CmsWhereMapper\n    ]\n});\n"],"names":["ENTRY_NOT_FOUND","toLogError","error","TaskLogNotFoundError","BackgroundTaskPersistenceError","TaskLogsRepositoryImpl","identityContext","modelProvider","getEntryById","listLatestEntries","createEntry","updateEntry","deleteEntry","whereMapper","task","data","result","model","Result","entryToTaskLog","id","createRevisionId","taskId","entry","params","entries","meta","TaskLogsRepository","Abstraction","IdentityContext","TaskLogModelProvider","GetEntryByIdUseCase","ListLatestEntriesUseCase","CreateEntryUseCase","UpdateEntryUseCase","DeleteEntryUseCase","CmsWhereMapper"],"mappings":"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"}

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

@@ -0,0 +1,12 @@
+import type { CmsModel } from "@webiny/api-headless-cms/types/index.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { TaskModelProvider as Abstraction } from "./abstractions.js";
+declare class TaskModelProviderImpl implements Abstraction.Interface {
+    private readonly getModel;
+    constructor(getModel: GetModelUseCase.Interface);
+    get(): Promise<CmsModel>;
+}
+export declare const TaskModelProvider: typeof TaskModelProviderImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ITaskModelProvider>;
+};
+export {};

package/api/domain/task/TaskModelProvider.js

@@ -0,0 +1,23 @@
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { TaskModelProvider } from "./abstractions.js";
+import { BackgroundTaskModelNotFoundError } from "../errors.js";
+import { WEBINY_TASK_MODEL_ID } from "../../crud/TaskPrivateModel.js";
+class TaskModelProviderImpl {
+    constructor(getModel){
+        this.getModel = getModel;
+    }
+    async get() {
+        const result = await this.getModel.execute(WEBINY_TASK_MODEL_ID);
+        if (result.isFail()) throw new BackgroundTaskModelNotFoundError(WEBINY_TASK_MODEL_ID);
+        return result.value;
+    }
+}
+const TaskModelProvider_TaskModelProvider = TaskModelProvider.createImplementation({
+    implementation: TaskModelProviderImpl,
+    dependencies: [
+        GetModelUseCase
+    ]
+});
+export { TaskModelProvider_TaskModelProvider as TaskModelProvider };
+
+//# sourceMappingURL=TaskModelProvider.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/task/TaskModelProvider.js","sources":["../../../../src/api/domain/task/TaskModelProvider.ts"],"sourcesContent":["import type { CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\nimport { TaskModelProvider as Abstraction } from \"./abstractions.js\";\nimport { BackgroundTaskModelNotFoundError } from \"~/api/domain/errors.js\";\nimport { WEBINY_TASK_MODEL_ID } from \"~/api/crud/TaskPrivateModel.js\";\n\nclass TaskModelProviderImpl implements Abstraction.Interface {\n    constructor(private readonly getModel: GetModelUseCase.Interface) {}\n\n    async get(): Promise<CmsModel> {\n        const result = await this.getModel.execute(WEBINY_TASK_MODEL_ID);\n        if (result.isFail()) {\n            throw new BackgroundTaskModelNotFoundError(WEBINY_TASK_MODEL_ID);\n        }\n        return result.value;\n    }\n}\n\nexport const TaskModelProvider = Abstraction.createImplementation({\n    implementation: TaskModelProviderImpl,\n    dependencies: [GetModelUseCase]\n});\n"],"names":["TaskModelProviderImpl","getModel","result","WEBINY_TASK_MODEL_ID","BackgroundTaskModelNotFoundError","TaskModelProvider","Abstraction","GetModelUseCase"],"mappings":";;;;AAMA,MAAMA;IACF,YAA6BC,QAAmC,CAAE;aAArCA,QAAQ,GAARA;IAAsC;IAEnE,MAAM,MAAyB;QAC3B,MAAMC,SAAS,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAACC;QAC3C,IAAID,OAAO,MAAM,IACb,MAAM,IAAIE,iCAAiCD;QAE/C,OAAOD,OAAO,KAAK;IACvB;AACJ;AAEO,MAAMG,sCAAoBC,kBAAAA,oBAAgC,CAAC;IAC9D,gBAAgBN;IAChB,cAAc;QAACO;KAAgB;AACnC"}

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

@@ -0,0 +1,37 @@
+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 as Abstraction } from "./abstractions.js";
+import { BackgroundTaskPersistenceError, TaskNotFoundError } from "../../../api/domain/errors.js";
+import type { IListTaskParams, ITaskCreateData, ITaskUpdateData } from "../../../api/types.js";
+import type { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+type TaskInput = TaskService.TaskInput;
+type TaskOutput = TaskService.GenericOutput;
+declare class TasksRepositoryImpl implements Abstraction.Interface {
+    private readonly identityContext;
+    private readonly modelProvider;
+    private readonly getEntryById;
+    private readonly listLatestEntries;
+    private readonly createEntry;
+    private readonly updateEntry;
+    private readonly deleteEntry;
+    private readonly whereMapper;
+    constructor(identityContext: IdentityContext.Interface, modelProvider: TaskModelProvider.Interface, getEntryById: GetEntryByIdUseCase.Interface, listLatestEntries: ListLatestEntriesUseCase.Interface, createEntry: CreateEntryUseCase.Interface, updateEntry: UpdateEntryUseCase.Interface, deleteEntry: DeleteEntryUseCase.Interface, whereMapper: CmsWhereMapper.Interface);
+    get<I extends TaskInput = TaskInput, O extends TaskOutput = TaskOutput>(id: string): Promise<Result<never, BackgroundTaskPersistenceError | TaskNotFoundError> | Result<TaskService.Task<I, O>, never>>;
+    list<I extends TaskInput = TaskInput, O extends TaskOutput = TaskOutput>(params?: IListTaskParams): Promise<Result<never, BackgroundTaskPersistenceError> | Result<{
+        items: TaskService.Task<I, O>[];
+        meta: import("@webiny/api-headless-cms/types/types.js").CmsEntryMeta;
+    }, never>>;
+    create<I extends TaskInput = TaskInput>(data: ITaskCreateData<I>): Promise<Result<never, BackgroundTaskPersistenceError> | Result<TaskService.Task<I, import("@webiny/api-core/features/task/TaskService/abstractions.js").IGenericOutput>, never>>;
+    update<I extends TaskInput = TaskInput, O extends TaskOutput = TaskOutput>(id: string, data: Partial<ITaskUpdateData<I, O>>): Promise<Result<never, BackgroundTaskPersistenceError | TaskNotFoundError> | Result<TaskService.Task<I, O>, never>>;
+    delete(id: string): Promise<Result<void, never> | Result<never, BackgroundTaskPersistenceError | TaskNotFoundError>>;
+}
+export declare const TasksRepository: typeof TasksRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ITasksRepository>;
+};
+export {};

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