fix(react-components): react components rule core improvements to fix several issues in the Rule Builder time series selection/searching/selecting/filtering

react-components/src/components/RuleBasedOutputs/RuleBasedOutputsSelector.tsx

@@ -96,7 +96,7 @@ export function RuleBasedOutputsSelector({
   const { isLoading: isLoadingAssetIdsAndTimeseriesData, data: assetIdsWithTimeseriesData } =
     useAssetsAndTimeseriesLinkageDataQuery({
       timeseriesExternalIds,
-      contextualizedAssetNodes
+      assetNodes: contextualizedAssetNodes
     });
 
   const flatAssetsMappingsListPerModel = useCreateAssetMappingsMapPerModel(models, assetMappings);

react-components/src/components/RuleBasedOutputs/index.ts

@@ -6,6 +6,8 @@ export * from './hooks';
 export { RuleBasedOutputsPanel } from './RuleBasedOutputsPanel';
 export { getRuleTriggerTypes } from './utils';
 
+export * from './utils/index';
+
 export type {
   RuleAndEnabled,
   TriggerType,

react-components/src/components/RuleBasedOutputs/utils/getResourceRelationship.ts

@@ -0,0 +1,20 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { type RelationshipResourceType, type CogniteClient } from '@cognite/sdk/dist/src';
+import { type ExtendedRelationshipWithSourceAndTarget } from '../../../data-providers/types';
+import { getRelationships } from '../../../hooks/network/getRelationships';
+
+export const getResourceRelationship = async (
+  sdk: CogniteClient,
+  resourceIds: string[],
+  resourceTypes: RelationshipResourceType[]
+): Promise<ExtendedRelationshipWithSourceAndTarget[]> => {
+  if (resourceIds.length === 0 || resourceIds.filter((id) => id.length > 0).length === 0) {
+    return [];
+  }
+  return await getRelationships(sdk, {
+    resourceExternalIds: resourceIds,
+    relationshipResourceTypes: resourceTypes
+  });
+};

react-components/src/components/RuleBasedOutputs/utils/index.ts

@@ -0,0 +1,4 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+export { getResourceRelationship } from './getResourceRelationship';

react-components/src/data-providers/index.ts

@@ -2,5 +2,11 @@
  * Copyright 2024 Cognite AS
  */
 
-export type { FdmInstanceWithView, InstanceReference, AssetInstanceReference } from './types';
+export type {
+  FdmInstanceWithView,
+  InstanceReference,
+  AssetInstanceReference,
+  AssetIdsAndTimeseriesData,
+  ExtendedRelationship
+} from './types';
 export type { Source, DmsUniqueIdentifier, SimpleSource } from './FdmSDK';

react-components/src/data-providers/types.ts

@@ -32,10 +32,21 @@ export type ExtendedRelationship = {
   relation: 'Source' | 'Target';
 } & Relationship;
 
+export type ExtendedRelationshipWithSourceAndTarget = {
+  relation: 'Source' | 'Target';
+} & Relationship &
+  Partial<RelationshipSourceAndTargetTimeseries>;
+
+export type RelationshipSourceAndTargetTimeseries = {
+  source: Timeseries;
+  target: Timeseries;
+};
+
 export type RelationshipSourceAndTarget = {
   source: RelationshipSourceAndTargetData;
   target: RelationshipSourceAndTargetData;
 };
+
 export type RelationshipSourceAndTargetData = {
   externalId?: string;
   id?: number;

react-components/src/hooks/network/getTimeseriesLatestDatapoints.ts

@@ -2,10 +2,25 @@
  * Copyright 2024 Cognite AS
  */
 import { type CogniteClient, type IdEither, type Datapoints } from '@cognite/sdk';
+import { executeParallel } from '../../utilities/executeParallel';
+import { isDefined } from '../../utilities/isDefined';
+import { chunk } from 'lodash';
+
+const FETCH_CHUNK = 100;
 
 export const getTimeseriesLatestDatapoints = async (
   sdk: CogniteClient,
   timeseriesIds: IdEither[]
 ): Promise<Datapoints[]> => {
-  return await sdk.datapoints.retrieveLatest(timeseriesIds);
+  const timeseriesChunks = chunk(timeseriesIds, FETCH_CHUNK);
+
+  const timeseriesDatapoints = await executeParallel(
+    timeseriesChunks.map(
+      (timeseriesIds) => async () => await sdk.datapoints.retrieveLatest(timeseriesIds)
+    ),
+    2
+  );
+
+  const cleanDatapoints = timeseriesDatapoints.filter(isDefined).flat();
+  return cleanDatapoints;
 };

react-components/src/query/useAssetsAndTimeseriesLinkageDataQuery.ts

@@ -26,15 +26,19 @@ import { getTimeseriesByIds } from '../hooks/network/getTimeseriesByIds';
 import { isDefined } from '../utilities/isDefined';
 import { getAssetsByIds } from '../hooks/network/getAssetsByIds';
 import { getTimeseriesLatestDatapoints } from '../hooks/network/getTimeseriesLatestDatapoints';
+import { chunk, uniqBy } from 'lodash';
+import { executeParallel } from '../utilities/executeParallel';
+
+const FETCH_RELATIONSHIP_CHUNK = 1000;
 
 type Props = {
   timeseriesExternalIds: CogniteExternalId[];
-  contextualizedAssetNodes: Asset[];
+  assetNodes: Asset[];
 };
 
 export function useAssetsAndTimeseriesLinkageDataQuery({
   timeseriesExternalIds,
-  contextualizedAssetNodes
+  assetNodes
 }: Props): UseQueryResult<AssetIdsAndTimeseriesData, unknown> {
   const sdk = useSDK();
 
@@ -64,16 +68,18 @@ export function useAssetsAndTimeseriesLinkageDataQuery({
         timeseries
           ?.map((timeseries) => {
             return getAssetIdsFromTimeseries(
-              contextualizedAssetNodes,
+              assetNodes,
               timeseries,
               assetAndTimeseriesIdsFromRelationship
             );
           })
           .flat()
           .filter(isDefined) ?? [];
 
+      const uniqueAssetIds = uniqBy(assetIdsFound, 'externalId');
+
       const assetFromTimeseries =
-        assetIdsFound.length > 0 ? await getAssetsByIds(sdk, assetIdsFound) : [];
+        assetIdsFound.length > 0 ? await getAssetsByIds(sdk, uniqueAssetIds) : [];
 
       const assetIdsWithTimeseries =
         timeseries
@@ -102,13 +108,23 @@ const getLinkFromRelationships = async (
   timeseriesExternalIds: string[],
   relationshipResourceTypes: RelationshipResourceType[]
 ): Promise<AssetAndTimeseriesIds[]> => {
-  const dataRelationship = await getRelationships(sdk, {
-    resourceExternalIds: timeseriesExternalIds,
-    relationshipResourceTypes
-  });
+  const timeseriesChunks = chunk(timeseriesExternalIds, FETCH_RELATIONSHIP_CHUNK);
+
+  const dataRelationship = await executeParallel(
+    timeseriesChunks.map(
+      (timeseriesIds) => async () =>
+        await getRelationships(sdk, {
+          resourceExternalIds: timeseriesIds,
+          relationshipResourceTypes
+        })
+    ),
+    2
+  );
+
+  const cleanDataRelationship = dataRelationship.filter(isDefined).flat();
 
   const assetAndTimeseriesIdsFromRelationship =
-    dataRelationship?.map((item) => {
+    cleanDataRelationship?.map((item) => {
       const assetAndTimeseriesIds: AssetAndTimeseriesIds = {
         assetIds: { externalId: '' },
         timeseriesIds: { externalId: '' }