dson

Dynamic Stateful Object Notation

JSON extension that preserves type information for sharing code between server and client

Example

shared-class.js

 
function ClassName(info) {
    this.info = info
}
 
DSON.register('$classname', ClassName)
 

server.js

 
var ClassName = require('./shared-class');
 
app.use(bodyParser({
    reviver: DSON.reviver
}));
 
app.get('/data', function(req, res){
    res.send({obj: new ClassName({hello: 'world'})})
})
 

client.js

 
var ClassName = require('./shared-class');
 
$.get('/data', function(data) {
    data = DSON.parse(data);
    console.log(data.obj instanceof ClassName) // => true
})
 

Pre-registered (can be overwritten)

Array $array — only used if there are non-numerical properties

var arr = ['asdf', {}, 6]
 
arr.special = true;
 
var copy = DSON.parse(DSON.stringify(arr));
 
console.log(arr.special) // => true
 

RegExp $regex

Date $date

Function $function

DSON.register(id, constructor, [serialize], [construct], [options])

@param	{String} 			id				unique identifier for serialization

@param	{Function} 			constructor		Constructor function

@param	{Function} 	(opt)	serialize		Serializing function 
											returns a value that the `construct` 
											function will be called with.
											default: 
											```
												function(obj) {
													return obj;
												}
											```
											
@param	{Function} 	(opt)	construct		Reconstructing function 
											returns the reconstructed object
											default: 
											```
												function(Constructor, value) {
													var obj = Object.create(Constructor.prototype);
													Constructor.apply(obj, Array.isArray(value) ? value : [value])
													return obj;
												}
											```
											
@param	{Object} 	(opt)	options			Hash of options 

		{Boolean}	[false]	noMerge			DSON will not automatically merge the object's
											own properties with the return value of the 
											`construct` function
											
		{Boolean}	[false]	collapse		If no own properties other than those returned
											by the `serialize` function, the result will be
											serialized as a basic JSON value.  e.g.:
											```
												function Collapsable(name) {
													this.name = name;
												};
												
												DSON.register('$collapsable', Collapsable, function(obj){
													return [obj.name]
												}, {
													collapse:true
												});
												DSON.stringify(new Collapseable('myName'))
													// => '["name"]' as opposed to '{"$collapsable": ["name"]}'
											```
											This option is mostly for internal use — You shouldn't need it.

		{Array}		[null]	exclude			List of properties that will not be serialized.  Differs fom 
											`noMerge` in that the properties will not be available during
											reconstruction.  If set to `true` all properties will be excluded