refactor: Use JSON.stringify replacer

Author: davidkna-sap

packages/connectivity/src/scp-cf/cache.spec.ts

@@ -1,4 +1,4 @@
-import { Cache } from './cache';
+import { Cache, hashCacheKey } from './cache';
 import { clientCredentialsTokenCache } from './client-credentials-token-cache';
 import { destinationCache } from './destination';
 import type { AuthenticationType, Destination } from './destination';
@@ -152,6 +152,54 @@ describe('Cache', () => {
     });
   });
 
+  describe('hashCacheKey', () => {
+    it('produces the same hash for plain objects with different key insertion order', () => {
+      expect(hashCacheKey({ a: 1, b: 2 })).toEqual(
+        hashCacheKey({ b: 2, a: 1 })
+      );
+    });
+
+    it('produces different hashes for plain objects with different values', () => {
+      expect(hashCacheKey({ a: 1 })).not.toEqual(hashCacheKey({ a: 2 }));
+    });
+
+    it('produces the same hash for Maps with different insertion order', () => {
+      const m1 = new Map([
+        ['x', 1],
+        ['y', 2]
+      ]);
+      const m2 = new Map([
+        ['y', 2],
+        ['x', 1]
+      ]);
+      expect(hashCacheKey({ m: m1 })).toEqual(hashCacheKey({ m: m2 }));
+    });
+
+    it('produces the same hash for Sets with different insertion order', () => {
+      const s1 = new Set([1, 2, 3]);
+      const s2 = new Set([3, 1, 2]);
+      expect(hashCacheKey({ s: s1 })).toEqual(hashCacheKey({ s: s2 }));
+    });
+
+    it('produces the same hash for class instances regardless of property insertion order', () => {
+      class Point {
+        [key: string]: number;
+      }
+      const p1 = new Point();
+      p1.y = 2;
+      p1.x = 1;
+      const p2 = new Point();
+      p2.x = 1;
+      p2.y = 2;
+      expect(hashCacheKey({ p: p1 })).toEqual(hashCacheKey({ p: p2 }));
+    });
+    it('preserves arrays as arrays (does not coerce to object)', () => {
+      expect(hashCacheKey({ arr: [1, 2, 3] })).not.toEqual(
+        hashCacheKey({ arr: { 0: 1, 1: 2, 2: 3 } })
+      );
+    });
+  });
+
   describe('getOrInsertComputed', () => {
     it('calls computeFn on cache miss and stores result', () => {
       const compute = jest.fn().mockReturnValue({ entry: destinationOne });

packages/connectivity/src/scp-cf/cache.ts

@@ -149,14 +149,54 @@ export class Cache<T> implements CacheInterface<T> {
   }
 }
 
+/**
+ * Stringifies a given object in a deterministic way, so that the same objects always yield the same string representation.
+ * @param toSerialize - The object to stringify.
+ * @returns A string representation of the given object.
+ */
+function stringifyJsonSafe(toSerialize: Record<string, unknown>): string {
+  return JSON.stringify(toSerialize, (_key, value) => {
+    if (value instanceof Map) {
+      return [
+        ['dataType', 'Map'],
+        ['value', Array.from(value.entries()).sort()]
+      ];
+    }
+    if (value instanceof Set) {
+      return [
+        ['dataType', 'Set'],
+        ['value', Array.from(value.values()).sort()]
+      ];
+    }
+    if (typeof value === 'function') {
+      return [
+        ['dataType', 'Function'],
+        ['value', value.toString()]
+      ];
+    }
+    if (value instanceof Object && !Array.isArray(value)) {
+      return [
+        ['dataType', 'Object'],
+        [
+          'value',
+          Object.entries(value).sort(([keyA], [keyB]) =>
+            keyA.localeCompare(keyB)
+          )
+        ]
+      ];
+    }
+    return value;
+  });
+}
+
 /**
  * Hashes the given value to create a cache key.
  * @internal
  * @param value - The value to hash.
  * @returns A hash of the given value using a cryptographic hash function.
  */
 export function hashCacheKey(value: Record<string, unknown>): string {
-  const serialized = JSON.stringify(value);
+  const serialized = stringifyJsonSafe(value);
   return createHash('blake2s256').update(serialized).digest('hex');
 }