Use 'intersect' new method from Set

This allow to do intersection more performant

Author: manelcecs

src/domain-services/external-reference/external-reference-service.ts

@@ -3,10 +3,8 @@ import { type FlowId } from '@unocha/hpc-api-core/src/db/models/flow';
 import { Op } from '@unocha/hpc-api-core/src/db/util/conditions';
 import { type InstanceDataOfModel } from '@unocha/hpc-api-core/src/db/util/raw-model';
 import { type InstanceOfModel } from '@unocha/hpc-api-core/src/db/util/types';
-import { createBrandedValue } from '@unocha/hpc-api-core/src/util/types';
 import { Service } from 'typedi';
 import { type FlowExternalReference } from '../flows/graphql/types';
-import { type UniqueFlowEntity } from '../flows/model';
 import { type SystemID } from '../report-details/graphql/types';
 
 @Service()
@@ -51,7 +49,7 @@ export class ExternalReferenceService {
   async getUniqueFlowIDsBySystemID(
     models: Database,
     systemID: SystemID
-  ): Promise<UniqueFlowEntity[]> {
+  ): Promise<Set<string>> {
     const externalRefences: Array<
       InstanceDataOfModel<Database['externalReference']>
     > = await models.externalReference.find({
@@ -61,13 +59,11 @@ export class ExternalReferenceService {
       skipValidation: true,
     });
 
-    const flowIDs: UniqueFlowEntity[] = [];
-
-    for (const reference of externalRefences) {
-      flowIDs.push(this.mapExternalDataToUniqueFlowEntity(reference));
-    }
-
-    return flowIDs;
+    return new Set(
+      externalRefences.map((externalReference) => {
+        return `${externalReference.flowID}:${externalReference.versionID}`;
+      })
+    );
   }
 
   private mapExternalReferenceToExternalReferenceFlows(
@@ -83,13 +79,4 @@ export class ExternalReferenceService {
       versionID: externalReference.versionID ?? 0,
     };
   }
-
-  private mapExternalDataToUniqueFlowEntity(
-    external: InstanceDataOfModel<Database['externalReference']>
-  ): UniqueFlowEntity {
-    return {
-      id: createBrandedValue(external.flowID),
-      versionID: external.versionID,
-    };
-  }
 }

src/domain-services/flows/strategy/impl/get-flowIds-flow-from-nested-flow-filters-strategy-impl.ts

@@ -3,13 +3,12 @@ import { ExternalReferenceService } from '../../../external-reference/external-r
 import { LegacyService } from '../../../legacy/legacy-service';
 import { ReportDetailService } from '../../../report-details/report-detail-service';
 import { FlowService } from '../../flow-service';
-import type { UniqueFlowEntity } from '../../model';
 import {
   type FlowIDSearchStrategy,
   type FlowIdSearchStrategyArgs,
   type FlowIdSearchStrategyResponse,
 } from '../flowID-search-strategy';
-import { intersectUniqueFlowEntities } from './utils';
+import { intersectSets, parseFlowIdVersionSet } from './utils';
 
 @Service()
 export class GetFlowIdsFromNestedFlowFiltersStrategyImpl
@@ -27,10 +26,10 @@ export class GetFlowIdsFromNestedFlowFiltersStrategyImpl
   ): Promise<FlowIdSearchStrategyResponse> {
     const { models, nestedFlowFilters } = args;
 
-    let flowsReporterReferenceCode: UniqueFlowEntity[] = [];
-    let flowsSourceSystemId: UniqueFlowEntity[] = [];
-    let flowsSystemId: UniqueFlowEntity[] = [];
-    const flowsLegacyId: UniqueFlowEntity[] = [];
+    let flowsReporterReferenceCode: Set<string> = new Set<string>();
+    let flowsSourceSystemId: Set<string> = new Set<string>();
+    let flowsSystemId: Set<string> = new Set<string>();
+    const flowsLegacyId: Set<string> = new Set<string>();
 
     // Get the flowIDs using 'reporterReferenceCode'
     if (nestedFlowFilters?.reporterRefCode) {
@@ -67,30 +66,26 @@ export class GetFlowIdsFromNestedFlowFiltersStrategyImpl
       );
 
       if (flowID) {
-        flowsLegacyId.push({
-          id: flowID,
-          versionID: 1,
-        });
+        flowsLegacyId.add(`${flowID}:1`);
       }
     }
 
     // Intersect the flowIDs from the nestedFlowFilters
-    const flowIDsFromNestedFlowFilters: UniqueFlowEntity[] =
-      intersectUniqueFlowEntities(
-        flowsReporterReferenceCode,
-        flowsSourceSystemId,
-        flowsSystemId,
-        flowsLegacyId
-      );
+    const flowIDsFromNestedFlowFilters: Set<string> = intersectSets(
+      flowsReporterReferenceCode,
+      flowsSourceSystemId,
+      flowsSystemId,
+      flowsLegacyId
+    );
 
-    if (flowIDsFromNestedFlowFilters.length === 0) {
+    if (flowIDsFromNestedFlowFilters.size === 0) {
       return { flows: [] };
     }
     // Once gathered and disjoined the flowIDs from the nestedFlowFilters
     // Look after this uniqueFlows in the flow table
     const flows = await this.flowService.progresiveSearch(
       models,
-      flowIDsFromNestedFlowFilters,
+      parseFlowIdVersionSet(flowIDsFromNestedFlowFilters),
       1000,
       0,
       false, // Stop when we have the limit

src/domain-services/flows/strategy/impl/get-flowIds-flow-object-conditions-strategy-impl.ts

@@ -1,12 +1,11 @@
 import { Op } from '@unocha/hpc-api-core/src/db/util/conditions';
 import { Service } from 'typedi';
-import { type UniqueFlowEntity } from '../../model';
 import {
   type FlowIDSearchStrategy,
   type FlowIdSearchStrategyArgs,
   type FlowIdSearchStrategyResponse,
 } from '../flowID-search-strategy';
-import { intersectUniqueFlowEntities } from './utils';
+import { intersectSets, parseFlowIdVersionSet } from './utils';
 
 @Service()
 export class GetFlowIdsFromObjectConditionsStrategyImpl
@@ -23,7 +22,7 @@ export class GetFlowIdsFromObjectConditionsStrategyImpl
       return { flows: [] };
     }
 
-    let intersectedFlows: UniqueFlowEntity[] = [];
+    let intersectedFlows: Set<string> = new Set<string>();
 
     for (const [flowObjectType, group] of flowObjectFilterGrouped.entries()) {
       for (const [direction, ids] of group.entries()) {
@@ -36,22 +35,19 @@ export class GetFlowIdsFromObjectConditionsStrategyImpl
           where: condition,
         });
 
-        const uniqueFlowObjectsEntities: UniqueFlowEntity[] =
+        const uniqueFlowObjectsEntities: Set<string> = new Set<string>(
           flowObjectsFound.map(
-            (flowObject) =>
-              ({
-                id: flowObject.flowID,
-                versionID: flowObject.versionID,
-              }) satisfies UniqueFlowEntity
-          );
-
-        intersectedFlows = intersectUniqueFlowEntities(
+            (flowObject) => `${flowObject.flowID}:${flowObject.versionID}`
+          )
+        );
+
+        intersectedFlows = intersectSets(
           intersectedFlows,
           uniqueFlowObjectsEntities
         );
       }
     }
 
-    return { flows: intersectedFlows };
+    return { flows: parseFlowIdVersionSet(intersectedFlows) };
   }
 }