Merge pull request #493 from UN-OCHA/env/stage

🚀 Release `v4.11.3` and deploy to production

Author: Onitoxan

package.json

@@ -1,6 +1,6 @@
 {
   "name": "hpc-api",
-  "version": "4.11.2-hotfix-1",
+  "version": "4.11.3",
   "description": "api for HPC applications",
   "main": "src/server.ts",
   "license": "MIT",
@@ -36,15 +36,15 @@
     "@types/bunyan": "^1.8.11",
     "@types/hapi__hapi": "^20.0.9",
     "@types/jest": "^30.0.0",
-    "@types/node": "^24.6.2",
-    "@types/pg": "^8.15.5",
+    "@types/node": "^24.10.0",
+    "@types/pg": "^8.15.6",
     "@unocha/hpc-repo-tools": "^8.0.0",
-    "eslint": "9.36.0",
+    "eslint": "9.39.1",
     "husky": "^9.1.7",
     "jest": "^30.2.0",
-    "lint-staged": "^16.2.3",
+    "lint-staged": "^16.2.6",
     "prettier": "3.6.2",
-    "ts-jest": "^29.4.4",
+    "ts-jest": "^29.4.5",
     "ts-node-dev": "^2.0.0"
   },
   "engines": {

src/domain-services/flow-object/flow-object-service.ts

@@ -9,11 +9,9 @@ import type {
   FieldsOfModel,
   InstanceOfModel,
 } from '@unocha/hpc-api-core/src/db/util/types';
-import { createBrandedValue } from '@unocha/hpc-api-core/src/util/types';
+import { groupObjectsByProperty } from '@unocha/hpc-api-core/src/util';
 import { Service } from 'typedi';
 import { type UniqueFlowEntity } from '../flows/model';
-import { type FlowObjectFilterGrouped } from './model';
-import { buildWhereConditionsForFlowObjectFilters } from './utils';
 
 // Local types definition to increase readability
 type FlowObjectModel = Database['flowObject'];
@@ -23,36 +21,36 @@ export type FlowObjectOrderByCond = OrderByCond<FlowObjectsFieldsDefinition>;
 export type FlowObjectWhere = Condition<FlowObjectInstance>;
 @Service()
 export class FlowObjectService {
-  // Merge with getFlowsObjectsByFlows
-  async getFlowIdsFromFlowObjects(
-    models: Database,
-    where: FlowObjectWhere
-  ): Promise<FlowId[]> {
-    const flowObjects = await models.flowObject.find({
-      where,
-    });
-    // Keep only not duplicated flowIDs
-    return [...new Set(flowObjects.map((flowObject) => flowObject.flowID))];
-  }
-
+  /**
+   * Get flows given flowObjects `OR` conditions and the number of conditions.
+   * This will return only flows that match all the conditions.
+   */
   async getFlowFromFlowObjects(
     models: Database,
-    where: FlowObjectWhere
+    where: FlowObjectWhere,
+    numberOfConditions: number
   ): Promise<UniqueFlowEntity[]> {
     const flowObjects = await models.flowObject.find({
       where,
     });
-    // Keep only not duplicated flowIDs
-    return [
-      ...new Set(
-        flowObjects.map((flowObject) => {
-          return {
-            id: createBrandedValue(flowObject.flowID),
-            versionID: flowObject.versionID,
-          };
-        })
-      ),
-    ];
+    const uniqueFlows: UniqueFlowEntity[] = [];
+
+    // Group by flowID
+    const flowIDGroups = groupObjectsByProperty(flowObjects, 'flowID');
+
+    for (const [flowID, flowGroup] of flowIDGroups.entries()) {
+      // Group each flowGroup by versionID
+      const versionIDGroups = groupObjectsByProperty(flowGroup, 'versionID');
+
+      for (const [versionID, objs] of versionIDGroups.entries()) {
+        if (objs.length === numberOfConditions) {
+          // Only add the flowID+versionID if all conditions are met
+          uniqueFlows.push({ id: flowID, versionID });
+        }
+      }
+    }
+
+    return uniqueFlows;
   }
 
   async getFlowObjectByFlowId(
@@ -72,39 +70,4 @@ export class FlowObjectService {
       },
     });
   }
-
-  async getFlowObjectsByFlowObjectConditions(
-    models: Database,
-    flowObjectFilterGrouped: FlowObjectFilterGrouped
-  ): Promise<FlowObjectInstance[]> {
-    const whereClause = buildWhereConditionsForFlowObjectFilters(
-      flowObjectFilterGrouped
-    );
-
-    return await models.flowObject.find({ where: whereClause });
-  }
-
-  async getFlowsObjectsByFlows(
-    models: Database,
-    whereClauses: FlowObjectWhere,
-    orderBy?: FlowObjectOrderByCond
-  ): Promise<FlowObjectInstance[]> {
-    const distinctColumns: Array<keyof FlowObjectInstance> = [
-      'flowID',
-      'versionID',
-    ];
-
-    if (orderBy) {
-      distinctColumns.push(orderBy.column);
-      distinctColumns.reverse();
-    }
-
-    const flowsObjects: FlowObjectInstance[] = await models.flowObject.find({
-      orderBy,
-      where: whereClauses,
-      distinct: distinctColumns,
-    });
-
-    return flowsObjects;
-  }
 }

src/domain-services/flow-object/utils.ts

@@ -3,11 +3,9 @@ import { type FlowObjectWhere } from './flow-object-service';
 import { type FlowObjectFilterGrouped } from './model';
 
 /**
- *  This alg iterates over the flowObjectFilters and creates a join for each flowObjectType
- *  and refDirection allowing to filter the flowObjects by the flowObjectType and refDirection
- * inclusivelly for each
- * @param flowObjectFiltersGrouped
- * @returns FlowObjectWhere
+ * Build where conditions for flow object filters as `OR` conditions.
+ * (This is done because we cannot have `AND` conditions on different values of the same column
+ * or use joiners)
  */
 export function buildWhereConditionsForFlowObjectFilters(
   flowObjectFiltersGrouped: FlowObjectFilterGrouped
@@ -16,18 +14,14 @@ export function buildWhereConditionsForFlowObjectFilters(
   for (const [flowObjectType, group] of flowObjectFiltersGrouped.entries()) {
     for (const [direction, ids] of group.entries()) {
       const condition = {
-        [Cond.AND]: [
-          {
-            objectType: flowObjectType,
-            refDirection: direction,
-            objectID: { [Op.IN]: ids },
-          },
-        ],
+        objectType: flowObjectType,
+        refDirection: direction,
+        objectID: { [Op.IN]: ids },
       };
 
       ANDConditions.push(condition);
     }
   }
 
-  return { [Cond.AND]: ANDConditions };
+  return { [Cond.OR]: ANDConditions };
 }

src/domain-services/flows/flow-service.ts

@@ -490,96 +490,43 @@ export class FlowService {
     return mappedParkedParentOrganizations;
   }
 
-  async getParkedParentFlowsByFlowObjectFilter(
+  /**
+   * (All parents are considered `parked`, if they are not parked, it means there is corruption in the data)
+   */
+  async getParkedParentsChildrenByFlowObjectFilter(
     models: Database,
     flowObjectFilters: FlowObjectFilterGrouped
   ): Promise<UniqueFlowEntity[]> {
-    // 1. Retrieve the parked category
-    const parkedCategory = await models.category.findOne({
-      where: {
-        name: 'Parked',
-        group: 'flowType',
-      },
-    });
-    if (!parkedCategory) {
-      throw new Error('Parked category not found');
-    }
+    // 1. Create where conditions from flow object filters
+    const flowObjectsWhere =
+      buildWhereConditionsForFlowObjectFilters(flowObjectFilters);
 
-    // 2. Get all category references for parked flows
-    const categoryRefs = await models.categoryRef.find({
-      where: {
-        categoryID: parkedCategory.id,
-        objectType: 'flow',
-      },
-      distinct: ['objectID', 'versionID'],
-    });
+    // 2. Extract number of conditions from flow object filters
+    const numberOfConditions = flowObjectFilters
+      .values()
+      .flatMap((m) => [...m.values()])
+      .toArray()
+      .flat().length;
 
-    // Build list of parent IDs from categoryRefs
-    const parentIDs: FlowId[] = categoryRefs.map((ref) =>
-      createBrandedValue(ref.objectID)
+    // 3. Retrieve flow objects matching the conditions
+    const flowObjects = await this.flowObjectService.getFlowFromFlowObjects(
+      models,
+      flowObjectsWhere,
+      numberOfConditions
     );
 
-    // 3. Retrieve flow links where the parent is among those references and depth > 0
+    // 4. Retrieve flow links where the parent is among those references and depth > 0
     const flowLinks = await models.flowLink.find({
       where: {
         depth: { [Op.GT]: 0 },
-        parentID: { [Op.IN]: parentIDs },
+        parentID: {
+          [Op.IN]: flowObjects.map((fo) => createBrandedValue(fo.id)),
+        },
       },
       distinct: ['parentID', 'childID'],
     });
-
-    // Create a reference list of parent flows from the flow links
-    const parentFlowsRef: UniqueFlowEntity[] = flowLinks.map((flowLink) => ({
-      id: flowLink.parentID,
-      versionID: null,
-    }));
-
-    // 4. Query parent flows progressively in chunks
-    const parentFlows = await this.progresiveSearch(
-      models,
-      parentFlowsRef,
-      1000,
-      0,
-      false, // Do not stop on batch size
-      [],
-      { activeStatus: true }
-    );
-
-    // 5. Retrieve flow objects using the flow object filters
-    const flowObjectsWhere =
-      buildWhereConditionsForFlowObjectFilters(flowObjectFilters);
-    const flowObjects = await this.flowObjectService.getFlowFromFlowObjects(
-      models,
-      flowObjectsWhere
-    );
-
-    // 6. Build a Set for flowObjects for fast lookup (using a composite key of id and versionID)
-    const flowObjectsSet = new Set(
-      flowObjects.map(
-        (flowObject) => `${flowObject.id}|${flowObject.versionID}`
-      )
-    );
-
-    // 7. Filter parent flows that are present in the flowObjects list
-    const filteredParentFlows = parentFlows.filter((parentFlow) => {
-      const key = `${parentFlow.id}|${parentFlow.versionID}`;
-      return flowObjectsSet.has(key);
-    });
-
-    // 8. Build a Set of filtered parent flow IDs for quick membership checking
-    const filteredParentFlowIds = new Set(
-      filteredParentFlows.map((flow) => flow.id)
-    );
-
-    // 9. Extract child flow IDs from flowLinks where the parent is in the filtered set
-    const childFlowsIDsSet = new Set<FlowId>();
-    for (const flowLink of flowLinks) {
-      if (filteredParentFlowIds.has(flowLink.parentID)) {
-        childFlowsIDsSet.add(flowLink.childID);
-      }
-    }
-
-    // 10. Retrieve child flows
+    const childFlowsIDsSet = new Set<FlowId>(flowLinks.map((fl) => fl.childID));
+    // 5. Retrieve child flows that are active
     const childFlows = await models.flow.find({
       where: {
         activeStatus: true,
@@ -588,13 +535,14 @@ export class FlowService {
       distinct: ['id', 'versionID'],
     });
 
-    // 11. Map child flows to UniqueFlowEntity and return the result
-    const result = childFlows.map((ref) => ({
-      id: ref.id,
-      versionID: ref.versionID,
-    }));
-
-    return result;
+    // 6. Map child flows to UniqueFlowEntity and return the result
+    return childFlows.map(
+      (ref) =>
+        ({
+          id: ref.id,
+          versionID: ref.versionID,
+        }) satisfies UniqueFlowEntity
+    );
   }
 
   /**