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

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,67 @@
+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 dataResult = await this.updateEntryDataFactory.create(model, {
+                values: {
+                    retentionDays: storedValue
+                }
+            }, entryResult.value);
+            if (dataResult.isFail()) return Result.fail(BackgroundTaskPersistenceError.from(dataResult.error));
+            const { entry } = dataResult.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 dataResult =\n                await this.updateEntryDataFactory.create<BackgroundTaskSettingsValues>(\n                    model,\n                    {\n                        values: {\n                            retentionDays: storedValue\n                        }\n                    },\n                    entryResult.value\n                );\n            if (dataResult.isFail()) {\n                return Result.fail(BackgroundTaskPersistenceError.from(dataResult.error));\n            }\n            const { entry } = dataResult.value;\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","dataResult","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,MAAMa,aACF,MAAM,IAAI,CAAC,sBAAsB,CAAC,MAAM,CACpCP,OACA;gBACI,QAAQ;oBACJ,eAAeM;gBACnB;YACJ,GACAF,YAAY,KAAK;YAEzB,IAAIG,WAAW,MAAM,IACjB,OAAOT,OAAO,IAAI,CAACO,+BAA+B,IAAI,CAACE,WAAW,KAAK;YAE3E,MAAM,EAAEC,KAAK,EAAE,GAAGD,WAAW,KAAK;YAElC,MAAME,eAAe,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAACT,OAAOQ;YACrE,IAAIC,aAAa,MAAM,IACnB,OAAOX,OAAO,IAAI,CAACO,+BAA+B,IAAI,CAACI,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,OAAOZ,OAAO,EAAE,CAACa;QACrB,EAAE,OAAOC,OAAO;YACZ,OAAOd,OAAO,IAAI,CAACO,+BAA+B,IAAI,CAACO;QAC3D;IACJ;AACJ;AAEO,MAAMC,gFAAyCC,uCAAAA,oBAA0C,CAAC;IAC7F,gBAAgB5B;IAChB,cAAc;QACV6B;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/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 {};