(fix) Scope concept-only fallback in findObsByFormField to respect obsGroup boundaries

Author: oisujeh

src/adapters/obs-adapter.test.ts

@@ -1086,6 +1086,110 @@ describe('findObsByFormField', () => {
     expect(matchedObs.length).toBe(1);
     expect(matchedObs[0]).toBe(obsList[3]);
   });
+
+  it('Should scope concept fallback to the parent obsGroup when field has a groupId', () => {
+    // Scenario: A form has two obsGroups — "Blood Tests" and "Urine Tests" — whose
+    // child fields share the same "Result Value" concept. When editing an encounter
+    // that only has Urine Test data, the Blood Test child field should NOT steal the
+    // Urine Test obs via concept fallback.
+    const resultValueConcept = 'shared-result-value-concept-uuid';
+
+    const bloodTestResultField: FormField = {
+      label: 'Blood Test Result',
+      type: 'obs',
+      questionOptions: { rendering: 'number', concept: resultValueConcept },
+      id: 'blood_test_result',
+      meta: { groupId: 'bloodTestGroup' },
+    };
+
+    const urineResultObs = {
+      uuid: 'urine-result-obs-uuid',
+      concept: { uuid: resultValueConcept },
+      formFieldNamespace: 'rfe-forms',
+      formFieldPath: 'rfe-forms-urine_test_result',
+    };
+
+    const urineGroupObs = {
+      uuid: 'urine-group-obs-uuid',
+      concept: { uuid: 'urine-group-concept' },
+      formFieldNamespace: 'rfe-forms',
+      formFieldPath: 'rfe-forms-urineTestGroup',
+      groupMembers: [urineResultObs],
+    };
+
+    const flatObs = [urineGroupObs, urineResultObs];
+
+    // Blood test field should NOT match the urine test obs
+    const matched = findObsByFormField(flatObs, [], bloodTestResultField);
+    expect(matched.length).toBe(0);
+  });
+
+  it('Should allow concept fallback within the correct parent obsGroup', () => {
+    const resultValueConcept = 'shared-result-value-concept-uuid';
+
+    const urineResultField: FormField = {
+      label: 'Urine Test Result',
+      type: 'obs',
+      questionOptions: { rendering: 'number', concept: resultValueConcept },
+      id: 'urine_test_result_v2',  // different ID so path match fails
+      meta: { groupId: 'urineTestGroup' },
+    };
+
+    const urineResultObs = {
+      uuid: 'urine-result-obs-uuid',
+      concept: { uuid: resultValueConcept },
+      formFieldNamespace: 'rfe-forms',
+      formFieldPath: 'rfe-forms-urine_test_result',  // doesn't match field ID
+    };
+
+    const urineGroupObs = {
+      uuid: 'urine-group-obs-uuid',
+      concept: { uuid: 'urine-group-concept' },
+      formFieldNamespace: 'rfe-forms',
+      formFieldPath: 'rfe-forms-urineTestGroup',
+      groupMembers: [urineResultObs],
+    };
+
+    const flatObs = [urineGroupObs, urineResultObs];
+
+    // Urine result field SHOULD match via concept fallback (correct group)
+    const matched = findObsByFormField(flatObs, [], urineResultField);
+    expect(matched.length).toBe(1);
+    expect(matched[0]).toBe(urineResultObs);
+  });
+
+  it('Should preserve backward compatibility when parent obsGroup has no formFieldPath', () => {
+    const resultValueConcept = 'shared-result-value-concept-uuid';
+
+    const childField: FormField = {
+      label: 'Test Result',
+      type: 'obs',
+      questionOptions: { rendering: 'number', concept: resultValueConcept },
+      id: 'test_result',
+      meta: { groupId: 'labTestGroup' },
+    };
+
+    const resultObs = {
+      uuid: 'result-obs-uuid',
+      concept: { uuid: resultValueConcept },
+      formFieldNamespace: 'rfe-forms',
+      formFieldPath: 'rfe-forms-old_field_id',
+    };
+
+    // Parent group saved from an older form version without formFieldPath
+    const groupObs = {
+      uuid: 'group-obs-uuid',
+      concept: { uuid: 'group-concept' },
+      groupMembers: [resultObs],
+    };
+
+    const flatObs = [groupObs, resultObs];
+
+    // No formFieldPath on parent → backward compat → allow fallback
+    const matched = findObsByFormField(flatObs, [], childField);
+    expect(matched.length).toBe(1);
+    expect(matched[0]).toBe(resultObs);
+  });
 });
 
 describe('ObsAdapter - handling nested obsGroups', () => {

src/adapters/obs-adapter.ts

@@ -268,6 +268,11 @@ function handleAttachments(field: FormField, attachments: Attachment[] = []) {
  * Notes:
  * If the query by field-path returns an empty list, the function falls back to querying
  * by concept and uses `claimedObsIds` to exclude already assigned observations.
+ *
+ * When the field belongs to an obsGroup (i.e. `field.meta.groupId` is set), the concept
+ * fallback is scoped to observations that are members of the matching parent obsGroup.
+ * This prevents child obs from one obsGroup from being incorrectly assigned to fields
+ * in a different obsGroup that happens to share the same concept.
  */
 export function findObsByFormField(
   obsList: Array<OpenmrsObs>,
@@ -287,7 +292,31 @@ export function findObsByFormField(
   // We shall fall back to mapping by the associated concept
   // That being said, we shall find all matching obs and pick the one that wasn't previously claimed.
   if (!obs?.length) {
-    const obsByConcept = obsList.filter((obs) => obs.concept.uuid == field.questionOptions.concept);
+    let obsByConcept = obsList.filter((obs) => obs.concept.uuid == field.questionOptions.concept);
+
+    // If this field belongs to an obsGroup, restrict the concept fallback to
+    // respect obsGroup boundaries.  For each candidate obs we check whether it
+    // is a member of any obsGroup in the encounter.  Three cases:
+    //   1. The obs is standalone (not in any group) → allow (normal fallback).
+    //   2. The obs is in a group whose formFieldPath matches the expected
+    //      parent → allow (correct group).
+    //   3. The obs is in a group with a *different* formFieldPath → exclude
+    //      (prevents cross-group concept bleeding, e.g. PrEP → ARV).
+    //   4. The obs is in a group that has no formFieldPath (old encounter) →
+    //      allow (backward compatibility).
+    if (field.meta?.groupId) {
+      const parentPath = `rfe-forms-${field.meta.groupId}`;
+      obsByConcept = obsByConcept.filter((candidate) => {
+        // Find the obsGroup that owns this candidate (if any)
+        const ownerGroup = obsList.find(
+          (o) => o.groupMembers?.some((m) => m.uuid === candidate.uuid),
+        );
+        if (!ownerGroup) return true;                       // case 1: standalone
+        if (!ownerGroup.formFieldPath) return true;         // case 4: old encounter
+        return ownerGroup.formFieldPath == parentPath;      // case 2 or 3
+      });
+    }
+
     return claimedObsIds?.length ? obsByConcept.filter((obs) => !claimedObsIds.includes(obs.uuid)) : obsByConcept;
   }