@webiny/api-aco 0.0.0-unstable.496cf268ac → 0.0.0-unstable.5387e5f7c8

package/features/folder/ListFolders/ListFoldersRepository.js

@@ -0,0 +1,53 @@
+import { Result } from "@webiny/feature/api";
+import { ListFoldersRepository } from "./abstractions.js";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
+import { FolderModelProvider } from "../../../domain/folder/abstractions.js";
+import { EntryToFolderMapper } from "../shared/EntryToFolderMapper.js";
+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, folderModelProvider, cmsWhereMapper, cmsSortMapper){
+        this.listLatestEntries = listLatestEntries;
+        this.folderModelProvider = folderModelProvider;
+        this.cmsWhereMapper = cmsWhereMapper;
+        this.cmsSortMapper = cmsSortMapper;
+    }
+    async execute(params) {
+        const folderModel = await this.folderModelProvider.get();
+        const { sort, where } = params;
+        const listSort = sort || {
+            values_title: "ASC"
+        };
+        const result = await this.listLatestEntries.execute(folderModel, {
+            ...params,
+            sort: this.cmsSortMapper.map({
+                input: createListSort(listSort),
+                fields: folderModel.fields
+            }),
+            where: this.cmsWhereMapper.map({
+                input: where,
+                fields: 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 ListFoldersRepository_ListFoldersRepository = ListFoldersRepository.createImplementation({
+    implementation: ListFoldersRepositoryImpl,
+    dependencies: [
+        ListLatestEntriesUseCase,
+        FolderModelProvider,
+        CmsWhereMapper,
+        CmsSortMapper
+    ]
+});
+export { ListFoldersRepository_ListFoldersRepository as ListFoldersRepository };
+
+//# sourceMappingURL=ListFoldersRepository.js.map

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

@@ -0,0 +1 @@
+{"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 { FolderModelProvider } 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 folderModelProvider: FolderModelProvider.Interface,\n        private cmsWhereMapper: CmsWhereMapper.Interface,\n        private cmsSortMapper: CmsSortMapper.Interface\n    ) {}\n\n    async execute(params: ListFoldersParams): RepositoryAbstraction.Return {\n        const folderModel = await this.folderModelProvider.get();\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>(folderModel, {\n            ...params,\n            sort: this.cmsSortMapper.map({\n                input: createListSort(listSort),\n                fields: folderModel.fields\n            }),\n            where: this.cmsWhereMapper.map({\n                input: where,\n                fields: 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, FolderModelProvider, CmsWhereMapper, CmsSortMapper]\n});\n"],"names":["ListFoldersRepositoryImpl","listLatestEntries","folderModelProvider","cmsWhereMapper","cmsSortMapper","params","folderModel","sort","where","listSort","result","createListSort","Result","FolderPersistenceError","entries","meta","folders","entry","EntryToFolderMapper","ListFoldersRepository","RepositoryAbstraction","ListLatestEntriesUseCase","FolderModelProvider","CmsWhereMapper","CmsSortMapper"],"mappings":";;;;;;;;AAcA,MAAMA;IACF,YACYC,iBAAqD,EACrDC,mBAAkD,EAClDC,cAAwC,EACxCC,aAAsC,CAChD;aAJUH,iBAAiB,GAAjBA;aACAC,mBAAmB,GAAnBA;aACAC,cAAc,GAAdA;aACAC,aAAa,GAAbA;IACT;IAEH,MAAM,QAAQC,MAAyB,EAAgC;QACnE,MAAMC,cAAc,MAAM,IAAI,CAAC,mBAAmB,CAAC,GAAG;QACtD,MAAM,EAAEC,IAAI,EAAEC,KAAK,EAAE,GAAGH;QAExB,MAAMI,WACFF,QACC;YACG,cAAc;QAClB;QAEJ,MAAMG,SAAS,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAiBJ,aAAa;YAC7E,GAAGD,MAAM;YACT,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC;gBACzB,OAAOM,eAAeF;gBACtB,QAAQH,YAAY,MAAM;YAC9B;YACA,OAAO,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC;gBAC3B,OAAOE;gBACP,QAAQF,YAAY,MAAM;YAC9B;QACJ;QAEA,IAAII,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,gBAAgBpB;IAChB,cAAc;QAACqB;QAA0BC;QAAqBC;QAAgBC;KAAc;AAChG"}

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,20 @@
+import { createImplementation } from "@webiny/feature/api";
+import { ListFoldersRepository, ListFoldersUseCase } from "./abstractions.js";
+class ListFoldersUseCaseImpl {
+    constructor(repository){
+        this.repository = repository;
+    }
+    async execute(params) {
+        return await this.repository.execute(params);
+    }
+}
+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

@@ -0,0 +1 @@
+{"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.d.ts

@@ -0,0 +1,44 @@
+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];
+/** Fetch folders from storage. */
+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];
+/** List folders with filtering. */
+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,6 @@
+import { createAbstraction } from "@webiny/feature/api";
+const ListFoldersRepository = createAbstraction("ListFoldersRepository");
+const ListFoldersUseCase = createAbstraction("ListFoldersUseCase");
+export { ListFoldersRepository, ListFoldersUseCase };
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"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.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/features/folder/ListFolders/decorators/ListFoldersWithFolderLevelPermissions.js

@@ -0,0 +1,65 @@
+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 {
+    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 ListFoldersWithFolderLevelPermissions = ListFoldersUseCase.createDecorator({
+    decorator: ListFoldersWithFolderLevelPermissionsImpl,
+    dependencies: [
+        FolderLevelPermissions
+    ]
+});
+export { ListFoldersWithFolderLevelPermissions };
+
+//# sourceMappingURL=ListFoldersWithFolderLevelPermissions.js.map

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

@@ -0,0 +1 @@
+{"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.d.ts

@@ -0,0 +1,5 @@
+import type { Container } from "@webiny/di";
+export declare const ListFoldersFeature: {
+    name: string;
+    register(container: Container): void;
+};

package/features/folder/ListFolders/feature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import { ListFoldersRepository } from "./ListFoldersRepository.js";
+import { ListFoldersUseCase } from "./ListFoldersUseCase.js";
+import { ListFoldersWithFolderLevelPermissions } from "./decorators/ListFoldersWithFolderLevelPermissions.js";
+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

@@ -0,0 +1 @@
+{"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.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,2 @@
+export { ListFoldersFeature } from "./feature.js";
+export { ListFoldersUseCase } from "./abstractions.js";

package/features/folder/NotifyFolderChange/NotifyFolderChangeUseCase.d.ts

@@ -0,0 +1,11 @@
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/abstractions.js";
+import { WebsocketsSendToIdentityUseCase } from "@webiny/api-websockets/exports/api.js";
+import { NotifyFolderChangeUseCase as UseCaseAbstraction } from "./abstractions.js";
+declare class NotifyFolderChangeUseCaseImpl implements UseCaseAbstraction.Interface {
+    private identityContext;
+    private sendToIdentity;
+    constructor(identityContext: IdentityContext.Interface, sendToIdentity: WebsocketsSendToIdentityUseCase.Interface);
+    execute({ id, change, identityId }: UseCaseAbstraction.Params): Promise<void>;
+}
+export declare const NotifyFolderChangeUseCase: import("@webiny/di").Implementation<typeof NotifyFolderChangeUseCaseImpl>;
+export {};

package/features/folder/NotifyFolderChange/NotifyFolderChangeUseCase.js

@@ -0,0 +1,38 @@
+import { createImplementation } from "@webiny/di";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/abstractions.js";
+import { WebsocketsSendToIdentityUseCase } from "@webiny/api-websockets/exports/api.js";
+import { FOLDER_CREATED_WEBSOCKET_ACTION, FOLDER_DELETED_WEBSOCKET_ACTION, FOLDER_UPDATED_WEBSOCKET_ACTION, NotifyFolderChangeUseCase } from "./abstractions.js";
+const ACTIONS = {
+    created: FOLDER_CREATED_WEBSOCKET_ACTION,
+    updated: FOLDER_UPDATED_WEBSOCKET_ACTION,
+    deleted: FOLDER_DELETED_WEBSOCKET_ACTION
+};
+class NotifyFolderChangeUseCaseImpl {
+    constructor(identityContext, sendToIdentity){
+        this.identityContext = identityContext;
+        this.sendToIdentity = sendToIdentity;
+    }
+    async execute({ id, change, identityId }) {
+        const recipient = identityId ?? this.identityContext.getIdentity()?.id;
+        if (!recipient) return;
+        await this.sendToIdentity.execute({
+            id: recipient
+        }, {
+            action: ACTIONS[change],
+            data: {
+                id
+            }
+        });
+    }
+}
+const NotifyFolderChangeUseCase_NotifyFolderChangeUseCase = createImplementation({
+    abstraction: NotifyFolderChangeUseCase,
+    implementation: NotifyFolderChangeUseCaseImpl,
+    dependencies: [
+        IdentityContext,
+        WebsocketsSendToIdentityUseCase
+    ]
+});
+export { NotifyFolderChangeUseCase_NotifyFolderChangeUseCase as NotifyFolderChangeUseCase };
+
+//# sourceMappingURL=NotifyFolderChangeUseCase.js.map

package/features/folder/NotifyFolderChange/NotifyFolderChangeUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/NotifyFolderChange/NotifyFolderChangeUseCase.js","sources":["../../../../src/features/folder/NotifyFolderChange/NotifyFolderChangeUseCase.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/di\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/abstractions.js\";\nimport { WebsocketsSendToIdentityUseCase } from \"@webiny/api-websockets/exports/api.js\";\nimport {\n    FOLDER_CREATED_WEBSOCKET_ACTION,\n    FOLDER_DELETED_WEBSOCKET_ACTION,\n    FOLDER_UPDATED_WEBSOCKET_ACTION,\n    NotifyFolderChangeUseCase as UseCaseAbstraction\n} from \"./abstractions.js\";\n\nconst ACTIONS: Record<UseCaseAbstraction.Params[\"change\"], string> = {\n    created: FOLDER_CREATED_WEBSOCKET_ACTION,\n    updated: FOLDER_UPDATED_WEBSOCKET_ACTION,\n    deleted: FOLDER_DELETED_WEBSOCKET_ACTION\n};\n\n/*\n * The change is already saved whether or not the message goes out, so the send's result is not the\n * caller's result. When it fails, the admin shows the change after its next reload, as it did before.\n */\nclass NotifyFolderChangeUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private identityContext: IdentityContext.Interface,\n        private sendToIdentity: WebsocketsSendToIdentityUseCase.Interface\n    ) {}\n\n    async execute({ id, change, identityId }: UseCaseAbstraction.Params): Promise<void> {\n        const recipient = identityId ?? this.identityContext.getIdentity()?.id;\n        if (!recipient) {\n            return;\n        }\n\n        await this.sendToIdentity.execute(\n            { id: recipient },\n            { action: ACTIONS[change], data: { id } }\n        );\n    }\n}\n\nexport const NotifyFolderChangeUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: NotifyFolderChangeUseCaseImpl,\n    dependencies: [IdentityContext, WebsocketsSendToIdentityUseCase]\n});\n"],"names":["ACTIONS","FOLDER_CREATED_WEBSOCKET_ACTION","FOLDER_UPDATED_WEBSOCKET_ACTION","FOLDER_DELETED_WEBSOCKET_ACTION","NotifyFolderChangeUseCaseImpl","identityContext","sendToIdentity","id","change","identityId","recipient","NotifyFolderChangeUseCase","createImplementation","UseCaseAbstraction","IdentityContext","WebsocketsSendToIdentityUseCase"],"mappings":";;;;AAUA,MAAMA,UAA+D;IACjE,SAASC;IACT,SAASC;IACT,SAASC;AACb;AAMA,MAAMC;IACF,YACYC,eAA0C,EAC1CC,cAAyD,CACnE;aAFUD,eAAe,GAAfA;aACAC,cAAc,GAAdA;IACT;IAEH,MAAM,QAAQ,EAAEC,EAAE,EAAEC,MAAM,EAAEC,UAAU,EAA6B,EAAiB;QAChF,MAAMC,YAAYD,cAAc,IAAI,CAAC,eAAe,CAAC,WAAW,IAAI;QACpE,IAAI,CAACC,WACD;QAGJ,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B;YAAE,IAAIA;QAAU,GAChB;YAAE,QAAQV,OAAO,CAACQ,OAAO;YAAE,MAAM;gBAAED;YAAG;QAAE;IAEhD;AACJ;AAEO,MAAMI,sDAA4BC,qBAAqB;IAC1D,aAAaC;IACb,gBAAgBT;IAChB,cAAc;QAACU;QAAiBC;KAAgC;AACpE"}

package/features/folder/NotifyFolderChange/NotifyOnFolderDeletedHandler.d.ts

@@ -0,0 +1,12 @@
+import { FolderAfterDeleteEventHandler } from "../../../features/folder/DeleteFolder/abstractions.js";
+import type { FolderAfterDeleteEvent } from "../../../features/folder/DeleteFolder/events.js";
+import { NotifyFolderChangeUseCase } from "./abstractions.js";
+declare class NotifyOnFolderDeletedHandlerImpl implements FolderAfterDeleteEventHandler.Interface {
+    private notifyFolderChange;
+    constructor(notifyFolderChange: NotifyFolderChangeUseCase.Interface);
+    handle(event: FolderAfterDeleteEvent): Promise<void>;
+}
+export declare const NotifyOnFolderDeletedHandler: typeof NotifyOnFolderDeletedHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher/abstractions.js").IEventHandler<import("@webiny/api-core/features/eventPublisher/abstractions.js").DomainEvent<import("~/features/folder/DeleteFolder/abstractions.js").FolderAfterDeletePayload>>>;
+};
+export {};

package/features/folder/NotifyFolderChange/NotifyOnFolderDeletedHandler.js

@@ -0,0 +1,24 @@
+import { FolderAfterDeleteEventHandler } from "../DeleteFolder/abstractions.js";
+import { NotifyFolderChangeUseCase } from "./abstractions.js";
+class NotifyOnFolderDeletedHandlerImpl {
+    constructor(notifyFolderChange){
+        this.notifyFolderChange = notifyFolderChange;
+    }
+    async handle(event) {
+        try {
+            await this.notifyFolderChange.execute({
+                id: event.payload.folder.id,
+                change: "deleted"
+            });
+        } catch  {}
+    }
+}
+const NotifyOnFolderDeletedHandler = FolderAfterDeleteEventHandler.createImplementation({
+    implementation: NotifyOnFolderDeletedHandlerImpl,
+    dependencies: [
+        NotifyFolderChangeUseCase
+    ]
+});
+export { NotifyOnFolderDeletedHandler };
+
+//# sourceMappingURL=NotifyOnFolderDeletedHandler.js.map

package/features/folder/NotifyFolderChange/NotifyOnFolderDeletedHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/NotifyFolderChange/NotifyOnFolderDeletedHandler.js","sources":["../../../../src/features/folder/NotifyFolderChange/NotifyOnFolderDeletedHandler.ts"],"sourcesContent":["import { FolderAfterDeleteEventHandler } from \"~/features/folder/DeleteFolder/abstractions.js\";\nimport type { FolderAfterDeleteEvent } from \"~/features/folder/DeleteFolder/events.js\";\nimport { NotifyFolderChangeUseCase } from \"./abstractions.js\";\n\n/*\n * Created and updated folders are announced by the FLP tasks, once the admin can read them back. A\n * deleted folder is only dropped from the admin's cache, so there is nothing to wait for.\n */\nclass NotifyOnFolderDeletedHandlerImpl implements FolderAfterDeleteEventHandler.Interface {\n    constructor(private notifyFolderChange: NotifyFolderChangeUseCase.Interface) {}\n\n    async handle(event: FolderAfterDeleteEvent): Promise<void> {\n        try {\n            await this.notifyFolderChange.execute({\n                id: event.payload.folder.id,\n                change: \"deleted\"\n            });\n        } catch {\n            // The folder is gone either way; the admin drops it on its next reload.\n        }\n    }\n}\n\nexport const NotifyOnFolderDeletedHandler = FolderAfterDeleteEventHandler.createImplementation({\n    implementation: NotifyOnFolderDeletedHandlerImpl,\n    dependencies: [NotifyFolderChangeUseCase]\n});\n"],"names":["NotifyOnFolderDeletedHandlerImpl","notifyFolderChange","event","NotifyOnFolderDeletedHandler","FolderAfterDeleteEventHandler","NotifyFolderChangeUseCase"],"mappings":";;AAQA,MAAMA;IACF,YAAoBC,kBAAuD,CAAE;aAAzDA,kBAAkB,GAAlBA;IAA0D;IAE9E,MAAM,OAAOC,KAA6B,EAAiB;QACvD,IAAI;YACA,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC;gBAClC,IAAIA,MAAM,OAAO,CAAC,MAAM,CAAC,EAAE;gBAC3B,QAAQ;YACZ;QACJ,EAAE,OAAM,CAER;IACJ;AACJ;AAEO,MAAMC,+BAA+BC,8BAA8B,oBAAoB,CAAC;IAC3F,gBAAgBJ;IAChB,cAAc;QAACK;KAA0B;AAC7C"}

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

@@ -0,0 +1,28 @@
+/**
+ * Sent to the user's open admin tabs when a folder changes. The admin keeps its own folder cache,
+ * and a change made on the server never passes through it, so without these the admin shows the old
+ * state until a reload. Each carries the folder id only; the admin reads the folder back.
+ *
+ * `created` and `updated` go out when the FLP tasks finish, since folder reads report permissions
+ * from the FLP records. `deleted` goes out right after the delete: nothing is read back.
+ */
+export declare const FOLDER_CREATED_WEBSOCKET_ACTION = "aco.folder.created";
+export declare const FOLDER_UPDATED_WEBSOCKET_ACTION = "aco.folder.updated";
+export declare const FOLDER_DELETED_WEBSOCKET_ACTION = "aco.folder.deleted";
+export interface NotifyFolderChangeParams {
+    id: string;
+    /**
+     * Whose open tabs to tell. Defaults to the current identity. The FLP tasks pass the identity
+     * that made the change, because they run later, outside that request.
+     */
+    identityId?: string;
+    change: "created" | "updated" | "deleted";
+}
+export interface INotifyFolderChangeUseCase {
+    execute(params: NotifyFolderChangeParams): Promise<void>;
+}
+export declare const NotifyFolderChangeUseCase: import("@webiny/di").Abstraction<INotifyFolderChangeUseCase>;
+export declare namespace NotifyFolderChangeUseCase {
+    type Interface = INotifyFolderChangeUseCase;
+    type Params = NotifyFolderChangeParams;
+}

package/features/folder/NotifyFolderChange/abstractions.js

@@ -0,0 +1,8 @@
+import { createAbstraction } from "@webiny/feature/api";
+const FOLDER_CREATED_WEBSOCKET_ACTION = "aco.folder.created";
+const FOLDER_UPDATED_WEBSOCKET_ACTION = "aco.folder.updated";
+const FOLDER_DELETED_WEBSOCKET_ACTION = "aco.folder.deleted";
+const NotifyFolderChangeUseCase = createAbstraction("Aco/NotifyFolderChangeUseCase");
+export { FOLDER_CREATED_WEBSOCKET_ACTION, FOLDER_DELETED_WEBSOCKET_ACTION, FOLDER_UPDATED_WEBSOCKET_ACTION, NotifyFolderChangeUseCase };
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/NotifyFolderChange/abstractions.js","sources":["../../../../src/features/folder/NotifyFolderChange/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\n\n/**\n * Sent to the user's open admin tabs when a folder changes. The admin keeps its own folder cache,\n * and a change made on the server never passes through it, so without these the admin shows the old\n * state until a reload. Each carries the folder id only; the admin reads the folder back.\n *\n * `created` and `updated` go out when the FLP tasks finish, since folder reads report permissions\n * from the FLP records. `deleted` goes out right after the delete: nothing is read back.\n */\nexport const FOLDER_CREATED_WEBSOCKET_ACTION = \"aco.folder.created\";\nexport const FOLDER_UPDATED_WEBSOCKET_ACTION = \"aco.folder.updated\";\nexport const FOLDER_DELETED_WEBSOCKET_ACTION = \"aco.folder.deleted\";\n\nexport interface NotifyFolderChangeParams {\n    id: string;\n    /**\n     * Whose open tabs to tell. Defaults to the current identity. The FLP tasks pass the identity\n     * that made the change, because they run later, outside that request.\n     */\n    identityId?: string;\n    change: \"created\" | \"updated\" | \"deleted\";\n}\n\nexport interface INotifyFolderChangeUseCase {\n    execute(params: NotifyFolderChangeParams): Promise<void>;\n}\n\nexport const NotifyFolderChangeUseCase = createAbstraction<INotifyFolderChangeUseCase>(\n    \"Aco/NotifyFolderChangeUseCase\"\n);\n\nexport namespace NotifyFolderChangeUseCase {\n    export type Interface = INotifyFolderChangeUseCase;\n    export type Params = NotifyFolderChangeParams;\n}\n"],"names":["FOLDER_CREATED_WEBSOCKET_ACTION","FOLDER_UPDATED_WEBSOCKET_ACTION","FOLDER_DELETED_WEBSOCKET_ACTION","NotifyFolderChangeUseCase","createAbstraction"],"mappings":";AAUO,MAAMA,kCAAkC;AACxC,MAAMC,kCAAkC;AACxC,MAAMC,kCAAkC;AAgBxC,MAAMC,4BAA4BC,kBACrC"}

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

@@ -0,0 +1,9 @@
+/**
+ * Tells the user's open admin tabs when a folder is created, updated or deleted. The FLP tasks send
+ * created and updated (see `CreateFlpOnFolderCreated` and `UpdateFlpOnFolderUpdated`); deleted goes
+ * out from here.
+ */
+export declare const NotifyFolderChangeFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/folder/NotifyFolderChange/feature.js

@@ -0,0 +1,13 @@
+import { createFeature } from "@webiny/feature/api";
+import { NotifyFolderChangeUseCase } from "./NotifyFolderChangeUseCase.js";
+import { NotifyOnFolderDeletedHandler } from "./NotifyOnFolderDeletedHandler.js";
+const NotifyFolderChangeFeature = createFeature({
+    name: "NotifyFolderChange",
+    register (container) {
+        container.register(NotifyFolderChangeUseCase);
+        container.register(NotifyOnFolderDeletedHandler);
+    }
+});
+export { NotifyFolderChangeFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/NotifyFolderChange/feature.js","sources":["../../../../src/features/folder/NotifyFolderChange/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { NotifyFolderChangeUseCase } from \"./NotifyFolderChangeUseCase.js\";\nimport { NotifyOnFolderDeletedHandler } from \"./NotifyOnFolderDeletedHandler.js\";\n\n/**\n * Tells the user's open admin tabs when a folder is created, updated or deleted. The FLP tasks send\n * created and updated (see `CreateFlpOnFolderCreated` and `UpdateFlpOnFolderUpdated`); deleted goes\n * out from here.\n */\nexport const NotifyFolderChangeFeature = createFeature({\n    name: \"NotifyFolderChange\",\n    register(container) {\n        container.register(NotifyFolderChangeUseCase);\n        container.register(NotifyOnFolderDeletedHandler);\n    }\n});\n"],"names":["NotifyFolderChangeFeature","createFeature","container","NotifyFolderChangeUseCase","NotifyOnFolderDeletedHandler"],"mappings":";;;AASO,MAAMA,4BAA4BC,cAAc;IACnD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;IACvB;AACJ"}

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

@@ -0,0 +1,2 @@
+export { NotifyFolderChangeFeature } from "./feature.js";
+export { NotifyFolderChangeUseCase, FOLDER_CREATED_WEBSOCKET_ACTION, FOLDER_UPDATED_WEBSOCKET_ACTION, FOLDER_DELETED_WEBSOCKET_ACTION } from "./abstractions.js";

package/features/folder/NotifyFolderChange/index.js

@@ -0,0 +1,2 @@
+export { NotifyFolderChangeFeature } from "./feature.js";
+export { FOLDER_CREATED_WEBSOCKET_ACTION, FOLDER_DELETED_WEBSOCKET_ACTION, FOLDER_UPDATED_WEBSOCKET_ACTION, NotifyFolderChangeUseCase } from "./abstractions.js";

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 { FolderModelProvider } 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 folderModelProvider;
+    constructor(updateEntry: UpdateEntryUseCase.Interface, getEntryById: GetEntryByIdUseCase.Interface, listLatestEntries: ListLatestEntriesUseCase.Interface, folderModelProvider: FolderModelProvider.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,87 @@
+import { Result } from "@webiny/feature/api";
+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";
+import { FolderModelProvider } 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, folderModelProvider){
+        this.updateEntry = updateEntry;
+        this.getEntryById = getEntryById;
+        this.listLatestEntries = listLatestEntries;
+        this.folderModelProvider = folderModelProvider;
+    }
+    async execute(id, data) {
+        const folderModel = await this.folderModelProvider.get();
+        const entryId = EntryId.from(id);
+        const originalResult = await this.getEntryById.execute(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(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 folderModel = await this.folderModelProvider.get();
+        const { id, type, slug, parentId } = params;
+        const result = await this.listLatestEntries.execute(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 folderModel = await this.folderModelProvider.get();
+        const { slug, parentId } = params;
+        if (!parentId) return Result.ok(Path.create(slug));
+        const parentResult = await this.getEntryById.execute(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 UpdateFolderRepository_UpdateFolderRepository = UpdateFolderRepository.createImplementation({
+    implementation: UpdateFolderRepositoryImpl,
+    dependencies: [
+        UpdateEntryUseCase,
+        GetEntryByIdUseCase,
+        ListLatestEntriesUseCase,
+        FolderModelProvider
+    ]
+});
+export { UpdateFolderRepository_UpdateFolderRepository as UpdateFolderRepository };
+
+//# sourceMappingURL=UpdateFolderRepository.js.map