data.js

(function(){

  var Data;
  if (typeof exports !== 'undefined') {
    Data = exports;
  } else {
    Data = this.Data = {};
  }
  

  Data.VERSION = '0.2.0';

  var _ = this._;
  if (!_ && (typeof require !== 'undefined')) _ = require("underscore");
  
  

  Data.VALUE_TYPES = [
    'string',
    'object',
    'number',
    'boolean',
    'date'
  ];
  
  Data.isValueType = function (type) {
    return _.include(Data.VALUE_TYPES, type);
  };
  

  Data.setAdapter = function(name, config) {
    if (typeof exports !== 'undefined') {
      var Adapter = require('./adapters/'+name+'_adapter');
      Data.adapter = new Adapter(config);
    } else {
      Data.adapter = new window[name](config);
    }
  };
  

  Data.middleware = {
    readgraph: [],
    writegraph: []
  };
  
  /*!
  Math.uuid.js (v1.4)
  http://www.broofa.com
  mailto:robert@broofa.com

  Copyright (c) 2010 Robert Kieffer
  Dual licensed under the MIT and GPL licenses.
  */

  Data.uuid = function (prefix) {
    var chars = '0123456789abcdefghijklmnopqrstuvwxyz'.split(''),
        uuid = [],
        radix = 16,
        len = 32;

    if (len) {

      for (var i = 0; i < len; i++) uuid[i] = chars[0 | Math.random()*radix];
    } else {

      var r;

      uuid[8] = uuid[13] = uuid[18] = uuid[23] = '-';
      uuid[14] = '4';

      for (var i = 0; i < 36; i++) {
        if (!uuid[i]) {
          r = 0 | Math.random()*16;
          uuid[i] = chars[(i == 19) ? (r & 0x3) | 0x8 : r];
        }
      }
    }
    
    return (prefix ? prefix : "") + uuid.join('');
  };

  
  _.Events = {

    bind : function(ev, callback) {
      var calls = this._callbacks || (this._callbacks = {});
      var list  = this._callbacks[ev] || (this._callbacks[ev] = []);
      list.push(callback);
      return this;
    },

    unbind : function(ev, callback) {
      var calls;
      if (!ev) {
        this._callbacks = {};
      } else if (calls = this._callbacks) {
        if (!callback) {
          calls[ev] = [];
        } else {
          var list = calls[ev];
          if (!list) return this;
          for (var i = 0, l = list.length; i < l; i++) {
            if (callback === list[i]) {
              list.splice(i, 1);
              break;
            }
          }
        }
      }
      return this;
    },

    trigger : function(ev) {
      var list, calls, i, l;
      if (!(calls = this._callbacks)) return this;
      if (list = calls[ev]) {
        for (i = 0, l = list.length; i < l; i++) {
          list[i].apply(this, Array.prototype.slice.call(arguments, 1));
        }
      }
      if (list = calls['all']) {
        for (i = 0, l = list.length; i < l; i++) {
          list[i].apply(this, arguments);
        }
      }
      return this;
    }
  };

  var ctor = function(){};

  _.inherits = function(parent, protoProps, staticProps) {
    var child;

    if (protoProps && protoProps.hasOwnProperty('constructor')) {
      child = protoProps.constructor;
    } else {
      child = function(){ return parent.apply(this, arguments); };
    }

    ctor.prototype = parent.prototype;
    child.prototype = new ctor();

    if (protoProps) _.extend(child.prototype, protoProps);

    if (staticProps) _.extend(child, staticProps);

    child.prototype.constructor = child;

    child.__super__ = parent.prototype;

    return child;
  };
  
  

  
  Data.Hash = function(data) {
    var that = this;
    this.data = {};
    this.keyOrder = [];
    this.length = 0;

    if (data instanceof Array) {
      _.each(data, function(datum, index) {
        that.set(index, datum);
      });
    } else if (data instanceof Object) {
      _.each(data, function(datum, key) {
        that.set(key, datum);
      });
    }
    
    if (this.initialize) this.initialize(attributes, options);
  };

  _.extend(Data.Hash.prototype, _.Events, {

    clone: function () {
      var copy = new Data.Hash();
      copy.length = this.length;
      _.each(this.data, function(value, key) {
        copy.data[key] = value;
      });
      copy.keyOrder = this.keyOrder.slice(0, this.keyOrder.length);
      return copy;
    },
    

    set: function (key, value, targetIndex) {
      var index;
      if (key === undefined)
        return this;
      
      if (!this.data[key]) {
        if (targetIndex !== undefined) { // insert at a given index
          var front = this.select(function(item, key, i) {
            return i < targetIndex;
          });

          var back = this.select(function(item, key, i) {
            return i >= targetIndex;
          });

          this.keyOrder = [].concat(front.keyOrder);
          this.keyOrder.push(key);
          this.keyOrder = this.keyOrder.concat(back.keyOrder);
        } else {
          this.keyOrder.push(key);
        }
        index = this.length;
        this.length += 1;
      } else {
        index = this.index(key);
      }
      this.data[key] = value;
      this[index] = this.data[key];
      
      this.trigger('set', key);
      return this;
    },
    

    del: function (key) {
      if (this.data[key]) {
        var l = this.length;
        var index = this.index(key);
        delete this.data[key];
        this.keyOrder.splice(index, 1);
        Array.prototype.splice.call(this, index, 1);
        this.length = l-1;
        this.trigger('del', key);
      }
      return this;
    },
    

    get: function (key) {
      return this.data[key];
    },
    

    at: function (index) {
      var key = this.keyOrder[index];
      return this.data[key];
    },
    

    first: function () {
      return this.at(0);
    },
    

    last: function () {
      return this.at(this.length-1);
    },
    

    key: function (index) {
      return this.keyOrder[index];
    },
    

    index: function(key) {
      return this.keyOrder.indexOf(key);
    },
    

    each: function (fn) {
      var that = this;
      _.each(this.keyOrder, function(key, index) {
        fn.call(that, that.data[key], key, index);
      });
      return this;
    },
    

    values: function () {
      var result = [];
      this.each(function(value, key, index) {
        result.push(value);
      });
      return result;
    },

    keys: function () {
      return this.keyOrder;
    },
    

    toArray: function () {
      var result = [];
    
      this.each(function(value, key) {
        result.push({key: key, value: value});
      });
    
      return result;
    },
    

    toJSON: function() {
      var result = {};
      
      this.each(function(value, key) {
        result[key] = value.toJSON();
      });
      return result;
    },

    map: function (fn) {
      var result = this.clone(),
          that = this;
      result.each(function(item, key, index) {
        result.data[that.key(index)] = fn.call(result, item);
      });
      return result;
    },

    select: function (fn) {
      var result = new Data.Hash(),
          that = this;
    
      this.each(function(value, key, index) {
        if (fn.call(that, value, key, index)) {
          result.set(key, value);
        }
      });
      return result;
    },
    

    sort: function (comparator) {
      var result = this.clone();
          sortedKeys = result.toArray().sort(comparator);
    

      result.keyOrder = _.map(sortedKeys, function(k) {
        return k.key;
      });
      return result;
    },
    

    intersect: function(hash) {
      var that = this,
      result = new Data.Hash();
    
      this.each(function(value, key) {
        hash.each(function(value2, key2) {
          if (key === key2) result.set(key, value);
        });
      });
      return result;
    },
    

    union: function(hash) {
      var that = this,
      result = new Data.Hash();
    
      this.each(function(value, key) {
        if (!result.get(key))
          result.set(key, value);
      });
      hash.each(function(value, key) {
        if (!result.get(key))
          result.set(key, value);
      });
      return result;
    }
  });
  
  

  Data.Comparators = {};
  
  Data.Comparators.ASC = function(item1, item2) {
    return item1.value === item2.value ? 0 : (item1.value < item2.value ? -1 : 1);
  };

  Data.Comparators.DESC = function(item1, item2) {
    return item1.value === item2.value ? 0 : (item1.value > item2.value ? -1 : 1);
  };
  
  

  Data.Aggregators = {};

  Data.Aggregators.SUM = function (values) {
    var result = 0;

    values.each(function(value, key, index) {
      result += value;
    });

    return result;
  };

  Data.Aggregators.MIN = function (values) {
    var result = Infinity;
    values.each(function(value, key, index) {
      if (value < result) result = value;
    });
    return result;
  };

  Data.Aggregators.MAX = function (values) {
    var result = -Infinity;
    values.each(function(value, key, index) {
      if (value > result) result = value;
    });
    return result;
  };

  Data.Aggregators.AVG = function (values) {
    return Data.Aggregators.SUM(values) / values.length;
  };

  Data.Aggregators.COUNT = function (values) {
    return values.length;
  };
  
  

  
  Data.Modifiers = {};

  Data.Modifiers.DEFAULT = function (attribute) {
    return attribute;
  };

  Data.Modifiers.MONTH = function (attribute) {
    return attribute.getMonth();
  };

  Data.Modifiers.QUARTER = function (attribute) {
    return Math.floor(attribute.getMonth() / 3) + 1;
  };
  
  

  
  Data.Transformers = {
    group: function(g, type, keys, properties) {
      var gspec = {},
          type = g.get(type),
          groups = {},
          count = 0;
      
      gspec[type._id] = {"type": "/type/type", "properties": {}};

      _.each(keys, function(key) {
        gspec[type._id].properties[key] = type.properties().get(key).toJSON();
      });
      

      _.each(properties, function(options, key) {
        var p = type.properties().get(key).toJSON();
        if (options.name) p.name = options.name;
        gspec[type._id].properties[key] = p;
      });

      _.each(keys, function(key) {
        groups[key] = type.properties().get(key).all('values');
      });

      function aggregate(key) {
        var members = new Data.Hash();
        _.each(keys, function(k, index) {
          var objects = groups[keys[index]].get(key[index]).referencedObjects;
          members = index === 0 ? members.union(objects) : members.intersect(objects);
        });
        
        
        var res = {type: type._id};
        _.each(gspec[type._id].properties, function(p, pk) {
          if (_.include(keys, pk)) {
            res[pk] = key[_.indexOf(keys, pk)];
          } else {
            var numbers = members.map(function(obj) {
              return obj.get(pk);
            });
            var aggregator = properties[pk].aggregator || Data.Aggregators.SUM
            res[pk] = aggregator(numbers);
          }
        });
        return res;
      }

      function extractGroups(keyIndex, key) {
        if (keyIndex === keys.length-1) {
          gspec[key.join('::')] = aggregate(key);
        } else {
          keyIndex += 1;
          groups[keys[keyIndex]].each(function(grp, grpkey) {
            extractGroups(keyIndex, key.concat([grpkey]));
          });
        }
      }

      extractGroups(-1, []);
      return new Data.Graph(gspec);
    }
  };
  
  

  
  Data.Node = function(options) {
    this.nodeId = Data.Node.generateId();
    if (options) {
      this.val = options.value;
    }
    this._properties = {};
    
    if (this.initialize) this.initialize(options);
  };
  
  Data.Node.nodeCount = 0;
  

  Data.Node.generateId = function () {
    return Data.Node.nodeCount += 1;
  };
  
  _.extend(Data.Node.prototype, _.Events, {

    identity: function() {
      return this.nodeId;
    },
    

    replace: function(property, hash) {
      this._properties[property] = hash;
    },

    set: function (property, key, value) {
      if (!this._properties[property]) {
        this._properties[property] = new Data.Hash();
      }
      this._properties[property].set(key, value instanceof Data.Node ? value : new Data.Node({value: value}));
      return this;
    },
    

    get: function (property, key) {
      if (key !== undefined && this._properties[property] !== undefined) {
        return this._properties[property].get(key);
      }
    },

    all: function(property) {
      return this._properties[property];
    },
    

    first: function(property) {
      var p = this._properties[property];
      return p ? p.first() : null;  
    },

    value: function(property) {
      return this.values(property).first();
    },
    

    values: function(property) {
      if (!this.all(property)) return new Data.Hash();
      return this.all(property).map(function(n) {
        return n.val;
      });
    }
  });
  
  

  
  Data.Adapter = function(config) {

    this.config = config;
  };
  
  _.extend(Data.Adapter.prototype, {
    

    flush: function() {},
    

    readGraph: function(qry, targetGraph, options, callback) {},
    

    writeGraph: function(graph, callback) {}
  });
  
  

  
  Data.Property = _.inherits(Data.Node, {
    constructor: function(type, id, options) {
      Data.Node.call(this);
      this.key = id;
      this._id = id;
      this.type = type;
      this.unique = options.unique;
      this.name = options.name;
      this.meta = options.meta || {};
      this.validator = options.validator;
      this.required = options["required"];
      this["default"] = options["default"];
      

      this.expectedTypes = _.isArray(options['type']) ? options['type'] : [options['type']];
      this.replace('values', new Data.Hash());
    },
    
    isValueType: function() {
      return Data.isValueType(this.expectedTypes[0]);
    },
    
    isObjectType: function() {
      return !this.isValueType();
    },
    
    registerValue: function(key, value, obj) {

      if (this.isObjectType()) {
        this.set('values', key, value);
      } else {
        var val = this.get('values', key);
        if (!val) {
          val = new Data.Node({value: value});
          val.referencedObjects = new Data.Hash();
        }
        
        obj.set(this.key, key, val);
        val.referencedObjects.set(obj.key, obj);
        this.set('values', key, val); // vals are shared among objects
      }
    },
    
    unregisterValue: function(key, value) {
      if (this.isObjectType()) {
        this.all('values').del(key);
      }
    },
    

    aggregate: function (fn) {
      return fn(this.values("values"));
    },
    

    toJSON: function() {
      return {
        name: this.name,
        type: this.expectedTypes,
        unique: this.unique,
        meta: this.meta,
        valiate: this.validator,
        required: this.required,
        "default": this["default"]
      }
    }
  });
  
   

  
  Data.Type = _.inherits(Data.Node, {
    constructor: function(g, id, type) {
      var that = this;
      Data.Node.call(this);
  
      this.g = g; // Belongs to the DataGraph
      this.key = id;
      this._id = id;
      this._rev = type._rev;
      this._conflicted = type._conflicted;
      this.type = type.type;
      this.name = type.name;
      this.meta = type.meta || {};
  

      _.each(type.properties, function(property, key) {
        that.set('properties', key, new Data.Property(that, key, property));
      });
    },
    

    properties: function() {
      return this.all('properties');
    },
    

    objects: function() {
      return this.all('objects');
    },
    

    toJSON: function() {
      var result = {
        _id: this._id,
        _rev: this._rev,
        type: '/type/type',
        name: this.name,
        properties: {},
        meta: this.meta
      };
      
      this.all('properties').each(function(property) {
        var p = result.properties[property.key] = {
          name: property.name,
          unique: property.unique,
          type: property.expectedTypes,
          required: property.required ? true : false
        };
        if (property["default"]) p["default"] = property["default"];
        if (property.validator) p.validator = property.validator;
        if (property.meta && _.keys(property.meta).length > 0) p.meta = property.meta;
      });
      
      return result;
    }
  });
  

  
  Data.Object = _.inherits(Data.Node, {
    constructor: function(g, id, data) {
      var that = this;
      Data.Node.call(this);
      
      this.g = g;
      

      this.key = id;
      this._id = id;
      this.html_id = id.replace(/\//g, '_');
      this.dirty = true; // Every constructed node is dirty by default
      
      this.errors = []; // Stores validation errors
      this._types = new Data.Hash();
      

      this.referencedObjects = new Data.Hash();
      

      if (data) this.data = data;
      

      this.bind('set', function(key, values, prevValues) {
        var p = this.properties().get(key);
        
        if (p.isObjectType()) {

          _.each(prevValues, function(value) {
            p.unregisterValue(value, that.g.get(value),that);
          });
          

          _.each(values, function(value) {
            p.registerValue(value, that.g.get(value), that);
          });
        
        } else { // Value type property values

          _.each(prevValues, function(value) {
            p.unregisterValue(value, value, that);
          });
          

          _.each(values, function(value) {
            p.registerValue(value, value, that);
          });
        }
      });
    },
    

    types: function() {
      return this._types;
    },
    
    toString: function() {
      return this.get('name') || this.val || this._id;
    },
    

    properties: function() {
      var properties = new Data.Hash();

      this._types.each(function(type) {
        type.all('properties').each(function(property) {
          properties.set(property.key, property);
        });
      });
      return properties;
    },
    

    build: function() {
      var types = _.isArray(this.data.type) ? this.data.type : [this.data.type];
      
      if (!this.data) throw 'object has no data, and cannot be built';
      var that = this;
      

      delete this.data._id;
      this._rev = this.data._rev; // delete this.data._rev;
      this._conflicted = this.data._conflicted;
      this._deleted = this.data._deleted; // delete this.data._deleted;
      

      this.type = this.g.get('objects', _.last(types));
      

      _.each(types, function(type) {
        that._types.set(type, that.g.get('objects', type));

        that._types.get(type).all('properties').each(function(property, key) {        
          function applyValue(value) {
            var values = _.isArray(value) ? value : [value];

            that.replace(property.key, new Data.Hash());
            property.isObjectType() ? that.setObjectProperty(property, values)
                                    : that.setValueProperty(property, values);
          }

          if (that.data[key] !== undefined) {
            applyValue(that.data[key]);
          } else if (property["default"]) {
            applyValue(property["default"]);
          }
        });
      });
      
      if (this.dirty) this.g.trigger('dirty');
    },
    

    validate: function() {
      if (this.type.key === '/type/type') return true; // Skip type nodes
      
      var that = this;
      this.errors = [];
      this.properties().each(function(property, key) {

        if ((that.get(key) === undefined || that.get(key) === null) || that.get(key) === "") {
          if (property.required) {
            that.errors.push({property: key, message: "Property \"" + property.name + "\" is required"});
          }
        } else {

          var types = property.expectedTypes;

          function validType(value, types) {
            if (_.include(types, typeof value)) return true;
            

            if (!value.data) return true;
            
            if (value instanceof Data.Object && _.intersect(types, value.types().keys()).length>0) return true;
            
            if (typeof value === 'object' && _.include(types, value.constructor.name.toLowerCase())) return true;
            return false;
          }
          

          if (property.unique && !validType(that.get(key), types)) {
            that.errors.push({property: key, message: "Invalid type for property \"" + property.name + "\""});
          }
          

          if (!property.unique && !_.all(that.get(key).values(), function(v) { return validType(v, types); })) {
            that.errors.push({property: key, message: "Invalid value type for property \"" + property.name + "\""});
          }
        }
        

        function validValue() {
          return new RegExp(property.validator).test(that.get(key));
        }
        
        if (property.validator) {
          if (!validValue()) {
            that.errors.push({property: key, message: "Invalid value for property \"" + property.name + "\""});
          }
        }
      });
      
      return this.errors.length === 0;
    },
    

    newReference: function(id) {
      var obj = this.g.get('objects', id);
      if (!obj) {

        obj = new Data.Object(this.g, id);
        this.g.set('objects', id, obj);
      }

      obj.referencedObjects.set(this.key, this);
      return obj;
    },
    

    setObjectProperty: function(p, values)  {
      var that = this;
      
      that.replace(p.key, new Data.Hash());
      _.each(values, function(v, index) {
        if (!v) return; // skip
        
        if (typeof v === 'object') {
          v = that.g.set(null, v)._id;
        }
        
        var obj = that.newReference(v);
        var prevKeys = that.all(p.key).keys();
        that.set(p.key, obj.key, obj);
        
        that.trigger('set', p.key, that.all(p.key).keys(), prevKeys);
        

      });
    },
    

    setValueProperty: function(p, values) {
      var that = this;

      that.replace(p.key, new Data.Hash());
      _.each(values, function(v, index) {
        var val = p.get('values', v);
        

        if (!val) {
          val = new Data.Node({value: v});
          val.referencedObjects = new Data.Hash();
        }
        
        var prevKeys = that.all(p.key).keys();
        that.set(p.key, v, val);
        that.trigger('set', p.key, that.all(p.key).keys(), prevKeys);
        

      });
    },
    

    
    get: function(property, key) {
      if (!this.data) return null;
      var p = this.properties().get(property);
      if (!p) return null;
    
      if (arguments.length === 1) {
        if (p.isObjectType()) {
          return p.unique ? this.first(property) : this.all(property);
        } else {
          return p.unique ? this.value(property) : this.values(property);
        }
      } else {
        return Data.Node.prototype.get.call(this, property, key);
      }
    },
    

    getAsync: function(property, callback) {
      var that = this;
      if (!this.data) {
        this.g.fetch({_id: this._id}, {}, function(err) {
          err ? callback(err) : callback(null, that.get(property));
        });
      } else {
        callback(null, that.get(property)); // Delegate to Data.Object#get
      }
    },
    

    set: function(properties) {
      var that = this;
      
      if (arguments.length === 1) {
        _.each(properties, function(value, key) {

          var prevValues = that.all('key') ? that.all(key).keys() : [];
          var p = that.properties().get(key);
          if (!p) return; // Property not found on type
          
          if (p.isObjectType()) {
            that.setObjectProperty(p, _.isArray(value) ? value : [value]);
          } else {
            that.setValueProperty(p, _.isArray(value) ? value : [value]);
          }
          
          that.trigger('set', key, that.all(key).keys(), prevValues);
          that.dirty = true;
          that.g.trigger('dirty');
        });
      } else {
        return Data.Node.prototype.set.call(this, arguments[0], arguments[1], arguments[2]);
      }
    },
    

    toJSON: function() {
      var that = this;
      result = {};
      
      _.each(this._properties, function(value, key) {
        var p = that.properties().get(key);
        if (p.isObjectType()) {
          result[key] = p.unique ? that.all(key).keys()[0] : that.all(key).keys()
        } else {
          result[key] = p.unique ? that.value(key) : that.values(key).values();
        }
      });
      
      result['type'] = this.types().keys();
      result['_id'] = this._id;
      if (this._rev !== undefined) result['_rev'] = this._rev;
      if (this._deleted) result['_deleted'] = this._deleted;
      return result;
    }
  });
  
  _.extend(Data.Object.prototype, _.Events);
  
  

  
  Data.Graph = _.inherits(Data.Node, {
    constructor: function(g, dirty) {
      var that = this;
      Data.Node.call(this);
      
      this.replace('objects', new Data.Hash());
      if (!g) return;
      this.merge(g, dirty);
    },
    

    merge: function(g, dirty) {
      var that = this;
      

      var types = _.select(g, function(node, key) {
        if (node.type === '/type/type' || node.type === 'type') {
          if (!that.get('objects', key)) {
            that.set('objects', key, new Data.Type(that, key, node));
            that.get(key).dirty = dirty;
          }
          return true;
        }
        return false;
      });
      

      var objects = _.select(g, function(node, key) {
        if (node.type !== '/type/type' && node.type !== 'type') {
          var res = that.get('objects', key);
          var types = _.isArray(node.type) ? node.type : [node.type];
          
          if (!res) {
            res = new Data.Object(that, key, node);
            that.set('objects', key, res);
          } else {

            res.data = node;
          }
          

          _.each(types, function(type) {
            if (!that.get('objects', type)) {
              console.log("Type '"+type+"' not found for "+key+"...");
              throw "Type '"+type+"' not found for "+key+"...";
            }
            that.get('objects', type).set('objects', key, res);
          });
          
          that.get(key).dirty = dirty;
          
          return true;
        }
        return false;
      });

      this.objects().each(function(r, key, index) {
        if (r.data) {
          r.build();
        }
      });
    },
    

    set: function(id, properties) {
      var that = this;
      var types = _.isArray(properties.type) ? properties.type : [properties.type];
      
      if (arguments.length === 2) {
        id = id ? id : Data.uuid('/' + _.last(_.last(types).split('/')) + '/');
        
        var res = new Data.Object(that, id, properties, true);
        res.dirty = true;
        res.build();
        
        this.set('objects', id, res);
        return this.get('objects', id);
        
      } else { // Delegate to Data.Node#set
        return Data.Node.prototype.set.call(this, arguments[0], arguments[1], arguments[2]);
      }
    },
    

    get: function(id) {
      if (arguments.length === 1) {
        return this.get('objects', id);
      } else {
        return Data.Node.prototype.get.call(this, arguments[0], arguments[1]);
      }
    },
    

    getAsync: function(id, callback) {
      var that = this,
          node = this.get(id);
      
      if (!node || !node.data) {
        that.fetch({_id: id}, {}, function(err) {
          err ? callback(err) : callback(null, that.get(id));
        });
      } else {

        callback(null, node);
      }
    },
    

    del: function(id) {
      var node = this.get(id);
      if (!node) return;
      node._deleted = true;
      node.dirty = true;
      this.trigger('dirty');
    },
    

    find: function(qry) {
      return this.objects().select(function(o) {
        var so = o.toJSON();
        var rejected = false;
        _.each(qry, function(value, key) {
          var condition;

          var matches = key.match(/^([a-z_]{1,30})(!=|>|>=|<|<=|\|=)?$/),
              property = matches[1],
              operator = matches[2] || '==';
          
          if (operator === "|=") { // one of operator
            var values = _.isArray(value) ? value : [value];
            condition = false;
            _.each(values, function(val) {
              if (_.include(so[property], val)) condition = true;
            });
          } else { // regular operators
            condition = so[property] === value;
          }
          
          if (!condition) rejected = true;
        });
        return !rejected;
      });
    },
    

    fetch: function(qry, options, callback) {
      var that = this;
      
      Data.adapter.readGraph(qry, this, options, function(err, graph) {
        if (graph) {
          that.merge(graph, false);
        } // else no nodes found
        
        err ? callback(err) : callback(null, graph);
      });
    },

    sync: function(callback) {
      callback = callback || function() {};
      var that = this,
          nodes = that.dirtyNodes();
      
      var validNodes = new Data.Hash();
      

      var invalidNodes = nodes.select(function(node, key) {
        if (!node.validate || (node.validate && node.validate())) {
          validNodes.set(key, node);
          return false;
        } else {
          return true;
        }
      });
      
      Data.adapter.writeGraph(validNodes.toJSON(), function(err, g) {
        if (err) {
          callback(err);
        } else {
          that.merge(g);

          that.dirtyNodes().each(function(n) {
            n.dirty = false;
          });
          

          var conflictedNodes = _.select(g, function(node) { return node._conflicted });
          if (conflictedNodes.length > 0) that.trigger('conflicted');
          callback(invalidNodes.length > 0 ? 'Some invalid nodes' : null, invalidNodes);
        }
      });
    },
    

    filter: function(criteria) {
      var g2 = {};
      

      this.types().each(function(type, key) {
        g2[key] = type.toJSON();
      });
      

      this.objects().each(function(obj, key) {
        if (!_.include(obj.types().keys(), criteria.type)) g2[key] = obj.toJSON();
      });
      

      criteria.run(this).each(function(obj, key) {
        g2[key] = obj.toJSON();
      });

      return new Data.Graph(g2);
    },
    

    group: function(type, keys, properties) {
      var res = new Data.Collection();
      res.g = Data.Transformers.group(this, type, keys, properties);
      return res;
    },
    

    types: function() {
      return this.all('objects').select(function(node, key) {
        return node.type === '/type/type' || node.type === 'type';
      });
    },