Circular Structure handling like json-stringify-safe. Fixes replacer for deep objects.

Author: Faleij

jsonStreamify.js

@@ -7,9 +7,9 @@ const RecursiveIterable = require('./recursiveIterable');
 const isReadableStream = require('./utils').isReadableStream;
 
 class JSONStreamify extends CoStream {
-    constructor(value, replacer) {
+    constructor(value, replacer, space, _visited) {
         super(arguments);
-        this._iter = new RecursiveIterable(replacer instanceof Function ? replacer(undefined, value) : value, replacer);
+        this._iter = new RecursiveIterable(replacer instanceof Function ? replacer(undefined, value) : value, replacer, space, _visited);
     }
 
     * _makeGenerator(value, replacer) {
@@ -54,12 +54,12 @@ class JSONStreamify extends CoStream {
                 const pass = new PassThrough();
                 obj.value.pipe(new Transform({
                     objectMode: true,
-                    transform: function(data, enc, next) {
+                    transform: (data, enc, next) => {
                         if (!first) {
                             pass.push(',');
                         }
                         first = false;
-                        let stream = new JSONStreamify(data);
+                        let stream = new JSONStreamify(data, this._iter.replacer, this._iter.space, this._iter.visited);
                         stream._iter._parentCtxType = Array;
                         stream.once('end', () => next(null, undefined)).pipe(pass, {
                             end: false
@@ -71,8 +71,27 @@ class JSONStreamify extends CoStream {
                 continue;
             }
 
+            if (obj.state === 'circular') {
+                let replacer;
+                this.emit('circular', Object.assign(obj, {
+                    replace: (promise) => {
+                        if (promise instanceof Promise) {
+                            obj.value = promise;
+                        }
+                    }
+                }));
+
+                // Wait for replace
+                yield new Promise(resolve => process.nextTick(resolve));
+
+                if (!(obj.value instanceof Promise)) {
+                    yield this.push('"[Circular]"');
+                }
+            }
+
             if (obj.value instanceof Promise) {
-                obj.value = obj.attachChild(new RecursiveIterable(yield obj.value)[Symbol.iterator]());
+                let childIterator = new RecursiveIterable(yield obj.value, this._iter.replacer, this._iter.space, this._iter.visited)[Symbol.iterator]();
+                obj.value = obj.attachChild(childIterator);
                 insertSeparator = false;
                 continue;
             }
@@ -87,6 +106,6 @@ class JSONStreamify extends CoStream {
     }
 }
 
-module.exports = function (obj, replacer) {
+module.exports = function(obj, replacer) {
     return new JSONStreamify(obj, replacer);
 };

recursiveIterable.js

@@ -4,17 +4,22 @@ const Readable = require('stream').Readable;
 const isReadableStream = require('./utils').isReadableStream;
 
 class RecursiveIterable {
-    constructor(obj, replacer) {
+    constructor(obj, replacer, space, visited) {
         // Save a copy of the root object so we can be memory effective
         if (obj && typeof obj.toJSON === 'function') {
             obj = obj.toJSON();
         }
         this.exclude = [Promise, {
             __shouldExclude: isReadableStream
         }];
+        this.visited = visited || new WeakSet();
+        if (this._shouldIterate(obj)) {
+            this.visited.add(obj);
+        }
         this.obj = this._shouldIterate(obj) ? (Array.isArray(obj) ? obj.slice(0) : Object.assign({}, obj)) : obj;
         this.replacerIsArray = Array.isArray(replacer);
         this.replacer = replacer instanceof Function || this.replacerIsArray ? replacer : undefined;
+        this.space = space;
     }
 
     _shouldIterate(val) {
@@ -101,11 +106,15 @@ class RecursiveIterable {
                     }
 
                     if (this._shouldIterate(val)) {
-                        state = 'child';
-                        childIterator = new RecursiveIterable(val)[Symbol.iterator]();
-                        childIterator.ctxType = ctx.type;
-                        childIterator.depth = ctx.depth + 1;
-                        childIterator.type = RecursiveIterable._getType(val);
+                        if (this.visited.has(val)) {
+                            state = 'circular';
+                        } else {
+                            state = 'child';
+                            childIterator = new RecursiveIterable(val, this.replacer, this.space, this.visited)[Symbol.iterator]();
+                            childIterator.ctxType = ctx.type;
+                            childIterator.depth = ctx.depth + 1;
+                            childIterator.type = RecursiveIterable._getType(val);
+                        }
                     }
 
                     if (key) {

test.js

@@ -138,4 +138,69 @@ describe('Streamify', () => {
             date: date
         })
     }, `{"a":[{"name":"name","arr":[],"date":"${date.toJSON()}"}]}`));
+
+    it(`{ a: [Circular] } should be {"a":"[Circular]"}`, () => {
+        let data = {};
+        data.a = data;
+
+        let deferred0 = Promise.defer();
+        let deferred1 = Promise.defer();
+        let str = '';
+        new JSONStreamify(data)
+            .once('circular', err => {
+                try {
+                    expect(err).to.be.ok();
+                } catch (err) {
+                    return deferred1.reject(err);
+                }
+                deferred1.resolve();
+            })
+            .on('data', data => str += data.toString())
+            .once('end', () => {
+                try {
+                    expect(str).to.equal(`{"a":"[Circular]"}`);
+                } catch (err) {
+                    return deferred0.reject(err);
+                }
+                deferred0.resolve();
+            });
+
+        return Promise.all([deferred0.promise, deferred1.promise]);
+    });
+
+    it(`{ a: [Circular] } should be {"a":"custom"}`, () => {
+        let data = {};
+        data.a = data;
+
+        let deferred0 = Promise.defer();
+        let deferred1 = Promise.defer();
+        let str = '';
+        new JSONStreamify(data)
+            .once('circular', err => {
+                try {
+                    expect(err).to.be.ok();
+                    expect(err.replace).to.be.a(Function);
+                    err.replace(Promise.resolve('custom'));
+                } catch (err) {
+                    return deferred1.reject(err);
+                }
+                deferred1.resolve();
+            })
+            .on('data', data => str += data.toString())
+            .once('end', () => {
+                try {
+                    expect(str).to.equal(`{"a":"custom"}`);
+                } catch (err) {
+                    return deferred0.reject(err);
+                }
+                deferred0.resolve();
+            });
+
+        return Promise.all([deferred0.promise, deferred1.promise]);
+    });
+
+    let circularData0 = {};
+    circularData0.a = circularData0;
+    circularData0.b = [circularData0, { a: circularData0 }]
+    it('{a: Circular, b: [Circular, { a: Circular }]} should be {"a":"[Circular]","b":["[Circular]",{"a":"[Circular]"}]}', createTest(circularData0, '{"a":"[Circular]","b":["[Circular]",{"a":"[Circular]"}]}'));
 });