Changed cyclic structure handling to a custom WeakMap implementation of Crockfords Decycle method.

Author: Faleij

README.md

@@ -90,14 +90,15 @@ app.get('/api/users', (req, res, next) => JSONStreamStreamify(Users.find().strea
 
 ## TODO
 - Space option
-- Circular dependency detection/handling (infinite loops may occur as it is)
 
 Feel free to contribute.
 
 ## Technical Notes
 Uses toJSON when available, and JSON.stringify to stringify everything but objects and arrays.  
 Streams with ObjectMode=true are output as arrays while ObjectMode=false output as a concatinated string (each chunk is piped with transforms).
 
+Circular structures are handled using a WeakMap based implementation of [Douglas Crockfords Decycle method](https://github.com/douglascrockford/JSON-js/blob/master/cycle.js). To restore circular structures; use Crockfords Retrocycle method on the parsed object.
+
 ## Requirements
 NodeJS >4.2.2
 

jsonStreamify.js

@@ -7,9 +7,9 @@ const RecursiveIterable = require('./recursiveIterable');
 const isReadableStream = require('./utils').isReadableStream;
 
 class JSONStreamify extends CoStream {
-    constructor(value, replacer, space, _visited) {
+    constructor(value, replacer, space, _visited, _stack) {
         super(arguments);
-        this._iter = new RecursiveIterable(replacer instanceof Function ? replacer(undefined, value) : value, replacer, space, _visited);
+        this._iter = new RecursiveIterable(replacer instanceof Function ? replacer(undefined, value) : value, replacer, space, _visited, _stack);
     }
 
     * _makeGenerator(value, replacer) {
@@ -52,6 +52,7 @@ class JSONStreamify extends CoStream {
                 yield this.push('[');
                 let first = true;
                 const pass = new PassThrough();
+                let i = 0;
                 obj.value.pipe(new Transform({
                     objectMode: true,
                     transform: (data, enc, next) => {
@@ -60,7 +61,7 @@ class JSONStreamify extends CoStream {
                         }
                         first = false;
                         let stream = new JSONStreamify(data, this._iter.replacer, this._iter.space, this._iter.visited);
-                        stream._iter._stack = this._iter._stack;
+                        stream._iter._stack = obj.stack.concat(i++);
                         stream._iter._parentCtxType = Array;
                         stream.once('end', () => next(null, undefined)).pipe(pass, {
                             end: false
@@ -73,11 +74,11 @@ class JSONStreamify extends CoStream {
             }
 
             if (obj.state === 'circular') {
-                yield this.push(JSON.stringify(`~${obj.value.join('~')}`));
+                yield this.push(JSON.stringify({ $ref: `$${obj.value.map(v => `[${JSON.stringify(v)}]`).join('')}` }));
             }
 
             if (obj.value instanceof Promise) {
-                let childIterator = new RecursiveIterable(yield obj.value, this._iter.replacer, this._iter.space, this._iter.visited, this._iter._stack)[Symbol.iterator]();
+                let childIterator = new RecursiveIterable(yield obj.value, this._iter.replacer, this._iter.space, this._iter.visited, obj.stack.concat(obj.key || []))[Symbol.iterator]();
                 obj.value = obj.attachChild(childIterator, obj.key);
                 insertSeparator = false;
                 continue;

recursiveIterable.js

@@ -15,9 +15,13 @@ class RecursiveIterable {
         this._stack = stack || [];
         this.visited = visited || new WeakMap();
         if (this._shouldIterate(obj)) {
-            this.visited.set(obj, this._stack.slice(0));
+            this.isVisited = this.visited.has(obj);
+            if (!this.isVisited) {
+                // Save only unvisited stack to weakmap
+                this.visited.set(obj, this._stack.slice(0));
+            }
         }
-        this.obj = this._shouldIterate(obj) ? (Array.isArray(obj) ? obj.slice(0) : Object.assign({}, obj)) : obj;
+        this.obj = this._shouldIterate(obj) && !this.isVisited ? (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;
@@ -63,9 +67,16 @@ class RecursiveIterable {
                 let type;
 
                 if (!opened) {
-                    state = 'open';
-                    type = ctxType;
-                    opened = true;
+                    if (this.isVisited) {
+                        state = 'circular';
+                        val = this.visited.get(this.obj);
+                        opened = closed = true;
+                        keys.length = 0;
+                    } else {
+                        state = 'open';
+                        type = ctxType;
+                        opened = true;
+                    }
                 } else if (!closed && !keys.length) {
                     state = 'close';
                     type = ctxType;

test.js

@@ -139,13 +139,29 @@ describe('Streamify', () => {
         })
     }, `{"a":[{"name":"name","arr":[],"date":"${date.toJSON()}"}]}`));
 
-    let circularData0 = {};
-    circularData0.a = circularData0;
-    it(`{ a: a } should be {"a":"~"}`, createTest(circularData0, `{"a":"~"}`));
-
-    let circularData1 = {};
-    circularData1.a = circularData1;
-    circularData1.b = [circularData1, { a: circularData1 }]
-    circularData1.b[3] = circularData1.b[1];
-    it('{a: a, b: [a, { a: a },,a.b.1]} should be {"a":"~","b":["~",{"a":"~"},null,"~b~1"]}', createTest(circularData1, '{"a":"~","b":["~",{"a":"~"},null,"~b~1"]}'));
+    describe('circular structure', function() {
+
+        let circularData0 = {};
+        circularData0.a = circularData0;
+        it(`{ a: a } should be {"a":{"$ref":"$"}}`, createTest(circularData0, `{"a":{"$ref":"$"}}`));
+
+        let circularData1 = {};
+        circularData1.a = circularData1;
+        circularData1.b = [circularData1, {
+            a: circularData1
+        }]
+        circularData1.b[3] = ReadableStream(circularData1.b[1]);
+        it('{a: a, b: [a, { a: a },,ReadableStream(b.1)]} should be {"a":{"$ref":"$"},"b":[{"$ref":"$"},{"a":{"$ref":"$"}},null,[{"$ref":"$[\\"b\\"][1]"}]]}', createTest(circularData1, '{"a":{"$ref":"$"},"b":[{"$ref":"$"},{"a":{"$ref":"$"}},null,[{"$ref":"$[\\"b\\"][1]"}]]}'));
+
+        let circularData2 = {};
+        let data2 = {
+            a: 'deep'
+        };
+        circularData2.a = Promise.resolve({
+            b: data2
+        });
+        circularData2.b = data2;
+        it(`{ a: Promise({ b: { a: 'deep' } }), b: a.b } should be {"a":{"b":{"a":"deep"}},"b":{"$ref":"$[\\"a\\"][\\"b\\"]"}}`, createTest(circularData2, `{"a":{"b":{"a":"deep"}},"b":{"$ref":"$[\\"a\\"][\\"b\\"]"}}`));
+
+    });
 });