@webiny/app-aco 6.0.0-beta.0 → 6.0.0-rc.1

package/features/folders/listFoldersByParentIds/index.js

@@ -0,0 +1,3 @@
+export * from "./useListFoldersByParentIds.js";
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export * from \"./useListFoldersByParentIds.js\";\n"],"mappings":"AAAA","ignoreList":[]}

package/features/folders/listFoldersByParentIds/useListFoldersByParentIds.d.ts

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

package/features/folders/listFoldersByParentIds/useListFoldersByParentIds.js

@@ -0,0 +1,53 @@
+import { useCallback, useEffect, useState } from "react";
+import { autorun } from "mobx";
+import { useFeature, useContainer } from "@webiny/app";
+import { FolderDtoMapper } from "../../../domain/folder/FolderDtoMapper.js";
+import { FoldersCache } from "../abstractions.js";
+import { ListFoldersByParentIdsFeature } from "./feature.js";
+import { ROOT_FOLDER } from "../../../constants.js";
+export const useListFoldersByParentIds = () => {
+  const container = useContainer();
+  const {
+    useCase,
+    loading: loadingState
+  } = useFeature(ListFoldersByParentIdsFeature);
+  const foldersCache = container.resolve(FoldersCache);
+  const [vm, setVm] = useState({
+    folders: [],
+    loading: []
+  });
+  const listFoldersByParentIds = useCallback(parentIds => {
+    return useCase.execute(parentIds);
+  }, [useCase]);
+  const getIsFolderLoading = useCallback((action = ROOT_FOLDER) => {
+    if (!loadingState) {
+      return true;
+    }
+    return loadingState.isLoading(action);
+  }, [loadingState]);
+  useEffect(() => {
+    return autorun(() => {
+      const folders = foldersCache.getItems().map(folder => FolderDtoMapper.toDTO(folder));
+      setVm(vm => ({
+        ...vm,
+        folders
+      }));
+    });
+  }, [foldersCache]);
+  useEffect(() => {
+    return autorun(() => {
+      const loading = loadingState.getActiveLoadings();
+      setVm(vm => ({
+        ...vm,
+        loading
+      }));
+    });
+  }, [loadingState]);
+  return {
+    ...vm,
+    listFoldersByParentIds,
+    getIsFolderLoading
+  };
+};
+
+//# sourceMappingURL=useListFoldersByParentIds.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["useCallback","useEffect","useState","autorun","useFeature","useContainer","FolderDtoMapper","FoldersCache","ListFoldersByParentIdsFeature","ROOT_FOLDER","useListFoldersByParentIds","container","useCase","loading","loadingState","foldersCache","resolve","vm","setVm","folders","listFoldersByParentIds","parentIds","execute","getIsFolderLoading","action","isLoading","getItems","map","folder","toDTO","getActiveLoadings"],"sources":["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"],"mappings":"AAAA,SAASA,WAAW,EAAEC,SAAS,EAAEC,QAAQ,QAAQ,OAAO;AACxD,SAASC,OAAO,QAAQ,MAAM;AAC9B,SAASC,UAAU,EAAEC,YAAY,QAAQ,aAAa;AAEtD,SAASC,eAAe;AACxB,SAASC,YAAY;AACrB,SAASC,6BAA6B;AACtC,SAASC,WAAW;AAEpB,OAAO,MAAMC,yBAAyB,GAAGA,CAAA,KAAM;EAC3C,MAAMC,SAAS,GAAGN,YAAY,CAAC,CAAC;EAChC,MAAM;IAAEO,OAAO;IAAEC,OAAO,EAAEC;EAAa,CAAC,GAAGV,UAAU,CAACI,6BAA6B,CAAC;EAEpF,MAAMO,YAAY,GAAGJ,SAAS,CAACK,OAAO,CAACT,YAAY,CAAC;EAEpD,MAAM,CAACU,EAAE,EAAEC,KAAK,CAAC,GAAGhB,QAAQ,CAGzB;IACCiB,OAAO,EAAE,EAAE;IACXN,OAAO,EAAE;EACb,CAAC,CAAC;EAEF,MAAMO,sBAAsB,GAAGpB,WAAW,CACrCqB,SAAoB,IAAK;IACtB,OAAOT,OAAO,CAACU,OAAO,CAACD,SAAS,CAAC;EACrC,CAAC,EACD,CAACT,OAAO,CACZ,CAAC;EAED,MAAMW,kBAAkB,GAAGvB,WAAW,CAClC,CAACwB,MAAM,GAAGf,WAAW,KAAK;IACtB,IAAI,CAACK,YAAY,EAAE;MACf,OAAO,IAAI;IACf;IAEA,OAAOA,YAAY,CAACW,SAAS,CAACD,MAAM,CAAC;EACzC,CAAC,EACD,CAACV,YAAY,CACjB,CAAC;EAEDb,SAAS,CAAC,MAAM;IACZ,OAAOE,OAAO,CAAC,MAAM;MACjB,MAAMgB,OAAO,GAAGJ,YAAY,CAACW,QAAQ,CAAC,CAAC,CAACC,GAAG,CAACC,MAAM,IAAItB,eAAe,CAACuB,KAAK,CAACD,MAAM,CAAC,CAAC;MAEpFV,KAAK,CAACD,EAAE,KAAK;QACT,GAAGA,EAAE;QACLE;MACJ,CAAC,CAAC,CAAC;IACP,CAAC,CAAC;EACN,CAAC,EAAE,CAACJ,YAAY,CAAC,CAAC;EAElBd,SAAS,CAAC,MAAM;IACZ,OAAOE,OAAO,CAAC,MAAM;MACjB,MAAMU,OAAO,GAAGC,YAAY,CAACgB,iBAAiB,CAAC,CAAC;MAEhDZ,KAAK,CAACD,EAAE,KAAK;QACT,GAAGA,EAAE;QACLJ;MACJ,CAAC,CAAC,CAAC;IACP,CAAC,CAAC;EACN,CAAC,EAAE,CAACC,YAAY,CAAC,CAAC;EAElB,OAAO;IACH,GAAGG,EAAE;IACLG,sBAAsB;IACtBG;EACJ,CAAC;AACL,CAAC","ignoreList":[]}

package/features/folders/loadFolderHierarchy/LoadFolderHierarchy.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,150 @@
+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 {
+    // Had to use `any` as the mock folders passed in the tests below are also partial objects.
+    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);
+    // We are storing only the parent folders id in the loadedFoldersCache
+    expect(loadedFoldersCache.count()).toEqual(3);
+    expect(loadedFoldersCache.getItems()).toEqual(["folder-1", "folder-2", "folder-3"]);
+
+    // This call should be idempotent: the number of elements in cache should not change
+    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);
+    // We are NOT storing any folder loadedFoldersCache
+    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,"names":["beforeEach","describe","expect","it","vi","Container","ListCache","LoadedCache","FoldersCache","FoldersContext","FoldersLoadingRepository","LoadedFoldersCache","LoadingRepository","LoadFolderHierarchyGateway","LoadFolderHierarchyUseCase","LoadFolderHierarchyFeature","type","setupTest","gateway","container","foldersCache","loadedFoldersCache","registerInstance","register","useCase","resolve","resetAllMocks","GetFolderHierarchyMockGateway","constructor","mockResponse","execute","parents","id","title","slug","parentId","siblings","spy","spyOn","hasItems","toBe","toHaveBeenCalledTimes","toHaveBeenCalledWith","count","toEqual","getItems","GetFolderHierarchyErrorMockGateway","Error","rejects","toThrow"],"sources":["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"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,35 @@
+import { GraphQLClient } from "@webiny/app/features/graphqlClient/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: GraphQLClient.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 { GraphQLClient } from "@webiny/app/features/graphqlClient/index.js";
+import { RootFolder } from "../../../domain/folder/RootFolder.js";
+import { FolderModelProvider } from "../abstractions.js";
+import { LoadFolderHierarchyGateway as GatewayAbstraction } from "./abstractions.js";
+export const LOAD_FOLDER_HIERARCHY = FOLDER_FIELDS => /* GraphQL*/`
+    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
+    };
+  }
+}
+export const LoadFolderHierarchyGqlGateway = GatewayAbstraction.createImplementation({
+  implementation: LoadFolderHierarchyGqlGatewayImpl,
+  dependencies: [GraphQLClient, FolderModelProvider]
+});
+
+//# sourceMappingURL=LoadFolderHierarchyGqlGateway.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["GraphQLClient","RootFolder","FolderModelProvider","LoadFolderHierarchyGateway","GatewayAbstraction","LOAD_FOLDER_HIERARCHY","FOLDER_FIELDS","LoadFolderHierarchyGqlGatewayImpl","constructor","client","folderModelProvider","execute","type","id","fields","getGraphQLSelection","response","query","variables","Error","data","error","aco","getFolderHierarchy","message","parents","create","siblings","LoadFolderHierarchyGqlGateway","createImplementation","implementation","dependencies"],"sources":["LoadFolderHierarchyGqlGateway.ts"],"sourcesContent":["import { GraphQLClient } from \"@webiny/app/features/graphqlClient/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: GraphQLClient.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: [GraphQLClient, FolderModelProvider]\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,6CAA6C;AAE3E,SAASC,UAAU;AACnB,SAASC,mBAAmB;AAC5B,SAASC,0BAA0B,IAAIC,kBAAkB;AAsBzD,OAAO,MAAMC,qBAAqB,GAAIC,aAAqB,IAAK,YAAa;AAC7E;AACA;AACA;AACA;AACA,8BAA8BA,aAAa;AAC3C,+BAA+BA,aAAa;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AAED,MAAMC,iCAAiC,CAAyC;EAC5EC,WAAWA,CACCC,MAA+B,EAC/BC,mBAAkD,EAC5D;IAAA,KAFUD,MAA+B,GAA/BA,MAA+B;IAAA,KAC/BC,mBAAkD,GAAlDA,mBAAkD;EAC3D;EAEH,MAAMC,OAAOA,CAACC,IAAY,EAAEC,EAAU,EAAE;IACpC,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACJ,mBAAmB,CAACK,mBAAmB,CAAC,CAAC;IAEnE,MAAMC,QAAQ,GAAG,MAAM,IAAI,CAACP,MAAM,CAACE,OAAO,CAGxC;MACEM,KAAK,EAAEZ,qBAAqB,CAACS,MAAM,CAAC;MACpCI,SAAS,EAAE;QACPN,IAAI;QACJC;MACJ;IACJ,CAAC,CAAC;IAEF,IAAI,CAACG,QAAQ,EAAE;MACX,MAAM,IAAIG,KAAK,CACX,0EAA0EP,IAAI,IAAIC,EAAE,GACxF,CAAC;IACL;IAEA,MAAM;MAAEO,IAAI;MAAEC;IAAM,CAAC,GAAGL,QAAQ,CAACM,GAAG,CAACC,kBAAkB;IAEvD,IAAI,CAACH,IAAI,EAAE;MACP,MAAM,IAAID,KAAK,CACXE,KAAK,EAAEG,OAAO,IACV,6DAA6DZ,IAAI,IAAIC,EAAE,GAC/E,CAAC;IACL;IAEA,OAAO;MACHY,OAAO,EAAE,CAACxB,UAAU,CAACyB,MAAM,CAAC,CAAC,EAAE,GAAGN,IAAI,CAACK,OAAO,CAAC;MAC/CE,QAAQ,EAAEP,IAAI,CAACO;IACnB,CAAC;EACL;AACJ;AAEA,OAAO,MAAMC,6BAA6B,GAAGxB,kBAAkB,CAACyB,oBAAoB,CAAC;EACjFC,cAAc,EAAEvB,iCAAiC;EACjDwB,YAAY,EAAE,CAAC/B,aAAa,EAAEE,mBAAmB;AACrD,CAAC,CAAC","ignoreList":[]}

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,49 @@
+import { Folder } from "../../../domain/folder/Folder.js";
+import { LoadFolderHierarchyRepository as RepositoryAbstraction, LoadFolderHierarchyGateway } from "./abstractions.js";
+import { FoldersCache, LoadedFoldersCache, FoldersContext } from "../abstractions.js";
+class LoadFolderHierarchyRepositoryImpl {
+  pendingPromises = new Map();
+  constructor(cache, loadedCache, gateway, foldersContext) {
+    this.cache = cache;
+    this.loadedCache = loadedCache;
+    this.gateway = gateway;
+    this.foldersContext = foldersContext;
+  }
+  async execute(id) {
+    // Return pending promise if one exists
+    const pendingPromise = this.pendingPromises.get(id);
+    if (pendingPromise) {
+      return pendingPromise;
+    }
+
+    // Create new promise with cleanup and cache it
+    const promise = this.loadFolders(id).finally(() => {
+      this.pendingPromises.delete(id);
+    });
+
+    // Store the promise
+    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)));
+  }
+}
+export const LoadFolderHierarchyRepository = RepositoryAbstraction.createImplementation({
+  implementation: LoadFolderHierarchyRepositoryImpl,
+  dependencies: [FoldersCache, LoadedFoldersCache, LoadFolderHierarchyGateway, FoldersContext]
+});
+
+//# sourceMappingURL=LoadFolderHierarchyRepository.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["Folder","LoadFolderHierarchyRepository","RepositoryAbstraction","LoadFolderHierarchyGateway","FoldersCache","LoadedFoldersCache","FoldersContext","LoadFolderHierarchyRepositoryImpl","pendingPromises","Map","constructor","cache","loadedCache","gateway","foldersContext","execute","id","pendingPromise","get","promise","loadFolders","finally","delete","set","existingCache","getItem","item","response","type","parents","siblings","length","addItems","map","parent","create","createImplementation","implementation","dependencies"],"sources":["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"],"mappings":"AAAA,SAASA,MAAM;AACf,SACIC,6BAA6B,IAAIC,qBAAqB,EACtDC,0BAA0B;AAE9B,SACIC,YAAY,EACZC,kBAAkB,EAClBC,cAAc;AAGlB,MAAMC,iCAAiC,CAA4C;EACvEC,eAAe,GAAG,IAAIC,GAAG,CAAwB,CAAC;EAE1DC,WAAWA,CACCC,KAA6B,EAC7BC,WAAyC,EACzCC,OAA6C,EAC7CC,cAAwC,EAClD;IAAA,KAJUH,KAA6B,GAA7BA,KAA6B;IAAA,KAC7BC,WAAyC,GAAzCA,WAAyC;IAAA,KACzCC,OAA6C,GAA7CA,OAA6C;IAAA,KAC7CC,cAAwC,GAAxCA,cAAwC;EACjD;EAEH,MAAMC,OAAOA,CAACC,EAAU,EAAE;IACtB;IACA,MAAMC,cAAc,GAAG,IAAI,CAACT,eAAe,CAACU,GAAG,CAACF,EAAE,CAAC;IACnD,IAAIC,cAAc,EAAE;MAChB,OAAOA,cAAc;IACzB;;IAEA;IACA,MAAME,OAAO,GAAG,IAAI,CAACC,WAAW,CAACJ,EAAE,CAAC,CAACK,OAAO,CAAC,MAAM;MAC/C,IAAI,CAACb,eAAe,CAACc,MAAM,CAACN,EAAE,CAAC;IACnC,CAAC,CAAC;;IAEF;IACA,IAAI,CAACR,eAAe,CAACe,GAAG,CAACP,EAAE,EAAEG,OAAO,CAAC;IAErC,OAAOA,OAAO;EAClB;EAEA,MAAcC,WAAWA,CAACJ,EAAU,EAAE;IAClC,MAAMQ,aAAa,GAAG,IAAI,CAACZ,WAAW,CAACa,OAAO,CAACC,IAAI,IAAIA,IAAI,KAAKV,EAAE,CAAC;IACnE,IAAIQ,aAAa,EAAE;MACf;IACJ;IAEA,MAAMG,QAAQ,GAAG,MAAM,IAAI,CAACd,OAAO,CAACE,OAAO,CAAC,IAAI,CAACD,cAAc,CAACc,IAAI,EAAEZ,EAAE,CAAC;IAEzE,MAAM;MAAEa,OAAO,GAAG,EAAE;MAAEC,QAAQ,GAAG;IAAG,CAAC,GAAGH,QAAQ;IAEhD,IAAIE,OAAO,CAACE,MAAM,GAAG,CAAC,EAAE;MACpB,IAAI,CAACnB,WAAW,CAACoB,QAAQ,CAACH,OAAO,CAACI,GAAG,CAACC,MAAM,IAAIA,MAAM,CAAClB,EAAE,CAAC,CAAC;IAC/D;IAEA,IAAI,CAACL,KAAK,CAACqB,QAAQ,CAAC,CAAC,GAAGH,OAAO,EAAE,GAAGC,QAAQ,CAAC,CAACG,GAAG,CAACP,IAAI,IAAI1B,MAAM,CAACmC,MAAM,CAACT,IAAI,CAAC,CAAC,CAAC;EACnF;AACJ;AAEA,OAAO,MAAMzB,6BAA6B,GAAGC,qBAAqB,CAACkC,oBAAoB,CAAC;EACpFC,cAAc,EAAE9B,iCAAiC;EACjD+B,YAAY,EAAE,CAAClC,YAAY,EAAEC,kBAAkB,EAAEF,0BAA0B,EAAEG,cAAc;AAC/F,CAAC,CAAC","ignoreList":[]}

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,15 @@
+import { LoadFolderHierarchyUseCase as UseCaseAbstraction, LoadFolderHierarchyRepository } from "./abstractions.js";
+class LoadFolderHierarchyUseCaseImpl {
+  constructor(repository) {
+    this.repository = repository;
+  }
+  async execute(id) {
+    await this.repository.execute(id);
+  }
+}
+export const LoadFolderHierarchyUseCase = UseCaseAbstraction.createImplementation({
+  implementation: LoadFolderHierarchyUseCaseImpl,
+  dependencies: [LoadFolderHierarchyRepository]
+});
+
+//# sourceMappingURL=LoadFolderHierarchyUseCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["LoadFolderHierarchyUseCase","UseCaseAbstraction","LoadFolderHierarchyRepository","LoadFolderHierarchyUseCaseImpl","constructor","repository","execute","id","createImplementation","implementation","dependencies"],"sources":["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"],"mappings":"AAAA,SACIA,0BAA0B,IAAIC,kBAAkB,EAChDC,6BAA6B;AAGjC,MAAMC,8BAA8B,CAAyC;EACzEC,WAAWA,CAASC,UAAmD,EAAE;IAAA,KAArDA,UAAmD,GAAnDA,UAAmD;EAAG;EAE1E,MAAMC,OAAOA,CAACC,EAAU,EAAE;IACtB,MAAM,IAAI,CAACF,UAAU,CAACC,OAAO,CAACC,EAAE,CAAC;EACrC;AACJ;AAEA,OAAO,MAAMP,0BAA0B,GAAGC,kBAAkB,CAACO,oBAAoB,CAAC;EAC9EC,cAAc,EAAEN,8BAA8B;EAC9CO,YAAY,EAAE,CAACR,6BAA6B;AAChD,CAAC,CAAC","ignoreList":[]}

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,18 @@
+import { FoldersLoadingRepository } from "../abstractions.js";
+import { LoadFolderHierarchyUseCase as UseCaseAbstraction } 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);
+  }
+}
+export const LoadFolderHierarchyUseCaseWithLoading = UseCaseAbstraction.createDecorator({
+  decorator: LoadFolderHierarchyUseCaseWithLoadingImpl,
+  dependencies: [FoldersLoadingRepository]
+});
+
+//# sourceMappingURL=LoadFolderHierarchyUseCaseWithLoading.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["FoldersLoadingRepository","LoadFolderHierarchyUseCase","UseCaseAbstraction","LoadingActionsEnum","LoadFolderHierarchyUseCaseWithLoadingImpl","constructor","loadingRepository","decoratee","execute","id","runCallBack","init","LoadFolderHierarchyUseCaseWithLoading","createDecorator","decorator","dependencies"],"sources":["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"],"mappings":"AAAA,SAASA,wBAAwB;AACjC,SAASC,0BAA0B,IAAIC,kBAAkB;AACzD,SAASC,kBAAkB;AAE3B,MAAMC,yCAAyC,CAAyC;EACpFC,WAAWA,CACCC,iBAAqD,EACrDC,SAAuC,EACjD;IAAA,KAFUD,iBAAqD,GAArDA,iBAAqD;IAAA,KACrDC,SAAuC,GAAvCA,SAAuC;EAChD;EAEH,MAAMC,OAAOA,CAACC,EAAU,EAAE;IACtB,MAAM,IAAI,CAACH,iBAAiB,CAACI,WAAW,CACpC,IAAI,CAACH,SAAS,CAACC,OAAO,CAACC,EAAE,CAAC,EAC1BN,kBAAkB,CAACQ,IACvB,CAAC;EACL;AACJ;AAEA,OAAO,MAAMC,qCAAqC,GAAGV,kBAAkB,CAACW,eAAe,CAAC;EACpFC,SAAS,EAAEV,yCAAyC;EACpDW,YAAY,EAAE,CAACf,wBAAwB;AAC3C,CAAC,CAAC","ignoreList":[]}

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,6 @@
+import { createAbstraction } from "@webiny/feature/admin";
+export const LoadFolderHierarchyUseCase = createAbstraction("LoadFolderHierarchyUseCase");
+export const LoadFolderHierarchyRepository = createAbstraction("LoadFolderHierarchyRepository");
+export const LoadFolderHierarchyGateway = createAbstraction("LoadFolderHierarchyGateway");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","LoadFolderHierarchyUseCase","LoadFolderHierarchyRepository","LoadFolderHierarchyGateway"],"sources":["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"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,uBAAuB;AAoBzD,OAAO,MAAMC,0BAA0B,GAAGD,iBAAiB,CACvD,4BACJ,CAAC;AAMD,OAAO,MAAME,6BAA6B,GAAGF,iBAAiB,CAC1D,+BACJ,CAAC;AAMD,OAAO,MAAMG,0BAA0B,GAAGH,iBAAiB,CACvD,4BACJ,CAAC","ignoreList":[]}

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,31 @@
+import { createFeature } from "@webiny/feature/admin";
+import { FoldersLoadingRepository } from "../abstractions.js";
+import { LoadFolderHierarchyUseCase as UseCase } from "./abstractions.js";
+import { LoadFolderHierarchyUseCase } from "./LoadFolderHierarchyUseCase.js";
+import { LoadFolderHierarchyRepository } from "./LoadFolderHierarchyRepository.js";
+import { LoadFolderHierarchyGqlGateway } from "./LoadFolderHierarchyGqlGateway.js";
+import { LoadFolderHierarchyUseCaseWithLoading } from "./LoadFolderHierarchyUseCaseWithLoading.js";
+export const LoadFolderHierarchyFeature = createFeature({
+  name: "LoadFolderHierarchy",
+  register(container) {
+    // Register base use case
+    container.register(LoadFolderHierarchyUseCase);
+
+    // Register repository
+    container.register(LoadFolderHierarchyRepository).inSingletonScope();
+
+    // Register gateway
+    container.register(LoadFolderHierarchyGqlGateway);
+
+    // Register decorator
+    container.registerDecorator(LoadFolderHierarchyUseCaseWithLoading);
+  },
+  resolve(container) {
+    return {
+      useCase: container.resolve(UseCase),
+      loading: container.resolve(FoldersLoadingRepository)
+    };
+  }
+});
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","FoldersLoadingRepository","LoadFolderHierarchyUseCase","UseCase","LoadFolderHierarchyRepository","LoadFolderHierarchyGqlGateway","LoadFolderHierarchyUseCaseWithLoading","LoadFolderHierarchyFeature","name","register","container","inSingletonScope","registerDecorator","resolve","useCase","loading"],"sources":["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"],"mappings":"AAAA,SAASA,aAAa,QAAQ,uBAAuB;AACrD,SAASC,wBAAwB;AACjC,SAASC,0BAA0B,IAAIC,OAAO;AAC9C,SAASD,0BAA0B;AACnC,SAASE,6BAA6B;AACtC,SAASC,6BAA6B;AACtC,SAASC,qCAAqC;AAE9C,OAAO,MAAMC,0BAA0B,GAAGP,aAAa,CAAC;EACpDQ,IAAI,EAAE,qBAAqB;EAC3BC,QAAQA,CAACC,SAAS,EAAE;IAChB;IACAA,SAAS,CAACD,QAAQ,CAACP,0BAA0B,CAAC;;IAE9C;IACAQ,SAAS,CAACD,QAAQ,CAACL,6BAA6B,CAAC,CAACO,gBAAgB,CAAC,CAAC;;IAEpE;IACAD,SAAS,CAACD,QAAQ,CAACJ,6BAA6B,CAAC;;IAEjD;IACAK,SAAS,CAACE,iBAAiB,CAACN,qCAAqC,CAAC;EACtE,CAAC;EACDO,OAAOA,CAACH,SAAS,EAAE;IACf,OAAO;MACHI,OAAO,EAAEJ,SAAS,CAACG,OAAO,CAACV,OAAO,CAAC;MACnCY,OAAO,EAAEL,SAAS,CAACG,OAAO,CAACZ,wBAAwB;IACvD,CAAC;EACL;AACJ,CAAC,CAAC","ignoreList":[]}

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

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

package/features/folders/loadFolderHierarchy/index.js

@@ -0,0 +1,3 @@
+export * from "./useLoadFolderHierarchy.js";
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export * from \"./useLoadFolderHierarchy.js\";\n"],"mappings":"AAAA","ignoreList":[]}

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

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