AUT-5433: Add enhanced consistency checks

This code, along with the rest of the dual session store, will be torn down and deleted once the migration is completed.

Author: sw-mattw

src/config/dual-session-store.ts

@@ -189,11 +189,16 @@ export class DualSessionStore extends Store {
       if (
         !isDeepStrictEqual(primarySession ?? null, secondarySession ?? null)
       ) {
+        const mismatchDetails = this.getKeyDiffs(
+          primarySession,
+          secondarySession
+        );
         logger.warn(
           {
             sid,
             primaryExists: !!primarySession,
             secondaryExists: !!secondarySession,
+            mismatchDetails,
           },
           "Session consistency mismatch"
         );
@@ -202,4 +207,67 @@ export class DualSessionStore extends Store {
       logger.warn({ err }, "Error performing session store consistency checks");
     }
   }
+
+  private getKeyDiffs(
+    primary: SessionData | null,
+    secondary: SessionData | null
+  ): {
+    keysOnlyInPrimary: string[];
+    keysOnlyInSecondary: string[];
+    keysDiffering: string[];
+  } {
+    const primaryKeys = primary ? Object.keys(primary) : [];
+    const secondaryKeys = secondary ? Object.keys(secondary) : [];
+    const allKeys = Array.from(new Set(primaryKeys.concat(secondaryKeys)));
+
+    const keysOnlyInPrimary: string[] = [];
+    const keysOnlyInSecondary: string[] = [];
+    const keysDiffering: string[] = [];
+
+    for (const key of allKeys) {
+      const inPrimary = primary && key in primary;
+      const inSecondary = secondary && key in secondary;
+
+      if (inPrimary && !inSecondary) {
+        keysOnlyInPrimary.push(key);
+      } else if (!inPrimary && inSecondary) {
+        keysOnlyInSecondary.push(key);
+      } else if (
+        !isDeepStrictEqual(
+          primary[key as keyof SessionData],
+          secondary[key as keyof SessionData]
+        )
+      ) {
+        const subDiffs = this.getDifferingPaths(
+          primary[key as keyof SessionData],
+          secondary[key as keyof SessionData],
+          key
+        );
+        keysDiffering.push(...subDiffs);
+      }
+    }
+
+    return { keysOnlyInPrimary, keysOnlyInSecondary, keysDiffering };
+  }
+
+  private getDifferingPaths(a: unknown, b: unknown, prefix: string): string[] {
+    if (
+      a &&
+      b &&
+      typeof a === "object" &&
+      typeof b === "object" &&
+      !Array.isArray(a) &&
+      !Array.isArray(b)
+    ) {
+      const aObj = a as Record<string, unknown>;
+      const bObj = b as Record<string, unknown>;
+      const keys = Array.from(
+        new Set(Object.keys(aObj).concat(Object.keys(bObj)))
+      );
+      return keys
+        .filter((k) => !isDeepStrictEqual(aObj[k], bObj[k]))
+        .map((k) => `${prefix}.${k}`);
+    }
+    return [prefix];
+  }
 }

test/unit/dual-session-store.test.ts

@@ -342,5 +342,27 @@ describe("DualSessionStore", () => {
         setTimeout(done, 10);
       });
     });
+
+    it("should safely handle key diffs with missing keys and nested differences", (done) => {
+      const primarySession = {
+        cookie: { originalMaxAge: 3600000 },
+        user: { id: 7777, role: "admin" },
+        token: "tokenValueOnlyInPrimary",
+      } as unknown as SessionData;
+      const secondarySession = {
+        cookie: { originalMaxAge: 9999 },
+        user: { id: 7777, role: "user" },
+        extra: "extraValueOnlyInSecondary",
+      } as unknown as SessionData;
+      primary.get = sinon.fake((_sid, cb) => cb(null, primarySession));
+      secondary.get = sinon.fake((_sid, cb) => cb(null, secondarySession));
+      store = new DualSessionStore(primary, secondary, "Redis", "DynamoDB");
+
+      store.get(sid, (err, sess) => {
+        expect(err).to.be.null;
+        expect(sess).to.deep.equal(primarySession);
+        setTimeout(done, 10);
+      });
+    });
   });
 });