Convert ES6 Class with Symbols to JSON

Question

I have hardcoded classes to represent models in my Aurelia application. Here's a model 'PostEdit':

var _postID = Symbol();
var _title = Symbol();
var _text = Symbol();

export class PostEdit {

    constructor(postEdit) {
        this[_postID] = postEdit.postID;
        this.title = postEdit.title;
        this.text= postEdit.text;
    }

    get postID() { return this[_postID]; }

    get title() { return this[_title]; }
    set title(val) { this[_title] = val; }

    get text() { return this[_text]; }
    set text(val) { this[_text] = val; }

}

After the object is manipulated, I need to PUT and POST it back to the server. But it looks like Aurelia's HttpClient is sending an empty JSON string ({}). Looking into it, it seems that Symbols are ignored when converting an ES6 class to JSON.

How can I go about getting all my properties into a JSON string to submit back to the server?

Answer 1

I'm assuming you're using symbols to keep the data private, but this means you're going to have to go through some extra steps if you want that data included in the JSON representation.

Here's an example using toJSON on your model to explicitly export the properties you care about

export class PostEdit {

  // ...
  toJSON() {
    return {
      postID: this.postID,
      title:  this.title,
      text:   this.text
    };
  }
}

Or

export class PostEdit {

  // ...
  toJSON() {
    let {postID, title, text} = this;
    return {postID, title, text};
  }
}

When JSON.stringify is called on your instance, it will automatically call toJSON

Answer 2

for more dynamic solution use this:

export class MeMe(){
 toJSON() {
    return Object.getOwnPropertyNames(this).reduce((a, b) => {
      a[b] = this[b];
      return a;
    }, {});
  }
}

or you can use my json-decorator :)

import json from "json-decorator";  

@json("postID") // pass the property names that you want to ignore
export class MeMe(){
  // ...
}

Answer 3

Give your class a toJSON method that returns a stringifyable object:

export class PostEdit {

    constructor(postEdit) {
        this[_postID] = postEdit.postID;
        this.title = postEdit.title;
        this.text = postEdit.text;
    }

    get postID() { return this[_postID]; }

    get title() { return this[_title]; }
    set title(val) { this[_title] = val; }

    get text() { return this[_text]; }
    set text(val) { this[_text] = val; }

    toJSON() {
        return {
            postId: this.postId,
            title: this.title,
            text: this.text
        };
    }
}

JSON.stringify will automatically call that and replace your instance with the result.

Also you might want to add a fromJSON method to your class that you can use to revive instances during JSON.parse. It is trivial in your case:

    static fromJSON(obj) {
        return new this(obj);
    }

but you might need something more complicated in other classes.

Answer 4

Symbol-based private variables are considerable recipe for encapsulation in ES6. The encapsulation in JS is rarely justified, but these are accessors (not symbols) that cause problems here.

Accessors are prototype methods in ES6 classes. So the property is defined not on instance but on prototype, it is non-enumerable. It can be seen in transpiled code, or by checking

postEditInstance.hasOwnProperty('postID') === false
Object.getPrototypeOf(postEditInstance).hasOwnProperty('postID') === true
Object.getPrototypeOf(postEditInstance).propertyIsEnumerable('postID') === false

JSON.stringify, on the other hand, serializes only own enumerable properties of the object.

The solution is to use toJSON method to serialize the object according to the desirable conditions. Or to use Occam's razor on model's accessors, especially if they aren't crucial there.

Answer 5

I wanted to have the whole class assigned to an object using Object.assign

My initial perspective on using this on a class assigning the allocated class to object. This created an infinite loop for _json in chrome. Bad idea.

class test {
    constructor() {
        this._json = {type: 'map'};
        Object.assign(this, this._json);
    }
    toJSON(){
        Object.assign(this._json, this);
        return this._json;
    }
}

I had to exclude the _json variable, so I iterated over the class variables to exclude it.

class test2 {
    constructor() {
        this._json = {type: 'map'};
        Object.assign(this, this._json);
    }
    toJSON(){
        Object.assign(this._json, {
            conv() {
                let ret = {};
                for(let i in this )
                {
                   if(i !== '_json') 
                       ret[i] = this[i];
                }
                return ret;
            }
        } );
        return this._json;
    }
}

but weirdly enough _json gets ignored even without if(i !== '_json')

have not fully tested it, but I thought this would be a good share.

Answer 6

How can I go about getting all my (symbol) properties into a JSON string to submit back to the server?

To get all symbol properties, you can use Object.getOwnPropertySymbols() to get an array of all symbol properties found directly upon a given object. Such as:

const pe = new PostEdit({...});
const symbols = Object.getOwnPropertySymbols(pe);

However, as all three symbol properties of PostEdit are using empty description (new Symbol(), without any description parameter), there is no way to distinguish these 3 symbols. If the above symbols array is printed, you will get:

//console.log(symbols)
[ Symbol(), Symbol(), Symbol() ]

So, if you want to serialize/deserialize PostEdit instance without adding toJSON()/fromJSON() method to PostEdit class, you can provide meaningful description for symbols and then serialize them accordingly:

var _postID = Symbol('postID');
var _title = Symbol('title');
var _text = Symbol('text');

export class PostEdit {
  ...
}

const pe = new PostEdit({...});
const symbols = Object.getOwnPropertySymbols(pe);
const serializeObj = {};
for (let s of symbols) {
  serializeObj[s.description] = pe[s];
}
const serializedText = JSON.stringify(serializeObj);

To make above serialize/deserialize steps more convenient to use, and also fix the identical-symbol-description issue, I've made an npm module named esserializer and implemented these logic in its pro version.