feat(react-components): add fetching of the view for mapped equipment hook

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

@@ -3,11 +3,15 @@
  */
 
 import { type Node3D, type CogniteClient, type CogniteExternalId } from '@cognite/sdk';
-import { type DmsUniqueIdentifier, type EdgeItem, type FdmSDK } from '../../utilities/FdmSDK';
+import {
+  type Source,
+  type DmsUniqueIdentifier,
+  type EdgeItem,
+  type FdmSDK
+} from '../../utilities/FdmSDK';
 import { RevisionFdmNodeCache } from './RevisionFdmNodeCache';
 import {
   type FdmEdgeWithNode,
-  type Fdm3dNodeData,
   type FdmCadEdge,
   type ModelRevisionKey,
   type RevisionId,
@@ -32,7 +36,7 @@ import {
 import { partition } from 'lodash';
 
 import assert from 'assert';
-import { fetchNodesForNodeIds } from './requests';
+import { fetchNodesForNodeIds, inspectNodes } from './requests';
 import { type ThreeDModelMappings } from '../../hooks/types';
 
 export class FdmNodeCache {
@@ -203,8 +207,9 @@ export class FdmNodeCache {
   ): Promise<Map<ModelRevisionKey, FdmEdgeWithNode[]>> {
     const revisionIds = modelRevisionIds.map((modelRevisionId) => modelRevisionId.revisionId);
     const edges = await this.getEdgesForRevisions(revisionIds, this._fdmClient);
+    const edgesWithViews = await this.getViewsForEdges(edges);
     const revisionToEdgesMap = await createRevisionToEdgesMap(
-      edges,
+      edgesWithViews,
       modelRevisionIds,
       this._cdfClient
     );
@@ -218,12 +223,28 @@ export class FdmNodeCache {
     modelId: number,
     revisionId: number,
     treeIndex: number
-  ): Promise<Fdm3dNodeData[]> {
+  ): Promise<FdmEdgeWithNode[]> {
     const revisionCache = this.getOrCreateRevisionCache(modelId, revisionId);
 
     return await revisionCache.getClosestParentFdmData(treeIndex);
   }
 
+  private async getViewsForEdges(
+    edges: FdmCadEdge[]
+  ): Promise<Array<{ edge: FdmCadEdge; view: Source }>> {
+    const nodeInspectionResults = await inspectNodes(
+      this._fdmClient,
+      edges.map((edge) => edge.startNode)
+    );
+
+    const dataWithViews = edges.map((edge, ind) => ({
+      edge,
+      view: nodeInspectionResults.items[ind].inspectionResults.involvedViewsAndContainers.views[0]
+    }));
+
+    return dataWithViews;
+  }
+
   private async getEdgesForRevisions(
     revisionIds: number[],
     fdmClient: FdmSDK
@@ -266,24 +287,29 @@ export class FdmNodeCache {
 }
 
 async function createRevisionToEdgesMap(
-  edges: FdmCadEdge[],
+  edgesWithViews: Array<{ edge: FdmCadEdge; view: Source }>,
   modelRevisionIds: ModelRevisionId[],
   cdfClient: CogniteClient
 ): Promise<Map<ModelRevisionKey, FdmEdgeWithNode[]>> {
-  const revisionToNodeIdsMap = createRevisionToNodeIdMap(edges);
+  const revisionToNodeIdsMap = createRevisionToNodeIdMap(edgesWithViews);
   const modelNodeIdToNodeMap = await createModelNodeIdToNodeMap(
     revisionToNodeIdsMap,
     modelRevisionIds,
     cdfClient
   );
 
-  return edges.reduce((map, edge) => {
-    const edgeRevisionId = edge.properties.revisionId;
+  return edgesWithViews.reduce((map, edgeWithView) => {
+    const edgeRevisionId = edgeWithView.edge.properties.revisionId;
     const modelRevisionId = modelRevisionIds.find((p) => p.revisionId === edgeRevisionId);
 
     if (modelRevisionId === undefined) return map;
 
-    const value = createFdmEdgeWithNode(modelRevisionId, edge, modelNodeIdToNodeMap);
+    const value = createFdmEdgeWithNode(
+      modelRevisionId,
+      edgeWithView.edge,
+      edgeWithView.view,
+      modelNodeIdToNodeMap
+    );
 
     insertEdgeIntoMapList(value, map, modelRevisionId);
 
@@ -294,6 +320,7 @@ async function createRevisionToEdgesMap(
 function createFdmEdgeWithNode(
   modelRevisionId: ModelRevisionId,
   edge: FdmCadEdge,
+  view: Source,
   modelNodeIdToNodeMap: Map<ModelNodeIdKey, Node3D>
 ): FdmEdgeWithNode {
   const revisionNodeIdKey = createModelNodeIdKey(
@@ -305,7 +332,7 @@ function createFdmEdgeWithNode(
   const node = modelNodeIdToNodeMap.get(revisionNodeIdKey);
   assert(node !== undefined);
 
-  return { edge, node };
+  return { edge, node, view };
 }
 
 function insertEdgeIntoMapList(
@@ -350,14 +377,18 @@ async function createModelNodeIdToNodeMap(
   return revisionNodeIdToNode;
 }
 
-function createRevisionToNodeIdMap(edges: FdmCadEdge[]): Map<RevisionId, NodeId[]> {
-  return edges.reduce((revisionNodeIdMap, edge) => {
-    const nodeIdsInRevision = revisionNodeIdMap.get(edge.properties.revisionId);
+function createRevisionToNodeIdMap(
+  edgesWithViews: Array<{ edge: FdmCadEdge; view: Source }>
+): Map<RevisionId, NodeId[]> {
+  return edgesWithViews.reduce((revisionNodeIdMap, edgeWithView) => {
+    const { revisionNodeId, revisionId } = edgeWithView.edge.properties;
+
+    const nodeIdsInRevision = revisionNodeIdMap.get(revisionId);
 
     if (nodeIdsInRevision !== undefined) {
-      nodeIdsInRevision.push(edge.properties.revisionNodeId);
+      nodeIdsInRevision.push(revisionNodeId);
     } else {
-      revisionNodeIdMap.set(edge.properties.revisionId, [edge.properties.revisionNodeId]);
+      revisionNodeIdMap.set(revisionId, [revisionNodeId]);
     }
 
     return revisionNodeIdMap;

react-components/src/components/NodeCacheProvider/NodeCacheProvider.tsx

@@ -6,7 +6,7 @@ import { type ReactElement, type ReactNode, createContext, useContext, useMemo }
 import { FdmNodeCache } from './FdmNodeCache';
 import { type UseQueryResult, useQuery } from '@tanstack/react-query';
 import { useFdmSdk, useSDK } from '../RevealContainer/SDKProvider';
-import { type ModelRevisionToEdgeMap, type Fdm3dNodeData } from './types';
+import { type FdmEdgeWithNode, type ModelRevisionToEdgeMap } from './types';
 
 import assert from 'assert';
 import { type DmsUniqueIdentifier } from '../../utilities/FdmSDK';
@@ -20,16 +20,22 @@ export type FdmNodeCacheContent = {
 
 export const FdmNodeCacheContext = createContext<FdmNodeCacheContent | undefined>(undefined);
 
-export const useMappedEdgesForRevisions = (
-  modelRevisionIds: Array<{ modelId: number; revisionId: number }>,
-  enabled = true
-): UseQueryResult<ModelRevisionToEdgeMap> => {
+export const useFdmNodeCache = (): FdmNodeCacheContent => {
   const content = useContext(FdmNodeCacheContext);
 
   if (content === undefined) {
     throw Error('Must use useNodeCache inside a NodeCacheContext');
   }
 
+  return content;
+};
+
+export const useMappedEdgesForRevisions = (
+  modelRevisionIds: Array<{ modelId: number; revisionId: number }>,
+  enabled = true
+): UseQueryResult<ModelRevisionToEdgeMap> => {
+  const content = useFdmNodeCache();
+
   return useQuery(
     [
       'reveal',
@@ -45,8 +51,8 @@ export const useFdm3dNodeData = (
   modelId: number | undefined,
   revisionId: number | undefined,
   treeIndex: number | undefined
-): UseQueryResult<Fdm3dNodeData[]> => {
-  const content = useContext(FdmNodeCacheContext);
+): UseQueryResult<FdmEdgeWithNode[]> => {
+  const content = useFdmNodeCache();
 
   const enableQuery =
     content !== undefined &&
@@ -65,25 +71,19 @@ export const useFdm3dNodeData = (
     }
   );
 
-  if (content === undefined) {
-    throw Error('Must use useNodeCache inside a NodeCacheContext');
-  }
-
   return result;
 };
 
 export const useFdmAssetMappings = (
   fdmAssetExternalIds: DmsUniqueIdentifier[],
   models: TypedReveal3DModel[]
 ): UseQueryResult<ThreeDModelMappings[]> => {
-  const nodeCacheContent = useContext(FdmNodeCacheContext);
+  const nodeCacheContent = useFdmNodeCache();
 
   return useQuery(
     ['reveal', 'react-components', 'fdm-asset-mappings', fdmAssetExternalIds],
     async () => {
-      return (
-        (await nodeCacheContent?.cache.getMappingsForFdmIds(fdmAssetExternalIds, models)) ?? []
-      );
+      return await nodeCacheContent.cache.getMappingsForFdmIds(fdmAssetExternalIds, models);
     },
     {
       enabled: fdmAssetExternalIds.length > 0 && models.length > 0,

react-components/src/components/NodeCacheProvider/RevisionFdmNodeCache.ts

@@ -4,7 +4,7 @@
 
 import { type CogniteClient, type Node3D } from '@cognite/sdk';
 import { type FdmSDK } from '../../utilities/FdmSDK';
-import { type TreeIndex, type Fdm3dNodeData, type FdmEdgeWithNode, type FdmCadEdge } from './types';
+import { type TreeIndex, type FdmEdgeWithNode, type FdmCadEdge } from './types';
 
 import {
   fetchAncestorNodesForTreeIndex,
@@ -24,7 +24,6 @@ export class RevisionFdmNodeCache {
   private readonly _revisionId: number;
 
   private readonly _treeIndexToFdmEdges = new Map<TreeIndex, FdmEdgeWithNode[]>();
-  private readonly _treeIndexToFdmData = new Map<TreeIndex, Fdm3dNodeData[]>();
 
   constructor(
     cogniteClient: CogniteClient,
@@ -39,8 +38,8 @@ export class RevisionFdmNodeCache {
     this._revisionId = revisionId;
   }
 
-  public async getClosestParentFdmData(searchTreeIndex: number): Promise<Fdm3dNodeData[]> {
-    const cachedFdmData = this._treeIndexToFdmData.get(searchTreeIndex);
+  public async getClosestParentFdmData(searchTreeIndex: number): Promise<FdmEdgeWithNode[]> {
+    const cachedFdmData = this._treeIndexToFdmEdges.get(searchTreeIndex);
 
     if (cachedFdmData !== undefined) {
       return cachedFdmData;
@@ -55,15 +54,15 @@ export class RevisionFdmNodeCache {
     return await this.findNodeDataFromAncestors(searchTreeIndex);
   }
 
-  private async findNodeDataFromAncestors(treeIndex: TreeIndex): Promise<Fdm3dNodeData[]> {
+  private async findNodeDataFromAncestors(treeIndex: TreeIndex): Promise<FdmEdgeWithNode[]> {
     const { edges, ancestorsWithSameMapping, firstMappedAncestorTreeIndex } =
       await this.getClosestParentMapping(treeIndex);
 
     if (edges.length === 0) {
       return [];
     }
 
-    const cachedFdmData = this._treeIndexToFdmData.get(firstMappedAncestorTreeIndex);
+    const cachedFdmData = this._treeIndexToFdmEdges.get(firstMappedAncestorTreeIndex);
 
     if (cachedFdmData !== undefined) {
       this.setCacheForNodes(ancestorsWithSameMapping, cachedFdmData);
@@ -82,29 +81,28 @@ export class RevisionFdmNodeCache {
     return await this.getDataWithViewsForFdmEdges(nodeEdges, ancestorsWithSameMapping);
   }
 
-  private setCacheForNodes(nodes: Node3D[], nodeData: Fdm3dNodeData[]): void {
+  private setCacheForNodes(nodes: Node3D[], nodeData: FdmEdgeWithNode[]): void {
     nodes.forEach((node) => {
-      this._treeIndexToFdmData.set(node.treeIndex, nodeData);
+      this._treeIndexToFdmEdges.set(node.treeIndex, nodeData);
     });
   }
 
   private async getDataWithViewsForFdmEdges(
-    nodeEdges: FdmEdgeWithNode[],
+    nodeEdges: Array<{ edge: FdmCadEdge; node: Node3D }>,
     ancestorsWithSameMapping: Node3D[]
-  ): Promise<Fdm3dNodeData[]> {
+  ): Promise<FdmEdgeWithNode[]> {
     const nodeInspectionResults = await inspectNodes(
       this._fdmClient,
       nodeEdges.map((edge) => edge.edge.startNode)
     );
 
     const dataWithViews = nodeEdges.map((fdmEdgeWithNode, ind) => ({
-      fdmId: fdmEdgeWithNode.edge.startNode,
-      view: nodeInspectionResults.items[ind].inspectionResults.involvedViewsAndContainers.views[0],
-      cadNode: fdmEdgeWithNode.node
+      ...fdmEdgeWithNode,
+      view: nodeInspectionResults.items[ind].inspectionResults.involvedViewsAndContainers.views[0]
     }));
 
     ancestorsWithSameMapping.forEach((ancestor) =>
-      this._treeIndexToFdmData.set(ancestor.treeIndex, dataWithViews)
+      this._treeIndexToFdmEdges.set(ancestor.treeIndex, dataWithViews)
     );
 
     return dataWithViews;

react-components/src/components/NodeCacheProvider/requests.ts

@@ -14,6 +14,7 @@ import {
   type InModel3dEdgeProperties,
   SYSTEM_3D_EDGE_SOURCE
 } from '../../utilities/globalDataModels';
+import { chunk } from 'lodash';
 
 export async function fetchAncestorNodesForTreeIndex(
   modelId: number,
@@ -83,14 +84,24 @@ export async function inspectNodes(
   fdmClient: FdmSDK,
   dataNodes: DmsUniqueIdentifier[]
 ): Promise<InspectResultList> {
-  const inspectionResult = await fdmClient.inspectInstances({
-    inspectionOperations: { involvedViewsAndContainers: {} },
-    items: dataNodes.map((node) => ({
-      instanceType: 'node',
-      externalId: node.externalId,
-      space: node.space
-    }))
-  });
+  const chunkedNodes = chunk(dataNodes, 100);
+
+  const inspectionResult: InspectResultList = {
+    items: []
+  };
+
+  for (const nodesChunk of chunkedNodes) {
+    const chunkInspectionResults = await fdmClient.inspectInstances({
+      inspectionOperations: { involvedViewsAndContainers: {} },
+      items: nodesChunk.map((node) => ({
+        instanceType: 'node',
+        externalId: node.externalId,
+        space: node.space
+      }))
+    });
+
+    inspectionResult.items.push(...chunkInspectionResults.items);
+  }
 
   return inspectionResult;
 }

react-components/src/components/NodeCacheProvider/types.ts

@@ -5,9 +5,8 @@ import { type Node3D } from '@cognite/sdk';
 import { type EdgeItem, type DmsUniqueIdentifier, type Source } from '../../utilities/FdmSDK';
 import { type InModel3dEdgeProperties } from '../../utilities/globalDataModels';
 
-export type Fdm3dNodeData = { fdmId: DmsUniqueIdentifier; view: Source; cadNode: Node3D };
 export type FdmCadEdge = EdgeItem<InModel3dEdgeProperties>;
-export type FdmEdgeWithNode = { edge: FdmCadEdge; node: Node3D };
+export type FdmEdgeWithNode = { edge: FdmCadEdge; node: Node3D; view: Source };
 
 export type ModelId = number;
 export type RevisionId = number;