@webiny/api-aco 6.0.0-alpha.5 → 6.0.0-rc.0

package/features/folder/ListFolders/ListFoldersUseCase.d.ts

@@ -0,0 +1,9 @@
+import { ListFoldersUseCase as UseCaseAbstraction, ListFoldersRepository } from "./abstractions.js";
+import type { ListFoldersParams } from "../../../folder/folder.types.js";
+declare class ListFoldersUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    constructor(repository: ListFoldersRepository.Interface);
+    execute(params: ListFoldersParams): UseCaseAbstraction.Return;
+}
+export declare const ListFoldersUseCase: import("@webiny/di").Implementation<typeof ListFoldersUseCaseImpl>;
+export {};

package/features/folder/ListFolders/ListFoldersUseCase.js

@@ -0,0 +1,17 @@
+import { createImplementation } from "@webiny/feature/api";
+import { ListFoldersUseCase as UseCaseAbstraction, ListFoldersRepository } from "./abstractions.js";
+class ListFoldersUseCaseImpl {
+  constructor(repository) {
+    this.repository = repository;
+  }
+  async execute(params) {
+    return await this.repository.execute(params);
+  }
+}
+export const ListFoldersUseCase = createImplementation({
+  abstraction: UseCaseAbstraction,
+  implementation: ListFoldersUseCaseImpl,
+  dependencies: [ListFoldersRepository]
+});
+
+//# sourceMappingURL=ListFoldersUseCase.js.map

package/features/folder/ListFolders/ListFoldersUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createImplementation","ListFoldersUseCase","UseCaseAbstraction","ListFoldersRepository","ListFoldersUseCaseImpl","constructor","repository","execute","params","abstraction","implementation","dependencies"],"sources":["ListFoldersUseCase.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/feature/api\";\nimport { ListFoldersUseCase as UseCaseAbstraction, ListFoldersRepository } from \"./abstractions.js\";\nimport type { ListFoldersParams } from \"~/folder/folder.types.js\";\n\nclass ListFoldersUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: ListFoldersRepository.Interface) {}\n\n    async execute(params: ListFoldersParams): UseCaseAbstraction.Return {\n        return await this.repository.execute(params);\n    }\n}\n\nexport const ListFoldersUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: ListFoldersUseCaseImpl,\n    dependencies: [ListFoldersRepository]\n});\n"],"mappings":"AAAA,SAASA,oBAAoB,QAAQ,qBAAqB;AAC1D,SAASC,kBAAkB,IAAIC,kBAAkB,EAAEC,qBAAqB;AAGxE,MAAMC,sBAAsB,CAAyC;EACjEC,WAAWA,CAASC,UAA2C,EAAE;IAAA,KAA7CA,UAA2C,GAA3CA,UAA2C;EAAG;EAElE,MAAMC,OAAOA,CAACC,MAAyB,EAA6B;IAChE,OAAO,MAAM,IAAI,CAACF,UAAU,CAACC,OAAO,CAACC,MAAM,CAAC;EAChD;AACJ;AAEA,OAAO,MAAMP,kBAAkB,GAAGD,oBAAoB,CAAC;EACnDS,WAAW,EAAEP,kBAAkB;EAC/BQ,cAAc,EAAEN,sBAAsB;EACtCO,YAAY,EAAE,CAACR,qBAAqB;AACxC,CAAC,CAAC","ignoreList":[]}

package/features/folder/ListFolders/abstractions.d.ts

@@ -0,0 +1,42 @@
+import type { Result } from "@webiny/feature/api";
+import type { Folder, ListFoldersParams } from "../../../folder/folder.types.js";
+import type { ListMeta } from "../../../types.js";
+import type { FolderNotAuthorizedError, FolderPersistenceError } from "../../../domain/folder/errors.js";
+interface IListFoldersResult {
+    folders: Folder[];
+    meta: ListMeta;
+}
+/**
+ * ListFolders repository interface
+ */
+export interface IListFoldersRepository {
+    execute(params: ListFoldersParams): Promise<Result<IListFoldersResult, RepositoryError>>;
+}
+export interface IListFoldersRepositoryErrors {
+    persistence: FolderPersistenceError;
+}
+type RepositoryError = IListFoldersRepositoryErrors[keyof IListFoldersRepositoryErrors];
+export declare const ListFoldersRepository: import("@webiny/di").Abstraction<IListFoldersRepository>;
+export declare namespace ListFoldersRepository {
+    type Interface = IListFoldersRepository;
+    type Return = Promise<Result<IListFoldersResult, RepositoryError>>;
+    type Error = RepositoryError;
+}
+/**
+ * ListFolders use case interface
+ */
+export interface IListFoldersUseCase {
+    execute(params: ListFoldersParams): Promise<Result<IListFoldersResult, UseCaseError>>;
+}
+export interface IListFoldersUseCaseErrors {
+    notAuthorized: FolderNotAuthorizedError;
+    persistence: FolderPersistenceError;
+}
+type UseCaseError = IListFoldersUseCaseErrors[keyof IListFoldersUseCaseErrors];
+export declare const ListFoldersUseCase: import("@webiny/di").Abstraction<IListFoldersUseCase>;
+export declare namespace ListFoldersUseCase {
+    type Interface = IListFoldersUseCase;
+    type Return = Promise<Result<IListFoldersResult, UseCaseError>>;
+    type Error = UseCaseError;
+}
+export {};

package/features/folder/ListFolders/abstractions.js

@@ -0,0 +1,15 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * ListFolders repository interface
+ */
+
+export const ListFoldersRepository = createAbstraction("ListFoldersRepository");
+
+/**
+ * ListFolders use case interface
+ */
+
+export const ListFoldersUseCase = createAbstraction("ListFoldersUseCase");
+
+//# sourceMappingURL=abstractions.js.map

package/features/folder/ListFolders/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","ListFoldersRepository","ListFoldersUseCase"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { Folder, ListFoldersParams } from \"~/folder/folder.types.js\";\nimport type { ListMeta } from \"~/types.js\";\nimport type { FolderNotAuthorizedError, FolderPersistenceError } from \"~/domain/folder/errors.js\";\n\ninterface IListFoldersResult {\n    folders: Folder[];\n    meta: ListMeta;\n}\n\n/**\n * ListFolders repository interface\n */\nexport interface IListFoldersRepository {\n    execute(params: ListFoldersParams): Promise<Result<IListFoldersResult, RepositoryError>>;\n}\n\nexport interface IListFoldersRepositoryErrors {\n    persistence: FolderPersistenceError;\n}\n\ntype RepositoryError = IListFoldersRepositoryErrors[keyof IListFoldersRepositoryErrors];\n\nexport const ListFoldersRepository =\n    createAbstraction<IListFoldersRepository>(\"ListFoldersRepository\");\n\nexport namespace ListFoldersRepository {\n    export type Interface = IListFoldersRepository;\n    export type Return = Promise<Result<IListFoldersResult, RepositoryError>>;\n    export type Error = RepositoryError;\n}\n\n/**\n * ListFolders use case interface\n */\nexport interface IListFoldersUseCase {\n    execute(params: ListFoldersParams): Promise<Result<IListFoldersResult, UseCaseError>>;\n}\n\nexport interface IListFoldersUseCaseErrors {\n    notAuthorized: FolderNotAuthorizedError;\n    persistence: FolderPersistenceError;\n}\n\ntype UseCaseError = IListFoldersUseCaseErrors[keyof IListFoldersUseCaseErrors];\n\nexport const ListFoldersUseCase = createAbstraction<IListFoldersUseCase>(\"ListFoldersUseCase\");\n\nexport namespace ListFoldersUseCase {\n    export type Interface = IListFoldersUseCase;\n    export type Return = Promise<Result<IListFoldersResult, UseCaseError>>;\n    export type Error = UseCaseError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAWvD;AACA;AACA;;AAWA,OAAO,MAAMC,qBAAqB,GAC9BD,iBAAiB,CAAyB,uBAAuB,CAAC;;AAQtE;AACA;AACA;;AAYA,OAAO,MAAME,kBAAkB,GAAGF,iBAAiB,CAAsB,oBAAoB,CAAC","ignoreList":[]}

package/features/folder/ListFolders/decorators/ListFoldersWithFolderLevelPermissions.d.ts

@@ -0,0 +1,17 @@
+import type { ListFoldersParams } from "../../../../folder/folder.types.js";
+import { ListFoldersUseCase } from "../abstractions.js";
+import { FolderLevelPermissions } from "../../../../features/flp/FolderLevelPermissions/index.js";
+declare class ListFoldersWithFolderLevelPermissionsImpl implements ListFoldersUseCase.Interface {
+    private folderLevelPermissions;
+    private decoratee;
+    private flpCatalog;
+    constructor(folderLevelPermissions: FolderLevelPermissions.Interface, decoratee: ListFoldersUseCase.Interface);
+    execute(params: ListFoldersParams): ListFoldersUseCase.Return;
+    private hasFlp;
+    private getFlp;
+    private setFlp;
+}
+export declare const ListFoldersWithFolderLevelPermissions: typeof ListFoldersWithFolderLevelPermissionsImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions.js").IListFoldersUseCase>;
+};
+export {};

package/{folder/useCases/ListFolders → features/folder/ListFolders/decorators}/ListFoldersWithFolderLevelPermissions.js

@@ -1,24 +1,28 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ListFoldersWithFolderLevelPermissions = void 0;
-var _constants = require("../../../constants");
-class ListFoldersWithFolderLevelPermissions {
+import { Result } from "@webiny/feature/api";
+import { ListFoldersUseCase } from "../abstractions.js";
+import { FolderLevelPermissions } from "../../../flp/FolderLevelPermissions/index.js";
+import { ROOT_FOLDER } from "../../../../constants.js";
+class ListFoldersWithFolderLevelPermissionsImpl {
   flpCatalog = new Map();
-  constructor(folderLevelPermissions, decoretee) {
+  constructor(folderLevelPermissions, decoratee) {
     this.folderLevelPermissions = folderLevelPermissions;
-    this.decoretee = decoretee;
+    this.decoratee = decoratee;
   }
   async execute(params) {
-    const [folders, meta] = await this.decoretee.execute(params);
+    const result = await this.decoratee.execute(params);
+    if (result.isFail()) {
+      return Result.fail(result.error);
+    }
+    const {
+      folders,
+      meta
+    } = result.value;
 
     // Fetch FLP records for ROOT folders and populate the catalog.
     const rootFlps = await this.folderLevelPermissions.listFolderLevelPermissions({
       where: {
         type: params.where.type,
-        parentId: _constants.ROOT_FOLDER
+        parentId: ROOT_FOLDER
       }
     });
     rootFlps.forEach(flp => this.setFlp(flp.id, flp.permissions));
@@ -50,7 +54,10 @@ class ListFoldersWithFolderLevelPermissions {
       };
       return canAccessFolder ? folderWithFlp : null;
     }));
-    return [foldersWithPermissions.filter(Boolean), meta];
+    return Result.ok({
+      folders: foldersWithPermissions.filter(Boolean),
+      meta
+    });
   }
   hasFlp(id) {
     return this.flpCatalog.has(id);
@@ -62,6 +69,9 @@ class ListFoldersWithFolderLevelPermissions {
     this.flpCatalog.set(id, permissions);
   }
 }
-exports.ListFoldersWithFolderLevelPermissions = ListFoldersWithFolderLevelPermissions;
+export const ListFoldersWithFolderLevelPermissions = ListFoldersUseCase.createDecorator({
+  decorator: ListFoldersWithFolderLevelPermissionsImpl,
+  dependencies: [FolderLevelPermissions]
+});
 
 //# sourceMappingURL=ListFoldersWithFolderLevelPermissions.js.map

package/features/folder/ListFolders/decorators/ListFoldersWithFolderLevelPermissions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","ListFoldersUseCase","FolderLevelPermissions","ROOT_FOLDER","ListFoldersWithFolderLevelPermissionsImpl","flpCatalog","Map","constructor","folderLevelPermissions","decoratee","execute","params","result","isFail","fail","error","folders","meta","value","rootFlps","listFolderLevelPermissions","where","type","parentId","forEach","flp","setFlp","id","permissions","Promise","all","map","folder","hasFlp","getFolderLevelPermissions","foldersWithPermissions","getFlp","canAccessFolder","rwd","folderWithFlp","ok","filter","Boolean","has","get","set","ListFoldersWithFolderLevelPermissions","createDecorator","decorator","dependencies"],"sources":["ListFoldersWithFolderLevelPermissions.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport type { Folder, ListFoldersParams } from \"~/folder/folder.types.js\";\nimport { ListFoldersUseCase } from \"../abstractions.js\";\nimport { FolderLevelPermissions } from \"~/features/flp/FolderLevelPermissions/index.js\";\nimport type { FolderPermission } from \"~/flp/flp.types.js\";\nimport { ROOT_FOLDER } from \"~/constants.js\";\n\nclass ListFoldersWithFolderLevelPermissionsImpl implements ListFoldersUseCase.Interface {\n    private flpCatalog: Map<string, FolderPermission[]> = new Map();\n\n    constructor(\n        private folderLevelPermissions: FolderLevelPermissions.Interface,\n        private decoratee: ListFoldersUseCase.Interface\n    ) {}\n\n    async execute(params: ListFoldersParams): ListFoldersUseCase.Return {\n        const result = await this.decoratee.execute(params);\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        const { folders, meta } = result.value;\n\n        // Fetch FLP records for ROOT folders and populate the catalog.\n        const rootFlps = await this.folderLevelPermissions.listFolderLevelPermissions({\n            where: {\n                type: params.where.type,\n                parentId: ROOT_FOLDER\n            }\n        });\n\n        rootFlps.forEach(flp => this.setFlp(flp.id, flp.permissions));\n\n        // Fetch FLP for folders not already in the catalog.\n        await Promise.all(\n            folders.map(async folder => {\n                if (!this.hasFlp(folder.id)) {\n                    const permissions = await this.folderLevelPermissions.getFolderLevelPermissions(\n                        folder.id\n                    );\n                    this.setFlp(folder.id, permissions);\n                }\n            })\n        );\n\n        // Filter folders based on permissions.\n        const foldersWithPermissions = await Promise.all(\n            folders.map(async folder => {\n                const permissions = this.getFlp(folder.id);\n                if (!permissions) {\n                    return null;\n                }\n\n                const canAccessFolder = await this.folderLevelPermissions.canAccessFolder({\n                    permissions,\n                    rwd: \"r\"\n                });\n\n                if (!canAccessFolder) {\n                    return null;\n                }\n\n                const folderWithFlp = { ...folder, permissions };\n                return canAccessFolder ? folderWithFlp : null;\n            })\n        );\n\n        return Result.ok({ folders: foldersWithPermissions.filter(Boolean) as Folder[], meta });\n    }\n\n    private hasFlp(id: string): boolean {\n        return this.flpCatalog.has(id);\n    }\n\n    private getFlp(id: string): FolderPermission[] | undefined {\n        return this.flpCatalog.get(id);\n    }\n\n    private setFlp(id: string, permissions: FolderPermission[]): void {\n        this.flpCatalog.set(id, permissions);\n    }\n}\n\nexport const ListFoldersWithFolderLevelPermissions = ListFoldersUseCase.createDecorator({\n    decorator: ListFoldersWithFolderLevelPermissionsImpl,\n    dependencies: [FolderLevelPermissions]\n});\n"],"mappings":"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","ignoreList":[]}

package/features/folder/ListFolders/feature.d.ts

@@ -0,0 +1 @@
+export declare const ListFoldersFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/folder/ListFolders/feature.js

@@ -0,0 +1,14 @@
+import { createFeature } from "@webiny/feature/api";
+import { ListFoldersRepository } from "./ListFoldersRepository.js";
+import { ListFoldersUseCase } from "./ListFoldersUseCase.js";
+import { ListFoldersWithFolderLevelPermissions } from "./decorators/ListFoldersWithFolderLevelPermissions.js";
+export const ListFoldersFeature = createFeature({
+  name: "ListFolders",
+  register(container) {
+    container.register(ListFoldersRepository).inSingletonScope();
+    container.register(ListFoldersUseCase);
+    container.registerDecorator(ListFoldersWithFolderLevelPermissions);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

package/features/folder/ListFolders/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","ListFoldersRepository","ListFoldersUseCase","ListFoldersWithFolderLevelPermissions","ListFoldersFeature","name","register","container","inSingletonScope","registerDecorator"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport type { Container } from \"@webiny/di\";\nimport { ListFoldersRepository } from \"./ListFoldersRepository.js\";\nimport { ListFoldersUseCase } from \"./ListFoldersUseCase.js\";\nimport { ListFoldersWithFolderLevelPermissions } from \"./decorators/ListFoldersWithFolderLevelPermissions.js\";\n\nexport const ListFoldersFeature = createFeature({\n    name: \"ListFolders\",\n    register(container: Container) {\n        container.register(ListFoldersRepository).inSingletonScope();\n        container.register(ListFoldersUseCase);\n        container.registerDecorator(ListFoldersWithFolderLevelPermissions);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AAEnD,SAASC,qBAAqB;AAC9B,SAASC,kBAAkB;AAC3B,SAASC,qCAAqC;AAE9C,OAAO,MAAMC,kBAAkB,GAAGJ,aAAa,CAAC;EAC5CK,IAAI,EAAE,aAAa;EACnBC,QAAQA,CAACC,SAAoB,EAAE;IAC3BA,SAAS,CAACD,QAAQ,CAACL,qBAAqB,CAAC,CAACO,gBAAgB,CAAC,CAAC;IAC5DD,SAAS,CAACD,QAAQ,CAACJ,kBAAkB,CAAC;IACtCK,SAAS,CAACE,iBAAiB,CAACN,qCAAqC,CAAC;EACtE;AACJ,CAAC,CAAC","ignoreList":[]}

package/features/folder/ListFolders/index.d.ts

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

package/features/folder/ListFolders/index.js

@@ -0,0 +1,4 @@
+export { ListFoldersFeature } from "./feature.js";
+export { ListFoldersUseCase } from "./abstractions.js";
+
+//# sourceMappingURL=index.js.map

package/features/folder/ListFolders/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ListFoldersFeature","ListFoldersUseCase"],"sources":["index.ts"],"sourcesContent":["export { ListFoldersFeature } from \"./feature.js\";\nexport { ListFoldersUseCase } from \"./abstractions.js\";\n"],"mappings":"AAAA,SAASA,kBAAkB;AAC3B,SAASC,kBAAkB","ignoreList":[]}

package/features/folder/UpdateFolder/UpdateFolderRepository.d.ts

@@ -0,0 +1,21 @@
+import { Result } from "@webiny/feature/api";
+import { type IUpdateFolderRepository, UpdateFolderRepository as RepositoryAbstraction } from "./abstractions.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
+import { FolderModel } from "../../../domain/folder/abstractions.js";
+import type { Folder, UpdateFolderParams } from "../../../folder/folder.types.js";
+declare class UpdateFolderRepositoryImpl implements IUpdateFolderRepository {
+    private updateEntry;
+    private getEntryById;
+    private listLatestEntries;
+    private folderModel;
+    constructor(updateEntry: UpdateEntryUseCase.Interface, getEntryById: GetEntryByIdUseCase.Interface, listLatestEntries: ListLatestEntriesUseCase.Interface, folderModel: FolderModel.Interface);
+    execute(id: string, data: UpdateFolderParams): Promise<Result<Folder, RepositoryAbstraction.Error>>;
+    private checkExistingFolder;
+    private createFolderPath;
+}
+export declare const UpdateFolderRepository: typeof UpdateFolderRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IUpdateFolderRepository>;
+};
+export {};

package/features/folder/UpdateFolder/UpdateFolderRepository.js

@@ -0,0 +1,110 @@
+import { Result } from "@webiny/feature/api";
+import { UpdateFolderRepository as RepositoryAbstraction } from "./abstractions.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
+import { FolderModel } from "../../../domain/folder/abstractions.js";
+import { EntryToFolderMapper } from "../shared/EntryToFolderMapper.js";
+import { FolderPersistenceError, FolderValidationError } from "../../../domain/folder/errors.js";
+import { Path } from "../../../utils/Path.js";
+import { EntryId } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+class UpdateFolderRepositoryImpl {
+  constructor(updateEntry, getEntryById, listLatestEntries, folderModel) {
+    this.updateEntry = updateEntry;
+    this.getEntryById = getEntryById;
+    this.listLatestEntries = listLatestEntries;
+    this.folderModel = folderModel;
+  }
+  async execute(id, data) {
+    const entryId = EntryId.from(id);
+
+    // Get the original folder
+    const originalResult = await this.getEntryById.execute(this.folderModel, entryId.toString());
+    if (originalResult.isFail()) {
+      return Result.fail(new FolderPersistenceError(originalResult.error));
+    }
+    const original = EntryToFolderMapper.toFolder(originalResult.value);
+
+    // Check if folder with new slug already exists
+    const checkResult = await this.checkExistingFolder({
+      id,
+      type: original.type,
+      slug: data.slug || original.slug,
+      parentId: data.parentId !== undefined ? data.parentId : original.parentId
+    });
+    if (checkResult.isFail()) {
+      return Result.fail(checkResult.error);
+    }
+
+    // Create new path if slug or parentId changed
+    const pathResult = await this.createFolderPath({
+      slug: data.slug || original.slug,
+      parentId: data.parentId !== undefined ? data.parentId : original.parentId
+    });
+    if (pathResult.isFail()) {
+      return Result.fail(pathResult.error);
+    }
+    const result = await this.updateEntry.execute(this.folderModel, entryId.toString(), {
+      values: {
+        ...data,
+        path: pathResult.value
+      }
+    });
+    if (result.isFail()) {
+      return Result.fail(new FolderPersistenceError(result.error));
+    }
+    const updatedFolder = EntryToFolderMapper.toFolder(result.value);
+    return Result.ok(updatedFolder);
+  }
+  async checkExistingFolder(params) {
+    const {
+      id,
+      type,
+      slug,
+      parentId
+    } = params;
+    const result = await this.listLatestEntries.execute(this.folderModel, {
+      where: {
+        latest: true,
+        entryId_not: id,
+        values: {
+          type,
+          slug,
+          parentId
+        }
+      },
+      limit: 1
+    });
+    if (result.isFail()) {
+      return Result.fail(new FolderPersistenceError(result.error));
+    }
+    const {
+      entries
+    } = result.value;
+    if (entries.length > 0) {
+      return Result.fail(new FolderValidationError(`Folder with slug "${slug}" already exists at this level.`));
+    }
+    return Result.ok();
+  }
+  async createFolderPath(params) {
+    const {
+      slug,
+      parentId
+    } = params;
+    if (!parentId) {
+      return Result.ok(Path.create(slug));
+    }
+    const parentResult = await this.getEntryById.execute(this.folderModel, EntryId.from(parentId).toString());
+    if (parentResult.isFail()) {
+      return Result.fail(new FolderPersistenceError(new Error("Parent folder not found. Unable to create the folder path")));
+    }
+    const parentFolder = EntryToFolderMapper.toFolder(parentResult.value);
+    return Result.ok(Path.create(slug, parentFolder.path));
+  }
+}
+export const UpdateFolderRepository = RepositoryAbstraction.createImplementation({
+  implementation: UpdateFolderRepositoryImpl,
+  dependencies: [UpdateEntryUseCase, GetEntryByIdUseCase, ListLatestEntriesUseCase, FolderModel]
+});
+
+//# sourceMappingURL=UpdateFolderRepository.js.map

package/features/folder/UpdateFolder/UpdateFolderRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Result","UpdateFolderRepository","RepositoryAbstraction","UpdateEntryUseCase","GetEntryByIdUseCase","ListLatestEntriesUseCase","FolderModel","EntryToFolderMapper","FolderPersistenceError","FolderValidationError","Path","EntryId","UpdateFolderRepositoryImpl","constructor","updateEntry","getEntryById","listLatestEntries","folderModel","execute","id","data","entryId","from","originalResult","toString","isFail","fail","error","original","toFolder","value","checkResult","checkExistingFolder","type","slug","parentId","undefined","pathResult","createFolderPath","result","values","path","updatedFolder","ok","params","where","latest","entryId_not","limit","entries","length","create","parentResult","Error","parentFolder","createImplementation","implementation","dependencies"],"sources":["UpdateFolderRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    type IUpdateFolderRepository,\n    UpdateFolderRepository as RepositoryAbstraction\n} from \"./abstractions.js\";\nimport { UpdateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries\";\nimport { FolderModel } from \"~/domain/folder/abstractions.js\";\nimport type { CmsEntryFolder, Folder, UpdateFolderParams } from \"~/folder/folder.types.js\";\nimport { EntryToFolderMapper } from \"../shared/EntryToFolderMapper.js\";\nimport { FolderPersistenceError, FolderValidationError } from \"~/domain/folder/errors.js\";\nimport { Path } from \"~/utils/Path.js\";\nimport { EntryId } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\n\nclass UpdateFolderRepositoryImpl implements IUpdateFolderRepository {\n    constructor(\n        private updateEntry: UpdateEntryUseCase.Interface,\n        private getEntryById: GetEntryByIdUseCase.Interface,\n        private listLatestEntries: ListLatestEntriesUseCase.Interface,\n        private folderModel: FolderModel.Interface\n    ) {}\n\n    async execute(\n        id: string,\n        data: UpdateFolderParams\n    ): Promise<Result<Folder, RepositoryAbstraction.Error>> {\n        const entryId = EntryId.from(id);\n\n        // Get the original folder\n        const originalResult = await this.getEntryById.execute<CmsEntryFolder>(\n            this.folderModel,\n            entryId.toString()\n        );\n\n        if (originalResult.isFail()) {\n            return Result.fail(new FolderPersistenceError(originalResult.error));\n        }\n\n        const original = EntryToFolderMapper.toFolder(originalResult.value);\n\n        // Check if folder with new slug already exists\n        const checkResult = await this.checkExistingFolder({\n            id,\n            type: original.type,\n            slug: data.slug || original.slug,\n            parentId: data.parentId !== undefined ? data.parentId : original.parentId\n        });\n\n        if (checkResult.isFail()) {\n            return Result.fail(checkResult.error);\n        }\n\n        // Create new path if slug or parentId changed\n        const pathResult = await this.createFolderPath({\n            slug: data.slug || original.slug,\n            parentId: data.parentId !== undefined ? data.parentId : original.parentId\n        });\n\n        if (pathResult.isFail()) {\n            return Result.fail(pathResult.error);\n        }\n\n        const result = await this.updateEntry.execute<CmsEntryFolder>(\n            this.folderModel,\n            entryId.toString(),\n            {\n                values: {\n                    ...data,\n                    path: pathResult.value\n                }\n            }\n        );\n\n        if (result.isFail()) {\n            return Result.fail(new FolderPersistenceError(result.error));\n        }\n\n        const updatedFolder = EntryToFolderMapper.toFolder(result.value);\n        return Result.ok(updatedFolder);\n    }\n\n    private async checkExistingFolder(params: {\n        id: string;\n        type: string;\n        slug: string;\n        parentId?: string | null;\n    }): Promise<Result<void, RepositoryAbstraction.Error>> {\n        const { id, type, slug, parentId } = params;\n\n        const result = await this.listLatestEntries.execute<CmsEntryFolder>(this.folderModel, {\n            where: {\n                latest: true,\n                entryId_not: id,\n                values: {\n                    type,\n                    slug,\n                    parentId\n                }\n            },\n            limit: 1\n        });\n\n        if (result.isFail()) {\n            return Result.fail(new FolderPersistenceError(result.error));\n        }\n\n        const { entries } = result.value;\n\n        if (entries.length > 0) {\n            return Result.fail(\n                new FolderValidationError(\n                    `Folder with slug \"${slug}\" already exists at this level.`\n                )\n            );\n        }\n\n        return Result.ok();\n    }\n\n    private async createFolderPath(params: {\n        slug: string;\n        parentId?: string | null;\n    }): Promise<Result<string, RepositoryAbstraction.Error>> {\n        const { slug, parentId } = params;\n\n        if (!parentId) {\n            return Result.ok(Path.create(slug));\n        }\n\n        const parentResult = await this.getEntryById.execute<CmsEntryFolder>(\n            this.folderModel,\n            EntryId.from(parentId).toString()\n        );\n\n        if (parentResult.isFail()) {\n            return Result.fail(\n                new FolderPersistenceError(\n                    new Error(\"Parent folder not found. Unable to create the folder path\")\n                )\n            );\n        }\n\n        const parentFolder = EntryToFolderMapper.toFolder(parentResult.value);\n        return Result.ok(Path.create(slug, parentFolder.path));\n    }\n}\n\nexport const UpdateFolderRepository = RepositoryAbstraction.createImplementation({\n    implementation: UpdateFolderRepositoryImpl,\n    dependencies: [UpdateEntryUseCase, GetEntryByIdUseCase, ListLatestEntriesUseCase, FolderModel]\n});\n"],"mappings":"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","ignoreList":[]}

package/features/folder/UpdateFolder/UpdateFolderUseCase.d.ts

@@ -0,0 +1,14 @@
+import { Result } from "@webiny/feature/api";
+import { EventPublisher as EventPublisherAbstraction } from "@webiny/api-core/features/EventPublisher";
+import { UpdateFolderRepository, UpdateFolderUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { GetFolderRepository } from "../GetFolder/abstractions.js";
+import type { Folder, UpdateFolderParams } from "../../../folder/folder.types.js";
+declare class UpdateFolderUseCaseImpl implements UseCaseAbstraction.Interface {
+    private eventPublisher;
+    private getFolderRepository;
+    private repository;
+    constructor(eventPublisher: EventPublisherAbstraction.Interface, getFolderRepository: GetFolderRepository.Interface, repository: UpdateFolderRepository.Interface);
+    execute(id: string, input: UpdateFolderParams): Promise<Result<Folder, UseCaseAbstraction.Error>>;
+}
+export declare const UpdateFolderUseCase: import("@webiny/di").Implementation<typeof UpdateFolderUseCaseImpl>;
+export {};

package/features/folder/UpdateFolder/UpdateFolderUseCase.js

@@ -0,0 +1,55 @@
+import { createImplementation, Result } from "@webiny/feature/api";
+import { EventPublisher } from "@webiny/api-core/features/EventPublisher";
+import { UpdateFolderRepository, UpdateFolderUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { GetFolderRepository } from "../GetFolder/abstractions.js";
+import { FolderAfterUpdateEvent, FolderBeforeUpdateEvent } from "./events.js";
+class UpdateFolderUseCaseImpl {
+  constructor(eventPublisher, getFolderRepository, repository) {
+    this.eventPublisher = eventPublisher;
+    this.getFolderRepository = getFolderRepository;
+    this.repository = repository;
+  }
+  async execute(id, input) {
+    const useCaseInput = {
+      id,
+      data: input
+    };
+
+    // Get original folder for events
+    const originalResult = await this.getFolderRepository.execute(id);
+    if (originalResult.isFail()) {
+      return originalResult;
+    }
+    const original = originalResult.value;
+
+    // Publish before update event
+    const beforeUpdateEvent = new FolderBeforeUpdateEvent({
+      original,
+      input: useCaseInput
+    });
+    await this.eventPublisher.publish(beforeUpdateEvent);
+
+    // Execute the update operation
+    const result = await this.repository.execute(id, input);
+    if (result.isFail()) {
+      return result;
+    }
+    const folder = result.value;
+
+    // Publish after update event
+    const afterUpdateEvent = new FolderAfterUpdateEvent({
+      original,
+      folder,
+      input: useCaseInput
+    });
+    await this.eventPublisher.publish(afterUpdateEvent);
+    return Result.ok(folder);
+  }
+}
+export const UpdateFolderUseCase = createImplementation({
+  abstraction: UseCaseAbstraction,
+  implementation: UpdateFolderUseCaseImpl,
+  dependencies: [EventPublisher, GetFolderRepository, UpdateFolderRepository]
+});
+
+//# sourceMappingURL=UpdateFolderUseCase.js.map

package/features/folder/UpdateFolder/UpdateFolderUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createImplementation","Result","EventPublisher","UpdateFolderRepository","UpdateFolderUseCase","UseCaseAbstraction","GetFolderRepository","FolderAfterUpdateEvent","FolderBeforeUpdateEvent","UpdateFolderUseCaseImpl","constructor","eventPublisher","getFolderRepository","repository","execute","id","input","useCaseInput","data","originalResult","isFail","original","value","beforeUpdateEvent","publish","result","folder","afterUpdateEvent","ok","abstraction","implementation","dependencies"],"sources":["UpdateFolderUseCase.ts"],"sourcesContent":["import { createImplementation, Result } from \"@webiny/feature/api\";\nimport {\n    EventPublisher,\n    EventPublisher as EventPublisherAbstraction\n} from \"@webiny/api-core/features/EventPublisher\";\nimport {\n    UpdateFolderRepository,\n    UpdateFolderUseCase as UseCaseAbstraction\n} from \"./abstractions.js\";\nimport { GetFolderRepository } from \"../GetFolder/abstractions.js\";\nimport { FolderAfterUpdateEvent, FolderBeforeUpdateEvent } from \"./events.js\";\nimport type { Folder, UpdateFolderParams } from \"~/folder/folder.types.js\";\n\nclass UpdateFolderUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private eventPublisher: EventPublisherAbstraction.Interface,\n        private getFolderRepository: GetFolderRepository.Interface,\n        private repository: UpdateFolderRepository.Interface\n    ) {}\n\n    async execute(\n        id: string,\n        input: UpdateFolderParams\n    ): Promise<Result<Folder, UseCaseAbstraction.Error>> {\n        const useCaseInput = { id, data: input };\n\n        // Get original folder for events\n        const originalResult = await this.getFolderRepository.execute(id);\n\n        if (originalResult.isFail()) {\n            return originalResult;\n        }\n\n        const original = originalResult.value;\n\n        // Publish before update event\n        const beforeUpdateEvent = new FolderBeforeUpdateEvent({\n            original,\n            input: useCaseInput\n        });\n\n        await this.eventPublisher.publish(beforeUpdateEvent);\n\n        // Execute the update operation\n        const result = await this.repository.execute(id, input);\n\n        if (result.isFail()) {\n            return result;\n        }\n\n        const folder = result.value;\n\n        // Publish after update event\n        const afterUpdateEvent = new FolderAfterUpdateEvent({\n            original,\n            folder,\n            input: useCaseInput\n        });\n\n        await this.eventPublisher.publish(afterUpdateEvent);\n\n        return Result.ok(folder);\n    }\n}\n\nexport const UpdateFolderUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: UpdateFolderUseCaseImpl,\n    dependencies: [EventPublisher, GetFolderRepository, UpdateFolderRepository]\n});\n"],"mappings":"AAAA,SAASA,oBAAoB,EAAEC,MAAM,QAAQ,qBAAqB;AAClE,SACIC,cAAc,QAEX,0CAA0C;AACjD,SACIC,sBAAsB,EACtBC,mBAAmB,IAAIC,kBAAkB;AAE7C,SAASC,mBAAmB;AAC5B,SAASC,sBAAsB,EAAEC,uBAAuB;AAGxD,MAAMC,uBAAuB,CAAyC;EAClEC,WAAWA,CACCC,cAAmD,EACnDC,mBAAkD,EAClDC,UAA4C,EACtD;IAAA,KAHUF,cAAmD,GAAnDA,cAAmD;IAAA,KACnDC,mBAAkD,GAAlDA,mBAAkD;IAAA,KAClDC,UAA4C,GAA5CA,UAA4C;EACrD;EAEH,MAAMC,OAAOA,CACTC,EAAU,EACVC,KAAyB,EACwB;IACjD,MAAMC,YAAY,GAAG;MAAEF,EAAE;MAAEG,IAAI,EAAEF;IAAM,CAAC;;IAExC;IACA,MAAMG,cAAc,GAAG,MAAM,IAAI,CAACP,mBAAmB,CAACE,OAAO,CAACC,EAAE,CAAC;IAEjE,IAAII,cAAc,CAACC,MAAM,CAAC,CAAC,EAAE;MACzB,OAAOD,cAAc;IACzB;IAEA,MAAME,QAAQ,GAAGF,cAAc,CAACG,KAAK;;IAErC;IACA,MAAMC,iBAAiB,GAAG,IAAIf,uBAAuB,CAAC;MAClDa,QAAQ;MACRL,KAAK,EAAEC;IACX,CAAC,CAAC;IAEF,MAAM,IAAI,CAACN,cAAc,CAACa,OAAO,CAACD,iBAAiB,CAAC;;IAEpD;IACA,MAAME,MAAM,GAAG,MAAM,IAAI,CAACZ,UAAU,CAACC,OAAO,CAACC,EAAE,EAAEC,KAAK,CAAC;IAEvD,IAAIS,MAAM,CAACL,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOK,MAAM;IACjB;IAEA,MAAMC,MAAM,GAAGD,MAAM,CAACH,KAAK;;IAE3B;IACA,MAAMK,gBAAgB,GAAG,IAAIpB,sBAAsB,CAAC;MAChDc,QAAQ;MACRK,MAAM;MACNV,KAAK,EAAEC;IACX,CAAC,CAAC;IAEF,MAAM,IAAI,CAACN,cAAc,CAACa,OAAO,CAACG,gBAAgB,CAAC;IAEnD,OAAO1B,MAAM,CAAC2B,EAAE,CAACF,MAAM,CAAC;EAC5B;AACJ;AAEA,OAAO,MAAMtB,mBAAmB,GAAGJ,oBAAoB,CAAC;EACpD6B,WAAW,EAAExB,kBAAkB;EAC/ByB,cAAc,EAAErB,uBAAuB;EACvCsB,YAAY,EAAE,CAAC7B,cAAc,EAAEI,mBAAmB,EAAEH,sBAAsB;AAC9E,CAAC,CAAC","ignoreList":[]}

package/features/folder/UpdateFolder/abstractions.d.ts

@@ -0,0 +1,60 @@
+import type { Result } from "@webiny/feature/api";
+import type { DomainEvent, IEventHandler } from "@webiny/api-core/features/EventPublisher";
+import type { Folder, UpdateFolderParams } from "../../../folder/folder.types.js";
+import { FolderCannotMoveToNewParent, type FolderNotAuthorizedError, type FolderNotFoundError, type FolderPersistenceError, type FolderValidationError } from "../../../domain/folder/errors.js";
+/**
+ * UpdateFolder repository interface
+ */
+export interface IUpdateFolderRepository {
+    execute(id: string, data: UpdateFolderParams): Promise<Result<Folder, RepositoryError>>;
+}
+export interface IUpdateFolderRepositoryErrors {
+    persistence: FolderPersistenceError;
+    validation: FolderValidationError;
+}
+type RepositoryError = IUpdateFolderRepositoryErrors[keyof IUpdateFolderRepositoryErrors];
+export declare const UpdateFolderRepository: import("@webiny/di").Abstraction<IUpdateFolderRepository>;
+export declare namespace UpdateFolderRepository {
+    type Interface = IUpdateFolderRepository;
+    type Error = RepositoryError;
+}
+/**
+ * UpdateFolder use case interface
+ */
+export interface IUpdateFolderUseCase {
+    execute(id: string, data: UpdateFolderParams): Promise<Result<Folder, UseCaseError>>;
+}
+export interface IUpdateFolderUseCaseErrors {
+    notAuthorized: FolderNotAuthorizedError;
+    notFound: FolderNotFoundError;
+    cannotMoveToNewParent: FolderCannotMoveToNewParent;
+    persistence: FolderPersistenceError;
+    validation: FolderValidationError;
+}
+type UseCaseError = IUpdateFolderUseCaseErrors[keyof IUpdateFolderUseCaseErrors];
+export declare const UpdateFolderUseCase: import("@webiny/di").Abstraction<IUpdateFolderUseCase>;
+export declare namespace UpdateFolderUseCase {
+    type Interface = IUpdateFolderUseCase;
+    type Return = Promise<Result<Folder, UseCaseError>>;
+    type Error = UseCaseError;
+}
+export interface FolderBeforeUpdatePayload {
+    original: Folder;
+    input: Record<string, any>;
+}
+export interface FolderAfterUpdatePayload {
+    original: Folder;
+    folder: Folder;
+    input: Record<string, any>;
+}
+export declare const FolderBeforeUpdateHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<FolderBeforeUpdatePayload>>>;
+export declare namespace FolderBeforeUpdateHandler {
+    type Interface = IEventHandler<DomainEvent<FolderBeforeUpdatePayload>>;
+    type Event = DomainEvent<FolderBeforeUpdatePayload>;
+}
+export declare const FolderAfterUpdateHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<FolderAfterUpdatePayload>>>;
+export declare namespace FolderAfterUpdateHandler {
+    type Interface = IEventHandler<DomainEvent<FolderAfterUpdatePayload>>;
+    type Event = DomainEvent<FolderAfterUpdatePayload>;
+}
+export {};

package/features/folder/UpdateFolder/abstractions.js

@@ -0,0 +1,21 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * UpdateFolder repository interface
+ */
+
+export const UpdateFolderRepository = createAbstraction("UpdateFolderRepository");
+
+/**
+ * UpdateFolder use case interface
+ */
+
+export const UpdateFolderUseCase = createAbstraction("UpdateFolderUseCase");
+
+// Event Payload Types
+
+// Event Handler Abstractions
+export const FolderBeforeUpdateHandler = createAbstraction("FolderBeforeUpdateHandler");
+export const FolderAfterUpdateHandler = createAbstraction("FolderAfterUpdateHandler");
+
+//# sourceMappingURL=abstractions.js.map

package/features/folder/UpdateFolder/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","UpdateFolderRepository","UpdateFolderUseCase","FolderBeforeUpdateHandler","FolderAfterUpdateHandler"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { DomainEvent, IEventHandler } from \"@webiny/api-core/features/EventPublisher\";\nimport type { Folder, UpdateFolderParams } from \"~/folder/folder.types.js\";\nimport {\n    FolderCannotMoveToNewParent,\n    type FolderNotAuthorizedError,\n    type FolderNotFoundError,\n    type FolderPersistenceError,\n    type FolderValidationError\n} from \"~/domain/folder/errors.js\";\n\n/**\n * UpdateFolder repository interface\n */\nexport interface IUpdateFolderRepository {\n    execute(id: string, data: UpdateFolderParams): Promise<Result<Folder, RepositoryError>>;\n}\n\nexport interface IUpdateFolderRepositoryErrors {\n    persistence: FolderPersistenceError;\n    validation: FolderValidationError;\n}\n\ntype RepositoryError = IUpdateFolderRepositoryErrors[keyof IUpdateFolderRepositoryErrors];\n\nexport const UpdateFolderRepository =\n    createAbstraction<IUpdateFolderRepository>(\"UpdateFolderRepository\");\n\nexport namespace UpdateFolderRepository {\n    export type Interface = IUpdateFolderRepository;\n    export type Error = RepositoryError;\n}\n\n/**\n * UpdateFolder use case interface\n */\nexport interface IUpdateFolderUseCase {\n    execute(id: string, data: UpdateFolderParams): Promise<Result<Folder, UseCaseError>>;\n}\n\nexport interface IUpdateFolderUseCaseErrors {\n    notAuthorized: FolderNotAuthorizedError;\n    notFound: FolderNotFoundError;\n    cannotMoveToNewParent: FolderCannotMoveToNewParent;\n    persistence: FolderPersistenceError;\n    validation: FolderValidationError;\n}\n\ntype UseCaseError = IUpdateFolderUseCaseErrors[keyof IUpdateFolderUseCaseErrors];\n\nexport const UpdateFolderUseCase = createAbstraction<IUpdateFolderUseCase>(\"UpdateFolderUseCase\");\n\nexport namespace UpdateFolderUseCase {\n    export type Interface = IUpdateFolderUseCase;\n    export type Return = Promise<Result<Folder, UseCaseError>>;\n    export type Error = UseCaseError;\n}\n\n// Event Payload Types\nexport interface FolderBeforeUpdatePayload {\n    original: Folder;\n    input: Record<string, any>;\n}\n\nexport interface FolderAfterUpdatePayload {\n    original: Folder;\n    folder: Folder;\n    input: Record<string, any>;\n}\n\n// Event Handler Abstractions\nexport const FolderBeforeUpdateHandler = createAbstraction<\n    IEventHandler<DomainEvent<FolderBeforeUpdatePayload>>\n>(\"FolderBeforeUpdateHandler\");\n\nexport namespace FolderBeforeUpdateHandler {\n    export type Interface = IEventHandler<DomainEvent<FolderBeforeUpdatePayload>>;\n    export type Event = DomainEvent<FolderBeforeUpdatePayload>;\n}\n\nexport const FolderAfterUpdateHandler = createAbstraction<\n    IEventHandler<DomainEvent<FolderAfterUpdatePayload>>\n>(\"FolderAfterUpdateHandler\");\n\nexport namespace FolderAfterUpdateHandler {\n    export type Interface = IEventHandler<DomainEvent<FolderAfterUpdatePayload>>;\n    export type Event = DomainEvent<FolderAfterUpdatePayload>;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAYvD;AACA;AACA;;AAYA,OAAO,MAAMC,sBAAsB,GAC/BD,iBAAiB,CAA0B,wBAAwB,CAAC;;AAOxE;AACA;AACA;;AAeA,OAAO,MAAME,mBAAmB,GAAGF,iBAAiB,CAAuB,qBAAqB,CAAC;;AAQjG;;AAYA;AACA,OAAO,MAAMG,yBAAyB,GAAGH,iBAAiB,CAExD,2BAA2B,CAAC;AAO9B,OAAO,MAAMI,wBAAwB,GAAGJ,iBAAiB,CAEvD,0BAA0B,CAAC","ignoreList":[]}

package/features/folder/UpdateFolder/decorators/UpdateFolderWithFolderLevelPermissions.d.ts

@@ -0,0 +1,13 @@
+import type { UpdateFolderParams } from "../../../../folder/folder.types.js";
+import { FolderLevelPermissions } from "../../../../features/flp/FolderLevelPermissions/index.js";
+import { UpdateFolderUseCase } from "../abstractions.js";
+import { GetFolderUseCase } from "../../../../features/folder/GetFolder/index.js";
+declare class UpdateFolderWithFolderLevelPermissionsImpl implements UpdateFolderUseCase.Interface {
+    private getFolder;
+    private folderLevelPermissions;
+    private readonly decoretee;
+    constructor(getFolder: GetFolderUseCase.Interface, folderLevelPermissions: FolderLevelPermissions.Interface, decoretee: UpdateFolderUseCase.Interface);
+    execute(id: string, params: UpdateFolderParams): UpdateFolderUseCase.Return;
+}
+export declare const UpdateFolderWithFolderLevelPermissions: typeof UpdateFolderWithFolderLevelPermissionsImpl;
+export {};