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

package/api/events/TaskAfterDeleteEvent.d.ts

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

package/api/events/TaskAfterDeleteEvent.js

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

package/api/events/TaskAfterDeleteEvent.js.map

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

package/api/events/TaskAfterUpdateEvent.d.ts

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

package/api/events/TaskAfterUpdateEvent.js

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

package/api/events/TaskAfterUpdateEvent.js.map

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

package/api/events/TaskBeforeCreateEvent.d.ts

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

package/api/events/TaskBeforeCreateEvent.js

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

package/api/events/TaskBeforeCreateEvent.js.map

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

package/api/events/TaskBeforeDeleteEvent.d.ts

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

package/api/events/TaskBeforeDeleteEvent.js

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

package/api/events/TaskBeforeDeleteEvent.js.map

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

package/api/events/TaskBeforeUpdateEvent.d.ts

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

package/api/events/TaskBeforeUpdateEvent.js

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

package/api/events/TaskBeforeUpdateEvent.js.map

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

package/api/events/abstractions.d.ts

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

package/api/events/abstractions.js

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

package/api/events/abstractions.js.map

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

package/api/events/index.d.ts

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

package/api/events/index.js

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

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

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

package/api/features/AbortTask/AbortTaskUseCase.js

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

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

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

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";
+import { GetRunnableTaskDefinitionUseCase } from "../../../api/features/GetRunnableTaskDefinition/index.js";
+/**
+ * Deletes the task identified by `rootId`, all its descendants, and their logs (when the owning
+ * definition has `databaseLogs: true`). 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 getDefinition;
+    private readonly logger;
+    constructor(tasks: TasksRepository.Interface, logs: TaskLogsRepository.Interface, deleteTask: DeleteTaskUseCase.Interface, getDefinition: GetRunnableTaskDefinitionUseCase.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,122 @@
+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";
+import { GetRunnableTaskDefinitionUseCase } from "../GetRunnableTaskDefinition/index.js";
+const PAGE_SIZE = 100;
+class CleanupTaskSubtreeUseCaseImpl {
+    constructor(tasks, logs, deleteTask, getDefinition, logger){
+        this.tasks = tasks;
+        this.logs = logs;
+        this.deleteTask = deleteTask;
+        this.getDefinition = getDefinition;
+        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) {
+        const definition = this.getDefinition.execute(task.definitionId);
+        if (definition.isFail() || true !== definition.value.databaseLogs) return;
+        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,
+        GetRunnableTaskDefinitionUseCase,
+        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 { GetRunnableTaskDefinitionUseCase } from \"~/api/features/GetRunnableTaskDefinition/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 (when the owning\n * definition has `databaseLogs: true`). Bottom-up and best-effort: a record that fails to delete is\n * logged and 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 getDefinition: GetRunnableTaskDefinitionUseCase.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        const definition = this.getDefinition.execute(task.definitionId);\n        if (definition.isFail() || definition.value.databaseLogs !== true) {\n            return;\n        }\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: [\n        TasksRepository,\n        TaskLogsRepository,\n        DeleteTaskUseCase,\n        GetRunnableTaskDefinitionUseCase,\n        Logger\n    ]\n});\n"],"names":["PAGE_SIZE","CleanupTaskSubtreeUseCaseImpl","tasks","logs","deleteTask","getDefinition","logger","rootId","ordered","error","task","result","root","order","seen","Set","i","current","child","parentId","children","after","params","items","meta","taskId","definition","log","CleanupTaskSubtreeUseCase","UseCaseAbstraction","TasksRepository","TaskLogsRepository","DeleteTaskUseCase","GetRunnableTaskDefinitionUseCase","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