@itwin/presentation-hierarchies 2.0.0-alpha.5 → 2.0.0-alpha.6

package/lib/esm/hierarchies/imodel/IModelHierarchyProvider.d.ts

@@ -37,7 +37,10 @@ interface IModelHierarchyProviderProps {
      * @see `ECClassHierarchyInspector`
      */
     imodelAccess: IModelAccess;
-    /** An event that is raised when iModel data, that may affect the hierarchy, changes. */
+    /**
+     * An event that is raised when iModel data, that may affect the hierarchy, changes. The created provider
+     * subscribes to the event to know that it needs to reload the data, and unsubscribes on disposal.
+     */
     imodelChanged?: Event<() => void>;
     /**
      * A function that returns a hierarchy definition, describing how the hierarchy that the provider should be create. The
@@ -66,15 +69,47 @@ interface IModelHierarchyProviderProps {
     };
 }
 /**
- * Creates an instance of `HierarchyProvider` that creates a hierarchy based on given iModel and
+ * Creates an instance of `HierarchyProvider` that creates a hierarchy based on given the iModel and
  * a hierarchy definition, which defines each hierarchy level through ECSQL queries.
  *
  * @public
  */
-export declare function createIModelHierarchyProvider(props: IModelHierarchyProviderProps): HierarchyProvider & {
-    /** @deprecated in 1.4. Use `[Symbol.dispose]` instead. */
-    dispose: () => void;
-    [Symbol.dispose]: () => void;
-};
+export declare function createIModelHierarchyProvider(props: IModelHierarchyProviderProps): HierarchyProvider & Disposable;
+/**
+ * Props for `createMergedIModelHierarchyProvider`.
+ * @alpha
+ */
+interface MergedIModelHierarchyProviderProps extends Omit<IModelHierarchyProviderProps, "imodelAccess" | "imodelChanged"> {
+    /**
+     * A list of iModels to create merged hierarchy for.
+     *
+     * **Warning:** These **must** all be different versions of the same iModel, ordered from the earliest to the
+     * latest version. Not obeying this rule may result in undefined behavior.
+     */
+    imodels: Array<{
+        /**
+         * An object that provides access to iModel's data and metadata.
+         *
+         * @see `ECSchemaProvider`
+         * @see `LimitingECSqlQueryExecutor`
+         * @see `ECClassHierarchyInspector`
+         */
+        imodelAccess: IModelAccess;
+        /**
+         * An event that is raised when iModel data, that may affect the hierarchy, changes. The created provider
+         * subscribes to the event to know that it needs to reload the data, and unsubscribes on disposal.
+         */
+        imodelChanged?: Event<() => void>;
+    }>;
+}
+/**
+ * Creates an instance of `HierarchyProvider` that creates a hierarchy based on multiple version of **the same** iModel
+ * and a hierarchy definition, which defines each hierarchy level through ECSQL queries.
+ *
+ * **Warning:** This is an experimental API that **should not be used in production**.
+ *
+ * @alpha
+ */
+export declare function createMergedIModelHierarchyProvider(props: MergedIModelHierarchyProviderProps): HierarchyProvider & Disposable;
 export {};
 //# sourceMappingURL=IModelHierarchyProvider.d.ts.map

package/lib/esm/hierarchies/imodel/IModelHierarchyProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IModelHierarchyProvider.d.ts","sourceRoot":"","sources":["../../../../src/hierarchies/imodel/IModelHierarchyProvider.ts"],"names":[],"mappings":"AAKA,OAAO,gCAAgC,CAAC;AAwBxC,OAAO,EAGL,yBAAyB,EACzB,gBAAgB,EAGhB,KAAK,EAIL,wBAAwB,EAEzB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAGlE,OAAO,EAA0B,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAkBpF,OAAO,EAA6B,mBAAmB,EAA4B,MAAM,gCAAgC,CAAC;AAE1H,OAAO,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AAe7E;;;GAGG;AACH,UAAU,uCAAuC;IAC/C;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAED,cAAc;AACd,KAAK,YAAY,GAAG,gBAAgB,GAAG,0BAA0B,GAAG,yBAAyB,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtH;;;GAGG;AACH,UAAU,4BAA4B;IACpC;;;;;;OAMG;IACH,YAAY,EAAE,YAAY,CAAC;IAE3B,wFAAwF;IACxF,aAAa,CAAC,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;IAElC;;;OAGG;IACH,mBAAmB,EAAE,mBAAmB,CAAC;IAEzC,qGAAqG;IACrG,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB,sEAAsE;IACtE,gBAAgB,CAAC,EAAE,OAAO,CAAC,uCAAuC,CAAC,CAAC;IAEpE;;;;OAIG;IACH,SAAS,CAAC,EAAE,wBAAwB,CAAC;IACrC,yCAAyC;IACzC,SAAS,CAAC,EAAE;QACV,2DAA2D;QAC3D,KAAK,EAAE,sBAAsB,EAAE,CAAC;KACjC,CAAC;CACH;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,4BAA4B,GAAG,iBAAiB,GAAG;IACtG,0DAA0D;IAC1D,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CAC9B,CAEA"}
+{"version":3,"file":"IModelHierarchyProvider.d.ts","sourceRoot":"","sources":["../../../../src/hierarchies/imodel/IModelHierarchyProvider.ts"],"names":[],"mappings":"AAKA,OAAO,gCAAgC,CAAC;AA4BxC,OAAO,EAGL,yBAAyB,EACzB,gBAAgB,EAGhB,KAAK,EAIL,wBAAwB,EAEzB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAGlE,OAAO,EAA0B,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAkBpF,OAAO,EAGL,mBAAmB,EAGpB,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AAe7E;;;GAGG;AACH,UAAU,uCAAuC;IAC/C;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAED,cAAc;AACd,KAAK,YAAY,GAAG,gBAAgB,GAAG,0BAA0B,GAAG,yBAAyB,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtH;;;GAGG;AACH,UAAU,4BAA4B;IACpC;;;;;;OAMG;IACH,YAAY,EAAE,YAAY,CAAC;IAE3B;;;OAGG;IACH,aAAa,CAAC,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;IAElC;;;OAGG;IACH,mBAAmB,EAAE,mBAAmB,CAAC;IAEzC,qGAAqG;IACrG,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB,sEAAsE;IACtE,gBAAgB,CAAC,EAAE,OAAO,CAAC,uCAAuC,CAAC,CAAC;IAEpE;;;;OAIG;IACH,SAAS,CAAC,EAAE,wBAAwB,CAAC;IAErC,yCAAyC;IACzC,SAAS,CAAC,EAAE;QACV,2DAA2D;QAC3D,KAAK,EAAE,sBAAsB,EAAE,CAAC;KACjC,CAAC;CACH;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,4BAA4B,GAAG,iBAAiB,GAAG,UAAU,CAGjH;AAED;;;GAGG;AACH,UAAU,kCAAmC,SAAQ,IAAI,CAAC,4BAA4B,EAAE,cAAc,GAAG,eAAe,CAAC;IACvH;;;;;OAKG;IACH,OAAO,EAAE,KAAK,CAAC;QACb;;;;;;WAMG;QACH,YAAY,EAAE,YAAY,CAAC;QAE3B;;;WAGG;QACH,aAAa,CAAC,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;KACnC,CAAC,CAAC;CACJ;AAED;;;;;;;GAOG;AACH,wBAAgB,mCAAmC,CAAC,KAAK,EAAE,kCAAkC,GAAG,iBAAiB,GAAG,UAAU,CAE7H"}

package/lib/esm/hierarchies/imodel/IModelHierarchyProvider.js

@@ -3,9 +3,9 @@
  * See LICENSE.md in the project root for license terms and full copyright notice.
  *--------------------------------------------------------------------------------------------*/
 import "../internal/DisposePolyfill.js";
-import { catchError, concat, defaultIfEmpty, EMPTY, filter, finalize, from, identity, map, merge, mergeAll, mergeMap, of, Subject, take, takeUntil, tap, } from "rxjs";
+import { catchError, concat, defaultIfEmpty, defer, EMPTY, filter, finalize, from, fromEventPattern, identity, map, merge, mergeAll, mergeMap, of, reduce, Subject, take, takeUntil, tap, } from "rxjs";
 import { assert, BeEvent, Guid, StopWatch } from "@itwin/core-bentley";
-import { createDefaultValueFormatter, formatConcatenatedValue, normalizeFullClassName, } from "@itwin/presentation-shared";
+import { createDefaultValueFormatter, formatConcatenatedValue, InstanceKey, normalizeFullClassName, } from "@itwin/presentation-shared";
 import { RowsLimitExceededError } from "../HierarchyErrors.js";
 import { HierarchyNode } from "../HierarchyNode.js";
 import { HierarchyNodeKey } from "../HierarchyNodeKey.js";
@@ -20,7 +20,7 @@ import { getRxjsHierarchyDefinition } from "../internal/RxjsHierarchyDefinition.
 import { SubscriptionScheduler } from "../internal/SubscriptionScheduler.js";
 import { FilteringHierarchyDefinition } from "./FilteringHierarchyDefinition.js";
 import { HierarchyCache } from "./HierarchyCache.js";
-import { HierarchyNodesDefinition } from "./IModelHierarchyDefinition.js";
+import { HierarchyNodesDefinition, } from "./IModelHierarchyDefinition.js";
 import { NodeSelectClauseColumnNames } from "./NodeSelectQueryFactory.js";
 import { createDetermineChildrenOperator } from "./operators/DetermineChildren.js";
 import { createGroupingOperator } from "./operators/Grouping.js";
@@ -33,36 +33,56 @@ const LOGGING_NAMESPACE_PERFORMANCE = `${BASE_LOGGING_NAMESPACE_PERFORMANCE}.IMo
 const DEFAULT_QUERY_CONCURRENCY = 10;
 const DEFAULT_QUERY_CACHE_SIZE = 1;
 /**
- * Creates an instance of `HierarchyProvider` that creates a hierarchy based on given iModel and
+ * Creates an instance of `HierarchyProvider` that creates a hierarchy based on given the iModel and
  * a hierarchy definition, which defines each hierarchy level through ECSQL queries.
  *
  * @public
  */
 export function createIModelHierarchyProvider(props) {
+    const { imodelAccess, imodelChanged, ...restProps } = props;
+    return createMergedIModelHierarchyProvider({ ...restProps, imodels: [{ imodelAccess, imodelChanged }] });
+}
+/**
+ * Creates an instance of `HierarchyProvider` that creates a hierarchy based on multiple version of **the same** iModel
+ * and a hierarchy definition, which defines each hierarchy level through ECSQL queries.
+ *
+ * **Warning:** This is an experimental API that **should not be used in production**.
+ *
+ * @alpha
+ */
+export function createMergedIModelHierarchyProvider(props) {
     return new IModelHierarchyProviderImpl(props);
 }
 class IModelHierarchyProviderImpl {
-    _imodelAccess;
+    _imodels;
     _hierarchyChanged;
     _valuesFormatter;
     _sourceHierarchyDefinition;
     _activeHierarchyDefinition;
     _localizedStrings;
-    _queryScheduler;
+    _queryConcurrency;
+    _querySchedulers;
     _nodesCache;
     _unsubscribe;
     _dispose = new Subject();
     #componentId;
     #componentName;
+    #sourceName;
     constructor(props) {
+        if (props.imodels.length === 0) {
+            throw new Error(`Creating an iModel hierarchy provider requires at least one iModel.`);
+        }
         this.#componentId = Guid.createValue();
         this.#componentName = "IModelHierarchyProviderImpl";
-        this._imodelAccess = props.imodelAccess;
+        /* c8 ignore next */
+        this.#sourceName = props.sourceName ?? `${this.#componentName}:${this.#componentId}`;
+        this._imodels = props.imodels;
         this._hierarchyChanged = new BeEvent();
         this._activeHierarchyDefinition = this._sourceHierarchyDefinition = getRxjsHierarchyDefinition(props.hierarchyDefinition);
         this._valuesFormatter = props?.formatter ?? createDefaultValueFormatter();
         this._localizedStrings = { other: "Other", unspecified: "Not specified", ...props?.localizedStrings };
-        this._queryScheduler = new SubscriptionScheduler(props.queryConcurrency ?? DEFAULT_QUERY_CONCURRENCY);
+        this._queryConcurrency = props.queryConcurrency ?? DEFAULT_QUERY_CONCURRENCY;
+        this._querySchedulers = new Map();
         this.setHierarchyFilter(props.filtering);
         const queryCacheSize = props.queryCacheSize ?? DEFAULT_QUERY_CACHE_SIZE;
         if (queryCacheSize !== 0) {
@@ -72,11 +92,18 @@ class IModelHierarchyProviderImpl {
                 variationsCount: 1,
             });
         }
-        this._unsubscribe = props.imodelChanged?.addListener(() => {
-            this.invalidateHierarchyCache("Data source changed");
+        const imodelChangeSubscription = from(this._imodels)
+            .pipe(mergeMap(({ imodelAccess, imodelChanged }) => imodelChanged
+            ? fromEventPattern((handler) => imodelChanged.addListener(handler), (handler) => imodelChanged.removeListener(handler), () => imodelAccess)
+            : EMPTY))
+            .subscribe(({ imodelKey }) => {
+            this.invalidateHierarchyCache(`Data source changed: "${imodelKey}"`);
             this._dispose.next();
             this._hierarchyChanged.raiseEvent();
         });
+        this._unsubscribe = () => {
+            imodelChangeSubscription.unsubscribe();
+        };
     }
     [Symbol.dispose]() {
         this._dispose.next();
@@ -89,6 +116,17 @@ class IModelHierarchyProviderImpl {
     get hierarchyChanged() {
         return this._hierarchyChanged;
     }
+    getQueryScheduler(imodelKey) {
+        let scheduler = this._querySchedulers.get(imodelKey);
+        if (!scheduler) {
+            scheduler = new SubscriptionScheduler(this._queryConcurrency);
+            this._querySchedulers.set(imodelKey, scheduler);
+        }
+        return scheduler;
+    }
+    getPrimaryIModelAccess() {
+        return this._imodels[this._imodels.length - 1].imodelAccess;
+    }
     invalidateHierarchyCache(reason) {
         doLog({
             category: `${LOGGING_NAMESPACE}.Events`,
@@ -114,8 +152,9 @@ class IModelHierarchyProviderImpl {
             return;
         }
         this._activeHierarchyDefinition = new FilteringHierarchyDefinition({
-            imodelAccess: this._imodelAccess,
+            imodelAccess: this.getPrimaryIModelAccess(),
             source: this._sourceHierarchyDefinition,
+            sourceName: this.#sourceName,
             nodeIdentifierPaths: props.paths,
         });
         this.invalidateHierarchyCache("Hierarchy filter set");
@@ -131,44 +170,51 @@ class IModelHierarchyProviderImpl {
             category: LOGGING_NAMESPACE_PERFORMANCE,
             message: /* c8 ignore next */ () => `[${requestContext.requestId}] Requesting hierarchy level definitions for ${createNodeIdentifierForLogging(props.parentNode)}`,
         });
-        let parentNode = props.parentNode;
-        if (parentNode && HierarchyNode.isGeneric(parentNode) && parentNode.key.source && parentNode.key.source !== this._imodelAccess.imodelKey) {
-            return EMPTY;
-        }
-        if (parentNode && HierarchyNode.isInstancesNode(parentNode)) {
-            parentNode = {
-                ...parentNode,
-                key: {
-                    ...parentNode.key,
-                    instanceKeys: parentNode.key.instanceKeys.filter((ik) => !ik.imodelKey || ik.imodelKey === this._imodelAccess.imodelKey),
-                },
-            };
-            assert(HierarchyNodeKey.isInstances(parentNode.key));
-            if (parentNode.key.instanceKeys.length === 0) {
+        return from(this._imodels).pipe(mergeMap(({ imodelAccess }, imodelAccessIndex) => {
+            let parentNode = props.parentNode;
+            if (parentNode && HierarchyNode.isGeneric(parentNode) && parentNode.key.source && parentNode.key.source !== this.#sourceName) {
                 return EMPTY;
             }
-        }
-        return this._activeHierarchyDefinition.defineHierarchyLevel({ ...defineHierarchyLevelProps, parentNode }).pipe(mergeAll(), finalize(() => doLog({
+            if (parentNode && HierarchyNode.isInstancesNode(parentNode)) {
+                parentNode = {
+                    ...parentNode,
+                    key: {
+                        ...parentNode.key,
+                        instanceKeys: parentNode.key.instanceKeys.filter((ik) => !ik.imodelKey || ik.imodelKey === imodelAccess.imodelKey),
+                    },
+                };
+                assert(HierarchyNodeKey.isInstances(parentNode.key));
+                if (parentNode.key.instanceKeys.length === 0) {
+                    return EMPTY;
+                }
+            }
+            return this._activeHierarchyDefinition.defineHierarchyLevel({ ...defineHierarchyLevelProps, parentNode }).pipe(mergeAll(), map(
+            /* Using `as` to work around TS not understanding that `{ x: A, y: B | C }` is the same as `{ x: A } & ({ y: B } | { y: C })` */
+            (hierarchyNodesDefinition) => ({ imodelAccess, imodelAccessIndex, hierarchyNodesDefinition })));
+        }), finalize(() => doLog({
             category: LOGGING_NAMESPACE_PERFORMANCE,
             message: /* c8 ignore next */ () => `[${requestContext.requestId}] Received all hierarchy level definitions for ${createNodeIdentifierForLogging(props.parentNode)}`,
         })));
     }
     createSourceNodesObservable(props) {
         // pipe definitions to nodes and put "share replay" on it
-        return this.createHierarchyLevelDefinitionsObservable(props).pipe(mergeMap((def) => {
+        return this.createHierarchyLevelDefinitionsObservable(props).pipe(mergeMap(({ imodelAccess, imodelAccessIndex, hierarchyNodesDefinition: def }) => defer(() => {
             if (HierarchyNodesDefinition.isGenericNode(def)) {
-                return of({ ...def.node, key: { type: "generic", id: def.node.key, source: this._imodelAccess.imodelKey } });
+                return of({
+                    ...def.node,
+                    key: { type: "generic", id: def.node.key, source: this.#sourceName },
+                });
             }
-            return this._queryScheduler.scheduleSubscription(of(def.query).pipe(map((query) => filterQueryByInstanceKeys(query, props.filteredInstanceKeys)), mergeMap((query) => readNodes({
-                queryExecutor: this._imodelAccess,
+            return this.getQueryScheduler(imodelAccess.imodelKey).scheduleSubscription(of(def.query).pipe(map((query) => filterQueryByInstanceKeys(query, props.filteredInstanceKeys)), mergeMap((query) => readNodes({
+                queryExecutor: imodelAccess,
                 query,
                 limit: props.hierarchyLevelSizeLimit,
                 parser: this._activeHierarchyDefinition.parseNode ? (row) => this._activeHierarchyDefinition.parseNode(row, props.parentNode) : undefined,
             })), map((node) => ({
                 ...node,
-                key: { ...node.key, instanceKeys: node.key.instanceKeys.map((key) => ({ ...key, imodelKey: this._imodelAccess.imodelKey })) },
+                key: { ...node.key, instanceKeys: node.key.instanceKeys.map((key) => ({ ...key, imodelKey: imodelAccess.imodelKey })) },
             }))));
-        }), finalize(() => doLog({
+        }).pipe(map((node) => ({ imodelAccess, imodelAccessIndex, node })))), mergeNodes, map(({ node }) => node), finalize(() => doLog({
             category: LOGGING_NAMESPACE_PERFORMANCE,
             message: /* c8 ignore next */ () => `[${props.requestContext.requestId}] Read all child nodes ${createNodeIdentifierForLogging(props.parentNode)}`,
         })), shareReplayWithErrors());
@@ -182,6 +228,7 @@ class IModelHierarchyProviderImpl {
         // format `ConcatenatedValue` labels into string labels
         mergeMap((node) => applyLabelsFormatting(node, this._valuesFormatter)), 
         // we have `ProcessedHierarchyNode` from here
+        // let consumers step-in
         preProcessNodes(this._activeHierarchyDefinition), 
         // process hiding
         createHideIfNoChildrenOperator((n) => this.getChildNodesObservables({ parentNode: n, requestContext: props.requestContext }).hasNodes), createHideNodesInHierarchyOperator(
@@ -192,7 +239,7 @@ class IModelHierarchyProviderImpl {
         })));
     }
     createProcessedNodesObservable(preprocessedNodesObservable, props) {
-        return preprocessedNodesObservable.pipe(createGroupingOperator(this._imodelAccess, props.parentNode, this._valuesFormatter, this._localizedStrings, undefined, (gn) => this.onGroupingNodeCreated(gn, props)), finalize(() => doLog({
+        return preprocessedNodesObservable.pipe(createGroupingOperator(this.getPrimaryIModelAccess(), props.parentNode, this._valuesFormatter, this._localizedStrings, undefined, (gn) => this.onGroupingNodeCreated(gn, props)), finalize(() => doLog({
             category: LOGGING_NAMESPACE_PERFORMANCE,
             message: /* c8 ignore next */ () => `[${props.requestContext.requestId}] Finished grouping child nodes for ${createNodeIdentifierForLogging(props.parentNode)}`,
         })));
@@ -202,9 +249,7 @@ class IModelHierarchyProviderImpl {
             if ("processingParams" in n) {
                 delete n.processingParams;
             }
-            return Object.assign(n, {
-                children: hasChildren(n),
-            });
+            return { ...n, children: hasChildren(n) };
         }), takeUntil(this._dispose), finalize(() => doLog({
             category: LOGGING_NAMESPACE_PERFORMANCE,
             message: /* c8 ignore next */ () => `[${props.requestContext.requestId}] Finished finalizing child nodes for ${createNodeIdentifierForLogging(props.parentNode)}`,
@@ -319,11 +364,11 @@ class IModelHierarchyProviderImpl {
             return from(parentNode.groupedInstanceKeys);
         }
         assert(!parentNode || HierarchyNode.isGeneric(parentNode) || HierarchyNode.isInstancesNode(parentNode));
-        const hierarchyLevelDefinitions = this.createHierarchyLevelDefinitionsObservable({ parentNode, instanceFilter, requestContext });
         // split the definitions based on whether they're for generic nodes or for instance nodes
-        const [genericDefs, instanceDefs] = partition(hierarchyLevelDefinitions, HierarchyNodesDefinition.isGenericNode);
+        const hierarchyLevelDefinitions = this.createHierarchyLevelDefinitionsObservable({ parentNode, instanceFilter, requestContext });
+        const [instanceDefs, genericDefs] = partition(hierarchyLevelDefinitions, (x) => HierarchyNodesDefinition.isInstanceNodesQuery(x.hierarchyNodesDefinition));
         // query instance keys and a flag whether they should be hidden
-        const instanceKeys = instanceDefs.pipe(mergeMap((def) => this._queryScheduler.scheduleSubscription(of(def.query).pipe(mergeMap(async (query) => {
+        const instanceKeys = instanceDefs.pipe(mergeMap(({ imodelAccess, hierarchyNodesDefinition: def }) => this.getQueryScheduler(imodelAccess.imodelKey).scheduleSubscription(of(def.query).pipe(mergeMap(async (query) => {
             const ecsql = `
                 SELECT
                   ${NodeSelectClauseColumnNames.FullClassName},
@@ -333,7 +378,7 @@ class IModelHierarchyProviderImpl {
                   ${query.ecsql}
                 )
               `;
-            const reader = this._imodelAccess.createQueryReader({ ...query, ecsql }, {
+            const reader = imodelAccess.createQueryReader({ ...query, ecsql }, {
                 rowFormat: "Indexes",
                 limit: hierarchyLevelSizeLimit,
                 restartToken: `${this.#componentName}/${this.#componentId}/node-instance-keys/${Guid.createValue()}`,
@@ -342,7 +387,7 @@ class IModelHierarchyProviderImpl {
                 key: {
                     className: normalizeFullClassName(row[0]),
                     id: row[1],
-                    imodelKey: this._imodelAccess.imodelKey,
+                    imodelKey: imodelAccess.imodelKey,
                 },
                 hide: !!row[2],
             })));
@@ -352,17 +397,17 @@ class IModelHierarchyProviderImpl {
         // hidden items' handling:
         // - if a generic node is hidden, we'll want to retrieve instance keys of its children, otherwise we don't care about it,
         // - if an instance key is hidden, we want to create a merged node similar to what we do in `createHideNodesInHierarchyOperator`
-        const hiddenParentNodes = merge(genericDefs.pipe(filter((def) => !!def.node.processingParams?.hideInHierarchy), map((def) => ({
+        const hiddenParentNodes = merge(genericDefs.pipe(filter(({ hierarchyNodesDefinition }) => !!hierarchyNodesDefinition.node.processingParams?.hideInHierarchy), map(({ hierarchyNodesDefinition }) => ({
             type: "generic",
-            id: def.node.key,
-            source: this._imodelAccess.imodelKey,
+            id: hierarchyNodesDefinition.node.key,
+            source: this.#sourceName,
         }))), hiddenNodeInstanceKeys.pipe(
         // first merge all keys by class
-        reduceToMergeMapList(({ key }) => key.className, ({ key }) => key.id), 
+        reduceToMergeMapList(({ key }) => key.className, ({ key }) => key), 
         // then, for each class, create an instance key
-        mergeMap((mergedMap) => [...mergedMap.entries()].map(([className, ids]) => ({
+        mergeMap((mergedMap) => [...mergedMap.entries()].map(([className, keys]) => ({
             type: "instances",
-            instanceKeys: ids.map((id) => ({ className, id, imodelKey: this._imodelAccess.imodelKey })),
+            instanceKeys: keys.map(({ id, imodelKey }) => ({ className, id, imodelKey })),
         }))))).pipe(map((key) => ({
             key,
             parentKeys: [],
@@ -451,4 +496,49 @@ function filterQueryByInstanceKeys(query, filteredInstanceKeys) {
     };
     /* c8 ignore end */
 }
+function mergeNodes(source) {
+    return from(source).pipe(reduce((acc, input) => {
+        for (let i = 0; i < acc.length; ++i) {
+            if (input.imodelAccess === acc[i].imodelAccess) {
+                // don't attempt to merge nodes if they come from the same provider
+                continue;
+            }
+            // the first argument for `tryMergeNodes` acts as the primary data source, so we have to make sure we pass
+            // the node with higher `imodelAccessIndex` first
+            const candidates = input.imodelAccessIndex > acc[i].imodelAccessIndex
+                ? { imodelAccess: input.imodelAccess, imodelAccessIndex: input.imodelAccessIndex, primary: input.node, secondary: acc[i].node }
+                : { imodelAccess: acc[i].imodelAccess, imodelAccessIndex: acc[i].imodelAccessIndex, primary: acc[i].node, secondary: input.node };
+            const merged = tryMergeNodes(candidates.primary, candidates.secondary);
+            if (merged) {
+                acc[i] = { ...acc[i], node: merged, imodelAccess: candidates.imodelAccess, imodelAccessIndex: candidates.imodelAccessIndex };
+                return acc;
+            }
+        }
+        acc.push(input);
+        return acc;
+    }, new Array()), mergeAll());
+}
+function tryMergeInstanceNodes(primary, secondary) {
+    if (HierarchyNode.isInstancesNode(primary) &&
+        HierarchyNode.isInstancesNode(secondary) &&
+        primary.key.instanceKeys.some((lhsKey) => secondary.key.instanceKeys.some((rhsKey) => InstanceKey.equals(lhsKey, rhsKey)))) {
+        return {
+            ...primary,
+            key: {
+                type: "instances",
+                instanceKeys: primary.key.instanceKeys.concat(secondary.key.instanceKeys),
+            },
+        };
+    }
+    return undefined;
+}
+function tryMergeGenericNodes(primary, secondary) {
+    if (HierarchyNode.isGeneric(primary) && HierarchyNode.isGeneric(secondary) && primary.key.type === secondary.key.type) {
+        return primary;
+    }
+    return undefined;
+}
+function tryMergeNodes(primary, secondary) {
+    return tryMergeInstanceNodes(primary, secondary) ?? tryMergeGenericNodes(primary, secondary) ?? undefined;
+}
 //# sourceMappingURL=IModelHierarchyProvider.js.map