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

package/api/features/CleanupTaskSubtree/index.js

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

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

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

package/api/features/CreateTask/CreateTaskUseCase.js

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

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

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

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

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

package/api/features/CreateTask/abstractions.js

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

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

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

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

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

package/api/features/CreateTask/feature.js

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

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

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

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

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

package/api/features/CreateTask/index.js

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

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

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

package/api/features/CreateTaskLog/CreateTaskLogUseCase.js

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

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

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

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

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

package/api/features/CreateTaskLog/abstractions.js

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

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

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

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

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

package/api/features/CreateTaskLog/feature.js

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

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

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

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

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

package/api/features/CreateTaskLog/index.js

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

package/api/features/DeleteTask/DeleteTaskUseCase.d.ts

@@ -0,0 +1,14 @@
+import { Result } from "@webiny/feature/api";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { DeleteTaskUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { TasksRepository } from "../../../api/domain/task/abstractions.js";
+declare class DeleteTaskUseCaseImpl implements UseCaseAbstraction.Interface {
+    private readonly eventPublisher;
+    private readonly repository;
+    constructor(eventPublisher: EventPublisher.Interface, repository: TasksRepository.Interface);
+    execute(id: string): Promise<Result<void, UseCaseAbstraction.Error>>;
+}
+export declare const DeleteTaskUseCase: typeof DeleteTaskUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDeleteTaskUseCase>;
+};
+export {};

package/api/features/DeleteTask/DeleteTaskUseCase.js

@@ -0,0 +1,34 @@
+import { Result } from "@webiny/feature/api";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { DeleteTaskUseCase } from "./abstractions.js";
+import { TasksRepository } from "../../domain/task/abstractions.js";
+import { TaskAfterDeleteEvent, TaskBeforeDeleteEvent } from "../../events/index.js";
+class DeleteTaskUseCaseImpl {
+    constructor(eventPublisher, repository){
+        this.eventPublisher = eventPublisher;
+        this.repository = repository;
+    }
+    async execute(id) {
+        const task = await this.repository.get(id);
+        if (task.isFail()) return Result.fail(task.error);
+        await this.eventPublisher.publish(new TaskBeforeDeleteEvent({
+            task: task.value
+        }));
+        const result = await this.repository.delete(id);
+        if (result.isFail()) return Result.fail(result.error);
+        await this.eventPublisher.publish(new TaskAfterDeleteEvent({
+            task: task.value
+        }));
+        return Result.ok();
+    }
+}
+const DeleteTaskUseCase_DeleteTaskUseCase = DeleteTaskUseCase.createImplementation({
+    implementation: DeleteTaskUseCaseImpl,
+    dependencies: [
+        EventPublisher,
+        TasksRepository
+    ]
+});
+export { DeleteTaskUseCase_DeleteTaskUseCase as DeleteTaskUseCase };
+
+//# sourceMappingURL=DeleteTaskUseCase.js.map

package/api/features/DeleteTask/DeleteTaskUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/DeleteTask/DeleteTaskUseCase.js","sources":["../../../../src/api/features/DeleteTask/DeleteTaskUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { DeleteTaskUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { TasksRepository } from \"~/api/domain/task/abstractions.js\";\nimport { TaskAfterDeleteEvent, TaskBeforeDeleteEvent } from \"~/api/events/index.js\";\n\nclass DeleteTaskUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private readonly eventPublisher: EventPublisher.Interface,\n        private readonly repository: TasksRepository.Interface\n    ) {}\n\n    async execute(id: string): Promise<Result<void, UseCaseAbstraction.Error>> {\n        const task = await this.repository.get(id);\n        if (task.isFail()) {\n            return Result.fail(task.error);\n        }\n\n        await this.eventPublisher.publish(new TaskBeforeDeleteEvent({ task: task.value }));\n\n        const result = await this.repository.delete(id);\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        await this.eventPublisher.publish(new TaskAfterDeleteEvent({ task: task.value }));\n\n        return Result.ok();\n    }\n}\n\nexport const DeleteTaskUseCase = UseCaseAbstraction.createImplementation({\n    implementation: DeleteTaskUseCaseImpl,\n    dependencies: [EventPublisher, TasksRepository]\n});\n"],"names":["DeleteTaskUseCaseImpl","eventPublisher","repository","id","task","Result","TaskBeforeDeleteEvent","result","TaskAfterDeleteEvent","DeleteTaskUseCase","UseCaseAbstraction","EventPublisher","TasksRepository"],"mappings":";;;;;AAMA,MAAMA;IACF,YACqBC,cAAwC,EACxCC,UAAqC,CACxD;aAFmBD,cAAc,GAAdA;aACAC,UAAU,GAAVA;IAClB;IAEH,MAAM,QAAQC,EAAU,EAAmD;QACvE,MAAMC,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAACD;QACvC,IAAIC,KAAK,MAAM,IACX,OAAOC,OAAO,IAAI,CAACD,KAAK,KAAK;QAGjC,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,IAAIE,sBAAsB;YAAE,MAAMF,KAAK,KAAK;QAAC;QAE/E,MAAMG,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAACJ;QAC5C,IAAII,OAAO,MAAM,IACb,OAAOF,OAAO,IAAI,CAACE,OAAO,KAAK;QAGnC,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,IAAIC,qBAAqB;YAAE,MAAMJ,KAAK,KAAK;QAAC;QAE9E,OAAOC,OAAO,EAAE;IACpB;AACJ;AAEO,MAAMI,sCAAoBC,kBAAAA,oBAAuC,CAAC;IACrE,gBAAgBV;IAChB,cAAc;QAACW;QAAgBC;KAAgB;AACnD"}

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

@@ -0,0 +1,17 @@
+import { type Result } from "@webiny/feature/api";
+import type { BackgroundTaskPersistenceError, TaskNotFoundError } from "../../../api/domain/errors.js";
+export interface IDeleteTaskUseCase {
+    execute(id: string): Promise<Result<void, UseCaseError>>;
+}
+export interface IDeleteTaskUseCaseErrors {
+    notFound: TaskNotFoundError;
+    persistence: BackgroundTaskPersistenceError;
+}
+type UseCaseError = IDeleteTaskUseCaseErrors[keyof IDeleteTaskUseCaseErrors];
+/** Delete a single stored task. Its logs and child tasks stay; see CleanupTaskSubtreeUseCase. */
+export declare const DeleteTaskUseCase: import("@webiny/di").Abstraction<IDeleteTaskUseCase>;
+export declare namespace DeleteTaskUseCase {
+    type Interface = IDeleteTaskUseCase;
+    type Error = UseCaseError;
+}
+export {};

package/api/features/DeleteTask/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/DeleteTask/abstractions.js","sources":["../../../../src/api/features/DeleteTask/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { BackgroundTaskPersistenceError, TaskNotFoundError } from \"~/api/domain/errors.js\";\n\nexport interface IDeleteTaskUseCase {\n    execute(id: string): Promise<Result<void, UseCaseError>>;\n}\n\nexport interface IDeleteTaskUseCaseErrors {\n    notFound: TaskNotFoundError;\n    persistence: BackgroundTaskPersistenceError;\n}\n\ntype UseCaseError = IDeleteTaskUseCaseErrors[keyof IDeleteTaskUseCaseErrors];\n\n/** Delete a single stored task. Its logs and child tasks stay; see CleanupTaskSubtreeUseCase. */\nexport const DeleteTaskUseCase = createAbstraction<IDeleteTaskUseCase>(\"Tasks/DeleteTaskUseCase\");\n\nexport namespace DeleteTaskUseCase {\n    export type Interface = IDeleteTaskUseCase;\n    export type Error = UseCaseError;\n}\n"],"names":["DeleteTaskUseCase","createAbstraction"],"mappings":";AAeO,MAAMA,oBAAoBC,kBAAsC"}

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

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

package/api/features/DeleteTask/feature.js

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

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

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

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

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

package/api/features/DeleteTask/index.js

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

package/api/features/DeleteTaskLog/DeleteTaskLogUseCase.d.ts

@@ -0,0 +1,11 @@
+import { DeleteTaskLogUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { TaskLogsRepository } from "../../../api/domain/task/abstractions.js";
+declare class DeleteTaskLogUseCaseImpl implements UseCaseAbstraction.Interface {
+    private readonly repository;
+    constructor(repository: TaskLogsRepository.Interface);
+    execute(id: string): Promise<import("@webiny/feature/api/Result.js").Result<void, import("../../domain/errors.js").BackgroundTaskPersistenceError | import("../../domain/errors.js").TaskLogNotFoundError>>;
+}
+export declare const DeleteTaskLogUseCase: typeof DeleteTaskLogUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDeleteTaskLogUseCase>;
+};
+export {};

package/api/features/DeleteTaskLog/DeleteTaskLogUseCase.js

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

package/api/features/DeleteTaskLog/DeleteTaskLogUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/DeleteTaskLog/DeleteTaskLogUseCase.js","sources":["../../../../src/api/features/DeleteTaskLog/DeleteTaskLogUseCase.ts"],"sourcesContent":["import { DeleteTaskLogUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { TaskLogsRepository } from \"~/api/domain/task/abstractions.js\";\n\nclass DeleteTaskLogUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private readonly repository: TaskLogsRepository.Interface) {}\n\n    execute(id: string) {\n        return this.repository.delete(id);\n    }\n}\n\nexport const DeleteTaskLogUseCase = UseCaseAbstraction.createImplementation({\n    implementation: DeleteTaskLogUseCaseImpl,\n    dependencies: [TaskLogsRepository]\n});\n"],"names":["DeleteTaskLogUseCaseImpl","repository","id","DeleteTaskLogUseCase","UseCaseAbstraction","TaskLogsRepository"],"mappings":";;AAGA,MAAMA;IACF,YAA6BC,UAAwC,CAAE;aAA1CA,UAAU,GAAVA;IAA2C;IAExE,QAAQC,EAAU,EAAE;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC,MAAM,CAACA;IAClC;AACJ;AAEO,MAAMC,4CAAuBC,qBAAAA,oBAAuC,CAAC;IACxE,gBAAgBJ;IAChB,cAAc;QAACK;KAAmB;AACtC"}

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

@@ -0,0 +1,14 @@
+import type { Result } from "@webiny/feature/api";
+import type { BackgroundTaskPersistenceError } from "../../../api/domain/errors.js";
+import type { TaskLogNotFoundError } from "../../../api/domain/errors.js";
+type UseCaseError = TaskLogNotFoundError | BackgroundTaskPersistenceError;
+export interface IDeleteTaskLogUseCase {
+    execute(id: string): Promise<Result<void, UseCaseError>>;
+}
+/** Delete a task log. */
+export declare const DeleteTaskLogUseCase: import("@webiny/di").Abstraction<IDeleteTaskLogUseCase>;
+export declare namespace DeleteTaskLogUseCase {
+    type Interface = IDeleteTaskLogUseCase;
+    type Error = UseCaseError;
+}
+export {};

package/api/features/DeleteTaskLog/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/DeleteTaskLog/abstractions.js","sources":["../../../../src/api/features/DeleteTaskLog/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\n\nimport type { BackgroundTaskPersistenceError } from \"~/api/domain/errors.js\";\nimport type { TaskLogNotFoundError } from \"~/api/domain/errors.js\";\n\ntype UseCaseError = TaskLogNotFoundError | BackgroundTaskPersistenceError;\n\nexport interface IDeleteTaskLogUseCase {\n    execute(id: string): Promise<Result<void, UseCaseError>>;\n}\n\n/** Delete a task log. */\nexport const DeleteTaskLogUseCase = createAbstraction<IDeleteTaskLogUseCase>(\n    \"Tasks/DeleteTaskLogUseCase\"\n);\n\nexport namespace DeleteTaskLogUseCase {\n    export type Interface = IDeleteTaskLogUseCase;\n    export type Error = UseCaseError;\n}\n"],"names":["DeleteTaskLogUseCase","createAbstraction"],"mappings":";AAaO,MAAMA,uBAAuBC,kBAChC"}

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

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

package/api/features/DeleteTaskLog/feature.js

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

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

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

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

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

package/api/features/DeleteTaskLog/index.js

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

package/api/features/GetBackgroundTaskSettings/GetBackgroundTaskSettingsRepository.d.ts

@@ -0,0 +1,21 @@
+import { Result } from "@webiny/feature/api";
+import { GetModelRepository } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { GetLatestRevisionByEntryIdRepository } from "@webiny/api-headless-cms/features/contentEntry/GetLatestRevisionByEntryId/index.js";
+import { CreateEntryRepository } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js";
+import { CreateEntryDataFactory } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+import { BuildParams } from "@webiny/api-core/features/buildParams/index.js";
+import { GetBackgroundTaskSettingsRepository as RepositoryAbstraction } from "./abstractions.js";
+import type { IBackgroundTaskSettings } from "../../../api/domain/BackgroundTaskSettings.js";
+declare class GetBackgroundTaskSettingsRepositoryImpl implements RepositoryAbstraction.Interface {
+    private readonly getModelRepository;
+    private readonly getLatestRevisionRepository;
+    private readonly createEntryRepository;
+    private readonly createEntryDataFactory;
+    private readonly defaultRetentionDays;
+    constructor(getModelRepository: GetModelRepository.Interface, getLatestRevisionRepository: GetLatestRevisionByEntryIdRepository.Interface, createEntryRepository: CreateEntryRepository.Interface, createEntryDataFactory: CreateEntryDataFactory.Interface, buildParams: BuildParams.Interface);
+    execute(): Promise<Result<IBackgroundTaskSettings, RepositoryAbstraction.Error>>;
+}
+export declare const GetBackgroundTaskSettingsRepository: typeof GetBackgroundTaskSettingsRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetBackgroundTaskSettingsRepository>;
+};
+export {};

package/api/features/GetBackgroundTaskSettings/GetBackgroundTaskSettingsRepository.js

@@ -0,0 +1,63 @@
+import { Result } from "@webiny/feature/api";
+import { createCacheKey } from "@webiny/utils";
+import { GetModelRepository } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { GetLatestRevisionByEntryIdRepository } from "@webiny/api-headless-cms/features/contentEntry/GetLatestRevisionByEntryId/index.js";
+import { CreateEntryRepository } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js";
+import { CreateEntryDataFactory } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+import { BuildParams } from "@webiny/api-core/features/buildParams/index.js";
+import { GetBackgroundTaskSettingsRepository } from "./abstractions.js";
+import { BackgroundTaskModelNotFoundError, BackgroundTaskPersistenceError } from "../../domain/errors.js";
+import { BACKGROUND_TASK_DEFAULT_RETENTION_DAYS, BACKGROUND_TASK_SETTINGS_MODEL_ID } from "../../domain/constants.js";
+class GetBackgroundTaskSettingsRepositoryImpl {
+    constructor(getModelRepository, getLatestRevisionRepository, createEntryRepository, createEntryDataFactory, buildParams){
+        this.getModelRepository = getModelRepository;
+        this.getLatestRevisionRepository = getLatestRevisionRepository;
+        this.createEntryRepository = createEntryRepository;
+        this.createEntryDataFactory = createEntryDataFactory;
+        this.defaultRetentionDays = buildParams.get("BackgroundTasks.RetentionDays") || BACKGROUND_TASK_DEFAULT_RETENTION_DAYS;
+    }
+    async execute() {
+        try {
+            const modelResult = await this.getModelRepository.execute(BACKGROUND_TASK_SETTINGS_MODEL_ID);
+            if (modelResult.isFail()) return Result.fail(new BackgroundTaskModelNotFoundError(BACKGROUND_TASK_SETTINGS_MODEL_ID));
+            const model = modelResult.value;
+            const singletonId = createCacheKey(model.modelId);
+            const entryId = `${singletonId}#0001`;
+            const entryResult = await this.getLatestRevisionRepository.execute(model, {
+                id: entryId
+            });
+            if (entryResult.isOk()) {
+                const retentionDays = null != entryResult.value.values.retentionDays ? entryResult.value.values.retentionDays : this.defaultRetentionDays;
+                return Result.ok({
+                    retentionDays
+                });
+            }
+            const { entry } = await this.createEntryDataFactory.create(model, {
+                id: singletonId,
+                values: {
+                    retentionDays: this.defaultRetentionDays
+                }
+            });
+            const createResult = await this.createEntryRepository.execute(model, entry);
+            if (createResult.isFail()) return Result.fail(BackgroundTaskPersistenceError.from(createResult.error));
+            return Result.ok({
+                retentionDays: this.defaultRetentionDays
+            });
+        } catch (error) {
+            return Result.fail(BackgroundTaskPersistenceError.from(error));
+        }
+    }
+}
+const GetBackgroundTaskSettingsRepository_GetBackgroundTaskSettingsRepository = GetBackgroundTaskSettingsRepository.createImplementation({
+    implementation: GetBackgroundTaskSettingsRepositoryImpl,
+    dependencies: [
+        GetModelRepository,
+        GetLatestRevisionByEntryIdRepository,
+        CreateEntryRepository,
+        CreateEntryDataFactory,
+        BuildParams
+    ]
+});
+export { GetBackgroundTaskSettingsRepository_GetBackgroundTaskSettingsRepository as GetBackgroundTaskSettingsRepository };
+
+//# sourceMappingURL=GetBackgroundTaskSettingsRepository.js.map

package/api/features/GetBackgroundTaskSettings/GetBackgroundTaskSettingsRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/GetBackgroundTaskSettings/GetBackgroundTaskSettingsRepository.js","sources":["../../../../src/api/features/GetBackgroundTaskSettings/GetBackgroundTaskSettingsRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { createCacheKey } from \"@webiny/utils\";\nimport { GetModelRepository } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\nimport { GetLatestRevisionByEntryIdRepository } from \"@webiny/api-headless-cms/features/contentEntry/GetLatestRevisionByEntryId/index.js\";\nimport { CreateEntryRepository } from \"@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js\";\nimport { CreateEntryDataFactory } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\nimport { BuildParams } from \"@webiny/api-core/features/buildParams/index.js\";\nimport { GetBackgroundTaskSettingsRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport {\n    BackgroundTaskModelNotFoundError,\n    BackgroundTaskPersistenceError\n} from \"~/api/domain/errors.js\";\nimport {\n    BACKGROUND_TASK_SETTINGS_MODEL_ID,\n    BACKGROUND_TASK_DEFAULT_RETENTION_DAYS\n} from \"~/api/domain/constants.js\";\nimport type { IBackgroundTaskSettings } from \"~/api/domain/BackgroundTaskSettings.js\";\n\ninterface BackgroundTaskSettingsValues {\n    retentionDays?: number;\n}\n\nclass GetBackgroundTaskSettingsRepositoryImpl implements RepositoryAbstraction.Interface {\n    private readonly defaultRetentionDays: number;\n\n    constructor(\n        private readonly getModelRepository: GetModelRepository.Interface,\n        private readonly getLatestRevisionRepository: GetLatestRevisionByEntryIdRepository.Interface,\n        private readonly createEntryRepository: CreateEntryRepository.Interface,\n        private readonly createEntryDataFactory: CreateEntryDataFactory.Interface,\n        buildParams: BuildParams.Interface\n    ) {\n        this.defaultRetentionDays =\n            buildParams.get<number>(\"BackgroundTasks.RetentionDays\") ||\n            BACKGROUND_TASK_DEFAULT_RETENTION_DAYS;\n    }\n\n    async execute(): Promise<Result<IBackgroundTaskSettings, RepositoryAbstraction.Error>> {\n        try {\n            const modelResult = await this.getModelRepository.execute(\n                BACKGROUND_TASK_SETTINGS_MODEL_ID\n            );\n            if (modelResult.isFail()) {\n                return Result.fail(\n                    new BackgroundTaskModelNotFoundError(BACKGROUND_TASK_SETTINGS_MODEL_ID)\n                );\n            }\n\n            const model = modelResult.value;\n            const singletonId = createCacheKey(model.modelId);\n            const entryId = `${singletonId}#0001`;\n\n            const entryResult =\n                await this.getLatestRevisionRepository.execute<BackgroundTaskSettingsValues>(\n                    model,\n                    { id: entryId }\n                );\n\n            if (entryResult.isOk()) {\n                const retentionDays =\n                    entryResult.value.values.retentionDays != null\n                        ? entryResult.value.values.retentionDays\n                        : this.defaultRetentionDays;\n\n                return Result.ok({ retentionDays });\n            }\n\n            /* Entry doesn't exist yet — create it with the build-param default. */\n            const { entry } =\n                await this.createEntryDataFactory.create<BackgroundTaskSettingsValues>(model, {\n                    id: singletonId,\n                    values: {\n                        retentionDays: this.defaultRetentionDays\n                    }\n                });\n\n            const createResult = await this.createEntryRepository.execute(model, entry);\n            if (createResult.isFail()) {\n                return Result.fail(BackgroundTaskPersistenceError.from(createResult.error));\n            }\n\n            return Result.ok({ retentionDays: this.defaultRetentionDays });\n        } catch (error) {\n            return Result.fail(BackgroundTaskPersistenceError.from(error));\n        }\n    }\n}\n\nexport const GetBackgroundTaskSettingsRepository = RepositoryAbstraction.createImplementation({\n    implementation: GetBackgroundTaskSettingsRepositoryImpl,\n    dependencies: [\n        GetModelRepository,\n        GetLatestRevisionByEntryIdRepository,\n        CreateEntryRepository,\n        CreateEntryDataFactory,\n        BuildParams\n    ]\n});\n"],"names":["GetBackgroundTaskSettingsRepositoryImpl","getModelRepository","getLatestRevisionRepository","createEntryRepository","createEntryDataFactory","buildParams","BACKGROUND_TASK_DEFAULT_RETENTION_DAYS","modelResult","BACKGROUND_TASK_SETTINGS_MODEL_ID","Result","BackgroundTaskModelNotFoundError","model","singletonId","createCacheKey","entryId","entryResult","retentionDays","entry","createResult","BackgroundTaskPersistenceError","error","GetBackgroundTaskSettingsRepository","RepositoryAbstraction","GetModelRepository","GetLatestRevisionByEntryIdRepository","CreateEntryRepository","CreateEntryDataFactory","BuildParams"],"mappings":";;;;;;;;;;AAsBA,MAAMA;IAGF,YACqBC,kBAAgD,EAChDC,2BAA2E,EAC3EC,qBAAsD,EACtDC,sBAAwD,EACzEC,WAAkC,CACpC;aALmBJ,kBAAkB,GAAlBA;aACAC,2BAA2B,GAA3BA;aACAC,qBAAqB,GAArBA;aACAC,sBAAsB,GAAtBA;QAGjB,IAAI,CAAC,oBAAoB,GACrBC,YAAY,GAAG,CAAS,oCACxBC;IACR;IAEA,MAAM,UAAiF;QACnF,IAAI;YACA,MAAMC,cAAc,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CACrDC;YAEJ,IAAID,YAAY,MAAM,IAClB,OAAOE,OAAO,IAAI,CACd,IAAIC,iCAAiCF;YAI7C,MAAMG,QAAQJ,YAAY,KAAK;YAC/B,MAAMK,cAAcC,eAAeF,MAAM,OAAO;YAChD,MAAMG,UAAU,GAAGF,YAAY,KAAK,CAAC;YAErC,MAAMG,cACF,MAAM,IAAI,CAAC,2BAA2B,CAAC,OAAO,CAC1CJ,OACA;gBAAE,IAAIG;YAAQ;YAGtB,IAAIC,YAAY,IAAI,IAAI;gBACpB,MAAMC,gBACFD,AAA0C,QAA1CA,YAAY,KAAK,CAAC,MAAM,CAAC,aAAa,GAChCA,YAAY,KAAK,CAAC,MAAM,CAAC,aAAa,GACtC,IAAI,CAAC,oBAAoB;gBAEnC,OAAON,OAAO,EAAE,CAAC;oBAAEO;gBAAc;YACrC;YAGA,MAAM,EAAEC,KAAK,EAAE,GACX,MAAM,IAAI,CAAC,sBAAsB,CAAC,MAAM,CAA+BN,OAAO;gBAC1E,IAAIC;gBACJ,QAAQ;oBACJ,eAAe,IAAI,CAAC,oBAAoB;gBAC5C;YACJ;YAEJ,MAAMM,eAAe,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAACP,OAAOM;YACrE,IAAIC,aAAa,MAAM,IACnB,OAAOT,OAAO,IAAI,CAACU,+BAA+B,IAAI,CAACD,aAAa,KAAK;YAG7E,OAAOT,OAAO,EAAE,CAAC;gBAAE,eAAe,IAAI,CAAC,oBAAoB;YAAC;QAChE,EAAE,OAAOW,OAAO;YACZ,OAAOX,OAAO,IAAI,CAACU,+BAA+B,IAAI,CAACC;QAC3D;IACJ;AACJ;AAEO,MAAMC,0EAAsCC,oCAAAA,oBAA0C,CAAC;IAC1F,gBAAgBtB;IAChB,cAAc;QACVuB;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

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

@@ -0,0 +1,13 @@
+import { type Result } from "@webiny/feature/api";
+import type { IBackgroundTaskSettings } from "../../../api/domain/BackgroundTaskSettings.js";
+import type { BackgroundTaskModelNotFoundError, BackgroundTaskPersistenceError } from "../../../api/domain/errors.js";
+type IError = BackgroundTaskModelNotFoundError | BackgroundTaskPersistenceError;
+export interface IGetBackgroundTaskSettingsRepository {
+    execute(): Promise<Result<IBackgroundTaskSettings, IError>>;
+}
+export declare const GetBackgroundTaskSettingsRepository: import("@webiny/di").Abstraction<IGetBackgroundTaskSettingsRepository>;
+export declare namespace GetBackgroundTaskSettingsRepository {
+    type Interface = IGetBackgroundTaskSettingsRepository;
+    type Error = IError;
+}
+export {};