refactor

Author: mtrezza

spec/MongoStorageAdapter.spec.js

@@ -1031,9 +1031,9 @@ describe_only_db('mongo')('MongoStorageAdapter', () => {
       await adapter.handleShutdown();
     });
 
-    it('should handle circular references with fallback warning', async () => {
+    it('should handle circular references gracefully', async () => {
       const logger = require('../lib/logger').logger;
-      const warnSpy = spyOn(logger, 'warn');
+      const infoSpy = spyOn(logger, 'info');
 
       const logClientEvents = [
         {
@@ -1055,9 +1055,9 @@ describe_only_db('mongo')('MongoStorageAdapter', () => {
 
       adapter.client.emit('circularEvent', mockEvent);
 
-      // Should fallback to warning when JSON.stringify fails
-      expect(warnSpy).toHaveBeenCalledWith(
-        jasmine.stringMatching(/MongoDB client event circularEvent logged with error:/)
+      // Should handle circular reference with [Circular] marker
+      expect(infoSpy).toHaveBeenCalledWith(
+        jasmine.stringMatching(/MongoDB client event circularEvent:.*\[Circular\]/)
       );
 
       await adapter.handleShutdown();

spec/Utils.spec.js

@@ -57,4 +57,69 @@ describe('Utils', () => {
       });
     });
   });
+
+  describe('getCircularReplacer', () => {
+    it('should handle Map instances', () => {
+      const obj = {
+        name: 'test',
+        mapData: new Map([
+          ['key1', 'value1'],
+          ['key2', 'value2']
+        ])
+      };
+      const result = JSON.stringify(obj, Utils.getCircularReplacer());
+      expect(result).toBe('{"name":"test","mapData":{"key1":"value1","key2":"value2"}}');
+    });
+
+    it('should handle Set instances', () => {
+      const obj = {
+        name: 'test',
+        setData: new Set([1, 2, 3])
+      };
+      const result = JSON.stringify(obj, Utils.getCircularReplacer());
+      expect(result).toBe('{"name":"test","setData":[1,2,3]}');
+    });
+
+    it('should handle circular references', () => {
+      const obj = { name: 'test', value: 123 };
+      obj.self = obj;
+      const result = JSON.stringify(obj, Utils.getCircularReplacer());
+      expect(result).toBe('{"name":"test","value":123,"self":"[Circular]"}');
+    });
+
+    it('should handle nested circular references', () => {
+      const obj = {
+        name: 'parent',
+        child: {
+          name: 'child'
+        }
+      };
+      obj.child.parent = obj;
+      const result = JSON.stringify(obj, Utils.getCircularReplacer());
+      expect(result).toBe('{"name":"parent","child":{"name":"child","parent":"[Circular]"}}');
+    });
+
+    it('should handle mixed Map, Set, and circular references', () => {
+      const obj = {
+        mapData: new Map([['key', 'value']]),
+        setData: new Set([1, 2]),
+        regular: 'data'
+      };
+      obj.circular = obj;
+      const result = JSON.stringify(obj, Utils.getCircularReplacer());
+      expect(result).toBe('{"mapData":{"key":"value"},"setData":[1,2],"regular":"data","circular":"[Circular]"}');
+    });
+
+    it('should handle normal objects without modification', () => {
+      const obj = {
+        name: 'test',
+        number: 42,
+        nested: {
+          key: 'value'
+        }
+      };
+      const result = JSON.stringify(obj, Utils.getCircularReplacer());
+      expect(result).toBe('{"name":"test","number":42,"nested":{"key":"value"}}');
+    });
+  });
 });

src/Adapters/Storage/Mongo/MongoStorageAdapter.js

@@ -18,6 +18,7 @@ import Parse from 'parse/node';
 import _ from 'lodash';
 import defaults from '../../../defaults';
 import logger from '../../../logger';
+import Utils from '../../../Utils';
 
 // @flow-disable-next
 const mongodb = require('mongodb');
@@ -211,35 +212,22 @@ export class MongoStorageAdapter implements StorageAdapter {
         if (this._logClientEvents && Array.isArray(this._logClientEvents)) {
           this._logClientEvents.forEach(eventConfig => {
             client.on(eventConfig.name, event => {
-              try {
-                let logData = {};
-                if (!eventConfig.keys || eventConfig.keys.length === 0) {
-                  logData = event;
-                } else {
-                  eventConfig.keys.forEach(keyPath => {
-                    logData[keyPath] = _.get(event, keyPath);
-                  });
-                }
-
-                // Validate log level exists, fallback to 'info'
-                const logLevel = typeof logger[eventConfig.logLevel] === 'function' ? eventConfig.logLevel : 'info';
-
-                // Safe JSON serialization with Map/Set support
-                const logMessage = `MongoDB client event ${eventConfig.name}: ${JSON.stringify(logData, (key, value) => {
-                  if (value instanceof Map) {
-                    return Object.fromEntries(value);
-                  }
-                  if (value instanceof Set) {
-                    return Array.from(value);
-                  }
-                  return value;
-                })}`;
-
-                logger[logLevel](logMessage);
-              } catch (error) {
-                // Fallback if serialization completely fails
-                logger.warn(`MongoDB client event ${eventConfig.name} logged with error: ${error.message}`);
+              let logData = {};
+              if (!eventConfig.keys || eventConfig.keys.length === 0) {
+                logData = event;
+              } else {
+                eventConfig.keys.forEach(keyPath => {
+                  logData[keyPath] = _.get(event, keyPath);
+                });
               }
+
+              // Validate log level exists, fallback to 'info'
+              const logLevel = typeof logger[eventConfig.logLevel] === 'function' ? eventConfig.logLevel : 'info';
+
+              // Safe JSON serialization with Map/Set and circular reference support
+              const logMessage = `MongoDB client event ${eventConfig.name}: ${JSON.stringify(logData, Utils.getCircularReplacer())}`;
+
+              logger[logLevel](logMessage);
             });
           });
         }

src/Utils.js

@@ -410,6 +410,40 @@ class Utils {
       '%' + char.charCodeAt(0).toString(16).toUpperCase()
     );
   }
+
+  /**
+   * Creates a JSON replacer function that handles Map, Set, and circular references.
+   * This replacer can be used with JSON.stringify to safely serialize complex objects.
+   *
+   * @returns {Function} A replacer function for JSON.stringify that:
+   * - Converts Map instances to plain objects
+   * - Converts Set instances to arrays
+   * - Replaces circular references with '[Circular]' marker
+   *
+   * @example
+   * const obj = { name: 'test', map: new Map([['key', 'value']]) };
+   * obj.self = obj; // circular reference
+   * JSON.stringify(obj, Utils.getCircularReplacer());
+   * // Output: {"name":"test","map":{"key":"value"},"self":"[Circular]"}
+   */
+  static getCircularReplacer() {
+    const seen = new WeakSet();
+    return (key, value) => {
+      if (value instanceof Map) {
+        return Object.fromEntries(value);
+      }
+      if (value instanceof Set) {
+        return Array.from(value);
+      }
+      if (typeof value === 'object' && value !== null) {
+        if (seen.has(value)) {
+          return '[Circular]';
+        }
+        seen.add(value);
+      }
+      return value;
+    };
+  }
 }
 
 module.exports = Utils;