[Test] red.dev deployment

Author: Onitoxan

src/domain-services/flows/strategy/flowID-search-strategy.ts

@@ -1,4 +1,5 @@
 import { type Database } from '@unocha/hpc-api-core/src/db';
+import { type FlowId } from '@unocha/hpc-api-core/src/db/models/flow';
 import { type ShortcutCategoryFilter } from '../../categories/model';
 import { type FlowObjectFilterGrouped } from '../../flow-object/model';
 import { type FlowCategory, type NestedFlowFilters } from '../graphql/args';
@@ -14,6 +15,7 @@ export interface FlowIdSearchStrategyArgs {
   flowCategoryConditions?: FlowCategory[];
   nestedFlowFilters?: NestedFlowFilters;
   shortcutFilters?: ShortcutCategoryFilter[] | null;
+  candidates?: Set<FlowId>;
 }
 
 export interface FlowIDSearchStrategy {

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

@@ -1,4 +1,7 @@
+import { type FlowId } from '@unocha/hpc-api-core/src/db/models/flow';
 import { Op } from '@unocha/hpc-api-core/src/db/util/conditions';
+import { splitIntoChunks } from '@unocha/hpc-api-core/src/util';
+import { PG_MAX_QUERY_PARAMS } from '@unocha/hpc-api-core/src/util/consts';
 import { Service } from 'typedi';
 import {
   type FlowIDSearchStrategy,
@@ -16,12 +19,12 @@ export class GetFlowIdsFromObjectConditionsStrategyImpl
   async search(
     args: FlowIdSearchStrategyArgs
   ): Promise<FlowIdSearchStrategyResponse> {
-    const { flowObjectFilterGrouped, models } = args;
+    const { flowObjectFilterGrouped, models, candidates } = args;
 
     if (!flowObjectFilterGrouped) {
       return { flows: [] };
     }
-
+    let flowCandidates = candidates ?? new Set<FlowId>();
     let intersectedFlows = new Set<string>();
 
     for (const [flowObjectType, group] of flowObjectFilterGrouped.entries()) {
@@ -31,16 +34,28 @@ export class GetFlowIdsFromObjectConditionsStrategyImpl
           refDirection: direction,
           objectID: { [Op.IN]: ids },
         };
-        const flowObjectsFound = await models.flowObject.find({
-          where: condition,
-        });
+
+        const flowObjectsFound = (
+          await Promise.all(
+            splitIntoChunks([...flowCandidates], PG_MAX_QUERY_PARAMS - 10).map(
+              (entityIds) =>
+                models.flowObject.find({
+                  where: { ...condition, flowID: { [Op.IN]: entityIds } },
+                  distinct: ['flowID', 'versionID'],
+                })
+            )
+          )
+        ).flat();
 
         const uniqueFlowObjectsEntities = new Set<string>(
           flowObjectsFound.map(
             (flowObject) => `${flowObject.flowID}:${flowObject.versionID}`
           )
         );
-
+        flowCandidates = intersectSets(
+          flowCandidates,
+          new Set(flowObjectsFound.map((flowObject) => flowObject.flowID))
+        );
         intersectedFlows = intersectSets(
           intersectedFlows,
           uniqueFlowObjectsEntities

src/domain-services/flows/strategy/impl/search-flow-by-filters-strategy-impl.ts

@@ -52,22 +52,6 @@ export class SearchFlowByFiltersStrategy implements FlowSearchStrategy {
     // to be able to sort the flows using the entity
     const isSortByEntity = orderBy && orderBy.entity !== 'flow';
     let sortByFlowIDsPromise: Promise<UniqueFlowEntity[]> = Promise.resolve([]);
-    const orderByForFlow = mapFlowOrderBy(orderBy);
-
-    // Fetch sorted flow IDs only for the filtered subset instead of the whole table
-    if (isSortByEntity) {
-      // Get entity-sorted IDs then intersect with filtered subset
-      sortByFlowIDsPromise = this.flowService.getFlowIDsFromEntity(
-        models,
-        orderBy
-      );
-    } else {
-      // Let the DB sort only the filtered IDs
-      sortByFlowIDsPromise = this.flowService.getFlows({
-        models,
-        orderBy: orderByForFlow,
-      });
-    }
     // We need to fetch the flowIDs by the nestedFlowFilters
     // if there are any
     const isFilterByNestedFilters = nestedFlowFilters !== undefined;
@@ -118,21 +102,6 @@ export class SearchFlowByFiltersStrategy implements FlowSearchStrategy {
     let didFlowsFromObjectFiltersPromiseCreated = false;
     let flowObjectFiltersGrouped: FlowObjectFilterGrouped | null = null;
 
-    if (isFilterByFlowObjects) {
-      // First step is to map the filters to the FlowObjectFiltersGrouped
-      // To allow doing inclusive filtering between filters of the same type+direction
-      // But exclusive filtering between filters of different type+direction
-      flowObjectFiltersGrouped =
-        mapFlowFiltersToFlowObjectFiltersGrouped(flowObjectFilters);
-
-      flowsFromObjectFiltersPromise =
-        this.getFlowIdsFromObjectConditions.search({
-          models,
-          flowObjectFilterGrouped: flowObjectFiltersGrouped,
-        });
-      didFlowsFromObjectFiltersPromiseCreated = true;
-    }
-
     // Lastly, we need to check if we need to filter by flow
     // And if we didn't did it before when sorting by entity
     // if so, we need to obtain the flowIDs from the flowFilters
@@ -163,17 +132,62 @@ export class SearchFlowByFiltersStrategy implements FlowSearchStrategy {
     const [
       flowsFromCategoryFilters,
       flowsFromNestedFilters,
-      flowsFromObjectFilters,
       flowsFromFlowFilters,
-      sortByFlowIDs,
     ] = await Promise.all([
       flowsFromCategoryFiltersPromise,
       flowsFromNestedFiltersPromise,
-      flowsFromObjectFiltersPromise,
       flowsFromFlowFiltersPromise,
-      sortByFlowIDsPromise,
     ]);
 
+    const intersectCandidates = intersectSets(
+      new Set(flowsFromCategoryFilters.flows.map((f) => f.id)),
+      new Set(flowsFromNestedFilters.flows.map((f) => f.id)),
+      new Set(flowsFromFlowFilters.map((f) => f.id))
+    );
+
+    if (isFilterByFlowObjects) {
+      // First step is to map the filters to the FlowObjectFiltersGrouped
+      // To allow doing inclusive filtering between filters of the same type+direction
+      // But exclusive filtering between filters of different type+direction
+      flowObjectFiltersGrouped =
+        mapFlowFiltersToFlowObjectFiltersGrouped(flowObjectFilters);
+
+      flowsFromObjectFiltersPromise =
+        this.getFlowIdsFromObjectConditions.search({
+          models,
+          flowObjectFilterGrouped: flowObjectFiltersGrouped,
+          candidates: intersectCandidates,
+        });
+      didFlowsFromObjectFiltersPromiseCreated = true;
+    }
+    const flowsFromObjectFilters = await flowsFromObjectFiltersPromise;
+
+    const orderByForFlow = mapFlowOrderBy(orderBy);
+
+    // Fetch sorted flow IDs only for the filtered subset instead of the whole table
+    if (isSortByEntity) {
+      // Get entity-sorted IDs then intersect with filtered subset
+      sortByFlowIDsPromise = this.flowService.getFlowIDsFromEntity(
+        models,
+        orderBy
+      );
+    } else {
+      // Let the DB sort only the filtered IDs
+      sortByFlowIDsPromise = this.flowService.getFlows({
+        models,
+        conditions: {
+          id: {
+            [models.Op.IN]: intersectSets(
+              intersectCandidates,
+              new Set(flowsFromObjectFilters.flows.map((f) => f.id))
+            ),
+          },
+        },
+        orderBy: orderByForFlow,
+      });
+    }
+    const sortByFlowIDs = await sortByFlowIDsPromise;
+
     // First check if we have created the promises
     // and if so, check if the flows are empty
     // If they are empty, we can return an empty array