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

package/api/features/UpdateBackgroundTaskSettings/UpdateBackgroundTaskSettingsUseCase.js

@@ -0,0 +1,27 @@
+import { Result } from "@webiny/feature/api";
+import { UpdateBackgroundTaskSettingsRepository, UpdateBackgroundTaskSettingsUseCase } from "./abstractions.js";
+import { UpdateBackgroundTaskSettingsInputSchema } from "./schema.js";
+import { BackgroundTaskNotAuthorizedError, BackgroundTaskValidationError } from "../../domain/errors.js";
+import { BackgroundTaskPermissions } from "../BackgroundTaskPermissions/abstractions.js";
+class UpdateBackgroundTaskSettingsUseCaseImpl {
+    constructor(permissions, repository){
+        this.permissions = permissions;
+        this.repository = repository;
+    }
+    async execute(input) {
+        if (!await this.permissions.canEdit("task")) return Result.fail(new BackgroundTaskNotAuthorizedError());
+        const parsed = UpdateBackgroundTaskSettingsInputSchema.safeParse(input);
+        if (!parsed.success) return Result.fail(new BackgroundTaskValidationError(parsed.error));
+        return this.repository.execute(parsed.data);
+    }
+}
+const UpdateBackgroundTaskSettingsUseCase_UpdateBackgroundTaskSettingsUseCase = UpdateBackgroundTaskSettingsUseCase.createImplementation({
+    implementation: UpdateBackgroundTaskSettingsUseCaseImpl,
+    dependencies: [
+        BackgroundTaskPermissions,
+        UpdateBackgroundTaskSettingsRepository
+    ]
+});
+export { UpdateBackgroundTaskSettingsUseCase_UpdateBackgroundTaskSettingsUseCase as UpdateBackgroundTaskSettingsUseCase };
+
+//# sourceMappingURL=UpdateBackgroundTaskSettingsUseCase.js.map

package/api/features/UpdateBackgroundTaskSettings/UpdateBackgroundTaskSettingsUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/UpdateBackgroundTaskSettings/UpdateBackgroundTaskSettingsUseCase.js","sources":["../../../../src/api/features/UpdateBackgroundTaskSettings/UpdateBackgroundTaskSettingsUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    UpdateBackgroundTaskSettingsRepository,\n    UpdateBackgroundTaskSettingsUseCase as UseCaseAbstraction\n} from \"./abstractions.js\";\nimport { UpdateBackgroundTaskSettingsInputSchema } from \"./schema.js\";\nimport {\n    BackgroundTaskNotAuthorizedError,\n    BackgroundTaskValidationError\n} from \"~/api/domain/errors.js\";\nimport type { IBackgroundTaskSettings } from \"~/api/domain/BackgroundTaskSettings.js\";\nimport { BackgroundTaskPermissions } from \"~/api/features/BackgroundTaskPermissions/abstractions.js\";\n\nclass UpdateBackgroundTaskSettingsUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private readonly permissions: BackgroundTaskPermissions.Interface,\n        private readonly repository: UpdateBackgroundTaskSettingsRepository.Interface\n    ) {}\n\n    async execute(\n        input: UseCaseAbstraction.Input\n    ): Promise<Result<IBackgroundTaskSettings, UseCaseAbstraction.Error>> {\n        if (!(await this.permissions.canEdit(\"task\"))) {\n            return Result.fail(new BackgroundTaskNotAuthorizedError());\n        }\n\n        const parsed = UpdateBackgroundTaskSettingsInputSchema.safeParse(input);\n        if (!parsed.success) {\n            return Result.fail(new BackgroundTaskValidationError(parsed.error));\n        }\n\n        return this.repository.execute(parsed.data);\n    }\n}\n\nexport const UpdateBackgroundTaskSettingsUseCase = UseCaseAbstraction.createImplementation({\n    implementation: UpdateBackgroundTaskSettingsUseCaseImpl,\n    dependencies: [BackgroundTaskPermissions, UpdateBackgroundTaskSettingsRepository]\n});\n"],"names":["UpdateBackgroundTaskSettingsUseCaseImpl","permissions","repository","input","Result","BackgroundTaskNotAuthorizedError","parsed","UpdateBackgroundTaskSettingsInputSchema","BackgroundTaskValidationError","UpdateBackgroundTaskSettingsUseCase","UseCaseAbstraction","BackgroundTaskPermissions","UpdateBackgroundTaskSettingsRepository"],"mappings":";;;;;AAaA,MAAMA;IACF,YACqBC,WAAgD,EAChDC,UAA4D,CAC/E;aAFmBD,WAAW,GAAXA;aACAC,UAAU,GAAVA;IAClB;IAEH,MAAM,QACFC,KAA+B,EACmC;QAClE,IAAI,CAAE,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,SACjC,OAAOC,OAAO,IAAI,CAAC,IAAIC;QAG3B,MAAMC,SAASC,wCAAwC,SAAS,CAACJ;QACjE,IAAI,CAACG,OAAO,OAAO,EACf,OAAOF,OAAO,IAAI,CAAC,IAAII,8BAA8BF,OAAO,KAAK;QAGrE,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA,OAAO,IAAI;IAC9C;AACJ;AAEO,MAAMG,0EAAsCC,oCAAAA,oBAAuC,CAAC;IACvF,gBAAgBV;IAChB,cAAc;QAACW;QAA2BC;KAAuC;AACrF"}

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

@@ -0,0 +1,26 @@
+import { type Result } from "@webiny/feature/api";
+import type { IBackgroundTaskSettings } from "../../../api/domain/BackgroundTaskSettings.js";
+import type { BackgroundTaskModelNotFoundError, BackgroundTaskNotAuthorizedError, BackgroundTaskPersistenceError, BackgroundTaskValidationError } from "../../../api/domain/errors.js";
+export interface IUpdateBackgroundTaskSettingsInput {
+    retentionDays?: number;
+}
+type IError = BackgroundTaskModelNotFoundError | BackgroundTaskPersistenceError | BackgroundTaskNotAuthorizedError | BackgroundTaskValidationError;
+export interface IUpdateBackgroundTaskSettingsUseCase {
+    execute(input: IUpdateBackgroundTaskSettingsInput): Promise<Result<IBackgroundTaskSettings, IError>>;
+}
+export declare const UpdateBackgroundTaskSettingsUseCase: import("@webiny/di").Abstraction<IUpdateBackgroundTaskSettingsUseCase>;
+export declare namespace UpdateBackgroundTaskSettingsUseCase {
+    type Interface = IUpdateBackgroundTaskSettingsUseCase;
+    type Input = IUpdateBackgroundTaskSettingsInput;
+    type Error = IError;
+}
+type IRepositoryError = BackgroundTaskModelNotFoundError | BackgroundTaskPersistenceError;
+export interface IUpdateBackgroundTaskSettingsRepository {
+    execute(input: IUpdateBackgroundTaskSettingsInput): Promise<Result<IBackgroundTaskSettings, IRepositoryError>>;
+}
+export declare const UpdateBackgroundTaskSettingsRepository: import("@webiny/di").Abstraction<IUpdateBackgroundTaskSettingsRepository>;
+export declare namespace UpdateBackgroundTaskSettingsRepository {
+    type Interface = IUpdateBackgroundTaskSettingsRepository;
+    type Error = IRepositoryError;
+}
+export {};

package/api/features/UpdateBackgroundTaskSettings/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/UpdateBackgroundTaskSettings/abstractions.js","sources":["../../../../src/api/features/UpdateBackgroundTaskSettings/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { IBackgroundTaskSettings } from \"~/api/domain/BackgroundTaskSettings.js\";\nimport type {\n    BackgroundTaskModelNotFoundError,\n    BackgroundTaskNotAuthorizedError,\n    BackgroundTaskPersistenceError,\n    BackgroundTaskValidationError\n} from \"~/api/domain/errors.js\";\n\nexport interface IUpdateBackgroundTaskSettingsInput {\n    retentionDays?: number;\n}\n\ntype IError =\n    | BackgroundTaskModelNotFoundError\n    | BackgroundTaskPersistenceError\n    | BackgroundTaskNotAuthorizedError\n    | BackgroundTaskValidationError;\n\nexport interface IUpdateBackgroundTaskSettingsUseCase {\n    execute(\n        input: IUpdateBackgroundTaskSettingsInput\n    ): Promise<Result<IBackgroundTaskSettings, IError>>;\n}\n\nexport const UpdateBackgroundTaskSettingsUseCase =\n    createAbstraction<IUpdateBackgroundTaskSettingsUseCase>(\n        \"BackgroundTasks/UpdateBackgroundTaskSettingsUseCase\"\n    );\n\nexport namespace UpdateBackgroundTaskSettingsUseCase {\n    export type Interface = IUpdateBackgroundTaskSettingsUseCase;\n    export type Input = IUpdateBackgroundTaskSettingsInput;\n    export type Error = IError;\n}\n\ntype IRepositoryError = BackgroundTaskModelNotFoundError | BackgroundTaskPersistenceError;\n\nexport interface IUpdateBackgroundTaskSettingsRepository {\n    execute(\n        input: IUpdateBackgroundTaskSettingsInput\n    ): Promise<Result<IBackgroundTaskSettings, IRepositoryError>>;\n}\n\nexport const UpdateBackgroundTaskSettingsRepository =\n    createAbstraction<IUpdateBackgroundTaskSettingsRepository>(\n        \"BackgroundTasks/UpdateBackgroundTaskSettingsRepository\"\n    );\n\nexport namespace UpdateBackgroundTaskSettingsRepository {\n    export type Interface = IUpdateBackgroundTaskSettingsRepository;\n    export type Error = IRepositoryError;\n}\n"],"names":["UpdateBackgroundTaskSettingsUseCase","createAbstraction","UpdateBackgroundTaskSettingsRepository"],"mappings":";AAyBO,MAAMA,sCACTC,kBACI;AAiBD,MAAMC,yCACTD,kBACI"}

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

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

package/api/features/UpdateBackgroundTaskSettings/feature.js

@@ -0,0 +1,13 @@
+import { createFeature } from "@webiny/feature/api";
+import { UpdateBackgroundTaskSettingsUseCase } from "./UpdateBackgroundTaskSettingsUseCase.js";
+import { UpdateBackgroundTaskSettingsRepository } from "./UpdateBackgroundTaskSettingsRepository.js";
+const UpdateBackgroundTaskSettingsFeature = createFeature({
+    name: "UpdateBackgroundTaskSettings",
+    register (container) {
+        container.register(UpdateBackgroundTaskSettingsUseCase);
+        container.register(UpdateBackgroundTaskSettingsRepository).inSingletonScope();
+    }
+});
+export { UpdateBackgroundTaskSettingsFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/UpdateBackgroundTaskSettings/feature.js","sources":["../../../../src/api/features/UpdateBackgroundTaskSettings/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { UpdateBackgroundTaskSettingsUseCase } from \"./UpdateBackgroundTaskSettingsUseCase.js\";\nimport { UpdateBackgroundTaskSettingsRepository } from \"./UpdateBackgroundTaskSettingsRepository.js\";\n\nexport const UpdateBackgroundTaskSettingsFeature = createFeature({\n    name: \"UpdateBackgroundTaskSettings\",\n    register(container) {\n        container.register(UpdateBackgroundTaskSettingsUseCase);\n        container.register(UpdateBackgroundTaskSettingsRepository).inSingletonScope();\n    }\n});\n"],"names":["UpdateBackgroundTaskSettingsFeature","createFeature","container","UpdateBackgroundTaskSettingsUseCase","UpdateBackgroundTaskSettingsRepository"],"mappings":";;;AAIO,MAAMA,sCAAsCC,cAAc;IAC7D,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,wCAAwC,gBAAgB;IAC/E;AACJ"}

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

@@ -0,0 +1,2 @@
+export { UpdateBackgroundTaskSettingsUseCase, UpdateBackgroundTaskSettingsRepository } from "./abstractions.js";
+export { UpdateBackgroundTaskSettingsFeature } from "./feature.js";

package/api/features/UpdateBackgroundTaskSettings/index.js

@@ -0,0 +1,2 @@
+export { UpdateBackgroundTaskSettingsRepository, UpdateBackgroundTaskSettingsUseCase } from "./abstractions.js";
+export { UpdateBackgroundTaskSettingsFeature } from "./feature.js";

package/api/features/UpdateBackgroundTaskSettings/schema.d.ts

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export declare const UpdateBackgroundTaskSettingsInputSchema: z.ZodObject<{
+    retentionDays: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;

package/api/features/UpdateBackgroundTaskSettings/schema.js

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import { BACKGROUND_TASK_MAX_RETENTION_DAYS } from "../../domain/constants.js";
+const UpdateBackgroundTaskSettingsInputSchema = z.object({
+    retentionDays: z.number().int().min(0).max(BACKGROUND_TASK_MAX_RETENTION_DAYS).optional()
+});
+export { UpdateBackgroundTaskSettingsInputSchema };
+
+//# sourceMappingURL=schema.js.map

package/api/features/UpdateBackgroundTaskSettings/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/UpdateBackgroundTaskSettings/schema.js","sources":["../../../../src/api/features/UpdateBackgroundTaskSettings/schema.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { BACKGROUND_TASK_MAX_RETENTION_DAYS } from \"~/api/domain/constants.js\";\n\nexport const UpdateBackgroundTaskSettingsInputSchema = z.object({\n    retentionDays: z.number().int().min(0).max(BACKGROUND_TASK_MAX_RETENTION_DAYS).optional()\n});\n"],"names":["UpdateBackgroundTaskSettingsInputSchema","z","BACKGROUND_TASK_MAX_RETENTION_DAYS"],"mappings":";;AAGO,MAAMA,0CAA0CC,EAAE,MAAM,CAAC;IAC5D,eAAeA,EAAE,MAAM,GAAG,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,CAACC,oCAAoC,QAAQ;AAC3F"}

package/api/features/UpdateTask/UpdateTaskUseCase.d.ts

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

package/api/features/UpdateTask/UpdateTaskUseCase.js

@@ -0,0 +1,36 @@
+import { Result } from "@webiny/feature/api";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { UpdateTaskUseCase } from "./abstractions.js";
+import { TasksRepository } from "../../domain/task/abstractions.js";
+import { TaskAfterUpdateEvent, TaskBeforeUpdateEvent } from "../../events/index.js";
+class UpdateTaskUseCaseImpl {
+    constructor(eventPublisher, repository){
+        this.eventPublisher = eventPublisher;
+        this.repository = repository;
+    }
+    async execute(id, data) {
+        const original = await this.repository.get(id);
+        if (original.isFail()) return Result.fail(original.error);
+        await this.eventPublisher.publish(new TaskBeforeUpdateEvent({
+            input: data,
+            original: original.value
+        }));
+        const result = await this.repository.update(id, data);
+        if (result.isFail()) return Result.fail(result.error);
+        await this.eventPublisher.publish(new TaskAfterUpdateEvent({
+            input: data,
+            task: result.value
+        }));
+        return Result.ok(result.value);
+    }
+}
+const UpdateTaskUseCase_UpdateTaskUseCase = UpdateTaskUseCase.createImplementation({
+    implementation: UpdateTaskUseCaseImpl,
+    dependencies: [
+        EventPublisher,
+        TasksRepository
+    ]
+});
+export { UpdateTaskUseCase_UpdateTaskUseCase as UpdateTaskUseCase };
+
+//# sourceMappingURL=UpdateTaskUseCase.js.map

package/api/features/UpdateTask/UpdateTaskUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/UpdateTask/UpdateTaskUseCase.js","sources":["../../../../src/api/features/UpdateTask/UpdateTaskUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport { UpdateTaskUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { TasksRepository } from \"~/api/domain/task/abstractions.js\";\nimport { TaskAfterUpdateEvent, TaskBeforeUpdateEvent } from \"~/api/events/index.js\";\n\ntype TaskInput = TaskService.TaskInput;\ntype TaskOutput = TaskService.GenericOutput;\n\nclass UpdateTaskUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private readonly eventPublisher: EventPublisher.Interface,\n        private readonly repository: TasksRepository.Interface\n    ) {}\n\n    async execute<I extends TaskInput = TaskInput, O extends TaskOutput = TaskOutput>(\n        id: string,\n        data: UseCaseAbstraction.Params<I, O>\n    ): Promise<Result<TaskService.Task<I, O>, UseCaseAbstraction.Error>> {\n        const original = await this.repository.get<I, O>(id);\n        if (original.isFail()) {\n            return Result.fail(original.error);\n        }\n\n        await this.eventPublisher.publish(\n            new TaskBeforeUpdateEvent({ input: data, original: original.value })\n        );\n\n        const result = await this.repository.update<I, O>(id, data);\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        await this.eventPublisher.publish(\n            new TaskAfterUpdateEvent({ input: data, task: result.value })\n        );\n\n        return Result.ok(result.value);\n    }\n}\n\nexport const UpdateTaskUseCase = UseCaseAbstraction.createImplementation({\n    implementation: UpdateTaskUseCaseImpl,\n    dependencies: [EventPublisher, TasksRepository]\n});\n"],"names":["UpdateTaskUseCaseImpl","eventPublisher","repository","id","data","original","Result","TaskBeforeUpdateEvent","result","TaskAfterUpdateEvent","UpdateTaskUseCase","UseCaseAbstraction","EventPublisher","TasksRepository"],"mappings":";;;;;AAUA,MAAMA;IACF,YACqBC,cAAwC,EACxCC,UAAqC,CACxD;aAFmBD,cAAc,GAAdA;aACAC,UAAU,GAAVA;IAClB;IAEH,MAAM,QACFC,EAAU,EACVC,IAAqC,EAC4B;QACjE,MAAMC,WAAW,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAAOF;QACjD,IAAIE,SAAS,MAAM,IACf,OAAOC,OAAO,IAAI,CAACD,SAAS,KAAK;QAGrC,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIE,sBAAsB;YAAE,OAAOH;YAAM,UAAUC,SAAS,KAAK;QAAC;QAGtE,MAAMG,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAAOL,IAAIC;QACtD,IAAII,OAAO,MAAM,IACb,OAAOF,OAAO,IAAI,CAACE,OAAO,KAAK;QAGnC,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIC,qBAAqB;YAAE,OAAOL;YAAM,MAAMI,OAAO,KAAK;QAAC;QAG/D,OAAOF,OAAO,EAAE,CAACE,OAAO,KAAK;IACjC;AACJ;AAEO,MAAME,sCAAoBC,kBAAAA,oBAAuC,CAAC;IACrE,gBAAgBX;IAChB,cAAc;QAACY;QAAgBC;KAAgB;AACnD"}

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

@@ -0,0 +1,22 @@
+import { type Result } from "@webiny/feature/api";
+import type { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import type { ITaskUpdateData } from "../../../api/types.js";
+import type { BackgroundTaskPersistenceError, TaskNotFoundError } from "../../../api/domain/errors.js";
+type TaskInput = TaskService.TaskInput;
+type TaskOutput = TaskService.GenericOutput;
+export interface IUpdateTaskUseCase {
+    execute<I extends TaskInput = TaskInput, O extends TaskOutput = TaskOutput>(id: string, data: Partial<ITaskUpdateData<I, O>>): Promise<Result<TaskService.Task<I, O>, UseCaseError>>;
+}
+export interface IUpdateTaskUseCaseErrors {
+    notFound: TaskNotFoundError;
+    persistence: BackgroundTaskPersistenceError;
+}
+type UseCaseError = IUpdateTaskUseCaseErrors[keyof IUpdateTaskUseCaseErrors];
+/** Update a stored task: its status, output, iterations and so on. */
+export declare const UpdateTaskUseCase: import("@webiny/di").Abstraction<IUpdateTaskUseCase>;
+export declare namespace UpdateTaskUseCase {
+    type Interface = IUpdateTaskUseCase;
+    type Params<I extends TaskInput = TaskInput, O extends TaskOutput = TaskOutput> = Partial<ITaskUpdateData<I, O>>;
+    type Error = UseCaseError;
+}
+export {};

package/api/features/UpdateTask/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/UpdateTask/abstractions.js","sources":["../../../../src/api/features/UpdateTask/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport type { ITaskUpdateData } from \"~/api/types.js\";\nimport type { BackgroundTaskPersistenceError, TaskNotFoundError } from \"~/api/domain/errors.js\";\n\ntype TaskInput = TaskService.TaskInput;\ntype TaskOutput = TaskService.GenericOutput;\n\nexport interface IUpdateTaskUseCase {\n    execute<I extends TaskInput = TaskInput, O extends TaskOutput = TaskOutput>(\n        id: string,\n        data: Partial<ITaskUpdateData<I, O>>\n    ): Promise<Result<TaskService.Task<I, O>, UseCaseError>>;\n}\n\nexport interface IUpdateTaskUseCaseErrors {\n    notFound: TaskNotFoundError;\n    persistence: BackgroundTaskPersistenceError;\n}\n\ntype UseCaseError = IUpdateTaskUseCaseErrors[keyof IUpdateTaskUseCaseErrors];\n\n/** Update a stored task: its status, output, iterations and so on. */\nexport const UpdateTaskUseCase = createAbstraction<IUpdateTaskUseCase>(\"Tasks/UpdateTaskUseCase\");\n\nexport namespace UpdateTaskUseCase {\n    export type Interface = IUpdateTaskUseCase;\n    export type Params<\n        I extends TaskInput = TaskInput,\n        O extends TaskOutput = TaskOutput\n    > = Partial<ITaskUpdateData<I, O>>;\n    export type Error = UseCaseError;\n}\n"],"names":["UpdateTaskUseCase","createAbstraction"],"mappings":";AAuBO,MAAMA,oBAAoBC,kBAAsC"}

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

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

package/api/features/UpdateTask/feature.js

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

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

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

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

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

package/api/features/UpdateTask/index.js

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

package/api/features/UpdateTaskLog/UpdateTaskLogUseCase.d.ts

@@ -0,0 +1,12 @@
+import { UpdateTaskLogUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { TaskLogsRepository } from "../../../api/domain/task/abstractions.js";
+import type { ITaskLogUpdateInput } from "../../../api/types.js";
+declare class UpdateTaskLogUseCaseImpl implements UseCaseAbstraction.Interface {
+    private readonly repository;
+    constructor(repository: TaskLogsRepository.Interface);
+    execute(id: string, data: ITaskLogUpdateInput): Promise<import("@webiny/feature/api/Result.js").Result<import("~/api/types.js").ITaskLog, import("../../domain/errors.js").BackgroundTaskPersistenceError | import("../../domain/errors.js").TaskLogNotFoundError>>;
+}
+export declare const UpdateTaskLogUseCase: typeof UpdateTaskLogUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateTaskLogUseCase>;
+};
+export {};

package/api/features/UpdateTaskLog/UpdateTaskLogUseCase.js

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

package/api/features/UpdateTaskLog/UpdateTaskLogUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/UpdateTaskLog/UpdateTaskLogUseCase.js","sources":["../../../../src/api/features/UpdateTaskLog/UpdateTaskLogUseCase.ts"],"sourcesContent":["import { UpdateTaskLogUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { TaskLogsRepository } from \"~/api/domain/task/abstractions.js\";\nimport type { ITaskLogUpdateInput } from \"~/api/types.js\";\n\nclass UpdateTaskLogUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private readonly repository: TaskLogsRepository.Interface) {}\n\n    execute(id: string, data: ITaskLogUpdateInput) {\n        return this.repository.update(id, data);\n    }\n}\n\nexport const UpdateTaskLogUseCase = UseCaseAbstraction.createImplementation({\n    implementation: UpdateTaskLogUseCaseImpl,\n    dependencies: [TaskLogsRepository]\n});\n"],"names":["UpdateTaskLogUseCaseImpl","repository","id","data","UpdateTaskLogUseCase","UseCaseAbstraction","TaskLogsRepository"],"mappings":";;AAIA,MAAMA;IACF,YAA6BC,UAAwC,CAAE;aAA1CA,UAAU,GAAVA;IAA2C;IAExE,QAAQC,EAAU,EAAEC,IAAyB,EAAE;QAC3C,OAAO,IAAI,CAAC,UAAU,CAAC,MAAM,CAACD,IAAIC;IACtC;AACJ;AAEO,MAAMC,4CAAuBC,qBAAAA,oBAAuC,CAAC;IACxE,gBAAgBL;IAChB,cAAc;QAACM;KAAmB;AACtC"}

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

@@ -0,0 +1,16 @@
+import type { Result } from "@webiny/feature/api";
+import type { ITaskLog } from "../../../api/types.js";
+import type { ITaskLogUpdateInput } from "../../../api/types.js";
+import type { BackgroundTaskPersistenceError } from "../../../api/domain/errors.js";
+import type { TaskLogNotFoundError } from "../../../api/domain/errors.js";
+type UseCaseError = TaskLogNotFoundError | BackgroundTaskPersistenceError;
+export interface IUpdateTaskLogUseCase {
+    execute(id: string, data: ITaskLogUpdateInput): Promise<Result<ITaskLog, UseCaseError>>;
+}
+/** Update a task log, usually to append items. */
+export declare const UpdateTaskLogUseCase: import("@webiny/di").Abstraction<IUpdateTaskLogUseCase>;
+export declare namespace UpdateTaskLogUseCase {
+    type Interface = IUpdateTaskLogUseCase;
+    type Error = UseCaseError;
+}
+export {};

package/api/features/UpdateTaskLog/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/UpdateTaskLog/abstractions.js","sources":["../../../../src/api/features/UpdateTaskLog/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { ITaskLog } from \"~/api/types.js\";\nimport type { ITaskLogUpdateInput } from \"~/api/types.js\";\nimport type { BackgroundTaskPersistenceError } from \"~/api/domain/errors.js\";\nimport type { TaskLogNotFoundError } from \"~/api/domain/errors.js\";\n\ntype UseCaseError = TaskLogNotFoundError | BackgroundTaskPersistenceError;\n\nexport interface IUpdateTaskLogUseCase {\n    execute(id: string, data: ITaskLogUpdateInput): Promise<Result<ITaskLog, UseCaseError>>;\n}\n\n/** Update a task log, usually to append items. */\nexport const UpdateTaskLogUseCase = createAbstraction<IUpdateTaskLogUseCase>(\n    \"Tasks/UpdateTaskLogUseCase\"\n);\n\nexport namespace UpdateTaskLogUseCase {\n    export type Interface = IUpdateTaskLogUseCase;\n    export type Error = UseCaseError;\n}\n"],"names":["UpdateTaskLogUseCase","createAbstraction"],"mappings":";AAcO,MAAMA,uBAAuBC,kBAChC"}

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

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

package/api/features/UpdateTaskLog/feature.js

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

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

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

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

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

package/api/features/UpdateTaskLog/index.js

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

package/api/global.d.ts

@@ -0,0 +1 @@
+import "./features/TaskController/augmentation.js";

package/api/global.js

@@ -0,0 +1 @@
+import "./features/TaskController/augmentation.js";

package/api/graphql/BackgroundTasksGraphQLSchema.d.ts

@@ -0,0 +1,29 @@
+import { GraphQLSchemaFactory } from "@webiny/api-graphql/graphql/abstractions.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/abstractions.js";
+import { ListModelsUseCase } from "@webiny/api-headless-cms/features/contentModel/ListModels/index.js";
+import { CmsModelFieldToGraphQLRegistry } from "@webiny/api-headless-cms/exports/api/cms/graphql.js";
+import { TaskLogModelProvider } from "../../api/domain/task/abstractions.js";
+import { TaskModelProvider } from "../../api/domain/task/abstractions.js";
+/**
+ * The background-tasks GraphQL schema. Its shape depends on the CMS task/log content models, which
+ * are loaded when the schema is composed. The settings schema lives here too, because it extends
+ * the task schema's `WebinyBackgroundTaskQuery`/`Mutation` types.
+ */
+declare class BackgroundTasksGraphQLSchemaImpl implements GraphQLSchemaFactory.Interface {
+    private readonly tenantContext;
+    private readonly identityContext;
+    private readonly taskModelProvider;
+    private readonly logModelProvider;
+    private readonly listModelsUseCase;
+    private readonly fieldRegistry;
+    constructor(tenantContext: TenantContext.Interface, identityContext: IdentityContext.Interface, taskModelProvider: TaskModelProvider.Interface, logModelProvider: TaskLogModelProvider.Interface, listModelsUseCase: ListModelsUseCase.Interface, fieldRegistry: CmsModelFieldToGraphQLRegistry.Interface);
+    getSchemaKey(): Promise<string>;
+    execute(builder: GraphQLSchemaFactory.SchemaBuilder): Promise<GraphQLSchemaFactory.SchemaBuilder>;
+    private loadInputs;
+    private createTypeDefs;
+}
+export declare const BackgroundTasksGraphQLSchema: typeof BackgroundTasksGraphQLSchemaImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-graphql/graphql/abstractions.public.js").IGraphQLSchemaFactory>;
+};
+export {};