feat: support PII in Set and Map

src/__tests__/unwrapObject.spec.ts

@@ -33,15 +33,24 @@ describe("unwrapObject", () => {
     })
   })
 
-  it("should ignore Map", () => {
-    const map = new Map()
+  it("should handle Map", () => {
+    const map = new Map([["a", 1]])
 
     expect(unwrapObject({ test: map, two: PII(2) })).toEqual({
       test: map,
       two: 2,
     })
   })
 
+  it("should handle Set", () => {
+    const set = new Set(["a", "b"])
+
+    expect(unwrapObject({ test: set, two: PII(2) })).toEqual({
+      test: set,
+      two: 2,
+    })
+  })
+
   it("should ignore weird Numbers", () => {
     const num = new Number(1)
 

src/pii.ts

@@ -92,11 +92,12 @@ const isObject = (value: unknown): boolean => {
   return value != null && (type == "object" || type == "function")
 }
 
-// Does not handle Set or Map for now.
 export const visitPII = <A, T>(
   input: A,
   visitors: {
     record: (value: Record<string, unknown>) => T
+    map: (value: Map<unknown, unknown>) => T
+    set: (value: Set<unknown>) => T
     object: (value: unknown) => T
     array: (value: Array<unknown>) => T
     primitive: (value: A) => T
@@ -110,6 +111,14 @@ export const visitPII = <A, T>(
     return visitors.array(input)
   }
 
+  if (input instanceof Map) {
+    return visitors.map(input)
+  }
+
+  if (input instanceof Set) {
+    return visitors.set(input)
+  }
+
   if (isObject(input)) {
     return visitors.object(input)
   }
@@ -122,7 +131,10 @@ export const containsPII = (input: unknown): boolean =>
     ? true
     : visitPII(input, {
         record: o => Object.values(o).some(containsPII),
+        map: m =>
+          Array.from(m).some(([k, v]) => containsPII(k) || containsPII(v)),
         array: a => a.some(containsPII),
+        set: s => Array.from(s).some(containsPII),
         primitive: p => isPIIType(p),
         object: p => isPIIType(p),
       })
@@ -134,7 +146,12 @@ export const unwrapObject = (input: unknown): unknown =>
         sum[key] = unwrapObject(o[key])
         return sum
       }, {} as Record<string, unknown>),
+    map: m =>
+      new Map(
+        Array.from(m).map(([k, v]) => [unwrapObject(k), unwrapObject(v)]),
+      ),
     array: a => a.map(unwrapObject),
+    set: s => new Set(Array.from(s).map(unwrapObject)),
     primitive: p => p,
     object: p => p,
   })