@webiny/api-aco 0.0.0-unstable.a4637c5ce6 → 0.0.0-unstable.a85ef555b2

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";

package/features/folder/ListFolderLevelPermissionsTargets/index.js

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

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

@@ -0,0 +1,17 @@
+import { type IListFoldersRepository, ListFoldersRepository as RepositoryAbstraction } from "./abstractions.js";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
+import { FolderModelProvider } from "../../../domain/folder/abstractions.js";
+import type { ListFoldersParams } from "../../../folder/folder.types.js";
+import { CmsSortMapper, CmsWhereMapper } from "@webiny/api-headless-cms";
+declare class ListFoldersRepositoryImpl implements IListFoldersRepository {
+    private listLatestEntries;
+    private folderModelProvider;
+    private cmsWhereMapper;
+    private cmsSortMapper;
+    constructor(listLatestEntries: ListLatestEntriesUseCase.Interface, folderModelProvider: FolderModelProvider.Interface, cmsWhereMapper: CmsWhereMapper.Interface, cmsSortMapper: CmsSortMapper.Interface);
+    execute(params: ListFoldersParams): RepositoryAbstraction.Return;
+}
+export declare const ListFoldersRepository: typeof ListFoldersRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IListFoldersRepository>;
+};
+export {};

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"}