@webiny/background-tasks 0.0.0-unstable.0d717d18dd

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

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

package/api/features/TaskExecutionContext/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/TaskExecutionContext/feature.js","sources":["../../../../src/api/features/TaskExecutionContext/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { TaskExecutionContext } from \"./TaskExecutionContext.js\";\n\nexport const TaskExecutionContextFeature = createFeature({\n    name: \"TaskExecutionContext\",\n    register(container) {\n        container.register(TaskExecutionContext).inSingletonScope();\n    }\n});\n"],"names":["TaskExecutionContextFeature","createFeature","container","TaskExecutionContext"],"mappings":";;AAGO,MAAMA,8BAA8BC,cAAc;IACrD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,sBAAsB,gBAAgB;IAC7D;AACJ"}

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

@@ -0,0 +1 @@
+export * from "./abstractions.js";

package/api/features/TaskExecutionContext/index.js

@@ -0,0 +1 @@
+export * from "./abstractions.js";

package/api/features/TriggerTask/TriggerTaskUseCase.d.ts

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

package/api/features/TriggerTask/TriggerTaskUseCase.js

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

package/api/features/TriggerTask/TriggerTaskUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/TriggerTask/TriggerTaskUseCase.js","sources":["../../../../src/api/features/TriggerTask/TriggerTaskUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { TriggerTaskUseCase 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\";\n\nexport class TriggerTaskUseCaseImpl implements UseCaseAbstraction.Interface {\n    public constructor(private taskService: TaskService.Interface) {}\n\n    public async execute<\n        I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends TaskService.GenericOutput = TaskService.GenericOutput\n    >(\n        params: UseCaseAbstraction.Params<I>\n    ): Promise<Result<TaskService.Task<I, O>, UseCaseAbstraction.Error>> {\n        const result = await this.taskService.trigger<I, O>(params);\n\n        return result as unknown as Promise<\n            Result<TaskService.Task<I, O>, UseCaseAbstraction.Error>\n        >;\n    }\n}\n"],"names":["TriggerTaskUseCaseImpl","taskService","params","result"],"mappings":"AAKO,MAAMA;IACT,YAA2BC,WAAkC,CAAE;aAApCA,WAAW,GAAXA;IAAqC;IAEhE,MAAa,QAITC,MAAoC,EAC6B;QACjE,MAAMC,SAAS,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAOD;QAEpD,OAAOC;IAGX;AACJ"}

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

@@ -0,0 +1,28 @@
+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, TaskServiceInfoError } from "../../../api/domain/errors.js";
+export interface ITriggerTaskUseCase {
+    execute<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends TaskService.GenericOutput = TaskService.GenericOutput>(params: TriggerTaskParams<I>): Promise<Result<TaskService.Task<I, O>, UseCaseError>>;
+}
+export interface TriggerTaskParams<I = TaskDefinition.TaskInput> {
+    definition: string;
+    input?: I;
+    name?: string;
+    parent?: Pick<TaskService.Task, "id">;
+    delay?: number;
+}
+export interface ITriggerTaskUseCaseErrors {
+    definitionNotFound: TaskDefinitionNotFoundError;
+    taskNotFound: TaskNotFoundError;
+    serviceError: TaskServiceInfoError;
+}
+type UseCaseError = ITriggerTaskUseCaseErrors[keyof ITriggerTaskUseCaseErrors];
+export declare const TriggerTaskUseCase: import("@webiny/di").Abstraction<ITriggerTaskUseCase>;
+export declare namespace TriggerTaskUseCase {
+    type Interface = ITriggerTaskUseCase;
+    type Params<I = TaskDefinition.TaskInput> = TriggerTaskParams<I>;
+    type Error = UseCaseError;
+    type Return<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput, O extends TaskService.GenericOutput = TaskService.GenericOutput> = Promise<Result<TaskService.Task<I, O>, UseCaseError>>;
+}
+export {};

package/api/features/TriggerTask/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/TriggerTask/abstractions.js","sources":["../../../../src/api/features/TriggerTask/abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport {\n    TaskDefinitionNotFoundError,\n    TaskNotFoundError,\n    TaskServiceInfoError\n} from \"~/api/domain/errors.js\";\n\nexport interface ITriggerTaskUseCase {\n    execute<\n        I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends TaskService.GenericOutput = TaskService.GenericOutput\n    >(\n        params: TriggerTaskParams<I>\n    ): Promise<Result<TaskService.Task<I, O>, UseCaseError>>;\n}\n\nexport interface TriggerTaskParams<I = TaskDefinition.TaskInput> {\n    definition: string;\n    input?: I;\n    name?: string;\n    parent?: Pick<TaskService.Task, \"id\">;\n    delay?: number;\n}\n\nexport interface ITriggerTaskUseCaseErrors {\n    definitionNotFound: TaskDefinitionNotFoundError;\n    taskNotFound: TaskNotFoundError;\n    serviceError: TaskServiceInfoError;\n}\n\ntype UseCaseError = ITriggerTaskUseCaseErrors[keyof ITriggerTaskUseCaseErrors];\n\nexport const TriggerTaskUseCase = createAbstraction<ITriggerTaskUseCase>(\n    \"Tasks/TriggerTaskUseCase\"\n);\n\nexport namespace TriggerTaskUseCase {\n    export type Interface = ITriggerTaskUseCase;\n    export type Params<I = TaskDefinition.TaskInput> = TriggerTaskParams<I>;\n\n    export type Error = UseCaseError;\n    export type Return<\n        I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput,\n        O extends TaskService.GenericOutput = TaskService.GenericOutput\n    > = Promise<Result<TaskService.Task<I, O>, UseCaseError>>;\n}\n"],"names":["TriggerTaskUseCase","createAbstraction"],"mappings":";AAkCO,MAAMA,qBAAqBC,kBAC9B"}

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

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

package/api/features/TriggerTask/feature.js

@@ -0,0 +1,13 @@
+import { createFeature } from "@webiny/feature/api";
+import { TriggerTaskUseCase } from "./abstractions.js";
+import { TriggerTaskUseCaseImpl } from "./TriggerTaskUseCase.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+const TriggerTaskFeature = createFeature({
+    name: "TriggerTask",
+    register (container) {
+        container.registerFactory(TriggerTaskUseCase, ()=>new TriggerTaskUseCaseImpl(container.resolve(TaskService)));
+    }
+});
+export { TriggerTaskFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/TriggerTask/feature.js","sources":["../../../../src/api/features/TriggerTask/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { TriggerTaskUseCase } from \"./abstractions.js\";\nimport { TriggerTaskUseCaseImpl } from \"~/api/features/TriggerTask/TriggerTaskUseCase.js\";\nimport { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\n\nexport const TriggerTaskFeature = createFeature({\n    name: \"TriggerTask\",\n    register(container) {\n        container.registerFactory(TriggerTaskUseCase, () => {\n            return new TriggerTaskUseCaseImpl(container.resolve(TaskService));\n        });\n    }\n});\n"],"names":["TriggerTaskFeature","createFeature","container","TriggerTaskUseCase","TriggerTaskUseCaseImpl","TaskService"],"mappings":";;;;AAKO,MAAMA,qBAAqBC,cAAc;IAC5C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,eAAe,CAACC,oBAAoB,IACnC,IAAIC,uBAAuBF,UAAU,OAAO,CAACG;IAE5D;AACJ"}

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

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

package/api/features/TriggerTask/index.js

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

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

@@ -0,0 +1,23 @@
+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 { UpdateEntryRepository } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { UpdateEntryDataFactory } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+import { BuildParams } from "@webiny/api-core/features/buildParams/index.js";
+import { GetBackgroundTaskSettingsRepository } from "../../../api/features/GetBackgroundTaskSettings/abstractions.js";
+import { UpdateBackgroundTaskSettingsRepository as RepositoryAbstraction, type IUpdateBackgroundTaskSettingsInput } from "./abstractions.js";
+import type { IBackgroundTaskSettings } from "../../../api/domain/BackgroundTaskSettings.js";
+declare class UpdateBackgroundTaskSettingsRepositoryImpl implements RepositoryAbstraction.Interface {
+    private readonly getModelRepository;
+    private readonly getSettingsRepository;
+    private readonly getLatestRevisionRepository;
+    private readonly updateEntryRepository;
+    private readonly updateEntryDataFactory;
+    private readonly defaultRetentionDays;
+    constructor(getModelRepository: GetModelRepository.Interface, getSettingsRepository: GetBackgroundTaskSettingsRepository.Interface, getLatestRevisionRepository: GetLatestRevisionByEntryIdRepository.Interface, updateEntryRepository: UpdateEntryRepository.Interface, updateEntryDataFactory: UpdateEntryDataFactory.Interface, buildParams: BuildParams.Interface);
+    execute(input: IUpdateBackgroundTaskSettingsInput): Promise<Result<IBackgroundTaskSettings, RepositoryAbstraction.Error>>;
+}
+export declare const UpdateBackgroundTaskSettingsRepository: typeof UpdateBackgroundTaskSettingsRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateBackgroundTaskSettingsRepository>;
+};
+export {};

package/api/features/UpdateBackgroundTaskSettings/UpdateBackgroundTaskSettingsRepository.js

@@ -0,0 +1,65 @@
+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 { UpdateEntryRepository } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { UpdateEntryDataFactory } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+import { BuildParams } from "@webiny/api-core/features/buildParams/index.js";
+import { GetBackgroundTaskSettingsRepository } from "../GetBackgroundTaskSettings/abstractions.js";
+import { UpdateBackgroundTaskSettingsRepository } 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 UpdateBackgroundTaskSettingsRepositoryImpl {
+    constructor(getModelRepository, getSettingsRepository, getLatestRevisionRepository, updateEntryRepository, updateEntryDataFactory, buildParams){
+        this.getModelRepository = getModelRepository;
+        this.getSettingsRepository = getSettingsRepository;
+        this.getLatestRevisionRepository = getLatestRevisionRepository;
+        this.updateEntryRepository = updateEntryRepository;
+        this.updateEntryDataFactory = updateEntryDataFactory;
+        this.defaultRetentionDays = buildParams.get("BackgroundTasks.RetentionDays") || BACKGROUND_TASK_DEFAULT_RETENTION_DAYS;
+    }
+    async execute(input) {
+        try {
+            const getResult = await this.getSettingsRepository.execute();
+            if (getResult.isFail()) return getResult;
+            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.isFail()) return Result.fail(BackgroundTaskPersistenceError.from(entryResult.error));
+            const storedValue = input.retentionDays === this.defaultRetentionDays ? null : input.retentionDays;
+            const { entry } = await this.updateEntryDataFactory.create(model, {
+                values: {
+                    retentionDays: storedValue
+                }
+            }, entryResult.value);
+            const updateResult = await this.updateEntryRepository.execute(model, entry);
+            if (updateResult.isFail()) return Result.fail(BackgroundTaskPersistenceError.from(updateResult.error));
+            const retentionDays = null != entry.values.retentionDays ? entry.values.retentionDays : this.defaultRetentionDays;
+            const settings = {
+                retentionDays
+            };
+            return Result.ok(settings);
+        } catch (error) {
+            return Result.fail(BackgroundTaskPersistenceError.from(error));
+        }
+    }
+}
+const UpdateBackgroundTaskSettingsRepository_UpdateBackgroundTaskSettingsRepository = UpdateBackgroundTaskSettingsRepository.createImplementation({
+    implementation: UpdateBackgroundTaskSettingsRepositoryImpl,
+    dependencies: [
+        GetModelRepository,
+        GetBackgroundTaskSettingsRepository,
+        GetLatestRevisionByEntryIdRepository,
+        UpdateEntryRepository,
+        UpdateEntryDataFactory,
+        BuildParams
+    ]
+});
+export { UpdateBackgroundTaskSettingsRepository_UpdateBackgroundTaskSettingsRepository as UpdateBackgroundTaskSettingsRepository };
+
+//# sourceMappingURL=UpdateBackgroundTaskSettingsRepository.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/UpdateBackgroundTaskSettings/UpdateBackgroundTaskSettingsRepository.js","sources":["../../../../src/api/features/UpdateBackgroundTaskSettings/UpdateBackgroundTaskSettingsRepository.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 { UpdateEntryRepository } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js\";\nimport { UpdateEntryDataFactory } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\nimport { BuildParams } from \"@webiny/api-core/features/buildParams/index.js\";\nimport { GetBackgroundTaskSettingsRepository } from \"~/api/features/GetBackgroundTaskSettings/abstractions.js\";\nimport {\n    UpdateBackgroundTaskSettingsRepository as RepositoryAbstraction,\n    type IUpdateBackgroundTaskSettingsInput\n} 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 | null;\n}\n\nclass UpdateBackgroundTaskSettingsRepositoryImpl implements RepositoryAbstraction.Interface {\n    private readonly defaultRetentionDays: number;\n\n    constructor(\n        private readonly getModelRepository: GetModelRepository.Interface,\n        private readonly getSettingsRepository: GetBackgroundTaskSettingsRepository.Interface,\n        private readonly getLatestRevisionRepository: GetLatestRevisionByEntryIdRepository.Interface,\n        private readonly updateEntryRepository: UpdateEntryRepository.Interface,\n        private readonly updateEntryDataFactory: UpdateEntryDataFactory.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(\n        input: IUpdateBackgroundTaskSettingsInput\n    ): Promise<Result<IBackgroundTaskSettings, RepositoryAbstraction.Error>> {\n        try {\n            /* Ensure the singleton entry exists (creates if missing). */\n            const getResult = await this.getSettingsRepository.execute();\n            if (getResult.isFail()) {\n                return getResult;\n            }\n\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.isFail()) {\n                return Result.fail(BackgroundTaskPersistenceError.from(entryResult.error));\n            }\n\n            /* Store null when the value matches the default so the default stays in control. */\n            const storedValue =\n                input.retentionDays === this.defaultRetentionDays ? null : input.retentionDays;\n\n            const { entry } =\n                await this.updateEntryDataFactory.create<BackgroundTaskSettingsValues>(\n                    model,\n                    {\n                        values: {\n                            retentionDays: storedValue\n                        }\n                    },\n                    entryResult.value\n                );\n\n            const updateResult = await this.updateEntryRepository.execute(model, entry);\n            if (updateResult.isFail()) {\n                return Result.fail(BackgroundTaskPersistenceError.from(updateResult.error));\n            }\n\n            const retentionDays =\n                entry.values.retentionDays != null\n                    ? entry.values.retentionDays\n                    : this.defaultRetentionDays;\n\n            const settings: IBackgroundTaskSettings = {\n                retentionDays\n            };\n\n            return Result.ok(settings);\n        } catch (error) {\n            return Result.fail(BackgroundTaskPersistenceError.from(error));\n        }\n    }\n}\n\nexport const UpdateBackgroundTaskSettingsRepository = RepositoryAbstraction.createImplementation({\n    implementation: UpdateBackgroundTaskSettingsRepositoryImpl,\n    dependencies: [\n        GetModelRepository,\n        GetBackgroundTaskSettingsRepository,\n        GetLatestRevisionByEntryIdRepository,\n        UpdateEntryRepository,\n        UpdateEntryDataFactory,\n        BuildParams\n    ]\n});\n"],"names":["UpdateBackgroundTaskSettingsRepositoryImpl","getModelRepository","getSettingsRepository","getLatestRevisionRepository","updateEntryRepository","updateEntryDataFactory","buildParams","BACKGROUND_TASK_DEFAULT_RETENTION_DAYS","input","getResult","modelResult","BACKGROUND_TASK_SETTINGS_MODEL_ID","Result","BackgroundTaskModelNotFoundError","model","singletonId","createCacheKey","entryId","entryResult","BackgroundTaskPersistenceError","storedValue","entry","updateResult","retentionDays","settings","error","UpdateBackgroundTaskSettingsRepository","RepositoryAbstraction","GetModelRepository","GetBackgroundTaskSettingsRepository","GetLatestRevisionByEntryIdRepository","UpdateEntryRepository","UpdateEntryDataFactory","BuildParams"],"mappings":";;;;;;;;;;;AA0BA,MAAMA;IAGF,YACqBC,kBAAgD,EAChDC,qBAAoE,EACpEC,2BAA2E,EAC3EC,qBAAsD,EACtDC,sBAAwD,EACzEC,WAAkC,CACpC;aANmBL,kBAAkB,GAAlBA;aACAC,qBAAqB,GAArBA;aACAC,2BAA2B,GAA3BA;aACAC,qBAAqB,GAArBA;aACAC,sBAAsB,GAAtBA;QAGjB,IAAI,CAAC,oBAAoB,GACrBC,YAAY,GAAG,CAAS,oCACxBC;IACR;IAEA,MAAM,QACFC,KAAyC,EAC4B;QACrE,IAAI;YAEA,MAAMC,YAAY,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO;YAC1D,IAAIA,UAAU,MAAM,IAChB,OAAOA;YAGX,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,MAAM,IAClB,OAAON,OAAO,IAAI,CAACO,+BAA+B,IAAI,CAACD,YAAY,KAAK;YAI5E,MAAME,cACFZ,MAAM,aAAa,KAAK,IAAI,CAAC,oBAAoB,GAAG,OAAOA,MAAM,aAAa;YAElF,MAAM,EAAEa,KAAK,EAAE,GACX,MAAM,IAAI,CAAC,sBAAsB,CAAC,MAAM,CACpCP,OACA;gBACI,QAAQ;oBACJ,eAAeM;gBACnB;YACJ,GACAF,YAAY,KAAK;YAGzB,MAAMI,eAAe,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAACR,OAAOO;YACrE,IAAIC,aAAa,MAAM,IACnB,OAAOV,OAAO,IAAI,CAACO,+BAA+B,IAAI,CAACG,aAAa,KAAK;YAG7E,MAAMC,gBACFF,AAA8B,QAA9BA,MAAM,MAAM,CAAC,aAAa,GACpBA,MAAM,MAAM,CAAC,aAAa,GAC1B,IAAI,CAAC,oBAAoB;YAEnC,MAAMG,WAAoC;gBACtCD;YACJ;YAEA,OAAOX,OAAO,EAAE,CAACY;QACrB,EAAE,OAAOC,OAAO;YACZ,OAAOb,OAAO,IAAI,CAACO,+BAA+B,IAAI,CAACM;QAC3D;IACJ;AACJ;AAEO,MAAMC,gFAAyCC,uCAAAA,oBAA0C,CAAC;IAC7F,gBAAgB3B;IAChB,cAAc;QACV4B;QACAC;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

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

@@ -0,0 +1,14 @@
+import { Result } from "@webiny/feature/api";
+import { UpdateBackgroundTaskSettingsRepository, UpdateBackgroundTaskSettingsUseCase as UseCaseAbstraction } from "./abstractions.js";
+import type { IBackgroundTaskSettings } from "../../../api/domain/BackgroundTaskSettings.js";
+import { BackgroundTaskPermissions } from "../../../api/features/BackgroundTaskPermissions/abstractions.js";
+declare class UpdateBackgroundTaskSettingsUseCaseImpl implements UseCaseAbstraction.Interface {
+    private readonly permissions;
+    private readonly repository;
+    constructor(permissions: BackgroundTaskPermissions.Interface, repository: UpdateBackgroundTaskSettingsRepository.Interface);
+    execute(input: UseCaseAbstraction.Input): Promise<Result<IBackgroundTaskSettings, UseCaseAbstraction.Error>>;
+}
+export declare const UpdateBackgroundTaskSettingsUseCase: typeof UpdateBackgroundTaskSettingsUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateBackgroundTaskSettingsUseCase>;
+};
+export {};

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/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/BackgroundTasksContextualSchema.d.ts

@@ -0,0 +1,21 @@
+import type { GraphQLSchema } from "graphql";
+import type { IGraphQLContextualSchema } from "@webiny/api-graphql";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/abstractions.js";
+/**
+ * Builds the background-tasks GraphQL schema after context enhancement — the schema shape depends on
+ * the per-tenant CMS task/log content models, so it can only be rendered at request time (once the
+ * tenant is known and the CMS facade is resolvable). Replaces the legacy `createBackgroundTaskGraphQL`
+ * + `createBackgroundTaskSettingsGraphQL` ContextPlugins; the settings schema is merged in here
+ * because it extends the task schema's `WebinyBackgroundTaskQuery`/`Mutation` types.
+ */
+declare class BackgroundTasksContextualSchemaImpl implements IGraphQLContextualSchema {
+    private tenantCtx;
+    private identityCtx;
+    constructor(tenantCtx: TenantContext.Interface, identityCtx: IdentityContext.Interface);
+    build(ctx: Record<string, any>): Promise<GraphQLSchema>;
+}
+export declare const BackgroundTasksContextualSchema: typeof BackgroundTasksContextualSchemaImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IGraphQLContextualSchema>;
+};
+export {};