Store promises for other entities filters

manelcecs · manelcecs · commit 709d65fefa1d · 2025-05-30T10:18:42.000+02:00
This allow to handle all request at the same time

Which helps with the time-performance of the endpoint
diff --git a/src/domain-services/flows/strategy/impl/search-flow-by-filters-strategy-impl.ts b/src/domain-services/flows/strategy/impl/search-flow-by-filters-strategy-impl.ts
@@ -1,4 +1,5 @@
 import { Service } from 'typedi';
+import { FlowObjectFilterGrouped } from '../../../flow-object/model';
 import { FlowService } from '../../flow-service';
 import type { FlowWhere, UniqueFlowEntity } from '../../model';
 import type {
@@ -18,6 +19,7 @@ import {
   parseFlowIdVersionSet,
   prepareFlowConditions,
   prepareFlowStatusConditions,
+  stringifyFlowIdVersionArray,
 } from './utils';
 
 @Service()
@@ -50,47 +52,37 @@ export class SearchFlowByFiltersStrategy implements FlowSearchStrategy {
     // to be able to sort the flows using the entity
     const isSortByEntity = orderBy && orderBy.entity !== 'flow';
     let sortByFlowIDsSet = new Set<string>();
+    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
-      const sortByFlowIDs = await this.flowService.getFlowIDsFromEntity(
+      sortByFlowIDsPromise = this.flowService.getFlowIDsFromEntity(
         models,
         orderBy
       );
-      sortByFlowIDsSet = new Set(
-        [...sortByFlowIDs].map((o) => `${o.id}:${o.versionID}`)
-      );
     } else {
       // Let the DB sort only the filtered IDs
-      const sortByFlowIDs = await this.flowService.getFlows({
+      sortByFlowIDsPromise = this.flowService.getFlows({
         models,
         orderBy: orderByForFlow,
       });
-      sortByFlowIDsSet = new Set(
-        [...sortByFlowIDs].map((o) => `${o.id}:${o.versionID}`)
-      );
     }
     // We need to fetch the flowIDs by the nestedFlowFilters
     // if there are any
     const isFilterByNestedFilters = nestedFlowFilters !== undefined;
     let flowIDsFromNestedFlowFiltersSet = new Set<string>();
-
+    let flowsFromNestedFiltersPromise: Promise<FlowIdSearchStrategyResponse> =
+      Promise.resolve({ flows: [] });
+    let didFlowsFromNestedFiltersPromiseCreated = false;
     if (isFilterByNestedFilters) {
-      const { flows }: FlowIdSearchStrategyResponse =
-        await this.getFlowIdsFromNestedFlowFilters.search({
+      flowsFromNestedFiltersPromise =
+        this.getFlowIdsFromNestedFlowFilters.search({
           models,
           nestedFlowFilters,
         });
-
-      // If after this filter we have no flows, we can return an empty array
-      if (flows.length === 0) {
-        return { flows: [], count: 0 };
-      }
-      flowIDsFromNestedFlowFiltersSet = new Set(
-        [...flows].map((o) => `${o.id}:${o.versionID}`)
-      );
+      didFlowsFromNestedFiltersPromiseCreated = true;
     }
 
     // Now we need to check if we need to filter by category
@@ -103,67 +95,43 @@ export class SearchFlowByFiltersStrategy implements FlowSearchStrategy {
       isSearchByCategoryShotcut || flowCategoryFilters?.length > 0;
 
     let flowIDsFromCategoryFiltersSet = new Set<string>();
+    let flowsFromCategoryFiltersPromise: Promise<FlowIdSearchStrategyResponse> =
+      Promise.resolve({ flows: [] });
+    let didFlowsFromCategoryFiltersPromiseCreated = false;
 
     if (isFilterByCategory) {
-      const { flows }: FlowIdSearchStrategyResponse =
-        await this.getFlowIdsFromCategoryConditions.search({
+      flowsFromCategoryFiltersPromise =
+        this.getFlowIdsFromCategoryConditions.search({
           models,
           flowCategoryConditions: flowCategoryFilters ?? [],
           shortcutFilters,
         });
-
-      // If after this filter we have no flows, we can return an empty array
-      if (flows.length === 0) {
-        return { flows: [], count: 0 };
-      }
-
-      flowIDsFromCategoryFiltersSet = new Set(
-        [...flows].map((o) => `${o.id}:${o.versionID}`)
-      );
+      didFlowsFromCategoryFiltersPromiseCreated = true;
     }
 
     // After that, if we need to filter by flowObjects
     // Obtain the flowIDs from the flowObjects
     const isFilterByFlowObjects = flowObjectFilters?.length > 0;
 
     let flowIDsFromObjectFiltersSet = new Set<string>();
+    let flowsFromObjectFiltersPromise: Promise<FlowIdSearchStrategyResponse> =
+      Promise.resolve({ flows: [] });
+    let didFlowsFromObjectFiltersPromiseCreated = false;
+    let flowObjectFiltersGrouped: FlowObjectFilterGrouped | null = null;
 
     if (isFilterByFlowObjects) {
       // Firts 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
-      const flowObjectFiltersGrouped =
+      flowObjectFiltersGrouped =
         mapFlowFiltersToFlowObjectFiltersGrouped(flowObjectFilters);
 
-      const { flows: flowsFromObjectFilters }: FlowIdSearchStrategyResponse =
-        await this.getFlowIdsFromObjectConditions.search({
+      flowsFromObjectFiltersPromise =
+        this.getFlowIdsFromObjectConditions.search({
           models,
           flowObjectFilterGrouped: flowObjectFiltersGrouped,
         });
-
-      // If after this filter we have no flows, we can return an empty array
-      if (flowsFromObjectFilters.length === 0) {
-        return { flows: [], count: 0 };
-      }
-
-      // If 'includeChildrenOfParkedFlows' is defined and true
-      // we need to obtain the flowIDs from the childs whose parent flows are parked
-      if (shouldIncludeChildrenOfParkedFlows) {
-        // We need to obtain the flowIDs from the childs whose parent flows are parked
-        const childs =
-          await this.flowService.getParkedParentFlowsByFlowObjectFilter(
-            models,
-            flowObjectFiltersGrouped
-          );
-
-        for (const child of childs) {
-          flowsFromObjectFilters.push(child);
-        }
-      }
-
-      flowIDsFromObjectFiltersSet = new Set(
-        [...flowsFromObjectFilters].map((o) => `${o.id}:${o.versionID}`)
-      );
+      didFlowsFromObjectFiltersPromiseCreated = true;
     }
 
     // Lastly, we need to check if we need to filter by flow
@@ -173,6 +141,9 @@ export class SearchFlowByFiltersStrategy implements FlowSearchStrategy {
     const isFilterByFlowStatus = statusFilter !== undefined;
 
     let flowIDsFromFlowFiltersSet = new Set<string>();
+    let flowsFromFlowFiltersPromise: Promise<UniqueFlowEntity[]> =
+      Promise.resolve([]);
+    let didFlowsFromFlowFiltersPromiseCreated = false;
 
     if (isFilterByFlow || isFilterByFlowStatus) {
       let flowConditions: FlowWhere = prepareFlowConditions(flowFilters);
@@ -182,21 +153,90 @@ export class SearchFlowByFiltersStrategy implements FlowSearchStrategy {
         statusFilter
       );
 
-      const flows: UniqueFlowEntity[] = await this.flowService.getFlows({
+      flowsFromFlowFiltersPromise = this.flowService.getFlows({
         models,
         conditions: flowConditions,
       });
+      didFlowsFromFlowFiltersPromiseCreated = true;
+    }
 
-      // If after this filter we have no flows, we can return an empty array
-      if (flows.length === 0) {
-        return { flows: [], count: 0 };
-      }
+    // Now we need to wait for all the promises to be resolved
+    const [
+      flowsFromCategoryFilters,
+      flowsFromNestedFilters,
+      flowsFromObjectFilters,
+      flowsFromFlowFilters,
+      sortByFlowIDs,
+    ] = await Promise.all([
+      flowsFromCategoryFiltersPromise,
+      flowsFromNestedFiltersPromise,
+      flowsFromObjectFiltersPromise,
+      flowsFromFlowFiltersPromise,
+      sortByFlowIDsPromise,
+    ]);
 
-      flowIDsFromFlowFiltersSet = new Set(
-        [...flows].map((o) => `${o.id}:${o.versionID}`)
-      );
+    // 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
+    // and a count of 0
+    if (
+      didFlowsFromNestedFiltersPromiseCreated &&
+      flowsFromNestedFilters.flows.length === 0
+    ) {
+      return { flows: [], count: 0 };
     }
 
+    if (
+      didFlowsFromCategoryFiltersPromiseCreated &&
+      flowsFromCategoryFilters.flows.length === 0
+    ) {
+      return { flows: [], count: 0 };
+    }
+    if (
+      didFlowsFromObjectFiltersPromiseCreated &&
+      flowsFromObjectFilters.flows.length === 0
+    ) {
+      return { flows: [], count: 0 };
+    }
+
+    if (
+      didFlowsFromFlowFiltersPromiseCreated &&
+      flowsFromFlowFilters.length === 0
+    ) {
+      return { flows: [], count: 0 };
+    }
+
+    // Now we need to obtain the flowIDs from the flows filtering promises
+    flowIDsFromNestedFlowFiltersSet = stringifyFlowIdVersionArray(
+      flowsFromNestedFilters.flows
+    );
+    flowIDsFromCategoryFiltersSet = stringifyFlowIdVersionArray(
+      flowsFromCategoryFilters.flows
+    );
+
+    // If 'includeChildrenOfParkedFlows' is defined and true
+    // we need to obtain the flowIDs from the childs whose parent flows are parked
+    // if (shouldIncludeChildrenOfParkedFlows) {
+    // We need to obtain the flowIDs from the childs whose parent flows are parked
+    if (shouldIncludeChildrenOfParkedFlows && flowObjectFiltersGrouped) {
+      const childs =
+        await this.flowService.getParkedParentFlowsByFlowObjectFilter(
+          models,
+          flowObjectFiltersGrouped
+        );
+
+      for (const child of childs) {
+        flowsFromObjectFilters.flows.push(child);
+      }
+    }
+    flowIDsFromObjectFiltersSet = stringifyFlowIdVersionArray(
+      flowsFromObjectFilters.flows
+    );
+    flowIDsFromFlowFiltersSet =
+      stringifyFlowIdVersionArray(flowsFromFlowFilters);
+    // Lastly, we need to obtain the flowIDs from the sortByFlowIDs
+    sortByFlowIDsSet = stringifyFlowIdVersionArray(sortByFlowIDs);
+
     // We need to intersect the flowIDs from the flowObjects, flowCategoryFilters and flowFilters
     // to obtain the flowIDs that match all the filters
     const intersectedFlows: Set<string> = intersectSets(
@@ -209,13 +249,16 @@ export class SearchFlowByFiltersStrategy implements FlowSearchStrategy {
     if (intersectedFlows.size === 0) {
       return { flows: [], count: 0 };
     }
-    
+
     // The method Set.prototype.intersection(...) compares the bigger set with the smaller one
     // and returns the smaller one, so we need to do the opposite
     // More likely the `sortedFlows` will be smaller than the `intersectedFlows`,
     // since `intersectedFlows` is the intersection of all the filters
     // so we need to reverse the list of `sortedFlows`
-    const sortedFlows: Set<string> = intersectSets(intersectedFlows, sortByFlowIDsSet);
+    const sortedFlows: Set<string> = intersectSets(
+      intersectedFlows,
+      sortByFlowIDsSet
+    );
     const parsedSortedFlows = parseFlowIdVersionSet(sortedFlows).reverse();
 
     const count = sortedFlows.size;
diff --git a/src/domain-services/flows/strategy/impl/utils.ts b/src/domain-services/flows/strategy/impl/utils.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 { Cond, Op } from '@unocha/hpc-api-core/src/db/util/conditions';
 import type { InstanceDataOf } from '@unocha/hpc-api-core/src/db/util/model-definition';
 import { type InstanceOfModel } from '@unocha/hpc-api-core/src/db/util/types';
@@ -26,7 +27,6 @@ import type {
   FlowWhere,
   UniqueFlowEntity,
 } from '../../model';
-import { type FlowId } from '@unocha/hpc-api-core/src/db/models/flow';
 
 export const sortingColumnMapping: Map<string, string> = new Map<
   string,
@@ -438,13 +438,26 @@ export const buildOrderBy = (
  * Converts a Set of "id:versionID" strings into the array
  * of UniqueFlowEntity objects your existing search method expects.
  */
-export const parseFlowIdVersionSet = (idVersionSet: Set<string>): UniqueFlowEntity[] => {
+export const parseFlowIdVersionSet = (
+  idVersionSet: Set<string>
+): UniqueFlowEntity[] => {
   return [...idVersionSet].map((entry) => {
     const [idStr, versionStr] = entry.split(':');
     const id: FlowId = createBrandedValue(Number(idStr));
-    return ({
+    return {
       id,
       versionID: versionStr !== undefined ? Number(versionStr) : 0,
-    }) satisfies UniqueFlowEntity;
+    } satisfies UniqueFlowEntity;
   });
-}
+};
+
+/**
+ * Converts an array of UniqueFlowEntity objects into a Set of "id:versionID" strings.
+ */
+export const stringifyFlowIdVersionArray = (
+  flowEntities: UniqueFlowEntity[]
+): Set<string> => {
+  return new Set(
+    flowEntities.map((entity) => `${entity.id}:${entity.versionID}`)
+  );
+};
