I have been coding in javascript for some time, but am fairly new to Node. I recently undertook a project that involves a complex object structure with multiple levels of prototypical inheritance and sub objects. This structure needs to be periodically saved / loaded. Saving and loading in JSON is desirable.

The Question

Is there a more elegant way of accomplishing the task of saving/loading these complex Javascript objects than my current method (outlined below)? Is it possible to design it in such a way where the constructors can initialize themselves as if they were normal objects without being bound by all of the restoring functionality?

My Solution

The base 'class' (from which, by design, all other objects under consideration inherit protoypically) has a function which processes an 'options' argument, adding all of it's properties to the current object. All deriving objects must include an options argument as the last argument and call the processing function in their constructor.

Each object also must add it's function name to a specific property so that the correct constructor function can be called when the object needs to be rebuilt.

An unpack function takes the saved object JSON, creates a plain object with JSON.parse and then passes that object in as the 'options' argument to the object's constructor.

Each object is given a unique id and stored in a lookup table, so that a function under construction with links to other objects can point to the right ones, or create them if it needs to.

Here is a plunker which demonstrates the idea (obviously in a non-Node way).

If you don't want to load the plunker, here's an excerpt which should hopefully provide the gist of what I'm trying to do:

function BaseClass(name, locale, options){
  if(name) this.name = name;
  if(locale) this.locale = locale;

  // If options are defined, apply them
  this.processOptions(options);

  // create the classList array which keeps track of
  // the object's prototype chain
  this._classList = [arguments.callee.name];

  // Create a unique id for the object and add it to
  // the lookup table
  if(!this.id) this.id = numEntities++;
  lookupTable[this.id] = this;

  if(!this.relations) this.relations = [];

  // other initialization stuff
}

BaseClass.prototype = {
  processOptions: function(options) {
    if(options && !options._processed){
            for(var key in options){
                if(options.hasOwnProperty(key)){
                    this[key] = options[key];
                }
            }
            options._processed = true;
        }
  },
  addNewRelation: function(otherObj){
    this.relations.push(otherObj.id);
  }

  // Other functions and such for the base object
}

function DerivedClassA(name, locale, age, options){
  if(age) this.age = age;

  this.processOptions(options);

  if(options && options.connectedObj){

    // Get the sub object if it already exists
    if(lookupTable[options.subObj.id]){
      this.subObj = lookupTable[options.subObj.id];
    }
    // Otherwise, create it from the options
    else {
      this.subObj = new OtherDerivedClass(options.subObj);
    }
  }
  else {
    // If no options then construct as normal
    this.subObj = new OtherDerivedClass();
  }

  // If something needs to be done before calling the super
  // constructor, It's done here.

  BaseClass.call(this, name, locale, options);
  this._classList.push(arguments.callee.name);

}

DerivedClassA.prototype = Object.create(BaseClass.prototype);

As mentioned, this gets the job done, but I can't help but feeling like this could be much better. It seems to impose a ridiculous amount of restrictions on the inheriting 'classes' and how their constructors must behave. It makes a specific order of execution critical, and requires that each object be deeply involved and aware of the restoration process, which is far from ideal.