@webiny/api-aco 6.3.0-beta.4 → 6.4.0-beta.0

package/features/folder/ListFolders/ListFoldersRepository.js

@@ -1,5 +1,5 @@
 import { Result } from "@webiny/feature/api";
-import { ListFoldersRepository as RepositoryAbstraction } from "./abstractions.js";
+import { ListFoldersRepository } from "./abstractions.js";
 import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
 import { FolderModel } from "../../../domain/folder/abstractions.js";
 import { EntryToFolderMapper } from "../shared/EntryToFolderMapper.js";
@@ -7,48 +7,46 @@ import { FolderPersistenceError } from "../../../domain/folder/errors.js";
 import { createListSort } from "../../../utils/createListSort.js";
 import { CmsSortMapper, CmsWhereMapper } from "@webiny/api-headless-cms";
 class ListFoldersRepositoryImpl {
-  constructor(listLatestEntries, folderModel, cmsWhereMapper, cmsSortMapper) {
-    this.listLatestEntries = listLatestEntries;
-    this.folderModel = folderModel;
-    this.cmsWhereMapper = cmsWhereMapper;
-    this.cmsSortMapper = cmsSortMapper;
-  }
-  async execute(params) {
-    const {
-      sort,
-      where
-    } = params;
-    const listSort = sort || {
-      values_title: "ASC"
-    };
-    const result = await this.listLatestEntries.execute(this.folderModel, {
-      ...params,
-      sort: this.cmsSortMapper.map({
-        input: createListSort(listSort),
-        fields: this.folderModel.fields
-      }),
-      where: this.cmsWhereMapper.map({
-        input: where,
-        fields: this.folderModel.fields
-      })
-    });
-    if (result.isFail()) {
-      return Result.fail(new FolderPersistenceError(result.error));
+    constructor(listLatestEntries, folderModel, cmsWhereMapper, cmsSortMapper){
+        this.listLatestEntries = listLatestEntries;
+        this.folderModel = folderModel;
+        this.cmsWhereMapper = cmsWhereMapper;
+        this.cmsSortMapper = cmsSortMapper;
+    }
+    async execute(params) {
+        const { sort, where } = params;
+        const listSort = sort || {
+            values_title: "ASC"
+        };
+        const result = await this.listLatestEntries.execute(this.folderModel, {
+            ...params,
+            sort: this.cmsSortMapper.map({
+                input: createListSort(listSort),
+                fields: this.folderModel.fields
+            }),
+            where: this.cmsWhereMapper.map({
+                input: where,
+                fields: this.folderModel.fields
+            })
+        });
+        if (result.isFail()) return Result.fail(new FolderPersistenceError(result.error));
+        const { entries, meta } = result.value;
+        const folders = entries.map((entry)=>EntryToFolderMapper.toFolder(entry));
+        return Result.ok({
+            folders,
+            meta
+        });
     }
-    const {
-      entries,
-      meta
-    } = result.value;
-    const folders = entries.map(entry => EntryToFolderMapper.toFolder(entry));
-    return Result.ok({
-      folders,
-      meta
-    });
-  }
 }
-export const ListFoldersRepository = RepositoryAbstraction.createImplementation({
-  implementation: ListFoldersRepositoryImpl,
-  dependencies: [ListLatestEntriesUseCase, FolderModel, CmsWhereMapper, CmsSortMapper]
+const ListFoldersRepository_ListFoldersRepository = ListFoldersRepository.createImplementation({
+    implementation: ListFoldersRepositoryImpl,
+    dependencies: [
+        ListLatestEntriesUseCase,
+        FolderModel,
+        CmsWhereMapper,
+        CmsSortMapper
+    ]
 });
+export { ListFoldersRepository_ListFoldersRepository as ListFoldersRepository };
 
 //# sourceMappingURL=ListFoldersRepository.js.map

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

@@ -1 +1 @@
-{"version":3,"names":["Result","ListFoldersRepository","RepositoryAbstraction","ListLatestEntriesUseCase","FolderModel","EntryToFolderMapper","FolderPersistenceError","createListSort","CmsSortMapper","CmsWhereMapper","ListFoldersRepositoryImpl","constructor","listLatestEntries","folderModel","cmsWhereMapper","cmsSortMapper","execute","params","sort","where","listSort","values_title","result","map","input","fields","isFail","fail","error","entries","meta","value","folders","entry","toFolder","ok","createImplementation","implementation","dependencies"],"sources":["ListFoldersRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    type IListFoldersRepository,\n    ListFoldersRepository as RepositoryAbstraction\n} from \"./abstractions.js\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries\";\nimport { FolderModel } from \"~/domain/folder/abstractions.js\";\nimport type { CmsEntryFolder, ListFoldersParams } from \"~/folder/folder.types.js\";\nimport { EntryToFolderMapper } from \"../shared/EntryToFolderMapper.js\";\nimport { FolderPersistenceError } from \"~/domain/folder/errors.js\";\nimport { createListSort } from \"~/utils/createListSort.js\";\nimport type { ListSort } from \"~/types.js\";\nimport { CmsSortMapper, CmsWhereMapper } from \"@webiny/api-headless-cms\";\n\nclass ListFoldersRepositoryImpl implements IListFoldersRepository {\n    constructor(\n        private listLatestEntries: ListLatestEntriesUseCase.Interface,\n        private folderModel: FolderModel.Interface,\n        private cmsWhereMapper: CmsWhereMapper.Interface,\n        private cmsSortMapper: CmsSortMapper.Interface\n    ) {}\n\n    async execute(params: ListFoldersParams): RepositoryAbstraction.Return {\n        const { sort, where } = params;\n\n        const listSort =\n            sort ||\n            ({\n                values_title: \"ASC\"\n            } as unknown as ListSort);\n\n        const result = await this.listLatestEntries.execute<CmsEntryFolder>(this.folderModel, {\n            ...params,\n            sort: this.cmsSortMapper.map({\n                input: createListSort(listSort),\n                fields: this.folderModel.fields\n            }),\n            where: this.cmsWhereMapper.map({\n                input: where,\n                fields: this.folderModel.fields\n            })\n        });\n\n        if (result.isFail()) {\n            return Result.fail(new FolderPersistenceError(result.error));\n        }\n\n        const { entries, meta } = result.value;\n        const folders = entries.map(entry => EntryToFolderMapper.toFolder(entry));\n        return Result.ok({ folders, meta });\n    }\n}\n\nexport const ListFoldersRepository = RepositoryAbstraction.createImplementation({\n    implementation: ListFoldersRepositoryImpl,\n    dependencies: [ListLatestEntriesUseCase, FolderModel, CmsWhereMapper, CmsSortMapper]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAEIC,qBAAqB,IAAIC,qBAAqB;AAElD,SAASC,wBAAwB,QAAQ,4DAA4D;AACrG,SAASC,WAAW;AAEpB,SAASC,mBAAmB;AAC5B,SAASC,sBAAsB;AAC/B,SAASC,cAAc;AAEvB,SAASC,aAAa,EAAEC,cAAc,QAAQ,0BAA0B;AAExE,MAAMC,yBAAyB,CAAmC;EAC9DC,WAAWA,CACCC,iBAAqD,EACrDC,WAAkC,EAClCC,cAAwC,EACxCC,aAAsC,EAChD;IAAA,KAJUH,iBAAqD,GAArDA,iBAAqD;IAAA,KACrDC,WAAkC,GAAlCA,WAAkC;IAAA,KAClCC,cAAwC,GAAxCA,cAAwC;IAAA,KACxCC,aAAsC,GAAtCA,aAAsC;EAC/C;EAEH,MAAMC,OAAOA,CAACC,MAAyB,EAAgC;IACnE,MAAM;MAAEC,IAAI;MAAEC;IAAM,CAAC,GAAGF,MAAM;IAE9B,MAAMG,QAAQ,GACVF,IAAI,IACH;MACGG,YAAY,EAAE;IAClB,CAAyB;IAE7B,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACV,iBAAiB,CAACI,OAAO,CAAiB,IAAI,CAACH,WAAW,EAAE;MAClF,GAAGI,MAAM;MACTC,IAAI,EAAE,IAAI,CAACH,aAAa,CAACQ,GAAG,CAAC;QACzBC,KAAK,EAAEjB,cAAc,CAACa,QAAQ,CAAC;QAC/BK,MAAM,EAAE,IAAI,CAACZ,WAAW,CAACY;MAC7B,CAAC,CAAC;MACFN,KAAK,EAAE,IAAI,CAACL,cAAc,CAACS,GAAG,CAAC;QAC3BC,KAAK,EAAEL,KAAK;QACZM,MAAM,EAAE,IAAI,CAACZ,WAAW,CAACY;MAC7B,CAAC;IACL,CAAC,CAAC;IAEF,IAAIH,MAAM,CAACI,MAAM,CAAC,CAAC,EAAE;MACjB,OAAO1B,MAAM,CAAC2B,IAAI,CAAC,IAAIrB,sBAAsB,CAACgB,MAAM,CAACM,KAAK,CAAC,CAAC;IAChE;IAEA,MAAM;MAAEC,OAAO;MAAEC;IAAK,CAAC,GAAGR,MAAM,CAACS,KAAK;IACtC,MAAMC,OAAO,GAAGH,OAAO,CAACN,GAAG,CAACU,KAAK,IAAI5B,mBAAmB,CAAC6B,QAAQ,CAACD,KAAK,CAAC,CAAC;IACzE,OAAOjC,MAAM,CAACmC,EAAE,CAAC;MAAEH,OAAO;MAAEF;IAAK,CAAC,CAAC;EACvC;AACJ;AAEA,OAAO,MAAM7B,qBAAqB,GAAGC,qBAAqB,CAACkC,oBAAoB,CAAC;EAC5EC,cAAc,EAAE3B,yBAAyB;EACzC4B,YAAY,EAAE,CAACnC,wBAAwB,EAAEC,WAAW,EAAEK,cAAc,EAAED,aAAa;AACvF,CAAC,CAAC","ignoreList":[]}
+{"version":3,"file":"features/folder/ListFolders/ListFoldersRepository.js","sources":["../../../../src/features/folder/ListFolders/ListFoldersRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    type IListFoldersRepository,\n    ListFoldersRepository as RepositoryAbstraction\n} from \"./abstractions.js\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries\";\nimport { FolderModel } from \"~/domain/folder/abstractions.js\";\nimport type { CmsEntryFolder, ListFoldersParams } from \"~/folder/folder.types.js\";\nimport { EntryToFolderMapper } from \"../shared/EntryToFolderMapper.js\";\nimport { FolderPersistenceError } from \"~/domain/folder/errors.js\";\nimport { createListSort } from \"~/utils/createListSort.js\";\nimport type { ListSort } from \"~/types.js\";\nimport { CmsSortMapper, CmsWhereMapper } from \"@webiny/api-headless-cms\";\n\nclass ListFoldersRepositoryImpl implements IListFoldersRepository {\n    constructor(\n        private listLatestEntries: ListLatestEntriesUseCase.Interface,\n        private folderModel: FolderModel.Interface,\n        private cmsWhereMapper: CmsWhereMapper.Interface,\n        private cmsSortMapper: CmsSortMapper.Interface\n    ) {}\n\n    async execute(params: ListFoldersParams): RepositoryAbstraction.Return {\n        const { sort, where } = params;\n\n        const listSort =\n            sort ||\n            ({\n                values_title: \"ASC\"\n            } as unknown as ListSort);\n\n        const result = await this.listLatestEntries.execute<CmsEntryFolder>(this.folderModel, {\n            ...params,\n            sort: this.cmsSortMapper.map({\n                input: createListSort(listSort),\n                fields: this.folderModel.fields\n            }),\n            where: this.cmsWhereMapper.map({\n                input: where,\n                fields: this.folderModel.fields\n            })\n        });\n\n        if (result.isFail()) {\n            return Result.fail(new FolderPersistenceError(result.error));\n        }\n\n        const { entries, meta } = result.value;\n        const folders = entries.map(entry => EntryToFolderMapper.toFolder(entry));\n        return Result.ok({ folders, meta });\n    }\n}\n\nexport const ListFoldersRepository = RepositoryAbstraction.createImplementation({\n    implementation: ListFoldersRepositoryImpl,\n    dependencies: [ListLatestEntriesUseCase, FolderModel, CmsWhereMapper, CmsSortMapper]\n});\n"],"names":["ListFoldersRepositoryImpl","listLatestEntries","folderModel","cmsWhereMapper","cmsSortMapper","params","sort","where","listSort","result","createListSort","Result","FolderPersistenceError","entries","meta","folders","entry","EntryToFolderMapper","ListFoldersRepository","RepositoryAbstraction","ListLatestEntriesUseCase","FolderModel","CmsWhereMapper","CmsSortMapper"],"mappings":";;;;;;;;AAcA,MAAMA;IACF,YACYC,iBAAqD,EACrDC,WAAkC,EAClCC,cAAwC,EACxCC,aAAsC,CAChD;aAJUH,iBAAiB,GAAjBA;aACAC,WAAW,GAAXA;aACAC,cAAc,GAAdA;aACAC,aAAa,GAAbA;IACT;IAEH,MAAM,QAAQC,MAAyB,EAAgC;QACnE,MAAM,EAAEC,IAAI,EAAEC,KAAK,EAAE,GAAGF;QAExB,MAAMG,WACFF,QACC;YACG,cAAc;QAClB;QAEJ,MAAMG,SAAS,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAiB,IAAI,CAAC,WAAW,EAAE;YAClF,GAAGJ,MAAM;YACT,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC;gBACzB,OAAOK,eAAeF;gBACtB,QAAQ,IAAI,CAAC,WAAW,CAAC,MAAM;YACnC;YACA,OAAO,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC;gBAC3B,OAAOD;gBACP,QAAQ,IAAI,CAAC,WAAW,CAAC,MAAM;YACnC;QACJ;QAEA,IAAIE,OAAO,MAAM,IACb,OAAOE,OAAO,IAAI,CAAC,IAAIC,uBAAuBH,OAAO,KAAK;QAG9D,MAAM,EAAEI,OAAO,EAAEC,IAAI,EAAE,GAAGL,OAAO,KAAK;QACtC,MAAMM,UAAUF,QAAQ,GAAG,CAACG,CAAAA,QAASC,oBAAoB,QAAQ,CAACD;QAClE,OAAOL,OAAO,EAAE,CAAC;YAAEI;YAASD;QAAK;IACrC;AACJ;AAEO,MAAMI,8CAAwBC,sBAAAA,oBAA0C,CAAC;IAC5E,gBAAgBnB;IAChB,cAAc;QAACoB;QAA0BC;QAAaC;QAAgBC;KAAc;AACxF"}

package/features/folder/ListFolders/ListFoldersUseCase.js

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

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

@@ -1 +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":[]}
+{"version":3,"file":"features/folder/ListFolders/ListFoldersUseCase.js","sources":["../../../../src/features/folder/ListFolders/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"],"names":["ListFoldersUseCaseImpl","repository","params","ListFoldersUseCase","createImplementation","UseCaseAbstraction","ListFoldersRepository"],"mappings":";;AAIA,MAAMA;IACF,YAAoBC,UAA2C,CAAE;aAA7CA,UAAU,GAAVA;IAA8C;IAElE,MAAM,QAAQC,MAAyB,EAA6B;QAChE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;IACzC;AACJ;AAEO,MAAMC,wCAAqBC,qBAAqB;IACnD,aAAaC;IACb,gBAAgBL;IAChB,cAAc;QAACM;KAAsB;AACzC"}

package/features/folder/ListFolders/abstractions.js

@@ -1,17 +1,6 @@
 import { createAbstraction } from "@webiny/feature/api";
-
-/**
- * ListFolders repository interface
- */
-
-/** Fetch folders from storage. */
-export const ListFoldersRepository = createAbstraction("ListFoldersRepository");
-
-/**
- * ListFolders use case interface
- */
-
-/** List folders with filtering. */
-export const ListFoldersUseCase = createAbstraction("ListFoldersUseCase");
+const ListFoldersRepository = createAbstraction("ListFoldersRepository");
+const ListFoldersUseCase = createAbstraction("ListFoldersUseCase");
+export { ListFoldersRepository, ListFoldersUseCase };
 
 //# sourceMappingURL=abstractions.js.map

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

@@ -1 +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\n/** Fetch folders from storage. */\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\n/** List folders with filtering. */\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;AACA,OAAO,MAAMC,qBAAqB,GAC9BD,iBAAiB,CAAyB,uBAAuB,CAAC;;AAQtE;AACA;AACA;;AAYA;AACA,OAAO,MAAME,kBAAkB,GAAGF,iBAAiB,CAAsB,oBAAoB,CAAC","ignoreList":[]}
+{"version":3,"file":"features/folder/ListFolders/abstractions.js","sources":["../../../../src/features/folder/ListFolders/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\n/** Fetch folders from storage. */\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\n/** List folders with filtering. */\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"],"names":["ListFoldersRepository","createAbstraction","ListFoldersUseCase"],"mappings":";AAyBO,MAAMA,wBACTC,kBAA0C;AAuBvC,MAAMC,qBAAqBD,kBAAuC"}

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

@@ -3,75 +3,63 @@ 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, decoratee) {
-    this.folderLevelPermissions = folderLevelPermissions;
-    this.decoratee = decoratee;
-  }
-  async execute(params) {
-    const result = await this.decoratee.execute(params);
-    if (result.isFail()) {
-      return Result.fail(result.error);
+    constructor(folderLevelPermissions, decoratee){
+        this.folderLevelPermissions = folderLevelPermissions;
+        this.decoratee = decoratee;
+        this.flpCatalog = new Map();
+    }
+    async execute(params) {
+        const result = await this.decoratee.execute(params);
+        if (result.isFail()) return Result.fail(result.error);
+        const { folders, meta } = result.value;
+        const rootFlps = await this.folderLevelPermissions.listFolderLevelPermissions({
+            where: {
+                type: params.where.type,
+                parentId: ROOT_FOLDER
+            }
+        });
+        rootFlps.forEach((flp)=>this.setFlp(flp.id, flp.permissions));
+        await Promise.all(folders.map(async (folder)=>{
+            if (!this.hasFlp(folder.id)) {
+                const permissions = await this.folderLevelPermissions.getFolderLevelPermissions(folder.id);
+                this.setFlp(folder.id, permissions);
+            }
+        }));
+        const foldersWithPermissions = await Promise.all(folders.map(async (folder)=>{
+            const permissions = this.getFlp(folder.id);
+            if (!permissions) return null;
+            const canAccessFolder = await this.folderLevelPermissions.canAccessFolder({
+                permissions,
+                rwd: "r"
+            });
+            if (!canAccessFolder) return null;
+            const folderWithFlp = {
+                ...folder,
+                permissions
+            };
+            return canAccessFolder ? folderWithFlp : null;
+        }));
+        return Result.ok({
+            folders: foldersWithPermissions.filter(Boolean),
+            meta
+        });
+    }
+    hasFlp(id) {
+        return this.flpCatalog.has(id);
+    }
+    getFlp(id) {
+        return this.flpCatalog.get(id);
+    }
+    setFlp(id, permissions) {
+        this.flpCatalog.set(id, permissions);
     }
-    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: ROOT_FOLDER
-      }
-    });
-    rootFlps.forEach(flp => this.setFlp(flp.id, flp.permissions));
-
-    // Fetch FLP for folders not already in the catalog.
-    await Promise.all(folders.map(async folder => {
-      if (!this.hasFlp(folder.id)) {
-        const permissions = await this.folderLevelPermissions.getFolderLevelPermissions(folder.id);
-        this.setFlp(folder.id, permissions);
-      }
-    }));
-
-    // Filter folders based on permissions.
-    const foldersWithPermissions = await Promise.all(folders.map(async folder => {
-      const permissions = this.getFlp(folder.id);
-      if (!permissions) {
-        return null;
-      }
-      const canAccessFolder = await this.folderLevelPermissions.canAccessFolder({
-        permissions,
-        rwd: "r"
-      });
-      if (!canAccessFolder) {
-        return null;
-      }
-      const folderWithFlp = {
-        ...folder,
-        permissions
-      };
-      return canAccessFolder ? folderWithFlp : null;
-    }));
-    return Result.ok({
-      folders: foldersWithPermissions.filter(Boolean),
-      meta
-    });
-  }
-  hasFlp(id) {
-    return this.flpCatalog.has(id);
-  }
-  getFlp(id) {
-    return this.flpCatalog.get(id);
-  }
-  setFlp(id, permissions) {
-    this.flpCatalog.set(id, permissions);
-  }
 }
-export const ListFoldersWithFolderLevelPermissions = ListFoldersUseCase.createDecorator({
-  decorator: ListFoldersWithFolderLevelPermissionsImpl,
-  dependencies: [FolderLevelPermissions]
+const ListFoldersWithFolderLevelPermissions = ListFoldersUseCase.createDecorator({
+    decorator: ListFoldersWithFolderLevelPermissionsImpl,
+    dependencies: [
+        FolderLevelPermissions
+    ]
 });
+export { ListFoldersWithFolderLevelPermissions };
 
 //# sourceMappingURL=ListFoldersWithFolderLevelPermissions.js.map

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

@@ -1 +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":[]}
+{"version":3,"file":"features/folder/ListFolders/decorators/ListFoldersWithFolderLevelPermissions.js","sources":["../../../../../src/features/folder/ListFolders/decorators/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"],"names":["ListFoldersWithFolderLevelPermissionsImpl","folderLevelPermissions","decoratee","Map","params","result","Result","folders","meta","rootFlps","ROOT_FOLDER","flp","Promise","folder","permissions","foldersWithPermissions","canAccessFolder","folderWithFlp","Boolean","id","ListFoldersWithFolderLevelPermissions","ListFoldersUseCase","FolderLevelPermissions"],"mappings":";;;;AAOA,MAAMA;IAGF,YACYC,sBAAwD,EACxDC,SAAuC,CACjD;aAFUD,sBAAsB,GAAtBA;aACAC,SAAS,GAATA;aAJJ,UAAU,GAAoC,IAAIC;IAKvD;IAEH,MAAM,QAAQC,MAAyB,EAA6B;QAChE,MAAMC,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACD;QAC5C,IAAIC,OAAO,MAAM,IACb,OAAOC,OAAO,IAAI,CAACD,OAAO,KAAK;QAGnC,MAAM,EAAEE,OAAO,EAAEC,IAAI,EAAE,GAAGH,OAAO,KAAK;QAGtC,MAAMI,WAAW,MAAM,IAAI,CAAC,sBAAsB,CAAC,0BAA0B,CAAC;YAC1E,OAAO;gBACH,MAAML,OAAO,KAAK,CAAC,IAAI;gBACvB,UAAUM;YACd;QACJ;QAEAD,SAAS,OAAO,CAACE,CAAAA,MAAO,IAAI,CAAC,MAAM,CAACA,IAAI,EAAE,EAAEA,IAAI,WAAW;QAG3D,MAAMC,QAAQ,GAAG,CACbL,QAAQ,GAAG,CAAC,OAAMM;YACd,IAAI,CAAC,IAAI,CAAC,MAAM,CAACA,OAAO,EAAE,GAAG;gBACzB,MAAMC,cAAc,MAAM,IAAI,CAAC,sBAAsB,CAAC,yBAAyB,CAC3ED,OAAO,EAAE;gBAEb,IAAI,CAAC,MAAM,CAACA,OAAO,EAAE,EAAEC;YAC3B;QACJ;QAIJ,MAAMC,yBAAyB,MAAMH,QAAQ,GAAG,CAC5CL,QAAQ,GAAG,CAAC,OAAMM;YACd,MAAMC,cAAc,IAAI,CAAC,MAAM,CAACD,OAAO,EAAE;YACzC,IAAI,CAACC,aACD,OAAO;YAGX,MAAME,kBAAkB,MAAM,IAAI,CAAC,sBAAsB,CAAC,eAAe,CAAC;gBACtEF;gBACA,KAAK;YACT;YAEA,IAAI,CAACE,iBACD,OAAO;YAGX,MAAMC,gBAAgB;gBAAE,GAAGJ,MAAM;gBAAEC;YAAY;YAC/C,OAAOE,kBAAkBC,gBAAgB;QAC7C;QAGJ,OAAOX,OAAO,EAAE,CAAC;YAAE,SAASS,uBAAuB,MAAM,CAACG;YAAsBV;QAAK;IACzF;IAEQ,OAAOW,EAAU,EAAW;QAChC,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAACA;IAC/B;IAEQ,OAAOA,EAAU,EAAkC;QACvD,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAACA;IAC/B;IAEQ,OAAOA,EAAU,EAAEL,WAA+B,EAAQ;QAC9D,IAAI,CAAC,UAAU,CAAC,GAAG,CAACK,IAAIL;IAC5B;AACJ;AAEO,MAAMM,wCAAwCC,mBAAmB,eAAe,CAAC;IACpF,WAAWrB;IACX,cAAc;QAACsB;KAAuB;AAC1C"}

package/features/folder/ListFolders/feature.js

@@ -2,13 +2,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);
-  }
+const ListFoldersFeature = createFeature({
+    name: "ListFolders",
+    register (container) {
+        container.register(ListFoldersRepository).inSingletonScope();
+        container.register(ListFoldersUseCase);
+        container.registerDecorator(ListFoldersWithFolderLevelPermissions);
+    }
 });
+export { ListFoldersFeature };
 
 //# sourceMappingURL=feature.js.map

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

@@ -1 +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":[]}
+{"version":3,"file":"features/folder/ListFolders/feature.js","sources":["../../../../src/features/folder/ListFolders/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"],"names":["ListFoldersFeature","createFeature","container","ListFoldersRepository","ListFoldersUseCase","ListFoldersWithFolderLevelPermissions"],"mappings":";;;;AAMO,MAAMA,qBAAqBC,cAAc;IAC5C,MAAM;IACN,UAASC,SAAoB;QACzBA,UAAU,QAAQ,CAACC,uBAAuB,gBAAgB;QAC1DD,UAAU,QAAQ,CAACE;QACnBF,UAAU,iBAAiB,CAACG;IAChC;AACJ"}

package/features/folder/ListFolders/index.js

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

package/features/folder/UpdateFolder/UpdateFolderRepository.js

@@ -1,5 +1,5 @@
 import { Result } from "@webiny/feature/api";
-import { UpdateFolderRepository as RepositoryAbstraction } from "./abstractions.js";
+import { UpdateFolderRepository } 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";
@@ -9,102 +9,76 @@ import { FolderPersistenceError, FolderValidationError } from "../../../domain/f
 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));
+    constructor(updateEntry, getEntryById, listLatestEntries, folderModel){
+        this.updateEntry = updateEntry;
+        this.getEntryById = getEntryById;
+        this.listLatestEntries = listLatestEntries;
+        this.folderModel = folderModel;
     }
-    const {
-      entries
-    } = result.value;
-    if (entries.length > 0) {
-      return Result.fail(new FolderValidationError(`Folder with slug "${slug}" already exists at this level.`));
+    async execute(id, data) {
+        const entryId = EntryId.from(id);
+        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);
+        const checkResult = await this.checkExistingFolder({
+            id,
+            type: original.type,
+            slug: data.slug || original.slug,
+            parentId: void 0 !== data.parentId ? data.parentId : original.parentId
+        });
+        if (checkResult.isFail()) return Result.fail(checkResult.error);
+        const pathResult = await this.createFolderPath({
+            slug: data.slug || original.slug,
+            parentId: void 0 !== data.parentId ? 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);
     }
-    return Result.ok();
-  }
-  async createFolderPath(params) {
-    const {
-      slug,
-      parentId
-    } = params;
-    if (!parentId) {
-      return Result.ok(Path.create(slug));
+    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();
     }
-    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")));
+    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));
     }
-    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]
+const UpdateFolderRepository_UpdateFolderRepository = UpdateFolderRepository.createImplementation({
+    implementation: UpdateFolderRepositoryImpl,
+    dependencies: [
+        UpdateEntryUseCase,
+        GetEntryByIdUseCase,
+        ListLatestEntriesUseCase,
+        FolderModel
+    ]
 });
+export { UpdateFolderRepository_UpdateFolderRepository as UpdateFolderRepository };
 
 //# sourceMappingURL=UpdateFolderRepository.js.map