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

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

@@ -0,0 +1,25 @@
+import { Result } from "@webiny/feature/api";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { TaskDefinitionNotFoundError, TaskNotFoundError, TaskAbortError } from "../../../api/domain/errors.js";
+export interface IAbortTaskUseCase {
+    execute<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends TaskService.GenericOutput = TaskService.GenericOutput>(params: AbortTaskParams): Promise<Result<TaskService.Task<I, O>, UseCaseError>>;
+}
+export interface AbortTaskParams {
+    id: string;
+    message?: string;
+}
+export interface IAbortTaskUseCaseErrors {
+    definitionNotFound: TaskDefinitionNotFoundError;
+    taskNotFound: TaskNotFoundError;
+    abortError: TaskAbortError;
+}
+type UseCaseError = IAbortTaskUseCaseErrors[keyof IAbortTaskUseCaseErrors];
+export declare const AbortTaskUseCase: import("@webiny/di").Abstraction<IAbortTaskUseCase>;
+export declare namespace AbortTaskUseCase {
+    type Interface = IAbortTaskUseCase;
+    type Params = AbortTaskParams;
+    type Error = UseCaseError;
+    type Return<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends TaskService.GenericOutput = TaskService.GenericOutput> = Promise<Result<TaskService.Task<I, O>, UseCaseError>>;
+}
+export {};

package/api/features/AbortTask/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AbortTask/abstractions.js","sources":["../../../../src/api/features/AbortTask/abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport {\n    TaskDefinitionNotFoundError,\n    TaskNotFoundError,\n    TaskAbortError\n} from \"~/api/domain/errors.js\";\n\nexport interface IAbortTaskUseCase {\n    execute<\n        I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends TaskService.GenericOutput = TaskService.GenericOutput\n    >(\n        params: AbortTaskParams\n    ): Promise<Result<TaskService.Task<I, O>, UseCaseError>>;\n}\n\nexport interface AbortTaskParams {\n    id: string;\n    message?: string;\n}\n\nexport interface IAbortTaskUseCaseErrors {\n    definitionNotFound: TaskDefinitionNotFoundError;\n    taskNotFound: TaskNotFoundError;\n    abortError: TaskAbortError;\n}\n\ntype UseCaseError = IAbortTaskUseCaseErrors[keyof IAbortTaskUseCaseErrors];\n\nexport const AbortTaskUseCase = createAbstraction<IAbortTaskUseCase>(\"Tasks/AbortTaskUseCase\");\n\nexport namespace AbortTaskUseCase {\n    export type Interface = IAbortTaskUseCase;\n    export type Params = AbortTaskParams;\n\n    export type Error = UseCaseError;\n    export type Return<\n        I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends TaskService.GenericOutput = TaskService.GenericOutput\n    > = Promise<Result<TaskService.Task<I, O>, UseCaseError>>;\n}\n"],"names":["AbortTaskUseCase","createAbstraction"],"mappings":";AA+BO,MAAMA,mBAAmBC,kBAAqC"}

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

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

package/api/features/AbortTask/feature.js

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

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

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

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

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

package/api/features/AbortTask/index.js

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

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

@@ -0,0 +1,17 @@
+import type { Permissions } from "@webiny/api-core/features/security/permissions/index.js";
+import { BACKGROUND_TASK_PERMISSIONS_SCHEMA } from "../../../api/permissions.js";
+export declare const BackgroundTaskPermissions: import("@webiny/di").Abstraction<import("@webiny/api-core/features/security/permissions/types").PermissionsTyped<{
+    readonly prefix: "backgroundTasks";
+    readonly fullAccess: true;
+    readonly entities: readonly [{
+        readonly id: "task";
+        readonly permission: "backgroundTasks.task";
+        readonly scopes: readonly ["full"];
+        readonly actions: readonly [{
+            readonly name: "rwd";
+        }];
+    }];
+}>>;
+export declare namespace BackgroundTaskPermissions {
+    type Interface = Permissions<typeof BACKGROUND_TASK_PERMISSIONS_SCHEMA>;
+}

package/api/features/BackgroundTaskPermissions/abstractions.js

@@ -0,0 +1,6 @@
+import { createPermissionsAbstraction } from "@webiny/api-core/features/security/permissions/index.js";
+import { BACKGROUND_TASK_PERMISSIONS_SCHEMA } from "../../permissions.js";
+const BackgroundTaskPermissions = createPermissionsAbstraction(BACKGROUND_TASK_PERMISSIONS_SCHEMA);
+export { BackgroundTaskPermissions };
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/BackgroundTaskPermissions/abstractions.js","sources":["../../../../src/api/features/BackgroundTaskPermissions/abstractions.ts"],"sourcesContent":["import { createPermissionsAbstraction } from \"@webiny/api-core/features/security/permissions/index.js\";\nimport type { Permissions } from \"@webiny/api-core/features/security/permissions/index.js\";\nimport { BACKGROUND_TASK_PERMISSIONS_SCHEMA } from \"~/api/permissions.js\";\n\nexport const BackgroundTaskPermissions = createPermissionsAbstraction(\n    BACKGROUND_TASK_PERMISSIONS_SCHEMA\n);\n\nexport namespace BackgroundTaskPermissions {\n    export type Interface = Permissions<typeof BACKGROUND_TASK_PERMISSIONS_SCHEMA>;\n}\n"],"names":["BackgroundTaskPermissions","createPermissionsAbstraction","BACKGROUND_TASK_PERMISSIONS_SCHEMA"],"mappings":";;AAIO,MAAMA,4BAA4BC,6BACrCC"}

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

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

package/api/features/BackgroundTaskPermissions/feature.js

@@ -0,0 +1,7 @@
+import { createPermissionsFeature } from "@webiny/api-core/features/security/permissions/index.js";
+import { BACKGROUND_TASK_PERMISSIONS_SCHEMA } from "../../permissions.js";
+import { BackgroundTaskPermissions } from "./abstractions.js";
+const BackgroundTaskPermissionsFeature = createPermissionsFeature(BACKGROUND_TASK_PERMISSIONS_SCHEMA, BackgroundTaskPermissions);
+export { BackgroundTaskPermissionsFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/BackgroundTaskPermissions/feature.js","sources":["../../../../src/api/features/BackgroundTaskPermissions/feature.ts"],"sourcesContent":["import { createPermissionsFeature } from \"@webiny/api-core/features/security/permissions/index.js\";\nimport { BACKGROUND_TASK_PERMISSIONS_SCHEMA } from \"~/api/permissions.js\";\nimport { BackgroundTaskPermissions } from \"./abstractions.js\";\n\nexport const BackgroundTaskPermissionsFeature = createPermissionsFeature(\n    BACKGROUND_TASK_PERMISSIONS_SCHEMA,\n    BackgroundTaskPermissions\n);\n"],"names":["BackgroundTaskPermissionsFeature","createPermissionsFeature","BACKGROUND_TASK_PERMISSIONS_SCHEMA","BackgroundTaskPermissions"],"mappings":";;;AAIO,MAAMA,mCAAmCC,yBAC5CC,oCACAC"}

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

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

package/api/features/BackgroundTaskPermissions/index.js

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

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

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

package/api/features/CleanupTaskSubtree/CleanupTaskSubtreeUseCase.js

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

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

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

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

@@ -0,0 +1,7 @@
+export interface ICleanupTaskSubtreeUseCase {
+    execute(taskId: string): Promise<void>;
+}
+export declare const CleanupTaskSubtreeUseCase: import("@webiny/di").Abstraction<ICleanupTaskSubtreeUseCase>;
+export declare namespace CleanupTaskSubtreeUseCase {
+    type Interface = ICleanupTaskSubtreeUseCase;
+}

package/api/features/CleanupTaskSubtree/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/CleanupTaskSubtree/abstractions.js","sources":["../../../../src/api/features/CleanupTaskSubtree/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\n\nexport interface ICleanupTaskSubtreeUseCase {\n    execute(taskId: string): Promise<void>;\n}\n\nexport const CleanupTaskSubtreeUseCase = createAbstraction<ICleanupTaskSubtreeUseCase>(\n    \"Tasks/CleanupTaskSubtreeUseCase\"\n);\n\nexport namespace CleanupTaskSubtreeUseCase {\n    export type Interface = ICleanupTaskSubtreeUseCase;\n}\n"],"names":["CleanupTaskSubtreeUseCase","createAbstraction"],"mappings":";AAMO,MAAMA,4BAA4BC,kBACrC"}

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

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

package/api/features/CleanupTaskSubtree/feature.js

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

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

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

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

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

package/api/features/CleanupTaskSubtree/index.js

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

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

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

package/api/features/CreateTask/CreateTaskUseCase.js

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

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

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

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

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

package/api/features/CreateTask/abstractions.js

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

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

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

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

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

package/api/features/CreateTask/feature.js

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

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

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

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

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

package/api/features/CreateTask/index.js

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

package/api/features/CreateTaskLog/CreateTaskLogUseCase.d.ts

@@ -0,0 +1,13 @@
+import { CreateTaskLogUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { TaskLogsRepository } from "../../../api/domain/task/abstractions.js";
+import type { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import type { ITaskLogCreateInput } from "../../../api/types.js";
+declare class CreateTaskLogUseCaseImpl implements UseCaseAbstraction.Interface {
+    private readonly repository;
+    constructor(repository: TaskLogsRepository.Interface);
+    execute(task: Pick<TaskService.Task, "id">, data: ITaskLogCreateInput): Promise<import("@webiny/feature/api/Result.js").Result<import("~/api/types.js").ITaskLog, import("../../domain/errors.js").BackgroundTaskPersistenceError>>;
+}
+export declare const CreateTaskLogUseCase: typeof CreateTaskLogUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateTaskLogUseCase>;
+};
+export {};

package/api/features/CreateTaskLog/CreateTaskLogUseCase.js

@@ -0,0 +1,19 @@
+import { CreateTaskLogUseCase } from "./abstractions.js";
+import { TaskLogsRepository } from "../../domain/task/abstractions.js";
+class CreateTaskLogUseCaseImpl {
+    constructor(repository){
+        this.repository = repository;
+    }
+    execute(task, data) {
+        return this.repository.create(task, data);
+    }
+}
+const CreateTaskLogUseCase_CreateTaskLogUseCase = CreateTaskLogUseCase.createImplementation({
+    implementation: CreateTaskLogUseCaseImpl,
+    dependencies: [
+        TaskLogsRepository
+    ]
+});
+export { CreateTaskLogUseCase_CreateTaskLogUseCase as CreateTaskLogUseCase };
+
+//# sourceMappingURL=CreateTaskLogUseCase.js.map

package/api/features/CreateTaskLog/CreateTaskLogUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/CreateTaskLog/CreateTaskLogUseCase.js","sources":["../../../../src/api/features/CreateTaskLog/CreateTaskLogUseCase.ts"],"sourcesContent":["import { CreateTaskLogUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { TaskLogsRepository } from \"~/api/domain/task/abstractions.js\";\nimport type { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport type { ITaskLogCreateInput } from \"~/api/types.js\";\n\nclass CreateTaskLogUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private readonly repository: TaskLogsRepository.Interface) {}\n\n    execute(task: Pick<TaskService.Task, \"id\">, data: ITaskLogCreateInput) {\n        return this.repository.create(task, data);\n    }\n}\n\nexport const CreateTaskLogUseCase = UseCaseAbstraction.createImplementation({\n    implementation: CreateTaskLogUseCaseImpl,\n    dependencies: [TaskLogsRepository]\n});\n"],"names":["CreateTaskLogUseCaseImpl","repository","task","data","CreateTaskLogUseCase","UseCaseAbstraction","TaskLogsRepository"],"mappings":";;AAKA,MAAMA;IACF,YAA6BC,UAAwC,CAAE;aAA1CA,UAAU,GAAVA;IAA2C;IAExE,QAAQC,IAAkC,EAAEC,IAAyB,EAAE;QACnE,OAAO,IAAI,CAAC,UAAU,CAAC,MAAM,CAACD,MAAMC;IACxC;AACJ;AAEO,MAAMC,4CAAuBC,qBAAAA,oBAAuC,CAAC;IACxE,gBAAgBL;IAChB,cAAc;QAACM;KAAmB;AACtC"}

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

@@ -0,0 +1,16 @@
+import type { Result } from "@webiny/feature/api";
+import type { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import type { ITaskLog } from "../../../api/types.js";
+import type { ITaskLogCreateInput } from "../../../api/types.js";
+import type { BackgroundTaskPersistenceError } from "../../../api/domain/errors.js";
+type UseCaseError = BackgroundTaskPersistenceError;
+export interface ICreateTaskLogUseCase {
+    execute(task: Pick<TaskService.Task, "id">, data: ITaskLogCreateInput): Promise<Result<ITaskLog, UseCaseError>>;
+}
+/** Create a new log for a task run. */
+export declare const CreateTaskLogUseCase: import("@webiny/di").Abstraction<ICreateTaskLogUseCase>;
+export declare namespace CreateTaskLogUseCase {
+    type Interface = ICreateTaskLogUseCase;
+    type Error = UseCaseError;
+}
+export {};

package/api/features/CreateTaskLog/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/CreateTaskLog/abstractions.js","sources":["../../../../src/api/features/CreateTaskLog/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport type { ITaskLog } from \"~/api/types.js\";\nimport type { ITaskLogCreateInput } from \"~/api/types.js\";\nimport type { BackgroundTaskPersistenceError } from \"~/api/domain/errors.js\";\n\ntype UseCaseError = BackgroundTaskPersistenceError;\n\nexport interface ICreateTaskLogUseCase {\n    execute(\n        task: Pick<TaskService.Task, \"id\">,\n        data: ITaskLogCreateInput\n    ): Promise<Result<ITaskLog, UseCaseError>>;\n}\n\n/** Create a new log for a task run. */\nexport const CreateTaskLogUseCase = createAbstraction<ICreateTaskLogUseCase>(\n    \"Tasks/CreateTaskLogUseCase\"\n);\n\nexport namespace CreateTaskLogUseCase {\n    export type Interface = ICreateTaskLogUseCase;\n    export type Error = UseCaseError;\n}\n"],"names":["CreateTaskLogUseCase","createAbstraction"],"mappings":";AAiBO,MAAMA,uBAAuBC,kBAChC"}

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

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

package/api/features/CreateTaskLog/feature.js

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

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

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

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

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

package/api/features/CreateTaskLog/index.js

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