Internal differences between circular-json and flatted?

[1999]

According to the API it should be straightforward to switch between circular-json and flatted but it didn't work in my case: mocha-parallel/mocha-parallel-tests#228

Is there anything in particular people should be careful about when switching to flatted?

[WebReflection]

If it was the same, it would've not been a different module 😉

Same as described in CircularJSON, you cannot interchange these parsers, they are all inevitably different.

If you want to migrate from CircularJSON to Flatted, you need to transform first all data from one format to the other.

const {parse} = require('circular-json');
const {stringify} = require('flatted');

const transform = (...args) => {
  return stringify(parse(...args));
};

// example: loop over all data ... then ...
db.get(key).then(text => db.set(key, transform(text)))

[1999]

Is it documented somewhere btw? Because I was under the impression that flatted is just a successor of circular-json with the same API.

[1999]

I'm not using circular-json serialized format anywhere - mostly just to pass the data between workers. Therefore, usual use case is 1) serialize in one worker, 2) pass the data to another worker, 3) parse in another worker. So I'm not sure what was wrong here.

[WebReflection]

I was under the impression that flatted is just a successor of circular-json with the same API.

the API is the same indeed: it's the native JSON stringify/parse API

however, the produced output and the consumed one is not the same.

As CircularJSON has never been a drop in replacement for JSON, Flatted is not a drop in replacement for anything.

Every part involved must use Flatted to parse or stringify objects.

If you try to Flatted.parse(JSON.stringify(obj)) it's expected to fail

If you try to JSON.parse(Flatted.stringify(obj)) it's expected to fail too.

This was the same as with CircularJSON and if it wasn't failing, it was a coincidence, since CircularJSON input, or output, is not meant to be consumed via JSON and yes, it's documented.

It is also a bad idea to CircularJSON.parse(JSON.stringify(object)) because of those manipulation used in CircularJSON.stringify() able to make parsing safe and secure.

[1999]

Okay, may be I was a bit unclear. I use CircularJSON.parse(CircularJSON.stringify(object)) so I was hoping to do the same with flatted like flatted.parse(flatted.stringify(object)). But it didn't work the same way for some reason - I still need to figure out why.

[WebReflection]

@1999 all tests, and coverage, are the same, so it'd be surprising since millions are using Flatted already and nobody has issues. If you find out though, please let me know.