@webiny/tasks 0.0.0-unstable.eb196ccd2f → 0.0.0-unstable.f6dc066313

package/events/abstractions.d.ts

@@ -0,0 +1,53 @@
+import type { DomainEvent, IEventHandler } from "@webiny/api-core/features/EventPublisher";
+import type { ITask, ITaskCreateData, ITaskUpdateData } from "../types.js";
+export interface TaskBeforeCreatePayload {
+    input: ITaskCreateData;
+}
+export declare const TaskBeforeCreateHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TaskBeforeCreatePayload>>>;
+export declare namespace TaskBeforeCreateHandler {
+    type Interface = IEventHandler<DomainEvent<TaskBeforeCreatePayload>>;
+    type Event = DomainEvent<TaskBeforeCreatePayload>;
+}
+export interface TaskAfterCreatePayload {
+    input: ITaskCreateData;
+    task: ITask;
+}
+export declare const TaskAfterCreateHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TaskAfterCreatePayload>>>;
+export declare namespace TaskAfterCreateHandler {
+    type Interface = IEventHandler<DomainEvent<TaskAfterCreatePayload>>;
+    type Event = DomainEvent<TaskAfterCreatePayload>;
+}
+export interface TaskBeforeUpdatePayload {
+    input: ITaskUpdateData;
+    original: ITask;
+}
+export declare const TaskBeforeUpdateHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TaskBeforeUpdatePayload>>>;
+export declare namespace TaskBeforeUpdateHandler {
+    type Interface = IEventHandler<DomainEvent<TaskBeforeUpdatePayload>>;
+    type Event = DomainEvent<TaskBeforeUpdatePayload>;
+}
+export interface TaskAfterUpdatePayload {
+    input: ITaskUpdateData;
+    task: ITask;
+}
+export declare const TaskAfterUpdateHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TaskAfterUpdatePayload>>>;
+export declare namespace TaskAfterUpdateHandler {
+    type Interface = IEventHandler<DomainEvent<TaskAfterUpdatePayload>>;
+    type Event = DomainEvent<TaskAfterUpdatePayload>;
+}
+export interface TaskBeforeDeletePayload {
+    task: ITask;
+}
+export declare const TaskBeforeDeleteHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TaskBeforeDeletePayload>>>;
+export declare namespace TaskBeforeDeleteHandler {
+    type Interface = IEventHandler<DomainEvent<TaskBeforeDeletePayload>>;
+    type Event = DomainEvent<TaskBeforeDeletePayload>;
+}
+export interface TaskAfterDeletePayload {
+    task: ITask;
+}
+export declare const TaskAfterDeleteHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TaskAfterDeletePayload>>>;
+export declare namespace TaskAfterDeleteHandler {
+    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 TaskBeforeCreateHandler = createAbstraction("TaskBeforeCreateHandler");
+
+// ============================================================================
+// TaskAfterCreate Event
+// ============================================================================
+
+export const TaskAfterCreateHandler = createAbstraction("TaskAfterCreateHandler");
+
+// ============================================================================
+// TaskBeforeUpdate Event
+// ============================================================================
+
+export const TaskBeforeUpdateHandler = createAbstraction("TaskBeforeUpdateHandler");
+
+// ============================================================================
+// TaskAfterUpdate Event
+// ============================================================================
+
+export const TaskAfterUpdateHandler = createAbstraction("TaskAfterUpdateHandler");
+
+// ============================================================================
+// TaskBeforeDelete Event
+// ============================================================================
+
+export const TaskBeforeDeleteHandler = createAbstraction("TaskBeforeDeleteHandler");
+
+// ============================================================================
+// TaskAfterDelete Event
+// ============================================================================
+
+export const TaskAfterDeleteHandler = createAbstraction("TaskAfterDeleteHandler");
+
+//# sourceMappingURL=abstractions.js.map

package/events/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","TaskBeforeCreateHandler","TaskAfterCreateHandler","TaskBeforeUpdateHandler","TaskAfterUpdateHandler","TaskBeforeDeleteHandler","TaskAfterDeleteHandler"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { DomainEvent, IEventHandler } from \"@webiny/api-core/features/EventPublisher\";\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 TaskBeforeCreateHandler =\n    createAbstraction<IEventHandler<DomainEvent<TaskBeforeCreatePayload>>>(\n        \"TaskBeforeCreateHandler\"\n    );\n\nexport namespace TaskBeforeCreateHandler {\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 TaskAfterCreateHandler =\n    createAbstraction<IEventHandler<DomainEvent<TaskAfterCreatePayload>>>(\"TaskAfterCreateHandler\");\n\nexport namespace TaskAfterCreateHandler {\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 TaskBeforeUpdateHandler =\n    createAbstraction<IEventHandler<DomainEvent<TaskBeforeUpdatePayload>>>(\n        \"TaskBeforeUpdateHandler\"\n    );\n\nexport namespace TaskBeforeUpdateHandler {\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 TaskAfterUpdateHandler =\n    createAbstraction<IEventHandler<DomainEvent<TaskAfterUpdatePayload>>>(\"TaskAfterUpdateHandler\");\n\nexport namespace TaskAfterUpdateHandler {\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 TaskBeforeDeleteHandler =\n    createAbstraction<IEventHandler<DomainEvent<TaskBeforeDeletePayload>>>(\n        \"TaskBeforeDeleteHandler\"\n    );\n\nexport namespace TaskBeforeDeleteHandler {\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 TaskAfterDeleteHandler =\n    createAbstraction<IEventHandler<DomainEvent<TaskAfterDeletePayload>>>(\"TaskAfterDeleteHandler\");\n\nexport namespace TaskAfterDeleteHandler {\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,uBAAuB,GAChCD,iBAAiB,CACb,yBACJ,CAAC;;AAOL;AACA;AACA;;AAOA,OAAO,MAAME,sBAAsB,GAC/BF,iBAAiB,CAAqD,wBAAwB,CAAC;;AAOnG;AACA;AACA;;AAOA,OAAO,MAAMG,uBAAuB,GAChCH,iBAAiB,CACb,yBACJ,CAAC;;AAOL;AACA;AACA;;AAOA,OAAO,MAAMI,sBAAsB,GAC/BJ,iBAAiB,CAAqD,wBAAwB,CAAC;;AAOnG;AACA;AACA;;AAMA,OAAO,MAAMK,uBAAuB,GAChCL,iBAAiB,CACb,yBACJ,CAAC;;AAOL;AACA;AACA;;AAMA,OAAO,MAAMM,sBAAsB,GAC/BN,iBAAiB,CAAqD,wBAAwB,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,2 @@
+import type { Context } from "../../types.js";
+export declare const AbortTaskFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<Context>;

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/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,2 @@
+import type { Context } from "../../types.js";
+export declare const GetTaskFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<Context>;

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 {};

package/features/GetTaskDefinition/abstractions.js

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

package/features/GetTaskDefinition/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","GetTaskDefinitionUseCase"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport type { TaskDefinitionNotFoundError } from \"~/domain/errors.js\";\n\nexport interface IGetTaskDefinitionUseCase {\n    execute<\n        I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends TaskDefinition.TaskOutput = TaskDefinition.TaskOutput\n    >(\n        id: string\n    ): Result<TaskDefinition.Runnable<I, O>, UseCaseError>;\n}\n\nexport interface IGetTaskDefinitionUseCaseErrors {\n    notFound: TaskDefinitionNotFoundError;\n}\n\ntype UseCaseError = IGetTaskDefinitionUseCaseErrors[keyof IGetTaskDefinitionUseCaseErrors];\n\nexport const GetTaskDefinitionUseCase = createAbstraction<IGetTaskDefinitionUseCase>(\n    \"Tasks/GetTaskDefinitionUseCase\"\n);\n\nexport namespace GetTaskDefinitionUseCase {\n    export type Interface = IGetTaskDefinitionUseCase;\n\n    export type Error = UseCaseError;\n    export type Return<\n        I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends TaskDefinition.TaskOutput = TaskDefinition.TaskOutput\n    > = Result<TaskDefinition.Runnable<I, O>, UseCaseError>;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAoBvD,OAAO,MAAMC,wBAAwB,GAAGD,iBAAiB,CACrD,gCACJ,CAAC","ignoreList":[]}

package/features/GetTaskDefinition/feature.d.ts

@@ -0,0 +1 @@
+export declare const GetTaskDefinitionFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/GetTaskDefinition/feature.js

@@ -0,0 +1,10 @@
+import { createFeature } from "@webiny/feature/api";
+import { GetTaskDefinitionUseCase } from "./GetTaskDefinitionUseCase.js";
+export const GetTaskDefinitionFeature = createFeature({
+  name: "GetTaskDefinition",
+  register(container) {
+    container.register(GetTaskDefinitionUseCase);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/GetTaskDefinition/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","GetTaskDefinitionUseCase","GetTaskDefinitionFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { GetTaskDefinitionUseCase } from \"./GetTaskDefinitionUseCase.js\";\n\nexport const GetTaskDefinitionFeature = createFeature({\n    name: \"GetTaskDefinition\",\n    register(container) {\n        container.register(GetTaskDefinitionUseCase);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,wBAAwB;AAEjC,OAAO,MAAMC,wBAAwB,GAAGF,aAAa,CAAC;EAClDG,IAAI,EAAE,mBAAmB;EACzBC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,wBAAwB,CAAC;EAChD;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/GetTaskDefinition/index.d.ts

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

package/features/GetTaskDefinition/index.js

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

package/features/GetTaskDefinition/index.js.map

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

package/features/ListTaskDefinitions/ListTaskDefinitionsUseCase.d.ts

@@ -0,0 +1,11 @@
+import { ListTaskDefinitionsUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+declare class ListTaskDefinitionsUseCaseImpl implements UseCaseAbstraction.Interface {
+    private definitions;
+    constructor(definitions: TaskDefinition.Interface[]);
+    execute(): TaskDefinition.Interface[];
+}
+export declare const ListTaskDefinitionsUseCase: typeof ListTaskDefinitionsUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IListTaskDefinitionsUseCase>;
+};
+export {};

package/features/ListTaskDefinitions/ListTaskDefinitionsUseCase.js

@@ -0,0 +1,18 @@
+import { ListTaskDefinitionsUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+class ListTaskDefinitionsUseCaseImpl {
+  constructor(definitions) {
+    this.definitions = definitions;
+  }
+  execute() {
+    return this.definitions;
+  }
+}
+export const ListTaskDefinitionsUseCase = UseCaseAbstraction.createImplementation({
+  implementation: ListTaskDefinitionsUseCaseImpl,
+  dependencies: [[TaskDefinition, {
+    multiple: true
+  }]]
+});
+
+//# sourceMappingURL=ListTaskDefinitionsUseCase.js.map

package/features/ListTaskDefinitions/ListTaskDefinitionsUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ListTaskDefinitionsUseCase","UseCaseAbstraction","TaskDefinition","ListTaskDefinitionsUseCaseImpl","constructor","definitions","execute","createImplementation","implementation","dependencies","multiple"],"sources":["ListTaskDefinitionsUseCase.ts"],"sourcesContent":["import { ListTaskDefinitionsUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\n\nclass ListTaskDefinitionsUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(private definitions: TaskDefinition.Interface[]) {}\n\n    public execute(): TaskDefinition.Interface[] {\n        return this.definitions;\n    }\n}\n\nexport const ListTaskDefinitionsUseCase = UseCaseAbstraction.createImplementation({\n    implementation: ListTaskDefinitionsUseCaseImpl,\n    dependencies: [[TaskDefinition, { multiple: true }]]\n});\n"],"mappings":"AAAA,SAASA,0BAA0B,IAAIC,kBAAkB;AACzD,SAASC,cAAc,QAAQ,wDAAwD;AAEvF,MAAMC,8BAA8B,CAAyC;EAClEC,WAAWA,CAASC,WAAuC,EAAE;IAAA,KAAzCA,WAAuC,GAAvCA,WAAuC;EAAG;EAE9DC,OAAOA,CAAA,EAA+B;IACzC,OAAO,IAAI,CAACD,WAAW;EAC3B;AACJ;AAEA,OAAO,MAAML,0BAA0B,GAAGC,kBAAkB,CAACM,oBAAoB,CAAC;EAC9EC,cAAc,EAAEL,8BAA8B;EAC9CM,YAAY,EAAE,CAAC,CAACP,cAAc,EAAE;IAAEQ,QAAQ,EAAE;EAAK,CAAC,CAAC;AACvD,CAAC,CAAC","ignoreList":[]}

package/features/ListTaskDefinitions/abstractions.d.ts

@@ -0,0 +1,9 @@
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+export interface IListTaskDefinitionsUseCase {
+    execute(): TaskDefinition.Interface[];
+}
+export declare const ListTaskDefinitionsUseCase: import("@webiny/di").Abstraction<IListTaskDefinitionsUseCase>;
+export declare namespace ListTaskDefinitionsUseCase {
+    type Interface = IListTaskDefinitionsUseCase;
+    type Return = TaskDefinition.Interface[];
+}

package/features/ListTaskDefinitions/abstractions.js

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

package/features/ListTaskDefinitions/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","ListTaskDefinitionsUseCase"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\n\nexport interface IListTaskDefinitionsUseCase {\n    execute(): TaskDefinition.Interface[];\n}\n\nexport const ListTaskDefinitionsUseCase = createAbstraction<IListTaskDefinitionsUseCase>(\n    \"Tasks/ListTaskDefinitionsUseCase\"\n);\n\nexport namespace ListTaskDefinitionsUseCase {\n    export type Interface = IListTaskDefinitionsUseCase;\n    export type Return = TaskDefinition.Interface[];\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAOvD,OAAO,MAAMC,0BAA0B,GAAGD,iBAAiB,CACvD,kCACJ,CAAC","ignoreList":[]}

package/features/ListTaskDefinitions/feature.d.ts

@@ -0,0 +1 @@
+export declare const ListTaskDefinitionsFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/ListTaskDefinitions/feature.js

@@ -0,0 +1,10 @@
+import { createFeature } from "@webiny/feature/api";
+import { ListTaskDefinitionsUseCase } from "./ListTaskDefinitionsUseCase.js";
+export const ListTaskDefinitionsFeature = createFeature({
+  name: "ListTaskDefinitions",
+  register(container) {
+    container.register(ListTaskDefinitionsUseCase);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/ListTaskDefinitions/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","ListTaskDefinitionsUseCase","ListTaskDefinitionsFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ListTaskDefinitionsUseCase } from \"./ListTaskDefinitionsUseCase.js\";\n\nexport const ListTaskDefinitionsFeature = createFeature({\n    name: \"ListTaskDefinitions\",\n    register(container) {\n        container.register(ListTaskDefinitionsUseCase);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,0BAA0B;AAEnC,OAAO,MAAMC,0BAA0B,GAAGF,aAAa,CAAC;EACpDG,IAAI,EAAE,qBAAqB;EAC3BC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,0BAA0B,CAAC;EAClD;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/ListTaskDefinitions/index.d.ts

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

package/features/ListTaskDefinitions/index.js

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

package/features/ListTaskDefinitions/index.js.map

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

package/features/ListTasks/ListTasksUseCase.d.ts

@@ -0,0 +1,9 @@
+import { ListTasksUseCase 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, IListTasksResponse } from "../../types.js";
+export declare class ListTasksUseCaseImpl 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<IListTasksResponse<I, O>>;
+}

package/features/ListTasks/ListTasksUseCase.js

@@ -0,0 +1,10 @@
+export class ListTasksUseCaseImpl {
+  constructor(context) {
+    this.context = context;
+  }
+  async execute(params) {
+    return await this.context.tasks.listTasks(params);
+  }
+}
+
+//# sourceMappingURL=ListTasksUseCase.js.map

package/features/ListTasks/ListTasksUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ListTasksUseCaseImpl","constructor","context","execute","params","tasks","listTasks"],"sources":["ListTasksUseCase.ts"],"sourcesContent":["import { ListTasksUseCase 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, IListTasksResponse } from \"~/types.js\";\n\nexport class ListTasksUseCaseImpl 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    >(params?: UseCaseAbstraction.Params): Promise<IListTasksResponse<I, O>> {\n        return await this.context.tasks.listTasks<I, O>(params);\n    }\n}\n"],"mappings":"AAKA,OAAO,MAAMA,oBAAoB,CAAyC;EAC/DC,WAAWA,CAASC,OAAgB,EAAE;IAAA,KAAlBA,OAAgB,GAAhBA,OAAgB;EAAG;EAE9C,MAAMC,OAAOA,CAGXC,MAAkC,EAAqC;IACrE,OAAO,MAAM,IAAI,CAACF,OAAO,CAACG,KAAK,CAACC,SAAS,CAAOF,MAAM,CAAC;EAC3D;AACJ","ignoreList":[]}

package/features/ListTasks/abstractions.d.ts

@@ -0,0 +1,13 @@
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import type { IListTasksResponse, IListTaskParams } from "../../types.js";
+export interface IListTasksUseCase {
+    execute<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends TaskService.GenericOutput = TaskService.GenericOutput>(params?: ListTasksParams): Promise<IListTasksResponse<I, O>>;
+}
+export type ListTasksParams = IListTaskParams;
+export declare const ListTasksUseCase: import("@webiny/di").Abstraction<IListTasksUseCase>;
+export declare namespace ListTasksUseCase {
+    type Interface = IListTasksUseCase;
+    type Params = ListTasksParams;
+    type Return<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends TaskService.GenericOutput = TaskService.GenericOutput> = Promise<IListTasksResponse<I, O>>;
+}

package/features/ListTasks/abstractions.js

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

package/features/ListTasks/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","ListTasksUseCase"],"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\";\nimport type { IListTasksResponse, IListTaskParams } from \"~/types.js\";\n\nexport interface IListTasksUseCase {\n    execute<\n        I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends TaskService.GenericOutput = TaskService.GenericOutput\n    >(\n        params?: ListTasksParams\n    ): Promise<IListTasksResponse<I, O>>;\n}\n\nexport type ListTasksParams = IListTaskParams;\n\nexport const ListTasksUseCase = createAbstraction<IListTasksUseCase>(\"Tasks/ListTasksUseCase\");\n\nexport namespace ListTasksUseCase {\n    export type Interface = IListTasksUseCase;\n    export type Params = ListTasksParams;\n\n    export type Return<\n        I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends TaskService.GenericOutput = TaskService.GenericOutput\n    > = Promise<IListTasksResponse<I, O>>;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAgBvD,OAAO,MAAMC,gBAAgB,GAAGD,iBAAiB,CAAoB,wBAAwB,CAAC","ignoreList":[]}

package/features/ListTasks/feature.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from "../../types.js";
+export declare const ListTasksFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<Context>;