@webiny/background-tasks 0.0.0-unstable.7be00a75a9 → 0.0.0-unstable.9f53ea597d

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,5 @@
+import type { Context } from "../../../api/types.js";
+export declare const TriggerTaskFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container, context: Context): void;
+};

package/api/features/TriggerTask/feature.js

@@ -0,0 +1,12 @@
+import { createFeature } from "@webiny/feature/api";
+import { TriggerTaskUseCase } from "./abstractions.js";
+import { TriggerTaskUseCaseImpl } from "./TriggerTaskUseCase.js";
+const TriggerTaskFeature = createFeature({
+    name: "TriggerTask",
+    register (container, context) {
+        container.registerInstance(TriggerTaskUseCase, new TriggerTaskUseCaseImpl(context));
+    }
+});
+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 type { Context } from \"~/api/types.js\";\n\nexport const TriggerTaskFeature = createFeature<Context>({\n    name: \"TriggerTask\",\n    register(container, context) {\n        container.registerInstance(TriggerTaskUseCase, new TriggerTaskUseCaseImpl(context!));\n    }\n});\n"],"names":["TriggerTaskFeature","createFeature","container","context","TriggerTaskUseCase","TriggerTaskUseCaseImpl"],"mappings":";;;AAKO,MAAMA,qBAAqBC,cAAuB;IACrD,MAAM;IACN,UAASC,SAAS,EAAEC,OAAO;QACvBD,UAAU,gBAAgB,CAACE,oBAAoB,IAAIC,uBAAuBF;IAC9E;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,64 @@
+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 settings = {
+                retentionDays: entry.values.retentionDays ?? this.defaultRetentionDays
+            };
+            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 settings: IBackgroundTaskSettings = {\n                retentionDays: entry.values.retentionDays ?? this.defaultRetentionDays\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","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,WAAoC;gBACtC,eAAeF,MAAM,MAAM,CAAC,aAAa,IAAI,IAAI,CAAC,oBAAoB;YAC1E;YAEA,OAAOT,OAAO,EAAE,CAACW;QACrB,EAAE,OAAOC,OAAO;YACZ,OAAOZ,OAAO,IAAI,CAACO,+BAA+B,IAAI,CAACK;QAC3D;IACJ;AACJ;AAEO,MAAMC,gFAAyCC,uCAAAA,oBAA0C,CAAC;IAC7F,gBAAgB1B;IAChB,cAAc;QACV2B;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/BackgroundTaskSettingsSchema.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "@webiny/plugins/types.js";
+export declare const createBackgroundTaskSettingsGraphQL: () => Plugin[];

package/api/graphql/BackgroundTaskSettingsSchema.js

@@ -0,0 +1,84 @@
+import { GraphQLSchemaPlugin } from "@webiny/handler-graphql";
+import { ContextPlugin } from "@webiny/handler";
+import { GetBackgroundTaskSettingsRepository } from "../features/GetBackgroundTaskSettings/abstractions.js";
+import { UpdateBackgroundTaskSettingsUseCase } from "../features/UpdateBackgroundTaskSettings/abstractions.js";
+import { checkPermissions } from "./checkPermissions.js";
+const resolve = async (fn)=>{
+    try {
+        const data = await fn();
+        return {
+            data,
+            error: null
+        };
+    } catch (error) {
+        return {
+            data: null,
+            error: {
+                message: error.message,
+                code: error.code,
+                data: error.data
+            }
+        };
+    }
+};
+const createBackgroundTaskSettingsGraphQL = ()=>{
+    const plugin = new ContextPlugin(async (ctx)=>{
+        if (!ctx.tenancy.getCurrentTenant()) return;
+        const schema = new GraphQLSchemaPlugin({
+            typeDefs: `
+                type WebinyBackgroundTaskSettings {
+                    retentionDays: Int
+                }
+
+                type WebinyBackgroundTaskSettingsResponse {
+                    data: WebinyBackgroundTaskSettings
+                    error: WebinyBackgroundTaskError
+                }
+
+                input UpdateBackgroundTaskSettingsInput {
+                    retentionDays: Int
+                }
+
+                extend type WebinyBackgroundTaskQuery {
+                    getSettings: WebinyBackgroundTaskSettingsResponse
+                }
+
+                extend type WebinyBackgroundTaskMutation {
+                    updateSettings(
+                        input: UpdateBackgroundTaskSettingsInput!
+                    ): WebinyBackgroundTaskSettingsResponse
+                }
+            `,
+            resolvers: {
+                WebinyBackgroundTaskQuery: {
+                    getSettings: async (_, __, context)=>resolve(async ()=>{
+                            await checkPermissions(context, {
+                                rwd: "r"
+                            });
+                            const repository = context.container.resolve(GetBackgroundTaskSettingsRepository);
+                            const result = await repository.execute();
+                            if (result.isFail()) throw result.error;
+                            return result.value;
+                        })
+                },
+                WebinyBackgroundTaskMutation: {
+                    updateSettings: async (_, args, context)=>resolve(async ()=>{
+                            const useCase = context.container.resolve(UpdateBackgroundTaskSettingsUseCase);
+                            const result = await useCase.execute(args.input);
+                            if (result.isFail()) throw result.error;
+                            return result.value;
+                        })
+                }
+            }
+        });
+        schema.name = "backgroundTasks.settings.graphql.schema";
+        ctx.plugins.register(schema);
+    });
+    plugin.name = "backgroundTasks.settings.graphql";
+    return [
+        plugin
+    ];
+};
+export { createBackgroundTaskSettingsGraphQL };
+
+//# sourceMappingURL=BackgroundTaskSettingsSchema.js.map

package/api/graphql/BackgroundTaskSettingsSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/graphql/BackgroundTaskSettingsSchema.js","sources":["../../../src/api/graphql/BackgroundTaskSettingsSchema.ts"],"sourcesContent":["import { GraphQLSchemaPlugin } from \"@webiny/handler-graphql\";\nimport { ContextPlugin } from \"@webiny/handler\";\nimport type { Context } from \"~/api/types.js\";\nimport { GetBackgroundTaskSettingsRepository } from \"~/api/features/GetBackgroundTaskSettings/abstractions.js\";\nimport { UpdateBackgroundTaskSettingsUseCase } from \"~/api/features/UpdateBackgroundTaskSettings/abstractions.js\";\nimport type { IUpdateBackgroundTaskSettingsInput } from \"~/api/features/UpdateBackgroundTaskSettings/abstractions.js\";\nimport type { Plugin } from \"@webiny/plugins/types.js\";\nimport { checkPermissions } from \"./checkPermissions.js\";\n\ninterface IUpdateSettingsArgs {\n    input: IUpdateBackgroundTaskSettingsInput;\n}\n\nconst resolve = async <T = unknown>(fn: () => Promise<T>) => {\n    try {\n        const data = await fn();\n        return { data, error: null };\n    } catch (error: any) {\n        return {\n            data: null,\n            error: {\n                message: error.message,\n                code: error.code,\n                data: error.data\n            }\n        };\n    }\n};\n\nexport const createBackgroundTaskSettingsGraphQL = (): Plugin[] => {\n    const plugin = new ContextPlugin<Context>(async ctx => {\n        if (!ctx.tenancy.getCurrentTenant()) {\n            return;\n        }\n\n        const schema = new GraphQLSchemaPlugin<Context>({\n            typeDefs: /* GraphQL */ `\n                type WebinyBackgroundTaskSettings {\n                    retentionDays: Int\n                }\n\n                type WebinyBackgroundTaskSettingsResponse {\n                    data: WebinyBackgroundTaskSettings\n                    error: WebinyBackgroundTaskError\n                }\n\n                input UpdateBackgroundTaskSettingsInput {\n                    retentionDays: Int\n                }\n\n                extend type WebinyBackgroundTaskQuery {\n                    getSettings: WebinyBackgroundTaskSettingsResponse\n                }\n\n                extend type WebinyBackgroundTaskMutation {\n                    updateSettings(\n                        input: UpdateBackgroundTaskSettingsInput!\n                    ): WebinyBackgroundTaskSettingsResponse\n                }\n            `,\n            resolvers: {\n                WebinyBackgroundTaskQuery: {\n                    getSettings: async (_, __, context) => {\n                        return resolve(async () => {\n                            await checkPermissions(context, { rwd: \"r\" });\n                            const repository = context.container.resolve(\n                                GetBackgroundTaskSettingsRepository\n                            );\n                            const result = await repository.execute();\n                            if (result.isFail()) {\n                                throw result.error;\n                            }\n                            return result.value;\n                        });\n                    }\n                },\n                WebinyBackgroundTaskMutation: {\n                    updateSettings: async (_, args: IUpdateSettingsArgs, context) => {\n                        return resolve(async () => {\n                            const useCase = context.container.resolve(\n                                UpdateBackgroundTaskSettingsUseCase\n                            );\n                            const result = await useCase.execute(args.input);\n                            if (result.isFail()) {\n                                throw result.error;\n                            }\n                            return result.value;\n                        });\n                    }\n                }\n            }\n        });\n\n        schema.name = \"backgroundTasks.settings.graphql.schema\";\n        ctx.plugins.register(schema);\n    });\n\n    plugin.name = \"backgroundTasks.settings.graphql\";\n\n    return [plugin];\n};\n"],"names":["resolve","fn","data","error","createBackgroundTaskSettingsGraphQL","plugin","ContextPlugin","ctx","schema","GraphQLSchemaPlugin","_","__","context","checkPermissions","repository","GetBackgroundTaskSettingsRepository","result","args","useCase","UpdateBackgroundTaskSettingsUseCase"],"mappings":";;;;;AAaA,MAAMA,UAAU,OAAoBC;IAChC,IAAI;QACA,MAAMC,OAAO,MAAMD;QACnB,OAAO;YAAEC;YAAM,OAAO;QAAK;IAC/B,EAAE,OAAOC,OAAY;QACjB,OAAO;YACH,MAAM;YACN,OAAO;gBACH,SAASA,MAAM,OAAO;gBACtB,MAAMA,MAAM,IAAI;gBAChB,MAAMA,MAAM,IAAI;YACpB;QACJ;IACJ;AACJ;AAEO,MAAMC,sCAAsC;IAC/C,MAAMC,SAAS,IAAIC,cAAuB,OAAMC;QAC5C,IAAI,CAACA,IAAI,OAAO,CAAC,gBAAgB,IAC7B;QAGJ,MAAMC,SAAS,IAAIC,oBAA6B;YAC5C,UAAwB,CAAC;;;;;;;;;;;;;;;;;;;;;;;YAuBzB,CAAC;YACD,WAAW;gBACP,2BAA2B;oBACvB,aAAa,OAAOC,GAAGC,IAAIC,UAChBZ,QAAQ;4BACX,MAAMa,iBAAiBD,SAAS;gCAAE,KAAK;4BAAI;4BAC3C,MAAME,aAAaF,QAAQ,SAAS,CAAC,OAAO,CACxCG;4BAEJ,MAAMC,SAAS,MAAMF,WAAW,OAAO;4BACvC,IAAIE,OAAO,MAAM,IACb,MAAMA,OAAO,KAAK;4BAEtB,OAAOA,OAAO,KAAK;wBACvB;gBAER;gBACA,8BAA8B;oBAC1B,gBAAgB,OAAON,GAAGO,MAA2BL,UAC1CZ,QAAQ;4BACX,MAAMkB,UAAUN,QAAQ,SAAS,CAAC,OAAO,CACrCO;4BAEJ,MAAMH,SAAS,MAAME,QAAQ,OAAO,CAACD,KAAK,KAAK;4BAC/C,IAAID,OAAO,MAAM,IACb,MAAMA,OAAO,KAAK;4BAEtB,OAAOA,OAAO,KAAK;wBACvB;gBAER;YACJ;QACJ;QAEAR,OAAO,IAAI,GAAG;QACdD,IAAI,OAAO,CAAC,QAAQ,CAACC;IACzB;IAEAH,OAAO,IAAI,GAAG;IAEd,OAAO;QAACA;KAAO;AACnB"}

package/api/graphql/checkPermissions.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from "../../api/types.js";
+/**
+ * @throws
+ */
+export declare const checkPermissions: (context: Context, check?: {
+    rwd?: string;
+}) => Promise<void>;

package/api/graphql/checkPermissions.js

@@ -0,0 +1,21 @@
+import { NotAuthorizedError } from "@webiny/api-core/features/security/shared/index.js";
+const checkPermissions = async (context, check = {})=>{
+    const taskPermissions = await context.security.getPermissions("tasks");
+    const relevant = taskPermissions.filter((current)=>{
+        if (check.rwd && !hasRwd(current, check.rwd)) return false;
+        return true;
+    });
+    if (0 === relevant.length) throw new NotAuthorizedError();
+};
+const hasRwd = (permissions, rwd)=>{
+    if (!Array.isArray(permissions)) permissions = [
+        permissions
+    ];
+    if (!rwd) return true;
+    const permissionWithoutRwdRestrictions = permissions.some((permission)=>"string" != typeof permission.rwd);
+    if (permissionWithoutRwdRestrictions) return true;
+    return permissions.some((permission)=>permission.rwd && permission.rwd.includes(rwd));
+};
+export { checkPermissions };
+
+//# sourceMappingURL=checkPermissions.js.map

package/api/graphql/checkPermissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/graphql/checkPermissions.js","sources":["../../../src/api/graphql/checkPermissions.ts"],"sourcesContent":["import type { Context, TaskPermission } from \"~/api/types.js\";\nimport { NotAuthorizedError } from \"@webiny/api-core/features/security/shared/index.js\";\n\n/**\n * @throws\n */\nexport const checkPermissions = async (\n    context: Context,\n    check: { rwd?: string } = {}\n): Promise<void> => {\n    const taskPermissions = await context.security.getPermissions<TaskPermission>(\"tasks\");\n\n    const relevant = taskPermissions.filter(current => {\n        if (check.rwd && !hasRwd(current, check.rwd)) {\n            return false;\n        }\n\n        return true;\n    });\n\n    if (relevant.length === 0) {\n        throw new NotAuthorizedError();\n    }\n};\n\nconst hasRwd = (permissions: TaskPermission | TaskPermission[], rwd: string): boolean => {\n    if (!Array.isArray(permissions)) {\n        permissions = [permissions];\n    }\n\n    if (!rwd) {\n        return true;\n    }\n\n    // Is there a permission that doesn't restrict RWD permissions, that means all RWD permissions are allowed.\n    const permissionWithoutRwdRestrictions = permissions.some(permission => {\n        return typeof permission.rwd !== \"string\";\n    });\n\n    if (permissionWithoutRwdRestrictions) {\n        return true;\n    }\n\n    // If there is no permission that doesn't restrict RWD permissions, that means we need to check if the RWD.\n    return permissions.some(permission => {\n        return permission.rwd && permission.rwd.includes(rwd);\n    });\n};\n"],"names":["checkPermissions","context","check","taskPermissions","relevant","current","hasRwd","NotAuthorizedError","permissions","rwd","Array","permissionWithoutRwdRestrictions","permission"],"mappings":";AAMO,MAAMA,mBAAmB,OAC5BC,SACAC,QAA0B,CAAC,CAAC;IAE5B,MAAMC,kBAAkB,MAAMF,QAAQ,QAAQ,CAAC,cAAc,CAAiB;IAE9E,MAAMG,WAAWD,gBAAgB,MAAM,CAACE,CAAAA;QACpC,IAAIH,MAAM,GAAG,IAAI,CAACI,OAAOD,SAASH,MAAM,GAAG,GACvC,OAAO;QAGX,OAAO;IACX;IAEA,IAAIE,AAAoB,MAApBA,SAAS,MAAM,EACf,MAAM,IAAIG;AAElB;AAEA,MAAMD,SAAS,CAACE,aAAgDC;IAC5D,IAAI,CAACC,MAAM,OAAO,CAACF,cACfA,cAAc;QAACA;KAAY;IAG/B,IAAI,CAACC,KACD,OAAO;IAIX,MAAME,mCAAmCH,YAAY,IAAI,CAACI,CAAAA,aAC/C,AAA0B,YAA1B,OAAOA,WAAW,GAAG;IAGhC,IAAID,kCACA,OAAO;IAIX,OAAOH,YAAY,IAAI,CAACI,CAAAA,aACbA,WAAW,GAAG,IAAIA,WAAW,GAAG,CAAC,QAAQ,CAACH;AAEzD"}

package/api/graphql/index.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "@webiny/plugins/types.js";
+export declare const createBackgroundTaskGraphQL: () => Plugin[];