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

package/features/folders/listFoldersByParentIds/useListFoldersByParentIds.js.map

@@ -1 +1 @@
-{"version":3,"names":["useCallback","useEffect","useMemo","useState","autorun","useApolloClient","ListFoldersByParentIdsGqlGateway","ListFoldersByParentIds","FolderDtoMapper","useFoldersType","useGetFolderGraphQLSelection","ROOT_FOLDER","useListFoldersByParentIds","client","type","fields","gateway","vm","setVm","folders","loading","useCase","foldersCache","loadingState","getInstance","listFoldersByParentIds","parentIds","execute","getIsFolderLoading","action","isLoading","getItems","map","folder","toDTO","getActiveLoadings"],"sources":["useListFoldersByParentIds.ts"],"sourcesContent":["import { useCallback, useEffect, useMemo, useState } from \"react\";\nimport { autorun } from \"mobx\";\nimport { useApolloClient } from \"@apollo/react-hooks\";\nimport { ListFoldersByParentIdsGqlGateway } from \"./ListFoldersByParentIdsGqlGateway\";\nimport { ListFoldersByParentIds } from \"./ListFoldersByParentIds\";\nimport { FolderDtoMapper } from \"./FolderDto\";\nimport { useFoldersType, useGetFolderGraphQLSelection } from \"~/hooks\";\nimport type { FolderItem } from \"~/types\";\nimport { ROOT_FOLDER } from \"~/constants\";\n\nexport const useListFoldersByParentIds = () => {\n    const client = useApolloClient();\n    const type = useFoldersType();\n    const fields = useGetFolderGraphQLSelection();\n    const gateway = new ListFoldersByParentIdsGqlGateway(client, fields);\n\n    const [vm, setVm] = useState<{\n        folders: FolderItem[];\n        loading: string[];\n    }>({\n        folders: [],\n        loading: []\n    });\n\n    const {\n        useCase,\n        folders: foldersCache,\n        loading: loadingState\n    } = useMemo(() => {\n        return ListFoldersByParentIds.getInstance(type, gateway);\n    }, [type, gateway]);\n\n    const listFoldersByParentIds = useCallback(\n        (parentIds?: string[]) => {\n            return useCase.execute({ parentIds });\n        },\n        [useCase]\n    );\n\n    const getIsFolderLoading = useCallback(\n        (action = ROOT_FOLDER) => {\n            if (!loadingState) {\n                return true;\n            }\n\n            return loadingState.isLoading(action);\n        },\n        [loadingState]\n    );\n\n    useEffect(() => {\n        return autorun(() => {\n            const folders = foldersCache.getItems().map(folder => FolderDtoMapper.toDTO(folder));\n\n            setVm(vm => ({\n                ...vm,\n                folders\n            }));\n        });\n    }, [foldersCache]);\n\n    useEffect(() => {\n        return autorun(() => {\n            const loading = loadingState.getActiveLoadings();\n\n            setVm(vm => ({\n                ...vm,\n                loading\n            }));\n        });\n    }, [loadingState]);\n\n    return {\n        ...vm,\n        listFoldersByParentIds,\n        getIsFolderLoading\n    };\n};\n"],"mappings":"AAAA,SAASA,WAAW,EAAEC,SAAS,EAAEC,OAAO,EAAEC,QAAQ,QAAQ,OAAO;AACjE,SAASC,OAAO,QAAQ,MAAM;AAC9B,SAASC,eAAe,QAAQ,qBAAqB;AACrD,SAASC,gCAAgC;AACzC,SAASC,sBAAsB;AAC/B,SAASC,eAAe;AACxB,SAASC,cAAc,EAAEC,4BAA4B;AAErD,SAASC,WAAW;AAEpB,OAAO,MAAMC,yBAAyB,GAAGA,CAAA,KAAM;EAC3C,MAAMC,MAAM,GAAGR,eAAe,CAAC,CAAC;EAChC,MAAMS,IAAI,GAAGL,cAAc,CAAC,CAAC;EAC7B,MAAMM,MAAM,GAAGL,4BAA4B,CAAC,CAAC;EAC7C,MAAMM,OAAO,GAAG,IAAIV,gCAAgC,CAACO,MAAM,EAAEE,MAAM,CAAC;EAEpE,MAAM,CAACE,EAAE,EAAEC,KAAK,CAAC,GAAGf,QAAQ,CAGzB;IACCgB,OAAO,EAAE,EAAE;IACXC,OAAO,EAAE;EACb,CAAC,CAAC;EAEF,MAAM;IACFC,OAAO;IACPF,OAAO,EAAEG,YAAY;IACrBF,OAAO,EAAEG;EACb,CAAC,GAAGrB,OAAO,CAAC,MAAM;IACd,OAAOK,sBAAsB,CAACiB,WAAW,CAACV,IAAI,EAAEE,OAAO,CAAC;EAC5D,CAAC,EAAE,CAACF,IAAI,EAAEE,OAAO,CAAC,CAAC;EAEnB,MAAMS,sBAAsB,GAAGzB,WAAW,CACrC0B,SAAoB,IAAK;IACtB,OAAOL,OAAO,CAACM,OAAO,CAAC;MAAED;IAAU,CAAC,CAAC;EACzC,CAAC,EACD,CAACL,OAAO,CACZ,CAAC;EAED,MAAMO,kBAAkB,GAAG5B,WAAW,CAClC,CAAC6B,MAAM,GAAGlB,WAAW,KAAK;IACtB,IAAI,CAACY,YAAY,EAAE;MACf,OAAO,IAAI;IACf;IAEA,OAAOA,YAAY,CAACO,SAAS,CAACD,MAAM,CAAC;EACzC,CAAC,EACD,CAACN,YAAY,CACjB,CAAC;EAEDtB,SAAS,CAAC,MAAM;IACZ,OAAOG,OAAO,CAAC,MAAM;MACjB,MAAMe,OAAO,GAAGG,YAAY,CAACS,QAAQ,CAAC,CAAC,CAACC,GAAG,CAACC,MAAM,IAAIzB,eAAe,CAAC0B,KAAK,CAACD,MAAM,CAAC,CAAC;MAEpFf,KAAK,CAACD,EAAE,KAAK;QACT,GAAGA,EAAE;QACLE;MACJ,CAAC,CAAC,CAAC;IACP,CAAC,CAAC;EACN,CAAC,EAAE,CAACG,YAAY,CAAC,CAAC;EAElBrB,SAAS,CAAC,MAAM;IACZ,OAAOG,OAAO,CAAC,MAAM;MACjB,MAAMgB,OAAO,GAAGG,YAAY,CAACY,iBAAiB,CAAC,CAAC;MAEhDjB,KAAK,CAACD,EAAE,KAAK;QACT,GAAGA,EAAE;QACLG;MACJ,CAAC,CAAC,CAAC;IACP,CAAC,CAAC;EACN,CAAC,EAAE,CAACG,YAAY,CAAC,CAAC;EAElB,OAAO;IACH,GAAGN,EAAE;IACLQ,sBAAsB;IACtBG;EACJ,CAAC;AACL,CAAC","ignoreList":[]}
+{"version":3,"file":"features/folders/listFoldersByParentIds/useListFoldersByParentIds.js","sources":["../../../../src/features/folders/listFoldersByParentIds/useListFoldersByParentIds.ts"],"sourcesContent":["import { useCallback, useEffect, useState } from \"react\";\nimport { autorun } from \"mobx\";\nimport { useFeature, useContainer } from \"@webiny/app\";\nimport type { FolderDto } from \"~/domain/folder/FolderDto.js\";\nimport { FolderDtoMapper } from \"~/domain/folder/FolderDtoMapper.js\";\nimport { FoldersCache } from \"~/features/folders/abstractions.js\";\nimport { ListFoldersByParentIdsFeature } from \"./feature.js\";\nimport { ROOT_FOLDER } from \"~/constants.js\";\n\nexport const useListFoldersByParentIds = () => {\n    const container = useContainer();\n    const { useCase, loading: loadingState } = useFeature(ListFoldersByParentIdsFeature);\n\n    const foldersCache = container.resolve(FoldersCache);\n\n    const [vm, setVm] = useState<{\n        folders: FolderDto[];\n        loading: string[];\n    }>({\n        folders: [],\n        loading: []\n    });\n\n    const listFoldersByParentIds = useCallback(\n        (parentIds?: string[]) => {\n            return useCase.execute(parentIds);\n        },\n        [useCase]\n    );\n\n    const getIsFolderLoading = useCallback(\n        (action = ROOT_FOLDER) => {\n            if (!loadingState) {\n                return true;\n            }\n\n            return loadingState.isLoading(action);\n        },\n        [loadingState]\n    );\n\n    useEffect(() => {\n        return autorun(() => {\n            const folders = foldersCache.getItems().map(folder => FolderDtoMapper.toDTO(folder));\n\n            setVm(vm => ({\n                ...vm,\n                folders\n            }));\n        });\n    }, [foldersCache]);\n\n    useEffect(() => {\n        return autorun(() => {\n            const loading = loadingState.getActiveLoadings();\n\n            setVm(vm => ({\n                ...vm,\n                loading\n            }));\n        });\n    }, [loadingState]);\n\n    return {\n        ...vm,\n        listFoldersByParentIds,\n        getIsFolderLoading\n    };\n};\n"],"names":["useListFoldersByParentIds","container","useContainer","useCase","loadingState","useFeature","ListFoldersByParentIdsFeature","foldersCache","FoldersCache","vm","setVm","useState","listFoldersByParentIds","useCallback","parentIds","getIsFolderLoading","action","ROOT_FOLDER","useEffect","autorun","folders","folder","FolderDtoMapper","loading"],"mappings":";;;;;;;AASO,MAAMA,4BAA4B;IACrC,MAAMC,YAAYC;IAClB,MAAM,EAAEC,OAAO,EAAE,SAASC,YAAY,EAAE,GAAGC,WAAWC;IAEtD,MAAMC,eAAeN,UAAU,OAAO,CAACO;IAEvC,MAAM,CAACC,IAAIC,MAAM,GAAGC,SAGjB;QACC,SAAS,EAAE;QACX,SAAS,EAAE;IACf;IAEA,MAAMC,yBAAyBC,YAC3B,CAACC,YACUX,QAAQ,OAAO,CAACW,YAE3B;QAACX;KAAQ;IAGb,MAAMY,qBAAqBF,YACvB,CAACG,SAASC,WAAW;QACjB,IAAI,CAACb,cACD,OAAO;QAGX,OAAOA,aAAa,SAAS,CAACY;IAClC,GACA;QAACZ;KAAa;IAGlBc,UAAU,IACCC,QAAQ;YACX,MAAMC,UAAUb,aAAa,QAAQ,GAAG,GAAG,CAACc,CAAAA,SAAUC,gBAAgB,KAAK,CAACD;YAE5EX,MAAMD,CAAAA,KAAO;oBACT,GAAGA,EAAE;oBACLW;gBACJ;QACJ,IACD;QAACb;KAAa;IAEjBW,UAAU,IACCC,QAAQ;YACX,MAAMI,UAAUnB,aAAa,iBAAiB;YAE9CM,MAAMD,CAAAA,KAAO;oBACT,GAAGA,EAAE;oBACLc;gBACJ;QACJ,IACD;QAACnB;KAAa;IAEjB,OAAO;QACH,GAAGK,EAAE;QACLG;QACAG;IACJ;AACJ"}

package/features/folders/loadFolderHierarchy/LoadFolderHierarchy.test.js

@@ -0,0 +1,148 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { Container } from "@webiny/di";
+import { ListCache, LoadedCache } from "../cache/index.js";
+import { FoldersCache, FoldersContext, FoldersLoadingRepository, LoadedFoldersCache } from "../abstractions.js";
+import { LoadingRepository } from "@webiny/app-utils";
+import { LoadFolderHierarchyGateway, LoadFolderHierarchyUseCase } from "./abstractions.js";
+import { LoadFolderHierarchyFeature } from "./feature.js";
+describe("GetFolderHierarchy", ()=>{
+    const type = "abc";
+    function setupTest(gateway) {
+        const container = new Container();
+        const foldersCache = new ListCache();
+        const loadedFoldersCache = new LoadedCache();
+        container.registerInstance(FoldersContext, {
+            type
+        });
+        container.registerInstance(FoldersCache, foldersCache);
+        container.registerInstance(LoadedFoldersCache, loadedFoldersCache);
+        container.registerInstance(FoldersLoadingRepository, new LoadingRepository());
+        LoadFolderHierarchyFeature.register(container);
+        container.registerInstance(LoadFolderHierarchyGateway, gateway);
+        return {
+            container,
+            foldersCache,
+            loadedFoldersCache,
+            useCase: container.resolve(LoadFolderHierarchyUseCase)
+        };
+    }
+    beforeEach(()=>{
+        vi.resetAllMocks();
+    });
+    class GetFolderHierarchyMockGateway {
+        constructor(mockResponse){
+            this.mockResponse = mockResponse;
+        }
+        async execute() {
+            return this.mockResponse;
+        }
+    }
+    it("should update the list of folders in both `cache` and `loadedCache` when `parents` and `children` are returned by the gateway", async ()=>{
+        const gateway = new GetFolderHierarchyMockGateway({
+            parents: [
+                {
+                    id: "folder-1",
+                    title: "Folder 1",
+                    slug: "folder-1",
+                    parentId: null,
+                    type
+                },
+                {
+                    id: "folder-2",
+                    title: "Folder 2",
+                    slug: "folder-2",
+                    parentId: "folder-1",
+                    type
+                },
+                {
+                    id: "folder-3",
+                    title: "Folder 3",
+                    slug: "folder-3",
+                    parentId: "folder-2",
+                    type
+                }
+            ],
+            siblings: [
+                {
+                    id: "folder-4",
+                    title: "Folder 4",
+                    slug: "folder-4",
+                    parentId: "folder-3",
+                    type
+                },
+                {
+                    id: "folder-5",
+                    title: "Folder 5",
+                    slug: "folder-5",
+                    parentId: "folder-3",
+                    type
+                }
+            ]
+        });
+        const spy = vi.spyOn(gateway, "execute");
+        const { useCase, foldersCache, loadedFoldersCache } = setupTest(gateway);
+        expect(foldersCache.hasItems()).toBe(false);
+        expect(loadedFoldersCache.hasItems()).toBe(false);
+        await useCase.execute("folder-0");
+        expect(spy).toHaveBeenCalledTimes(1);
+        expect(spy).toHaveBeenCalledWith(type, "folder-0");
+        expect(foldersCache.hasItems()).toBe(true);
+        expect(foldersCache.count()).toEqual(5);
+        expect(loadedFoldersCache.count()).toEqual(3);
+        expect(loadedFoldersCache.getItems()).toEqual([
+            "folder-1",
+            "folder-2",
+            "folder-3"
+        ]);
+        await useCase.execute("folder-0");
+        expect(foldersCache.count()).toEqual(5);
+        expect(loadedFoldersCache.count()).toEqual(3);
+    });
+    it("should only  update the list of folders in `cache` when `children` are returned by the gateway", async ()=>{
+        const gateway = new GetFolderHierarchyMockGateway({
+            parents: [],
+            siblings: [
+                {
+                    id: "folder-1",
+                    title: "Folder 1",
+                    slug: "folder-1",
+                    parentId: null,
+                    type
+                },
+                {
+                    id: "folder-2",
+                    title: "Folder 2",
+                    slug: "folder-2",
+                    parentId: null,
+                    type
+                }
+            ]
+        });
+        const spy = vi.spyOn(gateway, "execute");
+        const { useCase, foldersCache, loadedFoldersCache } = setupTest(gateway);
+        expect(foldersCache.hasItems()).toBe(false);
+        expect(loadedFoldersCache.hasItems()).toBe(false);
+        await useCase.execute("folder-0");
+        expect(spy).toHaveBeenCalledTimes(1);
+        expect(spy).toHaveBeenCalledWith(type, "folder-0");
+        expect(foldersCache.hasItems()).toBe(true);
+        expect(foldersCache.count()).toEqual(2);
+        expect(loadedFoldersCache.hasItems()).toBe(false);
+    });
+    it("should handle gateway errors gracefully", async ()=>{
+        class GetFolderHierarchyErrorMockGateway {
+            async execute() {
+                throw new Error("Gateway error");
+            }
+        }
+        const gateway = new GetFolderHierarchyErrorMockGateway();
+        const spy = vi.spyOn(gateway, "execute");
+        const { useCase, foldersCache } = setupTest(gateway);
+        expect(foldersCache.hasItems()).toBe(false);
+        await expect(useCase.execute("folder-0")).rejects.toThrow("Gateway error");
+        expect(spy).toHaveBeenCalledTimes(1);
+        expect(foldersCache.hasItems()).toBe(false);
+    });
+});
+
+//# sourceMappingURL=LoadFolderHierarchy.test.js.map

package/features/folders/loadFolderHierarchy/LoadFolderHierarchy.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folders/loadFolderHierarchy/LoadFolderHierarchy.test.js","sources":["../../../../src/features/folders/loadFolderHierarchy/LoadFolderHierarchy.test.ts"],"sourcesContent":["import { beforeEach, describe, expect, it, vi } from \"vitest\";\nimport { Container } from \"@webiny/di\";\nimport { ListCache, LoadedCache } from \"~/features/folders/cache/index.js\";\nimport { Folder } from \"~/domain/folder/Folder.js\";\nimport {\n    FoldersCache,\n    FoldersContext,\n    FoldersLoadingRepository,\n    LoadedFoldersCache\n} from \"../abstractions.js\";\nimport { LoadingRepository } from \"@webiny/app-utils\";\nimport type { LoadFolderHierarchyGatewayResponse } from \"./abstractions.js\";\nimport { LoadFolderHierarchyGateway, LoadFolderHierarchyUseCase } from \"./abstractions.js\";\nimport { LoadFolderHierarchyFeature } from \"./feature.js\";\n\ndescribe(\"GetFolderHierarchy\", () => {\n    const type = \"abc\";\n\n    function setupTest(gateway: LoadFolderHierarchyGateway.Interface) {\n        const container = new Container();\n        const foldersCache = new ListCache<Folder>();\n        const loadedFoldersCache = new LoadedCache();\n\n        container.registerInstance(FoldersContext, { type });\n        container.registerInstance(FoldersCache, foldersCache);\n        container.registerInstance(LoadedFoldersCache, loadedFoldersCache);\n        container.registerInstance(FoldersLoadingRepository, new LoadingRepository());\n\n        LoadFolderHierarchyFeature.register(container);\n        container.registerInstance(LoadFolderHierarchyGateway, gateway);\n\n        return {\n            container,\n            foldersCache,\n            loadedFoldersCache,\n            useCase: container.resolve(LoadFolderHierarchyUseCase)\n        };\n    }\n\n    beforeEach(() => {\n        vi.resetAllMocks();\n    });\n\n    class GetFolderHierarchyMockGateway implements LoadFolderHierarchyGateway.Interface {\n        mockResponse: LoadFolderHierarchyGatewayResponse;\n\n        // Had to use `any` as the mock folders passed in the tests below are also partial objects.\n        constructor(mockResponse: any) {\n            this.mockResponse = mockResponse as LoadFolderHierarchyGatewayResponse;\n        }\n\n        async execute() {\n            return this.mockResponse;\n        }\n    }\n\n    it(\"should update the list of folders in both `cache` and `loadedCache` when `parents` and `children` are returned by the gateway\", async () => {\n        const gateway = new GetFolderHierarchyMockGateway({\n            parents: [\n                {\n                    id: \"folder-1\",\n                    title: \"Folder 1\",\n                    slug: \"folder-1\",\n                    parentId: null,\n                    type\n                },\n                {\n                    id: \"folder-2\",\n                    title: \"Folder 2\",\n                    slug: \"folder-2\",\n                    parentId: \"folder-1\",\n                    type\n                },\n                {\n                    id: \"folder-3\",\n                    title: \"Folder 3\",\n                    slug: \"folder-3\",\n                    parentId: \"folder-2\",\n                    type\n                }\n            ],\n            siblings: [\n                {\n                    id: \"folder-4\",\n                    title: \"Folder 4\",\n                    slug: \"folder-4\",\n                    parentId: \"folder-3\",\n                    type\n                },\n                {\n                    id: \"folder-5\",\n                    title: \"Folder 5\",\n                    slug: \"folder-5\",\n                    parentId: \"folder-3\",\n                    type\n                }\n            ]\n        });\n\n        const spy = vi.spyOn(gateway, \"execute\");\n\n        const { useCase, foldersCache, loadedFoldersCache } = setupTest(gateway);\n\n        expect(foldersCache.hasItems()).toBe(false);\n        expect(loadedFoldersCache.hasItems()).toBe(false);\n        await useCase.execute(\"folder-0\");\n\n        expect(spy).toHaveBeenCalledTimes(1);\n        expect(spy).toHaveBeenCalledWith(type, \"folder-0\");\n\n        expect(foldersCache.hasItems()).toBe(true);\n        expect(foldersCache.count()).toEqual(5);\n        // We are storing only the parent folders id in the loadedFoldersCache\n        expect(loadedFoldersCache.count()).toEqual(3);\n        expect(loadedFoldersCache.getItems()).toEqual([\"folder-1\", \"folder-2\", \"folder-3\"]);\n\n        // This call should be idempotent: the number of elements in cache should not change\n        await useCase.execute(\"folder-0\");\n        expect(foldersCache.count()).toEqual(5);\n        expect(loadedFoldersCache.count()).toEqual(3);\n    });\n\n    it(\"should only  update the list of folders in `cache` when `children` are returned by the gateway\", async () => {\n        const gateway = new GetFolderHierarchyMockGateway({\n            parents: [],\n            siblings: [\n                {\n                    id: \"folder-1\",\n                    title: \"Folder 1\",\n                    slug: \"folder-1\",\n                    parentId: null,\n                    type\n                },\n                {\n                    id: \"folder-2\",\n                    title: \"Folder 2\",\n                    slug: \"folder-2\",\n                    parentId: null,\n                    type\n                }\n            ]\n        });\n\n        const spy = vi.spyOn(gateway, \"execute\");\n\n        const { useCase, foldersCache, loadedFoldersCache } = setupTest(gateway);\n\n        expect(foldersCache.hasItems()).toBe(false);\n        expect(loadedFoldersCache.hasItems()).toBe(false);\n        await useCase.execute(\"folder-0\");\n\n        expect(spy).toHaveBeenCalledTimes(1);\n        expect(spy).toHaveBeenCalledWith(type, \"folder-0\");\n\n        expect(foldersCache.hasItems()).toBe(true);\n        expect(foldersCache.count()).toEqual(2);\n        // We are NOT storing any folder loadedFoldersCache\n        expect(loadedFoldersCache.hasItems()).toBe(false);\n    });\n\n    it(\"should handle gateway errors gracefully\", async () => {\n        class GetFolderHierarchyErrorMockGateway implements LoadFolderHierarchyGateway.Interface {\n            async execute(): LoadFolderHierarchyGateway.Return {\n                throw new Error(\"Gateway error\");\n            }\n        }\n\n        const gateway = new GetFolderHierarchyErrorMockGateway();\n        const spy = vi.spyOn(gateway, \"execute\");\n\n        const { useCase, foldersCache } = setupTest(gateway);\n\n        expect(foldersCache.hasItems()).toBe(false);\n\n        await expect(useCase.execute(\"folder-0\")).rejects.toThrow(\"Gateway error\");\n\n        expect(spy).toHaveBeenCalledTimes(1);\n        expect(foldersCache.hasItems()).toBe(false);\n    });\n});\n"],"names":["describe","type","setupTest","gateway","container","Container","foldersCache","ListCache","loadedFoldersCache","LoadedCache","FoldersContext","FoldersCache","LoadedFoldersCache","FoldersLoadingRepository","LoadingRepository","LoadFolderHierarchyFeature","LoadFolderHierarchyGateway","LoadFolderHierarchyUseCase","beforeEach","vi","GetFolderHierarchyMockGateway","mockResponse","it","spy","useCase","expect","GetFolderHierarchyErrorMockGateway","Error"],"mappings":"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"}

package/features/folders/loadFolderHierarchy/LoadFolderHierarchyGqlGateway.d.ts

@@ -0,0 +1,35 @@
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/index.js";
+import type { FolderDto } from "../../../domain/folder/FolderDto.js";
+import { FolderModelProvider } from "../../../features/folders/abstractions.js";
+import { LoadFolderHierarchyGateway as GatewayAbstraction } from "./abstractions.js";
+import type { AcoError } from "../../../types.js";
+interface LoadFolderHierarchyResponseData {
+    parents: FolderDto[];
+    siblings: FolderDto[];
+}
+export interface LoadFolderHierarchyResponse {
+    aco: {
+        getFolderHierarchy: {
+            data: LoadFolderHierarchyResponseData | null;
+            error: AcoError | null;
+        };
+    };
+}
+export interface LoadFolderHierarchyQueryVariables {
+    type: string;
+    id: string;
+}
+export declare const LOAD_FOLDER_HIERARCHY: (FOLDER_FIELDS: string) => string;
+declare class LoadFolderHierarchyGqlGatewayImpl implements GatewayAbstraction.Interface {
+    private client;
+    private folderModelProvider;
+    constructor(client: MainGraphQLClient.Interface, folderModelProvider: FolderModelProvider.Interface);
+    execute(type: string, id: string): Promise<{
+        parents: FolderDto[];
+        siblings: FolderDto[];
+    }>;
+}
+export declare const LoadFolderHierarchyGqlGateway: typeof LoadFolderHierarchyGqlGatewayImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ILoadFolderHierarchyGateway>;
+};
+export {};

package/features/folders/loadFolderHierarchy/LoadFolderHierarchyGqlGateway.js

@@ -0,0 +1,57 @@
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/index.js";
+import { RootFolder } from "../../../domain/folder/RootFolder.js";
+import { FolderModelProvider } from "../abstractions.js";
+import { LoadFolderHierarchyGateway } from "./abstractions.js";
+const LOAD_FOLDER_HIERARCHY = (FOLDER_FIELDS)=>`
+    query GetFolderHierarchy($type: String!, $id: ID!) {
+        aco {
+            getFolderHierarchy(type: $type, id: $id) {
+                data {
+                    parents ${FOLDER_FIELDS}
+                    siblings ${FOLDER_FIELDS}
+                }
+                error {
+                    code
+                    data
+                    message
+                }
+            }
+        }
+    }
+`;
+class LoadFolderHierarchyGqlGatewayImpl {
+    constructor(client, folderModelProvider){
+        this.client = client;
+        this.folderModelProvider = folderModelProvider;
+    }
+    async execute(type, id) {
+        const fields = await this.folderModelProvider.getGraphQLSelection();
+        const response = await this.client.execute({
+            query: LOAD_FOLDER_HIERARCHY(fields),
+            variables: {
+                type,
+                id
+            }
+        });
+        if (!response) throw new Error(`Network error while loading folder hierarchy for the provided type/id: ${type}/${id}.`);
+        const { data, error } = response.aco.getFolderHierarchy;
+        if (!data) throw new Error(error?.message || `Could not load folder hierarchy for the provided type/id: ${type}/${id}.`);
+        return {
+            parents: [
+                RootFolder.create(),
+                ...data.parents
+            ],
+            siblings: data.siblings
+        };
+    }
+}
+const LoadFolderHierarchyGqlGateway = LoadFolderHierarchyGateway.createImplementation({
+    implementation: LoadFolderHierarchyGqlGatewayImpl,
+    dependencies: [
+        MainGraphQLClient,
+        FolderModelProvider
+    ]
+});
+export { LOAD_FOLDER_HIERARCHY, LoadFolderHierarchyGqlGateway };
+
+//# sourceMappingURL=LoadFolderHierarchyGqlGateway.js.map

package/features/folders/loadFolderHierarchy/LoadFolderHierarchyGqlGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folders/loadFolderHierarchy/LoadFolderHierarchyGqlGateway.js","sources":["../../../../src/features/folders/loadFolderHierarchy/LoadFolderHierarchyGqlGateway.ts"],"sourcesContent":["import { MainGraphQLClient } from \"@webiny/app/features/mainGraphQLClient/index.js\";\nimport type { FolderDto } from \"~/domain/folder/FolderDto.js\";\nimport { RootFolder } from \"~/domain/folder/RootFolder.js\";\nimport { FolderModelProvider } from \"~/features/folders/abstractions.js\";\nimport { LoadFolderHierarchyGateway as GatewayAbstraction } from \"./abstractions.js\";\nimport type { AcoError } from \"~/types.js\";\n\ninterface LoadFolderHierarchyResponseData {\n    parents: FolderDto[];\n    siblings: FolderDto[];\n}\n\nexport interface LoadFolderHierarchyResponse {\n    aco: {\n        getFolderHierarchy: {\n            data: LoadFolderHierarchyResponseData | null;\n            error: AcoError | null;\n        };\n    };\n}\n\nexport interface LoadFolderHierarchyQueryVariables {\n    type: string;\n    id: string;\n}\n\nexport const LOAD_FOLDER_HIERARCHY = (FOLDER_FIELDS: string) => /* GraphQL*/ `\n    query GetFolderHierarchy($type: String!, $id: ID!) {\n        aco {\n            getFolderHierarchy(type: $type, id: $id) {\n                data {\n                    parents ${FOLDER_FIELDS}\n                    siblings ${FOLDER_FIELDS}\n                }\n                error {\n                    code\n                    data\n                    message\n                }\n            }\n        }\n    }\n`;\n\nclass LoadFolderHierarchyGqlGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(\n        private client: MainGraphQLClient.Interface,\n        private folderModelProvider: FolderModelProvider.Interface\n    ) {}\n\n    async execute(type: string, id: string) {\n        const fields = await this.folderModelProvider.getGraphQLSelection();\n\n        const response = await this.client.execute<\n            LoadFolderHierarchyResponse,\n            LoadFolderHierarchyQueryVariables\n        >({\n            query: LOAD_FOLDER_HIERARCHY(fields),\n            variables: {\n                type,\n                id\n            }\n        });\n\n        if (!response) {\n            throw new Error(\n                `Network error while loading folder hierarchy for the provided type/id: ${type}/${id}.`\n            );\n        }\n\n        const { data, error } = response.aco.getFolderHierarchy;\n\n        if (!data) {\n            throw new Error(\n                error?.message ||\n                    `Could not load folder hierarchy for the provided type/id: ${type}/${id}.`\n            );\n        }\n\n        return {\n            parents: [RootFolder.create(), ...data.parents],\n            siblings: data.siblings\n        };\n    }\n}\n\nexport const LoadFolderHierarchyGqlGateway = GatewayAbstraction.createImplementation({\n    implementation: LoadFolderHierarchyGqlGatewayImpl,\n    dependencies: [MainGraphQLClient, FolderModelProvider]\n});\n"],"names":["LOAD_FOLDER_HIERARCHY","FOLDER_FIELDS","LoadFolderHierarchyGqlGatewayImpl","client","folderModelProvider","type","id","fields","response","Error","data","error","RootFolder","LoadFolderHierarchyGqlGateway","GatewayAbstraction","MainGraphQLClient","FolderModelProvider"],"mappings":";;;;AA0BO,MAAMA,wBAAwB,CAACC,gBAAuC,CAAC;;;;;4BAKlD,EAAEA,cAAc;6BACf,EAAEA,cAAc;;;;;;;;;;AAU7C,CAAC;AAED,MAAMC;IACF,YACYC,MAAmC,EACnCC,mBAAkD,CAC5D;aAFUD,MAAM,GAANA;aACAC,mBAAmB,GAAnBA;IACT;IAEH,MAAM,QAAQC,IAAY,EAAEC,EAAU,EAAE;QACpC,MAAMC,SAAS,MAAM,IAAI,CAAC,mBAAmB,CAAC,mBAAmB;QAEjE,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAGxC;YACE,OAAOR,sBAAsBO;YAC7B,WAAW;gBACPF;gBACAC;YACJ;QACJ;QAEA,IAAI,CAACE,UACD,MAAM,IAAIC,MACN,CAAC,uEAAuE,EAAEJ,KAAK,CAAC,EAAEC,GAAG,CAAC,CAAC;QAI/F,MAAM,EAAEI,IAAI,EAAEC,KAAK,EAAE,GAAGH,SAAS,GAAG,CAAC,kBAAkB;QAEvD,IAAI,CAACE,MACD,MAAM,IAAID,MACNE,OAAO,WACH,CAAC,0DAA0D,EAAEN,KAAK,CAAC,EAAEC,GAAG,CAAC,CAAC;QAItF,OAAO;YACH,SAAS;gBAACM,WAAW,MAAM;mBAAOF,KAAK,OAAO;aAAC;YAC/C,UAAUA,KAAK,QAAQ;QAC3B;IACJ;AACJ;AAEO,MAAMG,gCAAgCC,2BAAAA,oBAAuC,CAAC;IACjF,gBAAgBZ;IAChB,cAAc;QAACa;QAAmBC;KAAoB;AAC1D"}

package/features/folders/loadFolderHierarchy/LoadFolderHierarchyRepository.d.ts

@@ -0,0 +1,16 @@
+import { LoadFolderHierarchyRepository as RepositoryAbstraction, LoadFolderHierarchyGateway } from "./abstractions.js";
+import { FoldersCache, LoadedFoldersCache, FoldersContext } from "../../../features/folders/abstractions.js";
+declare class LoadFolderHierarchyRepositoryImpl implements RepositoryAbstraction.Interface {
+    private cache;
+    private loadedCache;
+    private gateway;
+    private foldersContext;
+    private pendingPromises;
+    constructor(cache: FoldersCache.Interface, loadedCache: LoadedFoldersCache.Interface, gateway: LoadFolderHierarchyGateway.Interface, foldersContext: FoldersContext.Interface);
+    execute(id: string): Promise<void>;
+    private loadFolders;
+}
+export declare const LoadFolderHierarchyRepository: typeof LoadFolderHierarchyRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ILoadFolderHierarchyRepository>;
+};
+export {};

package/features/folders/loadFolderHierarchy/LoadFolderHierarchyRepository.js

@@ -0,0 +1,44 @@
+import { Folder } from "../../../domain/folder/Folder.js";
+import { LoadFolderHierarchyGateway, LoadFolderHierarchyRepository } from "./abstractions.js";
+import { FoldersCache, FoldersContext, LoadedFoldersCache } from "../abstractions.js";
+class LoadFolderHierarchyRepositoryImpl {
+    constructor(cache, loadedCache, gateway, foldersContext){
+        this.cache = cache;
+        this.loadedCache = loadedCache;
+        this.gateway = gateway;
+        this.foldersContext = foldersContext;
+        this.pendingPromises = new Map();
+    }
+    async execute(id) {
+        const pendingPromise = this.pendingPromises.get(id);
+        if (pendingPromise) return pendingPromise;
+        const promise = this.loadFolders(id).finally(()=>{
+            this.pendingPromises.delete(id);
+        });
+        this.pendingPromises.set(id, promise);
+        return promise;
+    }
+    async loadFolders(id) {
+        const existingCache = this.loadedCache.getItem((item)=>item === id);
+        if (existingCache) return;
+        const response = await this.gateway.execute(this.foldersContext.type, id);
+        const { parents = [], siblings = [] } = response;
+        if (parents.length > 0) this.loadedCache.addItems(parents.map((parent)=>parent.id));
+        this.cache.addItems([
+            ...parents,
+            ...siblings
+        ].map((item)=>Folder.create(item)));
+    }
+}
+const LoadFolderHierarchyRepository_LoadFolderHierarchyRepository = LoadFolderHierarchyRepository.createImplementation({
+    implementation: LoadFolderHierarchyRepositoryImpl,
+    dependencies: [
+        FoldersCache,
+        LoadedFoldersCache,
+        LoadFolderHierarchyGateway,
+        FoldersContext
+    ]
+});
+export { LoadFolderHierarchyRepository_LoadFolderHierarchyRepository as LoadFolderHierarchyRepository };
+
+//# sourceMappingURL=LoadFolderHierarchyRepository.js.map

package/features/folders/loadFolderHierarchy/LoadFolderHierarchyRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folders/loadFolderHierarchy/LoadFolderHierarchyRepository.js","sources":["../../../../src/features/folders/loadFolderHierarchy/LoadFolderHierarchyRepository.ts"],"sourcesContent":["import { Folder } from \"~/domain/folder/Folder.js\";\nimport {\n    LoadFolderHierarchyRepository as RepositoryAbstraction,\n    LoadFolderHierarchyGateway\n} from \"./abstractions.js\";\nimport {\n    FoldersCache,\n    LoadedFoldersCache,\n    FoldersContext\n} from \"~/features/folders/abstractions.js\";\n\nclass LoadFolderHierarchyRepositoryImpl implements RepositoryAbstraction.Interface {\n    private pendingPromises = new Map<string, Promise<void>>();\n\n    constructor(\n        private cache: FoldersCache.Interface,\n        private loadedCache: LoadedFoldersCache.Interface,\n        private gateway: LoadFolderHierarchyGateway.Interface,\n        private foldersContext: FoldersContext.Interface\n    ) {}\n\n    async execute(id: string) {\n        // Return pending promise if one exists\n        const pendingPromise = this.pendingPromises.get(id);\n        if (pendingPromise) {\n            return pendingPromise;\n        }\n\n        // Create new promise with cleanup and cache it\n        const promise = this.loadFolders(id).finally(() => {\n            this.pendingPromises.delete(id);\n        });\n\n        // Store the promise\n        this.pendingPromises.set(id, promise);\n\n        return promise;\n    }\n\n    private async loadFolders(id: string) {\n        const existingCache = this.loadedCache.getItem(item => item === id);\n        if (existingCache) {\n            return;\n        }\n\n        const response = await this.gateway.execute(this.foldersContext.type, id);\n\n        const { parents = [], siblings = [] } = response;\n\n        if (parents.length > 0) {\n            this.loadedCache.addItems(parents.map(parent => parent.id));\n        }\n\n        this.cache.addItems([...parents, ...siblings].map(item => Folder.create(item)));\n    }\n}\n\nexport const LoadFolderHierarchyRepository = RepositoryAbstraction.createImplementation({\n    implementation: LoadFolderHierarchyRepositoryImpl,\n    dependencies: [FoldersCache, LoadedFoldersCache, LoadFolderHierarchyGateway, FoldersContext]\n});\n"],"names":["LoadFolderHierarchyRepositoryImpl","cache","loadedCache","gateway","foldersContext","Map","id","pendingPromise","promise","existingCache","item","response","parents","siblings","parent","Folder","LoadFolderHierarchyRepository","RepositoryAbstraction","FoldersCache","LoadedFoldersCache","LoadFolderHierarchyGateway","FoldersContext"],"mappings":";;;AAWA,MAAMA;IAGF,YACYC,KAA6B,EAC7BC,WAAyC,EACzCC,OAA6C,EAC7CC,cAAwC,CAClD;aAJUH,KAAK,GAALA;aACAC,WAAW,GAAXA;aACAC,OAAO,GAAPA;aACAC,cAAc,GAAdA;aANJ,eAAe,GAAG,IAAIC;IAO3B;IAEH,MAAM,QAAQC,EAAU,EAAE;QAEtB,MAAMC,iBAAiB,IAAI,CAAC,eAAe,CAAC,GAAG,CAACD;QAChD,IAAIC,gBACA,OAAOA;QAIX,MAAMC,UAAU,IAAI,CAAC,WAAW,CAACF,IAAI,OAAO,CAAC;YACzC,IAAI,CAAC,eAAe,CAAC,MAAM,CAACA;QAChC;QAGA,IAAI,CAAC,eAAe,CAAC,GAAG,CAACA,IAAIE;QAE7B,OAAOA;IACX;IAEA,MAAc,YAAYF,EAAU,EAAE;QAClC,MAAMG,gBAAgB,IAAI,CAAC,WAAW,CAAC,OAAO,CAACC,CAAAA,OAAQA,SAASJ;QAChE,IAAIG,eACA;QAGJ,MAAME,WAAW,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,EAAEL;QAEtE,MAAM,EAAEM,UAAU,EAAE,EAAEC,WAAW,EAAE,EAAE,GAAGF;QAExC,IAAIC,QAAQ,MAAM,GAAG,GACjB,IAAI,CAAC,WAAW,CAAC,QAAQ,CAACA,QAAQ,GAAG,CAACE,CAAAA,SAAUA,OAAO,EAAE;QAG7D,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC;eAAIF;eAAYC;SAAS,CAAC,GAAG,CAACH,CAAAA,OAAQK,OAAO,MAAM,CAACL;IAC5E;AACJ;AAEO,MAAMM,8DAAgCC,8BAAAA,oBAA0C,CAAC;IACpF,gBAAgBjB;IAChB,cAAc;QAACkB;QAAcC;QAAoBC;QAA4BC;KAAe;AAChG"}

package/features/folders/loadFolderHierarchy/LoadFolderHierarchyUseCase.d.ts

@@ -0,0 +1,10 @@
+import { LoadFolderHierarchyUseCase as UseCaseAbstraction, LoadFolderHierarchyRepository } from "./abstractions.js";
+declare class LoadFolderHierarchyUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    constructor(repository: LoadFolderHierarchyRepository.Interface);
+    execute(id: string): Promise<void>;
+}
+export declare const LoadFolderHierarchyUseCase: typeof LoadFolderHierarchyUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ILoadFolderHierarchyUseCase>;
+};
+export {};

package/features/folders/loadFolderHierarchy/LoadFolderHierarchyUseCase.js

@@ -0,0 +1,18 @@
+import { LoadFolderHierarchyRepository, LoadFolderHierarchyUseCase } from "./abstractions.js";
+class LoadFolderHierarchyUseCaseImpl {
+    constructor(repository){
+        this.repository = repository;
+    }
+    async execute(id) {
+        await this.repository.execute(id);
+    }
+}
+const LoadFolderHierarchyUseCase_LoadFolderHierarchyUseCase = LoadFolderHierarchyUseCase.createImplementation({
+    implementation: LoadFolderHierarchyUseCaseImpl,
+    dependencies: [
+        LoadFolderHierarchyRepository
+    ]
+});
+export { LoadFolderHierarchyUseCase_LoadFolderHierarchyUseCase as LoadFolderHierarchyUseCase };
+
+//# sourceMappingURL=LoadFolderHierarchyUseCase.js.map

package/features/folders/loadFolderHierarchy/LoadFolderHierarchyUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folders/loadFolderHierarchy/LoadFolderHierarchyUseCase.js","sources":["../../../../src/features/folders/loadFolderHierarchy/LoadFolderHierarchyUseCase.ts"],"sourcesContent":["import {\n    LoadFolderHierarchyUseCase as UseCaseAbstraction,\n    LoadFolderHierarchyRepository\n} from \"./abstractions.js\";\n\nclass LoadFolderHierarchyUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: LoadFolderHierarchyRepository.Interface) {}\n\n    async execute(id: string) {\n        await this.repository.execute(id);\n    }\n}\n\nexport const LoadFolderHierarchyUseCase = UseCaseAbstraction.createImplementation({\n    implementation: LoadFolderHierarchyUseCaseImpl,\n    dependencies: [LoadFolderHierarchyRepository]\n});\n"],"names":["LoadFolderHierarchyUseCaseImpl","repository","id","LoadFolderHierarchyUseCase","UseCaseAbstraction","LoadFolderHierarchyRepository"],"mappings":";AAKA,MAAMA;IACF,YAAoBC,UAAmD,CAAE;aAArDA,UAAU,GAAVA;IAAsD;IAE1E,MAAM,QAAQC,EAAU,EAAE;QACtB,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;IAClC;AACJ;AAEO,MAAMC,wDAA6BC,2BAAAA,oBAAuC,CAAC;IAC9E,gBAAgBJ;IAChB,cAAc;QAACK;KAA8B;AACjD"}

package/features/folders/loadFolderHierarchy/LoadFolderHierarchyUseCaseWithLoading.d.ts

@@ -0,0 +1,12 @@
+import { FoldersLoadingRepository } from "../abstractions.js";
+import { LoadFolderHierarchyUseCase as UseCaseAbstraction } from "./abstractions.js";
+declare class LoadFolderHierarchyUseCaseWithLoadingImpl implements UseCaseAbstraction.Interface {
+    private loadingRepository;
+    private decoratee;
+    constructor(loadingRepository: FoldersLoadingRepository.Interface, decoratee: UseCaseAbstraction.Interface);
+    execute(id: string): Promise<void>;
+}
+export declare const LoadFolderHierarchyUseCaseWithLoading: typeof LoadFolderHierarchyUseCaseWithLoadingImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ILoadFolderHierarchyUseCase>;
+};
+export {};

package/features/folders/loadFolderHierarchy/LoadFolderHierarchyUseCaseWithLoading.js

@@ -0,0 +1,21 @@
+import { FoldersLoadingRepository } from "../abstractions.js";
+import { LoadFolderHierarchyUseCase } from "./abstractions.js";
+import { LoadingActionsEnum } from "../../../types.js";
+class LoadFolderHierarchyUseCaseWithLoadingImpl {
+    constructor(loadingRepository, decoratee){
+        this.loadingRepository = loadingRepository;
+        this.decoratee = decoratee;
+    }
+    async execute(id) {
+        await this.loadingRepository.runCallBack(this.decoratee.execute(id), LoadingActionsEnum.init);
+    }
+}
+const LoadFolderHierarchyUseCaseWithLoading = LoadFolderHierarchyUseCase.createDecorator({
+    decorator: LoadFolderHierarchyUseCaseWithLoadingImpl,
+    dependencies: [
+        FoldersLoadingRepository
+    ]
+});
+export { LoadFolderHierarchyUseCaseWithLoading };
+
+//# sourceMappingURL=LoadFolderHierarchyUseCaseWithLoading.js.map

package/features/folders/loadFolderHierarchy/LoadFolderHierarchyUseCaseWithLoading.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folders/loadFolderHierarchy/LoadFolderHierarchyUseCaseWithLoading.js","sources":["../../../../src/features/folders/loadFolderHierarchy/LoadFolderHierarchyUseCaseWithLoading.ts"],"sourcesContent":["import { FoldersLoadingRepository } from \"../abstractions.js\";\nimport { LoadFolderHierarchyUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { LoadingActionsEnum } from \"~/types.js\";\n\nclass LoadFolderHierarchyUseCaseWithLoadingImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private loadingRepository: FoldersLoadingRepository.Interface,\n        private decoratee: UseCaseAbstraction.Interface\n    ) {}\n\n    async execute(id: string) {\n        await this.loadingRepository.runCallBack(\n            this.decoratee.execute(id),\n            LoadingActionsEnum.init\n        );\n    }\n}\n\nexport const LoadFolderHierarchyUseCaseWithLoading = UseCaseAbstraction.createDecorator({\n    decorator: LoadFolderHierarchyUseCaseWithLoadingImpl,\n    dependencies: [FoldersLoadingRepository]\n});\n"],"names":["LoadFolderHierarchyUseCaseWithLoadingImpl","loadingRepository","decoratee","id","LoadingActionsEnum","LoadFolderHierarchyUseCaseWithLoading","UseCaseAbstraction","FoldersLoadingRepository"],"mappings":";;;AAIA,MAAMA;IACF,YACYC,iBAAqD,EACrDC,SAAuC,CACjD;aAFUD,iBAAiB,GAAjBA;aACAC,SAAS,GAATA;IACT;IAEH,MAAM,QAAQC,EAAU,EAAE;QACtB,MAAM,IAAI,CAAC,iBAAiB,CAAC,WAAW,CACpC,IAAI,CAAC,SAAS,CAAC,OAAO,CAACA,KACvBC,mBAAmB,IAAI;IAE/B;AACJ;AAEO,MAAMC,wCAAwCC,2BAAAA,eAAkC,CAAC;IACpF,WAAWN;IACX,cAAc;QAACO;KAAyB;AAC5C"}

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

@@ -0,0 +1,27 @@
+import type { FolderDto } from "../../../domain/folder/FolderDto.js";
+export interface LoadFolderHierarchyGatewayResponse {
+    parents: FolderDto[];
+    siblings: FolderDto[];
+}
+export interface ILoadFolderHierarchyUseCase {
+    execute: (id: string) => Promise<void>;
+}
+export interface ILoadFolderHierarchyRepository {
+    execute: (id: string) => Promise<void>;
+}
+export interface ILoadFolderHierarchyGateway {
+    execute: (type: string, id: string) => Promise<LoadFolderHierarchyGatewayResponse>;
+}
+export declare const LoadFolderHierarchyUseCase: import("@webiny/di").Abstraction<ILoadFolderHierarchyUseCase>;
+export declare namespace LoadFolderHierarchyUseCase {
+    type Interface = ILoadFolderHierarchyUseCase;
+}
+export declare const LoadFolderHierarchyRepository: import("@webiny/di").Abstraction<ILoadFolderHierarchyRepository>;
+export declare namespace LoadFolderHierarchyRepository {
+    type Interface = ILoadFolderHierarchyRepository;
+}
+export declare const LoadFolderHierarchyGateway: import("@webiny/di").Abstraction<ILoadFolderHierarchyGateway>;
+export declare namespace LoadFolderHierarchyGateway {
+    type Interface = ILoadFolderHierarchyGateway;
+    type Return = Promise<LoadFolderHierarchyGatewayResponse>;
+}

package/features/folders/loadFolderHierarchy/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folders/loadFolderHierarchy/abstractions.js","sources":["../../../../src/features/folders/loadFolderHierarchy/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\nimport type { FolderDto } from \"~/domain/folder/FolderDto.js\";\n\nexport interface LoadFolderHierarchyGatewayResponse {\n    parents: FolderDto[];\n    siblings: FolderDto[];\n}\n\nexport interface ILoadFolderHierarchyUseCase {\n    execute: (id: string) => Promise<void>;\n}\n\nexport interface ILoadFolderHierarchyRepository {\n    execute: (id: string) => Promise<void>;\n}\n\nexport interface ILoadFolderHierarchyGateway {\n    execute: (type: string, id: string) => Promise<LoadFolderHierarchyGatewayResponse>;\n}\n\nexport const LoadFolderHierarchyUseCase = createAbstraction<ILoadFolderHierarchyUseCase>(\n    \"LoadFolderHierarchyUseCase\"\n);\n\nexport namespace LoadFolderHierarchyUseCase {\n    export type Interface = ILoadFolderHierarchyUseCase;\n}\n\nexport const LoadFolderHierarchyRepository = createAbstraction<ILoadFolderHierarchyRepository>(\n    \"LoadFolderHierarchyRepository\"\n);\n\nexport namespace LoadFolderHierarchyRepository {\n    export type Interface = ILoadFolderHierarchyRepository;\n}\n\nexport const LoadFolderHierarchyGateway = createAbstraction<ILoadFolderHierarchyGateway>(\n    \"LoadFolderHierarchyGateway\"\n);\n\nexport namespace LoadFolderHierarchyGateway {\n    export type Interface = ILoadFolderHierarchyGateway;\n    export type Return = Promise<LoadFolderHierarchyGatewayResponse>;\n}\n"],"names":["LoadFolderHierarchyUseCase","createAbstraction","LoadFolderHierarchyRepository","LoadFolderHierarchyGateway"],"mappings":";AAoBO,MAAMA,6BAA6BC,kBACtC;AAOG,MAAMC,gCAAgCD,kBACzC;AAOG,MAAME,6BAA6BF,kBACtC"}

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

@@ -0,0 +1,4 @@
+export declare const LoadFolderHierarchyFeature: import("@webiny/feature/admin").FeatureDefinition<{
+    useCase: import("./abstractions.js").ILoadFolderHierarchyUseCase;
+    loading: import("@webiny/app-utils/index.js").ILoadingRepository;
+}, []>;

package/features/folders/loadFolderHierarchy/feature.js

@@ -0,0 +1,25 @@
+import { createFeature } from "@webiny/feature/admin";
+import { FoldersLoadingRepository } from "../abstractions.js";
+import { LoadFolderHierarchyUseCase } from "./abstractions.js";
+import { LoadFolderHierarchyUseCase as external_LoadFolderHierarchyUseCase_js_LoadFolderHierarchyUseCase } from "./LoadFolderHierarchyUseCase.js";
+import { LoadFolderHierarchyRepository } from "./LoadFolderHierarchyRepository.js";
+import { LoadFolderHierarchyGqlGateway } from "./LoadFolderHierarchyGqlGateway.js";
+import { LoadFolderHierarchyUseCaseWithLoading } from "./LoadFolderHierarchyUseCaseWithLoading.js";
+const LoadFolderHierarchyFeature = createFeature({
+    name: "LoadFolderHierarchy",
+    register (container) {
+        container.register(external_LoadFolderHierarchyUseCase_js_LoadFolderHierarchyUseCase);
+        container.register(LoadFolderHierarchyRepository).inSingletonScope();
+        container.register(LoadFolderHierarchyGqlGateway);
+        container.registerDecorator(LoadFolderHierarchyUseCaseWithLoading);
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(LoadFolderHierarchyUseCase),
+            loading: container.resolve(FoldersLoadingRepository)
+        };
+    }
+});
+export { LoadFolderHierarchyFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/folders/loadFolderHierarchy/feature.js","sources":["../../../../src/features/folders/loadFolderHierarchy/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { FoldersLoadingRepository } from \"~/features/folders/abstractions.js\";\nimport { LoadFolderHierarchyUseCase as UseCase } from \"./abstractions.js\";\nimport { LoadFolderHierarchyUseCase } from \"./LoadFolderHierarchyUseCase.js\";\nimport { LoadFolderHierarchyRepository } from \"./LoadFolderHierarchyRepository.js\";\nimport { LoadFolderHierarchyGqlGateway } from \"./LoadFolderHierarchyGqlGateway.js\";\nimport { LoadFolderHierarchyUseCaseWithLoading } from \"./LoadFolderHierarchyUseCaseWithLoading.js\";\n\nexport const LoadFolderHierarchyFeature = createFeature({\n    name: \"LoadFolderHierarchy\",\n    register(container) {\n        // Register base use case\n        container.register(LoadFolderHierarchyUseCase);\n\n        // Register repository\n        container.register(LoadFolderHierarchyRepository).inSingletonScope();\n\n        // Register gateway\n        container.register(LoadFolderHierarchyGqlGateway);\n\n        // Register decorator\n        container.registerDecorator(LoadFolderHierarchyUseCaseWithLoading);\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCase),\n            loading: container.resolve(FoldersLoadingRepository)\n        };\n    }\n});\n"],"names":["LoadFolderHierarchyFeature","createFeature","container","LoadFolderHierarchyUseCase","LoadFolderHierarchyRepository","LoadFolderHierarchyGqlGateway","LoadFolderHierarchyUseCaseWithLoading","UseCase","FoldersLoadingRepository"],"mappings":";;;;;;;AAQO,MAAMA,6BAA6BC,cAAc;IACpD,MAAM;IACN,UAASC,SAAS;QAEdA,UAAU,QAAQ,CAACC;QAGnBD,UAAU,QAAQ,CAACE,+BAA+B,gBAAgB;QAGlEF,UAAU,QAAQ,CAACG;QAGnBH,UAAU,iBAAiB,CAACI;IAChC;IACA,SAAQJ,SAAS;QACb,OAAO;YACH,SAASA,UAAU,OAAO,CAACK;YAC3B,SAASL,UAAU,OAAO,CAACM;QAC/B;IACJ;AACJ"}

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

@@ -0,0 +1 @@
+export * from "./useLoadFolderHierarchy.js";

package/features/folders/loadFolderHierarchy/index.js

@@ -0,0 +1 @@
+export * from "./useLoadFolderHierarchy.js";

package/features/folders/loadFolderHierarchy/useLoadFolderHierarchy.d.ts

@@ -0,0 +1,7 @@
+import type { FolderDto } from "../../../domain/folder/FolderDto.js";
+export declare const useLoadFolderHierarchy: () => {
+    folders: FolderDto[];
+    loading: Record<string, boolean>;
+    getIsFolderLoading: (action?: string) => boolean;
+    loadFolderHierarchy: (id: string) => Promise<void>;
+};

package/features/folders/loadFolderHierarchy/useLoadFolderHierarchy.js

@@ -0,0 +1,48 @@
+import { useContainer, useFeature } from "@webiny/app";
+import { useCallback, useEffect, useState } from "react";
+import { autorun } from "mobx";
+import { FolderDtoMapper } from "../../../domain/folder/FolderDtoMapper.js";
+import { FoldersCache } from "../abstractions.js";
+import { LoadingActionsEnum } from "../../../types.js";
+import { LoadFolderHierarchyFeature } from "./feature.js";
+const useLoadFolderHierarchy = ()=>{
+    const container = useContainer();
+    const { useCase, loading } = useFeature(LoadFolderHierarchyFeature);
+    const foldersCache = container.resolve(FoldersCache);
+    const [vm, setVm] = useState({
+        folders: [],
+        loading: {
+            INIT: true
+        }
+    });
+    const loadFolderHierarchy = useCallback((id)=>useCase.execute(id), [
+        useCase
+    ]);
+    const getIsFolderLoading = useCallback((action = LoadingActionsEnum.init)=>loading.isLoading(action), []);
+    useEffect(()=>autorun(()=>{
+            const folders = foldersCache.getItems().map((folder)=>FolderDtoMapper.toDTO(folder));
+            setVm((vm)=>({
+                    ...vm,
+                    folders
+                }));
+        }), [
+        foldersCache
+    ]);
+    useEffect(()=>autorun(()=>{
+            const loadingState = loading.get();
+            setVm((vm)=>({
+                    ...vm,
+                    loading: loadingState
+                }));
+        }), [
+        loading
+    ]);
+    return {
+        ...vm,
+        getIsFolderLoading,
+        loadFolderHierarchy
+    };
+};
+export { useLoadFolderHierarchy };
+
+//# sourceMappingURL=useLoadFolderHierarchy.js.map

package/features/folders/loadFolderHierarchy/useLoadFolderHierarchy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folders/loadFolderHierarchy/useLoadFolderHierarchy.js","sources":["../../../../src/features/folders/loadFolderHierarchy/useLoadFolderHierarchy.ts"],"sourcesContent":["import { useContainer } from \"@webiny/app\";\nimport { useCallback, useEffect, useState } from \"react\";\nimport { autorun } from \"mobx\";\nimport { useFeature } from \"@webiny/app\";\nimport type { FolderDto } from \"~/domain/folder/FolderDto.js\";\nimport { FolderDtoMapper } from \"~/domain/folder/FolderDtoMapper.js\";\nimport { FoldersCache } from \"~/features/folders/abstractions.js\";\nimport { LoadingActionsEnum } from \"~/types.js\";\nimport { LoadFolderHierarchyFeature } from \"./feature.js\";\n\nexport const useLoadFolderHierarchy = () => {\n    const container = useContainer();\n    const { useCase, loading } = useFeature(LoadFolderHierarchyFeature);\n\n    const foldersCache = container.resolve(FoldersCache);\n\n    const [vm, setVm] = useState<{\n        folders: FolderDto[];\n        loading: Record<string, boolean>;\n    }>({\n        folders: [],\n        loading: {\n            INIT: true\n        }\n    });\n\n    const loadFolderHierarchy = useCallback(\n        (id: string) => {\n            return useCase.execute(id);\n        },\n        [useCase]\n    );\n\n    const getIsFolderLoading = useCallback((action = LoadingActionsEnum.init) => {\n        return loading.isLoading(action);\n    }, []);\n\n    useEffect(() => {\n        return autorun(() => {\n            const folders = foldersCache.getItems().map(folder => FolderDtoMapper.toDTO(folder));\n\n            setVm(vm => ({\n                ...vm,\n                folders\n            }));\n        });\n    }, [foldersCache]);\n\n    useEffect(() => {\n        return autorun(() => {\n            const loadingState = loading.get();\n\n            setVm(vm => ({\n                ...vm,\n                loading: loadingState\n            }));\n        });\n    }, [loading]);\n\n    return {\n        ...vm,\n        getIsFolderLoading,\n        loadFolderHierarchy\n    };\n};\n"],"names":["useLoadFolderHierarchy","container","useContainer","useCase","loading","useFeature","LoadFolderHierarchyFeature","foldersCache","FoldersCache","vm","setVm","useState","loadFolderHierarchy","useCallback","id","getIsFolderLoading","action","LoadingActionsEnum","useEffect","autorun","folders","folder","FolderDtoMapper","loadingState"],"mappings":";;;;;;;AAUO,MAAMA,yBAAyB;IAClC,MAAMC,YAAYC;IAClB,MAAM,EAAEC,OAAO,EAAEC,OAAO,EAAE,GAAGC,WAAWC;IAExC,MAAMC,eAAeN,UAAU,OAAO,CAACO;IAEvC,MAAM,CAACC,IAAIC,MAAM,GAAGC,SAGjB;QACC,SAAS,EAAE;QACX,SAAS;YACL,MAAM;QACV;IACJ;IAEA,MAAMC,sBAAsBC,YACxB,CAACC,KACUX,QAAQ,OAAO,CAACW,KAE3B;QAACX;KAAQ;IAGb,MAAMY,qBAAqBF,YAAY,CAACG,SAASC,mBAAmB,IAAI,GAC7Db,QAAQ,SAAS,CAACY,SAC1B,EAAE;IAELE,UAAU,IACCC,QAAQ;YACX,MAAMC,UAAUb,aAAa,QAAQ,GAAG,GAAG,CAACc,CAAAA,SAAUC,gBAAgB,KAAK,CAACD;YAE5EX,MAAMD,CAAAA,KAAO;oBACT,GAAGA,EAAE;oBACLW;gBACJ;QACJ,IACD;QAACb;KAAa;IAEjBW,UAAU,IACCC,QAAQ;YACX,MAAMI,eAAenB,QAAQ,GAAG;YAEhCM,MAAMD,CAAAA,KAAO;oBACT,GAAGA,EAAE;oBACL,SAASc;gBACb;QACJ,IACD;QAACnB;KAAQ;IAEZ,OAAO;QACH,GAAGK,EAAE;QACLM;QACAH;IACJ;AACJ"}