built.io/lib/group-multiple.js

SDK for Built.io Backend

var R                     = require('ramda');
var utility               = require('./utilities/utility');
var instanceMethodBuilder = require('./utilities/instanceMethodBuilder')();

/**
* @class GroupMultiple
* @classdesc
* A Group is special type of field in Built.io Backend. The reason its named such is that its a set of fields grouped together.
* Each group field has its own schema and can contain sub-groups. GroupMultiple should be used when a group field is marked as 'multiple'.
* @instance
* @deprecated
* @description This should be used to represent a 'group field' which is marked as multiple in your class. 
* This representation can then be passed to methods that accept a Built.GroupMultiple structure as argument.
* @param {String} fieldUid The Uid of the field in your class schema.
* @param {Array} data Can be 1] Plain JavaScript array representing intial values 2] Instance of Built.Group (sub-group) 3] Instance of Built.GroupMultiple (sub-group)
* @example
* <h3><u>Constructor accepting plain JavaScript Object</u></h3>
* var person = Built.GroupMultiple('person', [{
*    name: 'John',
*    age: 22
* }, {
*    name: 'Sam',
*    age: 19
* }]);
* console.log(person.toJSON())
*
* <h3><u>Constructor accepting instance of 'dummy' Built.Group</u></h3>
* // In the above example we used plain JavaScript array to represent group's data.
* // Instead of this we can create dummy Built.Group instance and pass them
* // to Built.GroupMultiple. To create a dummy group specify fieldUid as '$dummy'
*	
* var dummyGrp = Built.Group('$dummy', {
*    name: 'John',
*    age: 22
* })
* // We can take advantage of methods defined on Built.Group
* dummyGroup = dummyGroup.addCondition('address', {
*    city: 'Mumbai'
* })
* var person = Built.GroupMultiple('person', [dummyGroup])
* console.log(person.toJSON())
* 
* <h3><u>Constructor accepting instance of Built.Group</u></h3>
* // To construct structure in which a group field marked multiple contains a sub-groups use syntax shown below
* var mumbai = Built.Group('address', {
*    city: 'Mumbai',
*    state: 'Maharashtra'
* });
* var surat = Built.Group('address', {
*    city: 'Surat',
*    state: 'Gujrat'
* });
* var person = Built.GroupMultiple('person', [mumbai, surat]);
* console.log(person.toJSON())
*
* <h3><u>Constructor accepting instance of Built.GroupMultiple</u></h3>
* // To construct structure in which a group field marked multiple contains a sub-groups marked multiple use syntax shown below
* var developers = Built.GroupMultiple('developers', {
*    name: 'John',
*    profile: 'JavaScript Developer'
* }, {
*    name: 'Sam',
*    profile: 'Java Developer'
* }]);
* var devops = Built.GroupMultiple('devops', [{
*    name: 'Crystal',
*    profile: 'AWS'
* }, {
*    name: 'Jack',
*    profile: 'Azur'
* }]);
* // Built.Mixin should be used to mix 2 or more Built.Group or Built.GroupMultiple together
* var employee = Built.GroupMultiple('employee', [Built.Mixin(developers, devops)]);
* console.log(employee.toJSON())
* @return {GroupMultiple}
*/
var groupMultipleCons = module.exports = R.curry(function(field, array) {
	var data 		= {}
	if(!utility.isArray(array)){
		throw new Error("Expected 'Array' found '"+ typeof(array)+"'")
	}
	// If array is Built.Group or Built.GroupMultiple we need to Deserialize
	array = JSON.parse(JSON.stringify(array))
	// Creating a JavaScript object
	data[field] = array

	var returnObj = {
		data 							: data,
		field 						: field,
		_isGroupMultiple 	: true,
		toJSON 						: function() {
			return data
		}
	}
	return instanceMethodBuilder.build(module.exports, returnObj)
})
var modifier = R.curry(function(fn, obj, groupMultipe){
	var newData = getMixinedData(groupMultipe);
	if(obj._isGroup || obj._isGroupMultiple){
		newData[groupMultipe.field][fn](obj.toJSON())
	}
	else{
		newData[groupMultipe.field][fn](obj)
	}
	return groupMultipleCons(groupMultipe.field, newData[groupMultipe.field]);
})

/**
* This method is similar to Array.prototype.push.
* @memberof GroupMultiple
* @function push
* @param {object|Built.Group|Built.GroupMultiple} element Element to be pushed
* @instance
* @example
* <h3><u>Pushing a Plain JavaScript object</u></h3>
* // 'blt5d4sample2633b' is a dummy Application API key
* var person = Built.GroupMultiple('person',[{
*    name:'John'	
* }]);
* person = person.push({
*    name: 'Jack'	
* });
* <h3><u>Pushing Built.Group instance in Built.GroupMultiple</u></h3>
* // 'blt5d4sample2633b' is a dummy Application API key
* var pune = Built.Group('city', {
*    name:'Pune'
* })
* var mumbai = Built.Group('city', {
*    name:'Mumbai'
* })
* var address = Built.GroupMultiple('address',[mumbai]); 
* address = address.push(pune);
* console.log(address.toJSON())
* @return {GroupMultiple}
*/
module.exports.push = modifier('push')
instanceMethodBuilder.define('push', 2)

/**
* This method is similar to Array.prototype.pop(). 
* @memberof GroupMultiple
* @function pop
* @instance
* @example
* // 'blt5d4sample2633b' is a dummy Application API key
* var pune = Built.Group('city', {
*    name: 'Pune'
* })
* var mumbai = Built.Group('city', {
*    name: 'Mumbai'
* })
* var address = Built.GroupMultiple('address', [mumbai, pune]);
* address = address.pop();
* console.log(address.toJSON())
* @return {GroupMultiple}
*/
module.exports.pop = modifier('pop',{})
instanceMethodBuilder.define('pop', 1)

/**
* This method is similar to Array.prototype.shift(). 
* @memberof GroupMultiple
* @function shift
* @instance
* @example
* // 'blt5d4sample2633b' is a dummy Application API key
* var pune = Built.Group('city', {
*    name: 'Pune'
* })
* var mumbai = Built.Group('city', {
*    name: 'Mumbai'
* })
* var address = Built.GroupMultiple('address', [mumbai, pune]);
* address = address.shift();
* // Removes 'mumbai' from address
* console.log(address.toJSON())
* @return {GroupMultiple}
*/
module.exports.shift = modifier('shift', {})
instanceMethodBuilder.define('shift', 1)

/**
* This method is similar to Array.prototype.unshift(). 
* @memberof GroupMultiple
* @function unshift
* @param {object|Built.Group|Built.GroupMultiple} element Element to be pushed
* @instance
* @example
* // 'blt5d4sample2633b' is a dummy Application API key
* var pune = Built.Group('city', {
*    name: 'Pune'
* })
* var mumbai = Built.Group('city', {
*    name: 'Mumbai'
* })
* var address = Built.GroupMultiple('address', [mumbai]);
* address = address.unshift(pune);
* console.log(address.toJSON())
* @return {GroupMultiple}
*/
module.exports.unshift = modifier('unshift')
instanceMethodBuilder.define('unshift', 2)

function getMixinedData(group){
	//Cloning array
	var newArray 		 = group.data[group.field].slice(0);
	var mixinedValue = R.mixin({}, group.data)
	mixinedValue[group.field] = newArray;
	return mixinedValue
}