@webiny/tasks 0.0.0-unstable.e53eceafb5 → 0.0.0-unstable.e6f0dc8ca7

package/events/TaskAfterCreateEvent.js

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

package/events/TaskAfterCreateEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DomainEvent","TaskAfterCreateEventHandler","TaskAfterCreateEvent","eventType","getHandlerAbstraction"],"sources":["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"],"mappings":"AAAA,SAASA,WAAW,QAAQ,mDAAmD;AAC/E,SAASC,2BAA2B;AAEpC,OAAO,MAAMC,oBAAoB,SAASF,WAAW,CAAyB;EAC1EG,SAAS,GAAG,kBAAkB;EAE9BC,qBAAqBA,CAAA,EAAG;IACpB,OAAOH,2BAA2B;EACtC;AACJ","ignoreList":[]}

package/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/events/TaskAfterDeleteEvent.js

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

package/events/TaskAfterDeleteEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DomainEvent","TaskAfterDeleteEventHandler","TaskAfterDeleteEvent","eventType","getHandlerAbstraction"],"sources":["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"],"mappings":"AAAA,SAASA,WAAW,QAAQ,mDAAmD;AAC/E,SAASC,2BAA2B;AAEpC,OAAO,MAAMC,oBAAoB,SAASF,WAAW,CAAyB;EAC1EG,SAAS,GAAG,kBAAkB;EAE9BC,qBAAqBA,CAAA,EAAG;IACpB,OAAOH,2BAA2B;EACtC;AACJ","ignoreList":[]}

package/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/events/TaskAfterUpdateEvent.js

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

package/events/TaskAfterUpdateEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DomainEvent","TaskAfterUpdateEventHandler","TaskAfterUpdateEvent","eventType","getHandlerAbstraction"],"sources":["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"],"mappings":"AAAA,SAASA,WAAW,QAAQ,mDAAmD;AAC/E,SAASC,2BAA2B;AAEpC,OAAO,MAAMC,oBAAoB,SAASF,WAAW,CAAyB;EAC1EG,SAAS,GAAG,kBAAkB;EAE9BC,qBAAqBA,CAAA,EAAG;IACpB,OAAOH,2BAA2B;EACtC;AACJ","ignoreList":[]}

package/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/events/TaskBeforeCreateEvent.js

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

package/events/TaskBeforeCreateEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DomainEvent","TaskBeforeCreateEventHandler","TaskBeforeCreateEvent","eventType","getHandlerAbstraction"],"sources":["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"],"mappings":"AAAA,SAASA,WAAW,QAAQ,mDAAmD;AAC/E,SAASC,4BAA4B;AAErC,OAAO,MAAMC,qBAAqB,SAASF,WAAW,CAA0B;EAC5EG,SAAS,GAAG,mBAAmB;EAE/BC,qBAAqBA,CAAA,EAAG;IACpB,OAAOH,4BAA4B;EACvC;AACJ","ignoreList":[]}

package/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/events/TaskBeforeDeleteEvent.js

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

package/events/TaskBeforeDeleteEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DomainEvent","TaskBeforeDeleteEventHandler","TaskBeforeDeleteEvent","eventType","getHandlerAbstraction"],"sources":["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"],"mappings":"AAAA,SAASA,WAAW,QAAQ,mDAAmD;AAC/E,SAASC,4BAA4B;AAErC,OAAO,MAAMC,qBAAqB,SAASF,WAAW,CAA0B;EAC5EG,SAAS,GAAG,mBAAmB;EAE/BC,qBAAqBA,CAAA,EAAG;IACpB,OAAOH,4BAA4B;EACvC;AACJ","ignoreList":[]}

package/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/events/TaskBeforeUpdateEvent.js

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

package/events/TaskBeforeUpdateEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DomainEvent","TaskBeforeUpdateEventHandler","TaskBeforeUpdateEvent","eventType","getHandlerAbstraction"],"sources":["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"],"mappings":"AAAA,SAASA,WAAW,QAAQ,mDAAmD;AAC/E,SAASC,4BAA4B;AAErC,OAAO,MAAMC,qBAAqB,SAASF,WAAW,CAA0B;EAC5EG,SAAS,GAAG,mBAAmB;EAE/BC,qBAAqBA,CAAA,EAAG;IACpB,OAAOH,4BAA4B;EACvC;AACJ","ignoreList":[]}

package/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 "../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/events/abstractions.js

@@ -0,0 +1,39 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+// ============================================================================
+// TaskBeforeCreate Event
+// ============================================================================
+
+export const TaskBeforeCreateEventHandler = createAbstraction("TaskBeforeCreateEventHandler");
+
+// ============================================================================
+// TaskAfterCreate Event
+// ============================================================================
+
+export const TaskAfterCreateEventHandler = createAbstraction("TaskAfterCreateEventHandler");
+
+// ============================================================================
+// TaskBeforeUpdate Event
+// ============================================================================
+
+export const TaskBeforeUpdateEventHandler = createAbstraction("TaskBeforeUpdateEventHandler");
+
+// ============================================================================
+// TaskAfterUpdate Event
+// ============================================================================
+
+export const TaskAfterUpdateEventHandler = createAbstraction("TaskAfterUpdateEventHandler");
+
+// ============================================================================
+// TaskBeforeDelete Event
+// ============================================================================
+
+export const TaskBeforeDeleteEventHandler = createAbstraction("TaskBeforeDeleteEventHandler");
+
+// ============================================================================
+// TaskAfterDelete Event
+// ============================================================================
+
+export const TaskAfterDeleteEventHandler = createAbstraction("TaskAfterDeleteEventHandler");
+
+//# sourceMappingURL=abstractions.js.map

package/events/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","TaskBeforeCreateEventHandler","TaskAfterCreateEventHandler","TaskBeforeUpdateEventHandler","TaskAfterUpdateEventHandler","TaskBeforeDeleteEventHandler","TaskAfterDeleteEventHandler"],"sources":["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 \"~/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"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAIvD;AACA;AACA;;AAMA,OAAO,MAAMC,4BAA4B,GAAGD,iBAAiB,CAE3D,8BAA8B,CAAC;;AAOjC;AACA;AACA;;AAOA,OAAO,MAAME,2BAA2B,GAAGF,iBAAiB,CAE1D,6BAA6B,CAAC;;AAOhC;AACA;AACA;;AAOA,OAAO,MAAMG,4BAA4B,GAAGH,iBAAiB,CAE3D,8BAA8B,CAAC;;AAOjC;AACA;AACA;;AAOA,OAAO,MAAMI,2BAA2B,GAAGJ,iBAAiB,CAE1D,6BAA6B,CAAC;;AAOhC;AACA;AACA;;AAMA,OAAO,MAAMK,4BAA4B,GAAGL,iBAAiB,CAE3D,8BAA8B,CAAC;;AAOjC;AACA;AACA;;AAMA,OAAO,MAAMM,2BAA2B,GAAGN,iBAAiB,CAE1D,6BAA6B,CAAC","ignoreList":[]}

package/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/events/index.js

@@ -0,0 +1,9 @@
+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";
+
+//# sourceMappingURL=index.js.map

package/events/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export * from \"./abstractions.js\";\nexport * from \"./TaskBeforeCreateEvent.js\";\nexport * from \"./TaskAfterCreateEvent.js\";\nexport * from \"./TaskBeforeUpdateEvent.js\";\nexport * from \"./TaskAfterUpdateEvent.js\";\nexport * from \"./TaskBeforeDeleteEvent.js\";\nexport * from \"./TaskAfterDeleteEvent.js\";\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA","ignoreList":[]}

package/features/AbortTask/AbortTaskUseCase.d.ts

@@ -0,0 +1,10 @@
+import { Result } from "@webiny/feature/api";
+import { AbortTaskUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import type { Context } from "../../types.js";
+export declare class AbortTaskUseCaseImpl implements UseCaseAbstraction.Interface {
+    private context;
+    constructor(context: Context);
+    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/features/AbortTask/AbortTaskUseCase.js

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

package/features/AbortTask/AbortTaskUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["AbortTaskUseCaseImpl","constructor","context","execute","params","result","tasks","abort"],"sources":["AbortTaskUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { AbortTaskUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport type { Context } from \"~/types.js\";\n\nexport class AbortTaskUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(private context: Context) {}\n\n    async execute<\n        I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends TaskService.GenericOutput = TaskService.GenericOutput\n    >(\n        params: UseCaseAbstraction.Params\n    ): Promise<Result<TaskService.Task<I, O>, UseCaseAbstraction.Error>> {\n        const result = await this.context.tasks.abort<I, O>(params);\n        return result as unknown as Promise<\n            Result<TaskService.Task<I, O>, UseCaseAbstraction.Error>\n        >;\n    }\n}\n"],"mappings":"AAMA,OAAO,MAAMA,oBAAoB,CAAyC;EAC/DC,WAAWA,CAASC,OAAgB,EAAE;IAAA,KAAlBA,OAAgB,GAAhBA,OAAgB;EAAG;EAE9C,MAAMC,OAAOA,CAITC,MAAiC,EACgC;IACjE,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACH,OAAO,CAACI,KAAK,CAACC,KAAK,CAAOH,MAAM,CAAC;IAC3D,OAAOC,MAAM;EAGjB;AACJ","ignoreList":[]}

package/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 "../../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/features/AbortTask/abstractions.js

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

package/features/AbortTask/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","AbortTaskUseCase"],"sources":["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 { TaskDefinitionNotFoundError, TaskNotFoundError, TaskAbortError } from \"~/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"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;AA2B/D,OAAO,MAAMC,gBAAgB,GAAGD,iBAAiB,CAAoB,wBAAwB,CAAC","ignoreList":[]}

package/features/AbortTask/feature.d.ts

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

package/features/AbortTask/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { AbortTaskUseCaseImpl } from "./AbortTaskUseCase.js";
+import { AbortTaskUseCase } from "./abstractions.js";
+export const AbortTaskFeature = createFeature({
+  name: "AbortTask",
+  register(container, context) {
+    container.registerInstance(AbortTaskUseCase, new AbortTaskUseCaseImpl(context));
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/AbortTask/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","AbortTaskUseCaseImpl","AbortTaskUseCase","AbortTaskFeature","name","register","container","context","registerInstance"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { AbortTaskUseCaseImpl } from \"./AbortTaskUseCase.js\";\nimport type { Context } from \"~/types.js\";\nimport { AbortTaskUseCase } from \"./abstractions.js\";\n\nexport const AbortTaskFeature = createFeature<Context>({\n    name: \"AbortTask\",\n    register(container, context) {\n        container.registerInstance(AbortTaskUseCase, new AbortTaskUseCaseImpl(context!));\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,oBAAoB;AAE7B,SAASC,gBAAgB;AAEzB,OAAO,MAAMC,gBAAgB,GAAGH,aAAa,CAAU;EACnDI,IAAI,EAAE,WAAW;EACjBC,QAAQA,CAACC,SAAS,EAAEC,OAAO,EAAE;IACzBD,SAAS,CAACE,gBAAgB,CAACN,gBAAgB,EAAE,IAAID,oBAAoB,CAACM,OAAQ,CAAC,CAAC;EACpF;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/AbortTask/index.d.ts

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

package/features/AbortTask/index.js

@@ -0,0 +1,4 @@
+export { AbortTaskUseCase } from "./abstractions.js";
+export { AbortTaskFeature } from "./feature.js";
+
+//# sourceMappingURL=index.js.map

package/features/AbortTask/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["AbortTaskUseCase","AbortTaskFeature"],"sources":["index.ts"],"sourcesContent":["export { AbortTaskUseCase } from \"./abstractions.js\";\nexport { AbortTaskFeature } from \"./feature.js\";\n"],"mappings":"AAAA,SAASA,gBAAgB;AACzB,SAASC,gBAAgB","ignoreList":[]}

package/features/CleanupTaskSubtree/CleanupTaskSubtreeUseCase.d.ts

@@ -0,0 +1,7 @@
+import { CleanupTaskSubtreeUseCase as UseCaseAbstraction } from "./abstractions.js";
+import type { Context } from "../../types.js";
+export declare class CleanupTaskSubtreeUseCaseImpl implements UseCaseAbstraction.Interface {
+    private readonly context;
+    constructor(context: Context);
+    execute(taskId: string): Promise<void>;
+}

package/features/CleanupTaskSubtree/CleanupTaskSubtreeUseCase.js

@@ -0,0 +1,10 @@
+export class CleanupTaskSubtreeUseCaseImpl {
+  constructor(context) {
+    this.context = context;
+  }
+  async execute(taskId) {
+    await this.context.tasks.cleanupTaskSubtree(taskId);
+  }
+}
+
+//# sourceMappingURL=CleanupTaskSubtreeUseCase.js.map

package/features/CleanupTaskSubtree/CleanupTaskSubtreeUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["CleanupTaskSubtreeUseCaseImpl","constructor","context","execute","taskId","tasks","cleanupTaskSubtree"],"sources":["CleanupTaskSubtreeUseCase.ts"],"sourcesContent":["import { CleanupTaskSubtreeUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport type { Context } from \"~/types.js\";\n\nexport class CleanupTaskSubtreeUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(private readonly context: Context) {}\n\n    public async execute(taskId: string): Promise<void> {\n        await this.context.tasks.cleanupTaskSubtree(taskId);\n    }\n}\n"],"mappings":"AAGA,OAAO,MAAMA,6BAA6B,CAAyC;EACxEC,WAAWA,CAAkBC,OAAgB,EAAE;IAAA,KAAlBA,OAAgB,GAAhBA,OAAgB;EAAG;EAEvD,MAAaC,OAAOA,CAACC,MAAc,EAAiB;IAChD,MAAM,IAAI,CAACF,OAAO,CAACG,KAAK,CAACC,kBAAkB,CAACF,MAAM,CAAC;EACvD;AACJ","ignoreList":[]}

package/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/features/CleanupTaskSubtree/abstractions.js

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

package/features/CleanupTaskSubtree/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","CleanupTaskSubtreeUseCase"],"sources":["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"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAMvD,OAAO,MAAMC,yBAAyB,GAAGD,iBAAiB,CACtD,iCACJ,CAAC","ignoreList":[]}

package/features/CleanupTaskSubtree/index.d.ts

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

package/features/CleanupTaskSubtree/index.js

@@ -0,0 +1,4 @@
+export { CleanupTaskSubtreeUseCase } from "./abstractions.js";
+export { CleanupTaskSubtreeUseCaseImpl } from "./CleanupTaskSubtreeUseCase.js";
+
+//# sourceMappingURL=index.js.map

package/features/CleanupTaskSubtree/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["CleanupTaskSubtreeUseCase","CleanupTaskSubtreeUseCaseImpl"],"sources":["index.ts"],"sourcesContent":["export { CleanupTaskSubtreeUseCase } from \"./abstractions.js\";\nexport { CleanupTaskSubtreeUseCaseImpl } from \"./CleanupTaskSubtreeUseCase.js\";\n"],"mappings":"AAAA,SAASA,yBAAyB;AAClC,SAASC,6BAA6B","ignoreList":[]}

package/features/GetTask/GetTaskUseCase.d.ts

@@ -0,0 +1,9 @@
+import { GetTaskUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import type { Context } from "../../types.js";
+export declare class GetTaskUseCaseImpl implements UseCaseAbstraction.Interface {
+    private context;
+    constructor(context: Context);
+    execute<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends TaskService.GenericOutput = TaskService.GenericOutput>(id: string): Promise<TaskService.Task<I, O> | null>;
+}

package/features/GetTask/GetTaskUseCase.js

@@ -0,0 +1,10 @@
+export class GetTaskUseCaseImpl {
+  constructor(context) {
+    this.context = context;
+  }
+  async execute(id) {
+    return await this.context.tasks.getTask(id);
+  }
+}
+
+//# sourceMappingURL=GetTaskUseCase.js.map

package/features/GetTask/GetTaskUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["GetTaskUseCaseImpl","constructor","context","execute","id","tasks","getTask"],"sources":["GetTaskUseCase.ts"],"sourcesContent":["import { GetTaskUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport type { Context } from \"~/types.js\";\n\nexport class GetTaskUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(private context: Context) {}\n\n    async execute<\n        I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends TaskService.GenericOutput = TaskService.GenericOutput\n    >(id: string): Promise<TaskService.Task<I, O> | null> {\n        return await this.context.tasks.getTask<I, O>(id);\n    }\n}\n"],"mappings":"AAKA,OAAO,MAAMA,kBAAkB,CAAyC;EAC7DC,WAAWA,CAASC,OAAgB,EAAE;IAAA,KAAlBA,OAAgB,GAAhBA,OAAgB;EAAG;EAE9C,MAAMC,OAAOA,CAGXC,EAAU,EAA0C;IAClD,OAAO,MAAM,IAAI,CAACF,OAAO,CAACG,KAAK,CAACC,OAAO,CAAOF,EAAE,CAAC;EACrD;AACJ","ignoreList":[]}

package/features/GetTask/abstractions.d.ts

@@ -0,0 +1,10 @@
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+export interface IGetTaskUseCase {
+    execute<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends TaskService.GenericOutput = TaskService.GenericOutput>(id: string): Promise<TaskService.Task<I, O> | null>;
+}
+export declare const GetTaskUseCase: import("@webiny/di").Abstraction<IGetTaskUseCase>;
+export declare namespace GetTaskUseCase {
+    type Interface = IGetTaskUseCase;
+    type Return<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends TaskService.GenericOutput = TaskService.GenericOutput> = Promise<TaskService.Task<I, O> | null>;
+}

package/features/GetTask/abstractions.js

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

package/features/GetTask/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","GetTaskUseCase"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } 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\";\n\nexport interface IGetTaskUseCase {\n    execute<\n        I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends TaskService.GenericOutput = TaskService.GenericOutput\n    >(\n        id: string\n    ): Promise<TaskService.Task<I, O> | null>;\n}\n\nexport const GetTaskUseCase = createAbstraction<IGetTaskUseCase>(\"Tasks/GetTaskUseCase\");\n\nexport namespace GetTaskUseCase {\n    export type Interface = IGetTaskUseCase;\n\n    export type Return<\n        I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends TaskService.GenericOutput = TaskService.GenericOutput\n    > = Promise<TaskService.Task<I, O> | null>;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAavD,OAAO,MAAMC,cAAc,GAAGD,iBAAiB,CAAkB,sBAAsB,CAAC","ignoreList":[]}

package/features/GetTask/feature.d.ts

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

package/features/GetTask/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { GetTaskUseCaseImpl } from "./GetTaskUseCase.js";
+import { GetTaskUseCase } from "./abstractions.js";
+export const GetTaskFeature = createFeature({
+  name: "GetTask",
+  register(container, context) {
+    container.registerInstance(GetTaskUseCase, new GetTaskUseCaseImpl(context));
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/GetTask/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","GetTaskUseCaseImpl","GetTaskUseCase","GetTaskFeature","name","register","container","context","registerInstance"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { GetTaskUseCaseImpl } from \"./GetTaskUseCase.js\";\nimport type { Context } from \"~/types.js\";\nimport { GetTaskUseCase } from \"./abstractions.js\";\n\nexport const GetTaskFeature = createFeature<Context>({\n    name: \"GetTask\",\n    register(container, context) {\n        container.registerInstance(GetTaskUseCase, new GetTaskUseCaseImpl(context!));\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,kBAAkB;AAE3B,SAASC,cAAc;AAEvB,OAAO,MAAMC,cAAc,GAAGH,aAAa,CAAU;EACjDI,IAAI,EAAE,SAAS;EACfC,QAAQA,CAACC,SAAS,EAAEC,OAAO,EAAE;IACzBD,SAAS,CAACE,gBAAgB,CAACN,cAAc,EAAE,IAAID,kBAAkB,CAACM,OAAQ,CAAC,CAAC;EAChF;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/GetTask/index.d.ts

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

package/features/GetTask/index.js

@@ -0,0 +1,4 @@
+export { GetTaskUseCase } from "./abstractions.js";
+export { GetTaskFeature } from "./feature.js";
+
+//# sourceMappingURL=index.js.map

package/features/GetTask/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["GetTaskUseCase","GetTaskFeature"],"sources":["index.ts"],"sourcesContent":["export { GetTaskUseCase } from \"./abstractions.js\";\nexport { GetTaskFeature } from \"./feature.js\";\n"],"mappings":"AAAA,SAASA,cAAc;AACvB,SAASC,cAAc","ignoreList":[]}

package/features/GetTaskDefinition/GetTaskDefinitionUseCase.d.ts

@@ -0,0 +1,12 @@
+import { Result } from "@webiny/feature/api";
+import { GetTaskDefinitionUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+declare class GetTaskDefinitionUseCaseImpl implements UseCaseAbstraction.Interface {
+    private definitions;
+    constructor(definitions: TaskDefinition.Interface[]);
+    execute<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends TaskDefinition.TaskOutput = TaskDefinition.TaskOutput>(id: string): Result<TaskDefinition.Runnable<I, O>, UseCaseAbstraction.Error>;
+}
+export declare const GetTaskDefinitionUseCase: typeof GetTaskDefinitionUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetTaskDefinitionUseCase>;
+};
+export {};

package/features/GetTaskDefinition/GetTaskDefinitionUseCase.js

@@ -0,0 +1,25 @@
+import { Result } from "@webiny/feature/api";
+import { GetTaskDefinitionUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { TaskDefinitionNotFoundError } from "../../domain/errors.js";
+class GetTaskDefinitionUseCaseImpl {
+  constructor(definitions) {
+    this.definitions = definitions;
+  }
+  execute(id) {
+    for (const definition of this.definitions) {
+      if (definition.id === id) {
+        return Result.ok(definition);
+      }
+    }
+    return Result.fail(new TaskDefinitionNotFoundError(id));
+  }
+}
+export const GetTaskDefinitionUseCase = UseCaseAbstraction.createImplementation({
+  implementation: GetTaskDefinitionUseCaseImpl,
+  dependencies: [[TaskDefinition, {
+    multiple: true
+  }]]
+});
+
+//# sourceMappingURL=GetTaskDefinitionUseCase.js.map

package/features/GetTaskDefinition/GetTaskDefinitionUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","GetTaskDefinitionUseCase","UseCaseAbstraction","TaskDefinition","TaskDefinitionNotFoundError","GetTaskDefinitionUseCaseImpl","constructor","definitions","execute","id","definition","ok","fail","createImplementation","implementation","dependencies","multiple"],"sources":["GetTaskDefinitionUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { GetTaskDefinitionUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { TaskDefinitionNotFoundError } from \"~/domain/errors.js\";\n\nclass GetTaskDefinitionUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(private definitions: TaskDefinition.Interface[]) {}\n\n    public execute<\n        I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends TaskDefinition.TaskOutput = TaskDefinition.TaskOutput\n    >(id: string): Result<TaskDefinition.Runnable<I, O>, UseCaseAbstraction.Error> {\n        for (const definition of this.definitions) {\n            if (definition.id === id) {\n                return Result.ok(definition as TaskDefinition.Runnable<I, O>);\n            }\n        }\n\n        return Result.fail(new TaskDefinitionNotFoundError(id));\n    }\n}\n\nexport const GetTaskDefinitionUseCase = UseCaseAbstraction.createImplementation({\n    implementation: GetTaskDefinitionUseCaseImpl,\n    dependencies: [[TaskDefinition, { multiple: true }]]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,wBAAwB,IAAIC,kBAAkB;AACvD,SAASC,cAAc,QAAQ,wDAAwD;AACvF,SAASC,2BAA2B;AAEpC,MAAMC,4BAA4B,CAAyC;EAChEC,WAAWA,CAASC,WAAuC,EAAE;IAAA,KAAzCA,WAAuC,GAAvCA,WAAuC;EAAG;EAE9DC,OAAOA,CAGZC,EAAU,EAAmE;IAC3E,KAAK,MAAMC,UAAU,IAAI,IAAI,CAACH,WAAW,EAAE;MACvC,IAAIG,UAAU,CAACD,EAAE,KAAKA,EAAE,EAAE;QACtB,OAAOT,MAAM,CAACW,EAAE,CAACD,UAA2C,CAAC;MACjE;IACJ;IAEA,OAAOV,MAAM,CAACY,IAAI,CAAC,IAAIR,2BAA2B,CAACK,EAAE,CAAC,CAAC;EAC3D;AACJ;AAEA,OAAO,MAAMR,wBAAwB,GAAGC,kBAAkB,CAACW,oBAAoB,CAAC;EAC5EC,cAAc,EAAET,4BAA4B;EAC5CU,YAAY,EAAE,CAAC,CAACZ,cAAc,EAAE;IAAEa,QAAQ,EAAE;EAAK,CAAC,CAAC;AACvD,CAAC,CAAC","ignoreList":[]}

package/features/GetTaskDefinition/abstractions.d.ts

@@ -0,0 +1,17 @@
+import type { Result } from "@webiny/feature/api";
+import type { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import type { TaskDefinitionNotFoundError } from "../../domain/errors.js";
+export interface IGetTaskDefinitionUseCase {
+    execute<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends TaskDefinition.TaskOutput = TaskDefinition.TaskOutput>(id: string): Result<TaskDefinition.Runnable<I, O>, UseCaseError>;
+}
+export interface IGetTaskDefinitionUseCaseErrors {
+    notFound: TaskDefinitionNotFoundError;
+}
+type UseCaseError = IGetTaskDefinitionUseCaseErrors[keyof IGetTaskDefinitionUseCaseErrors];
+export declare const GetTaskDefinitionUseCase: import("@webiny/di").Abstraction<IGetTaskDefinitionUseCase>;
+export declare namespace GetTaskDefinitionUseCase {
+    type Interface = IGetTaskDefinitionUseCase;
+    type Error = UseCaseError;
+    type Return<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends TaskDefinition.TaskOutput = TaskDefinition.TaskOutput> = Result<TaskDefinition.Runnable<I, O>, UseCaseError>;
+}
+export {};