Merge pull request #73 from strongloop/feature/fix-include

Fix the inclusion processing for list of related items

examples/inclusion.js

@@ -0,0 +1,129 @@
+var jdb = require('../index');
+
+var User, Post, Passport, City, Street, Building;
+var nbSchemaRequests = 0;
+
+setup(function () {
+
+  Passport.find({include: 'owner'}, function (err, passports) {
+    console.log('passports.owner', passports);
+  });
+
+  User.find({include: 'posts'}, function (err, users) {
+    console.log('users.posts', users);
+  });
+
+  Passport.find({include: {owner: 'posts'}}, function (err, passports) {
+    console.log('passports.owner.posts', passports);
+  });
+
+  Passport.find({
+    include: {owner: {posts: 'author'}}
+  }, function (err, passports) {
+    console.log('passports.owner.posts.author', passports);
+  });
+
+  User.find({include: ['posts', 'passports']}, function (err, users) {
+    console.log('users.passports && users.posts', users);
+  });
+
+});
+
+function setup(done) {
+  var db = new jdb.DataSource({connector: 'memory'});
+  City = db.define('City');
+  Street = db.define('Street');
+  Building = db.define('Building');
+  User = db.define('User', {
+    name: String,
+    age: Number
+  });
+  Passport = db.define('Passport', {
+    number: String
+  });
+  Post = db.define('Post', {
+    title: String
+  });
+
+  Passport.belongsTo('owner', {model: User});
+  User.hasMany('passports', {foreignKey: 'ownerId'});
+  User.hasMany('posts', {foreignKey: 'userId'});
+  Post.belongsTo('author', {model: User, foreignKey: 'userId'});
+
+  db.automigrate(function () {
+    var createdUsers = [];
+    var createdPassports = [];
+    var createdPosts = [];
+    createUsers();
+    function createUsers() {
+      clearAndCreate(
+        User,
+        [
+          {name: 'User A', age: 21},
+          {name: 'User B', age: 22},
+          {name: 'User C', age: 23},
+          {name: 'User D', age: 24},
+          {name: 'User E', age: 25}
+        ],
+        function (items) {
+          createdUsers = items;
+          createPassports();
+        }
+      );
+    }
+
+    function createPassports() {
+      clearAndCreate(
+        Passport,
+        [
+          {number: '1', ownerId: createdUsers[0].id},
+          {number: '2', ownerId: createdUsers[1].id},
+          {number: '3'}
+        ],
+        function (items) {
+          createdPassports = items;
+          createPosts();
+        }
+      );
+    }
+
+    function createPosts() {
+      clearAndCreate(
+        Post,
+        [
+          {title: 'Post A', userId: createdUsers[0].id},
+          {title: 'Post B', userId: createdUsers[0].id},
+          {title: 'Post C', userId: createdUsers[0].id},
+          {title: 'Post D', userId: createdUsers[1].id},
+          {title: 'Post E'}
+        ],
+        function (items) {
+          createdPosts = items;
+          done();
+        }
+      );
+    }
+
+  });
+}
+
+function clearAndCreate(model, data, callback) {
+  var createdItems = [];
+  model.destroyAll(function () {
+    nextItem(null, null);
+  });
+
+  var itemIndex = 0;
+
+  function nextItem(err, lastItem) {
+    if (lastItem !== null) {
+      createdItems.push(lastItem);
+    }
+    if (itemIndex >= data.length) {
+      callback(createdItems);
+      return;
+    }
+    model.create(data[itemIndex], nextItem);
+    itemIndex++;
+  }
+}

examples/nesting-schema.js

@@ -29,4 +29,5 @@ var user = new User({name: 'Joe', age: 20, address: {street: '123 Main St', 'cit
     {label: 'work', email: 'xyz@sample.com'}
   ],
   friends: ['John', 'Mary']});
+console.log(user);
 console.log(user.toObject());

index.js

@@ -1,5 +1,3 @@
-var fs = require('fs');
-
 exports.ModelBuilder = exports.LDL = require('./lib/model-builder.js').ModelBuilder;
 exports.DataSource = exports.Schema = require('./lib/datasource.js').DataSource;
 exports.ModelBaseClass = require('./lib/model.js');
@@ -14,7 +12,7 @@ exports.__defineGetter__('BaseSQL', function () {
 
 
 exports.__defineGetter__('version', function () {
-    return JSON.parse(fs.readFileSync(__dirname + '/package.json')).version;
+    return require('./package.json').version;
 });
 
 var commonTest = './test/common_test';

lib/dao.js

@@ -6,13 +6,12 @@ module.exports = DataAccessObject;
 /**
  * Module dependencies
  */
-var util = require('util');
 var jutil = require('./jutil');
 var validations = require('./validations.js');
 var ValidationError = validations.ValidationError;
-require('./relations.js');
-var Inclusion = require('./include.js');
 var Relation = require('./relations.js');
+var Inclusion = require('./include.js');
+var List = require('./list.js');
 var geo = require('./geo');
 var Memory = require('./connectors/memory').Memory;
 var utils = require('./utils');
@@ -557,12 +556,16 @@ DataAccessObject.find = function find(params, cb) {
             var includes = params.include || [];
             if (typeof includes === 'string') {
               includes = [includes];
-            } else if (typeof includes === 'object') {
+            } else if (!Array.isArray(includes) && typeof includes === 'object') {
               includes = Object.keys(includes);
             }
             includes.forEach(function (inc) {
               // Promote the included model as a direct property
-              obj.__data[inc] = obj.__cachedRelations[inc];
+              var data = obj.__cachedRelations[inc];
+              if(Array.isArray(data)) {
+                data = new List(data, null, obj);
+              }
+              obj.__data[inc] = data;
             });
             delete obj.__data.__cachedRelations;
           }

lib/datasource.js

@@ -7,11 +7,8 @@ var jutil = require('./jutil');
 var utils = require('./utils');
 var ModelBaseClass = require('./model.js');
 var DataAccessObject = require('./dao.js');
-var List = require('./list.js');
 var EventEmitter = require('events').EventEmitter;
 var util = require('util');
-var path = require('path');
-var fs = require('fs');
 var assert = require('assert');
 var async = require('async');
 

lib/list.js

@@ -1,154 +1,75 @@
+var util = require('util');
+
 module.exports = List;
 
-/**
- * List class provides functionality of nested collection
- *
- * @param {Array} data - array of items.
- * @param {Crap} type - array with some type information? TODO: rework this API.
- * @param {AbstractClass} parent - owner of list.
- * @constructor
- */
-function List(data, type, parent) {
+function List(items, itemType, parent) {
   var list = this;
   if (!(list instanceof List)) {
-    return new List(data, type, parent);
+    return new List(items, itemType, parent);
   }
 
-  if (typeof data === 'string') {
+  if (typeof items === 'string') {
     try {
-      data = JSON.parse(data);
+      items = JSON.parse(items);
     } catch (e) {
-      throw new Error('could not create List from JSON string: ', data);
+      throw new Error('could not create List from JSON string: ', items);
     }
   }
 
-  if (data && data instanceof List) data = data.items;
+  var arr = [];
+  arr.__proto__ = List.prototype;
 
-  Object.defineProperty(list, 'parent', {
-    writable: false,
-    enumerable: false,
-    configurable: false,
-    value: parent
-  });
+  items = items || [];
+  if (!Array.isArray(items)) {
+    throw new Error('Items must be an array: ' + items);
+  }
 
-  Object.defineProperty(list, 'nextid', {
+  if(!itemType) {
+    itemType = items[0] && items[0].constructor;
+  }
+
+  if (Array.isArray(itemType)) {
+    itemType = itemType[0];
+  }
+
+  Object.defineProperty(arr, 'itemType', {
     writable: true,
     enumerable: false,
-    value: 1
+    value: itemType
   });
 
-  data = list.items = data || [];
-  var Item = list.ItemType = ListItem;
-
-  if (typeof type === 'object' && type.constructor.name === 'Array') {
-    Item = list.ItemType = type[0] || ListItem;
-  }
-
-  data.forEach(function (item, i) {
-    data[i] = Item(item, list);
-    Object.defineProperty(list, data[i].id, {
+  if (parent) {
+    Object.defineProperty(arr, 'parent', {
       writable: true,
       enumerable: false,
-      configurable: true,
-      value: data[i]
+      value: parent
     });
-    if (list.nextid <= data[i].id) {
-      list.nextid = data[i].id + 1;
-    }
-  });
-
-  Object.defineProperty(list, 'length', {
-    enumerable: false,
-    configurable: true,
-    get: function () {
-      return list.items.length;
-    }
-  });
-
-  return list;
-
-}
-
-var _;
-try {
-  var underscore = 'underscore';
-  _ = require(underscore);
-} catch (e) {
-  _ = false;
-}
-
-if (_) {
-  var _import = [
-    // collection methods
-    'each',
-    'map',
-    'reduce',
-    'reduceRight',
-    'find',
-    'filter',
-    'reject',
-    'all',
-    'any',
-    'include',
-    'invoke',
-    'pluck',
-    'max',
-    'min',
-    'sortBy',
-    'groupBy',
-    'sortedIndex',
-    'shuffle',
-    'toArray',
-    'size',
-    // array methods
-    'first',
-    'initial',
-    'last',
-    'rest',
-    'compact',
-    'flatten',
-    'without',
-    'union',
-    'intersection',
-    'difference',
-    'uniq',
-    'zip',
-    'indexOf',
-    'lastIndexOf',
-    'range'
-  ];
-
-  _import.forEach(function (name) {
-    List.prototype[name] = function () {
-      var args = [].slice.call(arguments);
-      args.unshift(this.items);
-      return _[name].apply(_, args);
-    };
-  });
-}
-
-['slice', 'forEach', 'filter', 'reduce', 'map'].forEach(function (method) {
-  var slice = [].slice;
-  List.prototype[method] = function () {
-    return Array.prototype[method].apply(this.items, slice.call(arguments));
-  };
-});
-
-List.prototype.find = function (pattern, field) {
-  if (field) {
-    var res;
-    this.items.forEach(function (o) {
-      if (o[field] == pattern) res = o;
-    });
-    return res;
-  } else {
-    return this.items[this.items.indexOf(pattern)];
   }
+
+  items.forEach(function (item, i) {
+    if (itemType && !(item instanceof itemType)) {
+      arr[i] = itemType(item);
+    } else {
+      arr[i] = item;
+    }
+  });
+
+  return arr;
+}
+
+util.inherits(List, Array);
+
+var _push = List.prototype.push;
+
+List.prototype.push = function (obj) {
+  var item = this.itemType && (obj instanceof this.itemType) ? obj : this.itemType(obj);
+  _push.call(this, item);
+  return item;
 };
 
 List.prototype.toObject = function (onlySchema) {
   var items = [];
-  this.items.forEach(function (item) {
+  this.forEach(function (item) {
     if (item.toObject) {
       items.push(item.toObject(onlySchema));
     } else {
@@ -163,75 +84,15 @@ List.prototype.toJSON = function () {
 };
 
 List.prototype.toString = function () {
-  return JSON.stringify(this.items);
+  return JSON.stringify(this.toJSON());
 };
 
-List.prototype.autoincrement = function () {
-  return this.nextid++;
-};
-
-List.prototype.push = function (obj) {
-  var item = new ListItem(obj, this);
-  this.items.push(item);
-  return item;
-};
-
-List.prototype.remove = function (obj) {
-  var id = obj.id ? obj.id : obj;
-  var found = false;
-  this.items.forEach(function (o, i) {
-    if (id && o.id == id) {
-      found = i;
-      if (o.id !== id) {
-        console.log('WARNING! Type of id not matched');
-      }
-    }
-  });
-  if (found !== false) {
-    delete this[id];
-    this.items.splice(found, 1);
-  }
-};
-
-List.prototype.sort = function (cb) {
-  return this.items.sort(cb);
-};
-
-List.prototype.map = function (cb) {
-  if (typeof cb === 'function') return this.items.map(cb);
-  if (typeof cb === 'string') return this.items.map(function (el) {
-    if (typeof el[cb] === 'function') return el[cb]();
-    if (el.hasOwnProperty(cb)) return el[cb];
-  });
-};
-
-function ListItem(data, parent) {
-  if (!(this instanceof  ListItem)) {
-    return new ListItem(data, parent);
-  }
-  if (typeof data === 'object') {
-    for (var i in data) this[i] = data[i];
-  } else {
-    this.id = data;
-  }
-  Object.defineProperty(this, 'parent', {
-    writable: false,
-    enumerable: false,
-    configurable: true,
-    value: parent
-  });
-  if (!this.id) {
-    this.id = parent.autoincrement();
-  }
-  if (parent.ItemType) {
-    this.__proto__ = parent.ItemType.prototype;
-    if (parent.ItemType !== ListItem) {
-      parent.ItemType.apply(this);
-    }
-  }
-
-  this.save = function (c) {
-    parent.parent.save(c);
-  };
-}
+/*
+ var strArray = new List(['1', 2], String);
+ strArray.push(3);
+ console.log(strArray);
+ console.log(strArray.length);
 
+ console.log(strArray.toJSON());
+ console.log(strArray.toString());
+ */

lib/types.js

@@ -1,44 +1,48 @@
-module.exports = function (Types) {
+var Types = {};
+/**
+ * Schema types
+ */
+Types.Text = function Text(value) {
+  if (!(this instanceof Text)) {
+    return value;
+  }
+  this.value = value;
+}; // Text type
+
+Types.Text.prototype.toObject = Types.Text.prototype.toJSON = function () {
+  return this.value;
+};
+
+Types.JSON = function JSON(value) {
+  if (!(this instanceof JSON)) {
+    return value;
+  }
+  this.value = value;
+}; // JSON Object
+Types.JSON.prototype.toObject = Types.JSON.prototype.toJSON = function () {
+  return this.value;
+};
+
+Types.Any = function Any(value) {
+  if (!(this instanceof Any)) {
+    return value;
+  }
+  this.value = value;
+}; // Any Type
+Types.Any.prototype.toObject = Types.Any.prototype.toJSON = function () {
+  return this.value;
+};
+
+module.exports = function (modelTypes) {
 
-  var List = require('./list.js');
   var GeoPoint = require('./geo').GeoPoint;
 
-  /**
-   * Schema types
-   */
-  Types.Text = function Text(value) {
-    if (!(this instanceof Text)) {
-      return value;
-    }
-    this.value = value;
-  }; // Text type
+  for(var t in Types) {
+    modelTypes[t] = Types[t];
+  }
 
-  Types.Text.prototype.toObject = Types.Text.prototype.toJSON = function () {
-    return this.value;
-  };
-
-  Types.JSON = function JSON(value) {
-    if (!(this instanceof JSON)) {
-      return value;
-    }
-    this.value = value;
-  }; // JSON Object
-  Types.JSON.prototype.toObject = Types.JSON.prototype.toJSON = function () {
-    return this.value;
-  };
-
-  Types.Any = function Any(value) {
-    if (!(this instanceof Any)) {
-      return value;
-    }
-    this.value = value;
-  }; // Any Type
-  Types.Any.prototype.toObject = Types.Any.prototype.toJSON = function () {
-    return this.value;
-  };
-
-  Types.schemaTypes = {};
-  Types.registerType = function (type, names) {
+  modelTypes.schemaTypes = {};
+  modelTypes.registerType = function (type, names) {
     names = names || [];
     names = names.concat([type.name]);
     for (var n = 0; n < names.length; n++) {
@@ -46,16 +50,18 @@ module.exports = function (Types) {
     }
   };
 
-  Types.registerType(Types.Text);
-  Types.registerType(Types.JSON);
-  Types.registerType(Types.Any);
+  modelTypes.registerType(Types.Text);
+  modelTypes.registerType(Types.JSON);
+  modelTypes.registerType(Types.Any);
 
-  Types.registerType(String);
-  Types.registerType(Number);
-  Types.registerType(Boolean);
-  Types.registerType(Date);
-  Types.registerType(Buffer, ['Binary']);
-  Types.registerType(Array);
-  Types.registerType(GeoPoint);
-  Types.registerType(Object);
-};
+  modelTypes.registerType(String);
+  modelTypes.registerType(Number);
+  modelTypes.registerType(Boolean);
+  modelTypes.registerType(Date);
+  modelTypes.registerType(Buffer, ['Binary']);
+  modelTypes.registerType(Array);
+  modelTypes.registerType(GeoPoint);
+  modelTypes.registerType(Object);
+};
+
+module.exports.Types = Types;

test/include.test.js

@@ -117,8 +117,15 @@ describe('include', function () {
         // The relation should be promoted as the 'owner' property
         user.should.have.property('posts');
         user.should.have.property('passports');
+
+        var userObj = user.toJSON();
+        userObj.should.have.property('posts');
+        userObj.should.have.property('passports');
+        userObj.posts.should.be.an.instanceOf(Array);
+        userObj.passports.should.be.an.instanceOf(Array);
+
         // The __cachedRelations should be removed from json output
-        user.toJSON().should.not.have.property('__cachedRelations');
+        userObj.should.not.have.property('__cachedRelations');
 
         user.__cachedRelations.should.have.property('posts');
         user.__cachedRelations.should.have.property('passports');