fix(resolvers): ignored priorities no longer discard all EIDs in multi-node targeting

lib/core/resolvers/resolveMultiTargeting.test.ts

@@ -281,6 +281,61 @@ describe("resolveMultiNodeTargeting", () => {
     expect(eidSources).toEqual(new Set<string>([]));
   });
 
+  test("ignored priorities do not discard eids from valid priorities", async () => {
+    const mockTargetingFnOne = new Promise<TargetingResponse>((resolve) => {
+      resolve(
+        createTargetingResponse({
+          eids: [{ inserter: "optable.co", source: "one.com", uids: [{ id: "uid1" }] }],
+          resolved_ids: ["id_one"],
+        })
+      );
+    });
+
+    const mockTargetingFnTwo = new Promise<TargetingResponse>((resolve) => {
+      resolve(
+        createTargetingResponse({ eids: [{ inserter: "optable.co", source: "two.com", uids: [{ id: "uid2" }] }] })
+      );
+    });
+
+    const mockTargetingFnUnset = new Promise<TargetingResponse>((resolve) => {
+      resolve(
+        createTargetingResponse({ eids: [{ inserter: "optable.co", source: "unset.com", uids: [{ id: "uid3" }] }] })
+      );
+    });
+
+    const mockTargetingFnNegative = new Promise<TargetingResponse>((resolve) => {
+      resolve(
+        createTargetingResponse({ eids: [{ inserter: "optable.co", source: "negative.com", uids: [{ id: "uid4" }] }] })
+      );
+    });
+
+    const configs = [
+      { targetingFn: () => mockTargetingFnOne, matcher: "matcher_one", mm: IDMatchMethod.AUTHENTICATED, priority: 1 },
+      { targetingFn: () => mockTargetingFnTwo, matcher: "matcher_two", mm: IDMatchMethod.INFERENCE, priority: 2 },
+      { targetingFn: () => mockTargetingFnUnset, matcher: "matcher_unset", mm: IDMatchMethod.INFERENCE },
+      {
+        targetingFn: () => mockTargetingFnNegative,
+        matcher: "matcher_negative",
+        mm: IDMatchMethod.INFERENCE,
+        priority: -1,
+      },
+    ];
+
+    const { ortb2, eidSources, resolvedIds } = await resolveMultiNodeTargeting(configs);
+
+    expect(ortb2.user!.eids).toEqual([
+      {
+        inserter: "optable.co",
+        matcher: "matcher_one",
+        mm: IDMatchMethod.AUTHENTICATED,
+        source: "one.com",
+        uids: [{ id: "uid1" }],
+      },
+    ]);
+    expect(eidSources).toEqual(new Set<string>(["matcher_one"]));
+    expect(resolvedIds).toEqual(new Set<string>(["id_one"]));
+  });
+
   it("Should use matcher from response if provided on aggregate", async () => {
     const mockTargetingFnOne = new Promise<TargetingResponse>((resolve) => {
       resolve(

lib/core/resolvers/resolveMultiTargeting.ts

@@ -16,7 +16,8 @@ type NodeTargetingRule = {
   // 0 = unknown, 1 = no_match, 2 = cookie_sync, 3 = authenticated, 4 = observed, 5 = inference.
   mm?: IDMatchMethod;
   // (Optional) If provided we will only pick one resolved Ortb2Response from the most prioritize matcher.
-  // Any values below 1 will be threated as ignore
+  // Any non-zero priority on any rule switches to priority mode, where rules with no priority
+  // or a priority below 1 never supply eids. 0 alone counts as no priority.
   priority?: number;
 };
 
@@ -122,12 +123,15 @@ async function resolvePriorityTargeting(rules: NodeTargetingRule[]): Promise<Mul
 
   await Promise.allSettled(targetingFnPromises);
 
+  // Only reached in priority mode, i.e. some rule has a non-zero priority (see
+  // resolveMultiNodeTargeting). Here, rules with no priority or a priority below 1
+  // never supply eids, so their bucket must not be selected.
   const priority = Array.from(eidsByPriority.keys())
+    .filter((x) => x >= 1 && eidsByPriority.get(x)?.length)
     .sort((a, b) => a - b)
-    .filter((x) => eidsByPriority.get(x)?.length)
     .shift();
 
-  if (priority) {
+  if (priority !== undefined) {
     const sources = sourcesByPriority.get(priority) || [];
     const resolvedIdsArray = resolvedIdsByPriority.get(priority) || [];
     ortb2.user!.eids!.push(...(eidsByPriority.get(priority) || []));