supermodels

dot notation get/set for an object or array of objects

installation

$ npm install supermodels

usage

supermodels returns a function that can read and write to an object using dot notation:

var supermodels = require('supermodels');
 
var data = {
    name:'Starship Enterprise',
    address:{
        street:'Hanger 7',
        city:'London'
    }
}
 
var supermodel = supermodels(data);
 
supermodel('address.postcode', 'SW12');
 
console.log(supermodel('address.postcode'));
 
// SW12
 
console.log(data);
 
/*
    {
        name:'Starship Enterprise',
        address:{
            street:'Hanger 7',
            city:'London',
            postcode:'SW12'
        }
    }
*/

dot notation

when you write values using dot notation and they do not exist - objects will be inserted in order to write the value:

var data = {}
 
var supermodel = supermodels(data);
 
supermodel('a.b.c', 10);
 
console.log(data);
 
/*
    {
        a:{
            b:{
                c:10
            }
        }
    }
*/

array data

the data can also be an array:

var supermodels = require('supermodels');
 
var arr = [{
    name:'Starship Enterprise'
},{
    name:'Millenium Falcon'
}]
 
var supermodel = supermodels(arr);

array read

When you read from an array based supermodel - it will return the value of the first model in the array:

var name = supermodel('name');
 
console.log(name);
 
// Starship Enterprise

array write

When you write to an array based supermodel - it will write to all models in the array:

supermodel('speed', 200);
 
console.log(arr);
 
/*
    [{
        name:'Starship Enterprise',
        speed:200
    },{
        name:'Millenium Falcon',
        speed:200
    }]
*/

class property access

mymodel.js:

var supermodels = require('supermodels');
 
module.exports = MyClass;
 
// a class that has an array as a named property
function MyClass(arr){
  this.modelarray = arr;
}
 
function getmodels(){
    return this.modelarray;
}
 
// create a function that updates objects living in modelarray
MyClass.prototype.attr = supermodels(getmodels);
 
// create a function that updates nested objects living in modelarray
MyClass.prototype.address = supermodels(getmodels, 'address');
 
// create a function that updates nested properties living in modelarray
MyClass.prototype.postcode = supermodels(getmodels, 'address.postcode', true);

Then create a new instance:

var Model = require('./mymodel.js');
 
var data = [{
    name:'HQ',
    address:{
        city:'London',
        postcode:'SW12'
    }
},{
    name:'Accounts',
    address:{
        city:'Bristol',
        postcode:'BS1'
    }
}]
 
var instance = new Model(data)

Our instance can update all models in the list at once:

instance.attr('test', 10);
 
console.log(instance.modelarray);
 
data.forEach(function(model){
    console.log(model.test);
})
 
/*
 
// 10
// 10
 
*/

It will return the value of the first model on reading:

console.log(instance.attr('address.city'));
 
// London

nested attributes

Access functions allow nested attributes:

instance.address('top.middle.bottom', 12);
 
 
console.log(data[1]);
 
/*
{
    name:'Accounts',
    test:10,
    address:{
        city:'Bristol,
        postcode:'BS1',
        top:{
            middle:{
                bottom:12
            }
        }
    }
}
*/

api

supermodels(data, [path], [type]);

Return an accessor function that will modify data.

Data can be a an object, an array or a function.

Path is a dot notation for the property in the data to modify.

If data is an object - it will be converted to an array with one element.

If data is an array - it will be used directly.

If data is a function - it will be called each time to provide the data.

type can be one of:

• true - which means 'primitive'
• primitive - return a function that will read and write one value - supermodel(value)
• object - return a function that will read and write objectvalues - supermodel(name, value)
• remove - return a function that will delete an object property - supermodel()
• array:add - return a function that inserts a primitive into an array (if it does not exist) - supermodel(value)
• array:remove - return a function that removes a primitive from an array - supermodel(value)
• array:has - return a function that tells you if a value is in the array - supermodel(value)
• has - return a function that tells you if the model has the property - supermodel(path)
• is - return a function that tells you if the models property is a value - supermodel(value)

A primitive:

var data = {
    title:'Test'
}
var prop = supermodels(data, 'title', true);
 
console.log(prop());
 
// Test
 
prop('apples');
 
console.log(prop());
 
// apples
 

A removal function:

var data = {
    address:{
        postcode:'SW12'
    }
}
 
var remover = supermodels(data, 'address', 'remove');
 
remover();
 
console.log(data);
 
/*
 {
 
 }
*/

license

MIT