@webiny/app-aco 0.0.0-unstable.eb196ccd2f → 0.0.0-unstable.eb81deee7e

package/features/folders/folderEvents/FolderEvents.test.js

@@ -0,0 +1,238 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { Container } from "@webiny/di";
+import { EventPublisher, EventPublisherFeature } from "@webiny/app/features/eventPublisher/index.js";
+import { EnvConfig } from "@webiny/app/features/envConfig/index.js";
+import { WebsocketEvent } from "@webiny/app-websockets/events/WebsocketEvent.js";
+import { GetFolderGateway } from "../getFolder/abstractions.js";
+import { folderCacheFactory } from "../cache/index.js";
+import { Folder } from "../../../domain/folder/Folder.js";
+import { AddCreatedFolderToCache } from "./AddCreatedFolderToCache.js";
+import { RefreshUpdatedFolderInCache } from "./RefreshUpdatedFolderInCache.js";
+import { RemoveDeletedFolderFromCache } from "./RemoveDeletedFolderFromCache.js";
+import { FolderWebsocketMessages } from "./FolderWebsocketMessages.js";
+const folderDto = (overrides = {})=>({
+        id: "folder-1",
+        title: "Drafts",
+        slug: "drafts",
+        path: "drafts",
+        type: "FmFile",
+        parentId: null,
+        permissions: [],
+        ...overrides
+    });
+const setup = (folder)=>{
+    const fetched = [];
+    const container = new Container();
+    container.registerInstance(EnvConfig, {
+        get: ()=>void 0
+    });
+    EventPublisherFeature.register(container);
+    container.registerInstance(GetFolderGateway, {
+        execute: async (id)=>{
+            fetched.push(id);
+            return folder;
+        }
+    });
+    container.register(AddCreatedFolderToCache);
+    container.register(RefreshUpdatedFolderInCache);
+    container.register(RemoveDeletedFolderFromCache);
+    container.register(FolderWebsocketMessages);
+    const receive = (payload)=>container.resolve(EventPublisher).publish(new WebsocketEvent(payload));
+    return {
+        receive,
+        fetched
+    };
+};
+describe("folder events", ()=>{
+    beforeEach(()=>{
+        folderCacheFactory.getCache("FmFile").clear();
+        folderCacheFactory.getCache("cms:article").clear();
+    });
+    it("adds a folder created on the server to the cache for its type", async ()=>{
+        const { receive, fetched } = setup(folderDto());
+        await receive({
+            action: "aco.folder.created",
+            data: {
+                id: "folder-1"
+            }
+        });
+        expect(fetched).toEqual([
+            "folder-1"
+        ]);
+        expect(folderCacheFactory.getCache("FmFile").getItem((f)=>"folder-1" === f.id)?.title).toBe("Drafts");
+    });
+    it("files the folder under its own type, not the one on screen", async ()=>{
+        const { receive } = setup(folderDto({
+            type: "cms:article"
+        }));
+        await receive({
+            action: "aco.folder.created",
+            data: {
+                id: "folder-1"
+            }
+        });
+        expect(folderCacheFactory.getCache("FmFile").hasItems()).toBe(false);
+        expect(folderCacheFactory.getCache("cms:article").count()).toBe(1);
+    });
+    it("keeps one copy when the same folder arrives twice", async ()=>{
+        const { receive } = setup(folderDto());
+        await receive({
+            action: "aco.folder.created",
+            data: {
+                id: "folder-1"
+            }
+        });
+        await receive({
+            action: "aco.folder.created",
+            data: {
+                id: "folder-1"
+            }
+        });
+        expect(folderCacheFactory.getCache("FmFile").count()).toBe(1);
+    });
+    it("ignores messages that are not about folders", async ()=>{
+        const { receive, fetched } = setup(folderDto());
+        await receive({
+            action: "fm.file.enrichment",
+            data: {
+                id: "file-1"
+            }
+        });
+        expect(fetched).toEqual([]);
+        expect(folderCacheFactory.getCache("FmFile").hasItems()).toBe(false);
+    });
+    describe("updates", ()=>{
+        const viewer = {
+            target: "admin:1",
+            level: "viewer"
+        };
+        const cache = ()=>folderCacheFactory.getCache("FmFile");
+        const child = ()=>cache().getItem((f)=>"child-1" === f.id);
+        const seed = (parentPermissions, childPermissions)=>{
+            cache().addItems([
+                Folder.create(folderDto({
+                    permissions: parentPermissions
+                })),
+                Folder.create(folderDto({
+                    id: "child-1",
+                    slug: "child",
+                    path: "drafts/child",
+                    parentId: "folder-1",
+                    permissions: childPermissions
+                }))
+            ]);
+        };
+        it("replaces the cached folder with the one the server has now", async ()=>{
+            seed([], []);
+            const { receive, fetched } = setup(folderDto({
+                title: "Renamed",
+                permissions: [
+                    viewer
+                ]
+            }));
+            await receive({
+                action: "aco.folder.updated",
+                data: {
+                    id: "folder-1"
+                }
+            });
+            expect(fetched).toEqual([
+                "folder-1"
+            ]);
+            const updated = cache().getItem((f)=>"folder-1" === f.id);
+            expect(updated?.title).toBe("Renamed");
+            expect(updated?.permissions).toEqual([
+                viewer
+            ]);
+        });
+        it("passes access granted on a parent down to its cached children", async ()=>{
+            seed([], []);
+            const { receive } = setup(folderDto({
+                permissions: [
+                    viewer
+                ]
+            }));
+            await receive({
+                action: "aco.folder.updated",
+                data: {
+                    id: "folder-1"
+                }
+            });
+            expect(child()?.permissions).toEqual([
+                {
+                    ...viewer,
+                    inheritedFrom: "parent:folder-1"
+                }
+            ]);
+        });
+        it("takes access revoked on a parent away from its cached children", async ()=>{
+            seed([
+                viewer
+            ], [
+                {
+                    ...viewer,
+                    inheritedFrom: "parent:folder-1"
+                }
+            ]);
+            const { receive } = setup(folderDto({
+                permissions: []
+            }));
+            await receive({
+                action: "aco.folder.updated",
+                data: {
+                    id: "folder-1"
+                }
+            });
+            expect(child()?.permissions).toEqual([]);
+        });
+    });
+    describe("deletes", ()=>{
+        it("removes a deleted folder from the cache it was in", async ()=>{
+            folderCacheFactory.getCache("cms:article").addItems([
+                Folder.create(folderDto({
+                    type: "cms:article"
+                })),
+                Folder.create(folderDto({
+                    id: "folder-2",
+                    type: "cms:article"
+                }))
+            ]);
+            const { receive, fetched } = setup(folderDto());
+            await receive({
+                action: "aco.folder.deleted",
+                data: {
+                    id: "folder-1"
+                }
+            });
+            expect(fetched).toEqual([]);
+            expect(folderCacheFactory.getCache("cms:article").getItems().map((f)=>f.id)).toEqual([
+                "folder-2"
+            ]);
+        });
+        it("ignores a folder the cache never held", async ()=>{
+            folderCacheFactory.getCache("FmFile").addItems([
+                Folder.create(folderDto())
+            ]);
+            const { receive } = setup(folderDto());
+            await receive({
+                action: "aco.folder.deleted",
+                data: {
+                    id: "unknown"
+                }
+            });
+            expect(folderCacheFactory.getCache("FmFile").count()).toBe(1);
+        });
+    });
+    it("ignores an action that only looks like a known key", async ()=>{
+        const { receive, fetched } = setup(folderDto());
+        await receive({
+            action: "toString",
+            data: {
+                id: "folder-1"
+            }
+        });
+        expect(fetched).toEqual([]);
+    });
+});
+
+//# sourceMappingURL=FolderEvents.test.js.map

package/features/folders/folderEvents/FolderEvents.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folders/folderEvents/FolderEvents.test.js","sources":["../../../../src/features/folders/folderEvents/FolderEvents.test.ts"],"sourcesContent":["import { describe, it, expect, beforeEach } from \"vitest\";\nimport { Container } from \"@webiny/di\";\nimport {\n    EventPublisher,\n    EventPublisherFeature\n} from \"@webiny/app/features/eventPublisher/index.js\";\nimport { EnvConfig } from \"@webiny/app/features/envConfig/index.js\";\nimport { WebsocketEvent } from \"@webiny/app-websockets/events/WebsocketEvent.js\";\nimport { GetFolderGateway } from \"~/features/folders/getFolder/abstractions.js\";\nimport { folderCacheFactory } from \"~/features/folders/cache/index.js\";\nimport type { FolderDto } from \"~/domain/folder/FolderDto.js\";\nimport type { FolderPermission } from \"~/types.js\";\nimport { Folder } from \"~/domain/folder/Folder.js\";\nimport { AddCreatedFolderToCache } from \"./AddCreatedFolderToCache.js\";\nimport { RefreshUpdatedFolderInCache } from \"./RefreshUpdatedFolderInCache.js\";\nimport { RemoveDeletedFolderFromCache } from \"./RemoveDeletedFolderFromCache.js\";\nimport { FolderWebsocketMessages } from \"./FolderWebsocketMessages.js\";\n\nconst folderDto = (overrides: Partial<FolderDto> = {}) =>\n    ({\n        id: \"folder-1\",\n        title: \"Drafts\",\n        slug: \"drafts\",\n        path: \"drafts\",\n        type: \"FmFile\",\n        parentId: null,\n        permissions: [],\n        ...overrides\n    }) as FolderDto;\n\n/*\n * Real publisher and handlers, fake server. The websocket bridge publishes `WebsocketEvent`s through\n * the same publisher, so publishing one here is what an incoming message does at runtime.\n */\nconst setup = (folder: FolderDto) => {\n    const fetched: string[] = [];\n    const container = new Container();\n\n    // The publisher reads `debug` from here to decide whether to log.\n    container.registerInstance(EnvConfig, {\n        get: () => undefined\n    } as unknown as EnvConfig.Interface);\n    EventPublisherFeature.register(container);\n    container.registerInstance(GetFolderGateway, {\n        execute: async (id: string) => {\n            fetched.push(id);\n            return folder;\n        }\n    });\n    container.register(AddCreatedFolderToCache);\n    container.register(RefreshUpdatedFolderInCache);\n    container.register(RemoveDeletedFolderFromCache);\n    container.register(FolderWebsocketMessages);\n\n    const receive = (payload: { action: string; data: unknown }) =>\n        container.resolve(EventPublisher).publish(new WebsocketEvent(payload));\n\n    return { receive, fetched };\n};\n\ndescribe(\"folder events\", () => {\n    beforeEach(() => {\n        folderCacheFactory.getCache(\"FmFile\").clear();\n        folderCacheFactory.getCache(\"cms:article\").clear();\n    });\n\n    it(\"adds a folder created on the server to the cache for its type\", async () => {\n        const { receive, fetched } = setup(folderDto());\n\n        await receive({ action: \"aco.folder.created\", data: { id: \"folder-1\" } });\n\n        expect(fetched).toEqual([\"folder-1\"]);\n        expect(folderCacheFactory.getCache(\"FmFile\").getItem(f => f.id === \"folder-1\")?.title).toBe(\n            \"Drafts\"\n        );\n    });\n\n    it(\"files the folder under its own type, not the one on screen\", async () => {\n        const { receive } = setup(folderDto({ type: \"cms:article\" }));\n\n        await receive({ action: \"aco.folder.created\", data: { id: \"folder-1\" } });\n\n        expect(folderCacheFactory.getCache(\"FmFile\").hasItems()).toBe(false);\n        expect(folderCacheFactory.getCache(\"cms:article\").count()).toBe(1);\n    });\n\n    it(\"keeps one copy when the same folder arrives twice\", async () => {\n        const { receive } = setup(folderDto());\n\n        await receive({ action: \"aco.folder.created\", data: { id: \"folder-1\" } });\n        await receive({ action: \"aco.folder.created\", data: { id: \"folder-1\" } });\n\n        expect(folderCacheFactory.getCache(\"FmFile\").count()).toBe(1);\n    });\n\n    it(\"ignores messages that are not about folders\", async () => {\n        const { receive, fetched } = setup(folderDto());\n\n        await receive({ action: \"fm.file.enrichment\", data: { id: \"file-1\" } });\n\n        expect(fetched).toEqual([]);\n        expect(folderCacheFactory.getCache(\"FmFile\").hasItems()).toBe(false);\n    });\n\n    describe(\"updates\", () => {\n        const viewer: FolderPermission = { target: \"admin:1\", level: \"viewer\" };\n        const cache = () => folderCacheFactory.getCache(\"FmFile\");\n        const child = () => cache().getItem(f => f.id === \"child-1\");\n\n        const seed = (\n            parentPermissions: FolderDto[\"permissions\"],\n            childPermissions: FolderDto[\"permissions\"]\n        ) => {\n            cache().addItems([\n                Folder.create(folderDto({ permissions: parentPermissions })),\n                Folder.create(\n                    folderDto({\n                        id: \"child-1\",\n                        slug: \"child\",\n                        path: \"drafts/child\",\n                        parentId: \"folder-1\",\n                        permissions: childPermissions\n                    })\n                )\n            ]);\n        };\n\n        it(\"replaces the cached folder with the one the server has now\", async () => {\n            seed([], []);\n            const { receive, fetched } = setup(\n                folderDto({ title: \"Renamed\", permissions: [viewer] })\n            );\n\n            await receive({ action: \"aco.folder.updated\", data: { id: \"folder-1\" } });\n\n            expect(fetched).toEqual([\"folder-1\"]);\n            const updated = cache().getItem(f => f.id === \"folder-1\");\n            expect(updated?.title).toBe(\"Renamed\");\n            expect(updated?.permissions).toEqual([viewer]);\n        });\n\n        it(\"passes access granted on a parent down to its cached children\", async () => {\n            seed([], []);\n            const { receive } = setup(folderDto({ permissions: [viewer] }));\n\n            await receive({ action: \"aco.folder.updated\", data: { id: \"folder-1\" } });\n\n            expect(child()?.permissions).toEqual([{ ...viewer, inheritedFrom: \"parent:folder-1\" }]);\n        });\n\n        it(\"takes access revoked on a parent away from its cached children\", async () => {\n            seed([viewer], [{ ...viewer, inheritedFrom: \"parent:folder-1\" }]);\n            const { receive } = setup(folderDto({ permissions: [] }));\n\n            await receive({ action: \"aco.folder.updated\", data: { id: \"folder-1\" } });\n\n            expect(child()?.permissions).toEqual([]);\n        });\n    });\n\n    describe(\"deletes\", () => {\n        it(\"removes a deleted folder from the cache it was in\", async () => {\n            folderCacheFactory\n                .getCache(\"cms:article\")\n                .addItems([\n                    Folder.create(folderDto({ type: \"cms:article\" })),\n                    Folder.create(folderDto({ id: \"folder-2\", type: \"cms:article\" }))\n                ]);\n            const { receive, fetched } = setup(folderDto());\n\n            await receive({ action: \"aco.folder.deleted\", data: { id: \"folder-1\" } });\n\n            // A deleted folder cannot be read back, so nothing is fetched.\n            expect(fetched).toEqual([]);\n            expect(\n                folderCacheFactory\n                    .getCache(\"cms:article\")\n                    .getItems()\n                    .map(f => f.id)\n            ).toEqual([\"folder-2\"]);\n        });\n\n        it(\"ignores a folder the cache never held\", async () => {\n            folderCacheFactory.getCache(\"FmFile\").addItems([Folder.create(folderDto())]);\n            const { receive } = setup(folderDto());\n\n            await receive({ action: \"aco.folder.deleted\", data: { id: \"unknown\" } });\n\n            expect(folderCacheFactory.getCache(\"FmFile\").count()).toBe(1);\n        });\n    });\n\n    it(\"ignores an action that only looks like a known key\", async () => {\n        const { receive, fetched } = setup(folderDto());\n\n        await receive({ action: \"toString\", data: { id: \"folder-1\" } });\n\n        expect(fetched).toEqual([]);\n    });\n});\n"],"names":["folderDto","overrides","setup","folder","fetched","container","Container","EnvConfig","undefined","EventPublisherFeature","GetFolderGateway","id","AddCreatedFolderToCache","RefreshUpdatedFolderInCache","RemoveDeletedFolderFromCache","FolderWebsocketMessages","receive","payload","EventPublisher","WebsocketEvent","describe","beforeEach","folderCacheFactory","it","expect","f","viewer","cache","child","seed","parentPermissions","childPermissions","Folder","updated"],"mappings":"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"}

package/features/folders/folderEvents/FolderUpdatedEvent.d.ts

@@ -0,0 +1,12 @@
+import { BaseEvent } from "@webiny/app/features/eventPublisher/index.js";
+export interface FolderUpdatedPayload {
+    id: string;
+}
+/**
+ * A folder changed and the admin's cache may hold the old version. Like `FolderCreatedEvent`, it
+ * says nothing about where the news came from.
+ */
+export declare class FolderUpdatedEvent extends BaseEvent<FolderUpdatedPayload> {
+    readonly eventType: "Aco/FolderUpdated";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("@webiny/app/features/eventPublisher/abstractions.js").IEventHandler<FolderUpdatedEvent>>;
+}

package/features/folders/folderEvents/FolderUpdatedEvent.js

@@ -0,0 +1,13 @@
+import { BaseEvent } from "@webiny/app/features/eventPublisher/index.js";
+import { FolderUpdatedEventHandler } from "./abstractions.js";
+class FolderUpdatedEvent extends BaseEvent {
+    getHandlerAbstraction() {
+        return FolderUpdatedEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Aco/FolderUpdated";
+    }
+}
+export { FolderUpdatedEvent };
+
+//# sourceMappingURL=FolderUpdatedEvent.js.map

package/features/folders/folderEvents/FolderUpdatedEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folders/folderEvents/FolderUpdatedEvent.js","sources":["../../../../src/features/folders/folderEvents/FolderUpdatedEvent.ts"],"sourcesContent":["import { BaseEvent } from \"@webiny/app/features/eventPublisher/index.js\";\nimport { FolderUpdatedEventHandler } from \"./abstractions.js\";\n\nexport interface FolderUpdatedPayload {\n    id: string;\n}\n\n/**\n * A folder changed and the admin's cache may hold the old version. Like `FolderCreatedEvent`, it\n * says nothing about where the news came from.\n */\nexport class FolderUpdatedEvent extends BaseEvent<FolderUpdatedPayload> {\n    readonly eventType = \"Aco/FolderUpdated\" as const;\n\n    getHandlerAbstraction() {\n        return FolderUpdatedEventHandler;\n    }\n}\n"],"names":["FolderUpdatedEvent","BaseEvent","FolderUpdatedEventHandler"],"mappings":";;AAWO,MAAMA,2BAA2BC;IAGpC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACM,SAAS,GAAG;;AAKzB"}

package/features/folders/folderEvents/FolderWebsocketMessages.d.ts

@@ -0,0 +1,15 @@
+import { WebsocketEventHandler } from "@webiny/app-websockets/events/abstractions.js";
+import { EventPublisher } from "@webiny/app/features/eventPublisher/index.js";
+/**
+ * Turns the folder messages the api sends over the websocket into folder events. The handlers that
+ * update the cache listen to those events, so they never depend on how the news arrived.
+ */
+declare class FolderWebsocketMessagesImpl implements WebsocketEventHandler.Interface {
+    private eventPublisher;
+    constructor(eventPublisher: EventPublisher.Interface);
+    handle(event: WebsocketEventHandler.Event): Promise<void>;
+}
+export declare const FolderWebsocketMessages: typeof FolderWebsocketMessagesImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/app/features/eventPublisher/abstractions.js").IEventHandler<import("@webiny/app-websockets/events/WebsocketEvent.js").WebsocketEvent>>;
+};
+export {};

package/features/folders/folderEvents/FolderWebsocketMessages.js

@@ -0,0 +1,48 @@
+import { WebsocketEventHandler } from "@webiny/app-websockets/events/abstractions.js";
+import { EventPublisher } from "@webiny/app/features/eventPublisher/index.js";
+import { FolderCreatedEvent } from "./FolderCreatedEvent.js";
+import { FolderUpdatedEvent } from "./FolderUpdatedEvent.js";
+import { FolderDeletedEvent } from "./FolderDeletedEvent.js";
+const FOLDER_CREATED_ACTION = "aco.folder.created";
+const FOLDER_UPDATED_ACTION = "aco.folder.updated";
+const FOLDER_DELETED_ACTION = "aco.folder.deleted";
+const TO_EVENT = new Map([
+    [
+        FOLDER_CREATED_ACTION,
+        (id)=>new FolderCreatedEvent({
+                id
+            })
+    ],
+    [
+        FOLDER_UPDATED_ACTION,
+        (id)=>new FolderUpdatedEvent({
+                id
+            })
+    ],
+    [
+        FOLDER_DELETED_ACTION,
+        (id)=>new FolderDeletedEvent({
+                id
+            })
+    ]
+]);
+class FolderWebsocketMessagesImpl {
+    constructor(eventPublisher){
+        this.eventPublisher = eventPublisher;
+    }
+    async handle(event) {
+        const toEvent = TO_EVENT.get(event.payload.action);
+        if (!toEvent) return;
+        const { data } = event.payload;
+        await this.eventPublisher.publish(toEvent(data.id));
+    }
+}
+const FolderWebsocketMessages = WebsocketEventHandler.createImplementation({
+    implementation: FolderWebsocketMessagesImpl,
+    dependencies: [
+        EventPublisher
+    ]
+});
+export { FolderWebsocketMessages };
+
+//# sourceMappingURL=FolderWebsocketMessages.js.map

package/features/folders/folderEvents/FolderWebsocketMessages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folders/folderEvents/FolderWebsocketMessages.js","sources":["../../../../src/features/folders/folderEvents/FolderWebsocketMessages.ts"],"sourcesContent":["import { WebsocketEventHandler } from \"@webiny/app-websockets/events/abstractions.js\";\nimport { EventPublisher, type BaseEvent } from \"@webiny/app/features/eventPublisher/index.js\";\nimport { FolderCreatedEvent } from \"./FolderCreatedEvent.js\";\nimport { FolderUpdatedEvent } from \"./FolderUpdatedEvent.js\";\nimport { FolderDeletedEvent } from \"./FolderDeletedEvent.js\";\n\n// Sent by the api when an AI tool changes a folder; see `NotifyFolderChangeUseCase` in @webiny/api-aco.\nconst FOLDER_CREATED_ACTION = \"aco.folder.created\";\nconst FOLDER_UPDATED_ACTION = \"aco.folder.updated\";\nconst FOLDER_DELETED_ACTION = \"aco.folder.deleted\";\n\ninterface FolderMessageData {\n    id: string;\n}\n\nconst TO_EVENT = new Map<string, (id: string) => BaseEvent<{ id: string }>>([\n    [FOLDER_CREATED_ACTION, id => new FolderCreatedEvent({ id })],\n    [FOLDER_UPDATED_ACTION, id => new FolderUpdatedEvent({ id })],\n    [FOLDER_DELETED_ACTION, id => new FolderDeletedEvent({ id })]\n]);\n\n/**\n * Turns the folder messages the api sends over the websocket into folder events. The handlers that\n * update the cache listen to those events, so they never depend on how the news arrived.\n */\nclass FolderWebsocketMessagesImpl implements WebsocketEventHandler.Interface {\n    constructor(private eventPublisher: EventPublisher.Interface) {}\n\n    async handle(event: WebsocketEventHandler.Event): Promise<void> {\n        const toEvent = TO_EVENT.get(event.payload.action);\n        if (!toEvent) {\n            return;\n        }\n\n        const { data } = event.payload as unknown as { data: FolderMessageData };\n        await this.eventPublisher.publish(toEvent(data.id));\n    }\n}\n\nexport const FolderWebsocketMessages = WebsocketEventHandler.createImplementation({\n    implementation: FolderWebsocketMessagesImpl,\n    dependencies: [EventPublisher]\n});\n"],"names":["FOLDER_CREATED_ACTION","FOLDER_UPDATED_ACTION","FOLDER_DELETED_ACTION","TO_EVENT","Map","id","FolderCreatedEvent","FolderUpdatedEvent","FolderDeletedEvent","FolderWebsocketMessagesImpl","eventPublisher","event","toEvent","data","FolderWebsocketMessages","WebsocketEventHandler","EventPublisher"],"mappings":";;;;;AAOA,MAAMA,wBAAwB;AAC9B,MAAMC,wBAAwB;AAC9B,MAAMC,wBAAwB;AAM9B,MAAMC,WAAW,IAAIC,IAAuD;IACxE;QAACJ;QAAuBK,CAAAA,KAAM,IAAIC,mBAAmB;gBAAED;YAAG;KAAG;IAC7D;QAACJ;QAAuBI,CAAAA,KAAM,IAAIE,mBAAmB;gBAAEF;YAAG;KAAG;IAC7D;QAACH;QAAuBG,CAAAA,KAAM,IAAIG,mBAAmB;gBAAEH;YAAG;KAAG;CAChE;AAMD,MAAMI;IACF,YAAoBC,cAAwC,CAAE;aAA1CA,cAAc,GAAdA;IAA2C;IAE/D,MAAM,OAAOC,KAAkC,EAAiB;QAC5D,MAAMC,UAAUT,SAAS,GAAG,CAACQ,MAAM,OAAO,CAAC,MAAM;QACjD,IAAI,CAACC,SACD;QAGJ,MAAM,EAAEC,IAAI,EAAE,GAAGF,MAAM,OAAO;QAC9B,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAACC,QAAQC,KAAK,EAAE;IACrD;AACJ;AAEO,MAAMC,0BAA0BC,sBAAsB,oBAAoB,CAAC;IAC9E,gBAAgBN;IAChB,cAAc;QAACO;KAAe;AAClC"}

package/features/folders/folderEvents/RefreshUpdatedFolderInCache.d.ts

@@ -0,0 +1,19 @@
+import { GetFolderGateway } from "../../../features/folders/getFolder/abstractions.js";
+import { FolderUpdatedEventHandler } from "./abstractions.js";
+/**
+ * Reads the folder back and replaces it in the cache for its type, then re-derives the inherited
+ * permissions of its cached descendants. An access change on a parent changes what every folder
+ * below it inherits, and the server only sent the one id.
+ *
+ * Same reasons as `AddCreatedFolderToCache` for reading back and for reaching the cache through
+ * `folderCacheFactory`.
+ */
+declare class RefreshUpdatedFolderInCacheImpl implements FolderUpdatedEventHandler.Interface {
+    private getFolder;
+    constructor(getFolder: GetFolderGateway.Interface);
+    handle(event: FolderUpdatedEventHandler.Event): Promise<void>;
+}
+export declare const RefreshUpdatedFolderInCache: typeof RefreshUpdatedFolderInCacheImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/app/features/eventPublisher/abstractions.js").IEventHandler<import("./FolderUpdatedEvent.js").FolderUpdatedEvent>>;
+};
+export {};

package/features/folders/folderEvents/RefreshUpdatedFolderInCache.js

@@ -0,0 +1,27 @@
+import { GetFolderGateway } from "../getFolder/abstractions.js";
+import { folderCacheFactory } from "../cache/index.js";
+import { updateDescendantPermissions } from "../cache/updateDescendantPermissions.js";
+import { Folder } from "../../../domain/folder/Folder.js";
+import { FolderUpdatedEventHandler } from "./abstractions.js";
+class RefreshUpdatedFolderInCacheImpl {
+    constructor(getFolder){
+        this.getFolder = getFolder;
+    }
+    async handle(event) {
+        const folder = Folder.create(await this.getFolder.execute(event.payload.id));
+        const cache = folderCacheFactory.getCache(folder.type);
+        cache.addItems([
+            folder
+        ]);
+        updateDescendantPermissions(cache, folder);
+    }
+}
+const RefreshUpdatedFolderInCache = FolderUpdatedEventHandler.createImplementation({
+    implementation: RefreshUpdatedFolderInCacheImpl,
+    dependencies: [
+        GetFolderGateway
+    ]
+});
+export { RefreshUpdatedFolderInCache };
+
+//# sourceMappingURL=RefreshUpdatedFolderInCache.js.map

package/features/folders/folderEvents/RefreshUpdatedFolderInCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folders/folderEvents/RefreshUpdatedFolderInCache.js","sources":["../../../../src/features/folders/folderEvents/RefreshUpdatedFolderInCache.ts"],"sourcesContent":["import { GetFolderGateway } from \"~/features/folders/getFolder/abstractions.js\";\nimport { folderCacheFactory } from \"~/features/folders/cache/index.js\";\nimport { updateDescendantPermissions } from \"~/features/folders/cache/updateDescendantPermissions.js\";\nimport { Folder } from \"~/domain/folder/Folder.js\";\nimport { FolderUpdatedEventHandler } from \"./abstractions.js\";\n\n/**\n * Reads the folder back and replaces it in the cache for its type, then re-derives the inherited\n * permissions of its cached descendants. An access change on a parent changes what every folder\n * below it inherits, and the server only sent the one id.\n *\n * Same reasons as `AddCreatedFolderToCache` for reading back and for reaching the cache through\n * `folderCacheFactory`.\n */\nclass RefreshUpdatedFolderInCacheImpl implements FolderUpdatedEventHandler.Interface {\n    constructor(private getFolder: GetFolderGateway.Interface) {}\n\n    async handle(event: FolderUpdatedEventHandler.Event): Promise<void> {\n        const folder = Folder.create(await this.getFolder.execute(event.payload.id));\n        const cache = folderCacheFactory.getCache(folder.type);\n\n        cache.addItems([folder]);\n        updateDescendantPermissions(cache, folder);\n    }\n}\n\nexport const RefreshUpdatedFolderInCache = FolderUpdatedEventHandler.createImplementation({\n    implementation: RefreshUpdatedFolderInCacheImpl,\n    dependencies: [GetFolderGateway]\n});\n"],"names":["RefreshUpdatedFolderInCacheImpl","getFolder","event","folder","Folder","cache","folderCacheFactory","updateDescendantPermissions","RefreshUpdatedFolderInCache","FolderUpdatedEventHandler","GetFolderGateway"],"mappings":";;;;;AAcA,MAAMA;IACF,YAAoBC,SAAqC,CAAE;aAAvCA,SAAS,GAATA;IAAwC;IAE5D,MAAM,OAAOC,KAAsC,EAAiB;QAChE,MAAMC,SAASC,OAAO,MAAM,CAAC,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACF,MAAM,OAAO,CAAC,EAAE;QAC1E,MAAMG,QAAQC,mBAAmB,QAAQ,CAACH,OAAO,IAAI;QAErDE,MAAM,QAAQ,CAAC;YAACF;SAAO;QACvBI,4BAA4BF,OAAOF;IACvC;AACJ;AAEO,MAAMK,8BAA8BC,0BAA0B,oBAAoB,CAAC;IACtF,gBAAgBT;IAChB,cAAc;QAACU;KAAiB;AACpC"}

package/features/folders/folderEvents/RemoveDeletedFolderFromCache.d.ts

@@ -0,0 +1,13 @@
+import { FolderDeletedEventHandler } from "./abstractions.js";
+/**
+ * Takes the folder out of the cache. A deleted folder cannot be read back to learn its type, so it
+ * is removed by id from every folder type's cache; ids are unique across types, so nothing else
+ * matches. Only empty folders can be deleted, so there are no cached children to clean up.
+ */
+declare class RemoveDeletedFolderFromCacheImpl implements FolderDeletedEventHandler.Interface {
+    handle(event: FolderDeletedEventHandler.Event): Promise<void>;
+}
+export declare const RemoveDeletedFolderFromCache: typeof RemoveDeletedFolderFromCacheImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/app/features/eventPublisher/abstractions.js").IEventHandler<import("./FolderDeletedEvent.js").FolderDeletedEvent>>;
+};
+export {};

package/features/folders/folderEvents/RemoveDeletedFolderFromCache.js

@@ -0,0 +1,15 @@
+import { folderCacheFactory } from "../cache/index.js";
+import { FolderDeletedEventHandler } from "./abstractions.js";
+class RemoveDeletedFolderFromCacheImpl {
+    async handle(event) {
+        const { id } = event.payload;
+        for (const cache of folderCacheFactory.getCaches())cache.removeItems((folder)=>folder.id === id);
+    }
+}
+const RemoveDeletedFolderFromCache = FolderDeletedEventHandler.createImplementation({
+    implementation: RemoveDeletedFolderFromCacheImpl,
+    dependencies: []
+});
+export { RemoveDeletedFolderFromCache };
+
+//# sourceMappingURL=RemoveDeletedFolderFromCache.js.map

package/features/folders/folderEvents/RemoveDeletedFolderFromCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folders/folderEvents/RemoveDeletedFolderFromCache.js","sources":["../../../../src/features/folders/folderEvents/RemoveDeletedFolderFromCache.ts"],"sourcesContent":["import { folderCacheFactory } from \"~/features/folders/cache/index.js\";\nimport { FolderDeletedEventHandler } from \"./abstractions.js\";\n\n/**\n * Takes the folder out of the cache. A deleted folder cannot be read back to learn its type, so it\n * is removed by id from every folder type's cache; ids are unique across types, so nothing else\n * matches. Only empty folders can be deleted, so there are no cached children to clean up.\n */\nclass RemoveDeletedFolderFromCacheImpl implements FolderDeletedEventHandler.Interface {\n    async handle(event: FolderDeletedEventHandler.Event): Promise<void> {\n        const { id } = event.payload;\n\n        for (const cache of folderCacheFactory.getCaches()) {\n            cache.removeItems(folder => folder.id === id);\n        }\n    }\n}\n\nexport const RemoveDeletedFolderFromCache = FolderDeletedEventHandler.createImplementation({\n    implementation: RemoveDeletedFolderFromCacheImpl,\n    dependencies: []\n});\n"],"names":["RemoveDeletedFolderFromCacheImpl","event","id","cache","folderCacheFactory","folder","RemoveDeletedFolderFromCache","FolderDeletedEventHandler"],"mappings":";;AAQA,MAAMA;IACF,MAAM,OAAOC,KAAsC,EAAiB;QAChE,MAAM,EAAEC,EAAE,EAAE,GAAGD,MAAM,OAAO;QAE5B,KAAK,MAAME,SAASC,mBAAmB,SAAS,GAC5CD,MAAM,WAAW,CAACE,CAAAA,SAAUA,OAAO,EAAE,KAAKH;IAElD;AACJ;AAEO,MAAMI,+BAA+BC,0BAA0B,oBAAoB,CAAC;IACvF,gBAAgBP;IAChB,cAAc,EAAE;AACpB"}

package/features/folders/folderEvents/abstractions.d.ts

@@ -0,0 +1,28 @@
+import type { IEventHandler } from "@webiny/app/features/eventPublisher/index.js";
+import type { FolderCreatedEvent } from "./FolderCreatedEvent.js";
+import type { FolderUpdatedEvent } from "./FolderUpdatedEvent.js";
+import type { FolderDeletedEvent } from "./FolderDeletedEvent.js";
+/**
+ * Reacts to a folder created somewhere the admin did not see: by the assistant, a background task,
+ * or anything else on the server. Folders the admin creates itself are already in its cache.
+ */
+export declare const FolderCreatedEventHandler: import("@webiny/di").Abstraction<IEventHandler<FolderCreatedEvent>>;
+export declare namespace FolderCreatedEventHandler {
+    type Interface = IEventHandler<FolderCreatedEvent>;
+    type Event = FolderCreatedEvent;
+}
+/**
+ * Reacts to a folder changed somewhere the admin did not see, such as the assistant granting or
+ * revoking access. Changes the admin makes itself already update its cache.
+ */
+export declare const FolderUpdatedEventHandler: import("@webiny/di").Abstraction<IEventHandler<FolderUpdatedEvent>>;
+export declare namespace FolderUpdatedEventHandler {
+    type Interface = IEventHandler<FolderUpdatedEvent>;
+    type Event = FolderUpdatedEvent;
+}
+/** Reacts to a folder deleted somewhere the admin did not see, such as by the assistant. */
+export declare const FolderDeletedEventHandler: import("@webiny/di").Abstraction<IEventHandler<FolderDeletedEvent>>;
+export declare namespace FolderDeletedEventHandler {
+    type Interface = IEventHandler<FolderDeletedEvent>;
+    type Event = FolderDeletedEvent;
+}

package/features/folders/folderEvents/abstractions.js

@@ -0,0 +1,7 @@
+import { createAbstraction } from "@webiny/feature/admin";
+const FolderCreatedEventHandler = createAbstraction("Aco/FolderCreatedEventHandler");
+const FolderUpdatedEventHandler = createAbstraction("Aco/FolderUpdatedEventHandler");
+const FolderDeletedEventHandler = createAbstraction("Aco/FolderDeletedEventHandler");
+export { FolderCreatedEventHandler, FolderDeletedEventHandler, FolderUpdatedEventHandler };
+
+//# sourceMappingURL=abstractions.js.map

package/features/folders/folderEvents/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folders/folderEvents/abstractions.js","sources":["../../../../src/features/folders/folderEvents/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\nimport type { IEventHandler } from \"@webiny/app/features/eventPublisher/index.js\";\nimport type { FolderCreatedEvent } from \"./FolderCreatedEvent.js\";\nimport type { FolderUpdatedEvent } from \"./FolderUpdatedEvent.js\";\nimport type { FolderDeletedEvent } from \"./FolderDeletedEvent.js\";\n\n/**\n * Reacts to a folder created somewhere the admin did not see: by the assistant, a background task,\n * or anything else on the server. Folders the admin creates itself are already in its cache.\n */\nexport const FolderCreatedEventHandler = createAbstraction<IEventHandler<FolderCreatedEvent>>(\n    \"Aco/FolderCreatedEventHandler\"\n);\n\nexport namespace FolderCreatedEventHandler {\n    export type Interface = IEventHandler<FolderCreatedEvent>;\n    export type Event = FolderCreatedEvent;\n}\n\n/**\n * Reacts to a folder changed somewhere the admin did not see, such as the assistant granting or\n * revoking access. Changes the admin makes itself already update its cache.\n */\nexport const FolderUpdatedEventHandler = createAbstraction<IEventHandler<FolderUpdatedEvent>>(\n    \"Aco/FolderUpdatedEventHandler\"\n);\n\nexport namespace FolderUpdatedEventHandler {\n    export type Interface = IEventHandler<FolderUpdatedEvent>;\n    export type Event = FolderUpdatedEvent;\n}\n\n/** Reacts to a folder deleted somewhere the admin did not see, such as by the assistant. */\nexport const FolderDeletedEventHandler = createAbstraction<IEventHandler<FolderDeletedEvent>>(\n    \"Aco/FolderDeletedEventHandler\"\n);\n\nexport namespace FolderDeletedEventHandler {\n    export type Interface = IEventHandler<FolderDeletedEvent>;\n    export type Event = FolderDeletedEvent;\n}\n"],"names":["FolderCreatedEventHandler","createAbstraction","FolderUpdatedEventHandler","FolderDeletedEventHandler"],"mappings":";AAUO,MAAMA,4BAA4BC,kBACrC;AAYG,MAAMC,4BAA4BD,kBACrC;AASG,MAAME,4BAA4BF,kBACrC"}

package/features/folders/folderEvents/feature.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Keeps folder caches current when folders change on the server. Registered once, in the container
+ * the websocket bridge publishes from, because the news can arrive while no folder view is open.
+ *
+ * Registers its own folder model provider. The one `FolderModelProviderModule` registers lives in a
+ * child of this container, and a container only looks up to its parents, so the gateway below could
+ * not reach it. The model is fetched on the first event, not at startup.
+ */
+export declare const FolderEventsFeature: import("@webiny/feature/admin").FeatureDefinition<any, []>;

package/features/folders/folderEvents/feature.js

@@ -0,0 +1,21 @@
+import { createFeature } from "@webiny/feature/admin";
+import { GetFolderGqlGateway } from "../getFolder/GetFolderGqlGateway.js";
+import { FolderModelProviderFeature } from "../folderModelProvider/feature.js";
+import { AddCreatedFolderToCache } from "./AddCreatedFolderToCache.js";
+import { RefreshUpdatedFolderInCache } from "./RefreshUpdatedFolderInCache.js";
+import { RemoveDeletedFolderFromCache } from "./RemoveDeletedFolderFromCache.js";
+import { FolderWebsocketMessages } from "./FolderWebsocketMessages.js";
+const FolderEventsFeature = createFeature({
+    name: "Aco/FolderEvents",
+    register (container) {
+        FolderModelProviderFeature.register(container);
+        container.register(GetFolderGqlGateway);
+        container.register(AddCreatedFolderToCache);
+        container.register(RefreshUpdatedFolderInCache);
+        container.register(RemoveDeletedFolderFromCache);
+        container.register(FolderWebsocketMessages);
+    }
+});
+export { FolderEventsFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/folders/folderEvents/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folders/folderEvents/feature.js","sources":["../../../../src/features/folders/folderEvents/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { GetFolderGqlGateway } from \"~/features/folders/getFolder/GetFolderGqlGateway.js\";\nimport { FolderModelProviderFeature } from \"~/features/folders/folderModelProvider/feature.js\";\nimport { AddCreatedFolderToCache } from \"./AddCreatedFolderToCache.js\";\nimport { RefreshUpdatedFolderInCache } from \"./RefreshUpdatedFolderInCache.js\";\nimport { RemoveDeletedFolderFromCache } from \"./RemoveDeletedFolderFromCache.js\";\nimport { FolderWebsocketMessages } from \"./FolderWebsocketMessages.js\";\n\n/**\n * Keeps folder caches current when folders change on the server. Registered once, in the container\n * the websocket bridge publishes from, because the news can arrive while no folder view is open.\n *\n * Registers its own folder model provider. The one `FolderModelProviderModule` registers lives in a\n * child of this container, and a container only looks up to its parents, so the gateway below could\n * not reach it. The model is fetched on the first event, not at startup.\n */\nexport const FolderEventsFeature = createFeature({\n    name: \"Aco/FolderEvents\",\n    register(container) {\n        FolderModelProviderFeature.register(container);\n        container.register(GetFolderGqlGateway);\n        container.register(AddCreatedFolderToCache);\n        container.register(RefreshUpdatedFolderInCache);\n        container.register(RemoveDeletedFolderFromCache);\n        container.register(FolderWebsocketMessages);\n    }\n});\n"],"names":["FolderEventsFeature","createFeature","container","FolderModelProviderFeature","GetFolderGqlGateway","AddCreatedFolderToCache","RefreshUpdatedFolderInCache","RemoveDeletedFolderFromCache","FolderWebsocketMessages"],"mappings":";;;;;;;AAgBO,MAAMA,sBAAsBC,cAAc;IAC7C,MAAM;IACN,UAASC,SAAS;QACdC,2BAA2B,QAAQ,CAACD;QACpCA,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI;QACnBJ,UAAU,QAAQ,CAACK;QACnBL,UAAU,QAAQ,CAACM;IACvB;AACJ"}

package/features/folders/folderEvents/index.d.ts

@@ -0,0 +1,5 @@
+export { FolderEventsFeature } from "./feature.js";
+export { FolderCreatedEvent, type FolderCreatedPayload } from "./FolderCreatedEvent.js";
+export { FolderUpdatedEvent, type FolderUpdatedPayload } from "./FolderUpdatedEvent.js";
+export { FolderDeletedEvent, type FolderDeletedPayload } from "./FolderDeletedEvent.js";
+export { FolderCreatedEventHandler, FolderUpdatedEventHandler, FolderDeletedEventHandler } from "./abstractions.js";

package/features/folders/folderEvents/index.js

@@ -0,0 +1,5 @@
+export { FolderEventsFeature } from "./feature.js";
+export { FolderCreatedEvent } from "./FolderCreatedEvent.js";
+export { FolderUpdatedEvent } from "./FolderUpdatedEvent.js";
+export { FolderDeletedEvent } from "./FolderDeletedEvent.js";
+export { FolderCreatedEventHandler, FolderDeletedEventHandler, FolderUpdatedEventHandler } from "./abstractions.js";

package/features/folders/folderModelProvider/FolderModelContext.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const FolderModelProviderModule: () => React.JSX.Element;

package/features/folders/folderModelProvider/FolderModelContext.js

@@ -0,0 +1,21 @@
+import { Plugin, createProvider, useContainer } from "@webiny/app";
+import react, { useEffect } from "react";
+import { FolderModelProvider } from "../abstractions.js";
+import { FolderModelProviderFeature } from "./feature.js";
+const AcoFolderModelProvider = createProvider((Original)=>function({ children }) {
+        const container = useContainer();
+        useEffect(()=>{
+            FolderModelProviderFeature.register(container);
+            const provider = container.resolve(FolderModelProvider);
+            provider.getModel();
+        }, []);
+        return /*#__PURE__*/ react.createElement(Original, null, children);
+    });
+const FolderModelProviderModule = ()=>/*#__PURE__*/ react.createElement(Plugin, {
+        providers: [
+            AcoFolderModelProvider
+        ]
+    });
+export { FolderModelProviderModule };
+
+//# sourceMappingURL=FolderModelContext.js.map

package/features/folders/folderModelProvider/FolderModelContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folders/folderModelProvider/FolderModelContext.js","sources":["../../../../src/features/folders/folderModelProvider/FolderModelContext.tsx"],"sourcesContent":["import { createProvider } from \"@webiny/app\";\nimport { useContainer } from \"@webiny/app\";\nimport React, { useEffect } from \"react\";\nimport { Plugin } from \"@webiny/app\";\nimport { FolderModelProvider } from \"~/features/folders/abstractions.js\";\nimport { FolderModelProviderFeature } from \"./feature.js\";\n\nconst AcoFolderModelProvider = createProvider(Original => {\n    return function AcoFolderProvider({ children }) {\n        const container = useContainer();\n\n        useEffect(() => {\n            FolderModelProviderFeature.register(container);\n\n            const provider = container.resolve(FolderModelProvider);\n\n            // Trigger loading of a model\n            provider.getModel();\n        }, []);\n\n        return <Original>{children}</Original>;\n    };\n});\n\nexport const FolderModelProviderModule = () => {\n    return <Plugin providers={[AcoFolderModelProvider]} />;\n};\n"],"names":["AcoFolderModelProvider","createProvider","Original","children","container","useContainer","useEffect","FolderModelProviderFeature","provider","FolderModelProvider","FolderModelProviderModule","Plugin"],"mappings":";;;;AAOA,MAAMA,yBAAyBC,eAAeC,CAAAA,WACnC,SAA2B,EAAEC,QAAQ,EAAE;QAC1C,MAAMC,YAAYC;QAElBC,UAAU;YACNC,2BAA2B,QAAQ,CAACH;YAEpC,MAAMI,WAAWJ,UAAU,OAAO,CAACK;YAGnCD,SAAS,QAAQ;QACrB,GAAG,EAAE;QAEL,OAAO,WAAP,GAAO,oBAACN,UAAAA,MAAUC;IACtB;AAGG,MAAMO,4BAA4B,IAC9B,WAAP,GAAO,oBAACC,QAAMA;QAAC,WAAW;YAACX;SAAuB"}

package/features/folders/{getFolderModel → folderModelProvider}/FolderModelDto.d.ts

@@ -1,2 +1,2 @@
-import type { CmsModel } from "@webiny/app-headless-cms-common/types";
+import type { CmsModel } from "@webiny/app-headless-cms-common/types/index.js";
 export type FolderModelDto = CmsModel;

package/features/folders/folderModelProvider/FolderModelProvider.d.ts

@@ -0,0 +1,13 @@
+import type { CmsModel } from "@webiny/app-headless-cms-common/types/index.js";
+import { GetFolderModelRepository } from "./abstractions.js";
+import { FolderModelProvider as Provider } from "../../../features/folders/abstractions.js";
+declare class FolderModelProviderImpl implements Provider.Interface {
+    private repository;
+    constructor(repository: GetFolderModelRepository.Interface);
+    getModel(): Promise<CmsModel>;
+    getGraphQLSelection(): Promise<string>;
+}
+export declare const FolderModelProvider: typeof FolderModelProviderImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("~/features/folders/abstractions.js").IFolderModelProvider>;
+};
+export {};