@webiny/api-aco 0.0.0-unstable.b14eaecf38 → 0.0.0-unstable.b6d7105cee

package/features/folder/GetFolder/decorators/GetFolderWithFolderLevelPermissions.d.ts

@@ -0,0 +1,29 @@
+import { GetFolderUseCase } from "../abstractions.js";
+import { Result } from "@webiny/feature/api";
+import { FolderLevelPermissions } from "../../../../features/flp/FolderLevelPermissions/index.js";
+import { FolderNotAuthorizedError } from "../../../../domain/folder/errors.js";
+declare class GetFolderWithFolderLevelPermissionsImpl implements GetFolderUseCase.Interface {
+    private folderLevelPermissions;
+    private readonly decoretee;
+    constructor(folderLevelPermissions: FolderLevelPermissions.Interface, decoretee: GetFolderUseCase.Interface);
+    execute(id: string): Promise<Result<never, FolderNotAuthorizedError | import("~/domain/folder/errors.js").FolderNotFoundError | import("~/domain/folder/errors.js").FolderPersistenceError> | Result<{
+        title: string;
+        slug: string;
+        type: string;
+        parentId?: string | null;
+        path: string;
+        extensions?: Record<string, any>;
+        id: string;
+        createdOn: string;
+        modifiedOn: string | null;
+        savedOn: string;
+        createdBy: import("../../../../types.js").User;
+        modifiedBy: import("../../../../types.js").User | null;
+        savedBy: import("../../../../types.js").User;
+        permissions: import("@webiny/shared-aco/flp/flp.types.js").FolderPermission[];
+    }, never>>;
+}
+export declare const GetFolderWithFolderLevelPermissions: typeof GetFolderWithFolderLevelPermissionsImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions.js").IGetFolderUseCase>;
+};
+export {};

package/features/folder/GetFolder/decorators/GetFolderWithFolderLevelPermissions.js

@@ -0,0 +1,34 @@
+import { GetFolderUseCase } from "../abstractions.js";
+import { Result } from "@webiny/feature/api";
+import { FolderLevelPermissions } from "../../../flp/FolderLevelPermissions/index.js";
+import { FolderNotAuthorizedError } from "../../../../domain/folder/errors.js";
+class GetFolderWithFolderLevelPermissionsImpl {
+    constructor(folderLevelPermissions, decoretee){
+        this.folderLevelPermissions = folderLevelPermissions;
+        this.decoretee = decoretee;
+    }
+    async execute(id) {
+        const result = await this.decoretee.execute(id);
+        if (result.isFail()) return Result.fail(result.error);
+        const folder = result.value;
+        const permissions = await this.folderLevelPermissions.getFolderLevelPermissions(folder.id);
+        const canAccessFolder = await this.folderLevelPermissions.canAccessFolder({
+            permissions,
+            rwd: "r"
+        });
+        if (!canAccessFolder) return Result.fail(new FolderNotAuthorizedError());
+        return Result.ok({
+            ...folder,
+            permissions
+        });
+    }
+}
+const GetFolderWithFolderLevelPermissions = GetFolderUseCase.createDecorator({
+    decorator: GetFolderWithFolderLevelPermissionsImpl,
+    dependencies: [
+        FolderLevelPermissions
+    ]
+});
+export { GetFolderWithFolderLevelPermissions };
+
+//# sourceMappingURL=GetFolderWithFolderLevelPermissions.js.map

package/features/folder/GetFolder/decorators/GetFolderWithFolderLevelPermissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/GetFolder/decorators/GetFolderWithFolderLevelPermissions.js","sources":["../../../../../src/features/folder/GetFolder/decorators/GetFolderWithFolderLevelPermissions.ts"],"sourcesContent":["import { GetFolderUseCase } from \"../abstractions.js\";\nimport { Result } from \"@webiny/feature/api\";\nimport { FolderLevelPermissions } from \"~/features/flp/FolderLevelPermissions/index.js\";\nimport { FolderNotAuthorizedError } from \"~/domain/folder/errors.js\";\n\nclass GetFolderWithFolderLevelPermissionsImpl implements GetFolderUseCase.Interface {\n    private folderLevelPermissions: FolderLevelPermissions.Interface;\n    private readonly decoretee: GetFolderUseCase.Interface;\n\n    constructor(\n        folderLevelPermissions: FolderLevelPermissions.Interface,\n        decoretee: GetFolderUseCase.Interface\n    ) {\n        this.folderLevelPermissions = folderLevelPermissions;\n        this.decoretee = decoretee;\n    }\n\n    async execute(id: string) {\n        const result = await this.decoretee.execute(id);\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        const folder = result.value;\n        const permissions = await this.folderLevelPermissions.getFolderLevelPermissions(folder.id);\n\n        // Let's check if the current user has read access level.\n        const canAccessFolder = await this.folderLevelPermissions.canAccessFolder({\n            permissions,\n            rwd: \"r\"\n        });\n\n        if (!canAccessFolder) {\n            return Result.fail(new FolderNotAuthorizedError());\n        }\n\n        return Result.ok({\n            ...folder,\n            permissions\n        });\n    }\n}\n\nexport const GetFolderWithFolderLevelPermissions = GetFolderUseCase.createDecorator({\n    decorator: GetFolderWithFolderLevelPermissionsImpl,\n    dependencies: [FolderLevelPermissions]\n});\n"],"names":["GetFolderWithFolderLevelPermissionsImpl","folderLevelPermissions","decoretee","id","result","Result","folder","permissions","canAccessFolder","FolderNotAuthorizedError","GetFolderWithFolderLevelPermissions","GetFolderUseCase","FolderLevelPermissions"],"mappings":";;;;AAKA,MAAMA;IAIF,YACIC,sBAAwD,EACxDC,SAAqC,CACvC;QACE,IAAI,CAAC,sBAAsB,GAAGD;QAC9B,IAAI,CAAC,SAAS,GAAGC;IACrB;IAEA,MAAM,QAAQC,EAAU,EAAE;QACtB,MAAMC,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACD;QAC5C,IAAIC,OAAO,MAAM,IACb,OAAOC,OAAO,IAAI,CAACD,OAAO,KAAK;QAGnC,MAAME,SAASF,OAAO,KAAK;QAC3B,MAAMG,cAAc,MAAM,IAAI,CAAC,sBAAsB,CAAC,yBAAyB,CAACD,OAAO,EAAE;QAGzF,MAAME,kBAAkB,MAAM,IAAI,CAAC,sBAAsB,CAAC,eAAe,CAAC;YACtED;YACA,KAAK;QACT;QAEA,IAAI,CAACC,iBACD,OAAOH,OAAO,IAAI,CAAC,IAAII;QAG3B,OAAOJ,OAAO,EAAE,CAAC;YACb,GAAGC,MAAM;YACTC;QACJ;IACJ;AACJ;AAEO,MAAMG,sCAAsCC,iBAAiB,eAAe,CAAC;IAChF,WAAWX;IACX,cAAc;QAACY;KAAuB;AAC1C"}

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

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

package/features/folder/GetFolder/feature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import { GetFolderRepository } from "./GetFolderRepository.js";
+import { GetFolderUseCase } from "./GetFolderUseCase.js";
+import { GetFolderWithFolderLevelPermissions } from "./decorators/GetFolderWithFolderLevelPermissions.js";
+const GetFolderFeature = createFeature({
+    name: "GetFolder",
+    register (container) {
+        container.register(GetFolderRepository).inSingletonScope();
+        container.register(GetFolderUseCase);
+        container.registerDecorator(GetFolderWithFolderLevelPermissions);
+    }
+});
+export { GetFolderFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/GetFolder/feature.js","sources":["../../../../src/features/folder/GetFolder/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport type { Container } from \"@webiny/di\";\nimport { GetFolderRepository } from \"./GetFolderRepository.js\";\nimport { GetFolderUseCase } from \"./GetFolderUseCase.js\";\nimport { GetFolderWithFolderLevelPermissions } from \"./decorators/GetFolderWithFolderLevelPermissions.js\";\n\nexport const GetFolderFeature = createFeature({\n    name: \"GetFolder\",\n    register(container: Container) {\n        container.register(GetFolderRepository).inSingletonScope();\n        container.register(GetFolderUseCase);\n        container.registerDecorator(GetFolderWithFolderLevelPermissions);\n    }\n});\n"],"names":["GetFolderFeature","createFeature","container","GetFolderRepository","GetFolderUseCase","GetFolderWithFolderLevelPermissions"],"mappings":";;;;AAMO,MAAMA,mBAAmBC,cAAc;IAC1C,MAAM;IACN,UAASC,SAAoB;QACzBA,UAAU,QAAQ,CAACC,qBAAqB,gBAAgB;QACxDD,UAAU,QAAQ,CAACE;QACnBF,UAAU,iBAAiB,CAACG;IAChC;AACJ"}

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

@@ -0,0 +1,2 @@
+export { GetFolderFeature } from "./feature.js";
+export { FolderAfterGetEventHandler, FolderBeforeGetEventHandler, GetFolderUseCase } from "./abstractions.js";

package/features/folder/GetFolder/index.js

@@ -0,0 +1,2 @@
+export { GetFolderFeature } from "./feature.js";
+export { FolderAfterGetEventHandler, FolderBeforeGetEventHandler, GetFolderUseCase } from "./abstractions.js";

package/features/folder/GetFolderHierarchy/GetFolderHierarchyRepository.d.ts

@@ -0,0 +1,18 @@
+import { Result } from "@webiny/feature/api";
+import { GetFolderHierarchyRepository as RepositoryAbstraction, type IGetFolderHierarchyRepository } from "./abstractions.js";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
+import { FolderModel } from "../../../domain/folder/abstractions.js";
+import type { GetFolderHierarchyParams, GetFolderHierarchyResponse } from "../../../folder/folder.types.js";
+declare class GetFolderHierarchyRepositoryImpl implements IGetFolderHierarchyRepository {
+    private getEntryById;
+    private listLatestEntries;
+    private folderModel;
+    constructor(getEntryById: GetEntryByIdUseCase.Interface, listLatestEntries: ListLatestEntriesUseCase.Interface, folderModel: FolderModel.Interface);
+    execute(params: GetFolderHierarchyParams): Promise<Result<GetFolderHierarchyResponse, RepositoryAbstraction.Error>>;
+    private getFolderParent;
+}
+export declare const GetFolderHierarchyRepository: typeof GetFolderHierarchyRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IGetFolderHierarchyRepository>;
+};
+export {};

package/features/folder/GetFolderHierarchy/GetFolderHierarchyRepository.js

@@ -0,0 +1,84 @@
+import { Result } from "@webiny/feature/api";
+import { GetFolderHierarchyRepository } from "./abstractions.js";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
+import { EntryId } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+import { FolderModel } from "../../../domain/folder/abstractions.js";
+import { EntryToFolderMapper } from "../shared/EntryToFolderMapper.js";
+import { FolderPersistenceError } from "../../../domain/folder/errors.js";
+import { ROOT_FOLDER } from "../../../constants.js";
+const FIXED_FOLDER_LISTING_LIMIT = 10000;
+class GetFolderHierarchyRepositoryImpl {
+    constructor(getEntryById, listLatestEntries, folderModel){
+        this.getEntryById = getEntryById;
+        this.listLatestEntries = listLatestEntries;
+        this.folderModel = folderModel;
+    }
+    async execute(params) {
+        const parents = [];
+        const siblings = [];
+        const rootFoldersResult = await this.listLatestEntries.execute(this.folderModel, {
+            where: {
+                values: {
+                    type: params.type,
+                    parentId: null
+                }
+            },
+            limit: FIXED_FOLDER_LISTING_LIMIT
+        });
+        if (rootFoldersResult.isFail()) return Result.fail(new FolderPersistenceError(rootFoldersResult.error));
+        const { entries: rootEntries } = rootFoldersResult.value;
+        siblings.push(...rootEntries.map((entry)=>EntryToFolderMapper.toFolder(entry)));
+        if (params.id === ROOT_FOLDER) return Result.ok({
+            parents,
+            siblings
+        });
+        const entryId = EntryId.from(params.id);
+        const folderResult = await this.getEntryById.execute(this.folderModel, entryId.toString());
+        if (folderResult.isFail()) return Result.fail(new FolderPersistenceError(folderResult.error));
+        const folder = EntryToFolderMapper.toFolder(folderResult.value);
+        parents.push(folder);
+        const getFolderParentResult = await this.getFolderParent(folder, parents);
+        if (getFolderParentResult.isFail()) return Result.fail(getFolderParentResult.error);
+        const parentIds = parents.map((f)=>f.id);
+        const childFoldersResult = await this.listLatestEntries.execute(this.folderModel, {
+            where: {
+                entryId_not_in: parentIds,
+                values: {
+                    type: folder.type,
+                    parentId_in: parentIds
+                }
+            },
+            limit: FIXED_FOLDER_LISTING_LIMIT
+        });
+        if (childFoldersResult.isFail()) return Result.fail(new FolderPersistenceError(childFoldersResult.error));
+        const { entries: childEntries } = childFoldersResult.value;
+        siblings.push(...childEntries.map((entry)=>EntryToFolderMapper.toFolder(entry)));
+        return Result.ok({
+            parents,
+            siblings
+        });
+    }
+    async getFolderParent(folder, parents) {
+        let currentFolder = folder;
+        while(currentFolder.parentId){
+            const parentResult = await this.getEntryById.execute(this.folderModel, EntryId.from(currentFolder.parentId).toString());
+            if (parentResult.isFail()) return Result.fail(new FolderPersistenceError(parentResult.error));
+            const parentFolder = EntryToFolderMapper.toFolder(parentResult.value);
+            parents.push(parentFolder);
+            currentFolder = parentFolder;
+        }
+        return Result.ok();
+    }
+}
+const GetFolderHierarchyRepository_GetFolderHierarchyRepository = GetFolderHierarchyRepository.createImplementation({
+    implementation: GetFolderHierarchyRepositoryImpl,
+    dependencies: [
+        GetEntryByIdUseCase,
+        ListLatestEntriesUseCase,
+        FolderModel
+    ]
+});
+export { GetFolderHierarchyRepository_GetFolderHierarchyRepository as GetFolderHierarchyRepository };
+
+//# sourceMappingURL=GetFolderHierarchyRepository.js.map

package/features/folder/GetFolderHierarchy/GetFolderHierarchyRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/GetFolderHierarchy/GetFolderHierarchyRepository.js","sources":["../../../../src/features/folder/GetFolderHierarchy/GetFolderHierarchyRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    GetFolderHierarchyRepository as RepositoryAbstraction,\n    type IGetFolderHierarchyRepository\n} from \"./abstractions.js\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries\";\nimport { EntryId } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\nimport { FolderModel } from \"~/domain/folder/abstractions.js\";\nimport type {\n    CmsEntryFolder,\n    Folder,\n    GetFolderHierarchyParams,\n    GetFolderHierarchyResponse\n} from \"~/folder/folder.types.js\";\nimport { EntryToFolderMapper } from \"../shared/EntryToFolderMapper.js\";\nimport { FolderPersistenceError } from \"~/domain/folder/errors.js\";\nimport { ROOT_FOLDER } from \"~/constants.js\";\n\nconst FIXED_FOLDER_LISTING_LIMIT = 10_000;\n\nclass GetFolderHierarchyRepositoryImpl implements IGetFolderHierarchyRepository {\n    constructor(\n        private getEntryById: GetEntryByIdUseCase.Interface,\n        private listLatestEntries: ListLatestEntriesUseCase.Interface,\n        private folderModel: FolderModel.Interface\n    ) {}\n\n    async execute(\n        params: GetFolderHierarchyParams\n    ): Promise<Result<GetFolderHierarchyResponse, RepositoryAbstraction.Error>> {\n        const parents: Folder[] = [];\n        const siblings: Folder[] = [];\n\n        // Get root folders (siblings at root level)\n        const rootFoldersResult = await this.listLatestEntries.execute<CmsEntryFolder>(\n            this.folderModel,\n            {\n                where: {\n                    values: {\n                        type: params.type,\n                        parentId: null\n                    }\n                },\n                limit: FIXED_FOLDER_LISTING_LIMIT\n            }\n        );\n\n        if (rootFoldersResult.isFail()) {\n            return Result.fail(new FolderPersistenceError(rootFoldersResult.error));\n        }\n\n        const { entries: rootEntries } = rootFoldersResult.value;\n        siblings.push(...rootEntries.map(entry => EntryToFolderMapper.toFolder(entry)));\n\n        if (params.id === ROOT_FOLDER) {\n            return Result.ok({\n                parents,\n                siblings\n            });\n        }\n\n        // Get the folder by id\n        const entryId = EntryId.from(params.id);\n        const folderResult = await this.getEntryById.execute<CmsEntryFolder>(\n            this.folderModel,\n            entryId.toString()\n        );\n\n        if (folderResult.isFail()) {\n            return Result.fail(new FolderPersistenceError(folderResult.error));\n        }\n\n        const folder = EntryToFolderMapper.toFolder(folderResult.value);\n        parents.push(folder);\n\n        // Recursively get all parent folders\n        const getFolderParentResult = await this.getFolderParent(folder, parents);\n        if (getFolderParentResult.isFail()) {\n            return Result.fail(getFolderParentResult.error);\n        }\n\n        // Get all child folders of all parents (these are siblings at different levels)\n        const parentIds = parents.map(f => f.id);\n\n        const childFoldersResult = await this.listLatestEntries.execute<CmsEntryFolder>(\n            this.folderModel,\n            {\n                where: {\n                    entryId_not_in: parentIds,\n                    values: {\n                        type: folder.type,\n                        parentId_in: parentIds\n                    }\n                },\n                limit: FIXED_FOLDER_LISTING_LIMIT\n            }\n        );\n\n        if (childFoldersResult.isFail()) {\n            return Result.fail(new FolderPersistenceError(childFoldersResult.error));\n        }\n\n        const { entries: childEntries } = childFoldersResult.value;\n        siblings.push(...childEntries.map(entry => EntryToFolderMapper.toFolder(entry)));\n\n        return Result.ok({\n            parents,\n            siblings\n        });\n    }\n\n    private async getFolderParent(\n        folder: Folder,\n        parents: Folder[]\n    ): Promise<Result<void, RepositoryAbstraction.Error>> {\n        let currentFolder = folder;\n\n        while (currentFolder.parentId) {\n            const parentResult = await this.getEntryById.execute<CmsEntryFolder>(\n                this.folderModel,\n                EntryId.from(currentFolder.parentId).toString()\n            );\n\n            if (parentResult.isFail()) {\n                return Result.fail(new FolderPersistenceError(parentResult.error));\n            }\n\n            const parentFolder = EntryToFolderMapper.toFolder(parentResult.value);\n            parents.push(parentFolder);\n            currentFolder = parentFolder;\n        }\n\n        return Result.ok();\n    }\n}\n\nexport const GetFolderHierarchyRepository = RepositoryAbstraction.createImplementation({\n    implementation: GetFolderHierarchyRepositoryImpl,\n    dependencies: [GetEntryByIdUseCase, ListLatestEntriesUseCase, FolderModel]\n});\n"],"names":["FIXED_FOLDER_LISTING_LIMIT","GetFolderHierarchyRepositoryImpl","getEntryById","listLatestEntries","folderModel","params","parents","siblings","rootFoldersResult","Result","FolderPersistenceError","rootEntries","entry","EntryToFolderMapper","ROOT_FOLDER","entryId","EntryId","folderResult","folder","getFolderParentResult","parentIds","f","childFoldersResult","childEntries","currentFolder","parentResult","parentFolder","GetFolderHierarchyRepository","RepositoryAbstraction","GetEntryByIdUseCase","ListLatestEntriesUseCase","FolderModel"],"mappings":";;;;;;;;;AAmBA,MAAMA,6BAA6B;AAEnC,MAAMC;IACF,YACYC,YAA2C,EAC3CC,iBAAqD,EACrDC,WAAkC,CAC5C;aAHUF,YAAY,GAAZA;aACAC,iBAAiB,GAAjBA;aACAC,WAAW,GAAXA;IACT;IAEH,MAAM,QACFC,MAAgC,EACwC;QACxE,MAAMC,UAAoB,EAAE;QAC5B,MAAMC,WAAqB,EAAE;QAG7B,MAAMC,oBAAoB,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAC1D,IAAI,CAAC,WAAW,EAChB;YACI,OAAO;gBACH,QAAQ;oBACJ,MAAMH,OAAO,IAAI;oBACjB,UAAU;gBACd;YACJ;YACA,OAAOL;QACX;QAGJ,IAAIQ,kBAAkB,MAAM,IACxB,OAAOC,OAAO,IAAI,CAAC,IAAIC,uBAAuBF,kBAAkB,KAAK;QAGzE,MAAM,EAAE,SAASG,WAAW,EAAE,GAAGH,kBAAkB,KAAK;QACxDD,SAAS,IAAI,IAAII,YAAY,GAAG,CAACC,CAAAA,QAASC,oBAAoB,QAAQ,CAACD;QAEvE,IAAIP,OAAO,EAAE,KAAKS,aACd,OAAOL,OAAO,EAAE,CAAC;YACbH;YACAC;QACJ;QAIJ,MAAMQ,UAAUC,QAAQ,IAAI,CAACX,OAAO,EAAE;QACtC,MAAMY,eAAe,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAChD,IAAI,CAAC,WAAW,EAChBF,QAAQ,QAAQ;QAGpB,IAAIE,aAAa,MAAM,IACnB,OAAOR,OAAO,IAAI,CAAC,IAAIC,uBAAuBO,aAAa,KAAK;QAGpE,MAAMC,SAASL,oBAAoB,QAAQ,CAACI,aAAa,KAAK;QAC9DX,QAAQ,IAAI,CAACY;QAGb,MAAMC,wBAAwB,MAAM,IAAI,CAAC,eAAe,CAACD,QAAQZ;QACjE,IAAIa,sBAAsB,MAAM,IAC5B,OAAOV,OAAO,IAAI,CAACU,sBAAsB,KAAK;QAIlD,MAAMC,YAAYd,QAAQ,GAAG,CAACe,CAAAA,IAAKA,EAAE,EAAE;QAEvC,MAAMC,qBAAqB,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAC3D,IAAI,CAAC,WAAW,EAChB;YACI,OAAO;gBACH,gBAAgBF;gBAChB,QAAQ;oBACJ,MAAMF,OAAO,IAAI;oBACjB,aAAaE;gBACjB;YACJ;YACA,OAAOpB;QACX;QAGJ,IAAIsB,mBAAmB,MAAM,IACzB,OAAOb,OAAO,IAAI,CAAC,IAAIC,uBAAuBY,mBAAmB,KAAK;QAG1E,MAAM,EAAE,SAASC,YAAY,EAAE,GAAGD,mBAAmB,KAAK;QAC1Df,SAAS,IAAI,IAAIgB,aAAa,GAAG,CAACX,CAAAA,QAASC,oBAAoB,QAAQ,CAACD;QAExE,OAAOH,OAAO,EAAE,CAAC;YACbH;YACAC;QACJ;IACJ;IAEA,MAAc,gBACVW,MAAc,EACdZ,OAAiB,EACiC;QAClD,IAAIkB,gBAAgBN;QAEpB,MAAOM,cAAc,QAAQ,CAAE;YAC3B,MAAMC,eAAe,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAChD,IAAI,CAAC,WAAW,EAChBT,QAAQ,IAAI,CAACQ,cAAc,QAAQ,EAAE,QAAQ;YAGjD,IAAIC,aAAa,MAAM,IACnB,OAAOhB,OAAO,IAAI,CAAC,IAAIC,uBAAuBe,aAAa,KAAK;YAGpE,MAAMC,eAAeb,oBAAoB,QAAQ,CAACY,aAAa,KAAK;YACpEnB,QAAQ,IAAI,CAACoB;YACbF,gBAAgBE;QACpB;QAEA,OAAOjB,OAAO,EAAE;IACpB;AACJ;AAEO,MAAMkB,4DAA+BC,6BAAAA,oBAA0C,CAAC;IACnF,gBAAgB3B;IAChB,cAAc;QAAC4B;QAAqBC;QAA0BC;KAAY;AAC9E"}

package/features/folder/GetFolderHierarchy/GetFolderHierarchyUseCase.d.ts

@@ -0,0 +1,10 @@
+import { Result } from "@webiny/feature/api";
+import { GetFolderHierarchyUseCase as UseCaseAbstraction, GetFolderHierarchyRepository } from "./abstractions.js";
+import type { GetFolderHierarchyParams, GetFolderHierarchyResponse } from "../../../folder/folder.types.js";
+declare class GetFolderHierarchyUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    constructor(repository: GetFolderHierarchyRepository.Interface);
+    execute(params: GetFolderHierarchyParams): Promise<Result<GetFolderHierarchyResponse, UseCaseAbstraction.Error>>;
+}
+export declare const GetFolderHierarchyUseCase: import("@webiny/di").Implementation<typeof GetFolderHierarchyUseCaseImpl>;
+export {};

package/features/folder/GetFolderHierarchy/GetFolderHierarchyUseCase.js

@@ -0,0 +1,20 @@
+import { GetFolderHierarchyRepository, GetFolderHierarchyUseCase } from "./abstractions.js";
+import { createImplementation } from "@webiny/di";
+class GetFolderHierarchyUseCaseImpl {
+    constructor(repository){
+        this.repository = repository;
+    }
+    async execute(params) {
+        return await this.repository.execute(params);
+    }
+}
+const GetFolderHierarchyUseCase_GetFolderHierarchyUseCase = createImplementation({
+    abstraction: GetFolderHierarchyUseCase,
+    implementation: GetFolderHierarchyUseCaseImpl,
+    dependencies: [
+        GetFolderHierarchyRepository
+    ]
+});
+export { GetFolderHierarchyUseCase_GetFolderHierarchyUseCase as GetFolderHierarchyUseCase };
+
+//# sourceMappingURL=GetFolderHierarchyUseCase.js.map

package/features/folder/GetFolderHierarchy/GetFolderHierarchyUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/GetFolderHierarchy/GetFolderHierarchyUseCase.js","sources":["../../../../src/features/folder/GetFolderHierarchy/GetFolderHierarchyUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    GetFolderHierarchyUseCase as UseCaseAbstraction,\n    GetFolderHierarchyRepository\n} from \"./abstractions.js\";\nimport type {\n    GetFolderHierarchyParams,\n    GetFolderHierarchyResponse\n} from \"~/folder/folder.types.js\";\nimport { createImplementation } from \"@webiny/di\";\n\nclass GetFolderHierarchyUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: GetFolderHierarchyRepository.Interface) {}\n\n    async execute(\n        params: GetFolderHierarchyParams\n    ): Promise<Result<GetFolderHierarchyResponse, UseCaseAbstraction.Error>> {\n        return await this.repository.execute(params);\n    }\n}\n\nexport const GetFolderHierarchyUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: GetFolderHierarchyUseCaseImpl,\n    dependencies: [GetFolderHierarchyRepository]\n});\n"],"names":["GetFolderHierarchyUseCaseImpl","repository","params","GetFolderHierarchyUseCase","createImplementation","UseCaseAbstraction","GetFolderHierarchyRepository"],"mappings":";;AAWA,MAAMA;IACF,YAAoBC,UAAkD,CAAE;aAApDA,UAAU,GAAVA;IAAqD;IAEzE,MAAM,QACFC,MAAgC,EACqC;QACrE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;IACzC;AACJ;AAEO,MAAMC,sDAA4BC,qBAAqB;IAC1D,aAAaC;IACb,gBAAgBL;IAChB,cAAc;QAACM;KAA6B;AAChD"}

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

@@ -0,0 +1,38 @@
+import type { Result } from "@webiny/feature/api";
+import type { GetFolderHierarchyParams, GetFolderHierarchyResponse } from "../../../folder/folder.types.js";
+import type { FolderNotAuthorizedError, FolderPersistenceError } from "../../../domain/folder/errors.js";
+/**
+ * GetFolderHierarchy repository interface
+ */
+export interface IGetFolderHierarchyRepository {
+    execute(params: GetFolderHierarchyParams): Promise<Result<GetFolderHierarchyResponse, RepositoryError>>;
+}
+export interface IGetFolderHierarchyRepositoryErrors {
+    persistence: FolderPersistenceError;
+}
+type RepositoryError = IGetFolderHierarchyRepositoryErrors[keyof IGetFolderHierarchyRepositoryErrors];
+/** Fetch folder hierarchy from storage. */
+export declare const GetFolderHierarchyRepository: import("@webiny/di").Abstraction<IGetFolderHierarchyRepository>;
+export declare namespace GetFolderHierarchyRepository {
+    type Interface = IGetFolderHierarchyRepository;
+    type Error = RepositoryError;
+}
+/**
+ * GetFolderHierarchy use case interface
+ */
+export interface IGetFolderHierarchyUseCase {
+    execute(params: GetFolderHierarchyParams): Promise<Result<GetFolderHierarchyResponse, UseCaseError>>;
+}
+export interface IGetFolderHierarchyUseCaseErrors {
+    notAuthorized: FolderNotAuthorizedError;
+    persistence: FolderPersistenceError;
+}
+type UseCaseError = IGetFolderHierarchyUseCaseErrors[keyof IGetFolderHierarchyUseCaseErrors];
+/** Retrieve the full folder hierarchy. */
+export declare const GetFolderHierarchyUseCase: import("@webiny/di").Abstraction<IGetFolderHierarchyUseCase>;
+export declare namespace GetFolderHierarchyUseCase {
+    type Interface = IGetFolderHierarchyUseCase;
+    type Return = Promise<Result<GetFolderHierarchyResponse, UseCaseError>>;
+    type Error = UseCaseError;
+}
+export {};

package/features/folder/GetFolderHierarchy/abstractions.js

@@ -0,0 +1,6 @@
+import { createAbstraction } from "@webiny/feature/api";
+const GetFolderHierarchyRepository = createAbstraction("GetFolderHierarchyRepository");
+const GetFolderHierarchyUseCase = createAbstraction("GetFolderHierarchyUseCase");
+export { GetFolderHierarchyRepository, GetFolderHierarchyUseCase };
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/GetFolderHierarchy/abstractions.js","sources":["../../../../src/features/folder/GetFolderHierarchy/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type {\n    GetFolderHierarchyParams,\n    GetFolderHierarchyResponse\n} from \"~/folder/folder.types.js\";\nimport type { FolderNotAuthorizedError, FolderPersistenceError } from \"~/domain/folder/errors.js\";\n\n/**\n * GetFolderHierarchy repository interface\n */\nexport interface IGetFolderHierarchyRepository {\n    execute(\n        params: GetFolderHierarchyParams\n    ): Promise<Result<GetFolderHierarchyResponse, RepositoryError>>;\n}\n\nexport interface IGetFolderHierarchyRepositoryErrors {\n    persistence: FolderPersistenceError;\n}\n\ntype RepositoryError =\n    IGetFolderHierarchyRepositoryErrors[keyof IGetFolderHierarchyRepositoryErrors];\n\n/** Fetch folder hierarchy from storage. */\nexport const GetFolderHierarchyRepository = createAbstraction<IGetFolderHierarchyRepository>(\n    \"GetFolderHierarchyRepository\"\n);\n\nexport namespace GetFolderHierarchyRepository {\n    export type Interface = IGetFolderHierarchyRepository;\n    export type Error = RepositoryError;\n}\n\n/**\n * GetFolderHierarchy use case interface\n */\nexport interface IGetFolderHierarchyUseCase {\n    execute(\n        params: GetFolderHierarchyParams\n    ): Promise<Result<GetFolderHierarchyResponse, UseCaseError>>;\n}\n\nexport interface IGetFolderHierarchyUseCaseErrors {\n    notAuthorized: FolderNotAuthorizedError;\n    persistence: FolderPersistenceError;\n}\n\ntype UseCaseError = IGetFolderHierarchyUseCaseErrors[keyof IGetFolderHierarchyUseCaseErrors];\n\n/** Retrieve the full folder hierarchy. */\nexport const GetFolderHierarchyUseCase = createAbstraction<IGetFolderHierarchyUseCase>(\n    \"GetFolderHierarchyUseCase\"\n);\n\nexport namespace GetFolderHierarchyUseCase {\n    export type Interface = IGetFolderHierarchyUseCase;\n    export type Return = Promise<Result<GetFolderHierarchyResponse, UseCaseError>>;\n    export type Error = UseCaseError;\n}\n"],"names":["GetFolderHierarchyRepository","createAbstraction","GetFolderHierarchyUseCase"],"mappings":";AAyBO,MAAMA,+BAA+BC,kBACxC;AAyBG,MAAMC,4BAA4BD,kBACrC"}

package/features/folder/GetFolderHierarchy/decorators/GetFolderHierarchyWithFolderLevelPermissions.d.ts

@@ -0,0 +1,16 @@
+import { FolderLevelPermissions } from "../../../../features/flp/FolderLevelPermissions/index.js";
+import { GetFolderHierarchyUseCase } from "../abstractions.js";
+import type { GetFolderHierarchyParams } from "../../../../folder/folder.types.js";
+declare class GetFolderHierarchyWithFolderLevelPermissionsImpl implements GetFolderHierarchyUseCase.Interface {
+    private folderLevelPermissions;
+    private decoratee;
+    private flpCatalog;
+    constructor(folderLevelPermissions: FolderLevelPermissions.Interface, decoratee: GetFolderHierarchyUseCase.Interface);
+    execute(params: GetFolderHierarchyParams): GetFolderHierarchyUseCase.Return;
+    private filterAccessibleFolders;
+    private hasFlp;
+    private getFlp;
+    private setFlp;
+}
+export declare const GetFolderHierarchyWithFolderLevelPermissions: typeof GetFolderHierarchyWithFolderLevelPermissionsImpl;
+export {};

package/features/folder/GetFolderHierarchy/decorators/GetFolderHierarchyWithFolderLevelPermissions.js

@@ -0,0 +1,63 @@
+import { Result, createDecorator } from "@webiny/feature/api";
+import { FolderLevelPermissions } from "../../../flp/FolderLevelPermissions/index.js";
+import { GetFolderHierarchyUseCase } from "../abstractions.js";
+class GetFolderHierarchyWithFolderLevelPermissionsImpl {
+    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 { siblings, parents } = result.value;
+        const folders = [
+            ...parents,
+            ...siblings
+        ];
+        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);
+            }
+        }));
+        return Result.ok({
+            parents: await this.filterAccessibleFolders(parents),
+            siblings: await this.filterAccessibleFolders(siblings)
+        });
+    }
+    async filterAccessibleFolders(folders) {
+        const results = await Promise.all(folders.map(async (folder)=>{
+            const permissions = this.getFlp(folder.id);
+            if (!permissions) return folder;
+            const canAccess = await this.folderLevelPermissions.canAccessFolder({
+                permissions,
+                rwd: "r"
+            });
+            return canAccess ? {
+                ...folder,
+                permissions
+            } : null;
+        }));
+        return results.filter((folder)=>null !== folder);
+    }
+    hasFlp(id) {
+        return this.flpCatalog.has(id);
+    }
+    getFlp(id) {
+        return this.flpCatalog.get(id);
+    }
+    setFlp(id, permissions) {
+        this.flpCatalog.set(id, permissions);
+    }
+}
+const GetFolderHierarchyWithFolderLevelPermissions = createDecorator({
+    abstraction: GetFolderHierarchyUseCase,
+    decorator: GetFolderHierarchyWithFolderLevelPermissionsImpl,
+    dependencies: [
+        FolderLevelPermissions
+    ]
+});
+export { GetFolderHierarchyWithFolderLevelPermissions };
+
+//# sourceMappingURL=GetFolderHierarchyWithFolderLevelPermissions.js.map

package/features/folder/GetFolderHierarchy/decorators/GetFolderHierarchyWithFolderLevelPermissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/GetFolderHierarchy/decorators/GetFolderHierarchyWithFolderLevelPermissions.js","sources":["../../../../../src/features/folder/GetFolderHierarchy/decorators/GetFolderHierarchyWithFolderLevelPermissions.ts"],"sourcesContent":["import { createDecorator, Result } from \"@webiny/feature/api\";\nimport type { FolderPermission } from \"~/flp/flp.types.js\";\nimport { FolderLevelPermissions } from \"~/features/flp/FolderLevelPermissions/index.js\";\nimport { GetFolderHierarchyUseCase } from \"../abstractions.js\";\nimport type { Folder, GetFolderHierarchyParams } from \"~/folder/folder.types.js\";\n\nclass GetFolderHierarchyWithFolderLevelPermissionsImpl\n    implements GetFolderHierarchyUseCase.Interface\n{\n    private flpCatalog: Map<string, FolderPermission[]> = new Map();\n\n    constructor(\n        private folderLevelPermissions: FolderLevelPermissions.Interface,\n        private decoratee: GetFolderHierarchyUseCase.Interface\n    ) {}\n\n    async execute(params: GetFolderHierarchyParams): GetFolderHierarchyUseCase.Return {\n        const result = await this.decoratee.execute(params);\n\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        const { siblings, parents } = result.value;\n        const folders = [...parents, ...siblings];\n\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        return Result.ok({\n            parents: await this.filterAccessibleFolders(parents),\n            siblings: await this.filterAccessibleFolders(siblings)\n        });\n    }\n\n    private async filterAccessibleFolders(folders: Folder[]): Promise<Folder[]> {\n        const results = await Promise.all(\n            folders.map(async folder => {\n                const permissions = this.getFlp(folder.id);\n                if (!permissions) {\n                    return folder;\n                }\n\n                const canAccess = await this.folderLevelPermissions.canAccessFolder({\n                    permissions,\n                    rwd: \"r\"\n                });\n\n                return canAccess ? { ...folder, permissions } : null;\n            })\n        );\n        return results.filter((folder): folder is Folder => folder !== null);\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 GetFolderHierarchyWithFolderLevelPermissions = createDecorator({\n    abstraction: GetFolderHierarchyUseCase,\n    decorator: GetFolderHierarchyWithFolderLevelPermissionsImpl,\n    dependencies: [FolderLevelPermissions]\n});\n"],"names":["GetFolderHierarchyWithFolderLevelPermissionsImpl","folderLevelPermissions","decoratee","Map","params","result","Result","siblings","parents","folders","Promise","folder","permissions","results","canAccess","id","GetFolderHierarchyWithFolderLevelPermissions","createDecorator","GetFolderHierarchyUseCase","FolderLevelPermissions"],"mappings":";;;AAMA,MAAMA;IAKF,YACYC,sBAAwD,EACxDC,SAA8C,CACxD;aAFUD,sBAAsB,GAAtBA;aACAC,SAAS,GAATA;aAJJ,UAAU,GAAoC,IAAIC;IAKvD;IAEH,MAAM,QAAQC,MAAgC,EAAoC;QAC9E,MAAMC,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACD;QAE5C,IAAIC,OAAO,MAAM,IACb,OAAOC,OAAO,IAAI,CAACD,OAAO,KAAK;QAGnC,MAAM,EAAEE,QAAQ,EAAEC,OAAO,EAAE,GAAGH,OAAO,KAAK;QAC1C,MAAMI,UAAU;eAAID;eAAYD;SAAS;QAEzC,MAAMG,QAAQ,GAAG,CACbD,QAAQ,GAAG,CAAC,OAAME;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;QAGJ,OAAON,OAAO,EAAE,CAAC;YACb,SAAS,MAAM,IAAI,CAAC,uBAAuB,CAACE;YAC5C,UAAU,MAAM,IAAI,CAAC,uBAAuB,CAACD;QACjD;IACJ;IAEA,MAAc,wBAAwBE,OAAiB,EAAqB;QACxE,MAAMI,UAAU,MAAMH,QAAQ,GAAG,CAC7BD,QAAQ,GAAG,CAAC,OAAME;YACd,MAAMC,cAAc,IAAI,CAAC,MAAM,CAACD,OAAO,EAAE;YACzC,IAAI,CAACC,aACD,OAAOD;YAGX,MAAMG,YAAY,MAAM,IAAI,CAAC,sBAAsB,CAAC,eAAe,CAAC;gBAChEF;gBACA,KAAK;YACT;YAEA,OAAOE,YAAY;gBAAE,GAAGH,MAAM;gBAAEC;YAAY,IAAI;QACpD;QAEJ,OAAOC,QAAQ,MAAM,CAAC,CAACF,SAA6BA,AAAW,SAAXA;IACxD;IAEQ,OAAOI,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,EAAEH,WAA+B,EAAQ;QAC9D,IAAI,CAAC,UAAU,CAAC,GAAG,CAACG,IAAIH;IAC5B;AACJ;AAEO,MAAMI,+CAA+CC,gBAAgB;IACxE,aAAaC;IACb,WAAWlB;IACX,cAAc;QAACmB;KAAuB;AAC1C"}

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

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

package/features/folder/GetFolderHierarchy/feature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import { GetFolderHierarchyRepository } from "./GetFolderHierarchyRepository.js";
+import { GetFolderHierarchyUseCase } from "./GetFolderHierarchyUseCase.js";
+import { GetFolderHierarchyWithFolderLevelPermissions } from "./decorators/GetFolderHierarchyWithFolderLevelPermissions.js";
+const GetFolderHierarchyFeature = createFeature({
+    name: "GetFolderHierarchy",
+    register (container) {
+        container.register(GetFolderHierarchyRepository).inSingletonScope();
+        container.register(GetFolderHierarchyUseCase);
+        container.registerDecorator(GetFolderHierarchyWithFolderLevelPermissions);
+    }
+});
+export { GetFolderHierarchyFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/GetFolderHierarchy/feature.js","sources":["../../../../src/features/folder/GetFolderHierarchy/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport type { Container } from \"@webiny/di\";\nimport { GetFolderHierarchyRepository } from \"./GetFolderHierarchyRepository.js\";\nimport { GetFolderHierarchyUseCase } from \"./GetFolderHierarchyUseCase.js\";\nimport { GetFolderHierarchyWithFolderLevelPermissions } from \"./decorators/GetFolderHierarchyWithFolderLevelPermissions.js\";\n\nexport const GetFolderHierarchyFeature = createFeature({\n    name: \"GetFolderHierarchy\",\n    register(container: Container) {\n        container.register(GetFolderHierarchyRepository).inSingletonScope();\n        container.register(GetFolderHierarchyUseCase);\n        container.registerDecorator(GetFolderHierarchyWithFolderLevelPermissions);\n    }\n});\n"],"names":["GetFolderHierarchyFeature","createFeature","container","GetFolderHierarchyRepository","GetFolderHierarchyUseCase","GetFolderHierarchyWithFolderLevelPermissions"],"mappings":";;;;AAMO,MAAMA,4BAA4BC,cAAc;IACnD,MAAM;IACN,UAASC,SAAoB;QACzBA,UAAU,QAAQ,CAACC,8BAA8B,gBAAgB;QACjED,UAAU,QAAQ,CAACE;QACnBF,UAAU,iBAAiB,CAACG;IAChC;AACJ"}

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

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

package/features/folder/GetFolderHierarchy/index.js

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

package/features/folder/ListFolderLevelPermissionsTargets/ListFolderLevelPermissionsTargetsUseCase.d.ts

@@ -0,0 +1,13 @@
+import { ListFolderLevelPermissionsTargetsUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { ListUsersUseCase } from "@webiny/api-core/features/users/ListUsers/index.js";
+import { ListTeamsUseCase } from "@webiny/api-core/features/security/teams/ListTeams/index.js";
+declare class ListFolderLevelPermissionsTargetsUseCaseImpl implements UseCaseAbstraction.Interface {
+    private listAdminUsers;
+    private listTeams;
+    constructor(listAdminUsers: ListUsersUseCase.Interface, listTeams: ListTeamsUseCase.Interface);
+    execute(): UseCaseAbstraction.Return;
+}
+export declare const ListFolderLevelPermissionsTargetsUseCase: typeof ListFolderLevelPermissionsTargetsUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IListFolderLevelPermissionsTargetsUseCase>;
+};
+export {};

package/features/folder/ListFolderLevelPermissionsTargets/ListFolderLevelPermissionsTargetsUseCase.js

@@ -0,0 +1,75 @@
+import { Result } from "@webiny/feature/api";
+import { ListFolderLevelPermissionsTargetsUseCase } from "./abstractions.js";
+import { validation } from "@webiny/validation";
+import { ListUsersUseCase } from "@webiny/api-core/features/users/ListUsers/index.js";
+import { ListTeamsUseCase } from "@webiny/api-core/features/security/teams/ListTeams/index.js";
+class ListFolderLevelPermissionsTargetsUseCaseImpl {
+    constructor(listAdminUsers, listTeams){
+        this.listAdminUsers = listAdminUsers;
+        this.listTeams = listTeams;
+    }
+    async execute() {
+        const adminUsersResult = await this.listAdminUsers.execute();
+        const teamsResult = await this.listTeams.execute();
+        if (adminUsersResult.isFail() || teamsResult.isFail()) return Result.ok([
+            [],
+            {
+                totalCount: 0
+            }
+        ]);
+        const adminUsers = adminUsersResult.value;
+        const teams = teamsResult.value;
+        const teamTargets = teams.map((team)=>({
+                id: team.id,
+                type: "team",
+                target: `team:${team.slug}`,
+                name: team.name || "",
+                meta: {}
+            }));
+        const adminUserTargets = adminUsers.map((user)=>{
+            let name = user.displayName;
+            if (!name) name = [
+                user.firstName,
+                user.lastName
+            ].filter(Boolean).join(" ");
+            let email = user.email;
+            try {
+                validation.validateSync(email, "email");
+            } catch  {
+                email = null;
+            }
+            const image = user.avatar?.src || null;
+            return {
+                id: user.id,
+                type: "admin",
+                target: `admin:${user.id}`,
+                name,
+                meta: {
+                    email,
+                    image
+                }
+            };
+        });
+        const results = [
+            ...teamTargets,
+            ...adminUserTargets
+        ];
+        const meta = {
+            totalCount: results.length
+        };
+        return Result.ok([
+            results,
+            meta
+        ]);
+    }
+}
+const ListFolderLevelPermissionsTargetsUseCase_ListFolderLevelPermissionsTargetsUseCase = ListFolderLevelPermissionsTargetsUseCase.createImplementation({
+    implementation: ListFolderLevelPermissionsTargetsUseCaseImpl,
+    dependencies: [
+        ListUsersUseCase,
+        ListTeamsUseCase
+    ]
+});
+export { ListFolderLevelPermissionsTargetsUseCase_ListFolderLevelPermissionsTargetsUseCase as ListFolderLevelPermissionsTargetsUseCase };
+
+//# sourceMappingURL=ListFolderLevelPermissionsTargetsUseCase.js.map

package/features/folder/ListFolderLevelPermissionsTargets/ListFolderLevelPermissionsTargetsUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/ListFolderLevelPermissionsTargets/ListFolderLevelPermissionsTargetsUseCase.js","sources":["../../../../src/features/folder/ListFolderLevelPermissionsTargets/ListFolderLevelPermissionsTargetsUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { ListFolderLevelPermissionsTargetsUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { validation } from \"@webiny/validation\";\nimport { ListUsersUseCase } from \"@webiny/api-core/features/users/ListUsers/index.js\";\nimport { ListTeamsUseCase } from \"@webiny/api-core/features/security/teams/ListTeams/index.js\";\n\nclass ListFolderLevelPermissionsTargetsUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private listAdminUsers: ListUsersUseCase.Interface,\n        private listTeams: ListTeamsUseCase.Interface\n    ) {}\n\n    public async execute(): UseCaseAbstraction.Return {\n        const adminUsersResult = await this.listAdminUsers.execute();\n        const teamsResult = await this.listTeams.execute();\n\n        if (adminUsersResult.isFail() || teamsResult.isFail()) {\n            return Result.ok([[], { totalCount: 0 }]);\n        }\n\n        const adminUsers = adminUsersResult.value;\n        const teams = teamsResult.value;\n\n        const teamTargets = teams.map(team => ({\n            id: team.id,\n            type: \"team\",\n            target: `team:${team.slug}`,\n            name: team.name || \"\",\n            meta: {}\n        }));\n\n        const adminUserTargets = adminUsers.map(user => {\n            let name = user.displayName;\n            if (!name) {\n                // For backwards compatibility, we also want to try concatenating first and last name.\n                name = [user.firstName, user.lastName].filter(Boolean).join(\" \");\n            }\n\n            // We're doing the validation because, with non-Cognito IdPs (Okta, Auth0), the email\n            // field might actually contain a non-email value: `id:${IdP_Identity_ID}`. In that case,\n            // let's not assign anything to the `email` field.\n            let email: string | null = user.email;\n            try {\n                validation.validateSync(email, \"email\");\n            } catch {\n                email = null;\n            }\n\n            const image = user.avatar?.src || null;\n\n            return {\n                id: user.id,\n                type: \"admin\",\n                target: `admin:${user.id}`,\n                name,\n                meta: {\n                    email,\n                    image\n                }\n            };\n        });\n\n        const results = [...teamTargets, ...adminUserTargets];\n        const meta = { totalCount: results.length };\n\n        return Result.ok([results, meta]);\n    }\n}\n\nexport const ListFolderLevelPermissionsTargetsUseCase = UseCaseAbstraction.createImplementation({\n    implementation: ListFolderLevelPermissionsTargetsUseCaseImpl,\n    dependencies: [ListUsersUseCase, ListTeamsUseCase]\n});\n"],"names":["ListFolderLevelPermissionsTargetsUseCaseImpl","listAdminUsers","listTeams","adminUsersResult","teamsResult","Result","adminUsers","teams","teamTargets","team","adminUserTargets","user","name","Boolean","email","validation","image","results","meta","ListFolderLevelPermissionsTargetsUseCase","UseCaseAbstraction","ListUsersUseCase","ListTeamsUseCase"],"mappings":";;;;;AAMA,MAAMA;IACF,YACYC,cAA0C,EAC1CC,SAAqC,CAC/C;aAFUD,cAAc,GAAdA;aACAC,SAAS,GAATA;IACT;IAEH,MAAa,UAAqC;QAC9C,MAAMC,mBAAmB,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO;QAC1D,MAAMC,cAAc,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO;QAEhD,IAAID,iBAAiB,MAAM,MAAMC,YAAY,MAAM,IAC/C,OAAOC,OAAO,EAAE,CAAC;YAAC,EAAE;YAAE;gBAAE,YAAY;YAAE;SAAE;QAG5C,MAAMC,aAAaH,iBAAiB,KAAK;QACzC,MAAMI,QAAQH,YAAY,KAAK;QAE/B,MAAMI,cAAcD,MAAM,GAAG,CAACE,CAAAA,OAAS;gBACnC,IAAIA,KAAK,EAAE;gBACX,MAAM;gBACN,QAAQ,CAAC,KAAK,EAAEA,KAAK,IAAI,EAAE;gBAC3B,MAAMA,KAAK,IAAI,IAAI;gBACnB,MAAM,CAAC;YACX;QAEA,MAAMC,mBAAmBJ,WAAW,GAAG,CAACK,CAAAA;YACpC,IAAIC,OAAOD,KAAK,WAAW;YAC3B,IAAI,CAACC,MAEDA,OAAO;gBAACD,KAAK,SAAS;gBAAEA,KAAK,QAAQ;aAAC,CAAC,MAAM,CAACE,SAAS,IAAI,CAAC;YAMhE,IAAIC,QAAuBH,KAAK,KAAK;YACrC,IAAI;gBACAI,WAAW,YAAY,CAACD,OAAO;YACnC,EAAE,OAAM;gBACJA,QAAQ;YACZ;YAEA,MAAME,QAAQL,KAAK,MAAM,EAAE,OAAO;YAElC,OAAO;gBACH,IAAIA,KAAK,EAAE;gBACX,MAAM;gBACN,QAAQ,CAAC,MAAM,EAAEA,KAAK,EAAE,EAAE;gBAC1BC;gBACA,MAAM;oBACFE;oBACAE;gBACJ;YACJ;QACJ;QAEA,MAAMC,UAAU;eAAIT;eAAgBE;SAAiB;QACrD,MAAMQ,OAAO;YAAE,YAAYD,QAAQ,MAAM;QAAC;QAE1C,OAAOZ,OAAO,EAAE,CAAC;YAACY;YAASC;SAAK;IACpC;AACJ;AAEO,MAAMC,oFAA2CC,yCAAAA,oBAAuC,CAAC;IAC5F,gBAAgBpB;IAChB,cAAc;QAACqB;QAAkBC;KAAiB;AACtD"}

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

@@ -0,0 +1,11 @@
+import { Result } from "@webiny/feature/api";
+import type { FolderLevelPermissionsTarget, FolderLevelPermissionsTargetListMeta } from "../../../folder/folder.types.js";
+export interface IListFolderLevelPermissionsTargetsUseCase {
+    execute: () => Promise<Result<[FolderLevelPermissionsTarget[], FolderLevelPermissionsTargetListMeta]>>;
+}
+/** List targets for folder-level permissions. */
+export declare const ListFolderLevelPermissionsTargetsUseCase: import("@webiny/di").Abstraction<IListFolderLevelPermissionsTargetsUseCase>;
+export declare namespace ListFolderLevelPermissionsTargetsUseCase {
+    type Interface = IListFolderLevelPermissionsTargetsUseCase;
+    type Return = Promise<Result<[FolderLevelPermissionsTarget[], FolderLevelPermissionsTargetListMeta]>>;
+}

package/features/folder/ListFolderLevelPermissionsTargets/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const ListFolderLevelPermissionsTargetsUseCase = createAbstraction("ListFolderLevelPermissionsTargetsUseCase");
+export { ListFolderLevelPermissionsTargetsUseCase };
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/ListFolderLevelPermissionsTargets/abstractions.js","sources":["../../../../src/features/folder/ListFolderLevelPermissionsTargets/abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type {\n    FolderLevelPermissionsTarget,\n    FolderLevelPermissionsTargetListMeta\n} from \"~/folder/folder.types.js\";\n\n// Use Case Abstraction\nexport interface IListFolderLevelPermissionsTargetsUseCase {\n    execute: () => Promise<\n        Result<[FolderLevelPermissionsTarget[], FolderLevelPermissionsTargetListMeta]>\n    >;\n}\n\n/** List targets for folder-level permissions. */\nexport const ListFolderLevelPermissionsTargetsUseCase =\n    createAbstraction<IListFolderLevelPermissionsTargetsUseCase>(\n        \"ListFolderLevelPermissionsTargetsUseCase\"\n    );\n\nexport namespace ListFolderLevelPermissionsTargetsUseCase {\n    export type Interface = IListFolderLevelPermissionsTargetsUseCase;\n    export type Return = Promise<\n        Result<[FolderLevelPermissionsTarget[], FolderLevelPermissionsTargetListMeta]>\n    >;\n}\n"],"names":["ListFolderLevelPermissionsTargetsUseCase","createAbstraction"],"mappings":";AAcO,MAAMA,2CACTC,kBACI"}

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

@@ -0,0 +1,4 @@
+export declare const ListFolderLevelPermissionsTargetsFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/folder/ListFolderLevelPermissionsTargets/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { ListFolderLevelPermissionsTargetsUseCase } from "./ListFolderLevelPermissionsTargetsUseCase.js";
+const ListFolderLevelPermissionsTargetsFeature = createFeature({
+    name: "ListFolderLevelPermissionsTargets",
+    register (container) {
+        container.register(ListFolderLevelPermissionsTargetsUseCase);
+    }
+});
+export { ListFolderLevelPermissionsTargetsFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/ListFolderLevelPermissionsTargets/feature.js","sources":["../../../../src/features/folder/ListFolderLevelPermissionsTargets/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ListFolderLevelPermissionsTargetsUseCase } from \"./ListFolderLevelPermissionsTargetsUseCase.js\";\n\nexport const ListFolderLevelPermissionsTargetsFeature = createFeature({\n    name: \"ListFolderLevelPermissionsTargets\",\n    register(container) {\n        container.register(ListFolderLevelPermissionsTargetsUseCase);\n    }\n});\n"],"names":["ListFolderLevelPermissionsTargetsFeature","createFeature","container","ListFolderLevelPermissionsTargetsUseCase"],"mappings":";;AAGO,MAAMA,2CAA2CC,cAAc;IAClE,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

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

@@ -0,0 +1 @@
+export { ListFolderLevelPermissionsTargetsUseCase } from "./abstractions.js";