feat(react-components): CoreDM queries

react-components/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cognite/reveal-react-components",
-  "version": "0.55.10",
+  "version": "0.56.0",
   "exports": {
     ".": {
       "import": "./dist/index.js",

react-components/src/architecture/concrete/observations/network.ts

@@ -5,18 +5,15 @@ import { chunk } from 'lodash';
 import {
   type CreateInstanceItem,
   type DmsUniqueIdentifier,
-  type FdmSDK,
-  type InstanceFilter
+  type FdmSDK
 } from '../../../data-providers/FdmSDK';
 import { type ObservationFdmNode, OBSERVATION_SOURCE, type ObservationProperties } from './models';
 
 import { v4 as uuid } from 'uuid';
 
 export async function fetchObservations(fdmSdk: FdmSDK): Promise<ObservationFdmNode[]> {
-  const observationsFilter: InstanceFilter = {};
-
   const observationResult = await fdmSdk.filterAllInstances<ObservationProperties>(
-    observationsFilter,
+    undefined,
     'node',
     OBSERVATION_SOURCE
   );

react-components/src/components/CacheProvider/AssetMappingAndNode3DCache.ts

@@ -9,7 +9,7 @@ import {
   type CogniteInternalId
 } from '@cognite/sdk';
 import {
-  type ModelNodeIdKey,
+  type ModelTreeIndexKey,
   type AssetId,
   type ModelId,
   type RevisionId,
@@ -195,7 +195,7 @@ export class AssetMappingAndNode3DCache {
 
   private async getItemCacheResult(
     type: string,
-    key: ModelNodeIdKey | ModelAssetIdKey
+    key: ModelTreeIndexKey | ModelAssetIdKey
   ): Promise<AssetMapping[] | undefined> {
     return type === 'nodeIds'
       ? await this.nodeIdsToAssetMappingCache.getNodeIdsToAssetMappingCacheItem(key)
@@ -204,7 +204,7 @@ export class AssetMappingAndNode3DCache {
 
   private setItemCacheResult(
     type: string,
-    key: ModelNodeIdKey | ModelAssetIdKey,
+    key: ModelTreeIndexKey | ModelAssetIdKey,
     item: AssetMapping[] | undefined
   ): void {
     const value = Promise.resolve(item ?? []);
@@ -238,7 +238,7 @@ export class AssetMappingAndNode3DCache {
       const keyAssetId: ModelAssetIdKey = modelRevisionNodesAssetsToKey(modelId, revisionId, [
         item.assetId
       ]);
-      const keyNodeId: ModelNodeIdKey = modelRevisionNodesAssetsToKey(modelId, revisionId, [
+      const keyNodeId: ModelTreeIndexKey = modelRevisionNodesAssetsToKey(modelId, revisionId, [
         item.nodeId
       ]);
       await this.assetIdsToAssetMappingCache.setAssetMappingsCacheItem(keyAssetId, item);

react-components/src/components/CacheProvider/AssetMappingPerNodeIdCache.ts

@@ -2,26 +2,29 @@
  * Copyright 2024 Cognite AS
  */
 import { type AssetMapping3D } from '@cognite/sdk/dist/src';
-import { type ModelNodeIdKey } from './types';
+import { type ModelTreeIndexKey } from './types';
 import { type AssetMapping } from './AssetMappingAndNode3DCache';
 
 export class AssetMappingPerNodeIdCache {
-  private readonly _nodeIdsToAssetMappings = new Map<ModelNodeIdKey, Promise<AssetMapping[]>>();
+  private readonly _nodeIdsToAssetMappings = new Map<ModelTreeIndexKey, Promise<AssetMapping[]>>();
 
   public setNodeIdsToAssetMappingCacheItem(
-    key: ModelNodeIdKey,
+    key: ModelTreeIndexKey,
     item: Promise<Array<Required<AssetMapping3D>>>
   ): void {
     this._nodeIdsToAssetMappings.set(key, Promise.resolve(item));
   }
 
   public async getNodeIdsToAssetMappingCacheItem(
-    key: ModelNodeIdKey
+    key: ModelTreeIndexKey
   ): Promise<AssetMapping[] | undefined> {
     return await this._nodeIdsToAssetMappings.get(key);
   }
 
-  public async setAssetMappingsCacheItem(key: ModelNodeIdKey, item: AssetMapping): Promise<void> {
+  public async setAssetMappingsCacheItem(
+    key: ModelTreeIndexKey,
+    item: AssetMapping
+  ): Promise<void> {
     const currentAssetMappings = this.getNodeIdsToAssetMappingCacheItem(key);
     this.setNodeIdsToAssetMappingCacheItem(
       key,

react-components/src/components/CacheProvider/FdmNodeCache.ts

@@ -10,25 +10,25 @@ import {
   type FdmCadConnection,
   type ModelRevisionKey,
   type RevisionId,
-  type NodeId,
-  type ModelNodeIdKey,
+  type ModelTreeIndexKey,
   type ModelRevisionToConnectionMap,
   type ModelRevisionId,
   type FdmKey,
-  type FdmNodeDataPromises
+  type FdmNodeDataPromises,
+  type TreeIndex
 } from './types';
 
 import {
   createFdmKey,
-  createModelNodeIdKey,
+  createModelTreeIndexKey,
   createModelRevisionKey,
   revisionKeyToIds
 } from './idAndKeyTranslation';
 
 import { partition } from 'lodash';
 
 import assert from 'assert';
-import { fetchNodesForNodeIds, inspectNodes } from './requests';
+import { fetchNodesForNodeIds, inspectNodes, treeIndexesToNodeIds } from './requests';
 import { type ThreeDModelFdmMappings } from '../../hooks/types';
 import { type Fdm3dDataProvider } from '../../data-providers/Fdm3dDataProvider';
 
@@ -78,9 +78,7 @@ export class FdmNodeCache {
     modelRevisionIds: ModelRevisionId[],
     externalIds: DmsUniqueIdentifier[]
   ): ThreeDModelFdmMappings[] {
-    const inputExternalIdSet = new Set<FdmKey>(
-      externalIds.map((id) => createFdmKey(id.space, id.externalId))
-    );
+    const inputExternalIdSet = new Set<FdmKey>(externalIds.map(createFdmKey));
 
     return modelRevisionIds.map((modelRevisionId) => {
       return this.getCachedModelMappingForRevision(modelRevisionId, inputExternalIdSet);
@@ -122,7 +120,7 @@ export class FdmNodeCache {
       return [];
     }
 
-    const fdmKeySet = new Set(instances.map((id) => createFdmKey(id.space, id.externalId)));
+    const fdmKeySet = new Set(instances.map(createFdmKey));
 
     const revisionToConnectionsMap = await this.getAndCacheRevisionToConnectionsMap(
       modelRevisions,
@@ -239,8 +237,8 @@ export class FdmNodeCache {
     modelRevisionIds: ModelRevisionId[],
     fetchViews: boolean
   ): Promise<Map<ModelRevisionKey, FdmConnectionWithNode[]>> {
-    const revisionIds = modelRevisionIds.map((modelRevisionId) => modelRevisionId.revisionId);
-    const connections = await this._fdm3dDataProvider.getCadConnectionsForRevisions(revisionIds);
+    const connections =
+      await this._fdm3dDataProvider.getCadConnectionsForRevisions(modelRevisionIds);
 
     const connectionsWithOptionalViews = fetchViews
       ? await this.getViewsForConnections(connections)
@@ -269,15 +267,15 @@ export class FdmNodeCache {
 
   private async getViewsForConnections(
     connections: FdmCadConnection[]
-  ): Promise<Array<{ connection: FdmCadConnection; view: Source }>> {
+  ): Promise<Array<{ connection: FdmCadConnection; views: Source[] }>> {
     const nodeInspectionResults = await inspectNodes(
       this._fdmClient,
       connections.map((connection) => connection.instance)
     );
 
     const dataWithViews = connections.map((connection, ind) => ({
       connection,
-      view: nodeInspectionResults.items[ind].inspectionResults.involvedViews[0]
+      views: nodeInspectionResults.items[ind].inspectionResults.involvedViews
     }));
 
     return dataWithViews;
@@ -307,28 +305,28 @@ export class FdmNodeCache {
 }
 
 async function createRevisionToConnectionsMap(
-  connectionsWithView: Array<{ connection: FdmCadConnection; view?: Source }>,
+  connectionsWithViews: Array<{ connection: FdmCadConnection; views?: Source[] }>,
   modelRevisionIds: ModelRevisionId[],
   cdfClient: CogniteClient
 ): Promise<Map<ModelRevisionKey, FdmConnectionWithNode[]>> {
-  const revisionToNodeIdsMap = createRevisionToNodeIdMap(connectionsWithView);
-  const modelNodeIdToNodeMap = await createModelNodeIdToNodeMap(
-    revisionToNodeIdsMap,
+  const revisionToTreeIndexMap = createRevisionToTreeIndexMap(connectionsWithViews);
+  const modelTreeIndexToNodeMap = await createModelTreeIndexToNodeMap(
+    revisionToTreeIndexMap,
     modelRevisionIds,
     cdfClient
   );
 
-  return connectionsWithView.reduce((map, connectionWithView) => {
-    const connectionRevisionId = connectionWithView.connection.revisionId;
+  return connectionsWithViews.reduce((map, connectionWithViews) => {
+    const connectionRevisionId = connectionWithViews.connection.revisionId;
     const modelRevisionId = modelRevisionIds.find((p) => p.revisionId === connectionRevisionId);
 
     if (modelRevisionId === undefined) return map;
 
     const value = createFdmConnectionWithNode(
       modelRevisionId,
-      modelNodeIdToNodeMap,
-      connectionWithView.connection,
-      connectionWithView.view
+      modelTreeIndexToNodeMap,
+      connectionWithViews.connection,
+      connectionWithViews.views
     );
 
     insertConnectionIntoMapList(value, map, modelRevisionId);
@@ -339,20 +337,20 @@ async function createRevisionToConnectionsMap(
 
 function createFdmConnectionWithNode(
   modelRevisionId: ModelRevisionId,
-  modelNodeIdToNodeMap: Map<ModelNodeIdKey, Node3D>,
+  modelTreeIndexToNodeMap: Map<ModelTreeIndexKey, Node3D>,
   connection: FdmCadConnection,
-  view?: Source
+  views?: Source[]
 ): FdmConnectionWithNode {
-  const revisionNodeIdKey = createModelNodeIdKey(
+  const revisionTreeIndexKey = createModelTreeIndexKey(
     modelRevisionId.modelId,
     modelRevisionId.revisionId,
-    connection.nodeId
+    connection.treeIndex
   );
 
-  const node = modelNodeIdToNodeMap.get(revisionNodeIdKey);
+  const node = modelTreeIndexToNodeMap.get(revisionTreeIndexKey);
   assert(node !== undefined);
 
-  return { connection, cadNode: node, view };
+  return { connection, cadNode: node, views };
 }
 
 function insertConnectionIntoMapList(
@@ -374,56 +372,57 @@ function insertConnectionIntoMapList(
   }
 }
 
-async function createModelNodeIdToNodeMap(
-  revisionToNodeIdsMap: Map<RevisionId, NodeId[]>,
+async function createModelTreeIndexToNodeMap(
+  revisionToTreeIndicesMap: Map<RevisionId, TreeIndex[]>,
   modelRevisionIds: ModelRevisionId[],
   cdfClient: CogniteClient
-): Promise<Map<ModelNodeIdKey, Node3D>> {
-  const revisionNodeIdToNode = new Map<ModelNodeIdKey, Node3D>();
+): Promise<Map<ModelTreeIndexKey, Node3D>> {
+  const revisionTreeIndexToNode = new Map<ModelTreeIndexKey, Node3D>();
 
-  const nodePromises = [...revisionToNodeIdsMap.entries()].map(async ([revisionId, nodeIds]) => {
-    const modelId = modelRevisionIds.find((p) => p.revisionId === revisionId)?.modelId;
-    assert(modelId !== undefined);
+  const nodePromises = [...revisionToTreeIndicesMap.entries()].map(
+    async ([revisionId, treeIndices]) => {
+      const modelId = modelRevisionIds.find((p) => p.revisionId === revisionId)?.modelId;
+      assert(modelId !== undefined);
 
-    const nodes = await fetchNodesForNodeIds(modelId, revisionId, nodeIds, cdfClient);
-    nodeIds.forEach((nodeId, ind) => {
-      const modelNodeIdKey = createModelNodeIdKey(modelId, revisionId, nodeId);
-      revisionNodeIdToNode.set(modelNodeIdKey, nodes[ind]);
-    });
-  });
+      const nodeIds = await treeIndexesToNodeIds(modelId, revisionId, treeIndices, cdfClient);
+      const nodes = await fetchNodesForNodeIds(modelId, revisionId, nodeIds, cdfClient);
+
+      nodes.forEach((node) => {
+        const modelTreeIndexKey = createModelTreeIndexKey(modelId, revisionId, node.treeIndex);
+        revisionTreeIndexToNode.set(modelTreeIndexKey, node);
+      });
+    }
+  );
 
   await Promise.all(nodePromises);
 
-  return revisionNodeIdToNode;
+  return revisionTreeIndexToNode;
 }
 
-function createRevisionToNodeIdMap(
+function createRevisionToTreeIndexMap(
   connections: Array<{ connection: FdmCadConnection; view?: Source }>
-): Map<RevisionId, NodeId[]> {
-  return connections.reduce((revisionNodeIdMap, connectionWithView) => {
-    const { nodeId, revisionId } = connectionWithView.connection;
+): Map<RevisionId, TreeIndex[]> {
+  return connections.reduce((revisionTreeIndexMap, connectionWithView) => {
+    const { treeIndex, revisionId } = connectionWithView.connection;
 
-    const nodeIdsInRevision = revisionNodeIdMap.get(revisionId);
+    const treeIndicesInRevision = revisionTreeIndexMap.get(revisionId);
 
-    if (nodeIdsInRevision !== undefined) {
-      nodeIdsInRevision.push(nodeId);
+    if (treeIndicesInRevision !== undefined) {
+      treeIndicesInRevision.push(treeIndex);
     } else {
-      revisionNodeIdMap.set(revisionId, [nodeId]);
+      revisionTreeIndexMap.set(revisionId, [treeIndex]);
     }
 
-    return revisionNodeIdMap;
-  }, new Map<RevisionId, NodeId[]>());
+    return revisionTreeIndexMap;
+  }, new Map<RevisionId, TreeIndex[]>());
 }
 
 function intersectWithFdmKeySet(
   connections: FdmConnectionWithNode[],
   relevantFdmKeySet: Set<FdmKey>
 ): FdmConnectionWithNode[] {
   return connections.filter((connectionData) => {
-    const fdmKey = createFdmKey(
-      connectionData.connection.instance.space,
-      connectionData.connection.instance.externalId
-    );
+    const fdmKey = createFdmKey(connectionData.connection.instance);
     return relevantFdmKeySet.has(fdmKey);
   });
 }

react-components/src/components/CacheProvider/Node3DPerNodeIdCache.ts

@@ -6,15 +6,15 @@ import {
   type ChunkInCacheTypes,
   type ModelId,
   type RevisionId,
-  type ModelNodeIdKey
+  type ModelTreeIndexKey
 } from './types';
 import { modelRevisionNodesAssetsToKey } from './utils';
 import { fetchNodesForNodeIds } from './requests';
 
 export class Node3DPerNodeIdCache {
   private readonly _sdk: CogniteClient;
 
-  private readonly _nodeIdsToNode3D = new Map<ModelNodeIdKey, Promise<Node3D>>();
+  private readonly _nodeIdsToNode3D = new Map<ModelTreeIndexKey, Promise<Node3D>>();
 
   constructor(sdk: CogniteClient) {
     this._sdk = sdk;
@@ -71,11 +71,11 @@ export class Node3DPerNodeIdCache {
     return allNodes;
   }
 
-  public async getNodeIdToNode3DCacheItem(key: ModelNodeIdKey): Promise<Node3D | undefined> {
+  public async getNodeIdToNode3DCacheItem(key: ModelTreeIndexKey): Promise<Node3D | undefined> {
     return await this._nodeIdsToNode3D.get(key);
   }
 
-  public setNodeIdToNode3DCacheItem(key: ModelNodeIdKey, item: Promise<Node3D>): void {
+  public setNodeIdToNode3DCacheItem(key: ModelTreeIndexKey, item: Promise<Node3D>): void {
     this._nodeIdsToNode3D.set(key, Promise.resolve(item));
   }
 }