diff --git a/examples/app-noschema.js b/examples/app-noschema.js
index 830af704..0da64cfc 100644
--- a/examples/app-noschema.js
+++ b/examples/app-noschema.js
@@ -10,36 +10,36 @@ var introspectType = require('../lib/introspection')(ModelBuilder);
 var ds = new DataSource('memory');
 
 // Create a open model that doesn't require a schema
-var Application = ds.createModel('Schemaless', {}, {strict: false});
+var Application = ds.createModel('Schemaless', {}, { strict: false });
 
 var application = {
   owner: 'rfeng',
   name: 'MyApp1',
   description: 'My first app',
   pushSettings: [
-    {   "platform": "apns",
-      "apns": {
-        "pushOptions": {
-          "gateway": "gateway.sandbox.push.apple.com",
-          "cert": "credentials/apns_cert_dev.pem",
-          "key": "credentials/apns_key_dev.pem"
+    {   'platform': 'apns',
+      'apns': {
+        'pushOptions': {
+          'gateway': 'gateway.sandbox.push.apple.com',
+          'cert': 'credentials/apns_cert_dev.pem',
+          'key': 'credentials/apns_key_dev.pem',
         },
 
-        "feedbackOptions": {
-          "gateway": "feedback.sandbox.push.apple.com",
-          "cert": "credentials/apns_cert_dev.pem",
-          "key": "credentials/apns_key_dev.pem",
-          "batchFeedback": true,
-          "interval": 300
-        }
-      }}
-  ]}
+        'feedbackOptions': {
+          'gateway': 'feedback.sandbox.push.apple.com',
+          'cert': 'credentials/apns_cert_dev.pem',
+          'key': 'credentials/apns_key_dev.pem',
+          'batchFeedback': true,
+          'interval': 300,
+        },
+      }},
+  ] };
 
 console.log(new Application(application).toObject());
 
-Application.create(application, function (err, app1) {
+Application.create(application, function(err, app1) {
   console.log('Created: ', app1.toObject());
-  Application.findById(app1.id, function (err, app2) {
+  Application.findById(app1.id, function(err, app2) {
     console.log('Found: ', app2.toObject());
   });
 });
@@ -55,30 +55,30 @@ var user = {
     city: 'San Jose',
     state: 'CA',
     zipcode: '95131',
-    country: 'US'
+    country: 'US',
   },
   friends: ['John', 'Mary'],
   emails: [
-    {label: 'work', id: 'x@sample.com'},
-    {label: 'home', id: 'x@home.com'}
+    { label: 'work', id: 'x@sample.com' },
+    { label: 'home', id: 'x@home.com' },
   ],
-  tags: []
+  tags: [],
 };
 
 // Introspect the JSON document to generate a schema
 var schema = introspectType(user);
 
 // Create a model for the generated schema
-var User = ds.createModel('User', schema, {idInjection: true});
+var User = ds.createModel('User', schema, { idInjection: true });
 
 // Use the model for CRUD
 var obj = new User(user);
 
 console.log(obj.toObject());
 
-User.create(user, function (err, u1) {
+User.create(user, function(err, u1) {
   console.log('Created: ', u1.toObject());
-  User.findById(u1.id, function (err, u2) {
+  User.findById(u1.id, function(err, u2) {
     console.log('Found: ', u2.toObject());
   });
 });
diff --git a/examples/app.js b/examples/app.js
index 8a96baec..f4392ec7 100644
--- a/examples/app.js
+++ b/examples/app.js
@@ -9,11 +9,11 @@ var modelBuilder = new ModelBuilder();
 var Post = modelBuilder.define('Post', {
   title: { type: String, length: 255 },
   content: { type: ModelBuilder.Text },
-  date: { type: Date, default: function () {
+  date: { type: Date, default: function() {
     return new Date();
   } },
   timestamp: { type: Number, default: Date.now },
-  published: { type: Boolean, default: false, index: true }
+  published: { type: Boolean, default: false, index: true },
 });
 
 // simpler way to describe model
@@ -22,24 +22,24 @@ var User = modelBuilder.define('User', {
   bio: ModelBuilder.Text,
   approved: Boolean,
   joinedAt: Date,
-  age: Number
+  age: Number,
 });
 
-var Group = modelBuilder.define('Group', {group: String});
+var Group = modelBuilder.define('Group', { group: String });
 
 // define any custom method
-User.prototype.getNameAndAge = function () {
+User.prototype.getNameAndAge = function() {
   return this.name + ', ' + this.age;
 };
 
-var user = new User({name: 'Joe'});
+var user = new User({ name: 'Joe' });
 console.log(user);
 
 console.log(modelBuilder.models);
 console.log(modelBuilder.definitions);
 
 User.mixin(Group);
-var user = new User({name: 'Ray', group: 'Admin'});
+var user = new User({ name: 'Ray', group: 'Admin' });
 console.log(user);
 
 
diff --git a/examples/datasource-app.js b/examples/datasource-app.js
index df142bfe..fe9e656e 100644
--- a/examples/datasource-app.js
+++ b/examples/datasource-app.js
@@ -11,11 +11,11 @@ var ds = new DataSource('memory');
 var Post = ds.define('Post', {
   title: { type: String, length: 255 },
   content: { type: DataSource.Text },
-  date: { type: Date, default: function () {
+  date: { type: Date, default: function() {
     return new Date;
   } },
   timestamp: { type: Number, default: Date.now },
-  published: { type: Boolean, default: false, index: true }
+  published: { type: Boolean, default: false, index: true },
 });
 
 // simplier way to describe model
@@ -24,31 +24,31 @@ var User = ds.define('User', {
   bio: DataSource.Text,
   approved: Boolean,
   joinedAt: Date,
-  age: Number
+  age: Number,
 });
 
-var Group = ds.define('Group', {name: String});
+var Group = ds.define('Group', { name: String });
 
 // define any custom method
-User.prototype.getNameAndAge = function () {
+User.prototype.getNameAndAge = function() {
   return this.name + ', ' + this.age;
 };
 
-var user = new User({name: 'Joe'});
+var user = new User({ name: 'Joe' });
 console.log(user);
 
 // console.log(ds.models);
 // console.log(ds.definitions);
 
 // setup relationships
-User.hasMany(Post, {as: 'posts', foreignKey: 'userId'});
+User.hasMany(Post, { as: 'posts', foreignKey: 'userId' });
 
 // creates instance methods:
 // user.posts(conds)
 // user.posts.build(data) // like new Post({userId: user.id});
 // user.posts.create(data) // build and save
 
-Post.belongsTo(User, {as: 'author', foreignKey: 'userId'});
+Post.belongsTo(User, { as: 'author', foreignKey: 'userId' });
 // creates instance methods:
 // post.author(callback) -- getter when called with function
 // post.author() -- sync getter when called without params
@@ -56,46 +56,46 @@ Post.belongsTo(User, {as: 'author', foreignKey: 'userId'});
 
 User.hasAndBelongsToMany('groups');
 
-var user2 = new User({name: 'Smith', age: 14});
-user2.save(function (err) {
+var user2 = new User({ name: 'Smith', age: 14 });
+user2.save(function(err) {
   console.log(user2);
-  var post = user2.posts.build({title: 'Hello world'});
-  post.save(function (err, data) {
+  var post = user2.posts.build({ title: 'Hello world' });
+  post.save(function(err, data) {
     console.log(err ? err : data);
   });
 });
 
-Post.findOne({where: {published: false}, order: 'date DESC'}, function (err, data) {
+Post.findOne({ where: { published: false }, order: 'date DESC' }, function(err, data) {
   console.log(data);
 });
 
-User.create({name: 'Jeff', age: 12}, function (err, data) {
+User.create({ name: 'Jeff', age: 12 }, function(err, data) {
   if (err) {
     console.log(err);
     return;
   }
   console.log(data);
-  var post = data.posts.build({title: 'My Post'});
+  var post = data.posts.build({ title: 'My Post' });
   console.log(post);
 });
 
-User.create({name: 'Ray'}, function (err, data) {
+User.create({ name: 'Ray' }, function(err, data) {
   console.log(data);
 });
 
-User.scope('minors', {where: {age: {lte: 16}}, include: 'posts'});
-User.minors(function (err, kids) {
+User.scope('minors', { where: { age: { lte: 16 }}, include: 'posts' });
+User.minors(function(err, kids) {
   console.log('Kids: ', kids);
 });
 
-var Article = ds.define('Article', {title: String});
-var Tag = ds.define('Tag', {name: String});
+var Article = ds.define('Article', { title: String });
+var Tag = ds.define('Tag', { name: String });
 Article.hasAndBelongsToMany('tags');
 
-Article.create(function (e, article) {
-  article.tags.create({name: 'popular'}, function (err, data) {
-    Article.findOne(function (e, article) {
-      article.tags(function (e, tags) {
+Article.create(function(e, article) {
+  article.tags.create({ name: 'popular' }, function(err, data) {
+    Article.findOne(function(e, article) {
+      article.tags(function(e, tags) {
         console.log(tags);
       });
     });
@@ -106,17 +106,17 @@ Article.create(function (e, article) {
 var modelBuilder = new ModelBuilder();
 
 Color = modelBuilder.define('Color', {
-  name: String
+  name: String,
 });
 
 // attach
 ds.attach(Color);
 
-Color.create({name: 'red'});
-Color.create({name: 'green'});
-Color.create({name: 'blue'});
+Color.create({ name: 'red' });
+Color.create({ name: 'green' });
+Color.create({ name: 'blue' });
 
-Color.all(function (err, colors) {
+Color.all(function(err, colors) {
   console.log(colors);
 });
 
diff --git a/examples/inclusion.js b/examples/inclusion.js
index 5bca6398..148f98b1 100644
--- a/examples/inclusion.js
+++ b/examples/inclusion.js
@@ -8,54 +8,54 @@ var jdb = require('../index');
 var User, Post, Passport, City, Street, Building;
 var nbSchemaRequests = 0;
 
-setup(function () {
+setup(function() {
 
-  Passport.find({include: 'owner'}, function (err, passports) {
+  Passport.find({ include: 'owner' }, function(err, passports) {
     console.log('passports.owner', passports);
   });
 
-  User.find({include: 'posts'}, function (err, users) {
+  User.find({ include: 'posts' }, function(err, users) {
     console.log('users.posts', users);
   });
 
-  Passport.find({include: {owner: 'posts'}}, function (err, passports) {
+  Passport.find({ include: { owner: 'posts' }}, function(err, passports) {
     console.log('passports.owner.posts', passports);
   });
 
   Passport.find({
-    include: {owner: {posts: 'author'}}
-  }, function (err, passports) {
+    include: { owner: { posts: 'author' }},
+  }, function(err, passports) {
     console.log('passports.owner.posts.author', passports);
   });
 
-  User.find({include: ['posts', 'passports']}, function (err, users) {
+  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'});
+  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
+    age: Number,
   });
   Passport = db.define('Passport', {
-    number: String
+    number: String,
   });
   Post = db.define('Post', {
-    title: String
+    title: String,
   });
 
-  Passport.belongsTo('owner', {model: User});
-  User.hasMany('passports', {foreignKey: 'ownerId'});
-  User.hasMany('posts', {foreignKey: 'userId'});
-  Post.belongsTo('author', {model: User, foreignKey: 'userId'});
+  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 () {
+  db.automigrate(function() {
     var createdUsers = [];
     var createdPassports = [];
     var createdPosts = [];
@@ -64,13 +64,13 @@ function setup(done) {
       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}
+          { 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) {
+        function(items) {
           createdUsers = items;
           createPassports();
         }
@@ -81,11 +81,11 @@ function setup(done) {
       clearAndCreate(
         Passport,
         [
-          {number: '1', ownerId: createdUsers[0].id},
-          {number: '2', ownerId: createdUsers[1].id},
-          {number: '3'}
+          { number: '1', ownerId: createdUsers[0].id },
+          { number: '2', ownerId: createdUsers[1].id },
+          { number: '3' },
         ],
-        function (items) {
+        function(items) {
           createdPassports = items;
           createPosts();
         }
@@ -96,13 +96,13 @@ function setup(done) {
       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'}
+          { 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) {
+        function(items) {
           createdPosts = items;
           done();
         }
@@ -114,7 +114,7 @@ function setup(done) {
 
 function clearAndCreate(model, data, callback) {
   var createdItems = [];
-  model.destroyAll(function () {
+  model.destroyAll(function() {
     nextItem(null, null);
   });
 
diff --git a/examples/nesting-schema.js b/examples/nesting-schema.js
index e7c8ac37..0588dba5 100644
--- a/examples/nesting-schema.js
+++ b/examples/nesting-schema.js
@@ -18,21 +18,21 @@ var User = modelBuilder.define('User', {
     city: String,
     state: String,
     zipCode: String,
-    country: String
+    country: String,
   },
   emails: [
     {
       label: String,
-      email: String
-    }
+      email: String,
+    },
   ],
-  friends: [String]
+  friends: [String],
 });
 
-var user = new User({name: 'Joe', age: 20, address: {street: '123 Main St', 'city': 'San Jose', state: 'CA'},
+var user = new User({ name: 'Joe', age: 20, address: { street: '123 Main St', 'city': 'San Jose', state: 'CA' },
   emails: [
-    {label: 'work', email: 'xyz@sample.com'}
+    { label: 'work', email: 'xyz@sample.com' },
   ],
-  friends: ['John', 'Mary']});
+  friends: ['John', 'Mary'] });
 console.log(user);
 console.log(user.toObject());
diff --git a/examples/relations.js b/examples/relations.js
index f4afd159..6374497f 100644
--- a/examples/relations.js
+++ b/examples/relations.js
@@ -9,55 +9,55 @@ var ds = new DataSource('memory');
 var Order = ds.createModel('Order', {
   items: [String],
   orderDate: Date,
-  qty: Number
+  qty: Number,
 });
 
 var Customer = ds.createModel('Customer', {
-  name: String
+  name: String,
 });
 
 Order.belongsTo(Customer);
 
 var order1, order2, order3;
 
-Customer.create({name: 'John'}, function (err, customer) {
-  Order.create({customerId: customer.id, orderDate: new Date(), items: ['Book']}, function (err, order) {
+Customer.create({ name: 'John' }, function(err, customer) {
+  Order.create({ customerId: customer.id, orderDate: new Date(), items: ['Book'] }, function(err, order) {
     order1 = order;
     order.customer(console.log);
     order.customer(true, console.log);
 
-    Customer.create({name: 'Mary'}, function (err, customer2) {
+    Customer.create({ name: 'Mary' }, function(err, customer2) {
       order.customer(customer2);
       order.customer(console.log);
     });
   });
 
-  Order.create({orderDate: new Date(), items: ['Phone']}, function (err, order) {
+  Order.create({ orderDate: new Date(), items: ['Phone'] }, function(err, order) {
 
-    order.customer.create({name: 'Smith'}, function(err, customer2) {
+    order.customer.create({ name: 'Smith' }, function(err, customer2) {
       console.log(order, customer2);
       order.save(function(err, order) {
         order2 = order;
       });
     });
 
-    var customer3 = order.customer.build({name: 'Tom'});
+    var customer3 = order.customer.build({ name: 'Tom' });
     console.log('Customer 3', customer3);
   });
 });
 
-Customer.hasMany(Order, {as: 'orders', foreignKey: 'customerId'});
+Customer.hasMany(Order, { as: 'orders', foreignKey: 'customerId' });
 
-Customer.create({name: 'Ray'}, function (err, customer) {
-  Order.create({customerId: customer.id, qty: 3, orderDate: new Date()}, function (err, order) {
+Customer.create({ name: 'Ray' }, function(err, customer) {
+  Order.create({ customerId: customer.id, qty: 3, orderDate: new Date() }, function(err, order) {
     order3 = order;
     customer.orders(console.log);
-    customer.orders.create({orderDate: new Date(), qty: 4}, function (err, order) {
+    customer.orders.create({ orderDate: new Date(), qty: 4 }, function(err, order) {
       console.log(order);
-      Customer.include([customer], 'orders', function (err, results) {
+      Customer.include([customer], 'orders', function(err, results) {
         console.log('Results: ', results);
       });
-      customer.orders({where: {qty: 4}}, function(err, results) {
+      customer.orders({ where: { qty: 4 }}, function(err, results) {
         console.log('customer.orders', results);
       });
       customer.orders.findById(order3.id, console.log);
@@ -67,43 +67,43 @@ Customer.create({name: 'Ray'}, function (err, customer) {
 });
 
 var Physician = ds.createModel('Physician', {
-  name: String
+  name: String,
 });
 
 var Patient = ds.createModel('Patient', {
-  name: String
+  name: String,
 });
 
 var Appointment = ds.createModel('Appointment', {
   physicianId: Number,
   patientId: Number,
-  appointmentDate: Date
+  appointmentDate: Date,
 });
 
 Appointment.belongsTo(Patient);
 Appointment.belongsTo(Physician);
 
-Physician.hasMany(Patient, {through: Appointment});
-Patient.hasMany(Physician, {through: Appointment});
+Physician.hasMany(Patient, { through: Appointment });
+Patient.hasMany(Physician, { through: Appointment });
 
-Physician.create({name: 'Dr John'}, function (err, physician1) {
-  Physician.create({name: 'Dr Smith'}, function (err, physician2) {
-    Patient.create({name: 'Mary'}, function (err, patient1) {
-      Patient.create({name: 'Ben'}, function (err, patient2) {
-        Appointment.create({appointmentDate: new Date(), physicianId: physician1.id, patientId: patient1.id},
-          function (err, appt1) {
-            Appointment.create({appointmentDate: new Date(), physicianId: physician1.id, patientId: patient2.id},
-              function (err, appt2) {
+Physician.create({ name: 'Dr John' }, function(err, physician1) {
+  Physician.create({ name: 'Dr Smith' }, function(err, physician2) {
+    Patient.create({ name: 'Mary' }, function(err, patient1) {
+      Patient.create({ name: 'Ben' }, function(err, patient2) {
+        Appointment.create({ appointmentDate: new Date(), physicianId: physician1.id, patientId: patient1.id },
+          function(err, appt1) {
+            Appointment.create({ appointmentDate: new Date(), physicianId: physician1.id, patientId: patient2.id },
+              function(err, appt2) {
                 physician1.patients(console.log);
-                physician1.patients({where: {name: 'Mary'}}, console.log);
+                physician1.patients({ where: { name: 'Mary' }}, console.log);
                 patient1.physicians(console.log);
 
                 // Build an appointment?
-                var patient3 = patient1.physicians.build({name: 'Dr X'});
+                var patient3 = patient1.physicians.build({ name: 'Dr X' });
                 console.log('Physician 3: ', patient3, patient3.constructor.modelName);
 
                 // Create a physician?
-                patient1.physicians.create({name: 'Dr X'}, function(err, patient4) {
+                patient1.physicians.create({ name: 'Dr X' }, function(err, patient4) {
                   console.log('Physician 4: ', patient4, patient4.constructor.modelName);
                 });
 
@@ -116,32 +116,32 @@ Physician.create({name: 'Dr John'}, function (err, physician1) {
 });
 
 var Assembly = ds.createModel('Assembly', {
-  name: String
+  name: String,
 });
 
 var Part = ds.createModel('Part', {
-  partNumber: String
+  partNumber: String,
 });
 
 Assembly.hasAndBelongsToMany(Part);
 Part.hasAndBelongsToMany(Assembly);
 
-Assembly.create({name: 'car'}, function (err, assembly) {
-  Part.create({partNumber: 'engine'}, function (err, part) {
-    assembly.parts.add(part, function (err) {
+Assembly.create({ name: 'car' }, function(err, assembly) {
+  Part.create({ partNumber: 'engine' }, function(err, part) {
+    assembly.parts.add(part, function(err) {
       assembly.parts(function(err, parts) {
         console.log('Parts: ', parts);
       });
 
       // Build an part?
-      var part3 = assembly.parts.build({partNumber: 'door'});
+      var part3 = assembly.parts.build({ partNumber: 'door' });
       console.log('Part3: ', part3, part3.constructor.modelName);
 
       // Create a part?
-      assembly.parts.create({partNumber: 'door'}, function(err, part4) {
+      assembly.parts.create({ partNumber: 'door' }, function(err, part4) {
         console.log('Part4: ', part4, part4.constructor.modelName);
 
-        Assembly.find({include: 'parts'}, function(err, assemblies) {
+        Assembly.find({ include: 'parts' }, function(err, assemblies) {
           console.log('Assemblies: ', assemblies);
         });
       });
diff --git a/index.js b/index.js
index 298e4ab0..a20d104d 100644
--- a/index.js
+++ b/index.js
@@ -10,12 +10,12 @@ exports.GeoPoint = require('./lib/geo.js').GeoPoint;
 exports.ValidationError = require('./lib/validations.js').ValidationError;
 
 Object.defineProperty(exports, 'version', {
-  get: function() {return require('./package.json').version;}
+  get: function() { return require('./package.json').version; },
 });
 
 var commonTest = './test/common_test';
 Object.defineProperty(exports, 'test', {
-  get: function() {return require(commonTest);}
+  get: function() { return require(commonTest); },
 });
 
 exports.Transaction = require('loopback-connector').Transaction;
diff --git a/lib/connectors/memory.js b/lib/connectors/memory.js
index b3b39497..0464876f 100644
--- a/lib/connectors/memory.js
+++ b/lib/connectors/memory.js
@@ -49,7 +49,7 @@ Memory.prototype.getTypes = function() {
   return ['db', 'nosql', 'memory'];
 };
 
-Memory.prototype.connect = function (callback) {
+Memory.prototype.connect = function(callback) {
   if (this.isTransaction) {
     this.onTransactionExec = callback;
   } else {
@@ -58,17 +58,17 @@ Memory.prototype.connect = function (callback) {
 };
 
 function serialize(obj) {
-  if(obj === null || obj === undefined) {
+  if (obj === null || obj === undefined) {
     return obj;
   }
   return JSON.stringify(obj);
 }
 
 function deserialize(dbObj) {
-  if(dbObj === null || dbObj === undefined) {
+  if (dbObj === null || dbObj === undefined) {
     return dbObj;
   }
-  if(typeof dbObj === 'string') {
+  if (typeof dbObj === 'string') {
     return JSON.parse(dbObj);
   } else {
     return dbObj;
@@ -81,12 +81,12 @@ Memory.prototype.getCollection = function(model) {
     model = modelClass.settings.memory.collection || model;
   }
   return model;
-}
+};
 
 Memory.prototype.initCollection = function(model) {
   this.collection(model, {});
   this.collectionSeq(model, 1);
-}
+};
 
 Memory.prototype.collection = function(model, val) {
   model = this.getCollection(model);
@@ -106,14 +106,14 @@ Memory.prototype.loadFromFile = function(callback) {
   var localStorage = hasLocalStorage && this.settings.localStorage;
 
   if (self.settings.file) {
-    fs.readFile(self.settings.file, {encoding: 'utf8', flag: 'r'}, function (err, data) {
+    fs.readFile(self.settings.file, { encoding: 'utf8', flag: 'r' }, function(err, data) {
       if (err && err.code !== 'ENOENT') {
         callback && callback(err);
       } else {
         parseAndLoad(data);
       }
     });
-  } else if(localStorage) {
+  } else if (localStorage) {
     var data = window.localStorage.getItem(localStorage);
     data = data || '{}';
     parseAndLoad(data);
@@ -125,14 +125,14 @@ Memory.prototype.loadFromFile = function(callback) {
     if (data) {
       try {
         data = JSON.parse(data.toString());
-      } catch(e) {
+      } catch (e) {
         return callback(e);
       }
 
       self.ids = data.ids || {};
       self.cache = data.models || {};
     } else {
-      if(!self.cache) {
+      if (!self.cache) {
         self.ids = {};
         self.cache = {};
       }
@@ -145,22 +145,22 @@ Memory.prototype.loadFromFile = function(callback) {
  * Flush the cache into the json file if necessary
  * @param {Function} callback
  */
-Memory.prototype.saveToFile = function (result, callback) {
+Memory.prototype.saveToFile = function(result, callback) {
   var self = this;
   var file = this.settings.file;
   var hasLocalStorage = typeof window !== 'undefined' && window.localStorage;
   var localStorage = hasLocalStorage && this.settings.localStorage;
   if (file) {
-    if(!self.writeQueue) {
+    if (!self.writeQueue) {
       // Create a queue for writes
-      self.writeQueue = async.queue(function (task, cb) {
+      self.writeQueue = async.queue(function(task, cb) {
         // Flush out the models/ids
         var data = JSON.stringify({
           ids: self.ids,
-          models: self.cache
+          models: self.cache,
         }, null, '  ');
 
-        fs.writeFile(self.settings.file, data, function (err) {
+        fs.writeFile(self.settings.file, data, function(err) {
           cb(err);
           task.callback && task.callback(err, task.data);
         });
@@ -169,20 +169,20 @@ Memory.prototype.saveToFile = function (result, callback) {
     // Enqueue the write
     self.writeQueue.push({
       data: result,
-      callback: callback
+      callback: callback,
     });
   } else if (localStorage) {
     // Flush out the models/ids
     var data = JSON.stringify({
       ids: self.ids,
-      models: self.cache
+      models: self.cache,
     }, null, '  ');
     window.localStorage.setItem(localStorage, data);
-    process.nextTick(function () {
+    process.nextTick(function() {
       callback && callback(null, result);
     });
   } else {
-    process.nextTick(function () {
+    process.nextTick(function() {
       callback && callback(null, result);
     });
   }
@@ -191,7 +191,7 @@ Memory.prototype.saveToFile = function (result, callback) {
 Memory.prototype.define = function defineModel(definition) {
   this.constructor.super_.prototype.define.apply(this, [].slice.call(arguments));
   var m = definition.model.modelName;
-  if(!this.collection(m)) this.initCollection(m);
+  if (!this.collection(m)) this.initCollection(m);
 };
 
 Memory.prototype._createSync = function(model, data, fn) {
@@ -235,15 +235,15 @@ Memory.prototype.create = function create(model, data, options, callback) {
   });
 };
 
-Memory.prototype.updateOrCreate = function (model, data, options, callback) {
+Memory.prototype.updateOrCreate = function(model, data, options, callback) {
   var self = this;
-  this.exists(model, self.getIdValue(model, data), options, function (err, exists) {
+  this.exists(model, self.getIdValue(model, data), options, function(err, exists) {
     if (exists) {
       self.save(model, data, options, function(err, data) {
         callback(err, data, { isNewInstance: false });
       });
     } else {
-      self.create(model, data, options, function (err, id) {
+      self.create(model, data, options, function(err, id) {
         self.setIdValue(model, data, id);
         callback(err, data, { isNewInstance: true });
       });
@@ -256,7 +256,7 @@ Memory.prototype.findOrCreate = function(model, filter, data, callback) {
   var nodes = self._findAllSkippingIncludes(model, filter);
   var found = nodes[0];
 
-  if(!found) {
+  if (!found) {
     // Calling _createSync to update the collection in a sync way and to guarantee to create it in the same turn of even loop
     return self._createSync(model, data, function(err, id) {
       if (err) return callback(err);
@@ -272,7 +272,7 @@ Memory.prototype.findOrCreate = function(model, filter, data, callback) {
       callback(null, found, false);
     });
   }
-   
+
   self._models[model].model.include(nodes[0], filter.include, {}, function(err, nodes) {
     process.nextTick(function() {
       if (err) return callback(err);
@@ -297,13 +297,13 @@ Memory.prototype.save = function save(model, data, options, callback) {
 };
 
 Memory.prototype.exists = function exists(model, id, options, callback) {
-  process.nextTick(function () {
+  process.nextTick(function() {
     callback(null, this.collection(model) && this.collection(model).hasOwnProperty(id));
   }.bind(this));
 };
 
 Memory.prototype.find = function find(model, id, options, callback) {
-  process.nextTick(function () {
+  process.nextTick(function() {
     callback(null, id in this.collection(model) && this.fromDb(model, this.collection(model)[id]));
   }.bind(this));
 };
@@ -314,7 +314,7 @@ Memory.prototype.destroy = function destroy(model, id, options, callback) {
   this.saveToFile({ count: exists ? 1 : 0 }, callback);
 };
 
-Memory.prototype.fromDb = function (model, data) {
+Memory.prototype.fromDb = function(model, data) {
   if (!data) return null;
   data = deserialize(data);
   var props = this._models[model].properties;
@@ -357,7 +357,7 @@ function getValue(obj, path) {
 }
 
 Memory.prototype._findAllSkippingIncludes = function(model, filter) {
-  var nodes = Object.keys(this.collection(model)).map(function (key) {
+  var nodes = Object.keys(this.collection(model)).map(function(key) {
     return this.fromDb(model, this.collection(model)[key]);
   }.bind(this));
 
@@ -371,17 +371,17 @@ Memory.prototype._findAllSkippingIncludes = function(model, filter) {
     // do we need some sorting?
     if (filter.order) {
       var orders = filter.order;
-      if (typeof filter.order === "string") {
+      if (typeof filter.order === 'string') {
         orders = [filter.order];
       }
-      orders.forEach(function (key, i) {
+      orders.forEach(function(key, i) {
         var reverse = 1;
         var m = key.match(/\s+(A|DE)SC$/i);
         if (m) {
           key = key.replace(/\s+(A|DE)SC/i, '');
           if (m[1].toLowerCase() === 'de') reverse = -1;
         }
-        orders[i] = {"key": key, "reverse": reverse};
+        orders[i] = { 'key': key, 'reverse': reverse };
       });
       nodes = nodes.sort(sorting.bind(orders));
     }
@@ -408,7 +408,7 @@ Memory.prototype._findAllSkippingIncludes = function(model, filter) {
     nodes = nodes.slice(skip, skip + limit);
   }
   return nodes;
-  
+
   function sorting(a, b) {
     var undefinedA, undefinedB;
 
@@ -448,18 +448,18 @@ function applyFilter(filter) {
     return where;
   }
   var keys = Object.keys(where);
-  return function (obj) {
+  return function(obj) {
     return keys.every(function(key) {
-      if(key === 'and' || key === 'or') {
-        if(Array.isArray(where[key])) {
-          if(key === 'and') {
+      if (key === 'and' || key === 'or') {
+        if (Array.isArray(where[key])) {
+          if (key === 'and') {
             return where[key].every(function(cond) {
-              return applyFilter({where: cond})(obj);
+              return applyFilter({ where: cond })(obj);
             });
           }
-          if(key === 'or') {
+          if (key === 'or') {
             return where[key].some(function(cond) {
-              return applyFilter({where: cond})(obj);
+              return applyFilter({ where: cond })(obj);
             });
           }
         }
@@ -475,8 +475,8 @@ function applyFilter(filter) {
         if (matcher.neq !== undefined && value.length <= 0) {
           return true;
         }
-        return value.some(function (v, i) {
-          var filter = {where: {}};
+        return value.some(function(v, i) {
+          var filter = { where: {}};
           filter.where[i] = matcher;
           return applyFilter(filter)(value);
         });
@@ -492,15 +492,15 @@ function applyFilter(filter) {
       var dotIndex = key.indexOf('.');
       var subValue = obj[key.substring(0, dotIndex)];
       if (dotIndex !== -1 && Array.isArray(subValue)) {
-        var subFilter = {where: {}};
-        var subKey = key.substring(dotIndex+1);
+        var subFilter = { where: {}};
+        var subKey = key.substring(dotIndex + 1);
         subFilter.where[subKey] = where[key];
         return subValue.some(applyFilter(subFilter));
       }
 
       return false;
     });
-  }
+  };
 
   function toRegExp(pattern) {
     if (pattern instanceof RegExp) {
@@ -509,7 +509,7 @@ function applyFilter(filter) {
     var regex = '';
     // Escaping user input to be treated as a literal string within a regular expression
     // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Writing_a_Regular_Expression_Pattern
-    pattern = pattern.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1");
+    pattern = pattern.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, '\\$1');
     for (var i = 0, n = pattern.length; i < n; i++) {
       var char = pattern.charAt(i);
       if (char === '\\') {
@@ -526,8 +526,7 @@ function applyFilter(filter) {
         regex += '\\.';
       } else if (char === '*') {
         regex += '\\*';
-      }
-      else {
+      } else {
         regex += char;
       }
     }
@@ -567,13 +566,12 @@ function applyFilter(filter) {
         return compare(example.neq, value) !== 0;
       }
 
-      if ('between' in example ) {
-        return ( testInEquality({gte:example.between[0]}, value) &&
-                 testInEquality({lte:example.between[1]}, value) );
+      if ('between' in example) {
+        return (testInEquality({ gte: example.between[0] }, value) &&
+          testInEquality({ lte: example.between[1] }, value));
       }
 
       if (example.like || example.nlike) {
-
         var like = example.like || example.nlike;
         if (typeof like === 'string') {
           like = toRegExp(like);
@@ -592,8 +590,8 @@ function applyFilter(filter) {
       }
     }
     // not strict equality
-    return (example !== null ? example.toString() : example)
-      == (value != null ? value.toString() : value);
+    return (example !== null ? example.toString() : example) ==
+      (value != null ? value.toString() : value);
   }
 
   /**
@@ -604,7 +602,7 @@ function applyFilter(filter) {
    * @private
    */
   function compare(val1, val2) {
-    if(val1 == null || val2 == null) {
+    if (val1 == null || val2 == null) {
       // Either val1 or val2 is null or undefined
       return val1 == val2 ? 0 : NaN;
     }
@@ -647,8 +645,8 @@ Memory.prototype.destroyAll = function destroyAll(model, where, options, callbac
   var filter = null;
   var count = 0;
   if (where) {
-    filter = applyFilter({where: where});
-    Object.keys(cache).forEach(function (id) {
+    filter = applyFilter({ where: where });
+    Object.keys(cache).forEach(function(id) {
       if (!filter || filter(this.fromDb(model, cache[id]))) {
         count++;
         delete cache[id];
@@ -665,13 +663,13 @@ Memory.prototype.count = function count(model, where, options, callback) {
   var cache = this.collection(model);
   var data = Object.keys(cache);
   if (where) {
-    var filter = {where: where};
-    data = data.map(function (id) {
+    var filter = { where: where };
+    data = data.map(function(id) {
       return this.fromDb(model, cache[id]);
     }.bind(this));
     data = data.filter(applyFilter(filter));
   }
-  process.nextTick(function () {
+  process.nextTick(function() {
     callback(null, data.length);
   });
 };
@@ -682,11 +680,11 @@ Memory.prototype.update =
     var cache = this.collection(model);
     var filter = null;
     where = where || {};
-    filter = applyFilter({where: where});
+    filter = applyFilter({ where: where });
 
     var ids = Object.keys(cache);
     var count = 0;
-    async.each(ids, function (id, done) {
+    async.each(ids, function(id, done) {
       var inst = self.fromDb(model, cache[id]);
       if (!filter || filter(inst)) {
         count++;
@@ -697,9 +695,9 @@ Memory.prototype.update =
       } else {
         process.nextTick(done);
       }
-    }, function (err) {
+    }, function(err) {
       if (err) return cb(err);
-      self.saveToFile({count: count}, cb);
+      self.saveToFile({ count: count }, cb);
     });
   };
 
@@ -745,16 +743,16 @@ Memory.prototype.replaceById = function(model, id, data, options, cb) {
   }
 
   var newModelData = {};
-  for(var key in data) {
+  for (var key in data) {
     var val = data[key];
-    if(typeof val === 'function') {
+    if (typeof val === 'function') {
       continue; // Skip methods
     }
     newModelData[key] = val;
   }
 
   this.collection(model)[id] = serialize(newModelData);
-  this.saveToFile(newModelData, function (err) {
+  this.saveToFile(newModelData, function(err) {
     cb(err, self.fromDb(model, newModelData));
   });
 };
@@ -763,13 +761,13 @@ Memory.prototype.replaceOrCreate = function(model, data, options, callback) {
   var self = this;
   var idName = self.idNames(model)[0];
   var idValue = self.getIdValue(model, data);
-  var filter = {where: {}};
+  var filter = { where: {}};
   filter.where[idName] = idValue;
   var nodes = self._findAllSkippingIncludes(model, filter);
   var found = nodes[0];
 
   if (!found) {
-    // Calling _createSync to update the collection in a sync way and 
+    // Calling _createSync to update the collection in a sync way and
     // to guarantee to create it in the same turn of even loop
     return self._createSync(model, data, function(err, id) {
       if (err) return process.nextTick(function() { cb(err); });
@@ -782,24 +780,24 @@ Memory.prototype.replaceOrCreate = function(model, data, options, callback) {
   var id = self.getIdValue(model, data);
   self.collection(model)[id] = serialize(data);
   self.saveToFile(data, function(err) {
-    callback(err, self.fromDb(model, data), {isNewInstance: false});
+    callback(err, self.fromDb(model, data), { isNewInstance: false });
   });
 };
 
-Memory.prototype.transaction = function () {
+Memory.prototype.transaction = function() {
   return new Memory(this);
 };
 
-Memory.prototype.exec = function (callback) {
+Memory.prototype.exec = function(callback) {
   this.onTransactionExec();
   setTimeout(callback, 50);
 };
 
-Memory.prototype.buildNearFilter = function (filter) {
+Memory.prototype.buildNearFilter = function(filter) {
   // noop
-}
+};
 
-Memory.prototype.automigrate = function (models, cb) {
+Memory.prototype.automigrate = function(models, cb) {
   var self = this;
 
   if ((!cb) && ('function' === typeof models)) {
@@ -831,7 +829,7 @@ Memory.prototype.automigrate = function (models, cb) {
     self.initCollection(m);
   });
   if (cb) process.nextTick(cb);
-}
+};
 
 function merge(base, update) {
   if (!base) {
@@ -839,9 +837,9 @@ function merge(base, update) {
   }
   // We cannot use Object.keys(update) if the update is an instance of the model
   // class as the properties are defined at the ModelClass.prototype level
-  for(var key in update) {
+  for (var key in update) {
     var val = update[key];
-    if(typeof val === 'function') {
+    if (typeof val === 'function') {
       continue; // Skip methods
     }
     base[key] = val;
diff --git a/lib/connectors/transient.js b/lib/connectors/transient.js
index d1ef9967..fa39a01e 100644
--- a/lib/connectors/transient.js
+++ b/lib/connectors/transient.js
@@ -47,7 +47,7 @@ Transient.prototype.getTypes = function() {
   return ['db', 'nosql', 'transient'];
 };
 
-Transient.prototype.connect = function (callback) {
+Transient.prototype.connect = function(callback) {
   if (this.isTransaction) {
     this.onTransactionExec = callback;
   } else {
@@ -63,26 +63,26 @@ Transient.prototype.generateId = function(model, data, idName) {
   if (idType === Number) {
     return Math.floor(Math.random() * 10000); // max. 4 digits
   } else {
-    return crypto.randomBytes(Math.ceil(24/2))
+    return crypto.randomBytes(Math.ceil(24 / 2))
         .toString('hex') // convert to hexadecimal format
         .slice(0, 24);   // return required number of characters
   }
 };
 
 Transient.prototype.exists = function exists(model, id, callback) {
-  process.nextTick(function () { callback(null, false); }.bind(this));
+  process.nextTick(function() { callback(null, false); }.bind(this));
 };
 
 Transient.prototype.find = function find(model, id, callback) {
-  process.nextTick(function () { callback(null, null); }.bind(this));
+  process.nextTick(function() { callback(null, null); }.bind(this));
 };
 
 Transient.prototype.all = function all(model, filter, callback) {
-  process.nextTick(function () { callback(null, []); });
+  process.nextTick(function() { callback(null, []); });
 };
 
 Transient.prototype.count = function count(model, callback, where) {
-  process.nextTick(function () { callback(null, 0); });
+  process.nextTick(function() { callback(null, 0); });
 };
 
 Transient.prototype.create = function create(model, data, callback) {
@@ -103,8 +103,8 @@ Transient.prototype.save = function save(model, data, callback) {
 Transient.prototype.update =
   Transient.prototype.updateAll = function updateAll(model, where, data, cb) {
     var count = 0;
-    this.flush('update', {count: count}, cb);
-};
+    this.flush('update', { count: count }, cb);
+  };
 
 Transient.prototype.updateAttributes = function updateAttributes(model, id, data, cb) {
   if (!id) {
@@ -136,15 +136,15 @@ Transient.prototype.destroyAll = function destroyAll(model, where, callback) {
  * Flush the cache - noop.
  * @param {Function} callback
  */
-Transient.prototype.flush = function (action, result, callback) {
-  process.nextTick(function () { callback && callback(null, result); });
+Transient.prototype.flush = function(action, result, callback) {
+  process.nextTick(function() { callback && callback(null, result); });
 };
 
-Transient.prototype.transaction = function () {
+Transient.prototype.transaction = function() {
   return new Transient(this);
 };
 
-Transient.prototype.exec = function (callback) {
+Transient.prototype.exec = function(callback) {
   this.onTransactionExec();
   setTimeout(callback, 50);
 };
diff --git a/lib/dao.js b/lib/dao.js
index ebe9f00d..0bc0b586 100644
--- a/lib/dao.js
+++ b/lib/dao.js
@@ -42,7 +42,7 @@ function DataAccessObject() {
   if (DataAccessObject._mixins) {
     var self = this;
     var args = arguments;
-    DataAccessObject._mixins.forEach(function (m) {
+    DataAccessObject._mixins.forEach(function(m) {
       m.call(self, args);
     });
   }
@@ -106,7 +106,7 @@ function setIdValue(m, data, value) {
 
 function byIdQuery(m, id) {
   var pk = idName(m);
-  var query = { where: {} };
+  var query = { where: {}};
   query.where[pk] = id;
   return query;
 }
@@ -121,7 +121,7 @@ function isWhereByGivenId(Model, where, idValue) {
   return where[pk] === idValue;
 }
 
-DataAccessObject._forDB = function (data) {
+DataAccessObject._forDB = function(data) {
   if (!(this.getDataSource().isRelational && this.getDataSource().isRelational())) {
     return data;
   }
@@ -177,7 +177,7 @@ DataAccessObject.lookupModel = function(data) {
  */
 DataAccessObject.getConnector = function() {
   return this.getDataSource().connector;
-}
+};
 
 // Empty callback function
 function noCallback(err, result) {
@@ -202,7 +202,7 @@ function noCallback(err, result) {
  *   - err (null or Error)
  *   - instance (null or Model)
  */
-DataAccessObject.create = function (data, options, cb) {
+DataAccessObject.create = function(data, options, cb) {
   var connectionPromise = stillConnecting(this.getDataSource(), this, arguments);
   if (connectionPromise) {
     return connectionPromise;
@@ -251,7 +251,7 @@ DataAccessObject.create = function (data, options, cb) {
     async.map(data, function(item, done) {
       self.create(item, options, function(err, result) {
         // Collect all errors and results
-        done(null, {err: err, result: result || item});
+        done(null, { err: err, result: result || item });
       });
     }, function(err, results) {
       if (err) {
@@ -296,7 +296,7 @@ DataAccessObject.create = function (data, options, cb) {
     instance: obj,
     isNewInstance: true,
     hookState: hookState,
-    options: options
+    options: options,
   };
   Model.notifyObserversOf('before save', context, function(err) {
     if (err) return cb(err);
@@ -312,9 +312,9 @@ DataAccessObject.create = function (data, options, cb) {
     if (options.validate === undefined && Model.settings.automaticValidation === false) {
       return create();
     }
-    
+
     // validation required
-    obj.isValid(function (valid) {
+    obj.isValid(function(valid) {
       if (valid) {
         create();
       } else {
@@ -324,8 +324,8 @@ DataAccessObject.create = function (data, options, cb) {
   });
 
   function create() {
-    obj.trigger('create', function (createDone) {
-      obj.trigger('save', function (saveDone) {
+    obj.trigger('create', function(createDone) {
+      obj.trigger('save', function(saveDone) {
         var _idName = idName(Model);
         var modelName = Model.modelName;
         var val = removeUndefined(obj.toObject(true));
@@ -347,7 +347,7 @@ DataAccessObject.create = function (data, options, cb) {
             data: val,
             isNewInstance: true,
             hookState: hookState,
-            options: options
+            options: options,
           };
           Model.notifyObserversOf('loaded', context, function(err) {
             if (err) return cb(err);
@@ -356,11 +356,11 @@ DataAccessObject.create = function (data, options, cb) {
             // with the changes made through persist/loaded hooks. To preserve
             // backwards compatibility, we introduced a new setting updateOnLoad,
             // which if set, will apply these changes to the model instance too.
-            if(Model.settings.updateOnLoad) {
+            if (Model.settings.updateOnLoad) {
               obj.setAttributes(context.data);
             }
-            saveDone.call(obj, function () {
-              createDone.call(obj, function () {
+            saveDone.call(obj, function() {
+              createDone.call(obj, function() {
                 if (err) {
                   return cb(err, obj);
                 }
@@ -369,12 +369,12 @@ DataAccessObject.create = function (data, options, cb) {
                   instance: obj,
                   isNewInstance: true,
                   hookState: hookState,
-                  options: options
+                  options: options,
                 };
 
                 Model.notifyObserversOf('after save', context, function(err) {
                   cb(err, obj);
-                  if(!err) Model.emit('changed', obj);
+                  if (!err) Model.emit('changed', obj);
                 });
               });
             });
@@ -387,7 +387,7 @@ DataAccessObject.create = function (data, options, cb) {
           isNewInstance: true,
           currentInstance: obj,
           hookState: hookState,
-          options: options
+          options: options,
         };
         Model.notifyObserversOf('persist', context, function(err) {
           if (err) return cb(err);
@@ -409,13 +409,13 @@ DataAccessObject.create = function (data, options, cb) {
 };
 
 function stillConnecting(dataSource, obj, args) {
-  if (typeof args[args.length-1] === 'function') {
+  if (typeof args[args.length - 1] === 'function') {
     return dataSource.ready(obj, args);
   }
 
   // promise variant
   var promiseArgs = Array.prototype.slice.call(args);
-  promiseArgs.callee = args.callee
+  promiseArgs.callee = args.callee;
   var cb =  utils.createPromiseCallback();
   promiseArgs.push(cb);
   if (dataSource.ready(obj, promiseArgs)) {
@@ -483,21 +483,21 @@ DataAccessObject.upsert = function(data, options, cb) {
     Model: Model,
     query: byIdQuery(Model, id),
     hookState: hookState,
-    options: options
+    options: options,
   };
   Model.notifyObserversOf('access', context, doUpdateOrCreate);
 
   function doUpdateOrCreate(err, ctx) {
     if (err) return cb(err);
 
-    var isOriginalQuery = isWhereByGivenId(Model, ctx.query.where, id)
+    var isOriginalQuery = isWhereByGivenId(Model, ctx.query.where, id);
     if (connector.updateOrCreate && isOriginalQuery) {
       var context = {
         Model: Model,
         where: ctx.query.where,
         data: data,
         hookState: hookState,
-        options: options
+        options: options,
       };
       Model.notifyObserversOf('before save', context, function(err, ctx) {
         if (err) return cb(err);
@@ -522,7 +522,7 @@ DataAccessObject.upsert = function(data, options, cb) {
               doValidate = Model.settings.automaticValidation;
             }
           } else {
-            doValidate = Model.settings.validateUpsert
+            doValidate = Model.settings.validateUpsert;
           }
         } else {
           doValidate = options.validate;
@@ -554,7 +554,7 @@ DataAccessObject.upsert = function(data, options, cb) {
             data: update,
             currentInstance: inst,
             hookState: ctx.hookState,
-            options: options
+            options: options,
           };
           Model.notifyObserversOf('persist', context, function(err) {
             if (err) return done(err);
@@ -570,7 +570,7 @@ DataAccessObject.upsert = function(data, options, cb) {
             Model: Model,
             data: data,
             hookState: ctx.hookState,
-            options: options
+            options: options,
           };
           Model.notifyObserversOf('loaded', context, function(err) {
             if (err) return cb(err);
@@ -584,7 +584,7 @@ DataAccessObject.upsert = function(data, options, cb) {
             }
             if (err) {
               cb(err, obj);
-              if(!err) {
+              if (!err) {
                 Model.emit('changed', inst);
               }
             } else {
@@ -593,12 +593,12 @@ DataAccessObject.upsert = function(data, options, cb) {
                 instance: obj,
                 isNewInstance: info ? info.isNewInstance : undefined,
                 hookState: hookState,
-                options: options
+                options: options,
               };
 
               Model.notifyObserversOf('after save', context, function(err) {
                 cb(err, obj);
-                if(!err) {
+                if (!err) {
                   Model.emit('changed', inst);
                 }
               });
@@ -607,11 +607,11 @@ DataAccessObject.upsert = function(data, options, cb) {
         }
       });
     } else {
-      var opts = {notify: false};
+      var opts = { notify: false };
       if (ctx.options && ctx.options.transaction) {
         opts.transaction = ctx.options.transaction;
       }
-      Model.findOne({where: ctx.query.where}, opts, function (err, inst){
+      Model.findOne({ where: ctx.query.where }, opts, function(err, inst) {
         if (err) {
           return cb(err);
         }
@@ -674,20 +674,20 @@ DataAccessObject.replaceOrCreate = function replaceOrCreate(data, options, cb) {
   if (id === undefined || id === null) {
     return this.create(data, options, cb);
   }
-  
+
   var inst;
   if (data instanceof Model) {
     inst = data;
   } else {
     inst = new Model(data);
   }
-  
-  var strict = inst.__strict; 
+
+  var strict = inst.__strict;
   var context = {
     Model: Model,
     query: byIdQuery(Model, id),
     hookState: hookState,
-    options: options
+    options: options,
   };
   Model.notifyObserversOf('access', context, doReplaceOrCreate);
 
@@ -701,7 +701,7 @@ DataAccessObject.replaceOrCreate = function replaceOrCreate(data, options, cb) {
         Model: Model,
         instance: inst,
         hookState: hookState,
-        options: options
+        options: options,
       };
       Model.notifyObserversOf('before save', context, function(err, ctx) {
         if (err) return cb(err);
@@ -712,7 +712,7 @@ DataAccessObject.replaceOrCreate = function replaceOrCreate(data, options, cb) {
           validateAndCallConnector();
         }
 
-        function validateAndCallConnector(err){
+        function validateAndCallConnector(err) {
           if (err) return cb(err);
           Model.applyProperties(update, inst);
           Model = Model.lookupModel(update);
@@ -741,7 +741,7 @@ DataAccessObject.replaceOrCreate = function replaceOrCreate(data, options, cb) {
               data: update,
               currentInstance: inst,
               hookState: ctx.hookState,
-              options: options
+              options: options,
             };
             Model.notifyObserversOf('persist', context, function(err) {
               if (err) return done(err);
@@ -755,7 +755,7 @@ DataAccessObject.replaceOrCreate = function replaceOrCreate(data, options, cb) {
               data: data,
               isNewInstance: info ? info.isNewInstance : undefined,
               hookState: ctx.hookState,
-              options: options
+              options: options,
             };
             Model.notifyObserversOf('loaded', context, function(err) {
               if (err) return cb(err);
@@ -775,7 +775,7 @@ DataAccessObject.replaceOrCreate = function replaceOrCreate(data, options, cb) {
                   instance: obj,
                   isNewInstance: info ? info.isNewInstance : undefined,
                   hookState: hookState,
-                  options: options
+                  options: options,
                 };
 
                 Model.notifyObserversOf('after save', context, function(err) {
@@ -789,11 +789,11 @@ DataAccessObject.replaceOrCreate = function replaceOrCreate(data, options, cb) {
         }
       });
     } else {
-      var opts = {notify: false};
+      var opts = { notify: false };
       if (ctx.options && ctx.options.transaction) {
         opts.transaction = ctx.options.transaction;
       }
-      Model.findOne({where: ctx.query.where}, opts, function (err, found){
+      Model.findOne({ where: ctx.query.where }, opts, function(err, found) {
         if (err) return cb(err);
         if (!isOriginalQuery) {
           // The custom query returned from a hook may hide the fact that
@@ -838,14 +838,14 @@ DataAccessObject.findOrCreate = function findOrCreate(query, data, options, cb)
     // findOrCreate(data);
     // query will be built from data, and method will return Promise
     data = query;
-    query = {where: data};
+    query = { where: data };
   } else  if (options === undefined && cb === undefined) {
     if (typeof data === 'function') {
       // findOrCreate(data, cb);
       // query will be built from data
       cb = data;
       data = query;
-      query = {where: data};
+      query = { where: data };
     }
   } else if (cb === undefined) {
     if (typeof options === 'function') {
@@ -856,7 +856,7 @@ DataAccessObject.findOrCreate = function findOrCreate(query, data, options, cb)
   }
 
   cb = cb || utils.createPromiseCallback();
-  query = query || {where: {}};
+  query = query || { where: {}};
   data = data || {};
   options = options || {};
 
@@ -879,7 +879,7 @@ DataAccessObject.findOrCreate = function findOrCreate(query, data, options, cb)
         data: data,
         isNewInstance: created,
         hookState: hookState,
-        options: options
+        options: options,
       };
       Model.notifyObserversOf('loaded', context, function(err) {
         if (err) return cb(err);
@@ -887,8 +887,8 @@ DataAccessObject.findOrCreate = function findOrCreate(query, data, options, cb)
         var obj, Model = self.lookupModel(data);
 
         if (data) {
-          obj = new Model(data, {fields: query.fields, applySetters: false,
-            persisted: true});
+          obj = new Model(data, { fields: query.fields, applySetters: false,
+            persisted: true });
         }
 
         if (created) {
@@ -897,7 +897,7 @@ DataAccessObject.findOrCreate = function findOrCreate(query, data, options, cb)
             instance: obj,
             isNewInstance: true,
             hookState: hookState,
-            options: options
+            options: options,
           };
           Model.notifyObserversOf('after save', context, function(err) {
             if (cb.promise) {
@@ -926,7 +926,7 @@ DataAccessObject.findOrCreate = function findOrCreate(query, data, options, cb)
       isNewInstance: true,
       currentInstance : currentInstance,
       hookState: hookState,
-      options: options
+      options: options,
     };
 
     Model.notifyObserversOf('persist', context, function(err) {
@@ -946,7 +946,7 @@ DataAccessObject.findOrCreate = function findOrCreate(query, data, options, cb)
     try {
       this._normalize(query);
     } catch (err) {
-      process.nextTick(function () {
+      process.nextTick(function() {
         cb(err);
       });
       return cb.promise;
@@ -958,9 +958,9 @@ DataAccessObject.findOrCreate = function findOrCreate(query, data, options, cb)
       Model: Model,
       query: query,
       hookState: hookState,
-      options: options
+      options: options,
     };
-    Model.notifyObserversOf('access', context, function (err, ctx) {
+    Model.notifyObserversOf('access', context, function(err, ctx) {
       if (err) return cb(err);
 
       var query = ctx.query;
@@ -977,8 +977,8 @@ DataAccessObject.findOrCreate = function findOrCreate(query, data, options, cb)
         instance: obj,
         isNewInstance: true,
         hookState: hookState,
-        options: options
-       };
+        options: options,
+      };
       Model.notifyObserversOf('before save', context, function(err, ctx) {
         if (err) return cb(err);
 
@@ -996,7 +996,7 @@ DataAccessObject.findOrCreate = function findOrCreate(query, data, options, cb)
         }
 
         // validation required
-        obj.isValid(function (valid) {
+        obj.isValid(function(valid) {
           if (valid) {
             _findOrCreate(query, data, obj);
           } else {
@@ -1006,7 +1006,7 @@ DataAccessObject.findOrCreate = function findOrCreate(query, data, options, cb)
       });
     });
   } else {
-    Model.findOne(query, options, function (err, record) {
+    Model.findOne(query, options, function(err, record) {
       if (err) return cb(err);
       if (record) {
         if (cb.promise) {
@@ -1015,7 +1015,7 @@ DataAccessObject.findOrCreate = function findOrCreate(query, data, options, cb)
           return cb(null, record, false);
         }
       }
-      Model.create(data, options, function (err, record) {
+      Model.create(data, options, function(err, record) {
         if (cb.promise) {
           cb(err, [record, record != null]);
         } else {
@@ -1172,21 +1172,21 @@ DataAccessObject.findByIds = function(ids, query, options, cb) {
   if (isPKMissing(this, cb)) {
     return cb.promise;
   } else if (ids.length === 0) {
-    process.nextTick(function(){cb(null, []);});
+    process.nextTick(function() { cb(null, []); });
     return cb.promise;
   }
 
-  var filter = { where: {} };
+  var filter = { where: {}};
   var pk = idName(this);
   filter.where[pk] = { inq: [].concat(ids) };
   mergeQuery(filter, query || {});
 
   // to know if the result need to be sorted by ids or not
   // this variable need to be initialized before the call to find, because filter is updated during the call with an order
-  var toSortObjectsByIds = filter.order ? false : true ;
+  var toSortObjectsByIds = filter.order ? false : true;
 
   this.find(filter, options, function(err, results) {
-    cb(err, toSortObjectsByIds ? utils.sortObjectsByIds(pk, ids, results) : results );
+    cb(err, toSortObjectsByIds ? utils.sortObjectsByIds(pk, ids, results) : results);
   });
   return cb.promise;
 };
@@ -1203,7 +1203,7 @@ function convertNullToNotFoundError(ctx, cb) {
 }
 
 // alias function for backwards compat.
-DataAccessObject.all = function () {
+DataAccessObject.all = function() {
   return DataAccessObject.find.apply(this, arguments);
 };
 
@@ -1215,13 +1215,13 @@ DataAccessObject.all = function () {
 DataAccessObject._getSetting = function(key) {
   // Check for settings in model
   var m = this.definition;
-  if(m && m.settings && m.settings[key]) {
-    return m.settings[key]
+  if (m && m.settings && m.settings[key]) {
+    return m.settings[key];
   }
 
   // Check for settings in connector
   var ds = this.getDataSource();
-  if(ds && ds.settings && ds.settings[key]) {
+  if (ds && ds.settings && ds.settings[key]) {
     return ds.settings[key];
   }
 
@@ -1239,7 +1239,7 @@ var operators = {
   neq: '!=',
   like: 'LIKE',
   nlike: 'NOT LIKE',
-  regexp: 'REGEXP'
+  regexp: 'REGEXP',
 };
 
 /*
@@ -1248,7 +1248,7 @@ var operators = {
  * @returns {Object} The normalized filter object
  * @private
  */
-DataAccessObject._normalize = function (filter) {
+DataAccessObject._normalize = function(filter) {
   if (!filter) {
     return undefined;
   }
@@ -1369,7 +1369,7 @@ function NumberType(val) {
  * @returns {Object} The coerced where clause
  * @private
  */
-DataAccessObject._coerce = function (where) {
+DataAccessObject._coerce = function(where) {
   var self = this;
   if (!where) {
     return where;
@@ -1447,7 +1447,7 @@ DataAccessObject._coerce = function (where) {
         if (op in val) {
           val = val[op];
           operator = op;
-          switch(operator) {
+          switch (operator) {
             case 'inq':
             case 'nin':
               if (!Array.isArray(val)) {
@@ -1612,7 +1612,7 @@ DataAccessObject.find = function find(query, options, cb) {
   try {
     this._normalize(query);
   } catch (err) {
-    process.nextTick(function () {
+    process.nextTick(function() {
       cb(err);
     });
     return cb.promise;
@@ -1636,7 +1636,7 @@ DataAccessObject.find = function find(query, options, cb) {
         Model: self,
         query: query,
         hookState: hookState,
-        options: options
+        options: options,
       };
       self.notifyObserversOf('access', context, function(err, ctx) {
         if (err) return cb(err);
@@ -1651,7 +1651,7 @@ DataAccessObject.find = function find(query, options, cb) {
             memory.define({
               properties: self.dataSource.definitions[self.modelName].properties,
               settings: self.dataSource.definitions[self.modelName].settings,
-              model: self
+              model: self,
             });
 
             data.forEach(function(obj) {
@@ -1685,7 +1685,7 @@ DataAccessObject.find = function find(query, options, cb) {
       async.each(data, function(item, callback) {
         var d = item;//data[i];
         var Model = self.lookupModel(d);
-        var obj = new Model(d, {fields: query.fields, applySetters: false, persisted: true});
+        var obj = new Model(d, { fields: query.fields, applySetters: false, persisted: true });
 
         if (query && query.include) {
           if (query.collect) {
@@ -1723,7 +1723,7 @@ DataAccessObject.find = function find(query, options, cb) {
             instance: obj,
             isNewInstance: false,
             hookState: hookState,
-            options: options
+            options: options,
           };
 
           Model.notifyObserversOf('loaded', context, function(err) {
@@ -1765,7 +1765,7 @@ DataAccessObject.find = function find(query, options, cb) {
       Model: this,
       query: query,
       hookState: hookState,
-      options: options
+      options: options,
     };
     this.notifyObserversOf('access', context, function(err, ctx) {
       if (err) return cb(err);
@@ -1813,7 +1813,7 @@ DataAccessObject.findOne = function findOne(query, options, cb) {
   assert(typeof cb === 'function', 'The cb argument must be a function');
 
   query.limit = 1;
-  this.find(query, options, function (err, collection) {
+  this.find(query, options, function(err, collection) {
     if (err || !collection || !collection.length > 0) return cb(err, null);
     cb(err, collection[0]);
   });
@@ -1876,7 +1876,7 @@ DataAccessObject.remove = DataAccessObject.deleteAll = DataAccessObject.destroyA
     Model: Model,
     where: whereIsEmpty(where) ? {} : where,
     hookState: hookState,
-    options: options
+    options: options,
   };
 
   if (options.notify === false) {
@@ -1887,21 +1887,21 @@ DataAccessObject.remove = DataAccessObject.deleteAll = DataAccessObject.destroyA
       Model: Model,
       query: query,
       hookState: hookState,
-      options: options
+      options: options,
     };
     Model.notifyObserversOf('access', context, function(err, ctx) {
+      if (err) return cb(err);
+      var context = {
+        Model: Model,
+        where: ctx.query.where,
+        hookState: hookState,
+        options: options,
+      };
+      Model.notifyObserversOf('before delete', context, function(err, ctx) {
         if (err) return cb(err);
-        var context = {
-          Model: Model,
-          where: ctx.query.where,
-          hookState: hookState,
-          options: options
-        };
-        Model.notifyObserversOf('before delete', context, function(err, ctx) {
-          if (err) return cb(err);
-          doDelete(ctx.where);
-        });
+        doDelete(ctx.where);
       });
+    });
   }
 
   function doDelete(where) {
@@ -1941,7 +1941,7 @@ DataAccessObject.remove = DataAccessObject.deleteAll = DataAccessObject.destroyA
         Model: Model,
         where: where,
         hookState: hookState,
-        options: options
+        options: options,
       };
       Model.notifyObserversOf('after delete', context, function(err) {
         cb(err, info);
@@ -1955,7 +1955,7 @@ DataAccessObject.remove = DataAccessObject.deleteAll = DataAccessObject.destroyA
 
 function whereIsEmpty(where) {
   return !where ||
-     (typeof where === 'object' && Object.keys(where).length === 0)
+     (typeof where === 'object' && Object.keys(where).length === 0);
 }
 
 /**
@@ -2030,7 +2030,7 @@ DataAccessObject.removeById = DataAccessObject.destroyById = DataAccessObject.de
  * @param {Object} [options] Options
  * @param {Function} cb Callback, called with (err, count)
  */
-DataAccessObject.count = function (where, options, cb) {
+DataAccessObject.count = function(where, options, cb) {
   var connectionPromise = stillConnecting(this.getDataSource(), this, arguments);
   if (connectionPromise) {
     return connectionPromise;
@@ -2075,7 +2075,7 @@ DataAccessObject.count = function (where, options, cb) {
     where = removeUndefined(where);
     where = this._coerce(where);
   } catch (err) {
-    process.nextTick(function () {
+    process.nextTick(function() {
       cb(err);
     });
     return cb.promise;
@@ -2085,7 +2085,7 @@ DataAccessObject.count = function (where, options, cb) {
     Model: Model,
     query: { where: where },
     hookState: hookState,
-    options: options
+    options: options,
   };
   this.notifyObserversOf('access', context, function(err, ctx) {
     if (err) return cb(err);
@@ -2112,7 +2112,7 @@ DataAccessObject.count = function (where, options, cb) {
  * @property {Boolean} throws  Default is false.
  * @param {Function} cb Callback function with err and object arguments
  */
-DataAccessObject.prototype.save = function (options, cb) {
+DataAccessObject.prototype.save = function(options, cb) {
   var connectionPromise = stillConnecting(this.getDataSource(), this, arguments);
   if (connectionPromise) {
     return connectionPromise;
@@ -2158,7 +2158,7 @@ DataAccessObject.prototype.save = function (options, cb) {
     Model: Model,
     instance: inst,
     hookState: hookState,
-    options: options
+    options: options,
   };
   Model.notifyObserversOf('before save', context, function(err) {
     if (err) return cb(err);
@@ -2172,7 +2172,7 @@ DataAccessObject.prototype.save = function (options, cb) {
       return save();
     }
 
-    inst.isValid(function (valid) {
+    inst.isValid(function(valid) {
       if (valid) {
         save();
       } else {
@@ -2187,8 +2187,8 @@ DataAccessObject.prototype.save = function (options, cb) {
 
     // then save
     function save() {
-      inst.trigger('save', function (saveDone) {
-        inst.trigger('update', function (updateDone) {
+      inst.trigger('save', function(saveDone) {
+        inst.trigger('update', function(updateDone) {
           data = removeUndefined(data);
           function saveCallback(err, unusedData, result) {
             if (err) {
@@ -2200,7 +2200,7 @@ DataAccessObject.prototype.save = function (options, cb) {
               data: data,
               isNewInstance: result && result.isNewInstance,
               hookState: hookState,
-              options: options
+              options: options,
             };
             Model.notifyObserversOf('loaded', context, function(err) {
               if (err) return cb(err);
@@ -2212,14 +2212,14 @@ DataAccessObject.prototype.save = function (options, cb) {
                 instance: inst,
                 isNewInstance: result && result.isNewInstance,
                 hookState: hookState,
-                options: options
+                options: options,
               };
               Model.notifyObserversOf('after save', context, function(err) {
                 if (err) return cb(err, inst);
-                updateDone.call(inst, function () {
-                  saveDone.call(inst, function () {
+                updateDone.call(inst, function() {
+                  saveDone.call(inst, function() {
                     cb(err, inst);
-                    if(!err) {
+                    if (!err) {
                       Model.emit('changed', inst);
                     }
                   });
@@ -2234,7 +2234,7 @@ DataAccessObject.prototype.save = function (options, cb) {
             where: byIdQuery(Model, getIdValue(Model, inst)).where,
             currentInstance: inst,
             hookState: hookState,
-            options: options
+            options: options,
           };
 
           Model.notifyObserversOf('persist', context, function(err) {
@@ -2271,7 +2271,7 @@ DataAccessObject.prototype.save = function (options, cb) {
  * @param {Function} cb Callback, called with (err, info)
  */
 DataAccessObject.update =
-DataAccessObject.updateAll = function (where, data, options, cb) {
+DataAccessObject.updateAll = function(where, data, options, cb) {
   var connectionPromise = stillConnecting(this.getDataSource(), this, arguments);
   if (connectionPromise) {
     return connectionPromise;
@@ -2328,7 +2328,7 @@ DataAccessObject.updateAll = function (where, data, options, cb) {
     Model: Model,
     query: { where: where },
     hookState: hookState,
-    options: options
+    options: options,
   };
   Model.notifyObserversOf('access', context, function(err, ctx) {
     if (err) return cb(err);
@@ -2337,7 +2337,7 @@ DataAccessObject.updateAll = function (where, data, options, cb) {
       where: ctx.query.where,
       data: data,
       hookState: hookState,
-      options: options
+      options: options,
     };
     Model.notifyObserversOf('before save', context,
       function(err, ctx) {
@@ -2353,7 +2353,7 @@ DataAccessObject.updateAll = function (where, data, options, cb) {
       data = removeUndefined(data);
       data = Model._coerce(data);
     } catch (err) {
-      return process.nextTick(function () {
+      return process.nextTick(function() {
         cb(err);
       });
     }
@@ -2366,7 +2366,7 @@ DataAccessObject.updateAll = function (where, data, options, cb) {
         where: where,
         data: data,
         hookState: hookState,
-        options: options
+        options: options,
       };
       Model.notifyObserversOf('after save', context, function(err, ctx) {
         return cb(err, info);
@@ -2378,7 +2378,7 @@ DataAccessObject.updateAll = function (where, data, options, cb) {
       where: where,
       data: data,
       hookState: hookState,
-      options: options
+      options: options,
     };
     Model.notifyObserversOf('persist', context, function(err, ctx) {
       if (err) return cb (err);
@@ -2393,7 +2393,7 @@ DataAccessObject.updateAll = function (where, data, options, cb) {
   return cb.promise;
 };
 
-DataAccessObject.prototype.isNewRecord = function () {
+DataAccessObject.prototype.isNewRecord = function() {
   return !this.__persisted;
 };
 
@@ -2401,7 +2401,7 @@ DataAccessObject.prototype.isNewRecord = function () {
  * Return connector of current record
  * @private
  */
-DataAccessObject.prototype.getConnector = function () {
+DataAccessObject.prototype.getConnector = function() {
   return this.getDataSource().connector;
 };
 
@@ -2415,7 +2415,7 @@ DataAccessObject.prototype.getConnector = function () {
  */
 DataAccessObject.prototype.remove =
   DataAccessObject.prototype.delete =
-    DataAccessObject.prototype.destroy = function (options, cb) {
+    DataAccessObject.prototype.destroy = function(options, cb) {
       var connectionPromise = stillConnecting(this.getDataSource(), this, arguments);
       if (connectionPromise) {
         return connectionPromise;
@@ -2446,23 +2446,23 @@ DataAccessObject.prototype.remove =
         Model: Model,
         query: byIdQuery(Model, id),
         hookState: hookState,
-        options: options
+        options: options,
       };
 
       Model.notifyObserversOf('access', context, function(err, ctx) {
+        if (err) return cb(err);
+        var context = {
+          Model: Model,
+          where: ctx.query.where,
+          instance: inst,
+          hookState: hookState,
+          options: options,
+        };
+        Model.notifyObserversOf('before delete', context, function(err, ctx) {
           if (err) return cb(err);
-          var context = {
-            Model: Model,
-            where: ctx.query.where,
-            instance: inst,
-            hookState: hookState,
-            options: options
-          };
-          Model.notifyObserversOf('before delete', context, function(err, ctx) {
-              if (err) return cb(err);
-              doDeleteInstance(ctx.where);
-            });
+          doDeleteInstance(ctx.where);
         });
+      });
 
       function doDeleteInstance(where) {
         if (!isWhereByGivenId(Model, where, id)) {
@@ -2483,7 +2483,7 @@ DataAccessObject.prototype.remove =
               where: where,
               instance: inst,
               hookState: hookState,
-              options: options
+              options: options,
             };
             Model.notifyObserversOf('after delete', context, function(err) {
               cb(err, info);
@@ -2493,7 +2493,7 @@ DataAccessObject.prototype.remove =
           return;
         }
 
-        inst.trigger('destroy', function (destroyed) {
+        inst.trigger('destroy', function(destroyed) {
           function destroyCallback(err, info) {
             if (err) return cb(err);
             var deleted = info && info.count > 0;
@@ -2510,7 +2510,7 @@ DataAccessObject.prototype.remove =
                 where: where,
                 instance: inst,
                 hookState: hookState,
-                options: options
+                options: options,
               };
               Model.notifyObserversOf('after delete', context, function(err) {
                 cb(err, info);
@@ -2650,18 +2650,18 @@ DataAccessObject.replaceById = function(id, data, options, cb) {
     process.nextTick(function() { cb(err); });
     return cb.promise;
   }
-  
+
   var context = {
     Model: Model,
     instance: inst,
     isNewInstance: false,
     hookState: hookState,
-    options: options
+    options: options,
   };
 
   Model.notifyObserversOf('before save', context, function(err, ctx) {
     if (err) return cb(err);
-    
+
     data = inst.toObject(false);
 
     if (strict) {
@@ -2673,7 +2673,7 @@ DataAccessObject.replaceById = function(id, data, options, cb) {
     function validateAndCallConnector(err, data) {
       if (err) return cb(err);
       data = removeUndefined(data);
-      // update instance's properties    
+      // update instance's properties
       inst.setAttributes(data);
 
       var doValidate = true;
@@ -2685,20 +2685,20 @@ DataAccessObject.replaceById = function(id, data, options, cb) {
         doValidate = options.validate;
       }
 
-      if (doValidate){
-        inst.isValid(function (valid) {
+      if (doValidate) {
+        inst.isValid(function(valid) {
           if (!valid) return cb(new ValidationError(inst), inst);
 
           callConnector();
         }, data);
       } else {
-          callConnector();
+        callConnector();
       }
 
       function callConnector() {
         var idNames = Model.definition.idNames();
         var propKeys = Object.keys(Model.definition.properties);
-        var nonIdsPropKeys = propKeys.filter(function(i) {return idNames.indexOf(i) < 0;});
+        var nonIdsPropKeys = propKeys.filter(function(i) { return idNames.indexOf(i) < 0; });
         for (var i = 0; i < nonIdsPropKeys.length; i++) {
           var p = nonIdsPropKeys[i];
           inst[p] = null;
@@ -2706,7 +2706,7 @@ DataAccessObject.replaceById = function(id, data, options, cb) {
         copyData(data, inst);
         var typedData = convertSubsetOfPropertiesByType(inst, data);
         context.data = typedData;
-        
+
         function replaceCallback(err, data) {
           if (err) return cb(err);
 
@@ -2715,7 +2715,7 @@ DataAccessObject.replaceById = function(id, data, options, cb) {
             hookState: hookState,
             data: context.data,
             isNewInstance:false,
-            options: options
+            options: options,
           };
           Model.notifyObserversOf('loaded', ctx, function(err) {
             if (err) return cb(err);
@@ -2728,7 +2728,7 @@ DataAccessObject.replaceById = function(id, data, options, cb) {
               instance: inst,
               isNewInstance: false,
               hookState: hookState,
-              options: options
+              options: options,
             };
             Model.notifyObserversOf('after save', context, function(err) {
               if (!err) Model.emit('changed', inst);
@@ -2745,12 +2745,12 @@ DataAccessObject.replaceById = function(id, data, options, cb) {
           isNewInstance:false,
           currentInstance: inst,
           hookState: hookState,
-          options: options
+          options: options,
         };
         Model.notifyObserversOf('persist', ctx, function(err) {
           connector.replaceById(model, id,
             inst.constructor._forDB(context.data), options, replaceCallback);
-        });        
+        });
       }
     }
   });
@@ -2841,7 +2841,7 @@ function(data, options, cb) {
     data: data,
     currentInstance: inst,
     hookState: hookState,
-    options: options
+    options: options,
   };
 
   Model.notifyObserversOf('before save', context, function(err, ctx) {
@@ -2869,8 +2869,8 @@ function(data, options, cb) {
       // update instance's properties
       inst.setAttributes(data);
 
-      if (doValidate){
-        inst.isValid(function (valid) {
+      if (doValidate) {
+        inst.isValid(function(valid) {
           if (!valid) {
             cb(new ValidationError(inst), inst);
             return;
@@ -2879,12 +2879,12 @@ function(data, options, cb) {
           triggerSave();
         }, data);
       } else {
-          triggerSave();
+        triggerSave();
       }
 
-      function triggerSave(){
-        inst.trigger('save', function (saveDone) {
-          inst.trigger('update', function (done) {
+      function triggerSave() {
+        inst.trigger('save', function(saveDone) {
+          inst.trigger('update', function(done) {
             copyData(data, inst);
             var typedData = convertSubsetOfPropertiesByType(inst, data);
             context.data = typedData;
@@ -2895,7 +2895,7 @@ function(data, options, cb) {
                 Model: Model,
                 data: context.data,
                 hookState: hookState,
-                options: options
+                options: options,
               };
               Model.notifyObserversOf('loaded', ctx, function(err) {
                 if (err) return cb(err);
@@ -2906,11 +2906,11 @@ function(data, options, cb) {
                 // with the changes made through persist/loaded hooks. To preserve
                 // backwards compatibility, we introduced a new setting updateOnLoad,
                 // which if set, will apply these changes to the model instance too.
-                if(Model.settings.updateOnLoad) {
+                if (Model.settings.updateOnLoad) {
                   inst.setAttributes(ctx.data);
                 }
-                done.call(inst, function () {
-                  saveDone.call(inst, function () {
+                done.call(inst, function() {
+                  saveDone.call(inst, function() {
                     if (err) return cb(err, inst);
 
                     var context = {
@@ -2918,10 +2918,10 @@ function(data, options, cb) {
                       instance: inst,
                       isNewInstance: false,
                       hookState: hookState,
-                      options: options
+                      options: options,
                     };
                     Model.notifyObserversOf('after save', context, function(err) {
-                      if(!err) Model.emit('changed', inst);
+                      if (!err) Model.emit('changed', inst);
                       cb(err, inst);
                     });
                   });
@@ -2936,7 +2936,7 @@ function(data, options, cb) {
               currentInstance: inst,
               isNewInstance: false,
               hookState: hookState,
-              options: options
+              options: options,
             };
             Model.notifyObserversOf('persist', ctx, function(err) {
               if (connector.updateAttributes.length === 5) {
@@ -2952,7 +2952,7 @@ function(data, options, cb) {
       }
     }
   });
-return cb.promise;
+  return cb.promise;
 };
 
 /**
@@ -2984,7 +2984,7 @@ function defineReadonlyProp(obj, key, value) {
     writable: false,
     enumerable: true,
     configurable: true,
-    value: value
+    value: value,
   });
 }
 
@@ -2999,7 +2999,7 @@ var defineScope = require('./scope.js').defineScope;
  * @param {ModelClass} [targetClass] The model class for the query, default to
  * the declaring model
  */
-DataAccessObject.scope = function (name, query, targetClass, methods, options) {
+DataAccessObject.scope = function(name, query, targetClass, methods, options) {
   var cls = this;
   if (options && options.isStatic === false) {
     cls = cls.prototype;
diff --git a/lib/datasource.js b/lib/datasource.js
index dfdac0b2..f62b07b4 100644
--- a/lib/datasource.js
+++ b/lib/datasource.js
@@ -120,11 +120,11 @@ function DataSource(name, settings, modelBuilder) {
 
   // DataAccessObject - connector defined or supply the default
   var dao = (connector && connector.DataAccessObject) || this.constructor.DataAccessObject;
-  this.DataAccessObject = function () {
+  this.DataAccessObject = function() {
   };
 
   // define DataAccessObject methods
-  Object.keys(dao).forEach(function (name) {
+  Object.keys(dao).forEach(function(name) {
     var fn = dao[name];
     this.DataAccessObject[name] = fn;
 
@@ -135,13 +135,13 @@ function DataSource(name, settings, modelBuilder) {
         http: fn.http,
         remoteEnabled: fn.shared ? true : false,
         scope: this.DataAccessObject,
-        fnName: name
+        fnName: name,
       });
     }
   }.bind(this));
 
   // define DataAccessObject.prototype methods
-  Object.keys(dao.prototype).forEach(function (name) {
+  Object.keys(dao.prototype).forEach(function(name) {
     var fn = dao.prototype[name];
     this.DataAccessObject.prototype[name] = fn;
     if (typeof fn === 'function') {
@@ -152,7 +152,7 @@ function DataSource(name, settings, modelBuilder) {
         http: fn.http,
         remoteEnabled: fn.shared ? true : false,
         scope: this.DataAccessObject.prototype,
-        fnName: name
+        fnName: name,
       });
     }
   }.bind(this));
@@ -168,7 +168,7 @@ DataSource.DataAccessObject = DataAccessObject;
  * Set up the connector instance for backward compatibility with JugglingDB schema/adapter
  * @private
  */
-DataSource.prototype._setupConnector = function () {
+DataSource.prototype._setupConnector = function() {
   this.connector = this.connector || this.adapter; // The legacy JugglingDB adapter will set up `adapter` property
   this.adapter = this.connector; // Keep the adapter as an alias to connector
   if (this.connector) {
@@ -177,14 +177,14 @@ DataSource.prototype._setupConnector = function () {
       this.connector.dataSource = this;
     }
     var dataSource = this;
-    this.connector.log = function (query, start) {
+    this.connector.log = function(query, start) {
       dataSource.log(query, start);
     };
 
-    this.connector.logger = function (query) {
+    this.connector.logger = function(query) {
       var t1 = Date.now();
       var log = this.log;
-      return function (q) {
+      return function(q) {
         log(q || query, t1);
       };
     };
@@ -233,7 +233,7 @@ function tryModules(names, loader) {
  * @returns {*}
  * @private
  */
-DataSource._resolveConnector = function (name, loader) {
+DataSource._resolveConnector = function(name, loader) {
   var names = connectorModuleNames(name);
   var connector = tryModules(names, loader);
   var error = null;
@@ -244,7 +244,7 @@ DataSource._resolveConnector = function (name, loader) {
   }
   return {
     connector: connector,
-    error: error
+    error: error,
   };
 };
 
@@ -255,7 +255,7 @@ DataSource._resolveConnector = function (name, loader) {
  * @returns {*}
  * @private
  */
-DataSource.prototype.setup = function (name, settings) {
+DataSource.prototype.setup = function(name, settings) {
   var dataSource = this;
   var connector;
 
@@ -341,7 +341,7 @@ DataSource.prototype.setup = function (name, settings) {
         this.connector = new connector(this.settings);
         postInit();
       }
-    } catch(err) {
+    } catch (err) {
       if (err.message) {
         err.message = 'Cannot initialize connector ' +
           JSON.stringify(connector.name || name)  + ': ' +
@@ -351,17 +351,17 @@ DataSource.prototype.setup = function (name, settings) {
     }
   }
 
-  dataSource.connect = function (cb) {
+  dataSource.connect = function(cb) {
     var dataSource = this;
     if (dataSource.connected || dataSource.connecting) {
-      process.nextTick(function () {
+      process.nextTick(function() {
         cb && cb();
       });
       return;
     }
     dataSource.connecting = true;
     if (dataSource.connector.connect) {
-      dataSource.connector.connect(function (err, result) {
+      dataSource.connector.connect(function(err, result) {
         if (!err) {
           dataSource.connected = true;
           dataSource.connecting = false;
@@ -374,7 +374,7 @@ DataSource.prototype.setup = function (name, settings) {
         cb && cb(err, result);
       });
     } else {
-      process.nextTick(function () {
+      process.nextTick(function() {
         dataSource.connected = true;
         dataSource.connecting = false;
         dataSource.emit('connected');
@@ -402,7 +402,7 @@ function isModelDataSourceAttached(model) {
  * @param modelClass
  * @param scopes
  */
-DataSource.prototype.defineScopes = function (modelClass, scopes) {
+DataSource.prototype.defineScopes = function(modelClass, scopes) {
   if (scopes) {
     for (var s in scopes) {
       defineScope(modelClass, modelClass, s, scopes[s], {}, scopes[s].options);
@@ -415,13 +415,13 @@ DataSource.prototype.defineScopes = function (modelClass, scopes) {
  * @param modelClass
  * @param relations
  */
-DataSource.prototype.defineRelations = function (modelClass, relations) {
+DataSource.prototype.defineRelations = function(modelClass, relations) {
   var self = this;
 
   // Create a function for the closure in the loop
-  var createListener = function (name, relation, targetModel, throughModel) {
+  var createListener = function(name, relation, targetModel, throughModel) {
     if (!isModelDataSourceAttached(targetModel)) {
-      targetModel.once('dataAccessConfigured', function (model) {
+      targetModel.once('dataAccessConfigured', function(model) {
         // Check if the through model doesn't exist or resolved
         if (!throughModel || isModelDataSourceAttached(throughModel)) {
           // The target model is resolved
@@ -438,7 +438,7 @@ DataSource.prototype.defineRelations = function (modelClass, relations) {
     }
     if (throughModel && !isModelDataSourceAttached(throughModel)) {
       // Set up a listener to the through model
-      throughModel.once('dataAccessConfigured', function (model) {
+      throughModel.once('dataAccessConfigured', function(model) {
         if (isModelDataSourceAttached(targetModel)) {
           // The target model is resolved
           var params = traverse(relation).clone();
@@ -453,9 +453,9 @@ DataSource.prototype.defineRelations = function (modelClass, relations) {
 
   // Set up the relations
   if (relations) {
-    Object.keys(relations).forEach(function (rn) {
+    Object.keys(relations).forEach(function(rn) {
       var r = relations[rn];
-      assert(DataSource.relationTypes.indexOf(r.type) !== -1, "Invalid relation type: " + r.type);
+      assert(DataSource.relationTypes.indexOf(r.type) !== -1, 'Invalid relation type: ' + r.type);
       var targetModel, polymorphicName;
 
       if (r.polymorphic && r.type !== 'belongsTo' && !r.model) {
@@ -503,7 +503,7 @@ DataSource.prototype.defineRelations = function (modelClass, relations) {
  * @param {Model} modelClass The model class
  * @param {Object} settings The settings object
  */
-DataSource.prototype.setupDataAccess = function (modelClass, settings) {
+DataSource.prototype.setupDataAccess = function(modelClass, settings) {
   if (this.connector) {
     // Check if the id property should be generated
     var idName = modelClass.definition.idName();
@@ -515,7 +515,7 @@ DataSource.prototype.setupDataAccess = function (modelClass, settings) {
       modelClass.definition.rawProperties[idName].type = idType;
       modelClass.definition.properties[idName].type = idType;
       if (settings.forceId) {
-        modelClass.validatesAbsenceOf(idName, {if: 'isNewRecord'});
+        modelClass.validatesAbsenceOf(idName, { if: 'isNewRecord' });
       }
     }
     if (this.connector.define) {
@@ -523,7 +523,7 @@ DataSource.prototype.setupDataAccess = function (modelClass, settings) {
       this.connector.define({
         model: modelClass,
         properties: modelClass.definition.properties,
-        settings: settings
+        settings: settings,
       });
     }
   }
@@ -642,15 +642,15 @@ DataSource.prototype.createModel = DataSource.prototype.define = function define
  * @private
  */
 
-DataSource.prototype.mixin = function (ModelCtor) {
+DataSource.prototype.mixin = function(ModelCtor) {
   var ops = this.operations();
   var DAO = this.DataAccessObject;
 
   // mixin DAO
-  jutil.mixin(ModelCtor, DAO, {proxyFunctions: true, override: true});
+  jutil.mixin(ModelCtor, DAO, { proxyFunctions: true, override: true });
 
   // decorate operations as alias functions
-  Object.keys(ops).forEach(function (name) {
+  Object.keys(ops).forEach(function(name) {
     var op = ops[name];
     var scope;
 
@@ -660,15 +660,15 @@ DataSource.prototype.mixin = function (ModelCtor) {
       //   op.scope[op.fnName].apply(self, arguments);
       // }
       Object.keys(op)
-        .filter(function (key) {
+        .filter(function(key) {
           // filter out the following keys
           return ~[
             'scope',
             'fnName',
-            'prototype'
+            'prototype',
           ].indexOf(key);
         })
-        .forEach(function (key) {
+        .forEach(function(key) {
           if (typeof op[key] !== 'undefined') {
             op.scope[op.fnName][key] = op[key];
           }
@@ -680,14 +680,14 @@ DataSource.prototype.mixin = function (ModelCtor) {
 /**
  * See ModelBuilder.getModel
  */
-DataSource.prototype.getModel = function (name, forceCreate) {
+DataSource.prototype.getModel = function(name, forceCreate) {
   return this.modelBuilder.getModel(name, forceCreate);
 };
 
 /**
  * See ModelBuilder.getModelDefinition
  */
-DataSource.prototype.getModelDefinition = function (name) {
+DataSource.prototype.getModelDefinition = function(name) {
   return this.modelBuilder.getModelDefinition(name);
 };
 
@@ -696,7 +696,7 @@ DataSource.prototype.getModelDefinition = function (name) {
  * @returns {String[]} The data source type, such as ['db', 'nosql', 'mongodb'],
  * ['rest'], or ['db', 'rdbms', 'mysql']
  */
-DataSource.prototype.getTypes = function () {
+DataSource.prototype.getTypes = function() {
   var getTypes = this.connector && this.connector.getTypes;
   var types = getTypes && getTypes() || [];
   if (typeof types === 'string') {
@@ -710,7 +710,7 @@ DataSource.prototype.getTypes = function () {
  * @param {String} types Type name or an array of type names.  Can also be array of Strings.
  * @returns {Boolean} true if all types are supported by the data source
  */
-DataSource.prototype.supportTypes = function (types) {
+DataSource.prototype.supportTypes = function(types) {
   var supportedTypes = this.getTypes();
   if (Array.isArray(types)) {
     // Check each of the types
@@ -733,7 +733,7 @@ DataSource.prototype.supportTypes = function (types) {
  * @param {Function} modelClass The model constructor
  */
 
-DataSource.prototype.attach = function (modelClass) {
+DataSource.prototype.attach = function(modelClass) {
   if (modelClass.dataSource === this) {
     // Already attached to the data source
     return modelClass;
@@ -762,7 +762,7 @@ DataSource.prototype.attach = function (modelClass) {
  * @param {String} prop Name of property
  * @param {Object} params Property settings
  */
-DataSource.prototype.defineProperty = function (model, prop, params) {
+DataSource.prototype.defineProperty = function(model, prop, params) {
   this.modelBuilder.defineProperty(model, prop, params);
 
   var resolvedProp = this.getModelDefinition(model).properties[prop];
@@ -782,7 +782,7 @@ DataSource.prototype.defineProperty = function (model, prop, params) {
  *
 
  */
-DataSource.prototype.automigrate = function (models, cb) {
+DataSource.prototype.automigrate = function(models, cb) {
   this.freeze();
 
   if ((!cb) && ('function' === typeof models)) {
@@ -813,13 +813,13 @@ DataSource.prototype.automigrate = function (models, cb) {
       return cb.promise;
     }
 
-    var invalidModels = models.filter(function (m) {
+    var invalidModels = models.filter(function(m) {
       return !(m in attachedModels);
     });
 
     if (invalidModels.length) {
-      process.nextTick(function () {
-          cb(new Error('Cannot migrate models not attached to this datasource: ' +
+      process.nextTick(function() {
+        cb(new Error('Cannot migrate models not attached to this datasource: ' +
           invalidModels.join(' ')));
       });
       return cb.promise;
@@ -837,7 +837,7 @@ DataSource.prototype.automigrate = function (models, cb) {
  * @param {String} model Model to migrate.  If not present, apply to all models.  Can also be an array of Strings.
  * @param {Function} [cb] The callback function
  */
-DataSource.prototype.autoupdate = function (models, cb) {
+DataSource.prototype.autoupdate = function(models, cb) {
   this.freeze();
 
   if ((!cb) && ('function' === typeof models)) {
@@ -868,12 +868,12 @@ DataSource.prototype.autoupdate = function (models, cb) {
       return cb.promise;
     }
 
-    var invalidModels = models.filter(function (m) {
+    var invalidModels = models.filter(function(m) {
       return !(m in attachedModels);
     });
 
     if (invalidModels.length) {
-      process.nextTick(function () {
+      process.nextTick(function() {
         cb(new Error('Cannot migrate models not attached to this datasource: ' +
         invalidModels.join(' ')));
       });
@@ -898,7 +898,7 @@ DataSource.prototype.autoupdate = function (models, cb) {
  * @property {Number} offset Starting index
  *
  */
-DataSource.prototype.discoverModelDefinitions = function (options, cb) {
+DataSource.prototype.discoverModelDefinitions = function(options, cb) {
   this.freeze();
 
   if (cb === undefined && typeof options === 'function') {
@@ -925,7 +925,7 @@ DataSource.prototype.discoverModelDefinitions = function (options, cb) {
  * @property {Number} offset Starting index
  * @returns {*}
  */
-DataSource.prototype.discoverModelDefinitionsSync = function (options) {
+DataSource.prototype.discoverModelDefinitionsSync = function(options) {
   this.freeze();
   if (this.connector.discoverModelDefinitionsSync) {
     return this.connector.discoverModelDefinitionsSync(options);
@@ -955,7 +955,7 @@ DataSource.prototype.discoverModelDefinitionsSync = function (options) {
  * @param {Function} cb Callback function. Optional
  *
  */
-DataSource.prototype.discoverModelProperties = function (modelName, options, cb) {
+DataSource.prototype.discoverModelProperties = function(modelName, options, cb) {
   this.freeze();
 
   if (cb === undefined && typeof options === 'function') {
@@ -970,7 +970,7 @@ DataSource.prototype.discoverModelProperties = function (modelName, options, cb)
   } else if (cb) {
     process.nextTick(cb);
   }
-   return cb.promise;
+  return cb.promise;
 };
 
 /**
@@ -979,7 +979,7 @@ DataSource.prototype.discoverModelProperties = function (modelName, options, cb)
  * @param {Object} options The options
  * @returns {*}
  */
-DataSource.prototype.discoverModelPropertiesSync = function (modelName, options) {
+DataSource.prototype.discoverModelPropertiesSync = function(modelName, options) {
   this.freeze();
   if (this.connector.discoverModelPropertiesSync) {
     return this.connector.discoverModelPropertiesSync(modelName, options);
@@ -1004,7 +1004,7 @@ DataSource.prototype.discoverModelPropertiesSync = function (modelName, options)
  * @property {String} owner|schema The database owner or schema
  * @param {Function} [cb] The callback function
  */
-DataSource.prototype.discoverPrimaryKeys = function (modelName, options, cb) {
+DataSource.prototype.discoverPrimaryKeys = function(modelName, options, cb) {
   this.freeze();
 
   if (cb === undefined && typeof options === 'function') {
@@ -1029,7 +1029,7 @@ DataSource.prototype.discoverPrimaryKeys = function (modelName, options, cb) {
  * @property {String} owner|schema The database owner orschema
  * @returns {*}
  */
-DataSource.prototype.discoverPrimaryKeysSync = function (modelName, options) {
+DataSource.prototype.discoverPrimaryKeysSync = function(modelName, options) {
   this.freeze();
   if (this.connector.discoverPrimaryKeysSync) {
     return this.connector.discoverPrimaryKeysSync(modelName, options);
@@ -1060,7 +1060,7 @@ DataSource.prototype.discoverPrimaryKeysSync = function (modelName, options) {
  * @param {Function} [cb] The callback function
  *
  */
-DataSource.prototype.discoverForeignKeys = function (modelName, options, cb) {
+DataSource.prototype.discoverForeignKeys = function(modelName, options, cb) {
   this.freeze();
 
   if (cb === undefined && typeof options === 'function') {
@@ -1085,7 +1085,7 @@ DataSource.prototype.discoverForeignKeys = function (modelName, options, cb) {
  * @param {Object} options The options
  * @returns {*}
  */
-DataSource.prototype.discoverForeignKeysSync = function (modelName, options) {
+DataSource.prototype.discoverForeignKeysSync = function(modelName, options) {
   this.freeze();
   if (this.connector.discoverForeignKeysSync) {
     return this.connector.discoverForeignKeysSync(modelName, options);
@@ -1116,7 +1116,7 @@ DataSource.prototype.discoverForeignKeysSync = function (modelName, options) {
  * @property {String} owner|schema The database owner or schema
  * @param {Function} [cb] The callback function
  */
-DataSource.prototype.discoverExportedForeignKeys = function (modelName, options, cb) {
+DataSource.prototype.discoverExportedForeignKeys = function(modelName, options, cb) {
   this.freeze();
 
   if (cb === undefined && typeof options === 'function') {
@@ -1140,7 +1140,7 @@ DataSource.prototype.discoverExportedForeignKeys = function (modelName, options,
  * @param {Object} options The options
  * @returns {*}
  */
-DataSource.prototype.discoverExportedForeignKeysSync = function (modelName, options) {
+DataSource.prototype.discoverExportedForeignKeysSync = function(modelName, options) {
   this.freeze();
   if (this.connector.discoverExportedForeignKeysSync) {
     return this.connector.discoverExportedForeignKeysSync(modelName, options);
@@ -1226,7 +1226,7 @@ function fromDBName(dbName, camelCase) {
  * @param {Object} [options] The options
  * @param {Function} [cb] The callback function
  */
-DataSource.prototype.discoverSchema = function (modelName, options, cb) {
+DataSource.prototype.discoverSchema = function(modelName, options, cb) {
   options = options || {};
 
   if (!cb && 'function' === typeof options) {
@@ -1238,7 +1238,7 @@ DataSource.prototype.discoverSchema = function (modelName, options, cb) {
 
   cb = cb || utils.createPromiseCallback();
 
-  this.discoverSchemas(modelName, options, function (err, schemas) {
+  this.discoverSchemas(modelName, options, function(err, schemas) {
     if (err) {
       cb && cb(err, schemas);
       return;
@@ -1262,7 +1262,7 @@ DataSource.prototype.discoverSchema = function (modelName, options, cb) {
  * @property {Boolean} views True if views are included; false otherwise.
  * @param {Function} [cb] The callback function
  */
-DataSource.prototype.discoverSchemas = function (modelName, options, cb) {
+DataSource.prototype.discoverSchemas = function(modelName, options, cb) {
   options = options || {};
 
   if (!cb && 'function' === typeof options) {
@@ -1310,7 +1310,7 @@ DataSource.prototype.discoverSchemas = function (modelName, options, cb) {
     tasks.push(this.discoverForeignKeys.bind(this, modelName, options));
   }
 
-  async.parallel(tasks, function (err, results) {
+  async.parallel(tasks, function(err, results) {
 
     if (err) {
       cb(err);
@@ -1326,7 +1326,7 @@ DataSource.prototype.discoverSchemas = function (modelName, options, cb) {
     // Handle primary keys
     var primaryKeys = results[1] || [];
     var pks = {};
-    primaryKeys.forEach(function (pk) {
+    primaryKeys.forEach(function(pk) {
       pks[pk.columnName] = pk.keySeq;
     });
 
@@ -1337,17 +1337,17 @@ DataSource.prototype.discoverSchemas = function (modelName, options, cb) {
     var schema = {
       name: nameMapper('table', modelName),
       options: {
-        idInjection: false // DO NOT add id property
+        idInjection: false, // DO NOT add id property
       },
-      properties: {}
+      properties: {},
     };
 
     schema.options[dbType] = {
       schema: columns[0].owner,
-      table: modelName
+      table: modelName,
     };
 
-    columns.forEach(function (item) {
+    columns.forEach(function(item) {
       var i = item;
 
       var propName = nameMapper('column', item.columnName);
@@ -1357,7 +1357,7 @@ DataSource.prototype.discoverSchemas = function (modelName, options, cb) {
         || item.nullable === 0 || item.nullable === false),
         length: item.dataLength,
         precision: item.dataPrecision,
-        scale: item.dataScale
+        scale: item.dataScale,
       };
 
       if (pks[item.columnName]) {
@@ -1369,7 +1369,7 @@ DataSource.prototype.discoverSchemas = function (modelName, options, cb) {
         dataLength: i.dataLength,
         dataPrecision: item.dataPrecision,
         dataScale: item.dataScale,
-        nullable: i.nullable
+        nullable: i.nullable,
       };
     });
 
@@ -1388,12 +1388,12 @@ DataSource.prototype.discoverSchemas = function (modelName, options, cb) {
       // Handle foreign keys
       var fks = {};
       var foreignKeys = results[2] || [];
-      foreignKeys.forEach(function (fk) {
+      foreignKeys.forEach(function(fk) {
         var fkInfo = {
           keySeq: fk.keySeq,
           owner: fk.pkOwner,
           tableName: fk.pkTableName,
-          columnName: fk.pkColumnName
+          columnName: fk.pkColumnName,
         };
         if (fks[fk.fkName]) {
           fks[fk.fkName].push(fkInfo);
@@ -1407,17 +1407,17 @@ DataSource.prototype.discoverSchemas = function (modelName, options, cb) {
       }
 
       schema.options.relations = {};
-      foreignKeys.forEach(function (fk) {
+      foreignKeys.forEach(function(fk) {
         var propName = nameMapper('column', fk.pkTableName);
         schema.options.relations[propName] = {
           model: nameMapper('table', fk.pkTableName),
           type: 'belongsTo',
-          foreignKey: nameMapper('column', fk.fkColumnName)
+          foreignKey: nameMapper('column', fk.fkColumnName),
         };
 
         var key = fk.pkOwner + '.' + fk.pkTableName;
         if (!options.visited.hasOwnProperty(key) && !otherTables.hasOwnProperty(key)) {
-          otherTables[key] = {owner: fk.pkOwner, tableName: fk.pkTableName};
+          otherTables[key] = { owner: fk.pkOwner, tableName: fk.pkTableName };
         }
       });
     }
@@ -1438,7 +1438,7 @@ DataSource.prototype.discoverSchemas = function (modelName, options, cb) {
 
         moreTasks.push(DataSource.prototype.discoverSchemas.bind(self, otherTables[t].tableName, newOptions));
       }
-      async.parallel(moreTasks, function (err, results) {
+      async.parallel(moreTasks, function(err, results) {
         var result = results && results[0];
         cb(err, result);
       });
@@ -1457,7 +1457,7 @@ DataSource.prototype.discoverSchemas = function (modelName, options, cb) {
  * @property {Boolean} all True if all owners are included; false otherwise.
  * @property {Boolean} views True if views are included; false otherwise.
  */
-DataSource.prototype.discoverSchemasSync = function (modelName, options) {
+DataSource.prototype.discoverSchemasSync = function(modelName, options) {
   var self = this;
   var dbType = this.name || this.connector.name;
 
@@ -1477,7 +1477,7 @@ DataSource.prototype.discoverSchemasSync = function (modelName, options) {
   // Handle primary keys
   var primaryKeys = this.discoverPrimaryKeysSync(modelName, options);
   var pks = {};
-  primaryKeys.forEach(function (pk) {
+  primaryKeys.forEach(function(pk) {
     pks[pk.columnName] = pk.keySeq;
   });
 
@@ -1488,17 +1488,17 @@ DataSource.prototype.discoverSchemasSync = function (modelName, options) {
   var schema = {
     name: nameMapper('table', modelName),
     options: {
-      idInjection: false // DO NOT add id property
+      idInjection: false, // DO NOT add id property
     },
-    properties: {}
+    properties: {},
   };
 
   schema.options[dbType] = {
     schema: columns.length > 0 && columns[0].owner,
-    table: modelName
+    table: modelName,
   };
 
-  columns.forEach(function (item) {
+  columns.forEach(function(item) {
     var i = item;
 
     var propName = nameMapper('column', item.columnName);
@@ -1507,7 +1507,7 @@ DataSource.prototype.discoverSchemasSync = function (modelName, options) {
       required: (item.nullable === 'N'),
       length: item.dataLength,
       precision: item.dataPrecision,
-      scale: item.dataScale
+      scale: item.dataScale,
     };
 
     if (pks[item.columnName]) {
@@ -1519,7 +1519,7 @@ DataSource.prototype.discoverSchemasSync = function (modelName, options) {
       dataLength: i.dataLength,
       dataPrecision: item.dataPrecision,
       dataScale: item.dataScale,
-      nullable: i.nullable
+      nullable: i.nullable,
     };
   });
 
@@ -1539,12 +1539,12 @@ DataSource.prototype.discoverSchemasSync = function (modelName, options) {
     // Handle foreign keys
     var fks = {};
     var foreignKeys = this.discoverForeignKeysSync(modelName, options);
-    foreignKeys.forEach(function (fk) {
+    foreignKeys.forEach(function(fk) {
       var fkInfo = {
         keySeq: fk.keySeq,
         owner: fk.pkOwner,
         tableName: fk.pkTableName,
-        columnName: fk.pkColumnName
+        columnName: fk.pkColumnName,
       };
       if (fks[fk.fkName]) {
         fks[fk.fkName].push(fkInfo);
@@ -1558,17 +1558,17 @@ DataSource.prototype.discoverSchemasSync = function (modelName, options) {
     }
 
     schema.options.relations = {};
-    foreignKeys.forEach(function (fk) {
+    foreignKeys.forEach(function(fk) {
       var propName = nameMapper('column', fk.pkTableName);
       schema.options.relations[propName] = {
         model: nameMapper('table', fk.pkTableName),
         type: 'belongsTo',
-        foreignKey: nameMapper('column', fk.fkColumnName)
+        foreignKey: nameMapper('column', fk.fkColumnName),
       };
 
       var key = fk.pkOwner + '.' + fk.pkTableName;
       if (!options.visited.hasOwnProperty(key) && !otherTables.hasOwnProperty(key)) {
-        otherTables[key] = {owner: fk.pkOwner, tableName: fk.pkTableName};
+        otherTables[key] = { owner: fk.pkOwner, tableName: fk.pkTableName };
       }
     });
   }
@@ -1604,10 +1604,10 @@ DataSource.prototype.discoverSchemasSync = function (modelName, options) {
  * @property {Boolean} views True if views are included; false otherwise.
  * @param {Function} [cb] The callback function
  */
-DataSource.prototype.discoverAndBuildModels = function (modelName, options, cb) {
+DataSource.prototype.discoverAndBuildModels = function(modelName, options, cb) {
   var self = this;
   options = options || {};
-  this.discoverSchemas(modelName, options, function (err, schemas) {
+  this.discoverSchemas(modelName, options, function(err, schemas) {
     if (err) {
       cb && cb(err, schemas);
       return;
@@ -1643,7 +1643,7 @@ DataSource.prototype.discoverAndBuildModels = function (modelName, options, cb)
  * @param {String} modelName The model name
  * @param {Object} [options] The options
  */
-DataSource.prototype.discoverAndBuildModelsSync = function (modelName, options) {
+DataSource.prototype.discoverAndBuildModelsSync = function(modelName, options) {
   options = options || {};
   var schemas = this.discoverSchemasSync(modelName, options);
 
@@ -1670,7 +1670,7 @@ DataSource.prototype.discoverAndBuildModelsSync = function (modelName, options)
  * @param {Object} options Options
  * @returns {*}
  */
-DataSource.prototype.buildModelFromInstance = function (name, json, options) {
+DataSource.prototype.buildModelFromInstance = function(name, json, options) {
 
   // Introspect the JSON document to generate a schema
   var schema = ModelBuilder.introspect(json);
@@ -1684,7 +1684,7 @@ DataSource.prototype.buildModelFromInstance = function (name, json, options) {
  * This method applies only to SQL connectors.
  * @param {String|String[]} [models] A model name or an array of model names. If not present, apply to all models.
  */
-DataSource.prototype.isActual = function (models, cb) {
+DataSource.prototype.isActual = function(models, cb) {
   this.freeze();
   if (this.connector.isActual) {
     this.connector.isActual(models, cb);
@@ -1694,7 +1694,7 @@ DataSource.prototype.isActual = function (models, cb) {
       models = undefined;
     }
     if (cb) {
-      process.nextTick(function () {
+      process.nextTick(function() {
         cb(null, true);
       });
     }
@@ -1707,7 +1707,7 @@ DataSource.prototype.isActual = function (models, cb) {
  *
  * @private used by connectors
  */
-DataSource.prototype.log = function (sql, t) {
+DataSource.prototype.log = function(sql, t) {
   debug(sql, t);
   this.emit('log', sql, t);
 };
@@ -1731,7 +1731,7 @@ DataSource.prototype.freeze = function freeze() {
  * Return table name for specified `modelName`
  * @param {String} modelName The model name
  */
-DataSource.prototype.tableName = function (modelName) {
+DataSource.prototype.tableName = function(modelName) {
   return this.getModelDefinition(modelName).tableName(this.connector.name);
 };
 
@@ -1741,7 +1741,7 @@ DataSource.prototype.tableName = function (modelName) {
  * @param {String} propertyName The property name
  * @returns {String} columnName The column name.
  */
-DataSource.prototype.columnName = function (modelName, propertyName) {
+DataSource.prototype.columnName = function(modelName, propertyName) {
   return this.getModelDefinition(modelName).columnName(this.connector.name, propertyName);
 };
 
@@ -1751,7 +1751,7 @@ DataSource.prototype.columnName = function (modelName, propertyName) {
  * @param {String} propertyName The property name
  * @returns {Object} column metadata
  */
-DataSource.prototype.columnMetadata = function (modelName, propertyName) {
+DataSource.prototype.columnMetadata = function(modelName, propertyName) {
   return this.getModelDefinition(modelName).columnMetadata(this.connector.name, propertyName);
 };
 
@@ -1760,7 +1760,7 @@ DataSource.prototype.columnMetadata = function (modelName, propertyName) {
  * @param {String} modelName The model name
  * @returns {String[]} column names
  */
-DataSource.prototype.columnNames = function (modelName) {
+DataSource.prototype.columnNames = function(modelName) {
   return this.getModelDefinition(modelName).columnNames(this.connector.name);
 };
 
@@ -1769,7 +1769,7 @@ DataSource.prototype.columnNames = function (modelName) {
  * @param {String} modelName The model name
  * @returns {String} columnName for ID
  */
-DataSource.prototype.idColumnName = function (modelName) {
+DataSource.prototype.idColumnName = function(modelName) {
   return this.getModelDefinition(modelName).idColumnName(this.connector.name);
 };
 
@@ -1778,7 +1778,7 @@ DataSource.prototype.idColumnName = function (modelName) {
  * @param {String} modelName The model name
  * @returns {String} property name for ID
  */
-DataSource.prototype.idName = function (modelName) {
+DataSource.prototype.idName = function(modelName) {
   if (!this.getModelDefinition(modelName).idName) {
     console.error('No id name', this.getModelDefinition(modelName));
   }
@@ -1790,7 +1790,7 @@ DataSource.prototype.idName = function (modelName) {
  * @param {String} modelName The model name
  * @returns {String[]} property names for IDs
  */
-DataSource.prototype.idNames = function (modelName) {
+DataSource.prototype.idNames = function(modelName) {
   return this.getModelDefinition(modelName).idNames();
 };
 
@@ -1799,7 +1799,7 @@ DataSource.prototype.idNames = function (modelName) {
  * @param {String} modelName The model name
  * @returns {Object} The id property definition
  */
-DataSource.prototype.idProperty = function (modelName) {
+DataSource.prototype.idProperty = function(modelName) {
   var def = this.getModelDefinition(modelName);
   var idProps = def && def.ids();
   return idProps && idProps[0] && idProps[0].property;
@@ -1828,7 +1828,7 @@ DataSource.prototype.defineForeignKey = function defineForeignKey(className, key
     return;
   }
 
-  var fkDef = {type: pkType};
+  var fkDef = { type: pkType };
   var foreignMeta = this.columnMetadata(foreignClassName, pkName);
   if (foreignMeta && (foreignMeta.dataType || foreignMeta.dataLength)) {
     fkDef[this.connector.name] = {};
@@ -1840,7 +1840,7 @@ DataSource.prototype.defineForeignKey = function defineForeignKey(className, key
     }
   }
   if (this.connector.defineForeignKey) {
-    var cb = function (err, keyType) {
+    var cb = function(err, keyType) {
       if (err) throw err;
       fkDef.type = keyType || pkType;
       // Add the foreign key property to the data source _models
@@ -1869,12 +1869,12 @@ DataSource.prototype.defineForeignKey = function defineForeignKey(className, key
 DataSource.prototype.disconnect = function disconnect(cb) {
   var self = this;
   if (this.connected && (typeof this.connector.disconnect === 'function')) {
-    this.connector.disconnect(function (err, result) {
+    this.connector.disconnect(function(err, result) {
       self.connected = false;
       cb && cb(err, result);
     });
   } else {
-    process.nextTick(function () {
+    process.nextTick(function() {
       cb && cb();
     });
   }
@@ -1914,7 +1914,7 @@ DataSource.prototype.copyModel = function copyModel(Master) {
       dataSource.connector.define({
         model: Slave,
         properties: md.properties,
-        settings: md.settings
+        settings: md.settings,
       });
     }
 
@@ -1928,7 +1928,7 @@ DataSource.prototype.copyModel = function copyModel(Master) {
  * @returns {EventEmitter}
  * @private
  */
-DataSource.prototype.transaction = function () {
+DataSource.prototype.transaction = function() {
   var dataSource = this;
   var transaction = new EventEmitter();
 
@@ -1953,7 +1953,7 @@ DataSource.prototype.transaction = function () {
     dataSource.copyModel.call(transaction, dataSource.modelBuilder.models[i]);
   }
 
-  transaction.exec = function (cb) {
+  transaction.exec = function(cb) {
     transaction.connector.exec(cb);
   };
 
@@ -1966,14 +1966,14 @@ DataSource.prototype.transaction = function () {
  * @param {String} operation The operation name
  */
 
-DataSource.prototype.enableRemote = function (operation) {
+DataSource.prototype.enableRemote = function(operation) {
   var op = this.getOperation(operation);
   if (op) {
     op.remoteEnabled = true;
   } else {
     throw new Error(operation + ' is not provided by the attached connector');
   }
-}
+};
 
 /**
  * Disable remote access to a data source operation. Each [connector](#connector) has its own set of set enabled
@@ -1995,21 +1995,21 @@ DataSource.prototype.enableRemote = function (operation) {
  * @param {String} operation The operation name
  */
 
-DataSource.prototype.disableRemote = function (operation) {
+DataSource.prototype.disableRemote = function(operation) {
   var op = this.getOperation(operation);
   if (op) {
     op.remoteEnabled = false;
   } else {
     throw new Error(operation + ' is not provided by the attached connector');
   }
-}
+};
 
 /**
  * Get an operation's metadata.
  * @param {String} operation The operation name
  */
 
-DataSource.prototype.getOperation = function (operation) {
+DataSource.prototype.getOperation = function(operation) {
   var ops = this.operations();
   var opKeys = Object.keys(ops);
 
@@ -2020,7 +2020,7 @@ DataSource.prototype.getOperation = function (operation) {
       return op;
     }
   }
-}
+};
 
 /**
  * Return JSON object describing all operations.
@@ -2045,9 +2045,9 @@ DataSource.prototype.getOperation = function (operation) {
  * }
  * ```
  */
-DataSource.prototype.operations = function () {
+DataSource.prototype.operations = function() {
   return this._operations;
-}
+};
 
 /**
  * Define an operation to the data source
@@ -2055,7 +2055,7 @@ DataSource.prototype.operations = function () {
  * @param {Object} options The options
  * @param {Function} fn The function
  */
-DataSource.prototype.defineOperation = function (name, options, fn) {
+DataSource.prototype.defineOperation = function(name, options, fn) {
   options.fn = fn;
   options.name = name;
   this._operations[name] = options;
@@ -2065,7 +2065,7 @@ DataSource.prototype.defineOperation = function (name, options, fn) {
  * Check if the backend is a relational DB
  * @returns {Boolean}
  */
-DataSource.prototype.isRelational = function () {
+DataSource.prototype.isRelational = function() {
   return this.connector && this.connector.relational;
 };
 
@@ -2075,7 +2075,7 @@ DataSource.prototype.isRelational = function () {
  * @param {Object} obj  ?
  * @param {Object} args  ?
  */
-DataSource.prototype.ready = function (obj, args) {
+DataSource.prototype.ready = function(obj, args) {
   var self = this;
   if (this.connected) {
     // Connected
@@ -2107,7 +2107,7 @@ DataSource.prototype.ready = function (obj, args) {
       }
     }
   };
-  onError = function (err) {
+  onError = function(err) {
     // Remove the connected listener
     self.removeListener('connected', onConnected);
     if (timeoutHandle) {
@@ -2126,7 +2126,7 @@ DataSource.prototype.ready = function (obj, args) {
 
   // Set up a timeout to cancel the invocation
   var timeout = this.settings.connectionTimeout || 5000;
-  timeoutHandle = setTimeout(function () {
+  timeoutHandle = setTimeout(function() {
     self.removeListener('error', onError);
     self.removeListener('connected', onConnected);
     var params = [].slice.call(args);
@@ -2146,14 +2146,14 @@ DataSource.prototype.ready = function (obj, args) {
  * Ping the underlying connector to test the connections
  * @param {Function} [cb] Callback function
  */
-DataSource.prototype.ping = function (cb) {
+DataSource.prototype.ping = function(cb) {
   var self = this;
   if (self.connector.ping) {
     this.connector.ping(cb);
   } else if (self.connector.discoverModelProperties) {
     self.discoverModelProperties('dummy', {}, cb);
   } else {
-    process.nextTick(function () {
+    process.nextTick(function() {
       var err = self.connected ? null : 'Not connected';
       cb(err);
     });
@@ -2171,7 +2171,7 @@ function hiddenProperty(obj, key, value) {
     writable: false,
     enumerable: false,
     configurable: false,
-    value: value
+    value: value,
   });
 }
 
@@ -2187,7 +2187,7 @@ function defineReadonlyProp(obj, key, value) {
     writable: false,
     enumerable: true,
     configurable: true,
-    value: value
+    value: value,
   });
 }
 
@@ -2200,6 +2200,6 @@ DataSource.Any = ModelBuilder.Any;
  * @deprecated Use ModelBuilder.registerType instead
  * @param type
  */
-DataSource.registerType = function (type) {
+DataSource.registerType = function(type) {
   ModelBuilder.registerType(type);
 };
diff --git a/lib/geo.js b/lib/geo.js
index 8b43198e..07c5afd5 100644
--- a/lib/geo.js
+++ b/lib/geo.js
@@ -13,7 +13,7 @@ exports.nearFilter = function nearFilter(where) {
   var result = false;
 
   if (where && typeof where === 'object') {
-    Object.keys(where).forEach(function (key) {
+    Object.keys(where).forEach(function(key) {
       var ex = where[key];
 
       if (ex && ex.near) {
@@ -21,20 +21,20 @@ exports.nearFilter = function nearFilter(where) {
           near: ex.near,
           maxDistance: ex.maxDistance,
           unit: ex.unit,
-          key: key
+          key: key,
         };
       }
     });
   }
 
   return result;
-}
+};
 
 /*!
  * Filter a set of objects using the given `nearFilter`.
  */
 
-exports.filter = function (arr, filter) {
+exports.filter = function(arr, filter) {
   var origin = filter.near;
   var max = filter.maxDistance > 0 ? filter.maxDistance : false;
   var unit = filter.unit;
@@ -44,7 +44,7 @@ exports.filter = function (arr, filter) {
   var distances = {};
   var result = [];
 
-  arr.forEach(function (obj) {
+  arr.forEach(function(obj) {
     var loc = obj[key];
 
     // filter out objects without locations
@@ -57,7 +57,7 @@ exports.filter = function (arr, filter) {
     if (typeof loc.lat !== 'number') return;
     if (typeof loc.lng !== 'number') return;
 
-    var d = GeoPoint.distanceBetween(origin, loc, {type: unit});
+    var d = GeoPoint.distanceBetween(origin, loc, { type: unit });
 
     if (max && d > max) {
       // dont add
@@ -67,7 +67,7 @@ exports.filter = function (arr, filter) {
     }
   });
 
-  return result.sort(function (objA, objB) {
+  return result.sort(function(objA, objB) {
     var a = objA[key];
     var b = objB[key];
 
@@ -81,31 +81,31 @@ exports.filter = function (arr, filter) {
       return 0;
     }
   });
-}
+};
 
 exports.GeoPoint = GeoPoint;
 
-/** 
+/**
  * The GeoPoint object represents a physical location.
- * 
+ *
  * For example:
- * 
+ *
  * ```js
  * var loopback = require(‘loopback’);
  * var here = new loopback.GeoPoint({lat: 10.32424, lng: 5.84978});
  * ```
- * 
+ *
  * Embed a latitude / longitude point in a model.
- * 
+ *
  * ```js
  * var CoffeeShop = loopback.createModel('coffee-shop', {
  *   location: 'GeoPoint'
  * });
  * ```
- * 
+ *
  * You can query LoopBack models with a GeoPoint property and an attached data source using geo-spatial filters and
  * sorting. For example, the following code finds the three nearest coffee shops.
- * 
+ *
  * ```js
  * CoffeeShop.attachTo(oracle);
  * var here = new GeoPoint({lat: 10.32424, lng: 5.84978});
@@ -114,9 +114,9 @@ exports.GeoPoint = GeoPoint;
  * });
  * ```
  * @class GeoPoint
- * @property {Number} lat The latitude in degrees. 
- * @property {Number} lng The longitude in degrees. 
- * 
+ * @property {Number} lat The latitude in degrees.
+ * @property {Number} lng The longitude in degrees.
+ *
  * @options {Object} Options Object with two Number properties: lat and long.
  * @property {Number} lat The latitude point in degrees. Range: -90 to 90.
  * @property {Number} lng The longitude point in degrees. Range: -180 to 180.
@@ -131,10 +131,10 @@ function GeoPoint(data) {
     return new GeoPoint(data);
   }
 
-  if(arguments.length === 2) {
+  if (arguments.length === 2) {
     data = {
       lat: arguments[0],
-      lng: arguments[1]
+      lng: arguments[1],
     };
   }
 
@@ -147,7 +147,7 @@ function GeoPoint(data) {
   if (Array.isArray(data)) {
     data = {
       lat: Number(data[0]),
-      lng: Number(data[1])
+      lng: Number(data[1]),
     };
   } else {
     data.lng = Number(data.lng);
@@ -162,18 +162,18 @@ function GeoPoint(data) {
   assert(data.lat <= 90, 'lat must be <= 90');
   assert(data.lat >= -90, 'lat must be >= -90');
 
-  this.lat = data.lat; 
+  this.lat = data.lat;
   this.lng = data.lng;
 }
 
 /**
  * Determine the spherical distance between two GeoPoints.
- *  
+ *
  * @param  {GeoPoint} pointA Point A
  * @param  {GeoPoint} pointB Point B
  * @options  {Object} options Options object with one key, 'type'.  See below.
  * @property {String} type Unit of measurement, one of:
- * 
+ *
  * - `miles` (default)
  * - `radians`
  * - `kilometers`
@@ -205,16 +205,16 @@ GeoPoint.distanceBetween = function distanceBetween(a, b, options) {
  * Example:
  * ```js
  * var loopback = require(‘loopback’);
- * 
+ *
  * var here = new loopback.GeoPoint({lat: 10, lng: 10});
  * var there = new loopback.GeoPoint({lat: 5, lng: 5});
- * 
+ *
  * loopback.GeoPoint.distanceBetween(here, there, {type: 'miles'}) // 438
  * ```
  * @param {Object} point GeoPoint object to which to measure distance.
  * @options  {Object} options Options object with one key, 'type'.  See below.
  * @property {String} type Unit of measurement, one of:
- * 
+ *
  * - `miles` (default)
  * - `radians`
  * - `kilometers`
@@ -224,7 +224,7 @@ GeoPoint.distanceBetween = function distanceBetween(a, b, options) {
  * - `degrees`
  */
 
-GeoPoint.prototype.distanceTo = function (point, options) {
+GeoPoint.prototype.distanceTo = function(point, options) {
   return GeoPoint.distanceBetween(this, point, options);
 };
 
@@ -232,7 +232,7 @@ GeoPoint.prototype.distanceTo = function (point, options) {
  * Simple serialization.
  */
 
-GeoPoint.prototype.toString = function () {
+GeoPoint.prototype.toString = function() {
   return this.lat + ',' + this.lng;
 };
 
@@ -255,7 +255,7 @@ var EARTH_RADIUS = {
   miles: 3958.75,
   feet: 20902200,
   radians: 1,
-  degrees: RAD2DEG
+  degrees: RAD2DEG,
 };
 
 function geoDistance(x1, y1, x2, y2, options) {
@@ -268,7 +268,7 @@ function geoDistance(x1, y1, x2, y2, options) {
   x2 = x2 * DEG2RAD;
   y2 = y2 * DEG2RAD;
 
-  // use the haversine formula to calculate distance for any 2 points on a sphere. 
+  // use the haversine formula to calculate distance for any 2 points on a sphere.
   // ref http://en.wikipedia.org/wiki/Haversine_formula
   var haversine = function(a) {
     return Math.pow(Math.sin(a / 2.0), 2);
diff --git a/lib/hooks.js b/lib/hooks.js
index 7c72fa81..ffdbd0fc 100644
--- a/lib/hooks.js
+++ b/lib/hooks.js
@@ -36,10 +36,10 @@ Hookable.afterDestroy = null;
 // TODO: Evaluate https://github.com/bnoguchi/hooks-js/
 Hookable.prototype.trigger = function trigger(actionName, work, data, callback) {
   var capitalizedName = capitalize(actionName);
-  var beforeHook = this.constructor["before" + capitalizedName]
-    || this.constructor["pre" + capitalizedName];
-  var afterHook = this.constructor["after" + capitalizedName]
-    || this.constructor["post" + capitalizedName];
+  var beforeHook = this.constructor['before' + capitalizedName]
+    || this.constructor['pre' + capitalizedName];
+  var afterHook = this.constructor['after' + capitalizedName]
+    || this.constructor['post' + capitalizedName];
   if (actionName === 'validate') {
     beforeHook = beforeHook || this.constructor.beforeValidation;
     afterHook = afterHook || this.constructor.afterValidation;
@@ -57,7 +57,7 @@ Hookable.prototype.trigger = function trigger(actionName, work, data, callback)
   if (work) {
     if (beforeHook) {
       // before hook should be called on instance with two parameters: next and data
-      beforeHook.call(inst, function () {
+      beforeHook.call(inst, function() {
         // Check arguments to next(err, result)
         if (arguments.length) {
           return callback && callback.apply(null, arguments);
diff --git a/lib/include.js b/lib/include.js
index 9a78d892..d02a2474 100644
--- a/lib/include.js
+++ b/lib/include.js
@@ -100,11 +100,11 @@ function lookupModel(models, modelName) {
 function execTasksWithInterLeave(tasks, callback) {
   //let's give others some time to process.
   //Context Switch BEFORE Heavy Computation
-  process.nextTick(function () {
+  process.nextTick(function() {
     //Heavy Computation
-    async.parallel(tasks, function (err, info) {
+    async.parallel(tasks, function(err, info) {
       //Context Switch AFTER Heavy Computation
-      process.nextTick(function () {
+      process.nextTick(function() {
         callback(err, info);
       });
     });
@@ -156,7 +156,7 @@ Inclusion.normalizeInclude = normalizeInclude;
  * @param {Function} cb Callback called when relations are loaded
  *
  */
-Inclusion.include = function (objects, include, options, cb) {
+Inclusion.include = function(objects, include, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     cb = options;
     options = {};
@@ -236,14 +236,14 @@ Inclusion.include = function (objects, include, options, cb) {
       if (filter.fields && Array.isArray(subInclude) &&
         relation.modelTo.relations) {
         includeScope.fields = [];
-        subInclude.forEach(function (name) {
+        subInclude.forEach(function(name) {
           var rel = relation.modelTo.relations[name];
           if (rel && rel.type === 'belongsTo') {
             includeScope.fields.push(rel.keyFrom);
           }
         });
       }
-      utils.mergeQuery(filter, includeScope, {fields: false});
+      utils.mergeQuery(filter, includeScope, { fields: false });
     }
     //Let's add a placeholder where query
     filter.where = filter.where || {};
@@ -276,7 +276,7 @@ Inclusion.include = function (objects, include, options, cb) {
       }
 
       //This handles exactly hasMany. Fast and straightforward. Without parallel, each and other boilerplate.
-      if(relation.type === 'hasMany' && relation.multiple && !subInclude){
+      if (relation.type === 'hasMany' && relation.multiple && !subInclude) {
         return includeHasManySimple(cb);
       }
       //assuming all other relations with multiple=true as hasMany
@@ -321,10 +321,10 @@ Inclusion.include = function (objects, include, options, cb) {
       //default filters are not applicable on through model. should be applied
       //on modelTo later in 2nd DB call.
       var throughFilter = {
-        where: {}
+        where: {},
       };
       throughFilter.where[relation.keyTo] = {
-        inq: uniq(sourceIds)
+        inq: uniq(sourceIds),
       };
       if (polymorphic) {
         //handle polymorphic hasMany (reverse) in which case we need to filter
@@ -367,7 +367,7 @@ Inclusion.include = function (objects, include, options, cb) {
         //Polymorphic relation does not have idKey of modelTo. Find it manually
         var modelToIdName = idName(relation.modelTo);
         filter.where[modelToIdName] = {
-          inq: uniq(targetIds)
+          inq: uniq(targetIds),
         };
 
         //make sure that the modelToIdName is included if fields are specified
@@ -401,7 +401,7 @@ Inclusion.include = function (objects, include, options, cb) {
             function linkManyToMany(target, next) {
               var targetId = target[modelToIdName];
               var objList = targetObjsMap[targetId.toString()];
-              async.each(objList, function (obj, next) {
+              async.each(objList, function(obj, next) {
                 if (!obj) return next();
                 obj.__cachedRelations[relationName].push(target);
                 processTargetObj(obj, next);
@@ -450,7 +450,7 @@ Inclusion.include = function (objects, include, options, cb) {
         obj.__cachedRelations[relationName] = [];
       }
       filter.where[relation.keyTo] = {
-        inq: uniq(allTargetIds)
+        inq: uniq(allTargetIds),
       };
       relation.applyScope(null, filter);
       /**
@@ -481,7 +481,7 @@ Inclusion.include = function (objects, include, options, cb) {
           async.each(targets, linkManyToMany, next);
           function linkManyToMany(target, next) {
             var objList = targetObjsMap[target[relation.keyTo].toString()];
-            async.each(objList, function (obj, next) {
+            async.each(objList, function(obj, next) {
               if (!obj) return next();
               obj.__cachedRelations[relationName].push(target);
               processTargetObj(obj, next);
@@ -503,21 +503,21 @@ Inclusion.include = function (objects, include, options, cb) {
       var objIdMap2 = includeUtils.buildOneToOneIdentityMapWithOrigKeys(objs, relation.keyFrom);
 
       filter.where[relation.keyTo] = {
-        inq: uniq(objIdMap2.getKeys())
+        inq: uniq(objIdMap2.getKeys()),
       };
 
       relation.applyScope(null, filter);
       relation.modelTo.find(filter, options, targetFetchHandler);
 
       function targetFetchHandler(err, targets) {
-        if(err) {
+        if (err) {
           return callback(err);
         }
         var targetsIdMap = includeUtils.buildOneToManyIdentityMapWithOrigKeys(targets, relation.keyTo);
-        includeUtils.join(objIdMap2, targetsIdMap, function(obj1, valueToMergeIn){
+        includeUtils.join(objIdMap2, targetsIdMap, function(obj1, valueToMergeIn) {
           defineCachedRelations(obj1);
           obj1.__cachedRelations[relationName] = valueToMergeIn;
-          processTargetObj(obj1, function(){});
+          processTargetObj(obj1, function() {});
         });
         callback(err, objs);
       }
@@ -545,7 +545,7 @@ Inclusion.include = function (objects, include, options, cb) {
         obj.__cachedRelations[relationName] = [];
       }
       filter.where[relation.keyTo] = {
-        inq: uniq(sourceIds)
+        inq: uniq(sourceIds),
       };
       relation.applyScope(null, filter);
       options.partitionBy = relation.keyTo;
@@ -580,7 +580,7 @@ Inclusion.include = function (objects, include, options, cb) {
           function linkManyToOne(target, next) {
             //fix for bug in hasMany with referencesMany
             var targetIds = [].concat(target[relation.keyTo]);
-            async.each(targetIds, function (targetId, next) {
+            async.each(targetIds, function(targetId, next) {
               var obj = objIdMap[targetId.toString()];
               if (!obj) return next();
               obj.__cachedRelations[relationName].push(target);
@@ -644,11 +644,11 @@ Inclusion.include = function (objects, include, options, cb) {
        * @param callback
        */
       function processPolymorphicType(modelType, callback) {
-        var typeFilter = {where: {}};
+        var typeFilter = { where: {}};
         utils.mergeQuery(typeFilter, filter);
         var targetIds = targetIdsByType[modelType];
         typeFilter.where[relation.keyTo] = {
-          inq: uniq(targetIds)
+          inq: uniq(targetIds),
         };
         var Model = lookupModel(relation.modelFrom.dataSource.modelBuilder.
           models, modelType);
@@ -684,7 +684,7 @@ Inclusion.include = function (objects, include, options, cb) {
             async.each(targets, linkOneToMany, next);
             function linkOneToMany(target, next) {
               var objList = targetObjsMap[target[relation.keyTo].toString()];
-              async.each(objList, function (obj, next) {
+              async.each(objList, function(obj, next) {
                 if (!obj) return next();
                 obj.__cachedRelations[relationName] = target;
                 processTargetObj(obj, next);
@@ -720,7 +720,7 @@ Inclusion.include = function (objects, include, options, cb) {
         obj.__cachedRelations[relationName] = null;
       }
       filter.where[relation.keyTo] = {
-        inq: uniq(sourceIds)
+        inq: uniq(sourceIds),
       };
       relation.applyScope(null, filter);
       relation.modelTo.find(filter, options, targetFetchHandler);
@@ -787,7 +787,7 @@ Inclusion.include = function (objects, include, options, cb) {
         obj.__cachedRelations[relationName] = null;
       }
       filter.where[relation.keyTo] = {
-        inq: uniq(targetIds)
+        inq: uniq(targetIds),
       };
       relation.applyScope(null, filter);
       relation.modelTo.find(filter, options, targetFetchHandler);
@@ -815,7 +815,7 @@ Inclusion.include = function (objects, include, options, cb) {
           function linkOneToMany(target, next) {
             var targetId = target[relation.keyTo];
             var objList = objTargetIdMap[targetId.toString()];
-            async.each(objList, function (obj, next) {
+            async.each(objList, function(obj, next) {
               if (!obj) return next();
               obj.__cachedRelations[relationName] = target;
               processTargetObj(obj, next);
@@ -838,7 +838,7 @@ Inclusion.include = function (objects, include, options, cb) {
      * @param callback
      */
     function includeEmbeds(callback) {
-      async.each(objs, function (obj, next) {
+      async.each(objs, function(obj, next) {
         processTargetObj(obj, next);
       }, callback);
     }
@@ -914,14 +914,14 @@ Inclusion.include = function (objects, include, options, cb) {
           });
         }
 
-        utils.mergeQuery(filter, includeScope, {fields: false});
+        utils.mergeQuery(filter, includeScope, { fields: false });
 
         related = inst[relationName].bind(inst, filter);
       } else {
         related = inst[relationName].bind(inst, undefined);
       }
 
-      related(options, function (err, result) {
+      related(options, function(err, result) {
         if (err) {
           return callback(err);
         } else {
diff --git a/lib/include_utils.js b/lib/include_utils.js
index e12042ad..29145fb9 100644
--- a/lib/include_utils.js
+++ b/lib/include_utils.js
@@ -18,7 +18,7 @@ module.exports.KVMap = KVMap;
  */
 function buildOneToOneIdentityMapWithOrigKeys(objs, idName) {
   var kvMap = new KVMap();
-  for(var i = 0; i < objs.length; i++) {
+  for (var i = 0; i < objs.length; i++) {
     var obj = objs[i];
     var id = obj[idName];
     kvMap.set(id, obj);
@@ -28,7 +28,7 @@ function buildOneToOneIdentityMapWithOrigKeys(objs, idName) {
 
 function buildOneToManyIdentityMapWithOrigKeys(objs, idName) {
   var kvMap = new KVMap();
-  for(var i = 0; i < objs.length; i++) {
+  for (var i = 0; i < objs.length; i++) {
     var obj = objs[i];
     var id = obj[idName];
     var value = kvMap.get(id) || [];
@@ -48,7 +48,7 @@ function buildOneToManyIdentityMapWithOrigKeys(objs, idName) {
  */
 function join(oneToOneIdMap, oneToManyIdMap, mergeF) {
   var ids = oneToOneIdMap.getKeys();
-  for(var i = 0; i < ids.length; i++) {
+  for (var i = 0; i < ids.length; i++) {
     var id = ids[i];
     var obj = oneToOneIdMap.get(id);
     var objectsToMergeIn = oneToManyIdMap.get(id) || [];
@@ -62,28 +62,28 @@ function join(oneToOneIdMap, oneToManyIdMap, mergeF) {
  * @returns {{set: Function, get: Function, remove: Function, exist: Function, getKeys: Function}}
  * @constructor
  */
-function KVMap(){
+function KVMap() {
   var _originalKeyFieldName = 'originalKey';
   var _valueKeyFieldName = 'value';
   var _dict = {};
-  var keyToString = function(key){ return key.toString() };
+  var keyToString = function(key) { return key.toString(); };
   var mapImpl = {
-    set: function(key, value){
+    set: function(key, value) {
       var recordObj = {};
       recordObj[_originalKeyFieldName] = key;
       recordObj[_valueKeyFieldName] = value;
       _dict[keyToString(key)] = recordObj;
       return true;
     },
-    get: function(key){
+    get: function(key) {
       var storeObj = _dict[keyToString(key)];
-      if(storeObj) {
+      if (storeObj) {
         return storeObj[_valueKeyFieldName];
       } else {
         return undefined;
       }
     },
-    remove: function(key){
+    remove: function(key) {
       delete _dict[keyToString(key)];
       return true;
     },
@@ -91,13 +91,13 @@ function KVMap(){
       var result = _dict.hasOwnProperty(keyToString(key));
       return result;
     },
-    getKeys: function(){
+    getKeys: function() {
       var result = [];
-      for(var key in _dict) {
+      for (var key in _dict) {
         result.push(_dict[key][_originalKeyFieldName]);
       }
       return result;
-    }
+    },
 
   };
   return mapImpl;
diff --git a/lib/introspection.js b/lib/introspection.js
index 34ccf392..8fd27c4c 100644
--- a/lib/introspection.js
+++ b/lib/introspection.js
@@ -62,6 +62,6 @@ module.exports = function getIntrospector(ModelBuilder) {
 
   ModelBuilder.introspect = introspectType;
   return introspectType;
-}
+};
 
 
diff --git a/lib/jutil.js b/lib/jutil.js
index 7b5f7cda..29049669 100644
--- a/lib/jutil.js
+++ b/lib/jutil.js
@@ -10,16 +10,16 @@ var util = require('util');
  * @param newClass
  * @param baseClass
  */
-exports.inherits = function (newClass, baseClass, options) {
+exports.inherits = function(newClass, baseClass, options) {
   util.inherits(newClass, baseClass);
 
   options = options || {
     staticProperties: true,
-    override: false
+    override: false,
   };
 
   if (options.staticProperties) {
-    Object.keys(baseClass).forEach(function (classProp) {
+    Object.keys(baseClass).forEach(function(classProp) {
       if (classProp !== 'super_' && (!newClass.hasOwnProperty(classProp)
         || options.override)) {
         var pd = Object.getOwnPropertyDescriptor(baseClass, classProp);
@@ -35,7 +35,7 @@ exports.inherits = function (newClass, baseClass, options) {
  * @param mixinClass The class to be mixed in
  * @param options
  */
-exports.mixin = function (newClass, mixinClass, options) {
+exports.mixin = function(newClass, mixinClass, options) {
   if (Array.isArray(newClass._mixins)) {
     if (newClass._mixins.indexOf(mixinClass) !== -1) {
       return;
@@ -49,7 +49,7 @@ exports.mixin = function (newClass, mixinClass, options) {
     staticProperties: true,
     instanceProperties: true,
     override: false,
-    proxyFunctions: false
+    proxyFunctions: false,
   };
 
   if (options.staticProperties === undefined) {
@@ -72,7 +72,7 @@ exports.mixin = function (newClass, mixinClass, options) {
 };
 
 function mixInto(sourceScope, targetScope, options) {
-  Object.keys(sourceScope).forEach(function (propertyName) {
+  Object.keys(sourceScope).forEach(function(propertyName) {
     var targetPropertyExists = targetScope.hasOwnProperty(propertyName);
     var sourceProperty = Object.getOwnPropertyDescriptor(sourceScope, propertyName);
     var targetProperty = targetPropertyExists && Object.getOwnPropertyDescriptor(targetScope, propertyName);
diff --git a/lib/list.js b/lib/list.js
index 0f47c5a8..94d211a5 100644
--- a/lib/list.js
+++ b/lib/list.js
@@ -34,7 +34,7 @@ function List(items, itemType, parent) {
     throw err;
   }
 
-  if(!itemType) {
+  if (!itemType) {
     itemType = items[0] && items[0].constructor;
   }
 
@@ -42,25 +42,25 @@ function List(items, itemType, parent) {
     itemType = itemType[0];
   }
 
-  if(itemType === Array) {
+  if (itemType === Array) {
     itemType = Any;
   }
 
   Object.defineProperty(arr, 'itemType', {
     writable: true,
     enumerable: false,
-    value: itemType
+    value: itemType,
   });
 
   if (parent) {
     Object.defineProperty(arr, 'parent', {
       writable: true,
       enumerable: false,
-      value: parent
+      value: parent,
     });
   }
 
-  items.forEach(function (item, i) {
+  items.forEach(function(item, i) {
     if (itemType && !(item instanceof itemType)) {
       arr[i] = itemType(item);
     } else {
@@ -75,15 +75,15 @@ util.inherits(List, Array);
 
 var _push = List.prototype.push;
 
-List.prototype.push = function (obj) {
+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, removeHidden, removeProtected) {
+List.prototype.toObject = function(onlySchema, removeHidden, removeProtected) {
   var items = [];
-  this.forEach(function (item) {
+  this.forEach(function(item) {
     if (item && typeof item === 'object' && item.toObject) {
       items.push(item.toObject(onlySchema, removeHidden, removeProtected));
     } else {
@@ -93,11 +93,11 @@ List.prototype.toObject = function (onlySchema, removeHidden, removeProtected) {
   return items;
 };
 
-List.prototype.toJSON = function () {
+List.prototype.toJSON = function() {
   return this.toObject(true);
 };
 
-List.prototype.toString = function () {
+List.prototype.toString = function() {
   return JSON.stringify(this.toJSON());
 };
 
diff --git a/lib/mixins.js b/lib/mixins.js
index 322f0b20..e9e04d60 100644
--- a/lib/mixins.js
+++ b/lib/mixins.js
@@ -40,7 +40,7 @@ MixinProvider.prototype.applyMixin = function applyMixin(modelClass, name, optio
   } else {
     // Try model name
     var model = this.modelBuilder.getModel(name);
-    if(model) {
+    if (model) {
       debug('Mixin is resolved to a model: %s', name);
       modelClass.mixin(model, options);
     } else {
@@ -62,7 +62,7 @@ MixinProvider.prototype.define = function defineMixin(name, mixin) {
     debug('Defining mixin: %s', name);
   }
   if (isModelClass(mixin)) {
-    this.mixins[name] = function (Model, options) {
+    this.mixins[name] = function(Model, options) {
       Model.mixin(mixin, options);
     };
   } else if (typeof mixin === 'function') {
diff --git a/lib/model-builder.js b/lib/model-builder.js
index 81d1c051..9cd156b5 100644
--- a/lib/model-builder.js
+++ b/lib/model-builder.js
@@ -68,10 +68,10 @@ function isModelClass(cls) {
  * @param {Boolean} forceCreate Whether the create a stub for the given name if a model doesn't exist.
  * @returns {*} The model class
  */
-ModelBuilder.prototype.getModel = function (name, forceCreate) {
+ModelBuilder.prototype.getModel = function(name, forceCreate) {
   var model = this.models[name];
   if (!model && forceCreate) {
-    model = this.define(name, {}, {unresolved: true});
+    model = this.define(name, {}, { unresolved: true });
   }
   return model;
 };
@@ -81,7 +81,7 @@ ModelBuilder.prototype.getModel = function (name, forceCreate) {
  * @param {String} name The model name
  * @returns {ModelDefinition} The model definition
  */
-ModelBuilder.prototype.getModelDefinition = function (name) {
+ModelBuilder.prototype.getModelDefinition = function(name) {
   return this.definitions[name];
 };
 
@@ -214,7 +214,7 @@ ModelBuilder.prototype.define = function defineClass(className, properties, sett
 
   // Return the unresolved model
   if (settings.unresolved) {
-    ModelClass.settings = {unresolved: true};
+    ModelClass.settings = { unresolved: true };
     return ModelClass;
   }
 
@@ -241,7 +241,7 @@ ModelBuilder.prototype.define = function defineClass(className, properties, sett
 
   // Load and inject the model classes
   if (settings.models) {
-    Object.keys(settings.models).forEach(function (m) {
+    Object.keys(settings.models).forEach(function(m) {
       var model = settings.models[m];
       ModelClass[m] = typeof model === 'string' ? modelBuilder.getModel(model, true) : model;
     });
@@ -297,18 +297,18 @@ ModelBuilder.prototype.define = function defineClass(className, properties, sett
     var idProp = idNames[0];
     if (idProp !== 'id') {
       Object.defineProperty(ModelClass.prototype, 'id', {
-        get: function () {
+        get: function() {
           var idProp = ModelClass.definition.idNames()[0];
           return this.__data[idProp];
         },
         configurable: true,
-        enumerable: false
+        enumerable: false,
       });
     }
   } else {
     // Now the id property is an object that consists of multiple keys
     Object.defineProperty(ModelClass.prototype, 'id', {
-      get: function () {
+      get: function() {
         var compositeId = {};
         var idNames = ModelClass.definition.idNames();
         for (var i = 0, p; i < idNames.length; i++) {
@@ -318,12 +318,12 @@ ModelBuilder.prototype.define = function defineClass(className, properties, sett
         return compositeId;
       },
       configurable: true,
-      enumerable: false
+      enumerable: false,
     });
   }
 
   // A function to loop through the properties
-  ModelClass.forEachProperty = function (cb) {
+  ModelClass.forEachProperty = function(cb) {
     var props = ModelClass.definition.properties;
     var keys = Object.keys(props);
     for (var i = 0, n = keys.length; i < n; i++) {
@@ -332,7 +332,7 @@ ModelBuilder.prototype.define = function defineClass(className, properties, sett
   };
 
   // A function to attach the model class to a data source
-  ModelClass.attachTo = function (dataSource) {
+  ModelClass.attachTo = function(dataSource) {
     dataSource.attach(this);
   };
 
@@ -356,7 +356,7 @@ ModelBuilder.prototype.define = function defineClass(className, properties, sett
    * @options {Object} settings Model settings, such as relations and acls.
    *
    */
-  ModelClass.extend = function (className, subclassProperties, subclassSettings) {
+  ModelClass.extend = function(className, subclassProperties, subclassSettings) {
     var properties = ModelClass.definition.properties;
     var settings = ModelClass.definition.settings;
 
@@ -418,7 +418,7 @@ ModelBuilder.prototype.define = function defineClass(className, properties, sett
    * Register a property for the model class
    * @param {String} propertyName Name of the property.
    */
-  ModelClass.registerProperty = function (propertyName) {
+  ModelClass.registerProperty = function(propertyName) {
     var properties = modelDefinition.build();
     var prop = properties[propertyName];
     var DataType = prop.type;
@@ -432,14 +432,14 @@ ModelBuilder.prototype.define = function defineClass(className, properties, sett
     }
 
     Object.defineProperty(ModelClass.prototype, propertyName, {
-      get: function () {
+      get: function() {
         if (ModelClass.getter[propertyName]) {
           return ModelClass.getter[propertyName].call(this); // Try getter first
         } else {
           return this.__data && this.__data[propertyName]; // Try __data
         }
       },
-      set: function (value) {
+      set: function(value) {
         var DataType = ModelClass.definition.properties[propertyName].type;
         if (Array.isArray(DataType) || DataType === Array) {
           DataType = List;
@@ -474,23 +474,23 @@ ModelBuilder.prototype.define = function defineClass(className, properties, sett
         }
       },
       configurable: true,
-      enumerable: true
+      enumerable: true,
     });
 
     // FIXME: [rfeng] Do we need to keep the raw data?
     // Use $ as the prefix to avoid conflicts with properties such as _id
     Object.defineProperty(ModelClass.prototype, '$' + propertyName, {
-      get: function () {
+      get: function() {
         return this.__data && this.__data[propertyName];
       },
-      set: function (value) {
+      set: function(value) {
         if (!this.__data) {
           this.__data = {};
         }
         this.__data[propertyName] = value;
       },
       configurable: true,
-      enumerable: false
+      enumerable: false,
     });
   };
 
@@ -563,7 +563,7 @@ function BooleanType(arg) {
  * @param {String} propertyName Name of property
  * @param {Object} propertyDefinition Property settings
  */
-ModelBuilder.prototype.defineProperty = function (model, propertyName, propertyDefinition) {
+ModelBuilder.prototype.defineProperty = function(model, propertyName, propertyDefinition) {
   this.definitions[model].defineProperty(propertyName, propertyDefinition);
   this.models[model].registerProperty(propertyName);
 };
@@ -607,7 +607,7 @@ ModelBuilder.prototype.defineValueType = function(type, aliases) {
  * @property {String} type Datatype of property: Must be an [LDL type](http://docs.strongloop.com/display/LB/LoopBack+types).
  * @property {Boolean} index True if the property is an index; false otherwise.
  */
-ModelBuilder.prototype.extendModel = function (model, props) {
+ModelBuilder.prototype.extendModel = function(model, props) {
   var t = this;
   var keys = Object.keys(props);
   for (var i = 0; i < keys.length; i++) {
@@ -638,7 +638,7 @@ ModelBuilder.prototype.copyModel = function copyModel(Master) {
     modelBuilder.models[className] = Slave;
     modelBuilder.definitions[className] = {
       properties: md.properties,
-      settings: md.settings
+      settings: md.settings,
     };
   }
 
@@ -653,14 +653,14 @@ function hiddenProperty(where, property, value) {
     writable: true,
     enumerable: false,
     configurable: true,
-    value: value
+    value: value,
   });
 }
 
 /**
  * Get the schema name
  */
-ModelBuilder.prototype.getSchemaName = function (name) {
+ModelBuilder.prototype.getSchemaName = function(name) {
   if (name) {
     return name;
   }
@@ -677,7 +677,7 @@ ModelBuilder.prototype.getSchemaName = function (name) {
  * Returns {Function} if the type is resolved
  * @param {String} type The type string, such as 'number', 'Number', 'boolean', or 'String'. It's case insensitive
  */
-ModelBuilder.prototype.resolveType = function (type) {
+ModelBuilder.prototype.resolveType = function(type) {
   if (!type) {
     return type;
   }
@@ -697,7 +697,7 @@ ModelBuilder.prototype.resolveType = function (type) {
       return schemaType;
     } else {
       // The type cannot be resolved, let's create a place holder
-      type = this.define(type, {}, {unresolved: true});
+      type = this.define(type, {}, { unresolved: true });
       return type;
     }
   } else if (type.constructor.name === 'Object') {
@@ -706,7 +706,7 @@ ModelBuilder.prototype.resolveType = function (type) {
       return this.resolveType(type.type);
     } else {
       return this.define(this.getSchemaName(null),
-        type, {anonymous: true, idInjection: false});
+        type, { anonymous: true, idInjection: false });
     }
   } else if ('function' === typeof type) {
     return type;
@@ -726,7 +726,7 @@ ModelBuilder.prototype.resolveType = function (type) {
  * @param {*} schemas The schemas
  * @returns {Object} A map of model constructors keyed by model name
  */
-ModelBuilder.prototype.buildModels = function (schemas, createModel) {
+ModelBuilder.prototype.buildModels = function(schemas, createModel) {
   var models = {};
 
   // Normalize the schemas to be an array of the schema objects {name: <name>, properties: {}, options: {}}
@@ -740,8 +740,8 @@ ModelBuilder.prototype.buildModels = function (schemas, createModel) {
         {
           name: this.getSchemaName(),
           properties: schemas,
-          options: {anonymous: true}
-        }
+          options: { anonymous: true },
+        },
       ];
     }
   }
@@ -751,7 +751,7 @@ ModelBuilder.prototype.buildModels = function (schemas, createModel) {
     var name = this.getSchemaName(schemas[s].name);
     schemas[s].name = name;
     var model;
-    if(typeof createModel === 'function') {
+    if (typeof createModel === 'function') {
       model = createModel(schemas[s].name, schemas[s].properties, schemas[s].options);
     } else {
       model = this.define(schemas[s].name, schemas[s].properties, schemas[s].options);
@@ -767,7 +767,7 @@ ModelBuilder.prototype.buildModels = function (schemas, createModel) {
     var targetModel = models[relation.target];
     if (sourceModel && targetModel) {
       if (typeof sourceModel[relation.type] === 'function') {
-        sourceModel[relation.type](targetModel, {as: relation.as});
+        sourceModel[relation.type](targetModel, { as: relation.as });
       }
     }
   }
@@ -781,7 +781,7 @@ ModelBuilder.prototype.buildModels = function (schemas, createModel) {
  * @param {Object} options The options
  * @returns {}
  */
-ModelBuilder.prototype.buildModelFromInstance = function (name, json, options) {
+ModelBuilder.prototype.buildModelFromInstance = function(name, json, options) {
 
   // Introspect the JSON document to generate a schema
   var schema = introspect(json);
diff --git a/lib/model-definition.js b/lib/model-definition.js
index 8b65c50d..6481f540 100644
--- a/lib/model-definition.js
+++ b/lib/model-definition.js
@@ -58,7 +58,7 @@ require('./types')(ModelDefinition);
  * Return table name for specified `modelName`
  * @param {String} connectorType The connector type, such as 'oracle' or 'mongodb'
  */
-ModelDefinition.prototype.tableName = function (connectorType) {
+ModelDefinition.prototype.tableName = function(connectorType) {
   var settings = this.settings;
   if (settings[connectorType]) {
     return settings[connectorType].table || settings[connectorType].tableName || this.name;
@@ -73,7 +73,7 @@ ModelDefinition.prototype.tableName = function (connectorType) {
  * @param propertyName The property name
  * @returns {String} columnName
  */
-ModelDefinition.prototype.columnName = function (connectorType, propertyName) {
+ModelDefinition.prototype.columnName = function(connectorType, propertyName) {
   if (!propertyName) {
     return propertyName;
   }
@@ -92,7 +92,7 @@ ModelDefinition.prototype.columnName = function (connectorType, propertyName) {
  * @param propertyName The property name
  * @returns {Object} column metadata
  */
-ModelDefinition.prototype.columnMetadata = function (connectorType, propertyName) {
+ModelDefinition.prototype.columnMetadata = function(connectorType, propertyName) {
   if (!propertyName) {
     return propertyName;
   }
@@ -110,7 +110,7 @@ ModelDefinition.prototype.columnMetadata = function (connectorType, propertyName
  * @param {String} connectorType The connector type, such as 'oracle' or 'mongodb'
  * @returns {String[]} column names
  */
-ModelDefinition.prototype.columnNames = function (connectorType) {
+ModelDefinition.prototype.columnNames = function(connectorType) {
   this.build();
   var props = this.properties;
   var cols = [];
@@ -128,7 +128,7 @@ ModelDefinition.prototype.columnNames = function (connectorType) {
  * Find the ID properties sorted by the index
  * @returns {Object[]} property name/index for IDs
  */
-ModelDefinition.prototype.ids = function () {
+ModelDefinition.prototype.ids = function() {
   if (this._ids) {
     return this._ids;
   }
@@ -143,9 +143,9 @@ ModelDefinition.prototype.ids = function () {
     if (typeof id !== 'number') {
       id = 1;
     }
-    ids.push({name: key, id: id, property: props[key]});
+    ids.push({ name: key, id: id, property: props[key] });
   }
-  ids.sort(function (a, b) {
+  ids.sort(function(a, b) {
     return a.id - b.id;
   });
   this._ids = ids;
@@ -157,7 +157,7 @@ ModelDefinition.prototype.ids = function () {
  * @param {String} modelName The model name
  * @returns {String} columnName for ID
  */
-ModelDefinition.prototype.idColumnName = function (connectorType) {
+ModelDefinition.prototype.idColumnName = function(connectorType) {
   return this.columnName(connectorType, this.idName());
 };
 
@@ -165,7 +165,7 @@ ModelDefinition.prototype.idColumnName = function (connectorType) {
  * Find the ID property name
  * @returns {String} property name for ID
  */
-ModelDefinition.prototype.idName = function () {
+ModelDefinition.prototype.idName = function() {
   var id = this.ids()[0];
   if (this.properties.id && this.properties.id.id) {
     return 'id';
@@ -178,9 +178,9 @@ ModelDefinition.prototype.idName = function () {
  * Find the ID property names sorted by the index
  * @returns {String[]} property names for IDs
  */
-ModelDefinition.prototype.idNames = function () {
+ModelDefinition.prototype.idNames = function() {
   var ids = this.ids();
-  var names = ids.map(function (id) {
+  var names = ids.map(function(id) {
     return id.name;
   });
   return names;
@@ -190,7 +190,7 @@ ModelDefinition.prototype.idNames = function () {
  *
  * @returns {{}}
  */
-ModelDefinition.prototype.indexes = function () {
+ModelDefinition.prototype.indexes = function() {
   this.build();
   var indexes = {};
   if (this.settings.indexes) {
@@ -210,7 +210,7 @@ ModelDefinition.prototype.indexes = function () {
  * Build a model definition
  * @param {Boolean} force Forcing rebuild
  */
-ModelDefinition.prototype.build = function (forceRebuild) {
+ModelDefinition.prototype.build = function(forceRebuild) {
   if (forceRebuild) {
     this.properties = null;
     this.relations = [];
@@ -229,11 +229,11 @@ ModelDefinition.prototype.build = function (forceRebuild) {
         source: this.name,
         target: type,
         type: Array.isArray(prop) ? 'hasMany' : 'belongsTo',
-        as: p
+        as: p,
       });
     } else {
       var typeDef = {
-        type: type
+        type: type,
       };
       if (typeof prop === 'object' && prop !== null) {
         for (var a in prop) {
@@ -254,7 +254,7 @@ ModelDefinition.prototype.build = function (forceRebuild) {
  * @param {String} propertyName The property name
  * @param {Object} propertyDefinition The property definition
  */
-ModelDefinition.prototype.defineProperty = function (propertyName, propertyDefinition) {
+ModelDefinition.prototype.defineProperty = function(propertyName, propertyDefinition) {
   this.rawProperties[propertyName] = propertyDefinition;
   this.build(true);
 };
@@ -266,7 +266,7 @@ function isModelClass(cls) {
   return cls.prototype instanceof ModelBaseClass;
 }
 
-ModelDefinition.prototype.toJSON = function (forceRebuild) {
+ModelDefinition.prototype.toJSON = function(forceRebuild) {
   if (forceRebuild) {
     this.json = null;
   }
@@ -276,11 +276,11 @@ ModelDefinition.prototype.toJSON = function (forceRebuild) {
   var json = {
     name: this.name,
     properties: {},
-    settings: this.settings
+    settings: this.settings,
   };
   this.build(forceRebuild);
 
-  var mapper = function (val) {
+  var mapper = function(val) {
     if (val === undefined || val === null) {
       return val;
     }
diff --git a/lib/model.js b/lib/model.js
index 3d5266a6..8b9cec46 100644
--- a/lib/model.js
+++ b/lib/model.js
@@ -31,7 +31,7 @@ var BASE_TYPES = {
   'Number': true,
   'Date': true,
   'Text': true,
-  'ObjectID': true
+  'ObjectID': true,
 };
 
 /**
@@ -44,7 +44,7 @@ var BASE_TYPES = {
  */
 function ModelBaseClass(data, options) {
   options = options || {};
-  if(!('applySetters' in options)) {
+  if (!('applySetters' in options)) {
     // Default to true
     options.applySetters = true;
   }
@@ -64,11 +64,11 @@ function ModelBaseClass(data, options) {
  * @property {Boolean} persisted Whether the instance has been persisted
  * @private
  */
-ModelBaseClass.prototype._initProperties = function (data, options) {
+ModelBaseClass.prototype._initProperties = function(data, options) {
   var self = this;
   var ctor = this.constructor;
 
-  if(data instanceof ctor) {
+  if (data instanceof ctor) {
     // Convert the data to be plain object to avoid pollutions
     data = data.toObject(false);
   }
@@ -84,7 +84,7 @@ ModelBaseClass.prototype._initProperties = function (data, options) {
   var applyDefaultValues = options.applyDefaultValues;
   var strict = options.strict;
 
-  if(strict === undefined) {
+  if (strict === undefined) {
     strict = ctor.definition.settings.strict;
   }
 
@@ -99,14 +99,14 @@ ModelBaseClass.prototype._initProperties = function (data, options) {
         writable: true,
         enumerable: false,
         configurable: true,
-        value: {}
+        value: {},
       },
 
       __data: {
         writable: true,
         enumerable: false,
         configurable: true,
-        value: {}
+        value: {},
       },
 
       // Instance level data source
@@ -114,7 +114,7 @@ ModelBaseClass.prototype._initProperties = function (data, options) {
         writable: true,
         enumerable: false,
         configurable: true,
-        value: options.dataSource
+        value: options.dataSource,
       },
 
       // Instance level strict mode
@@ -122,14 +122,14 @@ ModelBaseClass.prototype._initProperties = function (data, options) {
         writable: true,
         enumerable: false,
         configurable: true,
-        value: strict
+        value: strict,
       },
 
       __persisted: {
         writable: true,
         enumerable: false,
         configurable: true,
-        value: false
+        value: false,
       },
     });
 
@@ -138,7 +138,7 @@ ModelBaseClass.prototype._initProperties = function (data, options) {
         writable: true,
         enumerable: false,
         configrable: true,
-        value: []
+        value: [],
       });
     }
   } else {
@@ -320,13 +320,13 @@ ModelBaseClass.prototype._initProperties = function (data, options) {
       if (type.prototype instanceof ModelBaseClass) {
         if (!(self.__data[p] instanceof type)
           && typeof self.__data[p] === 'object'
-          && self.__data[p] !== null ) {
+          && self.__data[p] !== null) {
           self.__data[p] = new type(self.__data[p]);
         }
       } else if (type.name === 'Array' || Array.isArray(type)) {
         if (!(self.__data[p] instanceof List)
           && self.__data[p] !== undefined
-          && self.__data[p] !== null ) {
+          && self.__data[p] !== null) {
           self.__data[p] = List(self.__data[p], type, self);
         }
       }
@@ -340,15 +340,15 @@ ModelBaseClass.prototype._initProperties = function (data, options) {
  * @param {String} prop Property name
  * @param {Object} params Various property configuration
  */
-ModelBaseClass.defineProperty = function (prop, params) {
-  if(this.dataSource) {
+ModelBaseClass.defineProperty = function(prop, params) {
+  if (this.dataSource) {
     this.dataSource.defineProperty(this.modelName, prop, params);
   } else {
     this.modelBuilder.defineProperty(this.modelName, prop, params);
   }
 };
 
-ModelBaseClass.getPropertyType = function (propName) {
+ModelBaseClass.getPropertyType = function(propName) {
   var prop = this.definition.properties[propName];
   if (!prop) {
     // The property is not part of the definition
@@ -361,7 +361,7 @@ ModelBaseClass.getPropertyType = function (propName) {
   return prop.type.name;
 };
 
-ModelBaseClass.prototype.getPropertyType = function (propName) {
+ModelBaseClass.prototype.getPropertyType = function(propName) {
   return this.constructor.getPropertyType(propName);
 };
 
@@ -369,7 +369,7 @@ ModelBaseClass.prototype.getPropertyType = function (propName) {
  * Return string representation of class
  * This overrides the default `toString()` method
  */
-ModelBaseClass.toString = function () {
+ModelBaseClass.toString = function() {
   return '[Model ' + this.modelName + ']';
 };
 
@@ -379,7 +379,7 @@ ModelBaseClass.toString = function () {
  *
  * @param {Boolean} onlySchema Restrict properties to dataSource only.  Default is false.  If true, the function returns only properties defined in the schema;  Otherwise it returns all enumerable properties.
  */
-ModelBaseClass.prototype.toObject = function (onlySchema, removeHidden, removeProtected) {
+ModelBaseClass.prototype.toObject = function(onlySchema, removeHidden, removeProtected) {
   if (onlySchema === undefined) {
     onlySchema = true;
   }
@@ -504,7 +504,7 @@ ModelBaseClass.prototype.toObject = function (onlySchema, removeHidden, removePr
   return data;
 };
 
-ModelBaseClass.isProtectedProperty = function (propertyName) {
+ModelBaseClass.isProtectedProperty = function(propertyName) {
   var Model = this;
   var settings = Model.definition && Model.definition.settings;
   var protectedProperties = settings && (settings.protectedProperties || settings.protected);
@@ -523,7 +523,7 @@ ModelBaseClass.isProtectedProperty = function (propertyName) {
   }
 };
 
-ModelBaseClass.isHiddenProperty = function (propertyName) {
+ModelBaseClass.isHiddenProperty = function(propertyName) {
   var Model = this;
   var settings = Model.definition && Model.definition.settings;
   var hiddenProperties = settings && (settings.hiddenProperties || settings.hidden);
@@ -542,11 +542,11 @@ ModelBaseClass.isHiddenProperty = function (propertyName) {
   }
 };
 
-ModelBaseClass.prototype.toJSON = function () {
+ModelBaseClass.prototype.toJSON = function() {
   return this.toObject(false, true, false);
 };
 
-ModelBaseClass.prototype.fromObject = function (obj) {
+ModelBaseClass.prototype.fromObject = function(obj) {
   for (var key in obj) {
     this[key] = obj[key];
   }
@@ -557,7 +557,7 @@ ModelBaseClass.prototype.fromObject = function (obj) {
  * This method does not perform any database operations; it just resets the object to its
  * initial state.
  */
-ModelBaseClass.prototype.reset = function () {
+ModelBaseClass.prototype.reset = function() {
   var obj = this;
   for (var k in obj) {
     if (k !== 'id' && !obj.constructor.dataSource.definitions[obj.constructor.modelName].properties[k]) {
@@ -578,20 +578,20 @@ var INSPECT_SUPPORTS_OBJECT_RETVAL =
  versionParts[1] > 11 ||
  (versionParts[0] === 11 && versionParts[1] >= 14);
 
-ModelBaseClass.prototype.inspect = function (depth) {
+ModelBaseClass.prototype.inspect = function(depth) {
   if (INSPECT_SUPPORTS_OBJECT_RETVAL)
-     return this.__data;
+    return this.__data;
 
   // Workaround for older versions
   // See also https://github.com/joyent/node/commit/66280de133
   return util.inspect(this.__data, {
     showHidden: false,
     depth: depth,
-    colors: false
+    colors: false,
   });
 };
 
-ModelBaseClass.mixin = function (anotherClass, options) {
+ModelBaseClass.mixin = function(anotherClass, options) {
   if (typeof anotherClass === 'string') {
     this.modelBuilder.mixins.applyMixin(this, anotherClass, options);
   } else {
@@ -608,15 +608,15 @@ ModelBaseClass.mixin = function (anotherClass, options) {
   }
 };
 
-ModelBaseClass.prototype.getDataSource = function () {
+ModelBaseClass.prototype.getDataSource = function() {
   return this.__dataSource || this.constructor.dataSource;
 };
 
-ModelBaseClass.getDataSource = function () {
+ModelBaseClass.getDataSource = function() {
   return this.dataSource;
 };
 
-ModelBaseClass.prototype.setStrict = function (strict) {
+ModelBaseClass.prototype.setStrict = function(strict) {
   this.__strict = strict;
 };
 
diff --git a/lib/observer.js b/lib/observer.js
index 5de79fa1..f2046eb4 100644
--- a/lib/observer.js
+++ b/lib/observer.js
@@ -108,7 +108,7 @@ ObserverMixin.notifyObserversOf = function(operation, context, callback) {
           );
         }
       },
-      function(err) { callback(err, context) }
+      function(err) { callback(err, context); }
     );
   });
   return callback.promise;
diff --git a/lib/relation-definition.js b/lib/relation-definition.js
index 4c2780ce..12cb1eb0 100644
--- a/lib/relation-definition.js
+++ b/lib/relation-definition.js
@@ -26,7 +26,7 @@ var RelationTypes = {
   hasAndBelongsToMany: 'hasAndBelongsToMany',
   referencesMany: 'referencesMany',
   embedsOne: 'embedsOne',
-  embedsMany: 'embedsMany'
+  embedsMany: 'embedsMany',
 };
 
 var RelationClasses = {
@@ -37,7 +37,7 @@ var RelationClasses = {
   hasAndBelongsToMany: HasAndBelongsToMany,
   referencesMany: ReferencesMany,
   embedsOne: EmbedsOne,
-  embedsMany: EmbedsMany
+  embedsMany: EmbedsMany,
 };
 
 exports.Relation = Relation;
@@ -136,7 +136,7 @@ function RelationDefinition(definition) {
   this.methods = definition.methods || {};
 }
 
-RelationDefinition.prototype.toJSON = function () {
+RelationDefinition.prototype.toJSON = function() {
   var polymorphic = typeof this.polymorphic === 'object';
 
   var modelToName = this.modelTo && this.modelTo.modelName;
@@ -151,7 +151,7 @@ RelationDefinition.prototype.toJSON = function () {
     keyFrom: this.keyFrom,
     modelTo: modelToName,
     keyTo: this.keyTo,
-    multiple: this.multiple
+    multiple: this.multiple,
   };
   if (this.modelThrough) {
     json.modelThrough = this.modelThrough.modelName;
@@ -186,7 +186,7 @@ RelationDefinition.prototype.defineMethod = function(name, fn) {
     method = function() {
       var rel = this[relationName];
       return rel[name].apply(rel, arguments);
-    }
+    };
   }
   if (method && fn.shared) {
     sharedMethod(definition, name, method, fn);
@@ -241,16 +241,16 @@ RelationDefinition.prototype.applyProperties = function(modelInstance, obj) {
   var k, key;
   if (typeof this.properties === 'function') {
     var data = this.properties.call(this, source, target);
-    for(k in data) {
+    for (k in data) {
       target[k] = data[k];
     }
   } else if (Array.isArray(this.properties)) {
-    for(k = 0; k < this.properties.length; k++) {
+    for (k = 0; k < this.properties.length; k++) {
       key = this.properties[k];
       target[key] = source[key];
     }
   } else if (typeof this.properties === 'object') {
-    for(k in this.properties) {
+    for (k in this.properties) {
       key = this.properties[k];
       target[key] = source[k];
     }
@@ -285,12 +285,12 @@ function Relation(definition, modelInstance) {
   this.modelInstance = modelInstance;
 }
 
-Relation.prototype.resetCache = function (cache) {
+Relation.prototype.resetCache = function(cache) {
   cache = cache || undefined;
   this.modelInstance.__cachedRelations[this.definition.name] = cache;
 };
 
-Relation.prototype.getCache = function () {
+Relation.prototype.getCache = function() {
   return this.modelInstance.__cachedRelations[this.definition.name];
 };
 
@@ -333,12 +333,12 @@ function HasMany(definition, modelInstance) {
 
 util.inherits(HasMany, Relation);
 
-HasMany.prototype.removeFromCache = function (id) {
+HasMany.prototype.removeFromCache = function(id) {
   var cache = this.modelInstance.__cachedRelations[this.definition.name];
   var idName = this.definition.modelTo.definition.idName();
   if (Array.isArray(cache)) {
     for (var i = 0, n = cache.length; i < n; i++) {
-      if (idEquals(cache[i][idName],id)) {
+      if (idEquals(cache[i][idName], id)) {
         return cache.splice(i, 1);
       }
     }
@@ -346,7 +346,7 @@ HasMany.prototype.removeFromCache = function (id) {
   return null;
 };
 
-HasMany.prototype.addToCache = function (inst) {
+HasMany.prototype.addToCache = function(inst) {
   if (!inst) {
     return;
   }
@@ -357,7 +357,7 @@ HasMany.prototype.addToCache = function (inst) {
   var idName = this.definition.modelTo.definition.idName();
   if (Array.isArray(cache)) {
     for (var i = 0, n = cache.length; i < n; i++) {
-      if (idEquals(cache[i][idName],inst[idName])) {
+      if (idEquals(cache[i][idName], inst[idName])) {
         cache[i] = inst;
         return;
       }
@@ -518,7 +518,7 @@ function findBelongsTo(modelFrom, modelTo, keyTo) {
  * @returns {*} The matching model class
  */
 function lookupModel(models, modelName) {
-  if(models[modelName]) {
+  if (models[modelName]) {
     return models[modelName];
   }
   var lookupClassName = modelName.toLowerCase();
@@ -623,7 +623,7 @@ RelationDefinition.hasMany = function hasMany(modelFrom, modelTo, params) {
     scope: params.scope,
     options: params.options,
     keyThrough: keyThrough,
-    polymorphic: polymorphic
+    polymorphic: polymorphic,
   });
 
   definition.modelThrough = params.through;
@@ -641,7 +641,7 @@ RelationDefinition.hasMany = function hasMany(modelFrom, modelTo, params) {
     findById: scopeMethod(definition, 'findById'),
     destroy: scopeMethod(definition, 'destroyById'),
     updateById: scopeMethod(definition, 'updateById'),
-    exists: scopeMethod(definition, 'exists')
+    exists: scopeMethod(definition, 'exists'),
   };
 
   var findByIdFunc = scopeMethods.findById;
@@ -656,7 +656,7 @@ RelationDefinition.hasMany = function hasMany(modelFrom, modelTo, params) {
   var existsByIdFunc = scopeMethods.exists;
   modelFrom.prototype['__exists__' + relationName] = existsByIdFunc;
 
-  if(definition.modelThrough) {
+  if (definition.modelThrough) {
     scopeMethods.create = scopeMethod(definition, 'create');
     scopeMethods.add = scopeMethod(definition, 'add');
     scopeMethods.remove = scopeMethod(definition, 'remove');
@@ -682,7 +682,7 @@ RelationDefinition.hasMany = function hasMany(modelFrom, modelTo, params) {
   };
 
   // Mix the property and scoped methods into the prototype class
-  defineScope(modelFrom.prototype, params.through || modelTo, relationName, function () {
+  defineScope(modelFrom.prototype, params.through || modelTo, relationName, function() {
     var filter = {};
     filter.where = {};
     filter.where[fk] = this[pkName];
@@ -693,7 +693,7 @@ RelationDefinition.hasMany = function hasMany(modelFrom, modelTo, params) {
       var throughRelationName;
 
       // find corresponding belongsTo relations from through model as collect
-      for(var r in definition.modelThrough.relations) {
+      for (var r in definition.modelThrough.relations) {
         var relation = definition.modelThrough.relations[r];
 
         // should be a belongsTo and match modelTo and keyThrough
@@ -727,7 +727,7 @@ function scopeMethod(definition, methodName) {
   if (definition.type === RelationTypes.hasMany && definition.modelThrough) {
     relationClass = RelationClasses.hasManyThrough;
   }
-  var method = function () {
+  var method = function() {
     var relation = new relationClass(definition, this);
     return relation[methodName].apply(relation, arguments);
   };
@@ -753,7 +753,7 @@ function sharedMethod(definition, methodName, method, relationMethod) {
  * @param {Object} [options] Options
  * @param {Function} cb The callback function
  */
-HasMany.prototype.findById = function (fkId, options, cb) {
+HasMany.prototype.findById = function(fkId, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     cb = options;
     options = {};
@@ -779,7 +779,7 @@ HasMany.prototype.findById = function (fkId, options, cb) {
   }
   this.definition.applyScope(modelInstance, filter);
 
-  modelTo.findOne(filter, options, function (err, inst) {
+  modelTo.findOne(filter, options, function(err, inst) {
     if (err) {
       return cb(err);
     }
@@ -808,7 +808,7 @@ HasMany.prototype.findById = function (fkId, options, cb) {
  * @param {Object} [options] Options
  * @param {Function} cb The callback function
  */
-HasMany.prototype.exists = function (fkId, options, cb) {
+HasMany.prototype.exists = function(fkId, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     cb = options;
     options = {};
@@ -819,7 +819,7 @@ HasMany.prototype.exists = function (fkId, options, cb) {
   cb = cb || utils.createPromiseCallback();
 
 
-  this.findById(fkId, function (err, inst) {
+  this.findById(fkId, function(err, inst) {
     if (err) {
       return cb(err);
     }
@@ -843,13 +843,13 @@ HasMany.prototype.exists = function (fkId, options, cb) {
  * @param {Object} [options] Options
  * @param {Function} cb The callback function
  */
-HasMany.prototype.updateById = function (fkId, data, options, cb) {
+HasMany.prototype.updateById = function(fkId, data, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     cb = options;
     options = {};
   }
   cb = cb || utils.createPromiseCallback();
-  this.findById(fkId, options, function (err, inst) {
+  this.findById(fkId, options, function(err, inst) {
     if (err) {
       return cb && cb(err);
     }
@@ -864,7 +864,7 @@ HasMany.prototype.updateById = function (fkId, data, options, cb) {
  * @param {Object} [options] Options
  * @param {Function} cb The callback function
  */
-HasMany.prototype.destroyById = function (fkId, options, cb) {
+HasMany.prototype.destroyById = function(fkId, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     cb = options;
     options = {};
@@ -894,7 +894,7 @@ var throughKeys = function(definition) {
     }
   } else if (definition.modelFrom === definition.modelTo) {
     return findBelongsTo(modelThrough, definition.modelTo, pk2).
-      sort(function (fk1, fk2) {
+      sort(function(fk1, fk2) {
         //Fix for bug - https://github.com/strongloop/loopback-datasource-juggler/issues/571
         //Make sure that first key is mapped to modelFrom
         //& second key to modelTo. Order matters
@@ -906,7 +906,7 @@ var throughKeys = function(definition) {
     var fk2 = findBelongsTo(modelThrough, definition.modelTo, pk2)[0];
   }
   return [fk1, fk2];
-}
+};
 
 /**
  * Find a related item by foreign key
@@ -914,7 +914,7 @@ var throughKeys = function(definition) {
  * @param {Object} [options] Options
  * @param {Function} cb The callback function
  */
-HasManyThrough.prototype.findById = function (fkId, options, cb) {
+HasManyThrough.prototype.findById = function(fkId, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     cb = options;
     options = {};
@@ -927,7 +927,7 @@ HasManyThrough.prototype.findById = function (fkId, options, cb) {
 
   cb = cb || utils.createPromiseCallback();
 
-  self.exists(fkId, options, function (err, exists) {
+  self.exists(fkId, options, function(err, exists) {
     if (err || !exists) {
       if (!err) {
         err = new Error('No relation found in ' + modelThrough.modelName
@@ -937,7 +937,7 @@ HasManyThrough.prototype.findById = function (fkId, options, cb) {
       }
       return cb(err);
     }
-    modelTo.findById(fkId, options, function (err, inst) {
+    modelTo.findById(fkId, options, function(err, inst) {
       if (err) {
         return cb(err);
       }
@@ -958,7 +958,7 @@ HasManyThrough.prototype.findById = function (fkId, options, cb) {
  * @param {Object} [options] Options
  * @param {Function} cb The callback function
  */
-HasManyThrough.prototype.destroyById = function (fkId, options, cb) {
+HasManyThrough.prototype.destroyById = function(fkId, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     cb = options;
     options = {};
@@ -971,7 +971,7 @@ HasManyThrough.prototype.destroyById = function (fkId, options, cb) {
 
   cb = cb || utils.createPromiseCallback();
 
-  self.exists(fkId, options, function (err, exists) {
+  self.exists(fkId, options, function(err, exists) {
     if (err || !exists) {
       if (!err) {
         err = new Error('No record found in ' + modelThrough.modelName
@@ -982,7 +982,7 @@ HasManyThrough.prototype.destroyById = function (fkId, options, cb) {
       return cb(err);
     }
     self.remove(fkId, options, function(err) {
-      if(err) {
+      if (err) {
         return cb(err);
       }
       modelTo.deleteById(fkId, options, cb);
@@ -1012,7 +1012,7 @@ HasManyThrough.prototype.create = function create(data, options, cb) {
   var modelInstance = this.modelInstance;
 
   // First create the target model
-  modelTo.create(data, options, function (err, to) {
+  modelTo.create(data, options, function(err, to) {
     if (err) {
       return cb(err, to);
     }
@@ -1023,17 +1023,17 @@ HasManyThrough.prototype.create = function create(data, options, cb) {
     var fk2 = keys[1];
 
     function createRelation(to, next) {
-      var d = {}, q = {}, filter = {where:q};
+      var d = {}, q = {}, filter = { where:q };
       d[fk1] = q[fk1] = modelInstance[definition.keyFrom];
       d[fk2] = q[fk2] = to[pk2];
       definition.applyProperties(modelInstance, d);
       definition.applyScope(modelInstance, filter);
 
       // Then create the through model
-      modelThrough.findOrCreate(filter, d, options, function (e, through) {
+      modelThrough.findOrCreate(filter, d, options, function(e, through) {
         if (e) {
           // Undo creation of the target model
-          to.destroy(options, function () {
+          to.destroy(options, function() {
             next(e);
           });
         } else {
@@ -1061,7 +1061,7 @@ HasManyThrough.prototype.create = function create(data, options, cb) {
  * @param {Object} [options] Options
  * @param {Function} [cb] Callback function
  */
-HasManyThrough.prototype.add = function (acInst, data, options, cb) {
+HasManyThrough.prototype.add = function(acInst, data, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     cb = options;
     options = {};
@@ -1101,7 +1101,7 @@ HasManyThrough.prototype.add = function (acInst, data, options, cb) {
 
   // Create an instance of the through model
   modelThrough.findOrCreate(filter, data, options, function(err, ac) {
-    if(!err) {
+    if (!err) {
       if (acInst instanceof definition.modelTo) {
         self.addToCache(acInst);
       }
@@ -1115,7 +1115,7 @@ HasManyThrough.prototype.add = function (acInst, data, options, cb) {
  * Check if the target model instance is related to the 'hasMany' relation
  * @param {Object|ID} acInst The actual instance or id value
  */
-HasManyThrough.prototype.exists = function (acInst, options, cb) {
+HasManyThrough.prototype.exists = function(acInst, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     cb = options;
     options = {};
@@ -1152,7 +1152,7 @@ HasManyThrough.prototype.exists = function (acInst, options, cb) {
  * Remove the target model instance from the 'hasMany' relation
  * @param {Object|ID) acInst The actual instance or id value
  */
-HasManyThrough.prototype.remove = function (acInst, options, cb) {
+HasManyThrough.prototype.remove = function(acInst, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     cb = options;
     options = {};
@@ -1180,7 +1180,7 @@ HasManyThrough.prototype.remove = function (acInst, options, cb) {
 
   cb = cb || utils.createPromiseCallback();
 
-  modelThrough.deleteAll(filter.where, options, function (err) {
+  modelThrough.deleteAll(filter.where, options, function(err) {
     if (!err) {
       self.removeFromCache(query[fk2]);
     }
@@ -1214,7 +1214,7 @@ HasManyThrough.prototype.remove = function (acInst, options, cb) {
  * @property {String} foreignKey Name of foreign key property.
  *
  */
-RelationDefinition.belongsTo = function (modelFrom, modelTo, params) {
+RelationDefinition.belongsTo = function(modelFrom, modelTo, params) {
   var discriminator, polymorphic;
   params = params || {};
   if ('string' === typeof modelTo && !params.polymorphic) {
@@ -1266,7 +1266,7 @@ RelationDefinition.belongsTo = function (modelFrom, modelTo, params) {
     scope: params.scope,
     options: params.options,
     polymorphic: polymorphic,
-    methods: params.methods
+    methods: params.methods,
   });
 
   // Define a property for the scope so that we have 'this' for the scoped methods
@@ -1286,7 +1286,7 @@ RelationDefinition.belongsTo = function (modelFrom, modelTo, params) {
       }
       bindRelationMethods(relation, relationMethod, definition);
       return relationMethod;
-    }
+    },
   });
 
   // FIXME: [rfeng] Wrap the property into a function for remoting
@@ -1321,7 +1321,7 @@ BelongsTo.prototype.create = function(targetModelData, options, cb) {
   this.definition.applyProperties(modelInstance, targetModelData || {});
 
   modelTo.create(targetModelData, options, function(err, targetModel) {
-    if(!err) {
+    if (!err) {
       modelInstance[fk] = targetModel[pk];
       if (modelInstance.isNewRecord()) {
         self.resetCache(targetModel);
@@ -1346,7 +1346,7 @@ BelongsTo.prototype.build = function(targetModelData) {
   return new modelTo(targetModelData);
 };
 
-BelongsTo.prototype.update = function (targetModelData, options, cb) {
+BelongsTo.prototype.update = function(targetModelData, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     cb = options;
     options = {};
@@ -1364,7 +1364,7 @@ BelongsTo.prototype.update = function (targetModelData, options, cb) {
   return cb.promise;
 };
 
-BelongsTo.prototype.destroy = function (options, cb) {
+BelongsTo.prototype.destroy = function(options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     cb = options;
     options = {};
@@ -1401,7 +1401,7 @@ BelongsTo.prototype.destroy = function (options, cb) {
  * @param params
  * @returns {*}
  */
-BelongsTo.prototype.related = function (condOrRefresh, options, cb) {
+BelongsTo.prototype.related = function(condOrRefresh, options, cb) {
   var self = this;
   var modelFrom = this.definition.modelFrom;
   var modelTo = this.definition.modelTo;
@@ -1464,7 +1464,7 @@ BelongsTo.prototype.related = function (condOrRefresh, options, cb) {
     }
 
     if (cachedValue === undefined || !(cachedValue instanceof ModelBaseClass)) {
-      var query = {where: {}};
+      var query = { where: {}};
       query.where[pk] = modelInstance[fk];
 
       if (query.where[pk] === undefined
@@ -1478,10 +1478,10 @@ BelongsTo.prototype.related = function (condOrRefresh, options, cb) {
       if (scopeQuery) mergeQuery(query, scopeQuery);
 
       if (Array.isArray(query.fields) && query.fields.indexOf(pk) === -1) {
-          query.fields.push(pk); // always include the pk
+        query.fields.push(pk); // always include the pk
       }
 
-      modelTo.findOne(query, options, function (err, inst) {
+      modelTo.findOne(query, options, function(err, inst) {
         if (err) {
           return cb(err);
         }
@@ -1522,7 +1522,7 @@ BelongsTo.prototype.related = function (condOrRefresh, options, cb) {
  * @param {Function} cb Callback of the form function (err, inst)
  * @returns {Promise | Undefined} returns promise if callback is omitted
  */
-BelongsTo.prototype.getAsync = function (options, cb) {
+BelongsTo.prototype.getAsync = function(options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     // order.customer.getAsync(cb)
     cb = options;
@@ -1531,7 +1531,7 @@ BelongsTo.prototype.getAsync = function (options, cb) {
   cb = cb || utils.createPromiseCallback();
   this.related(true, options, cb);
   return cb.promise;
-}
+};
 
 
 /**
@@ -1565,7 +1565,7 @@ RelationDefinition.hasAndBelongsToMany = function hasAndBelongsToMany(modelFrom,
       modelFrom.dataSource.define(name1);
   }
 
-  var options = {as: params.as, through: params.through};
+  var options = { as: params.as, through: params.through };
   options.properties = params.properties;
   options.scope = params.scope;
 
@@ -1601,7 +1601,7 @@ RelationDefinition.hasAndBelongsToMany = function hasAndBelongsToMany(modelFrom,
  * @property {String} foreignKey Property name of foreign key field.
  * @property {Object} model Model object
  */
-RelationDefinition.hasOne = function (modelFrom, modelTo, params) {
+RelationDefinition.hasOne = function(modelFrom, modelTo, params) {
   params = params || {};
   modelTo = lookupModelTo(modelFrom, modelTo, params);
 
@@ -1632,7 +1632,7 @@ RelationDefinition.hasOne = function (modelFrom, modelTo, params) {
     scope: params.scope,
     options: params.options,
     polymorphic: polymorphic,
-    methods: params.methods
+    methods: params.methods,
   });
 
   modelTo.dataSource.defineForeignKey(modelTo.modelName, fk, modelFrom.modelName, pk);
@@ -1643,7 +1643,7 @@ RelationDefinition.hasOne = function (modelFrom, modelTo, params) {
     configurable: true,
     get: function() {
       var relation = new HasOne(definition, this);
-      var relationMethod = relation.related.bind(relation)
+      var relationMethod = relation.related.bind(relation);
       relationMethod.getAsync = relation.getAsync.bind(relation);
       relationMethod.create = relation.create.bind(relation);
       relationMethod.build = relation.build.bind(relation);
@@ -1652,7 +1652,7 @@ RelationDefinition.hasOne = function (modelFrom, modelTo, params) {
       relationMethod._targetClass = definition.modelTo.modelName;
       bindRelationMethods(relation, relationMethod, definition);
       return relationMethod;
-    }
+    },
   });
 
   // FIXME: [rfeng] Wrap the property into a function for remoting
@@ -1688,7 +1688,7 @@ RelationDefinition.hasOne = function (modelFrom, modelTo, params) {
  * @param {String|Object} err Error string or object
  * @param {Object} The newly created target model instance
  */
-HasOne.prototype.create = function (targetModelData, options, cb) {
+HasOne.prototype.create = function(targetModelData, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     // customer.profile.create(options, cb)
     cb = options;
@@ -1708,7 +1708,7 @@ HasOne.prototype.create = function (targetModelData, options, cb) {
   cb = cb || utils.createPromiseCallback();
 
   targetModelData[fk] = modelInstance[pk];
-  var query = {where: {}};
+  var query = { where: {}};
   query.where[fk] = targetModelData[fk];
 
   this.definition.applyScope(modelInstance, query);
@@ -1752,7 +1752,7 @@ HasOne.prototype.update = function(targetModelData, options, cb) {
   return cb.promise;
 };
 
-HasOne.prototype.destroy = function (options, cb) {
+HasOne.prototype.destroy = function(options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     // customer.profile.destroy(cb)
     cb = options;
@@ -1778,7 +1778,7 @@ HasOne.prototype.destroy = function (options, cb) {
  * @param {String|Object} err Error string or object
  * @param {Object} The newly created target model instance
  */
-HasMany.prototype.create = function (targetModelData, options, cb) {
+HasMany.prototype.create = function(targetModelData, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     // customer.orders.create(data, cb)
     cb = options;
@@ -1813,7 +1813,7 @@ HasMany.prototype.create = function (targetModelData, options, cb) {
   apply(targetModelData, fkAndProps);
 
   modelTo.create(targetModelData, options, function(err, targetModel) {
-    if(!err) {
+    if (!err) {
       //Refresh the cache
       apply(targetModel, self.addToCache.bind(self));
       cb && cb(err, targetModel);
@@ -1852,7 +1852,7 @@ HasMany.prototype.build = HasOne.prototype.build = function(targetModelData) {
  * @param {Object|Function} params Query parameters
  * @returns {Object}
  */
-HasOne.prototype.related = function (condOrRefresh, options, cb) {
+HasOne.prototype.related = function(condOrRefresh, options, cb) {
   var self = this;
   var modelTo = this.definition.modelTo;
   var fk = this.definition.keyTo;
@@ -1886,10 +1886,10 @@ HasOne.prototype.related = function (condOrRefresh, options, cb) {
     self.resetCache(newValue);
   } else if (typeof cb === 'function') { // acts as async getter
     if (cachedValue === undefined) {
-      var query = {where: {}};
+      var query = { where: {}};
       query.where[fk] = modelInstance[pk];
       definition.applyScope(modelInstance, query);
-      modelTo.findOne(query, options, function (err, inst) {
+      modelTo.findOne(query, options, function(err, inst) {
         if (err) {
           return cb(err);
         }
@@ -1930,7 +1930,7 @@ HasOne.prototype.related = function (condOrRefresh, options, cb) {
  * @returns {Promise | Undefined} Returns promise if cb is omitted
  */
 
-HasOne.prototype.getAsync = function (options, cb) {
+HasOne.prototype.getAsync = function(options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     // order.profile.getAsync(cb)
     cb = options;
@@ -1941,7 +1941,7 @@ HasOne.prototype.getAsync = function (options, cb) {
   return cb.promise;
 };
 
-RelationDefinition.embedsOne = function (modelFrom, modelTo, params) {
+RelationDefinition.embedsOne = function(modelFrom, modelTo, params) {
   params = params || {};
   modelTo = lookupModelTo(modelFrom, modelTo, params);
 
@@ -1968,7 +1968,7 @@ RelationDefinition.embedsOne = function (modelFrom, modelTo, params) {
     scope: params.scope,
     options: params.options,
     embed: true,
-    methods: params.methods
+    methods: params.methods,
   });
 
   var opts = { type: modelTo };
@@ -2015,7 +2015,7 @@ RelationDefinition.embedsOne = function (modelFrom, modelTo, params) {
       relationMethod._targetClass = definition.modelTo.modelName;
       bindRelationMethods(relation, relationMethod, definition);
       return relationMethod;
-    }
+    },
   });
 
   // FIXME: [rfeng] Wrap the property into a function for remoting
@@ -2044,7 +2044,7 @@ RelationDefinition.embedsOne = function (modelFrom, modelTo, params) {
   return definition;
 };
 
-EmbedsOne.prototype.related = function (condOrRefresh, options, cb) {
+EmbedsOne.prototype.related = function(condOrRefresh, options, cb) {
   var modelTo = this.definition.modelTo;
   var modelInstance = this.modelInstance;
   var propertyName = this.definition.keyFrom;
@@ -2094,7 +2094,7 @@ EmbedsOne.prototype.embeddedValue = function(modelInstance) {
   return modelInstance[this.definition.keyFrom];
 };
 
-EmbedsOne.prototype.create = function (targetModelData, options, cb) {
+EmbedsOne.prototype.create = function(targetModelData, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     // order.customer.create(data, cb)
     cb = options;
@@ -2118,13 +2118,13 @@ EmbedsOne.prototype.create = function (targetModelData, options, cb) {
     if (modelInstance.isNewRecord()) {
       modelInstance.setAttribute(propertyName, inst);
       modelInstance.save(options, function(err) {
-          cb(err, err ? null : inst);
+        cb(err, err ? null : inst);
       });
     } else {
       modelInstance.updateAttribute(propertyName,
         inst, options, function(err) {
-        cb(err, err ? null : inst);
-      });
+          cb(err, err ? null : inst);
+        });
     }
   };
 
@@ -2146,7 +2146,7 @@ EmbedsOne.prototype.create = function (targetModelData, options, cb) {
   return cb.promise;
 };
 
-EmbedsOne.prototype.build = function (targetModelData) {
+EmbedsOne.prototype.build = function(targetModelData) {
   var modelTo = this.definition.modelTo;
   var modelInstance = this.modelInstance;
   var propertyName = this.definition.keyFrom;
@@ -2165,8 +2165,8 @@ EmbedsOne.prototype.build = function (targetModelData) {
   assignId = assignId && !persistent && (pkProp && pkProp.generated);
 
   if (assignId && typeof connector.generateId === 'function') {
-      var id = connector.generateId(modelTo.modelName, targetModelData, pk);
-      targetModelData[pk] = id;
+    var id = connector.generateId(modelTo.modelName, targetModelData, pk);
+    targetModelData[pk] = id;
   }
 
   var embeddedInstance = new modelTo(targetModelData);
@@ -2175,7 +2175,7 @@ EmbedsOne.prototype.build = function (targetModelData) {
   return embeddedInstance;
 };
 
-EmbedsOne.prototype.update = function (targetModelData, options, cb) {
+EmbedsOne.prototype.update = function(targetModelData, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     // order.customer.update(data, cb)
     cb = options;
@@ -2205,7 +2205,7 @@ EmbedsOne.prototype.update = function (targetModelData, options, cb) {
   return cb.promise;
 };
 
-EmbedsOne.prototype.destroy = function (options, cb) {
+EmbedsOne.prototype.destroy = function(options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     // order.customer.destroy(cb)
     cb = options;
@@ -2215,7 +2215,7 @@ EmbedsOne.prototype.destroy = function (options, cb) {
   var propertyName = this.definition.keyFrom;
   modelInstance.unsetAttribute(propertyName, true);
   cb = cb || utils.createPromiseCallback();
-  modelInstance.save(function (err, result) {
+  modelInstance.save(function(err, result) {
     cb && cb(err, result);
   });
   return cb.promise;
@@ -2247,11 +2247,11 @@ RelationDefinition.embedsMany = function embedsMany(modelFrom, modelTo, params)
     properties: params.properties,
     scope: params.scope,
     options: params.options,
-    embed: true
+    embed: true,
   });
 
   modelFrom.dataSource.defineProperty(modelFrom.modelName, propertyName, {
-    type: [modelTo], default: function() { return []; }
+    type: [modelTo], default: function() { return []; },
   });
 
   if (typeof modelTo.dataSource.connector.generateId !== 'function') {
@@ -2276,13 +2276,13 @@ RelationDefinition.embedsMany = function embedsMany(modelFrom, modelTo, params)
       var embeddedList = this[propertyName] || [];
       var ids = embeddedList.map(function(m) { return m[idName] && m[idName].toString(); }); // mongodb
       var uniqueIds = ids.filter(function(id, pos) {
-          return utils.findIndexOf(ids, id, idEquals) === pos;
+        return utils.findIndexOf(ids, id, idEquals) === pos;
       });
       if (ids.length !== uniqueIds.length) {
         this.errors.add(propertyName, 'contains duplicate `' + idName + '`', 'uniqueness');
         err(false);
       }
-    }, { code: 'uniqueness' })
+    }, { code: 'uniqueness' });
   }
 
   // validate all embedded items
@@ -2325,7 +2325,7 @@ RelationDefinition.embedsMany = function embedsMany(modelFrom, modelTo, params)
     set: scopeMethod(definition, 'set'),
     unset: scopeMethod(definition, 'unset'),
     at: scopeMethod(definition, 'at'),
-    value: scopeMethod(definition, 'embeddedValue')
+    value: scopeMethod(definition, 'embeddedValue'),
   };
 
   var findByIdFunc = scopeMethods.findById;
@@ -2363,7 +2363,7 @@ RelationDefinition.embedsMany = function embedsMany(modelFrom, modelTo, params)
   };
 
   // Mix the property and scoped methods into the prototype class
-  var scopeDefinition = defineScope(modelFrom.prototype, modelTo, relationName, function () {
+  var scopeDefinition = defineScope(modelFrom.prototype, modelTo, relationName, function() {
     return {};
   }, scopeMethods, definition.options);
 
@@ -2378,10 +2378,10 @@ EmbedsMany.prototype.prepareEmbeddedInstance = function(inst) {
     var propertyName = this.definition.keyFrom;
     var modelInstance = this.modelInstance;
     if (this.definition.options.persistent) {
-        var pk = this.definition.keyTo;
-        inst.__persisted = !!inst[pk];
+      var pk = this.definition.keyTo;
+      inst.__persisted = !!inst[pk];
     } else {
-        inst.__persisted = true;
+      inst.__persisted = true;
     }
     inst.triggerParent = function(actionName, callback) {
       if (actionName === 'save' || actionName === 'destroy') {
@@ -2392,8 +2392,8 @@ EmbedsMany.prototype.prepareEmbeddedInstance = function(inst) {
         }
         modelInstance.updateAttribute(propertyName,
           embeddedList, function(err, modelInst) {
-          callback(err, err ? null : modelInst);
-        });
+            callback(err, err ? null : modelInst);
+          });
       } else {
         process.nextTick(callback);
       }
@@ -2417,11 +2417,11 @@ EmbedsMany.prototype.prepareEmbeddedInstance = function(inst) {
 
 EmbedsMany.prototype.embeddedList =
   EmbedsMany.prototype.embeddedValue = function(modelInstance) {
-  modelInstance = modelInstance || this.modelInstance;
-  var embeddedList = modelInstance[this.definition.keyFrom] || [];
-  embeddedList.forEach(this.prepareEmbeddedInstance.bind(this));
-  return embeddedList;
-};
+    modelInstance = modelInstance || this.modelInstance;
+    var embeddedList = modelInstance[this.definition.keyFrom] || [];
+    embeddedList.forEach(this.prepareEmbeddedInstance.bind(this));
+    return embeddedList;
+  };
 
 EmbedsMany.prototype.related = function(receiver, scopeParams, condOrRefresh, options, cb) {
   var modelTo = this.definition.modelTo;
@@ -2466,7 +2466,7 @@ EmbedsMany.prototype.related = function(receiver, scopeParams, condOrRefresh, op
   returnRelated(embeddedList);
 };
 
-EmbedsMany.prototype.findById = function (fkId, options, cb) {
+EmbedsMany.prototype.findById = function(fkId, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     // order.emails(fkId, cb)
     cb = options;
@@ -2481,7 +2481,7 @@ EmbedsMany.prototype.findById = function (fkId, options, cb) {
   var find = function(id) {
     for (var i = 0; i < embeddedList.length; i++) {
       var item = embeddedList[i];
-      if (idEquals(item[pk],id)) return item;
+      if (idEquals(item[pk], id)) return item;
     }
     return null;
   };
@@ -2498,20 +2498,20 @@ EmbedsMany.prototype.findById = function (fkId, options, cb) {
   return item; // sync
 };
 
-EmbedsMany.prototype.exists = function (fkId, options, cb) {
+EmbedsMany.prototype.exists = function(fkId, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     // customer.emails.exists(fkId, cb)
     cb = options;
     options = {};
   }
   var modelTo = this.definition.modelTo;
-  var inst = this.findById(fkId, options, function (err, inst) {
+  var inst = this.findById(fkId, options, function(err, inst) {
     if (cb) cb(err, inst instanceof modelTo);
   });
   return inst instanceof modelTo; // sync
 };
 
-EmbedsMany.prototype.updateById = function (fkId, data, options, cb) {
+EmbedsMany.prototype.updateById = function(fkId, data, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     // customer.emails.updateById(fkId, data, cb)
     cb = options;
@@ -2533,7 +2533,7 @@ EmbedsMany.prototype.updateById = function (fkId, data, options, cb) {
 
   if (inst instanceof modelTo) {
     if (typeof data === 'object') {
-        inst.setAttributes(data);
+      inst.setAttributes(data);
     }
     var err = inst.isValid() ? null : new ValidationError(inst);
     if (err && typeof cb === 'function') {
@@ -2545,8 +2545,8 @@ EmbedsMany.prototype.updateById = function (fkId, data, options, cb) {
     if (typeof cb === 'function') {
       modelInstance.updateAttribute(propertyName,
         embeddedList, options, function(err) {
-        cb(err, inst);
-      });
+          cb(err, inst);
+        });
     }
   } else if (typeof cb === 'function') {
     process.nextTick(function() {
@@ -2556,7 +2556,7 @@ EmbedsMany.prototype.updateById = function (fkId, data, options, cb) {
   return inst; // sync
 };
 
-EmbedsMany.prototype.destroyById = function (fkId, options, cb) {
+EmbedsMany.prototype.destroyById = function(fkId, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     // customer.emails.destroyById(fkId, cb)
     cb = options;
@@ -2576,9 +2576,9 @@ EmbedsMany.prototype.destroyById = function (fkId, options, cb) {
     if (typeof cb === 'function') {
       modelInstance.updateAttribute(propertyName,
         embeddedList, function(err) {
-        cb(err);
-        modelTo.emit('deleted', inst.id, inst.toJSON());
-      });
+          cb(err);
+          modelTo.emit('deleted', inst.id, inst.toJSON());
+        });
     }
   } else if (typeof cb === 'function') {
     process.nextTick(cb); // not found
@@ -2604,7 +2604,7 @@ EmbedsMany.prototype.destroyAll = function(where, options, cb) {
 
   if (where && Object.keys(where).length > 0) {
     var filter = applyFilter({ where: where });
-    var reject = function(v) { return !filter(v) };
+    var reject = function(v) { return !filter(v); };
     embeddedList = embeddedList ? embeddedList.filter(reject) : embeddedList;
   } else {
     embeddedList = [];
@@ -2613,8 +2613,8 @@ EmbedsMany.prototype.destroyAll = function(where, options, cb) {
   if (typeof cb === 'function') {
     modelInstance.updateAttribute(propertyName,
       embeddedList, function(err) {
-      cb(err);
-    });
+        cb(err);
+      });
   } else {
     modelInstance.setAttribute(propertyName, embeddedList);
   }
@@ -2624,7 +2624,7 @@ EmbedsMany.prototype.get = EmbedsMany.prototype.findById;
 EmbedsMany.prototype.set = EmbedsMany.prototype.updateById;
 EmbedsMany.prototype.unset = EmbedsMany.prototype.destroyById;
 
-EmbedsMany.prototype.at = function (index, cb) {
+EmbedsMany.prototype.at = function(index, cb) {
   var modelTo = this.definition.modelTo;
   var modelInstance = this.modelInstance;
 
@@ -2642,7 +2642,7 @@ EmbedsMany.prototype.at = function (index, cb) {
   return item; // sync
 };
 
-EmbedsMany.prototype.create = function (targetModelData, options, cb) {
+EmbedsMany.prototype.create = function(targetModelData, options, cb) {
   var pk = this.definition.keyTo;
   var modelTo = this.definition.modelTo;
   var propertyName = this.definition.keyFrom;
@@ -2669,13 +2669,13 @@ EmbedsMany.prototype.create = function (targetModelData, options, cb) {
     if (modelInstance.isNewRecord()) {
       modelInstance.setAttribute(propertyName, embeddedList);
       modelInstance.save(options, function(err) {
-          cb(err, err ? null : inst);
+        cb(err, err ? null : inst);
       });
     } else {
       modelInstance.updateAttribute(propertyName,
         embeddedList, options, function(err) {
-        cb(err, err ? null : inst);
-      });
+          cb(err, err ? null : inst);
+        });
     }
   };
 
@@ -2725,8 +2725,8 @@ EmbedsMany.prototype.build = function(targetModelData) {
       targetModelData[pk] = 1;
     }
   } else if (assignId && typeof connector.generateId === 'function') {
-      var id = connector.generateId(modelTo.modelName, targetModelData, pk);
-      targetModelData[pk] = id;
+    var id = connector.generateId(modelTo.modelName, targetModelData, pk);
+    targetModelData[pk] = id;
   }
 
   this.definition.applyProperties(modelInstance, targetModelData);
@@ -2748,7 +2748,7 @@ EmbedsMany.prototype.build = function(targetModelData) {
  * Add the target model instance to the 'embedsMany' relation
  * @param {Object|ID} acInst The actual instance or id value
  */
-EmbedsMany.prototype.add = function (acInst, data, options, cb) {
+EmbedsMany.prototype.add = function(acInst, data, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     // customer.emails.add(acInst, data, cb)
     cb = options;
@@ -2802,7 +2802,7 @@ EmbedsMany.prototype.add = function (acInst, data, options, cb) {
  * Remove the target model instance from the 'embedsMany' relation
  * @param {Object|ID) acInst The actual instance or id value
  */
-EmbedsMany.prototype.remove = function (acInst, options, cb) {
+EmbedsMany.prototype.remove = function(acInst, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     // customer.emails.remove(acInst, cb)
     cb = options;
@@ -2867,24 +2867,24 @@ RelationDefinition.referencesMany = function referencesMany(modelFrom, modelTo,
     multiple: true,
     properties: params.properties,
     scope: params.scope,
-    options: params.options
+    options: params.options,
   });
 
   modelFrom.dataSource.defineProperty(modelFrom.modelName, fk, {
-    type: [idType], default: function() { return []; }
+    type: [idType], default: function() { return []; },
   });
 
   modelFrom.validate(relationName, function(err) {
     var ids = this[fk] || [];
     var uniqueIds = ids.filter(function(id, pos) {
-        return utils.findIndexOf(ids, id, idEquals) === pos;
+      return utils.findIndexOf(ids, id, idEquals) === pos;
     });
     if (ids.length !== uniqueIds.length) {
       var msg = 'contains duplicate `' + modelTo.modelName + '` instance';
       this.errors.add(relationName, msg, 'uniqueness');
       err(false);
     }
-  }, { code: 'uniqueness' })
+  }, { code: 'uniqueness' });
 
   var scopeMethods = {
     findById: scopeMethod(definition, 'findById'),
@@ -2893,7 +2893,7 @@ RelationDefinition.referencesMany = function referencesMany(modelFrom, modelTo,
     exists: scopeMethod(definition, 'exists'),
     add: scopeMethod(definition, 'add'),
     remove: scopeMethod(definition, 'remove'),
-    at: scopeMethod(definition, 'at')
+    at: scopeMethod(definition, 'at'),
   };
 
   var findByIdFunc = scopeMethods.findById;
@@ -2927,7 +2927,7 @@ RelationDefinition.referencesMany = function referencesMany(modelFrom, modelTo,
   };
 
   // Mix the property and scoped methods into the prototype class
-  var scopeDefinition = defineScope(modelFrom.prototype, modelTo, relationName, function () {
+  var scopeDefinition = defineScope(modelFrom.prototype, modelTo, relationName, function() {
     return {};
   }, scopeMethods, definition.options);
 
@@ -2972,7 +2972,7 @@ ReferencesMany.prototype.related = function(receiver, scopeParams, condOrRefresh
   return modelTo.findByIds(ids, params, options, cb);
 };
 
-ReferencesMany.prototype.findById = function (fkId, options, cb) {
+ReferencesMany.prototype.findById = function(fkId, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     // customer.orders.findById(fkId, cb)
     cb = options;
@@ -2998,7 +2998,7 @@ ReferencesMany.prototype.findById = function (fkId, options, cb) {
 
   cb = cb || utils.createPromiseCallback();
 
-  modelTo.findByIds([fkId], filter, options, function (err, instances) {
+  modelTo.findByIds([fkId], filter, options, function(err, instances) {
     if (err) {
       return cb(err);
     }
@@ -3024,7 +3024,7 @@ ReferencesMany.prototype.findById = function (fkId, options, cb) {
   return cb.promise;
 };
 
-ReferencesMany.prototype.exists = function (fkId, options, cb) {
+ReferencesMany.prototype.exists = function(fkId, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     // customer.orders.exists(fkId, cb)
     cb = options;
@@ -3034,11 +3034,11 @@ ReferencesMany.prototype.exists = function (fkId, options, cb) {
   var ids = this.modelInstance[fk] || [];
 
   cb = cb || utils.createPromiseCallback();
-  process.nextTick(function() { cb(null, utils.findIndexOf(ids, fkId, idEquals) > -1) });
+  process.nextTick(function() { cb(null, utils.findIndexOf(ids, fkId, idEquals) > -1); });
   return cb.promise;
 };
 
-ReferencesMany.prototype.updateById = function (fkId, data, options, cb) {
+ReferencesMany.prototype.updateById = function(fkId, data, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     // customer.orders.updateById(fkId, data, cb)
     cb = options;
@@ -3058,7 +3058,7 @@ ReferencesMany.prototype.updateById = function (fkId, data, options, cb) {
   return cb.promise;
 };
 
-ReferencesMany.prototype.destroyById = function (fkId, options, cb) {
+ReferencesMany.prototype.destroyById = function(fkId, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     // customer.orders.destroyById(fkId, cb)
     cb = options;
@@ -3075,7 +3075,7 @@ ReferencesMany.prototype.destroyById = function (fkId, options, cb) {
   return cb.promise;
 };
 
-ReferencesMany.prototype.at = function (index, options, cb) {
+ReferencesMany.prototype.at = function(index, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     // customer.orders.at(index, cb)
     cb = options;
@@ -3088,7 +3088,7 @@ ReferencesMany.prototype.at = function (index, options, cb) {
   return cb.promise;
 };
 
-ReferencesMany.prototype.create = function (targetModelData, options, cb) {
+ReferencesMany.prototype.create = function(targetModelData, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     // customer.orders.create(data, cb)
     cb = options;
@@ -3130,8 +3130,8 @@ ReferencesMany.prototype.create = function (targetModelData, options, cb) {
 
     modelInstance.updateAttribute(fk,
       ids, options, function(err, modelInst) {
-      cb(err, inst);
-    });
+        cb(err, inst);
+      });
   });
   return cb.promise;
 };
@@ -3149,7 +3149,7 @@ ReferencesMany.prototype.build = function(targetModelData) {
  * Add the target model instance to the 'embedsMany' relation
  * @param {Object|ID} acInst The actual instance or id value
  */
-ReferencesMany.prototype.add = function (acInst, options, cb) {
+ReferencesMany.prototype.add = function(acInst, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     // customer.orders.add(acInst, cb)
     cb = options;
@@ -3188,12 +3188,12 @@ ReferencesMany.prototype.add = function (acInst, options, cb) {
   if (acInst instanceof modelTo) {
     insert(acInst, cb);
   } else {
-    var filter = { where: {} };
+    var filter = { where: {}};
     filter.where[pk] = acInst;
 
     definition.applyScope(modelInstance, filter);
 
-    modelTo.findOne(filter, options, function (err, inst) {
+    modelTo.findOne(filter, options, function(err, inst) {
       if (err || !inst) return cb(err, null);
       insert(inst, cb);
     });
@@ -3205,7 +3205,7 @@ ReferencesMany.prototype.add = function (acInst, options, cb) {
  * Remove the target model instance from the 'embedsMany' relation
  * @param {Object|ID) acInst The actual instance or id value
  */
-ReferencesMany.prototype.remove = function (acInst, options, cb) {
+ReferencesMany.prototype.remove = function(acInst, options, cb) {
   if (typeof options === 'function' && cb === undefined) {
     // customer.orders.remove(acInst, cb)
     cb = options;
diff --git a/lib/relations.js b/lib/relations.js
index 5dd9994d..b4a2c8b5 100644
--- a/lib/relations.js
+++ b/lib/relations.js
@@ -21,12 +21,12 @@ function RelationMixin() {
 
 /**
  * Define a "one to many" relationship by specifying the model name
- * 
+ *
  * Examples:
  * ```
  * User.hasMany(Post, {as: 'posts', foreignKey: 'authorId'});
  * ```
- * 
+ *
  * ```
  * Book.hasMany(Chapter);
  * ```
@@ -39,24 +39,24 @@ function RelationMixin() {
  *
  * ```js
  * Book.create(function(err, book) {
- * 
+ *
  *   // Create a chapter instance ready to be saved in the data source.
  *   var chapter = book.chapters.build({name: 'Chapter 1'});
- * 
+ *
  *   // Save the new chapter
  *   chapter.save();
- * 
+ *
  *  // you can also call the Chapter.create method with the `chapters` property which will build a chapter
  *  // instance and save the it in the data source.
  *  book.chapters.create({name: 'Chapter 2'}, function(err, savedChapter) {
  *  // this callback is optional
  *  });
- * 
- *   // Query chapters for the book  
- *   book.chapters(function(err, chapters) {  // all chapters with bookId = book.id 
+ *
+ *   // Query chapters for the book
+ *   book.chapters(function(err, chapters) {  // all chapters with bookId = book.id
  *     console.log(chapters);
  *   });
- * 
+ *
  *   book.chapters({where: {name: 'test'}, function(err, chapters) {
  *    // All chapters with bookId = book.id and name = 'test'
  *     console.log(chapters);
@@ -94,10 +94,10 @@ RelationMixin.hasMany = function hasMany(modelTo, params) {
  * ```
  * Set the author to be the given user:
  * ```
- * post.author(user) 
+ * post.author(user)
  * ```
  * Examples:
- * 
+ *
  * Suppose the model Post has a *belongsTo* relationship with User (the author of the post). You could declare it this way:
  * ```js
  * Post.belongsTo(User, {as: 'author', foreignKey: 'userId'});
@@ -123,9 +123,9 @@ RelationMixin.hasMany = function hasMany(modelTo, params) {
  * @options {Object} params Configuration parameters; see below.
  * @property {String} as Name of the property in the referring model that corresponds to the foreign key field in the related model.
  * @property {String} foreignKey Name of foreign key property.
- * 
+ *
  */
-RelationMixin.belongsTo = function (modelTo, params) {
+RelationMixin.belongsTo = function(modelTo, params) {
   return RelationDefinition.belongsTo(this, modelTo, params);
 };
 
@@ -150,9 +150,9 @@ RelationMixin.belongsTo = function (modelTo, params) {
  * ```
  *  Remove the user from the group:
  * ```
- *  user.groups.remove(group, callback); 
+ *  user.groups.remove(group, callback);
  * ```
- * 
+ *
  * @param {String|Object} modelTo Model object (or String name of model) to which you are creating the relationship.
  * the relation
  * @options {Object} params Configuration parameters; see below.
diff --git a/lib/scope.js b/lib/scope.js
index fb361735..59941da0 100644
--- a/lib/scope.js
+++ b/lib/scope.js
@@ -83,9 +83,9 @@ ScopeDefinition.prototype.related = function(receiver, scopeParams, condOrRefres
   if (!self.__cachedRelations || self.__cachedRelations[name] === undefined
     || actualRefresh) {
     // It either doesn't hit the cache or refresh is required
-    var params = mergeQuery(actualCond, scopeParams, {nestedInclude: true});
+    var params = mergeQuery(actualCond, scopeParams, { nestedInclude: true });
     var targetModel = this.targetModel(receiver);
-    targetModel.find(params, options, function (err, data) {
+    targetModel.find(params, options, function(err, data) {
       if (!err && saveOnCache) {
         defineCachedRelations(self);
         self.__cachedRelations[name] = data;
@@ -97,7 +97,7 @@ ScopeDefinition.prototype.related = function(receiver, scopeParams, condOrRefres
     cb(null, self.__cachedRelations[name]);
   }
   return cb.promise;
-}
+};
 
 /**
  * Define a scope method
@@ -106,7 +106,7 @@ ScopeDefinition.prototype.related = function(receiver, scopeParams, condOrRefres
  */
 ScopeDefinition.prototype.defineMethod = function(name, fn) {
   return this.methods[name] = fn;
-}
+};
 
 /**
  * Define a scope to the class
@@ -143,10 +143,10 @@ function defineScope(cls, targetClass, name, params, methods, options) {
     name: name,
     params: params,
     methods: methods,
-    options: options
+    options: options,
   });
 
-  if(isStatic) {
+  if (isStatic) {
     cls.scopes = cls.scopes || {};
     cls.scopes[name] = definition;
   } else {
@@ -169,7 +169,7 @@ function defineScope(cls, targetClass, name, params, methods, options) {
      * user.accounts.create(act, cb).
      *
      */
-    get: function () {
+    get: function() {
       var targetModel = definition.targetModel(this);
       var self = this;
 
@@ -192,23 +192,23 @@ function defineScope(cls, targetClass, name, params, methods, options) {
             cb = options;
             options = {};
           }
-          options = options || {}
+          options = options || {};
           // Check if there is a through model
           // see https://github.com/strongloop/loopback/issues/1076
           if (f._scope.collect &&
             condOrRefresh !== null && typeof condOrRefresh === 'object') {
             //extract the paging filters to the through model
-            ['limit','offset','skip','order'].forEach(function(pagerFilter){
-                if(typeof(condOrRefresh[pagerFilter]) !== 'undefined'){
-                    f._scope[pagerFilter] = condOrRefresh[pagerFilter];
-                    delete condOrRefresh[pagerFilter];
-                }
+            ['limit', 'offset', 'skip', 'order'].forEach(function(pagerFilter) {
+              if (typeof(condOrRefresh[pagerFilter]) !== 'undefined') {
+                f._scope[pagerFilter] = condOrRefresh[pagerFilter];
+                delete condOrRefresh[pagerFilter];
+              }
             });
             // Adjust the include so that the condition will be applied to
             // the target model
             f._scope.include = {
               relation: f._scope.collect,
-              scope: condOrRefresh
+              scope: condOrRefresh,
             };
             condOrRefresh = {};
           }
@@ -237,9 +237,9 @@ function defineScope(cls, targetClass, name, params, methods, options) {
           cb = options;
           options = {};
         }
-        options = options || {}
+        options = options || {};
         return definition.related(self, f._scope, condOrRefresh, options, cb);
-      }
+      };
 
       f.build = build;
       f.create = create;
@@ -259,21 +259,21 @@ function defineScope(cls, targetClass, name, params, methods, options) {
       // Station.scope('active', {where: {isActive: true}});
       // Station.scope('subway', {where: {isUndeground: true}});
       // Station.active.subway(cb);
-      Object.keys(targetClass._scopeMeta).forEach(function (name) {
+      Object.keys(targetClass._scopeMeta).forEach(function(name) {
         Object.defineProperty(f, name, {
           enumerable: false,
-          get: function () {
+          get: function() {
             mergeQuery(f._scope, targetModel._scopeMeta[name]);
             return f;
-          }
+          },
         });
       }.bind(self));
       return f;
-    }
+    },
   });
 
   // Wrap the property into a function for remoting
-  var fn = function () {
+  var fn = function() {
     // primaryObject.scopeName, such as user.accounts
     var f = this[name];
     // set receiver to be the scope property whose value is a function
@@ -282,42 +282,42 @@ function defineScope(cls, targetClass, name, params, methods, options) {
 
   cls['__get__' + name] = fn;
 
-  var fn_create = function () {
+  var fn_create = function() {
     var f = this[name].create;
     f.apply(this[name], arguments);
   };
 
   cls['__create__' + name] = fn_create;
 
-  var fn_delete = function () {
+  var fn_delete = function() {
     var f = this[name].destroyAll;
     f.apply(this[name], arguments);
   };
 
   cls['__delete__' + name] = fn_delete;
 
-  var fn_update = function () {
+  var fn_update = function() {
     var f = this[name].updateAll;
     f.apply(this[name], arguments);
   };
 
   cls['__update__' + name] = fn_update;
 
-  var fn_findById = function (cb) {
+  var fn_findById = function(cb) {
     var f = this[name].findById;
     f.apply(this[name], arguments);
   };
 
   cls['__findById__' + name] = fn_findById;
 
-  var fn_findOne = function (cb) {
+  var fn_findOne = function(cb) {
     var f = this[name].findOne;
     f.apply(this[name], arguments);
   };
 
   cls['__findOne__' + name] = fn_findOne;
 
-  var fn_count = function (cb) {
+  var fn_count = function(cb) {
     var f = this[name].count;
     f.apply(this[name], arguments);
   };
@@ -369,7 +369,7 @@ function defineScope(cls, targetClass, name, params, methods, options) {
 
     var targetModel = definition.targetModel(this._receiver);
     var scoped = (this._scope && this._scope.where) || {};
-    var filter = mergeQuery({ where: scoped }, { where: where || {} });
+    var filter = mergeQuery({ where: scoped }, { where: where || {}});
     return targetModel.destroyAll(filter.where, options, cb);
   }
 
@@ -389,7 +389,7 @@ function defineScope(cls, targetClass, name, params, methods, options) {
     options = options || {};
     var targetModel = definition.targetModel(this._receiver);
     var scoped = (this._scope && this._scope.where) || {};
-    var filter = mergeQuery({ where: scoped }, { where: where || {} });
+    var filter = mergeQuery({ where: scoped }, { where: where || {}});
     return targetModel.updateAll(filter.where, data, options, cb);
   }
 
@@ -412,12 +412,12 @@ function defineScope(cls, targetClass, name, params, methods, options) {
         }
       }
     }
-    
+
     options = options || {};
     filter = filter || {};
     var targetModel = definition.targetModel(this._receiver);
     var idName = targetModel.definition.idName();
-    var query = {where: {}};
+    var query = { where: {}};
     query.where[idName] = id;
     query = mergeQuery(query, filter);
     return this.findOne(query, options, cb);
@@ -455,7 +455,7 @@ function defineScope(cls, targetClass, name, params, methods, options) {
 
     var targetModel = definition.targetModel(this._receiver);
     var scoped = (this._scope && this._scope.where) || {};
-    var filter = mergeQuery({ where: scoped }, { where: where || {} });
+    var filter = mergeQuery({ where: scoped }, { where: where || {}});
     return targetModel.count(filter.where, options, cb);
   }
 
diff --git a/lib/transaction.js b/lib/transaction.js
index 5c1d3623..8edb4845 100644
--- a/lib/transaction.js
+++ b/lib/transaction.js
@@ -78,7 +78,7 @@ TransactionMixin.beginTransaction = function(options, cb) {
         setTimeout(function() {
           var context = {
             transaction: transaction,
-            operation: 'timeout'
+            operation: 'timeout',
           };
           transaction.notifyObserversOf('timeout', context, function(err) {
             if (!err) {
@@ -121,7 +121,7 @@ if (Transaction) {
     }
     var context = {
       transaction: self,
-      operation: 'commit'
+      operation: 'commit',
     };
 
     function work(done) {
@@ -155,7 +155,7 @@ if (Transaction) {
     }
     var context = {
       transaction: self,
-      operation: 'rollback'
+      operation: 'rollback',
     };
 
     function work(done) {
diff --git a/lib/types.js b/lib/types.js
index 286d04c0..f892ae24 100644
--- a/lib/types.js
+++ b/lib/types.js
@@ -14,7 +14,7 @@ Types.Text = function Text(value) {
   this.value = value;
 }; // Text type
 
-Types.Text.prototype.toObject = Types.Text.prototype.toJSON = function () {
+Types.Text.prototype.toObject = Types.Text.prototype.toJSON = function() {
   return this.value;
 };
 
@@ -24,7 +24,7 @@ Types.JSON = function JSON(value) {
   }
   this.value = value;
 }; // JSON Object
-Types.JSON.prototype.toObject = Types.JSON.prototype.toJSON = function () {
+Types.JSON.prototype.toObject = Types.JSON.prototype.toJSON = function() {
   return this.value;
 };
 
@@ -34,20 +34,20 @@ Types.Any = function Any(value) {
   }
   this.value = value;
 }; // Any Type
-Types.Any.prototype.toObject = Types.Any.prototype.toJSON = function () {
+Types.Any.prototype.toObject = Types.Any.prototype.toJSON = function() {
   return this.value;
 };
 
-module.exports = function (modelTypes) {
+module.exports = function(modelTypes) {
 
   var GeoPoint = require('./geo').GeoPoint;
 
-  for(var t in Types) {
+  for (var t in Types) {
     modelTypes[t] = Types[t];
   }
 
   modelTypes.schemaTypes = {};
-  modelTypes.registerType = function (type, names) {
+  modelTypes.registerType = function(type, names) {
     names = names || [];
     names = names.concat([type.name]);
     for (var n = 0; n < names.length; n++) {
@@ -69,4 +69,4 @@ module.exports = function (modelTypes) {
   modelTypes.registerType(Object);
 };
 
-module.exports.Types = Types;
\ No newline at end of file
+module.exports.Types = Types;
diff --git a/lib/utils.js b/lib/utils.js
index 4107bde8..f2edd3e5 100644
--- a/lib/utils.js
+++ b/lib/utils.js
@@ -135,9 +135,9 @@ function convertToArray(include) {
       if (typeof includeEntry === 'string') {
         var obj = {};
         obj[includeEntry] = true;
-        normalized.push(obj)
+        normalized.push(obj);
       }
-      else{
+      else {
         normalized.push(includeEntry);
       }
     }
@@ -163,7 +163,7 @@ function mergeQuery(base, update, spec) {
 
   if (update.where && Object.keys(update.where).length > 0) {
     if (base.where && Object.keys(base.where).length > 0) {
-      base.where = {and: [base.where, update.where]};
+      base.where = { and: [base.where, update.where] };
     } else {
       base.where = update.where;
     }
@@ -174,7 +174,7 @@ function mergeQuery(base, update, spec) {
     if (!base.include) {
       base.include = update.include;
     } else {
-      if (spec.nestedInclude === true){
+      if (spec.nestedInclude === true) {
         //specify nestedInclude=true to force nesting of inclusions on scoped
         //queries. e.g. In physician.patients.getAsync({include: 'address'}),
         //inclusion should be on patient model, not on physician model.
@@ -182,7 +182,7 @@ function mergeQuery(base, update, spec) {
         base.include = {};
         base.include[update.include] = saved;
       }
-      else{
+      else {
         //default behaviour of inclusion merge - merge inclusions at the same
         //level. - https://github.com/strongloop/loopback-datasource-juggler/pull/569#issuecomment-95310874
         base.include = mergeIncludes(base.include, update.include);
@@ -283,7 +283,7 @@ function fieldsToArray(fields, properties, excludeUnknown) {
 
 function selectFields(fields) {
   // map function
-  return function (obj) {
+  return function(obj) {
     var result = {};
     var key;
 
@@ -308,7 +308,7 @@ function removeUndefined(query, handleUndefined) {
   }
   // WARNING: [rfeng] Use map() will cause mongodb to produce invalid BSON
   // as traverse doesn't transform the ObjectId correctly
-  return traverse(query).forEach(function (x) {
+  return traverse(query).forEach(function(x) {
     if (x === undefined) {
       switch (handleUndefined) {
         case 'nullify':
@@ -430,7 +430,7 @@ function defineCachedRelations(obj) {
       writable: true,
       enumerable: false,
       configurable: true,
-      value: {}
+      value: {},
     });
   }
 }
@@ -449,7 +449,7 @@ function isPlainObject(obj) {
 
 function sortObjectsByIds(idName, ids, objects, strict) {
   ids = ids.map(function(id) {
-      return (typeof id === 'object') ? String(id) : id;
+    return (typeof id === 'object') ? String(id) : id;
   });
 
   var indexOf = function(x) {
@@ -485,15 +485,15 @@ function createPromiseCallback() {
   var cb;
 
   if (!global.Promise) {
-    cb = function(){};
+    cb = function() {};
     cb.promise = {};
     Object.defineProperty(cb.promise, 'then', { get: throwPromiseNotDefined });
     Object.defineProperty(cb.promise, 'catch', { get: throwPromiseNotDefined });
     return cb;
   }
 
-  var promise = new Promise(function (resolve, reject) {
-    cb = function (err, data) {
+  var promise = new Promise(function(resolve, reject) {
+    cb = function(err, data) {
       if (err) return reject(err);
       return resolve(data);
     };
diff --git a/lib/validations.js b/lib/validations.js
index ec33e743..9e774099 100644
--- a/lib/validations.js
+++ b/lib/validations.js
@@ -207,7 +207,7 @@ Validatable.validate = getConfigurator('custom');
  * @options {Object} Options See below
  * @property {String} message Optional error message if property is not valid.  Default error message: " is invalid".
  */
-Validatable.validateAsync = getConfigurator('custom', {async: true});
+Validatable.validateAsync = getConfigurator('custom', { async: true });
 
 /**
  * Validate uniqueness. Ensure the value for property is unique in the collection of models.
@@ -231,7 +231,7 @@ Validatable.validateAsync = getConfigurator('custom', {async: true});
  * @property {Array.<String>} scopedTo List of properties defining the scope.
  * @property {String} message Optional error message if property is not valid.  Default error message: "is not unique".
  */
-Validatable.validatesUniquenessOf = getConfigurator('uniqueness', {async: true});
+Validatable.validatesUniquenessOf = getConfigurator('uniqueness', { async: true });
 
 // implementation of validators
 
@@ -292,7 +292,7 @@ function validateInclusion(attr, conf, err) {
   if (nullCheck.call(this, attr, conf, err)) return;
 
   if (!~conf.in.indexOf(this[attr])) {
-    err()
+    err();
   }
 }
 
@@ -303,7 +303,7 @@ function validateExclusion(attr, conf, err) {
   if (nullCheck.call(this, attr, conf, err)) return;
 
   if (~conf.in.indexOf(this[attr])) {
-    err()
+    err();
   }
 }
 
@@ -336,7 +336,7 @@ function validateUniqueness(attr, conf, err, done) {
   if (blank(this[attr])) {
     return process.nextTick(done);
   }
-  var cond = {where: {}};
+  var cond = { where: {}};
   cond.where[attr] = this[attr];
 
   if (conf && conf.scopedTo) {
@@ -349,7 +349,7 @@ function validateUniqueness(attr, conf, err, done) {
 
   var idName = this.constructor.definition.idName();
   var isNewRecord = this.isNewRecord();
-  this.constructor.find(cond, function (error, found) {
+  this.constructor.find(cond, function(error, found) {
     if (error) {
       err(error);
     } else if (found.length > 1) {
@@ -372,11 +372,11 @@ var validators = {
   exclusion: validateExclusion,
   format: validateFormat,
   custom: validateCustom,
-  uniqueness: validateUniqueness
+  uniqueness: validateUniqueness,
 };
 
 function getConfigurator(name, opts) {
-  return function () {
+  return function() {
     var args = Array.prototype.slice.call(arguments);
     args[1] = args[1] || {};
     configure(this, name, args, opts);
@@ -415,7 +415,7 @@ function getConfigurator(name, opts) {
  * @param {Function} callback called with (valid)
  * @returns {Boolean} True if no asynchronous validation is configured and all properties pass validation.
  */
-Validatable.prototype.isValid = function (callback, data) {
+Validatable.prototype.isValid = function(callback, data) {
   var valid = true, inst = this, wait = 0, async = false;
   var validations = this.constructor.validations;
 
@@ -426,8 +426,8 @@ Validatable.prototype.isValid = function (callback, data) {
   if (typeof validations !== 'object' && !reportDiscardedProperties) {
     cleanErrors(this);
     if (callback) {
-      this.trigger('validate', function (validationsDone) {
-        validationsDone.call(inst, function () {
+      this.trigger('validate', function(validationsDone) {
+        validationsDone.call(inst, function() {
           callback(valid);
         });
       }, data, callback);
@@ -438,10 +438,10 @@ Validatable.prototype.isValid = function (callback, data) {
   Object.defineProperty(this, 'errors', {
     enumerable: false,
     configurable: true,
-    value: new Errors
+    value: new Errors,
   });
 
-  this.trigger('validate', function (validationsDone) {
+  this.trigger('validate', function(validationsDone) {
     var inst = this,
       asyncFail = false;
 
@@ -453,7 +453,7 @@ Validatable.prototype.isValid = function (callback, data) {
         if (v.options && v.options.async) {
           async = true;
           wait += 1;
-          process.nextTick(function () {
+          process.nextTick(function() {
             validationFailed(inst, attr, v, done);
           });
         } else {
@@ -475,7 +475,7 @@ Validatable.prototype.isValid = function (callback, data) {
     }
 
     if (!async) {
-      validationsDone.call(inst, function () {
+      validationsDone.call(inst, function() {
         if (valid) cleanErrors(inst);
         if (callback) {
           callback(valid);
@@ -486,7 +486,7 @@ Validatable.prototype.isValid = function (callback, data) {
     function done(fail) {
       asyncFail = asyncFail || fail;
       if (--wait === 0) {
-        validationsDone.call(inst, function () {
+        validationsDone.call(inst, function() {
           if (valid && !asyncFail) cleanErrors(inst);
           if (callback) {
             callback(valid && !asyncFail);
@@ -511,7 +511,7 @@ function cleanErrors(inst) {
   Object.defineProperty(inst, 'errors', {
     enumerable: false,
     configurable: true,
-    value: false
+    value: false,
   });
 }
 
@@ -559,7 +559,7 @@ function validationFailed(inst, attr, conf, cb) {
     fail = true;
   });
   if (cb) {
-    validatorArguments.push(function () {
+    validatorArguments.push(function() {
       cb(fail);
     });
   }
@@ -593,19 +593,19 @@ var defaultMessages = {
   length: {
     min: 'too short',
     max: 'too long',
-    is: 'length is wrong'
+    is: 'length is wrong',
   },
   common: {
     blank: 'is blank',
-    'null': 'is null'
+    'null': 'is null',
   },
   numericality: {
     'int': 'is not an integer',
-    'number': 'is not a number'
+    'number': 'is not a number',
   },
   inclusion: 'is not included in the list',
   exclusion: 'is reserved',
-  uniqueness: 'is not unique'
+  uniqueness: 'is not unique',
 };
 
 function nullCheck(attr, conf, err) {
@@ -647,7 +647,7 @@ function configure(cls, validation, args, opts) {
       writable: true,
       configurable: true,
       enumerable: false,
-      value: {}
+      value: {},
     });
   }
   args = [].slice.call(args);
@@ -661,7 +661,7 @@ function configure(cls, validation, args, opts) {
     conf.customValidator = args.pop();
   }
   conf.validation = validation;
-  args.forEach(function (attr) {
+  args.forEach(function(attr) {
     if (typeof attr === 'string') {
       var validation = extend({}, conf);
       validation.options = opts || {};
@@ -675,11 +675,11 @@ function Errors() {
   Object.defineProperty(this, 'codes', {
     enumerable: false,
     configurable: true,
-    value: {}
+    value: {},
   });
 }
 
-Errors.prototype.add = function (field, message, code) {
+Errors.prototype.add = function(field, message, code) {
   code = code || 'invalid';
   if (!this[field]) {
     this[field] = [];
@@ -691,7 +691,7 @@ Errors.prototype.add = function (field, message, code) {
 
 function ErrorCodes(messages) {
   var c = this;
-  Object.keys(messages).forEach(function (field) {
+  Object.keys(messages).forEach(function(field) {
     c[field] = messages[field].codes;
   });
 }
@@ -763,7 +763,7 @@ function ValidationError(obj) {
   this.details = {
     context: context,
     codes: obj.errors && obj.errors.codes,
-    messages: obj.errors
+    messages: obj.errors,
   };
 
   if (Error.captureStackTrace) {
@@ -813,7 +813,7 @@ function formatPropertyError(propertyName, propertyValue, errorMessage) {
       showHidden: false,
       color: false,
       // show top-level object properties only
-      depth: Array.isArray(propertyValue) ? 1 : 0
+      depth: Array.isArray(propertyValue) ? 1 : 0,
     });
     formattedValue = truncatePropertyString(formattedValue);
   } else {
@@ -839,5 +839,5 @@ function truncatePropertyString(value) {
     len -= 3;
   }
 
-  return value.slice(0, len-4) + '...' + tail;
+  return value.slice(0, len - 4) + '...' + tail;
 }
diff --git a/support/describe-operation-hooks.js b/support/describe-operation-hooks.js
index da1e5bb6..f0e348f7 100644
--- a/support/describe-operation-hooks.js
+++ b/support/describe-operation-hooks.js
@@ -17,12 +17,12 @@ var Memory = require('../lib/connectors/memory').Memory;
 var HOOK_NAMES = [
   'access',
   'before save', 'persist', 'after save',
-  'before delete', 'after delete'
+  'before delete', 'after delete',
 ];
 
 var dataSources = [
   createOptimizedDataSource(),
-  createUnoptimizedDataSource()
+  createUnoptimizedDataSource(),
 ];
 
 var observedContexts = [];
@@ -34,7 +34,7 @@ Promise.onPossiblyUnhandledRejection(function(err) {
 
 var operations = [
   function find(ds) {
-    return ds.TestModel.find({ where: { id: '1' } });
+    return ds.TestModel.find({ where: { id: '1' }});
   },
 
   function count(ds) {
@@ -47,13 +47,13 @@ var operations = [
 
   function findOrCreate_found(ds) {
     return ds.TestModel.findOrCreate(
-      { where: { name: ds.existingInstance.name } },
+      { where: { name: ds.existingInstance.name }},
       { name: ds.existingInstance.name });
   },
 
   function findOrCreate_create(ds) {
     return ds.TestModel.findOrCreate(
-      { where: { name: 'new-record' } },
+      { where: { name: 'new-record' }},
       { name: 'new-record' });
   },
 
@@ -134,7 +134,7 @@ function setupTestModels() {
     var TestModel = ds.TestModel = ds.createModel('TestModel', {
       id: { type: String, id: true, default: uid },
       name: { type: String, required: true },
-      extra: { type: String, required: false }
+      extra: { type: String, required: false },
     });
   });
   return Promise.resolve();
@@ -155,7 +155,7 @@ function runner(fn) {
         observedContexts.push({
           operation: fn.name,
           connector: ds.name,
-          hooks: {}
+          hooks: {},
         });
         return fn(ds);
       });
@@ -171,11 +171,11 @@ function resetStorage(ds) {
   });
   return TestModel.deleteAll()
     .then(function() {
-      return TestModel.create({ name: 'first' })
+      return TestModel.create({ name: 'first' });
     })
     .then(function(instance) {
       // Look it up from DB so that default values are retrieved
-      return TestModel.findById(instance.id)
+      return TestModel.findById(instance.id);
     })
     .then(function(instance) {
       ds.existingInstance = instance;
@@ -184,7 +184,7 @@ function resetStorage(ds) {
     .then(function() {
       HOOK_NAMES.forEach(function(hook) {
         TestModel.observe(hook, function(ctx, next) {
-          var row = observedContexts[observedContexts.length-1];
+          var row = observedContexts[observedContexts.length - 1];
           row.hooks[hook] = Object.keys(ctx);
           next();
         });
@@ -193,7 +193,7 @@ function resetStorage(ds) {
 }
 
 function report() {
-  console.log('<style>')
+  console.log('<style>');
   console.log('td { font-family: "monospace": }');
   console.log('td, th {');
   console.log('  vertical-align: text-top;');
@@ -204,7 +204,7 @@ function report() {
   // merge rows where Optimized and Unoptimized produce the same context
   observedContexts.forEach(function(row, ix) {
     if (!ix) return;
-    var last = observedContexts[ix-1];
+    var last = observedContexts[ix - 1];
     if (row.operation != last.operation) return;
     if (JSON.stringify(row.hooks) !== JSON.stringify(last.hooks)) return;
     last.merge = true;
diff --git a/test/CustomTypeForeignKey.test.js b/test/CustomTypeForeignKey.test.js
index 1de8d29f..6adc7583 100644
--- a/test/CustomTypeForeignKey.test.js
+++ b/test/CustomTypeForeignKey.test.js
@@ -9,36 +9,36 @@ var jdb = require('../');
 var DataSource = jdb.DataSource;
 
 var ds, Item, Variant;
-describe('Datasource-specific field types for foreign keys', function () {
-  before(function () {
+describe('Datasource-specific field types for foreign keys', function() {
+  before(function() {
     ds = new DataSource('memory');
     Item = ds.define('Item', {
-      "myProp": {
-        "id": true,
-        "type": "string",
-        "memory": {
-          "dataType": "string"
-        }
-      }
+      'myProp': {
+        'id': true,
+        'type': 'string',
+        'memory': {
+          'dataType': 'string',
+        },
+      },
     });
     Variant = ds.define('Variant', {}, {
       relations: {
-        "item": {
-          "type": "belongsTo",
-          "as": "item",
-          "model": "Item",
-          "foreignKey": "myProp"
-        }
-      }
+        'item': {
+          'type': 'belongsTo',
+          'as': 'item',
+          'model': 'Item',
+          'foreignKey': 'myProp',
+        },
+      },
     });
   });
 
-  it('should create foreign key with database-specific field type', function (done) {
+  it('should create foreign key with database-specific field type', function(done) {
     var VariantDefinition = ds.getModelDefinition('Variant');
     should.exist(VariantDefinition);
     should.exist(VariantDefinition.properties.myProp.memory);
     should.exist(VariantDefinition.properties.myProp.memory.dataType);
-    VariantDefinition.properties.myProp.memory.dataType.should.be.equal("string");
+    VariantDefinition.properties.myProp.memory.dataType.should.be.equal('string');
     done();
   });
 })
diff --git a/test/async-observer.test.js b/test/async-observer.test.js
index e157b3fd..90ed0489 100644
--- a/test/async-observer.test.js
+++ b/test/async-observer.test.js
@@ -160,7 +160,7 @@ describe('async observer', function() {
   it('passes context to final callback', function(done) {
     var context = {};
     TestModel.notifyObserversOf('event', context, function(err, ctx) {
-      (ctx || "null").should.equal(context);
+      (ctx || 'null').should.equal(context);
       done();
     });
   });
diff --git a/test/basic-querying.test.js b/test/basic-querying.test.js
index 71f8954a..7412bd12 100644
--- a/test/basic-querying.test.js
+++ b/test/basic-querying.test.js
@@ -8,52 +8,52 @@ var should = require('./init.js');
 var async = require('async');
 var db, User;
 
-describe('basic-querying', function () {
+describe('basic-querying', function() {
 
-  before(function (done) {
+  before(function(done) {
     db = getSchema();
     User = db.define('User', {
-      seq: {type: Number, index: true},
-      name: {type: String, index: true, sort: true},
-      email: {type: String, index: true},
-      birthday: {type: Date, index: true},
-      role: {type: String, index: true},
-      order: {type: Number, index: true, sort: true},
-      vip: {type: Boolean}
+      seq: { type: Number, index: true },
+      name: { type: String, index: true, sort: true },
+      email: { type: String, index: true },
+      birthday: { type: Date, index: true },
+      role: { type: String, index: true },
+      order: { type: Number, index: true, sort: true },
+      vip: { type: Boolean },
     });
 
     db.automigrate(done);
 
   });
 
-  describe('ping', function () {
-    it('should be able to test connections', function (done) {
-      db.ping(function (err) {
+  describe('ping', function() {
+    it('should be able to test connections', function(done) {
+      db.ping(function(err) {
         should.not.exist(err);
         done();
       });
     });
   });
 
-  describe('findById', function () {
+  describe('findById', function() {
 
-    before(function (done) {
+    before(function(done) {
       User.destroyAll(done);
     });
 
-    it('should query by id: not found', function (done) {
-      User.findById(1, function (err, u) {
+    it('should query by id: not found', function(done) {
+      User.findById(1, function(err, u) {
         should.not.exist(u);
         should.not.exist(err);
         done();
       });
     });
 
-    it('should query by id: found', function (done) {
-      User.create(function (err, u) {
+    it('should query by id: found', function(done) {
+      User.create(function(err, u) {
         should.not.exist(err);
         should.exist(u.id);
-        User.findById(u.id, function (err, u) {
+        User.findById(u.id, function(err, u) {
           should.exist(u);
           should.not.exist(err);
           u.should.be.an.instanceOf(User);
@@ -64,7 +64,7 @@ describe('basic-querying', function () {
 
   });
 
-  describe('findByIds', function () {
+  describe('findByIds', function() {
     var createdUsers;
     before(function(done) {
       var people = [
@@ -73,7 +73,7 @@ describe('basic-querying', function () {
         { name: 'c' },
         { name: 'd', vip: true },
         { name: 'e' },
-        { name: 'f' }
+        { name: 'f' },
       ];
       db.automigrate(['User'], function(err) {
         User.create(people, function(err, users) {
@@ -103,11 +103,11 @@ describe('basic-querying', function () {
 
     it('should query by ids and condition', function(done) {
       User.findByIds([
-          createdUsers[0].id,
-          createdUsers[1].id,
-          createdUsers[2].id,
-          createdUsers[3].id],
-        { where: { vip: true } }, function(err, users) {
+        createdUsers[0].id,
+        createdUsers[1].id,
+        createdUsers[2].id,
+        createdUsers[3].id],
+        { where: { vip: true }}, function(err, users) {
           should.exist(users);
           should.not.exist(err);
           var names = users.map(function(u) {
@@ -125,12 +125,12 @@ describe('basic-querying', function () {
 
   });
 
-  describe('find', function () {
+  describe('find', function() {
 
     before(seed);
 
-    it('should query collection', function (done) {
-      User.find(function (err, users) {
+    it('should query collection', function(done) {
+      User.find(function(err, users) {
         should.exists(users);
         should.not.exists(err);
         users.should.have.lengthOf(6);
@@ -138,8 +138,8 @@ describe('basic-querying', function () {
       });
     });
 
-    it('should query limited collection', function (done) {
-      User.find({limit: 3}, function (err, users) {
+    it('should query limited collection', function(done) {
+      User.find({ limit: 3 }, function(err, users) {
         should.exists(users);
         should.not.exists(err);
         users.should.have.lengthOf(3);
@@ -147,8 +147,8 @@ describe('basic-querying', function () {
       });
     });
 
-    it('should query collection with skip & limit', function (done) {
-      User.find({skip: 1, limit: 4, order: 'seq'}, function (err, users) {
+    it('should query collection with skip & limit', function(done) {
+      User.find({ skip: 1, limit: 4, order: 'seq' }, function(err, users) {
         should.exists(users);
         should.not.exists(err);
         users[0].seq.should.be.eql(1);
@@ -157,8 +157,8 @@ describe('basic-querying', function () {
       });
     });
 
-    it('should query collection with offset & limit', function (done) {
-      User.find({offset: 2, limit: 3, order: 'seq'}, function (err, users) {
+    it('should query collection with offset & limit', function(done) {
+      User.find({ offset: 2, limit: 3, order: 'seq' }, function(err, users) {
         should.exists(users);
         should.not.exists(err);
         users[0].seq.should.be.eql(2);
@@ -167,8 +167,8 @@ describe('basic-querying', function () {
       });
     });
 
-    it('should query filtered collection', function (done) {
-      User.find({where: {role: 'lead'}}, function (err, users) {
+    it('should query filtered collection', function(done) {
+      User.find({ where: { role: 'lead' }}, function(err, users) {
         should.exists(users);
         should.not.exists(err);
         users.should.have.lengthOf(2);
@@ -176,30 +176,30 @@ describe('basic-querying', function () {
       });
     });
 
-    it('should query collection sorted by numeric field', function (done) {
-      User.find({order: 'order'}, function (err, users) {
+    it('should query collection sorted by numeric field', function(done) {
+      User.find({ order: 'order' }, function(err, users) {
         should.exists(users);
         should.not.exists(err);
-        users.forEach(function (u, i) {
+        users.forEach(function(u, i) {
           u.order.should.eql(i + 1);
         });
         done();
       });
     });
 
-    it('should query collection desc sorted by numeric field', function (done) {
-      User.find({order: 'order DESC'}, function (err, users) {
+    it('should query collection desc sorted by numeric field', function(done) {
+      User.find({ order: 'order DESC' }, function(err, users) {
         should.exists(users);
         should.not.exists(err);
-        users.forEach(function (u, i) {
+        users.forEach(function(u, i) {
           u.order.should.eql(users.length - i);
         });
         done();
       });
     });
 
-    it('should query collection sorted by string field', function (done) {
-      User.find({order: 'name'}, function (err, users) {
+    it('should query collection sorted by string field', function(done) {
+      User.find({ order: 'name' }, function(err, users) {
         should.exists(users);
         should.not.exists(err);
         users.shift().name.should.equal('George Harrison');
@@ -209,8 +209,8 @@ describe('basic-querying', function () {
       });
     });
 
-    it('should query collection desc sorted by string field', function (done) {
-      User.find({order: 'name DESC'}, function (err, users) {
+    it('should query collection desc sorted by string field', function(done) {
+      User.find({ order: 'name DESC' }, function(err, users) {
         should.exists(users);
         should.not.exists(err);
         users.pop().name.should.equal('George Harrison');
@@ -220,53 +220,53 @@ describe('basic-querying', function () {
       });
     });
 
-    it('should support "and" operator that is satisfied', function (done) {
-      User.find({where: {and: [
-        {name: 'John Lennon'},
-        {role: 'lead'}
-      ]}}, function (err, users) {
+    it('should support "and" operator that is satisfied', function(done) {
+      User.find({ where: { and: [
+        { name: 'John Lennon' },
+        { role: 'lead' },
+      ] }}, function(err, users) {
         should.not.exist(err);
         users.should.have.property('length', 1);
         done();
       });
     });
 
-    it('should support "and" operator that is not satisfied', function (done) {
-      User.find({where: {and: [
-        {name: 'John Lennon'},
-        {role: 'member'}
-      ]}}, function (err, users) {
+    it('should support "and" operator that is not satisfied', function(done) {
+      User.find({ where: { and: [
+        { name: 'John Lennon' },
+        { role: 'member' },
+      ] }}, function(err, users) {
         should.not.exist(err);
         users.should.have.property('length', 0);
         done();
       });
     });
 
-    it('should support "or" that is satisfied', function (done) {
-      User.find({where: {or: [
-        {name: 'John Lennon'},
-        {role: 'lead'}
-      ]}}, function (err, users) {
+    it('should support "or" that is satisfied', function(done) {
+      User.find({ where: { or: [
+        { name: 'John Lennon' },
+        { role: 'lead' },
+      ] }}, function(err, users) {
         should.not.exist(err);
         users.should.have.property('length', 2);
         done();
       });
     });
 
-    it('should support "or" operator that is not satisfied', function (done) {
-      User.find({where: {or: [
-        {name: 'XYZ'},
-        {role: 'Hello1'}
-      ]}}, function (err, users) {
+    it('should support "or" operator that is not satisfied', function(done) {
+      User.find({ where: { or: [
+        { name: 'XYZ' },
+        { role: 'Hello1' },
+      ] }}, function(err, users) {
         should.not.exist(err);
         users.should.have.property('length', 0);
         done();
       });
     });
 
-    it('should support date "gte" that is satisfied', function (done) {
-      User.find({order: 'seq', where: { birthday: { "gte": new Date('1980-12-08') }
-      }}, function (err, users) {
+    it('should support date "gte" that is satisfied', function(done) {
+      User.find({ order: 'seq', where: { birthday: { 'gte': new Date('1980-12-08') },
+      }}, function(err, users) {
         should.not.exist(err);
         users.should.have.property('length', 1);
         users[0].name.should.equal('John Lennon');
@@ -274,18 +274,18 @@ describe('basic-querying', function () {
       });
     });
 
-    it('should support date "gt" that is not satisfied', function (done) {
-      User.find({order: 'seq', where: { birthday: { "gt": new Date('1980-12-08') }
-      }}, function (err, users) {
+    it('should support date "gt" that is not satisfied', function(done) {
+      User.find({ order: 'seq', where: { birthday: { 'gt': new Date('1980-12-08') },
+      }}, function(err, users) {
         should.not.exist(err);
         users.should.have.property('length', 0);
         done();
       });
     });
 
-    it('should support date "gt" that is satisfied', function (done) {
-      User.find({order: 'seq', where: { birthday: { "gt": new Date('1980-12-07') }
-      }}, function (err, users) {
+    it('should support date "gt" that is satisfied', function(done) {
+      User.find({ order: 'seq', where: { birthday: { 'gt': new Date('1980-12-07') },
+      }}, function(err, users) {
         should.not.exist(err);
         users.should.have.property('length', 1);
         users[0].name.should.equal('John Lennon');
@@ -293,9 +293,9 @@ describe('basic-querying', function () {
       });
     });
 
-    it('should support date "lt" that is satisfied', function (done) {
-      User.find({order: 'seq', where: { birthday: { "lt": new Date('1980-12-07') }
-      }}, function (err, users) {
+    it('should support date "lt" that is satisfied', function(done) {
+      User.find({ order: 'seq', where: { birthday: { 'lt': new Date('1980-12-07') },
+      }}, function(err, users) {
         should.not.exist(err);
         users.should.have.property('length', 1);
         users[0].name.should.equal('Paul McCartney');
@@ -303,9 +303,9 @@ describe('basic-querying', function () {
       });
     });
 
-    it('should support number "gte" that is satisfied', function (done) {
-      User.find({order: 'seq', where: { order: { "gte":  3}
-      }}, function (err, users) {
+    it('should support number "gte" that is satisfied', function(done) {
+      User.find({ order: 'seq', where: { order: { 'gte':  3 },
+      }}, function(err, users) {
         should.not.exist(err);
         users.should.have.property('length', 4);
         users[0].name.should.equal('George Harrison');
@@ -313,18 +313,18 @@ describe('basic-querying', function () {
       });
     });
 
-    it('should support number "gt" that is not satisfied', function (done) {
-      User.find({order: 'seq', where: { order: { "gt": 6 }
-      }}, function (err, users) {
+    it('should support number "gt" that is not satisfied', function(done) {
+      User.find({ order: 'seq', where: { order: { 'gt': 6 },
+      }}, function(err, users) {
         should.not.exist(err);
         users.should.have.property('length', 0);
         done();
       });
     });
 
-    it('should support number "gt" that is satisfied', function (done) {
-      User.find({order: 'seq', where: { order: { "gt": 5 }
-      }}, function (err, users) {
+    it('should support number "gt" that is satisfied', function(done) {
+      User.find({ order: 'seq', where: { order: { 'gt': 5 },
+      }}, function(err, users) {
         should.not.exist(err);
         users.should.have.property('length', 1);
         users[0].name.should.equal('Ringo Starr');
@@ -332,9 +332,9 @@ describe('basic-querying', function () {
       });
     });
 
-    it('should support number "lt" that is satisfied', function (done) {
-      User.find({order: 'seq', where: { order: { "lt": 2 }
-      }}, function (err, users) {
+    it('should support number "lt" that is satisfied', function(done) {
+      User.find({ order: 'seq', where: { order: { 'lt': 2 },
+      }}, function(err, users) {
         should.not.exist(err);
         users.should.have.property('length', 1);
         users[0].name.should.equal('Paul McCartney');
@@ -342,36 +342,36 @@ describe('basic-querying', function () {
       });
     });
 
-    it('should support number "gt" that is satisfied by null value', function (done) {
-      User.find({order: 'seq', where: { order: { "gt": null }
-      }}, function (err, users) {
+    it('should support number "gt" that is satisfied by null value', function(done) {
+      User.find({ order: 'seq', where: { order: { 'gt': null },
+      }}, function(err, users) {
         should.not.exist(err);
         users.should.have.property('length', 0);
         done();
       });
     });
 
-    it('should support number "lt" that is not satisfied by null value', function (done) {
-      User.find({order: 'seq', where: { order: { "lt": null }
-      }}, function (err, users) {
+    it('should support number "lt" that is not satisfied by null value', function(done) {
+      User.find({ order: 'seq', where: { order: { 'lt': null },
+      }}, function(err, users) {
         should.not.exist(err);
         users.should.have.property('length', 0);
         done();
       });
     });
 
-    it('should support string "gte" that is satisfied by null value', function (done) {
-      User.find({order: 'seq', where: { name: { "gte":  null}
-      }}, function (err, users) {
+    it('should support string "gte" that is satisfied by null value', function(done) {
+      User.find({ order: 'seq', where: { name: { 'gte':  null },
+      }}, function(err, users) {
         should.not.exist(err);
         users.should.have.property('length', 0);
         done();
       });
     });
 
-    it('should support string "gte" that is satisfied', function (done) {
-      User.find({order: 'seq', where: { name: { "gte":  'Paul McCartney'}
-      }}, function (err, users) {
+    it('should support string "gte" that is satisfied', function(done) {
+      User.find({ order: 'seq', where: { name: { 'gte':  'Paul McCartney' },
+      }}, function(err, users) {
         should.not.exist(err);
         users.should.have.property('length', 4);
         users[0].name.should.equal('Paul McCartney');
@@ -379,18 +379,18 @@ describe('basic-querying', function () {
       });
     });
 
-    it('should support string "gt" that is not satisfied', function (done) {
-      User.find({order: 'seq', where: { name: { "gt": 'xyz' }
-      }}, function (err, users) {
+    it('should support string "gt" that is not satisfied', function(done) {
+      User.find({ order: 'seq', where: { name: { 'gt': 'xyz' },
+      }}, function(err, users) {
         should.not.exist(err);
         users.should.have.property('length', 0);
         done();
       });
     });
 
-    it('should support string "gt" that is satisfied', function (done) {
-      User.find({order: 'seq', where: { name: { "gt": 'Paul McCartney' }
-      }}, function (err, users) {
+    it('should support string "gt" that is satisfied', function(done) {
+      User.find({ order: 'seq', where: { name: { 'gt': 'Paul McCartney' },
+      }}, function(err, users) {
         should.not.exist(err);
         users.should.have.property('length', 3);
         users[0].name.should.equal('Ringo Starr');
@@ -398,9 +398,9 @@ describe('basic-querying', function () {
       });
     });
 
-    it('should support string "lt" that is satisfied', function (done) {
-      User.find({order: 'seq', where: { name: { "lt": 'Paul McCartney' }
-      }}, function (err, users) {
+    it('should support string "lt" that is satisfied', function(done) {
+      User.find({ order: 'seq', where: { name: { 'lt': 'Paul McCartney' },
+      }}, function(err, users) {
         should.not.exist(err);
         users.should.have.property('length', 2);
         users[0].name.should.equal('John Lennon');
@@ -408,9 +408,9 @@ describe('basic-querying', function () {
       });
     });
 
-    it('should support boolean "gte" that is satisfied', function (done) {
-      User.find({order: 'seq', where: { vip: { "gte":  true}
-      }}, function (err, users) {
+    it('should support boolean "gte" that is satisfied', function(done) {
+      User.find({ order: 'seq', where: { vip: { 'gte':  true },
+      }}, function(err, users) {
         should.not.exist(err);
         users.should.have.property('length', 3);
         users[0].name.should.equal('John Lennon');
@@ -418,18 +418,18 @@ describe('basic-querying', function () {
       });
     });
 
-    it('should support boolean "gt" that is not satisfied', function (done) {
-      User.find({order: 'seq', where: { vip: { "gt": true }
-      }}, function (err, users) {
+    it('should support boolean "gt" that is not satisfied', function(done) {
+      User.find({ order: 'seq', where: { vip: { 'gt': true },
+      }}, function(err, users) {
         should.not.exist(err);
         users.should.have.property('length', 0);
         done();
       });
     });
 
-    it('should support boolean "gt" that is satisfied', function (done) {
-      User.find({order: 'seq', where: { vip: { "gt": false }
-      }}, function (err, users) {
+    it('should support boolean "gt" that is satisfied', function(done) {
+      User.find({ order: 'seq', where: { vip: { 'gt': false },
+      }}, function(err, users) {
         should.not.exist(err);
         users.should.have.property('length', 3);
         users[0].name.should.equal('John Lennon');
@@ -437,9 +437,9 @@ describe('basic-querying', function () {
       });
     });
 
-    it('should support boolean "lt" that is satisfied', function (done) {
-      User.find({order: 'seq', where: { vip: { "lt": true }
-      }}, function (err, users) {
+    it('should support boolean "lt" that is satisfied', function(done) {
+      User.find({ order: 'seq', where: { vip: { 'lt': true },
+      }}, function(err, users) {
         should.not.exist(err);
         users.should.have.property('length', 2);
         users[0].name.should.equal('George Harrison');
@@ -448,15 +448,15 @@ describe('basic-querying', function () {
     });
 
 
-    it('should only include fields as specified', function (done) {
+    it('should only include fields as specified', function(done) {
       var remaining = 0;
 
       function sample(fields) {
 
         return {
-          expect: function (arr) {
+          expect: function(arr) {
             remaining++;
-            User.find({fields: fields}, function (err, users) {
+            User.find({ fields: fields }, function(err, users) {
 
               remaining--;
               if (err) return done(err);
@@ -467,11 +467,11 @@ describe('basic-querying', function () {
                 done();
               }
 
-              users.forEach(function (user) {
+              users.forEach(function(user) {
                 var obj = user.toObject();
 
                 Object.keys(obj)
-                  .forEach(function (key) {
+                  .forEach(function(key) {
                     // if the obj has an unexpected value
                     if (obj[key] !== undefined && arr.indexOf(key) === -1) {
                       console.log('Given fields:', fields);
@@ -482,14 +482,14 @@ describe('basic-querying', function () {
                   });
               });
             });
-          }
-        }
+          },
+        };
       }
 
-      sample({name: true}).expect(['name']);
-      sample({name: false}).expect(['id', 'seq', 'email', 'role', 'order', 'birthday', 'vip']);
-      sample({name: false, id: true}).expect(['id']);
-      sample({id: true}).expect(['id']);
+      sample({ name: true }).expect(['name']);
+      sample({ name: false }).expect(['id', 'seq', 'email', 'role', 'order', 'birthday', 'vip']);
+      sample({ name: false, id: true }).expect(['id']);
+      sample({ id: true }).expect(['id']);
       sample('id').expect(['id']);
       sample(['id']).expect(['id']);
       sample(['email']).expect(['email']);
@@ -497,12 +497,12 @@ describe('basic-querying', function () {
 
   });
 
-  describe('count', function () {
+  describe('count', function() {
 
     before(seed);
 
-    it('should query total count', function (done) {
-      User.count(function (err, n) {
+    it('should query total count', function(done) {
+      User.count(function(err, n) {
         should.not.exist(err);
         should.exist(n);
         n.should.equal(6);
@@ -510,8 +510,8 @@ describe('basic-querying', function () {
       });
     });
 
-    it('should query filtered count', function (done) {
-      User.count({role: 'lead'}, function (err, n) {
+    it('should query filtered count', function(done) {
+      User.count({ role: 'lead' }, function(err, n) {
         should.not.exist(err);
         should.exist(n);
         n.should.equal(2);
@@ -520,13 +520,13 @@ describe('basic-querying', function () {
     });
   });
 
-  describe('findOne', function () {
+  describe('findOne', function() {
 
     before(seed);
 
-    it('should find first record (default sort by id)', function (done) {
-      User.all({order: 'id'}, function (err, users) {
-        User.findOne(function (e, u) {
+    it('should find first record (default sort by id)', function(done) {
+      User.all({ order: 'id' }, function(err, users) {
+        User.findOne(function(e, u) {
           should.not.exist(e);
           should.exist(u);
           u.id.toString().should.equal(users[0].id.toString());
@@ -535,8 +535,8 @@ describe('basic-querying', function () {
       });
     });
 
-    it('should find first record', function (done) {
-      User.findOne({order: 'order'}, function (e, u) {
+    it('should find first record', function(done) {
+      User.findOne({ order: 'order' }, function(e, u) {
         should.not.exist(e);
         should.exist(u);
         u.order.should.equal(1);
@@ -545,8 +545,8 @@ describe('basic-querying', function () {
       });
     });
 
-    it('should find last record', function (done) {
-      User.findOne({order: 'order DESC'}, function (e, u) {
+    it('should find last record', function(done) {
+      User.findOne({ order: 'order DESC' }, function(e, u) {
         should.not.exist(e);
         should.exist(u);
         u.order.should.equal(6);
@@ -555,11 +555,11 @@ describe('basic-querying', function () {
       });
     });
 
-    it('should find last record in filtered set', function (done) {
+    it('should find last record in filtered set', function(done) {
       User.findOne({
-        where: {role: 'lead'},
-        order: 'order DESC'
-      }, function (e, u) {
+        where: { role: 'lead' },
+        order: 'order DESC',
+      }, function(e, u) {
         should.not.exist(e);
         should.exist(u);
         u.order.should.equal(2);
@@ -568,9 +568,9 @@ describe('basic-querying', function () {
       });
     });
 
-    it('should work even when find by id', function (done) {
-      User.findOne(function (e, u) {
-        User.findOne({where: {id: u.id}}, function (err, user) {
+    it('should work even when find by id', function(done) {
+      User.findOne(function(e, u) {
+        User.findOne({ where: { id: u.id }}, function(err, user) {
           should.not.exist(err);
           should.exist(user);
           done();
@@ -580,13 +580,13 @@ describe('basic-querying', function () {
 
   });
 
-  describe('exists', function () {
+  describe('exists', function() {
 
     before(seed);
 
-    it('should check whether record exist', function (done) {
-      User.findOne(function (e, u) {
-        User.exists(u.id, function (err, exists) {
+    it('should check whether record exist', function(done) {
+      User.findOne(function(e, u) {
+        User.exists(u.id, function(err, exists) {
           should.not.exist(err);
           should.exist(exists);
           exists.should.be.ok;
@@ -595,9 +595,9 @@ describe('basic-querying', function () {
       });
     });
 
-    it('should check whether record not exist', function (done) {
-      User.destroyAll(function () {
-        User.exists(42, function (err, exists) {
+    it('should check whether record not exist', function(done) {
+      User.destroyAll(function() {
+        User.exists(42, function(err, exists) {
           should.not.exist(err);
           exists.should.not.be.ok;
           done();
@@ -615,7 +615,7 @@ describe('basic-querying', function () {
       // `undefined` is not tested because the `removeUndefined` function
       // in `lib/dao.js` removes it before coercion
       invalidDataTypes.forEach(function(invalidDataType) {
-        User.find({where: {name: {regexp: invalidDataType}}}, function(err,
+        User.find({ where: { name: { regexp: invalidDataType }}}, function(err,
             users) {
           should.exist(err);
         });
@@ -632,25 +632,25 @@ describe.skip('queries', function() {
     var db = getSchema();
     Todo = db.define('Todo', {
       id: false,
-      content: {type: 'string'}
+      content: { type: 'string' },
     }, {
-      idInjection: false
+      idInjection: false,
     });
     db.automigrate(['Todo'], done);
   });
   beforeEach(function resetFixtures(done) {
     Todo.destroyAll(function() {
       Todo.create([
-        {content: 'Buy eggs'},
-        {content: 'Buy milk'},
-        {content: 'Buy sausages'}
+        { content: 'Buy eggs' },
+        { content: 'Buy milk' },
+        { content: 'Buy sausages' },
       ], done);
     });
   });
 
   context('that do not require an id', function() {
     it('should work for create', function(done) {
-      Todo.create({content: 'Buy ham'}, function(err) {
+      Todo.create({ content: 'Buy ham' }, function(err) {
         should.not.exist(err);
         done();
       });
@@ -659,7 +659,7 @@ describe.skip('queries', function() {
     it('should work for updateOrCreate/upsert', function(done) {
       var aliases = ['updateOrCreate', 'upsert'];
       async.each(aliases, function(alias, cb) {
-        Todo[alias]({content: 'Buy ham'}, function(err) {
+        Todo[alias]({ content: 'Buy ham' }, function(err) {
           should.not.exist(err);
           cb();
         });
@@ -667,14 +667,14 @@ describe.skip('queries', function() {
     });
 
     it('should work for findOrCreate', function(done) {
-      Todo.findOrCreate({content: 'Buy ham'}, function(err) {
+      Todo.findOrCreate({ content: 'Buy ham' }, function(err) {
         should.not.exist(err);
         done();
       });
     });
 
     it('should work for exists', function(done) {
-      Todo.exists({content: 'Buy ham'}, function(err) {
+      Todo.exists({ content: 'Buy ham' }, function(err) {
         should.not.exist(err);
         done();
       });
@@ -707,14 +707,14 @@ describe.skip('queries', function() {
     });
 
     it('should work for update/updateAll', function(done) {
-      Todo.update({content: 'Buy ham'}, function(err) {
+      Todo.update({ content: 'Buy ham' }, function(err) {
         should.not.exist(err);
         done();
       });
     });
 
     it('should work for count', function(done) {
-      Todo.count({content: 'Buy eggs'}, function(err) {
+      Todo.count({ content: 'Buy eggs' }, function(err) {
         should.not.exist(err);
         done();
       });
@@ -742,15 +742,15 @@ describe.skip('queries', function() {
 
     it('should return an error for deleteById/destroyById/removeById',
         function(done) {
-      var aliases = ['deleteById', 'destroyById', 'removeById'];
-      async.each(aliases, function(alias, cb) {
-        Todo[alias](1, function(err) {
+          var aliases = ['deleteById', 'destroyById', 'removeById'];
+          async.each(aliases, function(alias, cb) {
+            Todo[alias](1, function(err) {
           should.exist(err);
           err.message.should.equal(expectedErrMsg);
           cb();
         });
-      }, done);
-    });
+          }, done);
+        });
 
     it('should return an error for instance.save', function(done) {
       var todo = new Todo();
@@ -784,7 +784,7 @@ describe.skip('queries', function() {
 
     it('should return an error for instance.updateAttributes', function(done) {
       Todo.findOne(function(err, todo) {
-        todo.updateAttributes({content: 'Buy ham'}, function(err) {
+        todo.updateAttributes({ content: 'Buy ham' }, function(err) {
           should.exist(err);
           err.message.should.equal(expectedErrMsg);
           done();
@@ -803,7 +803,7 @@ function seed(done) {
       role: 'lead',
       birthday: new Date('1980-12-08'),
       order: 2,
-      vip: true
+      vip: true,
     },
     {
       seq: 1,
@@ -812,18 +812,18 @@ function seed(done) {
       role: 'lead',
       birthday: new Date('1942-06-18'),
       order: 1,
-      vip: true
+      vip: true,
     },
-    {seq: 2, name: 'George Harrison', order: 5, vip: false},
-    {seq: 3, name: 'Ringo Starr', order: 6, vip: false},
-    {seq: 4, name: 'Pete Best', order: 4},
-    {seq: 5, name: 'Stuart Sutcliffe', order: 3, vip: true}
+    { seq: 2, name: 'George Harrison', order: 5, vip: false },
+    { seq: 3, name: 'Ringo Starr', order: 6, vip: false },
+    { seq: 4, name: 'Pete Best', order: 4 },
+    { seq: 5, name: 'Stuart Sutcliffe', order: 3, vip: true },
   ];
 
   async.series([
     User.destroyAll.bind(User),
     function(cb) {
       async.each(beatles, User.create.bind(User), cb);
-    }
+    },
   ], done);
 }
diff --git a/test/common_test.js b/test/common_test.js
index d19e45ee..e3ce840b 100644
--- a/test/common_test.js
+++ b/test/common_test.js
@@ -28,13 +28,13 @@ module.exports = function testSchema(exportCasesHere, dataSource) {
   }
   var start;
 
-  batch['should connect to database'] = function (test) {
+  batch['should connect to database'] = function(test) {
     start = Date.now();
     if (dataSource.connected) return test.done();
     dataSource.on('connected', test.done);
   };
 
-  dataSource.log = function (a) {
+  dataSource.log = function(a) {
     console.log(a);
     nbSchemaRequests++;
   };
@@ -43,7 +43,7 @@ module.exports = function testSchema(exportCasesHere, dataSource) {
 
   testOrm(dataSource);
 
-  batch['all tests done'] = function (test) {
+  batch['all tests done'] = function(test) {
     test.done();
     process.nextTick(allTestsDone);
   };
@@ -59,19 +59,19 @@ Object.defineProperty(module.exports, 'it', {
   writable: true,
   enumerable: false,
   configurable: true,
-  value: it
+  value: it,
 });
 
 Object.defineProperty(module.exports, 'skip', {
   writable: true,
   enumerable: false,
   configurable: true,
-  value: skip
+  value: skip,
 });
 
 function clearAndCreate(model, data, callback) {
   var createdItems = [];
-  model.destroyAll(function () {
+  model.destroyAll(function() {
     nextItem(null, null);
   });
 
@@ -95,7 +95,7 @@ function testOrm(dataSource) {
 
   var Post, User, Passport, Log, Dog;
 
-  it('should define class', function (test) {
+  it('should define class', function(test) {
 
     User = dataSource.define('User', {
       name: { type: String, index: true },
@@ -104,52 +104,52 @@ function testOrm(dataSource) {
       approved: Boolean,
       joinedAt: Date,
       age: Number,
-      passwd: { type: String, index: true }
+      passwd: { type: String, index: true },
     });
 
     Dog = dataSource.define('Dog', {
-      name: { type: String, limit: 64, allowNull: false }
+      name: { type: String, limit: 64, allowNull: false },
     });
 
     Log = dataSource.define('Log', {
       ownerId: { type: Number, allowNull: true },
-      name: { type: String, limit: 64, allowNull: false }
+      name: { type: String, limit: 64, allowNull: false },
     });
 
-    Log.belongsTo(Dog, {as: 'owner', foreignKey: 'ownerId'});
+    Log.belongsTo(Dog, { as: 'owner', foreignKey: 'ownerId' });
 
     dataSource.extendModel('User', {
       settings: { type: Schema.JSON },
-      extra: Object
+      extra: Object,
     });
 
-    var newuser = new User({settings: {hey: 'you'}});
+    var newuser = new User({ settings: { hey: 'you' }});
     test.ok(newuser.settings);
 
     Post = dataSource.define('Post', {
       title: { type: String, length: 255, index: true },
       subject: { type: String },
       content: { type: Text },
-      date: { type: Date, default: function () {
-        return new Date
+      date: { type: Date, default: function() {
+        return new Date;
       }, index: true },
       published: { type: Boolean, default: false, index: true },
       likes: [],
-      related: [RelatedPost]
-    }, {table: 'posts'});
+      related: [RelatedPost],
+    }, { table: 'posts' });
 
     function RelatedPost() {
     }
 
-    RelatedPost.prototype.someMethod = function () {
+    RelatedPost.prototype.someMethod = function() {
       return this.parent;
     };
 
-    Post.validateAsync('title', function (err, done) {
+    Post.validateAsync('title', function(err, done) {
       process.nextTick(done);
     });
 
-    User.hasMany(Post, {as: 'posts', foreignKey: 'userId'});
+    User.hasMany(Post, { as: 'posts', foreignKey: 'userId' });
     // creates instance methods:
     // user.posts(conds)
     // user.posts.build(data) // like new Post({userId: user.id});
@@ -164,18 +164,18 @@ function testOrm(dataSource) {
     // user.latestPost.build(data)
     // user.latestPost.create(data)
 
-    Post.belongsTo(User, {as: 'author', foreignKey: 'userId'});
+    Post.belongsTo(User, { as: 'author', foreignKey: 'userId' });
     // creates instance methods:
     // post.author(callback) -- getter when called with function
     // post.author() -- sync getter when called without params
     // post.author(user) -- setter when called with object
 
     Passport = dataSource.define('Passport', {
-      number: String
+      number: String,
     });
 
-    Passport.belongsTo(User, {as: 'owner', foreignKey: 'ownerId'});
-    User.hasMany(Passport, {as: 'passports', foreignKey: 'ownerId'});
+    Passport.belongsTo(User, { as: 'owner', foreignKey: 'ownerId' });
+    User.hasMany(Passport, { as: 'passports', foreignKey: 'ownerId' });
 
     var user = new User;
 
@@ -188,7 +188,7 @@ function testOrm(dataSource) {
     // instance methods
     test.ok(user.save instanceof Function);
 
-    dataSource.automigrate(function (err) {
+    dataSource.automigrate(function(err) {
       if (err) {
         console.log('Error while migrating');
         console.log(err);
@@ -199,11 +199,11 @@ function testOrm(dataSource) {
 
   });
 
-  it('should initialize object properly', function (test) {
+  it('should initialize object properly', function(test) {
     var hw = 'Hello word',
       now = Date.now(),
-      post = new Post({title: hw}),
-      anotherPost = Post({title: 'Resig style constructor'});
+      post = new Post({ title: hw }),
+      anotherPost = Post({ title: 'Resig style constructor' });
 
     test.equal(post.title, hw);
     test.ok(!post.propertyChanged('title'), 'property changed: title');
@@ -218,31 +218,31 @@ function testOrm(dataSource) {
     test.done();
   });
 
-  it('should save object', function (test) {
+  it('should save object', function(test) {
     var title = 'Initial title', title2 = 'Hello world',
       date = new Date;
 
     Post.create({
       title: title,
-      date: date
-    }, function (err, obj) {
+      date: date,
+    }, function(err, obj) {
       test.ok(obj.id, 'Object id should present');
       test.equals(obj.title, title);
       // test.equals(obj.date, date);
       obj.title = title2;
       test.ok(obj.propertyChanged('title'), 'Title changed');
-      obj.save(function (err, obj) {
+      obj.save(function(err, obj) {
         test.equal(obj.title, title2);
         test.ok(!obj.propertyChanged('title'));
 
-        var p = new Post({title: 1});
+        var p = new Post({ title: 1 });
         p.title = 2;
-        p.save(function (err, obj) {
+        p.save(function(err, obj) {
           test.ok(!p.propertyChanged('title'));
           p.title = 3;
           test.ok(p.propertyChanged('title'));
           test.equal(p.title_was, 2);
-          p.save(function () {
+          p.save(function() {
             test.equal(p.title_was, 3);
             test.ok(!p.propertyChanged('title'));
             test.done();
@@ -252,18 +252,18 @@ function testOrm(dataSource) {
     });
   });
 
-  it('should create object with initial data', function (test) {
+  it('should create object with initial data', function(test) {
     var title = 'Initial title',
       date = new Date;
 
     Post.create({
       title: title,
-      date: date
-    }, function (err, obj) {
+      date: date,
+    }, function(err, obj) {
       test.ok(obj.id);
       test.equals(obj.title, title);
       test.equals(obj.date, date);
-      Post.findById(obj.id, function () {
+      Post.findById(obj.id, function() {
         test.equal(obj.title, title);
         test.equal(obj.date.toString(), date.toString());
         test.done();
@@ -271,13 +271,13 @@ function testOrm(dataSource) {
     });
   });
 
-  it('should save only dataSource-defined field in database', function (test) {
-    Post.create({title: '1602', nonSchemaField: 'some value'}, function (err, post) {
+  it('should save only dataSource-defined field in database', function(test) {
+    Post.create({ title: '1602', nonSchemaField: 'some value' }, function(err, post) {
       test.ok(!post.nonSchemaField);
       post.a = 1;
-      post.save(function () {
+      post.save(function() {
         test.ok(post.a);
-        post.reload(function (err, psto) {
+        post.reload(function(err, psto) {
           test.ok(!psto.a);
           test.done();
         });
@@ -301,24 +301,24 @@ function testOrm(dataSource) {
    });
    */
 
-  it('should not re-instantiate object on saving', function (test) {
+  it('should not re-instantiate object on saving', function(test) {
     var title = 'Initial title';
-    var post = new Post({title: title});
-    post.save(function (err, savedPost) {
+    var post = new Post({ title: title });
+    post.save(function(err, savedPost) {
       test.strictEqual(post, savedPost);
       test.done();
     });
   });
 
-  it('should destroy object', function (test) {
-    Post.create(function (err, post) {
-      Post.exists(post.id, function (err, exists) {
+  it('should destroy object', function(test) {
+    Post.create(function(err, post) {
+      Post.exists(post.id, function(err, exists) {
         test.ok(exists, 'Object exists');
-        post.destroy(function () {
-          Post.exists(post.id, function (err, exists) {
+        post.destroy(function() {
+          Post.exists(post.id, function(err, exists) {
             if (err) console.log(err);
             test.ok(!exists, 'Hey! ORM told me that object exists, but it looks like it doesn\'t. Something went wrong...');
-            Post.findById(post.id, function (err, obj) {
+            Post.findById(post.id, function(err, obj) {
               test.equal(obj, null, 'Param obj should be null');
               test.done();
             });
@@ -328,10 +328,10 @@ function testOrm(dataSource) {
     });
   });
 
-  it('should handle virtual attributes', function (test) {
+  it('should handle virtual attributes', function(test) {
     var salt = 's0m3s3cr3t5a1t';
 
-    User.setter.passwd = function (password) {
+    User.setter.passwd = function(password) {
       this._passwd = calcHash(password, salt);
     };
 
@@ -361,15 +361,15 @@ function testOrm(dataSource) {
   //     });
   // });
 
-  it('should update single attribute', function (test) {
-    Post.create({title: 'title', content: 'content', published: true}, function (err, post) {
+  it('should update single attribute', function(test) {
+    Post.create({ title: 'title', content: 'content', published: true }, function(err, post) {
       post.content = 'New content';
-      post.updateAttribute('title', 'New title', function () {
+      post.updateAttribute('title', 'New title', function() {
         test.equal(post.title, 'New title');
         test.ok(!post.propertyChanged('title'));
         test.equal(post.content, 'New content', 'dirty state saved');
         test.ok(post.propertyChanged('content'));
-        post.reload(function (err, post) {
+        post.reload(function(err, post) {
           test.equal(post.title, 'New title');
           test.ok(!post.propertyChanged('title'), 'title not changed');
           test.equal(post.content, 'content', 'real value turned back');
@@ -381,22 +381,22 @@ function testOrm(dataSource) {
   });
 
   var countOfposts, countOfpostsFiltered;
-  it('should fetch collection', function (test) {
-    Post.all(function (err, posts) {
+  it('should fetch collection', function(test) {
+    Post.all(function(err, posts) {
       countOfposts = posts.length;
       test.ok(countOfposts > 0);
       test.ok(posts[0] instanceof Post);
-      countOfpostsFiltered = posts.filter(function (p) {
+      countOfpostsFiltered = posts.filter(function(p) {
         return p.title === 'title';
       }).length;
       test.done();
     });
   });
 
-  it('should find records filtered with multiple attributes', function (test) {
+  it('should find records filtered with multiple attributes', function(test) {
     var d = new Date;
-    Post.create({title: 'title', content: 'content', published: true, date: d}, function (err, post) {
-      Post.all({where: {title: 'title', date: d, published: true}}, function (err, res) {
+    Post.create({ title: 'title', content: 'content', published: true, date: d }, function(err, post) {
+      Post.all({ where: { title: 'title', date: d, published: true }}, function(err, res) {
         test.equals(res.length, 1, 'Filtering Posts returns one post');
         test.done();
       });
@@ -409,7 +409,7 @@ function testOrm(dataSource) {
       dataSource.name !== 'neo4j' &&
       dataSource.name !== 'cradle'
     )
-    it('relations key is working', function (test) {
+    it('relations key is working', function(test) {
       test.ok(User.relations, 'Relations key should be defined');
       test.ok(User.relations.posts, 'posts relation should exist on User');
       test.equal(User.relations.posts.type, 'hasMany', 'Type of hasMany relation is hasMany');
@@ -426,15 +426,15 @@ function testOrm(dataSource) {
       test.done();
     });
 
-  it('should handle hasMany relationship', function (test) {
-    User.create(function (err, u) {
+  it('should handle hasMany relationship', function(test) {
+    User.create(function(err, u) {
       if (err) return console.log(err);
       test.ok(u.posts, 'Method defined: posts');
       test.ok(u.posts.build, 'Method defined: posts.build');
       test.ok(u.posts.create, 'Method defined: posts.create');
-      u.posts.create(function (err, post) {
+      u.posts.create(function(err, post) {
         if (err) return console.log(err);
-        u.posts(function (err, posts) {
+        u.posts(function(err, posts) {
           test.equal(posts.pop().id.toString(), post.id.toString());
           test.done();
         });
@@ -442,13 +442,13 @@ function testOrm(dataSource) {
     });
   });
 
-  it('should navigate variations of belongsTo regardless of column name', function (test) {
+  it('should navigate variations of belongsTo regardless of column name', function(test) {
 
-    Dog.create({name: 'theDog'}, function (err, obj) {
+    Dog.create({ name: 'theDog' }, function(err, obj) {
       test.ok(obj instanceof Dog);
-      Log.create({name: 'theLog', ownerId: obj.id}, function (err, obj) {
+      Log.create({ name: 'theLog', ownerId: obj.id }, function(err, obj) {
         test.ok(obj instanceof Log);
-        obj.owner(function (err, obj) {
+        obj.owner(function(err, obj) {
           test.ok(!err, 'Should not have an error.'); // Before cba174b this would be 'Error: Permission denied'
           if (err) {
             console.log('Found: ' + err);
@@ -467,11 +467,11 @@ function testOrm(dataSource) {
     });
   });
 
-  it('hasMany should support additional conditions', function (test) {
+  it('hasMany should support additional conditions', function(test) {
 
-    User.create(function (e, u) {
-      u.posts.create({}, function (e, p) {
-        u.posts({where: {id: p.id}}, function (e, posts) {
+    User.create(function(e, u) {
+      u.posts.create({}, function(e, p) {
+        u.posts({ where: { id: p.id }}, function(e, posts) {
           test.equal(posts.length, 1, 'There should be only 1 post.');
           test.done();
         });
@@ -480,26 +480,26 @@ function testOrm(dataSource) {
 
   });
 
-  it('hasMany should be cached', function (test) {
+  it('hasMany should be cached', function(test) {
     //User.create(function (e, u) {
     //    u.posts.create({}, function (e, p) {
     // find all posts for a user.
     // Finding one post with an existing author associated
-    Post.all(function (err, posts) {
+    Post.all(function(err, posts) {
       // We try to get the first post with a userId != NULL
       for (var i = 0; i < posts.length; i++) {
         var post = posts[i];
         if (post.userId) {
           // We could get the user with belongs to relationship but it is better if there is no interactions.
-          User.findById(post.userId, function (err, user) {
-            User.create(function (err, voidUser) {
-              Post.create({userId: user.id}, function () {
+          User.findById(post.userId, function(err, user) {
+            User.create(function(err, voidUser) {
+              Post.create({ userId: user.id }, function() {
 
                 // There can't be any concurrency because we are counting requests
                 // We are first testing cases when user has posts
-                user.posts(function (err, data) {
+                user.posts(function(err, data) {
                   var nbInitialRequests = nbSchemaRequests;
-                  user.posts(function (err, data2) {
+                  user.posts(function(err, data2) {
                     test.equal(data.length, 2, 'There should be 2 posts.');
                     test.equal(data.length, data2.length, 'Posts should be the same, since we are loading on the same object.');
                     requestsAreCounted && test.equal(nbInitialRequests, nbSchemaRequests, 'There should not be any request because value is cached.');
@@ -507,23 +507,23 @@ function testOrm(dataSource) {
                     if (dataSource.name === 'mongodb') { // for the moment mongodb doesn\'t support additional conditions on hasMany relations (see above)
                       test.done();
                     } else {
-                      user.posts({where: {id: data[0].id}}, function (err, data) {
+                      user.posts({ where: { id: data[0].id }}, function(err, data) {
                         test.equal(data.length, 1, 'There should be only one post.');
                         requestsAreCounted && test.equal(nbInitialRequests + 1, nbSchemaRequests, 'There should be one additional request since we added conditions.');
 
-                        user.posts(function (err, data) {
+                        user.posts(function(err, data) {
                           test.equal(data.length, 2, 'Previous get shouldn\'t have changed cached value though, since there was additional conditions.');
                           requestsAreCounted && test.equal(nbInitialRequests + 1, nbSchemaRequests, 'There should not be any request because value is cached.');
 
                           // We are now testing cases when user doesn't have any post
-                          voidUser.posts(function (err, data) {
+                          voidUser.posts(function(err, data) {
                             var nbInitialRequests = nbSchemaRequests;
-                            voidUser.posts(function (err, data2) {
+                            voidUser.posts(function(err, data2) {
                               test.equal(data.length, 0, 'There shouldn\'t be any posts (1/2).');
                               test.equal(data2.length, 0, 'There shouldn\'t be any posts (2/2).');
                               requestsAreCounted && test.equal(nbInitialRequests, nbSchemaRequests, 'There should not be any request because value is cached.');
 
-                              voidUser.posts(true, function (err, data3) {
+                              voidUser.posts(true, function(err, data3) {
                                 test.equal(data3.length, 0, 'There shouldn\'t be any posts.');
                                 requestsAreCounted && test.equal(nbInitialRequests + 1, nbSchemaRequests, 'There should be one additional request since we forced refresh.');
 
@@ -555,24 +555,24 @@ function testOrm(dataSource) {
   //     });
   // });
 
-  it('should support scopes', function (test) {
+  it('should support scopes', function(test) {
     var wait = 2;
 
     test.ok(Post.scope, 'Scope supported');
-    Post.scope('published', {where: {published: true}});
+    Post.scope('published', { where: { published: true }});
     test.ok(typeof Post.published === 'function');
     test.ok(Post.published._scope.where.published === true);
     var post = Post.published.build();
     test.ok(post.published, 'Can build');
     test.ok(post.isNewRecord());
-    Post.published.create(function (err, psto) {
+    Post.published.create(function(err, psto) {
       if (err) return console.log(err);
       test.ok(psto.published);
       test.ok(!psto.isNewRecord());
       done();
     });
 
-    User.create(function (err, u) {
+    User.create(function(err, u) {
       if (err) return console.log(err);
       test.ok(typeof u.posts.published == 'function');
       test.ok(u.posts.published._scope.where.published);
@@ -586,7 +586,7 @@ function testOrm(dataSource) {
     };
   });
 
-  it('should return type of property', function (test) {
+  it('should return type of property', function(test) {
     test.equal(Post.getPropertyType('title'), 'String');
     test.equal(Post.getPropertyType('content'), 'Text');
     var p = new Post;
@@ -595,26 +595,26 @@ function testOrm(dataSource) {
     test.done();
   });
 
-  it('should handle ORDER clause', function (test) {
+  it('should handle ORDER clause', function(test) {
     var titles = [
-      { title: 'Title A', subject: "B" },
-      { title: 'Title Z', subject: "A" },
-      { title: 'Title M', subject: "C" },
-      { title: 'Title A', subject: "A" },
-      { title: 'Title B', subject: "A" },
-      { title: 'Title C', subject: "D" }
+      { title: 'Title A', subject: 'B' },
+      { title: 'Title Z', subject: 'A' },
+      { title: 'Title M', subject: 'C' },
+      { title: 'Title A', subject: 'A' },
+      { title: 'Title B', subject: 'A' },
+      { title: 'Title C', subject: 'D' },
     ];
     var isRedis = Post.dataSource.name === 'redis';
-    var dates = isRedis ? [ 5, 9, 0, 17, 10, 9 ] : [
+    var dates = isRedis ? [5, 9, 0, 17, 10, 9] : [
       new Date(1000 * 5),
       new Date(1000 * 9),
       new Date(1000 * 0),
       new Date(1000 * 17),
       new Date(1000 * 10),
-      new Date(1000 * 9)
+      new Date(1000 * 9),
     ];
-    titles.forEach(function (t, i) {
-      Post.create({title: t.title, subject: t.subject, date: dates[i]}, done);
+    titles.forEach(function(t, i) {
+      Post.create({ title: t.title, subject: t.subject, date: dates[i] }, done);
     });
 
     var i = 0, tests = 0;
@@ -643,10 +643,10 @@ function testOrm(dataSource) {
 
     function doStringTest() {
       tests += 1;
-      Post.all({order: 'title'}, function (err, posts) {
+      Post.all({ order: 'title' }, function(err, posts) {
         if (err) console.log(err);
         test.equal(posts.length, 6);
-        titles.sort(compare).forEach(function (t, i) {
+        titles.sort(compare).forEach(function(t, i) {
           if (posts[i]) test.equal(posts[i].title, t.title);
         });
         finished();
@@ -655,10 +655,10 @@ function testOrm(dataSource) {
 
     function doNumberTest() {
       tests += 1;
-      Post.all({order: 'date'}, function (err, posts) {
+      Post.all({ order: 'date' }, function(err, posts) {
         if (err) console.log(err);
         test.equal(posts.length, 6);
-        dates.sort(numerically).forEach(function (d, i) {
+        dates.sort(numerically).forEach(function(d, i) {
           if (posts[i])
             test.equal(posts[i].date.toString(), d.toString(), 'doNumberTest');
         });
@@ -668,11 +668,11 @@ function testOrm(dataSource) {
 
     function doFilterAndSortTest() {
       tests += 1;
-      Post.all({where: {date: new Date(1000 * 9)}, order: 'title', limit: 3}, function (err, posts) {
+      Post.all({ where: { date: new Date(1000 * 9) }, order: 'title', limit: 3 }, function(err, posts) {
         if (err) console.log(err);
         console.log(posts.length);
         test.equal(posts.length, 2, 'Exactly 2 posts returned by query');
-        [ 'Title C', 'Title Z' ].forEach(function (t, i) {
+        ['Title C', 'Title Z'].forEach(function(t, i) {
           if (posts[i]) {
             test.equal(posts[i].title, t, 'doFilterAndSortTest');
           }
@@ -683,10 +683,10 @@ function testOrm(dataSource) {
 
     function doFilterAndSortReverseTest() {
       tests += 1;
-      Post.all({where: {date: new Date(1000 * 9)}, order: 'title DESC', limit: 3}, function (err, posts) {
+      Post.all({ where: { date: new Date(1000 * 9) }, order: 'title DESC', limit: 3 }, function(err, posts) {
         if (err) console.log(err);
         test.equal(posts.length, 2, 'Exactly 2 posts returned by query');
-        [ 'Title Z', 'Title C' ].forEach(function (t, i) {
+        ['Title Z', 'Title C'].forEach(function(t, i) {
           if (posts[i]) {
             test.equal(posts[i].title, t, 'doFilterAndSortReverseTest');
           }
@@ -697,28 +697,28 @@ function testOrm(dataSource) {
 
     function doMultipleSortTest() {
       tests += 1;
-      Post.all({order: "title ASC, subject ASC"}, function (err, posts) {
+      Post.all({ order: 'title ASC, subject ASC' }, function(err, posts) {
         if (err) console.log(err);
         test.equal(posts.length, 6);
-        test.equal(posts[0].title, "Title A");
-        test.equal(posts[0].subject, "A");
-        test.equal(posts[1].title, "Title A");
-        test.equal(posts[1].subject, "B");
-        test.equal(posts[5].title, "Title Z");
+        test.equal(posts[0].title, 'Title A');
+        test.equal(posts[0].subject, 'A');
+        test.equal(posts[1].title, 'Title A');
+        test.equal(posts[1].subject, 'B');
+        test.equal(posts[5].title, 'Title Z');
         finished();
       });
     }
 
     function doMultipleReverseSortTest() {
       tests += 1;
-      Post.all({order: "title ASC, subject DESC"}, function (err, posts) {
+      Post.all({ order: 'title ASC, subject DESC' }, function(err, posts) {
         if (err) console.log(err);
         test.equal(posts.length, 6);
-        test.equal(posts[0].title, "Title A");
-        test.equal(posts[0].subject, "B");
-        test.equal(posts[1].title, "Title A");
-        test.equal(posts[1].subject, "A");
-        test.equal(posts[5].title, "Title Z");
+        test.equal(posts[0].title, 'Title A');
+        test.equal(posts[0].subject, 'B');
+        test.equal(posts[1].title, 'Title A');
+        test.equal(posts[1].subject, 'A');
+        test.equal(posts[5].title, 'Title Z');
         finished();
       });
     }
@@ -877,7 +877,7 @@ function testOrm(dataSource) {
   //     }
   // });
 
-  it('should handle order clause with direction', function (test) {
+  it('should handle order clause with direction', function(test) {
     var wait = 0;
     var emails = [
       'john@hcompany.com',
@@ -886,18 +886,18 @@ function testOrm(dataSource) {
       'tin@hcompany.com',
       'mike@hcompany.com',
       'susan@hcompany.com',
-      'test@hcompany.com'
+      'test@hcompany.com',
     ];
-    User.destroyAll(function () {
-      emails.forEach(function (email) {
+    User.destroyAll(function() {
+      emails.forEach(function(email) {
         wait += 1;
-        User.create({email: email, name: 'Nick'}, done);
+        User.create({ email: email, name: 'Nick' }, done);
       });
     });
     var tests = 2;
 
     function done() {
-      process.nextTick(function () {
+      process.nextTick(function() {
         if (--wait === 0) {
           doSortTest();
           doReverseSortTest();
@@ -906,9 +906,9 @@ function testOrm(dataSource) {
     }
 
     function doSortTest() {
-      User.all({order: 'email ASC', where: {name: 'Nick'}}, function (err, users) {
+      User.all({ order: 'email ASC', where: { name: 'Nick' }}, function(err, users) {
         var _emails = emails.sort();
-        users.forEach(function (user, i) {
+        users.forEach(function(user, i) {
           test.equal(_emails[i], user.email, 'ASC sorting');
         });
         testDone();
@@ -916,9 +916,9 @@ function testOrm(dataSource) {
     }
 
     function doReverseSortTest() {
-      User.all({order: 'email DESC', where: {name: 'Nick'}}, function (err, users) {
+      User.all({ order: 'email DESC', where: { name: 'Nick' }}, function(err, users) {
         var _emails = emails.sort().reverse();
-        users.forEach(function (user, i) {
+        users.forEach(function(user, i) {
           test.equal(_emails[i], user.email, 'DESC sorting');
         });
         testDone();
@@ -930,12 +930,12 @@ function testOrm(dataSource) {
     }
   });
 
-  it('should return id in find result even after updateAttributes', function (test) {
-    Post.create(function (err, post) {
+  it('should return id in find result even after updateAttributes', function(test) {
+    Post.create(function(err, post) {
       var id = post.id;
       test.ok(post.published === false);
-      post.updateAttributes({title: 'hey', published: true}, function () {
-        Post.find(id, function (err, post) {
+      post.updateAttributes({ title: 'hey', published: true }, function() {
+        Post.find(id, function(err, post) {
           test.ok(!!post.published, 'Update boolean field');
           test.ok(post.id);
           test.done();
@@ -944,8 +944,8 @@ function testOrm(dataSource) {
     });
   });
 
-  it('should handle belongsTo correctly', function (test) {
-    var passport = new Passport({ownerId: 16});
+  it('should handle belongsTo correctly', function(test) {
+    var passport = new Passport({ ownerId: 16 });
     // sync getter
     test.equal(passport.owner(), 16);
     // sync setter
@@ -954,18 +954,18 @@ function testOrm(dataSource) {
     test.done();
   });
 
-  it('should query one record', function (test) {
+  it('should query one record', function(test) {
     test.expect(4);
-    Post.findOne(function (err, post) {
+    Post.findOne(function(err, post) {
       test.ok(post && post.id);
-      Post.findOne({ where: { title: 'hey' } }, function (err, post) {
+      Post.findOne({ where: { title: 'hey' }}, function(err, post) {
         if (err) {
           console.log(err);
           return test.done();
         }
         test.equal(post && post.constructor.modelName, 'Post');
         test.equal(post && post.title, 'hey');
-        Post.findOne({ where: { title: 'not exists' } }, function (err, post) {
+        Post.findOne({ where: { title: 'not exists' }}, function(err, post) {
           test.ok(post === null);
           test.done();
         });
@@ -1023,13 +1023,13 @@ function testOrm(dataSource) {
   // });
 
   if (dataSource.name !== 'mongoose' && dataSource.name !== 'neo4j')
-    it('should update or create record', function (test) {
+    it('should update or create record', function(test) {
       var newData = {
         id: 1,
         title: 'New title (really new)',
-        content: 'Some example content (updated)'
+        content: 'Some example content (updated)',
       };
-      Post.updateOrCreate(newData, function (err, updatedPost) {
+      Post.updateOrCreate(newData, function(err, updatedPost) {
         if (err) throw err;
         test.ok(updatedPost);
         if (!updatedPost) throw Error('No post!');
@@ -1040,7 +1040,7 @@ function testOrm(dataSource) {
         test.equal(newData.title, updatedPost.toObject().title);
         test.equal(newData.content, updatedPost.toObject().content);
 
-        Post.findById(updatedPost.id, function (err, post) {
+        Post.findById(updatedPost.id, function(err, post) {
           if (err) throw err;
           if (!post) throw Error('No post!');
           if (dataSource.name !== 'mongodb') {
@@ -1048,10 +1048,10 @@ function testOrm(dataSource) {
           }
           test.equal(newData.title, post.toObject().title);
           test.equal(newData.content, post.toObject().content);
-          Post.updateOrCreate({id: 100001, title: 'hey'}, function (err, post) {
+          Post.updateOrCreate({ id: 100001, title: 'hey' }, function(err, post) {
             if (dataSource.name !== 'mongodb') test.equal(post.id, 100001);
             test.equal(post.title, 'hey');
-            Post.findById(post.id, function (err, post) {
+            Post.findById(post.id, function(err, post) {
               if (!post) throw Error('No post!');
               test.done();
             });
@@ -1060,25 +1060,25 @@ function testOrm(dataSource) {
       });
     });
 
-  it('should work with custom setters and getters', function (test) {
+  it('should work with custom setters and getters', function(test) {
     User.dataSource.defineForeignKey('User', 'passwd');
-    User.setter.passwd = function (pass) {
+    User.setter.passwd = function(pass) {
       this._passwd = pass + 'salt';
     };
-    var u = new User({passwd: 'qwerty'});
+    var u = new User({ passwd: 'qwerty' });
     test.equal(u.passwd, 'qwertysalt');
-    u.save(function (err, user) {
-      User.findById(user.id, function (err, user) {
+    u.save(function(err, user) {
+      User.findById(user.id, function(err, user) {
         test.ok(user !== u);
         test.equal(user.passwd, 'qwertysalt');
-        User.all({where: {passwd: 'qwertysalt'}}, function (err, users) {
+        User.all({ where: { passwd: 'qwertysalt' }}, function(err, users) {
           test.ok(users[0] !== user);
           test.equal(users[0].passwd, 'qwertysalt');
-          User.create({passwd: 'asalat'}, function (err, usr) {
+          User.create({ passwd: 'asalat' }, function(err, usr) {
             test.equal(usr.passwd, 'asalatsalt');
-            User.upsert({passwd: 'heyman'}, function (err, us) {
+            User.upsert({ passwd: 'heyman' }, function(err, us) {
               test.equal(us.passwd, 'heymansalt');
-              User.findById(us.id, function (err, user) {
+              User.findById(us.id, function(err, user) {
                 test.equal(user.passwd, 'heymansalt');
                 test.done();
               });
@@ -1089,18 +1089,18 @@ function testOrm(dataSource) {
     });
   });
 
-  it('should work with typed and untyped nested collections', function (test) {
+  it('should work with typed and untyped nested collections', function(test) {
     var post = new Post;
-    var like = post.likes.push({foo: 'bar'});
+    var like = post.likes.push({ foo: 'bar' });
     test.equal(like.constructor.name, 'ListItem');
-    var related = post.related.push({hello: 'world'});
+    var related = post.related.push({ hello: 'world' });
     test.ok(related.someMethod);
-    post.save(function (err, p) {
+    post.save(function(err, p) {
       test.equal(p.likes.nextid, 2);
-      p.likes.push({second: 2});
-      p.likes.push({third: 3});
-      p.save(function (err) {
-        Post.findById(p.id, function (err, pp) {
+      p.likes.push({ second: 2 });
+      p.likes.push({ third: 3 });
+      p.save(function(err) {
+        Post.findById(p.id, function(err, pp) {
           test.equal(pp.likes.length, 3);
           test.ok(pp.likes[3].third);
           test.ok(pp.likes[2].second);
@@ -1112,8 +1112,8 @@ function testOrm(dataSource) {
           test.equal(pp.likes.length, 1);
           test.ok(!pp.likes[1]);
           test.ok(pp.likes[3]);
-          pp.save(function () {
-            Post.findById(p.id, function (err, pp) {
+          pp.save(function() {
+            Post.findById(p.id, function(err, pp) {
               test.equal(pp.likes.length, 1);
               test.ok(!pp.likes[1]);
               test.ok(pp.likes[3]);
@@ -1125,13 +1125,13 @@ function testOrm(dataSource) {
     });
   });
 
-  it('should find or create', function (test) {
+  it('should find or create', function(test) {
     var email = 'some email ' + Math.random();
-    User.findOrCreate({where: {email: email}}, function (err, u, created) {
+    User.findOrCreate({ where: { email: email }}, function(err, u, created) {
       test.ok(u);
       test.ok(!u.age);
       test.ok(created);
-      User.findOrCreate({where: {email: email}}, {age: 21}, function (err, u2, created) {
+      User.findOrCreate({ where: { email: email }}, { age: 21 }, function(err, u2, created) {
         test.equals(u.id.toString(), u2.id.toString(), 'Same user ids');
         test.ok(!u2.age);
         test.ok(!created);
diff --git a/test/crud-with-options.test.js b/test/crud-with-options.test.js
index bbe7437b..235b30f2 100644
--- a/test/crud-with-options.test.js
+++ b/test/crud-with-options.test.js
@@ -8,61 +8,61 @@ var should = require('./init.js');
 var async = require('async');
 var db, User, options, filter;
 
-describe('crud-with-options', function () {
+describe('crud-with-options', function() {
 
-  before(function (done) {
+  before(function(done) {
     db = getSchema();
     User = db.define('User', {
-      seq: {type: Number, index: true},
-      name: {type: String, index: true, sort: true},
-      email: {type: String, index: true},
-      birthday: {type: Date, index: true},
-      role: {type: String, index: true},
-      order: {type: Number, index: true, sort: true},
-      vip: {type: Boolean}
+      seq: { type: Number, index: true },
+      name: { type: String, index: true, sort: true },
+      email: { type: String, index: true },
+      birthday: { type: Date, index: true },
+      role: { type: String, index: true },
+      order: { type: Number, index: true, sort: true },
+      vip: { type: Boolean },
     });
     options = {};
-    filter = {fields: ['name', 'id']};
+    filter = { fields: ['name', 'id'] };
 
     db.automigrate(['User'], done);
 
   });
 
-  describe('findById', function () {
+  describe('findById', function() {
 
-    before(function (done) {
+    before(function(done) {
       User.destroyAll(done);
     });
 
-    it('should allow findById(id, options, cb)', function (done) {
-      User.findById(1, options, function (err, u) {
+    it('should allow findById(id, options, cb)', function(done) {
+      User.findById(1, options, function(err, u) {
         should.not.exist(u);
         should.not.exist(err);
         done();
       });
     });
 
-    it('should allow findById(id, filter, cb)', function (done) {
-      User.findById(1, filter, function (err, u) {
+    it('should allow findById(id, filter, cb)', function(done) {
+      User.findById(1, filter, function(err, u) {
         should.not.exist(u);
         should.not.exist(err);
         done();
       });
     });
 
-    it('should allow findById(id)', function () {
+    it('should allow findById(id)', function() {
       User.findById(1);
     });
 
-    it('should allow findById(id, filter)', function () {
+    it('should allow findById(id, filter)', function() {
       User.findById(1, filter);
     });
 
-    it('should allow findById(id, options)', function () {
+    it('should allow findById(id, options)', function() {
       User.findById(1, options);
     });
 
-    it('should allow findById(id, filter, options)', function () {
+    it('should allow findById(id, filter, options)', function() {
       User.findById(1, filter, options);
     });
 
@@ -72,7 +72,7 @@ describe('crud-with-options', function () {
           User.findById(1, '123', function(err, u) {
           });
         }).should.throw('The filter argument must be an object');
-          done();
+        done();
       });
 
     it('should throw when invalid options are provided for findById',
@@ -95,7 +95,7 @@ describe('crud-with-options', function () {
 
     it('should allow findById(id, filter, cb) for a matching id',
       function(done) {
-        User.create({name: 'x', email: 'x@y.com'}, function(err, u) {
+        User.create({ name: 'x', email: 'x@y.com' }, function(err, u) {
           should.not.exist(err);
           should.exist(u.id);
           User.findById(u.id, filter, function(err, u) {
@@ -111,7 +111,7 @@ describe('crud-with-options', function () {
 
     it('should allow findById(id, options, cb) for a matching id',
       function(done) {
-        User.create({name: 'y', email: 'y@y.com'}, function(err, u) {
+        User.create({ name: 'y', email: 'y@y.com' }, function(err, u) {
           should.not.exist(err);
           should.exist(u.id);
           User.findById(u.id, options, function(err, u) {
@@ -127,7 +127,7 @@ describe('crud-with-options', function () {
 
     it('should allow findById(id, filter, options, cb) for a matching id',
       function(done) {
-        User.create({name: 'z', email: 'z@y.com'}, function(err, u) {
+        User.create({ name: 'z', email: 'z@y.com' }, function(err, u) {
           should.not.exist(err);
           should.exist(u.id);
           User.findById(u.id, filter, options, function(err, u) {
@@ -143,7 +143,7 @@ describe('crud-with-options', function () {
 
     it('should allow promise-style findById',
       function(done) {
-        User.create({name: 'w', email: 'w@y.com'}).then(function(u) {
+        User.create({ name: 'w', email: 'w@y.com' }).then(function(u) {
           should.exist(u.id);
           return User.findById(u.id).then(function(u) {
             should.exist(u);
@@ -189,7 +189,7 @@ describe('crud-with-options', function () {
 
   });
 
-  describe('findByIds', function () {
+  describe('findByIds', function() {
 
     before(function(done) {
       var people = [
@@ -198,7 +198,7 @@ describe('crud-with-options', function () {
         { id: 3, name: 'c' },
         { id: 4, name: 'd', vip: true },
         { id: 5, name: 'e' },
-        { id: 6, name: 'f' }
+        { id: 6, name: 'f' },
       ];
       // Use automigrate so that serial keys are 1-6
       db.automigrate(['User'], function(err) {
@@ -208,8 +208,8 @@ describe('crud-with-options', function () {
       });
     });
 
-    it('should allow findByIds(ids, cb)', function (done) {
-      User.findByIds([3, 2, 1], function (err, users) {
+    it('should allow findByIds(ids, cb)', function(done) {
+      User.findByIds([3, 2, 1], function(err, users) {
         should.exist(users);
         should.not.exist(err);
         var names = users.map(function(u) { return u.name; });
@@ -221,7 +221,7 @@ describe('crud-with-options', function () {
     it('should allow findByIds(ids, filter, options, cb)',
       function(done) {
         User.findByIds([4, 3, 2, 1],
-          { where: { vip: true } }, options, function(err, users) {
+          { where: { vip: true }}, options, function(err, users) {
             should.exist(users);
             should.not.exist(err);
             var names = users.map(function(u) {
@@ -234,7 +234,7 @@ describe('crud-with-options', function () {
 
   });
 
-  describe('find', function () {
+  describe('find', function() {
 
     before(seed);
 
@@ -248,7 +248,7 @@ describe('crud-with-options', function () {
     });
 
     it('should allow find(filter, cb)', function(done) {
-      User.find({limit: 3}, function(err, users) {
+      User.find({ limit: 3 }, function(err, users) {
         should.exists(users);
         should.not.exists(err);
         users.should.have.lengthOf(3);
@@ -266,15 +266,15 @@ describe('crud-with-options', function () {
     });
 
     it('should allow find(filter, options)', function() {
-      User.find({limit: 3}, options);
+      User.find({ limit: 3 }, options);
     });
 
     it('should allow find(filter)', function() {
-      User.find({limit: 3});
+      User.find({ limit: 3 });
     });
 
     it('should skip trailing undefined args', function(done) {
-      User.find({limit: 3}, function(err, users) {
+      User.find({ limit: 3 }, function(err, users) {
         should.exists(users);
         should.not.exists(err);
         users.should.have.lengthOf(3);
@@ -292,7 +292,7 @@ describe('crud-with-options', function () {
 
     it('should throw on an invalid options arg', function() {
       (function() {
-        User.find({limit: 3}, 'invalid option', function(err, users) {
+        User.find({ limit: 3 }, 'invalid option', function(err, users) {
           // noop
         });
       }).should.throw('The options argument must be an object');
@@ -300,18 +300,18 @@ describe('crud-with-options', function () {
 
     it('should throw on an invalid cb arg', function() {
       (function() {
-        User.find({limit: 3}, {}, 'invalid cb');
+        User.find({ limit: 3 }, {}, 'invalid cb');
       }).should.throw('The cb argument must be a function');
     });
 
   });
 
-  describe('count', function () {
+  describe('count', function() {
 
     before(seed);
 
-    it('should allow count(cb)', function (done) {
-      User.count(function (err, n) {
+    it('should allow count(cb)', function(done) {
+      User.count(function(err, n) {
         should.not.exist(err);
         should.exist(n);
         n.should.equal(6);
@@ -319,8 +319,8 @@ describe('crud-with-options', function () {
       });
     });
 
-    it('should allow count(where, cb)', function (done) {
-      User.count({role: 'lead'}, function (err, n) {
+    it('should allow count(where, cb)', function(done) {
+      User.count({ role: 'lead' }, function(err, n) {
         should.not.exist(err);
         should.exist(n);
         n.should.equal(2);
@@ -328,8 +328,8 @@ describe('crud-with-options', function () {
       });
     });
 
-    it('should allow count(where, options, cb)', function (done) {
-      User.count({role: 'lead'}, options, function (err, n) {
+    it('should allow count(where, options, cb)', function(done) {
+      User.count({ role: 'lead' }, options, function(err, n) {
         should.not.exist(err);
         should.exist(n);
         n.should.equal(2);
@@ -339,13 +339,13 @@ describe('crud-with-options', function () {
 
   });
 
-  describe('findOne', function () {
+  describe('findOne', function() {
 
     before(seed);
 
-    it('should allow findOne(cb)', function (done) {
-      User.find({order: 'id'}, function (err, users) {
-        User.findOne(function (e, u) {
+    it('should allow findOne(cb)', function(done) {
+      User.find({ order: 'id' }, function(err, users) {
+        User.findOne(function(e, u) {
           should.not.exist(e);
           should.exist(u);
           u.id.toString().should.equal(users[0].id.toString());
@@ -354,8 +354,8 @@ describe('crud-with-options', function () {
       });
     });
 
-    it('should allow findOne(filter, options, cb)', function (done) {
-      User.findOne({order: 'order'}, options, function (e, u) {
+    it('should allow findOne(filter, options, cb)', function(done) {
+      User.findOne({ order: 'order' }, options, function(e, u) {
         should.not.exist(e);
         should.exist(u);
         u.order.should.equal(1);
@@ -364,8 +364,8 @@ describe('crud-with-options', function () {
       });
     });
 
-    it('should allow findOne(filter, cb)', function (done) {
-      User.findOne({order: 'order'}, function (e, u) {
+    it('should allow findOne(filter, cb)', function(done) {
+      User.findOne({ order: 'order' }, function(e, u) {
         should.not.exist(e);
         should.exist(u);
         u.order.should.equal(1);
@@ -374,8 +374,8 @@ describe('crud-with-options', function () {
       });
     });
 
-    it('should allow trailing undefined args', function (done) {
-      User.findOne({order: 'order'}, function (e, u) {
+    it('should allow trailing undefined args', function(done) {
+      User.findOne({ order: 'order' }, function(e, u) {
         should.not.exist(e);
         should.exist(u);
         u.order.should.equal(1);
@@ -386,13 +386,13 @@ describe('crud-with-options', function () {
 
   });
 
-  describe('exists', function () {
+  describe('exists', function() {
 
     before(seed);
 
-    it('should allow exists(id, cb)', function (done) {
-      User.findOne(function (e, u) {
-        User.exists(u.id, function (err, exists) {
+    it('should allow exists(id, cb)', function(done) {
+      User.findOne(function(e, u) {
+        User.exists(u.id, function(err, exists) {
           should.not.exist(err);
           should.exist(exists);
           exists.should.be.ok;
@@ -401,9 +401,9 @@ describe('crud-with-options', function () {
       });
     });
 
-    it('should allow exists(id, options, cb)', function (done) {
-      User.destroyAll(function () {
-        User.exists(42, options, function (err, exists) {
+    it('should allow exists(id, options, cb)', function(done) {
+      User.destroyAll(function() {
+        User.exists(42, options, function(err, exists) {
           should.not.exist(err);
           exists.should.not.be.ok;
           done();
@@ -413,9 +413,9 @@ describe('crud-with-options', function () {
 
   });
 
-  describe('save', function () {
+  describe('save', function() {
 
-    it('should allow save(options, cb)', function (done) {
+    it('should allow save(options, cb)', function(done) {
       var options = { foo: 'bar' };
       var opts;
 
@@ -434,17 +434,17 @@ describe('crud-with-options', function () {
 
   });
 
-  describe('destroyAll with options', function () {
+  describe('destroyAll with options', function() {
 
     beforeEach(seed);
 
-    it('should allow destroyAll(where, options, cb)', function (done) {
-      User.destroyAll({name: 'John Lennon'}, options, function (err) {
+    it('should allow destroyAll(where, options, cb)', function(done) {
+      User.destroyAll({ name: 'John Lennon' }, options, function(err) {
         should.not.exist(err);
-        User.find({where: {name: 'John Lennon'}}, function (err, data) {
+        User.find({ where: { name: 'John Lennon' }}, function(err, data) {
           should.not.exist(err);
           data.length.should.equal(0);
-          User.find({where: {name: 'Paul McCartney'}}, function (err, data) {
+          User.find({ where: { name: 'Paul McCartney' }}, function(err, data) {
             should.not.exist(err);
             data.length.should.equal(1);
             done();
@@ -453,13 +453,13 @@ describe('crud-with-options', function () {
       });
     });
 
-    it('should allow destroyAll(where, cb)', function (done) {
-      User.destroyAll({name: 'John Lennon'}, function (err) {
+    it('should allow destroyAll(where, cb)', function(done) {
+      User.destroyAll({ name: 'John Lennon' }, function(err) {
         should.not.exist(err);
-        User.find({where: {name: 'John Lennon'}}, function (err, data) {
+        User.find({ where: { name: 'John Lennon' }}, function(err, data) {
           should.not.exist(err);
           data.length.should.equal(0);
-          User.find({where: {name: 'Paul McCartney'}}, function (err, data) {
+          User.find({ where: { name: 'Paul McCartney' }}, function(err, data) {
             should.not.exist(err);
             data.length.should.equal(1);
             done();
@@ -468,13 +468,13 @@ describe('crud-with-options', function () {
       });
     });
 
-    it('should allow destroyAll(cb)', function (done) {
-      User.destroyAll(function (err) {
+    it('should allow destroyAll(cb)', function(done) {
+      User.destroyAll(function(err) {
         should.not.exist(err);
-        User.find({where: {name: 'John Lennon'}}, function (err, data) {
+        User.find({ where: { name: 'John Lennon' }}, function(err, data) {
           should.not.exist(err);
           data.length.should.equal(0);
-          User.find({where: {name: 'Paul McCartney'}}, function (err, data) {
+          User.find({ where: { name: 'Paul McCartney' }}, function(err, data) {
             should.not.exist(err);
             data.length.should.equal(0);
             done();
@@ -485,17 +485,17 @@ describe('crud-with-options', function () {
 
   });
 
-  describe('updateAll ', function () {
+  describe('updateAll ', function() {
 
     beforeEach(seed);
 
-    it('should allow updateAll(where, data, cb)', function (done) {
-      User.update({name: 'John Lennon'}, {name: 'John Smith'}, function (err) {
+    it('should allow updateAll(where, data, cb)', function(done) {
+      User.update({ name: 'John Lennon' }, { name: 'John Smith' }, function(err) {
         should.not.exist(err);
-        User.find({where: {name: 'John Lennon'}}, function (err, data) {
+        User.find({ where: { name: 'John Lennon' }}, function(err, data) {
           should.not.exist(err);
           data.length.should.equal(0);
-          User.find({where: {name: 'John Smith'}}, function (err, data) {
+          User.find({ where: { name: 'John Smith' }}, function(err, data) {
             should.not.exist(err);
             data.length.should.equal(1);
             done();
@@ -505,13 +505,13 @@ describe('crud-with-options', function () {
     });
 
     it('should allow updateAll(where, data, options, cb)', function(done) {
-      User.update({name: 'John Lennon'}, {name: 'John Smith'}, options,
+      User.update({ name: 'John Lennon' }, { name: 'John Smith' }, options,
         function(err) {
           should.not.exist(err);
-          User.find({where: {name: 'John Lennon'}}, function(err, data) {
+          User.find({ where: { name: 'John Lennon' }}, function(err, data) {
             should.not.exist(err);
             data.length.should.equal(0);
-            User.find({where: {name: 'John Smith'}}, function(err, data) {
+            User.find({ where: { name: 'John Smith' }}, function(err, data) {
               should.not.exist(err);
               data.length.should.equal(1);
               done();
@@ -520,12 +520,12 @@ describe('crud-with-options', function () {
         });
     });
 
-    it('should allow updateAll(data, cb)', function (done) {
-      User.update({name: 'John Smith'}, function () {
-        User.find({where: {name: 'John Lennon'}}, function (err, data) {
+    it('should allow updateAll(data, cb)', function(done) {
+      User.update({ name: 'John Smith' }, function() {
+        User.find({ where: { name: 'John Lennon' }}, function(err, data) {
           should.not.exist(err);
           data.length.should.equal(0);
-          User.find({where: {name: 'John Smith'}}, function (err, data) {
+          User.find({ where: { name: 'John Smith' }}, function(err, data) {
             should.not.exist(err);
             data.length.should.equal(6);
             done();
@@ -547,7 +547,7 @@ function seed(done) {
       role: 'lead',
       birthday: new Date('1980-12-08'),
       order: 2,
-      vip: true
+      vip: true,
     },
     {
       seq: 1,
@@ -556,18 +556,18 @@ function seed(done) {
       role: 'lead',
       birthday: new Date('1942-06-18'),
       order: 1,
-      vip: true
+      vip: true,
     },
-    {seq: 2, name: 'George Harrison', order: 5, vip: false},
-    {seq: 3, name: 'Ringo Starr', order: 6, vip: false},
-    {seq: 4, name: 'Pete Best', order: 4},
-    {seq: 5, name: 'Stuart Sutcliffe', order: 3, vip: true}
+    { seq: 2, name: 'George Harrison', order: 5, vip: false },
+    { seq: 3, name: 'Ringo Starr', order: 6, vip: false },
+    { seq: 4, name: 'Pete Best', order: 4 },
+    { seq: 5, name: 'Stuart Sutcliffe', order: 3, vip: true },
   ];
 
   async.series([
     User.destroyAll.bind(User),
     function(cb) {
       async.each(beatles, User.create.bind(User), cb);
-    }
+    },
   ], done);
 }
diff --git a/test/datasource.test.js b/test/datasource.test.js
index 5e610c73..802c422e 100644
--- a/test/datasource.test.js
+++ b/test/datasource.test.js
@@ -19,7 +19,7 @@ describe('DataSource', function() {
       // this is what LoopBack does
       return new DataSource({
         name: 'dsname',
-        connector: throwingConnector
+        connector: throwingConnector,
       });
     }).should.throw(/loopback-connector-throwing/);
   });
diff --git a/test/datatype.test.js b/test/datatype.test.js
index 52e59a35..b2e2f9dd 100644
--- a/test/datatype.test.js
+++ b/test/datatype.test.js
@@ -8,9 +8,9 @@ var should = require('./init.js');
 
 var db, Model;
 
-describe('datatypes', function () {
+describe('datatypes', function() {
 
-  before(function (done) {
+  before(function(done) {
     db = getSchema();
     Nested = db.define('Nested', {});
 
@@ -19,45 +19,45 @@ describe('datatypes', function () {
       date: Date,
       num: Number,
       bool: Boolean,
-      list: {type: [String]},
+      list: { type: [String] },
       arr: Array,
-      nested: Nested
+      nested: Nested,
     });
     db.automigrate(['Model'], done);
   });
 
   it('should return 400 when property of type array is set to string value',
-    function (done) {
+    function(done) {
       var myModel = db.define('myModel', {
-        list: { type: ['object'] }
+        list: { type: ['object'] },
       });
 
-      (function(){
+      (function() {
         myModel.create({ list: 'This string will crash the server' });
       }).should.throw({ statusCode: 400 });
 
       done();
-  });
+    });
 
   it('should return 400 when property of type array is set to object value',
-    function (done) {
+    function(done) {
       var myModel = db.define('myModel', {
-        list: { type: ['object'] }
+        list: { type: ['object'] },
       });
 
-      (function(){
-        myModel.create({ list: { key: 'This string will crash the server' } });
+      (function() {
+        myModel.create({ list: { key: 'This string will crash the server' }});
       }).should.throw({ statusCode: 400 });
 
       done();
-  });
+    });
 
-  it('should keep types when get read data from db', function (done) {
+  it('should keep types when get read data from db', function(done) {
     var d = new Date, id;
 
     Model.create({
-      str: 'hello', date: d, num: '3', bool: 1, list: ['test'], arr: [1, 'str']
-    }, function (err, m) {
+      str: 'hello', date: d, num: '3', bool: 1, list: ['test'], arr: [1, 'str'],
+    }, function(err, m) {
       should.not.exists(err);
       should.exist(m && m.id);
       m.str.should.be.type('string');
@@ -71,7 +71,7 @@ describe('datatypes', function () {
     });
 
     function testFind(next) {
-      Model.findById(id, function (err, m) {
+      Model.findById(id, function(err, m) {
         should.not.exist(err);
         should.exist(m);
         m.str.should.be.type('string');
@@ -87,7 +87,7 @@ describe('datatypes', function () {
     }
 
     function testAll() {
-      Model.findOne(function (err, m) {
+      Model.findOne(function(err, m) {
         should.not.exist(err);
         should.exist(m);
         m.str.should.be.type('string');
@@ -101,11 +101,11 @@ describe('datatypes', function () {
 
   });
 
-  it('should respect data types when updating attributes', function (done) {
+  it('should respect data types when updating attributes', function(done) {
     var d = new Date, id;
 
     Model.create({
-      str: 'hello', date: d, num: '3', bool: 1}, function(err, m) {
+      str: 'hello', date: d, num: '3', bool: 1 }, function(err, m) {
       should.not.exist(err);
       should.exist(m && m.id);
 
@@ -114,7 +114,7 @@ describe('datatypes', function () {
       m.num.should.be.type('number');
       m.bool.should.be.type('boolean');
       id = m.id;
-      testDataInDB(function () {
+      testDataInDB(function() {
         testUpdate(function() {
           testDataInDB(done);
         });
@@ -127,8 +127,8 @@ describe('datatypes', function () {
 
         // update using updateAttributes
         m.updateAttributes({
-          id: m.id, num: '10'
-        }, function (err, m) {
+          id: m.id, num: '10',
+        }, function(err, m) {
           should.not.exist(err);
           m.num.should.be.type('number');
           done();
@@ -154,18 +154,18 @@ describe('datatypes', function () {
   });
 
   it('should not coerce nested objects into ModelConstructor types', function() {
-      var coerced = Model._coerce({ nested: { foo: 'bar' } });
-      coerced.nested.constructor.name.should.equal('Object');
+    var coerced = Model._coerce({ nested: { foo: 'bar' }});
+    coerced.nested.constructor.name.should.equal('Object');
   });
 
   it('rejects array value converted to NaN for a required property',
   function(done) {
     db = getSchema();
     Model = db.define('RequiredNumber', {
-      num: { type: Number, required: true }
+      num: { type: Number, required: true },
     });
-    db.automigrate(['Model'], function () {
-      Model.create({ num: [1,2,3] }, function(err, inst) {
+    db.automigrate(['Model'], function() {
+      Model.create({ num: [1, 2, 3] }, function(err, inst) {
         should.exist(err);
         err.should.have.property('name').equal('ValidationError');
         done();
@@ -180,10 +180,10 @@ describe('datatypes', function () {
         'TestModel',
         {
           desc: { type: String, required: false },
-          stars: { type: Number, required: false }
+          stars: { type: Number, required: false },
         },
         {
-          persistUndefinedAsNull: true
+          persistUndefinedAsNull: true,
         });
 
       isStrict = TestModel.definition.settings.strict;
@@ -212,7 +212,7 @@ describe('datatypes', function () {
         delete EXPECTED.extra;
       }
 
-      var data ={ desc: undefined, extra: undefined };
+      var data = { desc: undefined, extra: undefined };
       TestModel.create(data, function(err, created) {
         if (err) return done(err);
 
@@ -271,14 +271,14 @@ describe('datatypes', function () {
           if (TestModel.dataSource.connector.all.length === 4) {
             TestModel.dataSource.connector.all(
               TestModel.modelName,
-              {where: {id: created.id}},
+              { where: { id: created.id }},
               {},
               cb
             );
           } else {
             TestModel.dataSource.connector.all(
               TestModel.modelName,
-              {where: {id: created.id}},
+              { where: { id: created.id }},
               cb
             );
           }
@@ -294,7 +294,7 @@ describe('datatypes', function () {
       inst.__data.dx = undefined;
 
       inst.toObject(false).should.have.properties({
-       desc: null, stars: null, extra: null, dx: null
+        desc: null, stars: null, extra: null, dx: null,
       });
     });
   });
diff --git a/test/default-scope.test.js b/test/default-scope.test.js
index 1390cb1a..7e6ae1e7 100644
--- a/test/default-scope.test.js
+++ b/test/default-scope.test.js
@@ -18,108 +18,108 @@ var db, Category, Product, Tool, Widget, Thing, Person;
 var setupProducts = function(ids, done) {
   async.series([
     function(next) {
-      Tool.create({name: 'Tool Z'}, function(err, inst) {
+      Tool.create({ name: 'Tool Z' }, function(err, inst) {
         ids.toolZ = inst.id;
         next();
       });
     },
     function(next) {
-      Widget.create({name: 'Widget Z'}, function(err, inst) {
+      Widget.create({ name: 'Widget Z' }, function(err, inst) {
         ids.widgetZ = inst.id;
         next();
       });
     },
     function(next) {
-      Tool.create({name: 'Tool A', active: false}, function(err, inst) {
+      Tool.create({ name: 'Tool A', active: false }, function(err, inst) {
         ids.toolA = inst.id;
         next();
       });
     },
     function(next) {
-      Widget.create({name: 'Widget A'}, function(err, inst) {
+      Widget.create({ name: 'Widget A' }, function(err, inst) {
         ids.widgetA = inst.id;
         next();
       });
     },
     function(next) {
-      Widget.create({name: 'Widget B', active: false}, function(err, inst) {
+      Widget.create({ name: 'Widget B', active: false }, function(err, inst) {
         ids.widgetB = inst.id;
         next();
       });
-    }
+    },
   ], done);
 };
 
-describe('default scope', function () {
-  
-  before(function (done) {
+describe('default scope', function() {
+
+  before(function(done) {
     db = getSchema();
-    
+
     Category = db.define('Category', {
-      name: String
+      name: String,
     });
 
     Product = db.define('Product', {
       name: String,
       kind: String,
       description: String,
-      active: { type: Boolean, default: true }
+      active: { type: Boolean, default: true },
     }, {
       scope: { order: 'name' },
-      scopes: { active: { where: { active: true } } }
+      scopes: { active: { where: { active: true }}},
     });
-    
+
     Product.lookupModel = function(data) {
       var m = this.dataSource.models[data.kind];
       if (m.base === this) return m;
       return this;
     };
-    
+
     Tool = db.define('Tool', Product.definition.properties, {
-        base: 'Product',
-        scope: { where: { kind: 'Tool' }, order: 'name' },
-        scopes: { active: { where: { active: true } } },
-        mongodb: { collection: 'Product' },
-        memory: { collection: 'Product' }
+      base: 'Product',
+      scope: { where: { kind: 'Tool' }, order: 'name' },
+      scopes: { active: { where: { active: true }}},
+      mongodb: { collection: 'Product' },
+      memory: { collection: 'Product' },
     });
-    
+
     Widget = db.define('Widget', Product.definition.properties, {
-        base: 'Product',
-        properties: { kind: 'Widget' },
-        scope: { where: { kind: 'Widget' }, order: 'name' },
-        scopes: { active: { where: { active: true } } },
-        mongodb: { collection: 'Product' },
-        memory: { collection: 'Product' }
+      base: 'Product',
+      properties: { kind: 'Widget' },
+      scope: { where: { kind: 'Widget' }, order: 'name' },
+      scopes: { active: { where: { active: true }}},
+      mongodb: { collection: 'Product' },
+      memory: { collection: 'Product' },
     });
 
     Person = db.define('Person', { name: String }, {
-      scope: { include: 'things' }
+      scope: { include: 'things' },
     });
-    
+
     // inst is only valid for instance methods
     // like save, updateAttributes
-    
+
     var scopeFn = function(target, inst) {
-      return { where: { kind: this.modelName } };
+      return { where: { kind: this.modelName }};
     };
-    
+
     var propertiesFn = function(target, inst) {
       return { kind: this.modelName };
     };
-    
+
     Thing = db.define('Thing', Product.definition.properties, {
-        base: 'Product',
-        attributes: propertiesFn,
-        scope: scopeFn,
-        mongodb: { collection: 'Product' },
-        memory: { collection: 'Product' }
+      base: 'Product',
+      attributes: propertiesFn,
+      scope: scopeFn,
+      mongodb: { collection: 'Product' },
+      memory: { collection: 'Product' },
     });
-    
+
     Category.hasMany(Product);
-    Category.hasMany(Tool, {scope: {order: 'name DESC'}});
+    Category.hasMany(Tool, { scope: { order: 'name DESC' }});
     Category.hasMany(Widget);
     Category.hasMany(Thing);
-    
+
     Product.belongsTo(Category);
     Tool.belongsTo(Category);
     Widget.belongsTo(Category);
@@ -127,31 +127,31 @@ describe('default scope', function () {
 
     Person.hasMany(Thing);
     Thing.belongsTo(Person);
-    
+
     db.automigrate(done);
   });
-  
+
   describe('manipulation', function() {
-    
+
     var ids = {};
-    
+
     before(function(done) {
       db.automigrate(done);
     });
-    
+
     it('should return a scoped instance', function() {
-      var p = new Tool({name: 'Product A', kind:'ignored'});
+      var p = new Tool({ name: 'Product A', kind:'ignored' });
       p.name.should.equal('Product A');
       p.kind.should.equal('Tool');
       p.setAttributes({ kind: 'ignored' });
       p.kind.should.equal('Tool');
-      
+
       p.setAttribute('kind', 'other'); // currently not enforced
       p.kind.should.equal('other');
     });
-    
+
     it('should create a scoped instance - tool', function(done) {
-      Tool.create({name: 'Product A', kind: 'ignored'}, function(err, p) {
+      Tool.create({ name: 'Product A', kind: 'ignored' }, function(err, p) {
         should.not.exist(err);
         p.name.should.equal('Product A');
         p.kind.should.equal('Tool');
@@ -159,9 +159,9 @@ describe('default scope', function () {
         done();
       });
     });
-    
+
     it('should create a scoped instance - widget', function(done) {
-      Widget.create({name: 'Product B', kind: 'ignored'}, function(err, p) {
+      Widget.create({ name: 'Product B', kind: 'ignored' }, function(err, p) {
         should.not.exist(err);
         p.name.should.equal('Product B');
         p.kind.should.equal('Widget');
@@ -169,10 +169,10 @@ describe('default scope', function () {
         done();
       });
     });
-  
+
     it('should update a scoped instance - updateAttributes', function(done) {
       Tool.findById(ids.productA, function(err, p) {
-        p.updateAttributes({description: 'A thing...', kind: 'ingored'}, function(err, inst) {
+        p.updateAttributes({ description: 'A thing...', kind: 'ingored' }, function(err, inst) {
           should.not.exist(err);
           p.name.should.equal('Product A');
           p.kind.should.equal('Tool');
@@ -181,7 +181,7 @@ describe('default scope', function () {
         });
       });
     });
-  
+
     it('should update a scoped instance - save', function(done) {
       Tool.findById(ids.productA, function(err, p) {
         p.description = 'Something...';
@@ -198,28 +198,28 @@ describe('default scope', function () {
         });
       });
     });
-  
+
     it('should update a scoped instance - updateOrCreate', function(done) {
-      var data = {id: ids.productA, description: 'Anything...', kind: 'ingored'};
+      var data = { id: ids.productA, description: 'Anything...', kind: 'ingored' };
       Tool.updateOrCreate(data, function(err, p) {
-          should.not.exist(err);
-          p.name.should.equal('Product A');
-          p.kind.should.equal('Tool');
-          p.description.should.equal('Anything...');
-          done();
+        should.not.exist(err);
+        p.name.should.equal('Product A');
+        p.kind.should.equal('Tool');
+        p.description.should.equal('Anything...');
+        done();
       });
     });
-  
+
   });
-  
+
   describe('findById', function() {
-    
+
     var ids = {};
-    
-    before(function (done) {
+
+    before(function(done) {
       db.automigrate(setupProducts.bind(null, ids, done));
     });
-    
+
     it('should apply default scope', function(done) {
       Product.findById(ids.toolA, function(err, inst) {
         should.not.exist(err);
@@ -228,7 +228,7 @@ describe('default scope', function () {
         done();
       });
     });
-    
+
     it('should apply default scope - tool', function(done) {
       Tool.findById(ids.toolA, function(err, inst) {
         should.not.exist(err);
@@ -236,7 +236,7 @@ describe('default scope', function () {
         done();
       });
     });
-    
+
     it('should apply default scope (no match)', function(done) {
       Widget.findById(ids.toolA, function(err, inst) {
         should.not.exist(err);
@@ -244,17 +244,17 @@ describe('default scope', function () {
         done();
       });
     });
-    
+
   });
-  
+
   describe('find', function() {
-    
+
     var ids = {};
-    
-    before(function (done) {
+
+    before(function(done) {
       db.automigrate(setupProducts.bind(null, ids, done));
     });
-    
+
     it('should apply default scope - order', function(done) {
       Product.find(function(err, products) {
         should.not.exist(err);
@@ -264,17 +264,17 @@ describe('default scope', function () {
         products[2].name.should.equal('Widget A');
         products[3].name.should.equal('Widget B');
         products[4].name.should.equal('Widget Z');
-        
+
         products[0].should.be.instanceof(Product);
         products[0].should.be.instanceof(Tool);
-        
+
         products[2].should.be.instanceof(Product);
         products[2].should.be.instanceof(Widget);
-        
+
         done();
       });
     });
-    
+
     it('should apply default scope - order override', function(done) {
       Product.find({ order: 'name DESC' }, function(err, products) {
         should.not.exist(err);
@@ -287,7 +287,7 @@ describe('default scope', function () {
         done();
       });
     });
-    
+
     it('should apply default scope - tool', function(done) {
       Tool.find(function(err, products) {
         should.not.exist(err);
@@ -297,9 +297,9 @@ describe('default scope', function () {
         done();
       });
     });
-    
+
     it('should apply default scope - where (widget)', function(done) {
-      Widget.find({ where: { active: true } }, function(err, products) {
+      Widget.find({ where: { active: true }}, function(err, products) {
         should.not.exist(err);
         products.should.have.length(2);
         products[0].name.should.equal('Widget A');
@@ -307,7 +307,7 @@ describe('default scope', function () {
         done();
       });
     });
-    
+
     it('should apply default scope - order (widget)', function(done) {
       Widget.find({ order: 'name DESC' }, function(err, products) {
         should.not.exist(err);
@@ -318,17 +318,17 @@ describe('default scope', function () {
         done();
       });
     });
-  
+
   });
-  
+
   describe('exists', function() {
-    
+
     var ids = {};
-    
-    before(function (done) {
+
+    before(function(done) {
       db.automigrate(setupProducts.bind(null, ids, done));
     });
-    
+
     it('should apply default scope', function(done) {
       Product.exists(ids.widgetA, function(err, exists) {
         should.not.exist(err);
@@ -336,7 +336,7 @@ describe('default scope', function () {
         done();
       });
     });
-    
+
     it('should apply default scope - tool', function(done) {
       Tool.exists(ids.toolZ, function(err, exists) {
         should.not.exist(err);
@@ -344,7 +344,7 @@ describe('default scope', function () {
         done();
       });
     });
-    
+
     it('should apply default scope - widget', function(done) {
       Widget.exists(ids.widgetA, function(err, exists) {
         should.not.exist(err);
@@ -352,7 +352,7 @@ describe('default scope', function () {
         done();
       });
     });
-    
+
     it('should apply default scope - tool (no match)', function(done) {
       Tool.exists(ids.widgetA, function(err, exists) {
         should.not.exist(err);
@@ -360,7 +360,7 @@ describe('default scope', function () {
         done();
       });
     });
-    
+
     it('should apply default scope - widget (no match)', function(done) {
       Widget.exists(ids.toolZ, function(err, exists) {
         should.not.exist(err);
@@ -368,17 +368,17 @@ describe('default scope', function () {
         done();
       });
     });
-  
+
   });
-  
+
   describe('count', function() {
-    
+
     var ids = {};
-    
-    before(function (done) {
+
+    before(function(done) {
       db.automigrate(setupProducts.bind(null, ids, done));
     });
-    
+
     it('should apply default scope - order', function(done) {
       Product.count(function(err, count) {
         should.not.exist(err);
@@ -386,7 +386,7 @@ describe('default scope', function () {
         done();
       });
     });
-    
+
     it('should apply default scope - tool', function(done) {
       Tool.count(function(err, count) {
         should.not.exist(err);
@@ -394,7 +394,7 @@ describe('default scope', function () {
         done();
       });
     });
-    
+
     it('should apply default scope - widget', function(done) {
       Widget.count(function(err, count) {
         should.not.exist(err);
@@ -402,29 +402,29 @@ describe('default scope', function () {
         done();
       });
     });
-    
+
     it('should apply default scope - where', function(done) {
-      Widget.count({name: 'Widget Z'}, function(err, count) {
+      Widget.count({ name: 'Widget Z' }, function(err, count) {
         should.not.exist(err);
         count.should.equal(1);
         done();
       });
     });
-    
+
     it('should apply default scope - no match', function(done) {
-      Tool.count({name: 'Widget Z'}, function(err, count) {
+      Tool.count({ name: 'Widget Z' }, function(err, count) {
         should.not.exist(err);
         count.should.equal(0);
         done();
       });
     });
-  
+
   });
-  
+
   describe('removeById', function() {
-    
+
     var ids = {};
-    
+
     function isDeleted(id, done) {
       Product.exists(id, function(err, exists) {
         should.not.exist(err);
@@ -432,25 +432,25 @@ describe('default scope', function () {
         done();
       });
     };
-    
-    before(function (done) {
+
+    before(function(done) {
       db.automigrate(setupProducts.bind(null, ids, done));
     });
-    
+
     it('should apply default scope', function(done) {
       Product.removeById(ids.widgetZ, function(err) {
         should.not.exist(err);
         isDeleted(ids.widgetZ, done);
       });
     });
-    
+
     it('should apply default scope - tool', function(done) {
       Tool.removeById(ids.toolA, function(err) {
         should.not.exist(err);
         isDeleted(ids.toolA, done);
       });
     });
-    
+
     it('should apply default scope - no match', function(done) {
       Tool.removeById(ids.widgetA, function(err) {
         should.not.exist(err);
@@ -461,14 +461,14 @@ describe('default scope', function () {
         });
       });
     });
-    
+
     it('should apply default scope - widget', function(done) {
       Widget.removeById(ids.widgetA, function(err) {
         should.not.exist(err);
         isDeleted(ids.widgetA, done);
       });
     });
-    
+
     it('should apply default scope - verify', function(done) {
       Product.find(function(err, products) {
         should.not.exist(err);
@@ -478,21 +478,21 @@ describe('default scope', function () {
         done();
       });
     });
-    
+
   });
-  
+
   describe('update', function() {
-    
+
     var ids = {};
-    
-    before(function (done) {
+
+    before(function(done) {
       db.automigrate(setupProducts.bind(null, ids, done));
     });
-    
+
     it('should apply default scope', function(done) {
-      Widget.update({active: false},{active: true, kind: 'ignored'}, function(err) {
+      Widget.update({ active: false }, { active: true, kind: 'ignored' }, function(err) {
         should.not.exist(err);
-        Widget.find({where: { active: true }}, function(err, products) {
+        Widget.find({ where: { active: true }}, function(err, products) {
           should.not.exist(err);
           products.should.have.length(3);
           products[0].name.should.equal('Widget A');
@@ -502,9 +502,9 @@ describe('default scope', function () {
         });
       });
     });
-    
+
     it('should apply default scope - no match', function(done) {
-      Tool.update({name: 'Widget A'},{name: 'Ignored'}, function(err) {
+      Tool.update({ name: 'Widget A' }, { name: 'Ignored' }, function(err) {
         should.not.exist(err);
         Product.findById(ids.widgetA, function(err, product) {
           should.not.exist(err);
@@ -513,9 +513,9 @@ describe('default scope', function () {
         });
       });
     });
-    
+
     it('should have updated within scope', function(done) {
-      Product.find({where: {active: true}}, function(err, products) {
+      Product.find({ where: { active: true }}, function(err, products) {
         should.not.exist(err);
         products.should.have.length(4);
         products[0].name.should.equal('Tool Z');
@@ -525,19 +525,19 @@ describe('default scope', function () {
         done();
       });
     });
-    
+
   });
-  
+
   describe('remove', function() {
-    
+
     var ids = {};
-    
-    before(function (done) {
+
+    before(function(done) {
       db.automigrate(setupProducts.bind(null, ids, done));
     });
-    
+
     it('should apply default scope - custom where', function(done) {
-      Widget.remove({name: 'Widget A'}, function(err) {
+      Widget.remove({ name: 'Widget A' }, function(err) {
         should.not.exist(err);
         Product.find(function(err, products) {
           products.should.have.length(4);
@@ -549,9 +549,9 @@ describe('default scope', function () {
         });
       });
     });
-    
+
     it('should apply default scope - custom where (no match)', function(done) {
-      Tool.remove({name: 'Widget Z'}, function(err) {
+      Tool.remove({ name: 'Widget Z' }, function(err) {
         should.not.exist(err);
         Product.find(function(err, products) {
           products.should.have.length(4);
@@ -563,7 +563,7 @@ describe('default scope', function () {
         });
       });
     });
-    
+
     it('should apply default scope - deleteAll', function(done) {
       Tool.deleteAll(function(err) {
         should.not.exist(err);
@@ -575,9 +575,9 @@ describe('default scope', function () {
         });
       });
     });
-    
+
     it('should create a scoped instance - tool', function(done) {
-      Tool.create({name: 'Tool B'}, function(err, p) {
+      Tool.create({ name: 'Tool B' }, function(err, p) {
         should.not.exist(err);
         Product.find(function(err, products) {
           products.should.have.length(3);
@@ -588,7 +588,7 @@ describe('default scope', function () {
         });
       });
     });
-    
+
     it('should apply default scope - destroyAll', function(done) {
       Widget.destroyAll(function(err) {
         should.not.exist(err);
@@ -599,17 +599,17 @@ describe('default scope', function () {
         });
       });
     });
-    
+
   });
-  
+
   describe('scopes', function() {
-    
+
     var ids = {};
-    
-    before(function (done) {
+
+    before(function(done) {
       db.automigrate(setupProducts.bind(null, ids, done));
     });
-    
+
     it('should merge with default scope', function(done) {
       Product.active(function(err, products) {
         should.not.exist(err);
@@ -620,7 +620,7 @@ describe('default scope', function () {
         done();
       });
     });
-    
+
     it('should merge with default scope - tool', function(done) {
       Tool.active(function(err, products) {
         should.not.exist(err);
@@ -629,7 +629,7 @@ describe('default scope', function () {
         done();
       });
     });
-    
+
     it('should merge with default scope - widget', function(done) {
       Widget.active(function(err, products) {
         should.not.exist(err);
@@ -639,89 +639,89 @@ describe('default scope', function () {
         done();
       });
     });
-    
+
   });
-  
+
   describe('scope function', function() {
-    
+
     before(function(done) {
       db.automigrate(done);
     });
-    
+
     it('should create a scoped instance - widget', function(done) {
-      Widget.create({name: 'Product', kind:'ignored'}, function(err, p) {
+      Widget.create({ name: 'Product', kind:'ignored' }, function(err, p) {
         p.name.should.equal('Product');
         p.kind.should.equal('Widget');
         done();
       });
     });
-    
+
     it('should create a scoped instance - thing', function(done) {
-      Thing.create({name: 'Product', kind:'ignored'}, function(err, p) {
+      Thing.create({ name: 'Product', kind:'ignored' }, function(err, p) {
         p.name.should.equal('Product');
         p.kind.should.equal('Thing');
         done();
       });
     });
-    
+
     it('should find a scoped instance - widget', function(done) {
-      Widget.findOne({where: {name: 'Product'}}, function(err, p) {
+      Widget.findOne({ where: { name: 'Product' }}, function(err, p) {
         p.name.should.equal('Product');
         p.kind.should.equal('Widget');
         done();
       });
     });
-    
+
     it('should find a scoped instance - thing', function(done) {
-      Thing.findOne({where: {name: 'Product'}}, function(err, p) {
+      Thing.findOne({ where: { name: 'Product' }}, function(err, p) {
         p.name.should.equal('Product');
         p.kind.should.equal('Thing');
         done();
       });
     });
-    
+
     it('should find a scoped instance - thing', function(done) {
-      Product.find({where: {name: 'Product'}}, function(err, products) {
+      Product.find({ where: { name: 'Product' }}, function(err, products) {
         products.should.have.length(2);
         products[0].name.should.equal('Product');
         products[1].name.should.equal('Product');
-        var kinds = products.map(function(p) { return p.kind; })
+        var kinds = products.map(function(p) { return p.kind; });
         kinds.sort();
         kinds.should.eql(['Thing', 'Widget']);
         done();
       });
     });
-  
+
   });
-  
+
   describe('relations', function() {
-    
+
     var ids = {};
-    
-    before(function (done) {
+
+    before(function(done) {
       db.automigrate(done);
     });
-    
-    before(function (done) {
-      Category.create({name: 'Category A'}, function(err, cat) {
+
+    before(function(done) {
+      Category.create({ name: 'Category A' }, function(err, cat) {
         ids.categoryA = cat.id;
         async.series([
           function(next) {
-            cat.widgets.create({name: 'Widget B', kind: 'ignored'}, next);
+            cat.widgets.create({ name: 'Widget B', kind: 'ignored' }, next);
           },
           function(next) {
-            cat.widgets.create({name: 'Widget A'}, next);
+            cat.widgets.create({ name: 'Widget A' }, next);
           },
           function(next) {
-            cat.tools.create({name: 'Tool A'}, next);
+            cat.tools.create({ name: 'Tool A' }, next);
           },
           function(next) {
-            cat.things.create({name: 'Thing A'}, next);
-          }
+            cat.things.create({ name: 'Thing A' }, next);
+          },
         ], done);
       });
     });
-    
+
     it('should apply default scope - products', function(done) {
       Category.findById(ids.categoryA, function(err, cat) {
         should.not.exist(err);
@@ -732,21 +732,21 @@ describe('default scope', function () {
           products[1].name.should.equal('Tool A');
           products[2].name.should.equal('Widget A');
           products[3].name.should.equal('Widget B');
-          
+
           products[0].should.be.instanceof(Product);
           products[0].should.be.instanceof(Thing);
-          
+
           products[1].should.be.instanceof(Product);
           products[1].should.be.instanceof(Tool);
-          
+
           products[2].should.be.instanceof(Product);
           products[2].should.be.instanceof(Widget);
-          
+
           done();
         });
       });
     });
-    
+
     it('should apply default scope - widgets', function(done) {
       Category.findById(ids.categoryA, function(err, cat) {
         should.not.exist(err);
@@ -763,7 +763,7 @@ describe('default scope', function () {
         });
       });
     });
-    
+
     it('should apply default scope - tools', function(done) {
       Category.findById(ids.categoryA, function(err, cat) {
         should.not.exist(err);
@@ -779,7 +779,7 @@ describe('default scope', function () {
         });
       });
     });
-    
+
     it('should apply default scope - things', function(done) {
       Category.findById(ids.categoryA, function(err, cat) {
         should.not.exist(err);
@@ -795,13 +795,13 @@ describe('default scope', function () {
         });
       });
     });
-    
+
     it('should create related item with default scope', function(done) {
       Category.findById(ids.categoryA, function(err, cat) {
-        cat.tools.create({name: 'Tool B'}, done);
+        cat.tools.create({ name: 'Tool B' }, done);
       });
     });
-    
+
     it('should use relation scope order', function(done) {
       Category.findById(ids.categoryA, function(err, cat) {
         should.not.exist(err);
@@ -819,11 +819,11 @@ describe('default scope', function () {
 
   describe('with include option', function() {
 
-    before(function (done) {
+    before(function(done) {
       db.automigrate(done);
     });
 
-    before(function (done) {
+    before(function(done) {
       Person.create({ id: 1, name: 'Person A' }, function(err, person) {
         person.things.create({ name: 'Thing A' }, done);
       });
diff --git a/test/defaults.test.js b/test/defaults.test.js
index 6a536485..18f2829c 100644
--- a/test/defaults.test.js
+++ b/test/defaults.test.js
@@ -8,45 +8,45 @@ var should = require('./init.js');
 
 var db = getSchema();
 
-describe('defaults', function () {
+describe('defaults', function() {
   var Server;
 
-  before(function () {
+  before(function() {
     Server = db.define('Server', {
       host: String,
-      port: {type: Number, default: 80},
-      createdAt: {type: Date, default: '$now'}
+      port: { type: Number, default: 80 },
+      createdAt: { type: Date, default: '$now' },
     });
   });
 
-  it('should apply defaults on new', function () {
+  it('should apply defaults on new', function() {
     var s = new Server;
     s.port.should.equal(80);
   });
 
-  it('should apply defaults on create', function (done) {
-    Server.create(function (err, s) {
+  it('should apply defaults on create', function(done) {
+    Server.create(function(err, s) {
       s.port.should.equal(80);
       done();
     });
   });
 
-  it('should apply defaults on read', function (done) {
+  it('should apply defaults on read', function(done) {
     db.defineProperty('Server', 'host', {
       type: String,
-      default: 'localhost'
+      default: 'localhost',
     });
-    Server.all(function (err, servers) {
+    Server.all(function(err, servers) {
       (new String('localhost')).should.equal(servers[0].host);
       done();
     });
   });
 
-  it('should ignore defaults with limited fields', function (done) {
+  it('should ignore defaults with limited fields', function(done) {
     Server.create({ host: 'localhost', port: 8080 }, function(err, s) {
       should.not.exist(err);
       s.port.should.equal(8080);
-      Server.find({ fields: ['host'] }, function (err, servers) {
+      Server.find({ fields: ['host'] }, function(err, servers) {
         servers[0].host.should.equal('localhost');
         servers[0].should.have.property('host');
         servers[0].should.have.property('port', undefined);
@@ -55,17 +55,17 @@ describe('defaults', function () {
     });
   });
 
-  it('should apply defaults in upsert create', function (done) {
-    Server.upsert({port: 8181 }, function(err, server) {
+  it('should apply defaults in upsert create', function(done) {
+    Server.upsert({ port: 8181 }, function(err, server) {
       should.not.exist(err);
       should.exist(server.createdAt);
       done();
     });
   });
 
-  it('should preserve defaults in upsert update', function (done) {
+  it('should preserve defaults in upsert update', function(done) {
     Server.findOne({}, function(err, server) {
-      Server.upsert({id:server.id, port: 1337 }, function(err, s) {
+      Server.upsert({ id:server.id, port: 1337 }, function(err, s) {
         should.not.exist(err);
         (Number(1337)).should.equal(s.port);
         server.createdAt.should.eql(s.createdAt);
diff --git a/test/discovery.test.js b/test/discovery.test.js
index f28a49bb..8bc18452 100644
--- a/test/discovery.test.js
+++ b/test/discovery.test.js
@@ -11,11 +11,11 @@ describe('Memory connector with mocked discovery', function() {
   var ds;
 
   before(function() {
-    ds = new DataSource({connector: 'memory'});
+    ds = new DataSource({ connector: 'memory' });
 
-    var models = [{type: 'table', name: 'CUSTOMER', owner: 'STRONGLOOP'},
-      {type: 'table', name: 'INVENTORY', owner: 'STRONGLOOP'},
-      {type: 'table', name: 'LOCATION', owner: 'STRONGLOOP'}];
+    var models = [{ type: 'table', name: 'CUSTOMER', owner: 'STRONGLOOP' },
+      { type: 'table', name: 'INVENTORY', owner: 'STRONGLOOP' },
+      { type: 'table', name: 'LOCATION', owner: 'STRONGLOOP' }];
 
     ds.discoverModelDefinitions = function(options, cb) {
       process.nextTick(function() {
@@ -31,7 +31,7 @@ describe('Memory connector with mocked discovery', function() {
       dataLength: 20,
       dataPrecision: null,
       dataScale: null,
-      nullable: 0
+      nullable: 0,
     },
       {
         owner: 'STRONGLOOP',
@@ -41,7 +41,7 @@ describe('Memory connector with mocked discovery', function() {
         dataLength: 20,
         dataPrecision: null,
         dataScale: null,
-        nullable: 0
+        nullable: 0,
       },
       {
         owner: 'STRONGLOOP',
@@ -51,7 +51,7 @@ describe('Memory connector with mocked discovery', function() {
         dataLength: null,
         dataPrecision: 10,
         dataScale: 0,
-        nullable: 1
+        nullable: 1,
       },
       {
         owner: 'STRONGLOOP',
@@ -61,7 +61,7 @@ describe('Memory connector with mocked discovery', function() {
         dataLength: null,
         dataPrecision: 10,
         dataScale: 0,
-        nullable: 1
+        nullable: 1,
       }];
 
     ds.discoverModelProperties = function(modelName, options, cb) {
@@ -88,7 +88,7 @@ describe('Memory connector with mocked discovery', function() {
       nameMapper: function(type, name) {
         // Convert all names to lower case
         return name.toLowerCase();
-      }
+      },
     }, function(err, schemas) {
       if (err) return done(err);
       schemas.should.have.property('STRONGLOOP.INVENTORY');
@@ -102,7 +102,7 @@ describe('Memory connector with mocked discovery', function() {
 
   it('should not convert table/column names with null custom mapper',
     function(done) {
-      ds.discoverSchemas('INVENTORY', {nameMapper: null}, function(err, schemas) {
+      ds.discoverSchemas('INVENTORY', { nameMapper: null }, function(err, schemas) {
         if (err) return done(err);
         schemas.should.have.property('STRONGLOOP.INVENTORY');
         var s = schemas['STRONGLOOP.INVENTORY'];
@@ -117,16 +117,16 @@ describe('Memory connector with mocked discovery', function() {
     function(done) {
       var models = {
         inventory: {
-          product: {type: 'string'},
-          location: {type: 'string'}
-        }
+          product: { type: 'string' },
+          location: { type: 'string' },
+        },
       };
       ds.connector.discoverSchemas = function(modelName, options, cb) {
         process.nextTick(function() {
           cb(null, models);
         });
       };
-      ds.discoverSchemas('INVENTORY', {nameMapper: null}, function(err, schemas) {
+      ds.discoverSchemas('INVENTORY', { nameMapper: null }, function(err, schemas) {
         if (err) return done(err);
         schemas.should.be.eql(models);
         done();
@@ -137,9 +137,9 @@ describe('Memory connector with mocked discovery', function() {
     function(done) {
       var models = {
         inventory: {
-          product: {type: 'string'},
-          location: {type: 'string'}
-        }
+          product: { type: 'string' },
+          location: { type: 'string' },
+        },
       };
       ds.connector.discoverSchemas = function(modelName, options, cb) {
         process.nextTick(function() {
@@ -174,9 +174,9 @@ describe('Memory connector with mocked discovery', function() {
       .catch(function(err) {
         done(err);
       });
-  });
+    });
 
-  describe('discoverSchema', function(){
+  describe('discoverSchema', function() {
     var models;
     var schema;
     before(function() {
@@ -184,7 +184,7 @@ describe('Memory connector with mocked discovery', function() {
         name: 'Inventory',
         options: {
           idInjection: false,
-          memory: { schema: 'STRONGLOOP', table: 'INVENTORY' }
+          memory: { schema: 'STRONGLOOP', table: 'INVENTORY' },
         },
         properties: {
           available: {
@@ -195,12 +195,12 @@ describe('Memory connector with mocked discovery', function() {
               dataPrecision: 10,
               dataScale: 0,
               dataType: 'int',
-              nullable: 1
+              nullable: 1,
             },
             precision: 10,
             required: false,
             scale: 0,
-            type: undefined
+            type: undefined,
           },
           locationId: {
             length: 20,
@@ -210,12 +210,12 @@ describe('Memory connector with mocked discovery', function() {
               dataPrecision: null,
               dataScale: null,
               dataType: 'varchar',
-              nullable: 0
+              nullable: 0,
             },
             precision: null,
             required: true,
             scale: null,
-            type: undefined
+            type: undefined,
           },
           productId: {
             length: 20,
@@ -225,12 +225,12 @@ describe('Memory connector with mocked discovery', function() {
               dataPrecision: null,
               dataScale: null,
               dataType: 'varchar',
-              nullable: 0
+              nullable: 0,
             },
             precision: null,
             required: true,
             scale: null,
-            type: undefined
+            type: undefined,
           },
           total: {
             length: null,
@@ -240,15 +240,15 @@ describe('Memory connector with mocked discovery', function() {
               dataPrecision: 10,
               dataScale: 0,
               dataType: 'int',
-              nullable: 1
+              nullable: 1,
             },
             precision: 10,
             required: false,
             scale: 0,
-            type: undefined
-          }
-        }
-      } ;
+            type: undefined,
+          },
+        },
+      };
     });
 
     it('should discover schema using `discoverSchema`', function(done) {
@@ -275,21 +275,21 @@ describe('Memory connector with mocked discovery', function() {
           schemas.should.be.eql(schema);
           done();
         })
-        .catch(function(err){
+        .catch(function(err) {
           done(err);
         });
     });
   });
 });
 
-describe('discoverModelDefinitions', function(){
+describe('discoverModelDefinitions', function() {
   var ds;
-  before(function(){
-    ds = new DataSource({connector: 'memory'});
+  before(function() {
+    ds = new DataSource({ connector: 'memory' });
 
-    var models = [{type: 'table', name: 'CUSTOMER', owner: 'STRONGLOOP'},
-      {type: 'table', name: 'INVENTORY', owner: 'STRONGLOOP'},
-      {type: 'table', name: 'LOCATION', owner: 'STRONGLOOP'}];
+    var models = [{ type: 'table', name: 'CUSTOMER', owner: 'STRONGLOOP' },
+      { type: 'table', name: 'INVENTORY', owner: 'STRONGLOOP' },
+      { type: 'table', name: 'LOCATION', owner: 'STRONGLOOP' }];
 
     ds.connector.discoverModelDefinitions = function(options, cb) {
       process.nextTick(function() {
@@ -307,7 +307,7 @@ describe('discoverModelDefinitions', function(){
       });
 
       tableNames.should.be.eql(
-        ["CUSTOMER", "INVENTORY", "LOCATION"]
+        ['CUSTOMER', 'INVENTORY', 'LOCATION']
       );
       done();
     });
@@ -322,7 +322,7 @@ describe('discoverModelDefinitions', function(){
       });
 
       tableNames.should.be.eql(
-        ["CUSTOMER", "INVENTORY", "LOCATION"]
+        ['CUSTOMER', 'INVENTORY', 'LOCATION']
       );
       done();
     };
@@ -338,21 +338,21 @@ describe('discoverModelDefinitions', function(){
         });
 
         tableNames.should.be.eql(
-          ["CUSTOMER", "INVENTORY", "LOCATION"]
+          ['CUSTOMER', 'INVENTORY', 'LOCATION']
         );
         done();
       })
-    .catch(function(err){
+    .catch(function(err) {
       done(err);
     });
   });
 });
 
-describe('discoverModelProperties', function(){
+describe('discoverModelProperties', function() {
   var ds;
   var modelProperties;
-  before(function(){
-    ds = new DataSource({connector: 'memory'});
+  before(function() {
+    ds = new DataSource({ connector: 'memory' });
 
     modelProperties = [{
       owner: 'STRONGLOOP',
@@ -362,38 +362,38 @@ describe('discoverModelProperties', function(){
       dataLength: 20,
       dataPrecision: null,
       dataScale: null,
-      nullable: 0
+      nullable: 0,
     },
-      {
-        owner: 'STRONGLOOP',
-        tableName: 'INVENTORY',
-        columnName: 'LOCATION_ID',
-        dataType: 'varchar',
-        dataLength: 20,
-        dataPrecision: null,
-        dataScale: null,
-        nullable: 0
-      },
-      {
-        owner: 'STRONGLOOP',
-        tableName: 'INVENTORY',
-        columnName: 'AVAILABLE',
-        dataType: 'int',
-        dataLength: null,
-        dataPrecision: 10,
-        dataScale: 0,
-        nullable: 1
-      },
-      {
-        owner: 'STRONGLOOP',
-        tableName: 'INVENTORY',
-        columnName: 'TOTAL',
-        dataType: 'int',
-        dataLength: null,
-        dataPrecision: 10,
-        dataScale: 0,
-        nullable: 1
-      }];
+    {
+      owner: 'STRONGLOOP',
+      tableName: 'INVENTORY',
+      columnName: 'LOCATION_ID',
+      dataType: 'varchar',
+      dataLength: 20,
+      dataPrecision: null,
+      dataScale: null,
+      nullable: 0,
+    },
+    {
+      owner: 'STRONGLOOP',
+      tableName: 'INVENTORY',
+      columnName: 'AVAILABLE',
+      dataType: 'int',
+      dataLength: null,
+      dataPrecision: 10,
+      dataScale: 0,
+      nullable: 1,
+    },
+    {
+      owner: 'STRONGLOOP',
+      tableName: 'INVENTORY',
+      columnName: 'TOTAL',
+      dataType: 'int',
+      dataLength: null,
+      dataPrecision: 10,
+      dataScale: 0,
+      nullable: 1,
+    }];
 
     ds.connector.discoverModelProperties = function(modelName, options, cb) {
       process.nextTick(function() {
@@ -404,11 +404,11 @@ describe('discoverModelProperties', function(){
 
   it('should callback function, passed as options parameter', function(done) {
     var options = function(err, schemas) {
-        if (err) return done(err);
+      if (err) return done(err);
 
-        schemas.should.be.eql(modelProperties);
-        done();
-      };
+      schemas.should.be.eql(modelProperties);
+      done();
+    };
 
     ds.discoverModelProperties('INVENTORY', options);
   });
@@ -428,32 +428,32 @@ describe('discoverModelProperties', function(){
         schemas.should.be.eql(modelProperties);
         done();
       })
-    .catch(function(err){
+    .catch(function(err) {
       done(err);
     });
   });
 });
 
-describe('discoverPrimaryKeys', function(){
+describe('discoverPrimaryKeys', function() {
   var ds;
   var modelProperties;
-  before(function(){
-    ds = new DataSource({connector: 'memory'});
+  before(function() {
+    ds = new DataSource({ connector: 'memory' });
 
     primaryKeys = [
-      { 
+      {
         owner: 'STRONGLOOP',
         tableName: 'INVENTORY',
         columnName: 'PRODUCT_ID',
         keySeq: 1,
-        pkName: 'ID_PK' 
-      }, 
-      { 
+        pkName: 'ID_PK',
+      },
+      {
         owner: 'STRONGLOOP',
         tableName: 'INVENTORY',
         columnName: 'LOCATION_ID',
         keySeq: 2,
-        pkName: 'ID_PK' 
+        pkName: 'ID_PK',
       }];
 
     ds.connector.discoverPrimaryKeys = function(modelName, options, cb) {
@@ -488,19 +488,19 @@ describe('discoverPrimaryKeys', function(){
         modelPrimaryKeys.should.be.eql(primaryKeys);
         done();
       })
-      .catch(function(err){
+      .catch(function(err) {
         done(err);
       });
   });
 });
 
-describe('discoverForeignKeys', function(){
+describe('discoverForeignKeys', function() {
   var ds;
   var modelProperties;
-  before(function(){
-    ds = new DataSource({connector: 'memory'});
+  before(function() {
+    ds = new DataSource({ connector: 'memory' });
 
-    foreignKeys = [{ 
+    foreignKeys = [{
       fkOwner: 'STRONGLOOP',
       fkName: 'PRODUCT_FK',
       fkTableName: 'INVENTORY',
@@ -509,7 +509,7 @@ describe('discoverForeignKeys', function(){
       pkOwner: 'STRONGLOOP',
       pkName: 'PRODUCT_PK',
       pkTableName: 'PRODUCT',
-      pkColumnName: 'ID'
+      pkColumnName: 'ID',
     }];
 
     ds.connector.discoverForeignKeys = function(modelName, options, cb) {
@@ -545,17 +545,17 @@ describe('discoverForeignKeys', function(){
         modelForeignKeys.should.be.eql(foreignKeys);
         done();
       })
-      .catch(function(err){
+      .catch(function(err) {
         done(err);
       });
   });
 });
 
-describe('discoverExportedForeignKeys', function(){
+describe('discoverExportedForeignKeys', function() {
   var ds;
   var modelProperties;
-  before(function(){
-    ds = new DataSource({connector: 'memory'});
+  before(function() {
+    ds = new DataSource({ connector: 'memory' });
 
     exportedForeignKeys = [{
       fkName: 'PRODUCT_FK',
@@ -566,7 +566,7 @@ describe('discoverExportedForeignKeys', function(){
       pkName: 'PRODUCT_PK',
       pkOwner: 'STRONGLOOP',
       pkTableName: 'PRODUCT',
-      pkColumnName: 'ID'
+      pkColumnName: 'ID',
     }];
 
     ds.connector.discoverExportedForeignKeys = function(modelName, options, cb) {
@@ -602,7 +602,7 @@ describe('discoverExportedForeignKeys', function(){
         modelForeignKeys.should.be.eql(exportedForeignKeys);
         done();
       })
-      .catch(function(err){
+      .catch(function(err) {
         done(err);
       });
   });
diff --git a/test/events.js b/test/events.js
index d9022afe..21d2cb5a 100644
--- a/test/events.js
+++ b/test/events.js
@@ -11,9 +11,9 @@ describe('events', function() {
     this.db = getSchema();
     this.TestModel = this.db.define('TestModel');
     this.db.automigrate(function(err) {
-      if(err) return done(err);
+      if (err) return done(err);
       test.TestModel.create(function(err, inst) {
-        if(err) return done(err);
+        if (err) return done(err);
         test.inst = inst;
         done();
       });
@@ -23,30 +23,30 @@ describe('events', function() {
         listener.apply(this, arguments);
         done();
       });
-    }
+    };
   });
 
   describe('changed', function() {
     it('should be emitted after save', function(done) {
-      var model = new this.TestModel({name: 'foobar'});
+      var model = new this.TestModel({ name: 'foobar' });
       this.shouldEmitEvent('changed', assertValidChangedArgs, done);
       model.save();
     });
     it('should be emitted after upsert', function(done) {
       this.shouldEmitEvent('changed', assertValidChangedArgs, done);
-      this.TestModel.upsert({name: 'batbaz'});
+      this.TestModel.upsert({ name: 'batbaz' });
     });
     it('should be emitted after create', function(done) {
       this.shouldEmitEvent('changed', assertValidChangedArgs, done);
-      this.TestModel.create({name: '...'});
+      this.TestModel.create({ name: '...' });
     });
     it('should be emitted after updateAttributes', function(done) {
       var test = this;
-      this.TestModel.create({name: 'bazzy'}, function(err, model) {
+      this.TestModel.create({ name: 'bazzy' }, function(err, model) {
         // prevent getting the changed event from "create"
         process.nextTick(function() {
           test.shouldEmitEvent('changed', assertValidChangedArgs, done);
-          model.updateAttributes({name: 'foo'});
+          model.updateAttributes({ name: 'foo' });
         });
       });
     });
@@ -68,7 +68,7 @@ describe('events', function() {
       this.shouldEmitEvent('deletedAll', function(where) {
         where.name.should.equal('foo');
       }, done);
-      this.TestModel.destroyAll({name: 'foo'});
+      this.TestModel.destroyAll({ name: 'foo' });
     });
   });
 });
diff --git a/test/geo.test.js b/test/geo.test.js
index 8b2f684a..8c0b2f77 100644
--- a/test/geo.test.js
+++ b/test/geo.test.js
@@ -11,39 +11,39 @@ require('should');
 var GeoPoint = require('../lib/geo').GeoPoint;
 var DELTA = 0.0000001;
 
-describe('GeoPoint', function () {
+describe('GeoPoint', function() {
 
   describe('constructor', function() {
 
-    it('should support a valid array', function () {
+    it('should support a valid array', function() {
       var point = new GeoPoint([-34, 150]);
 
       point.lat.should.equal(-34);
       point.lng.should.equal(150);
     });
 
-    it('should support a valid object', function () {
+    it('should support a valid object', function() {
       var point = new GeoPoint({ lat: -34, lng: 150 });
 
       point.lat.should.equal(-34);
       point.lng.should.equal(150);
     });
 
-    it('should support valid string geo coordinates', function () {
+    it('should support valid string geo coordinates', function() {
       var point = new GeoPoint('-34,150');
 
       point.lat.should.equal(-34);
       point.lng.should.equal(150);
     });
 
-    it('should support coordinates as inline parameters', function () {
+    it('should support coordinates as inline parameters', function() {
       var point = new GeoPoint(-34, 150);
 
       point.lat.should.equal(-34);
       point.lng.should.equal(150);
     });
 
-    it('should reject invalid parameters', function () {
+    it('should reject invalid parameters', function() {
       /*jshint -W024 */
       var fn = function() {
         new GeoPoint('150,-34');
@@ -63,7 +63,7 @@ describe('GeoPoint', function () {
       fn = function() {
         new GeoPoint({
           lat: 150,
-          lng: null
+          lng: null,
         });
       };
       fn.should.throw();
@@ -91,19 +91,19 @@ describe('GeoPoint', function () {
 
   });
 
-  describe('distance calculation between two points', function () {
+  describe('distance calculation between two points', function() {
 
     var here = new GeoPoint({ lat: 40.77492964101182, lng: -73.90950187151662 });
     var there = new GeoPoint({ lat: 40.7753227, lng: -73.909217 });
 
-    it('should return value in miles by default', function () {
+    it('should return value in miles by default', function() {
 
       var distance = GeoPoint.distanceBetween(here, there);
       distance.should.be.a.Number;
       distance.should.be.approximately(0.03097916611592679, DELTA);
     });
 
-    it('should return value using specified unit', function () {
+    it('should return value using specified unit', function() {
 
       /* Supported units:
        * - `radians`
@@ -114,27 +114,27 @@ describe('GeoPoint', function () {
        * - `degrees`
        */
 
-      var distance = here.distanceTo(there, { type: 'radians'});
+      var distance = here.distanceTo(there, { type: 'radians' });
       distance.should.be.a.Number;
       distance.should.be.approximately(0.000007825491914348416, DELTA);
 
-      distance = here.distanceTo(there, { type: 'kilometers'});
+      distance = here.distanceTo(there, { type: 'kilometers' });
       distance.should.be.a.Number;
       distance.should.be.approximately(0.04985613511367009, DELTA);
 
-      distance = here.distanceTo(there, { type: 'meters'});
+      distance = here.distanceTo(there, { type: 'meters' });
       distance.should.be.a.Number;
       distance.should.be.approximately(49.856135113670085, DELTA);
 
-      distance = here.distanceTo(there, { type: 'miles'});
+      distance = here.distanceTo(there, { type: 'miles' });
       distance.should.be.a.Number;
       distance.should.be.approximately(0.03097916611592679, DELTA);
 
-      distance = here.distanceTo(there, { type: 'feet'});
+      distance = here.distanceTo(there, { type: 'feet' });
       distance.should.be.a.Number;
       distance.should.be.approximately(163.56999709209347, DELTA);
 
-      distance = here.distanceTo(there, { type: 'degrees'});
+      distance = here.distanceTo(there, { type: 'degrees' });
       distance.should.be.a.Number;
       distance.should.be.approximately(0.0004483676593058972, DELTA);
     });
diff --git a/test/hooks.test.js b/test/hooks.test.js
index 50de3c08..b059e527 100644
--- a/test/hooks.test.js
+++ b/test/hooks.test.js
@@ -13,42 +13,42 @@ var j = require('../'),
 
   db, User;
 
-describe('hooks', function () {
+describe('hooks', function() {
 
-  before(function (done) {
+  before(function(done) {
     db = getSchema();
 
     User = db.define('User', {
-      email: {type: String, index: true},
+      email: { type: String, index: true },
       name: String,
       password: String,
-      state: String
+      state: String,
     });
 
     db.automigrate('User', done);
   });
 
-  describe('initialize', function () {
+  describe('initialize', function() {
 
-    afterEach(function () {
+    afterEach(function() {
       User.afterInitialize = null;
     });
 
-    it('should be triggered on new', function (done) {
-      User.afterInitialize = function () {
+    it('should be triggered on new', function(done) {
+      User.afterInitialize = function() {
         done();
       };
       new User;
     });
 
-    it('should be triggered on create', function (done) {
+    it('should be triggered on create', function(done) {
       var user;
-      User.afterInitialize = function () {
+      User.afterInitialize = function() {
         if (this.name === 'Nickolay') {
           this.name += ' Rozental';
         }
       };
-      User.create({name: 'Nickolay'}, function (err, u) {
+      User.create({ name: 'Nickolay' }, function(err, u) {
         u.id.should.be.ok;
         u.name.should.equal('Nickolay Rozental');
         done();
@@ -57,116 +57,116 @@ describe('hooks', function () {
 
   });
 
-  describe('create', function () {
+  describe('create', function() {
 
     afterEach(removeHooks('Create'));
 
-    it('should be triggered on create', function (done) {
+    it('should be triggered on create', function(done) {
       addHooks('Create', done);
       User.create();
     });
 
-    it('should not be triggered on new', function () {
-      User.beforeCreate = function (next) {
+    it('should not be triggered on new', function() {
+      User.beforeCreate = function(next) {
         should.fail('This should not be called');
         next();
       };
       var u = new User;
     });
 
-    it('should be triggered on new+save', function (done) {
+    it('should be triggered on new+save', function(done) {
       addHooks('Create', done);
       (new User).save();
     });
 
-    it('afterCreate should not be triggered on failed create', function (done) {
+    it('afterCreate should not be triggered on failed create', function(done) {
       var old = User.dataSource.connector.create;
-      User.dataSource.connector.create = function (modelName, id, cb) {
+      User.dataSource.connector.create = function(modelName, id, cb) {
         cb(new Error('error'));
-      }
+      };
 
-      User.afterCreate = function () {
+      User.afterCreate = function() {
         throw new Error('shouldn\'t be called');
       };
-      User.create(function (err, user) {
+      User.create(function(err, user) {
         User.dataSource.connector.create = old;
         done();
       });
     });
 
-    it('afterCreate should not be triggered on failed beforeCreate', function (done) {
-      User.beforeCreate = function (next, data) {
+    it('afterCreate should not be triggered on failed beforeCreate', function(done) {
+      User.beforeCreate = function(next, data) {
         // Skip next()
         next(new Error('fail in beforeCreate'));
       };
 
       var old = User.dataSource.connector.create;
-      User.dataSource.connector.create = function (modelName, id, cb) {
-        throw new Error('shouldn\'t be called');
-      }
-
-      User.afterCreate = function () {
+      User.dataSource.connector.create = function(modelName, id, cb) {
         throw new Error('shouldn\'t be called');
       };
-      User.create(function (err, user) {
+
+      User.afterCreate = function() {
+        throw new Error('shouldn\'t be called');
+      };
+      User.create(function(err, user) {
         User.dataSource.connector.create = old;
         done();
       });
     });
   });
 
-  describe('save', function () {
+  describe('save', function() {
     afterEach(removeHooks('Save'));
 
-    it('should be triggered on create', function (done) {
+    it('should be triggered on create', function(done) {
       addHooks('Save', done);
       User.create();
     });
 
-    it('should be triggered on new+save', function (done) {
+    it('should be triggered on new+save', function(done) {
       addHooks('Save', done);
       (new User).save();
     });
 
-    it('should be triggered on updateAttributes', function (done) {
-      User.create(function (err, user) {
+    it('should be triggered on updateAttributes', function(done) {
+      User.create(function(err, user) {
         addHooks('Save', done);
-        user.updateAttributes({name: 'Anatoliy'});
+        user.updateAttributes({ name: 'Anatoliy' });
       });
     });
 
-    it('should be triggered on save', function (done) {
-      User.create(function (err, user) {
+    it('should be triggered on save', function(done) {
+      User.create(function(err, user) {
         addHooks('Save', done);
         user.name = 'Hamburger';
         user.save();
       });
     });
 
-    it('should save full object', function (done) {
-      User.create(function (err, user) {
-        User.beforeSave = function (next, data) {
+    it('should save full object', function(done) {
+      User.create(function(err, user) {
+        User.beforeSave = function(next, data) {
           data.should.have.keys('id', 'name', 'email',
-            'password', 'state')
+            'password', 'state');
           done();
         };
         user.save();
       });
     });
 
-    it('should save actual modifications to database', function (done) {
-      User.beforeSave = function (next, data) {
+    it('should save actual modifications to database', function(done) {
+      User.beforeSave = function(next, data) {
         data.password = 'hash';
         next();
       };
-      User.destroyAll(function () {
+      User.destroyAll(function() {
         User.create({
           email: 'james.bond@example.com',
-          password: '53cr3t'
-        }, function () {
+          password: '53cr3t',
+        }, function() {
           User.findOne({
-            where: {email: 'james.bond@example.com'}
-          }, function (err, jb) {
+            where: { email: 'james.bond@example.com' },
+          }, function(err, jb) {
             jb.password.should.equal('hash');
             done();
           });
@@ -174,22 +174,22 @@ describe('hooks', function () {
       });
     });
 
-    it('should save actual modifications on updateAttributes', function (done) {
-      User.beforeSave = function (next, data) {
+    it('should save actual modifications on updateAttributes', function(done) {
+      User.beforeSave = function(next, data) {
         data.password = 'hash';
         next();
       };
-      User.destroyAll(function () {
+      User.destroyAll(function() {
         User.create({
-          email: 'james.bond@example.com'
-        }, function (err, u) {
-          u.updateAttribute('password', 'new password', function (e, u) {
+          email: 'james.bond@example.com',
+        }, function(err, u) {
+          u.updateAttribute('password', 'new password', function(e, u) {
             should.not.exist(e);
             should.exist(u);
             u.password.should.equal('hash');
             User.findOne({
-              where: {email: 'james.bond@example.com'}
-            }, function (err, jb) {
+              where: { email: 'james.bond@example.com' },
+            }, function(err, jb) {
               jb.password.should.equal('hash');
               done();
             });
@@ -198,9 +198,9 @@ describe('hooks', function () {
       });
     });
 
-    it('beforeSave should be able to skip next', function (done) {
-      User.create(function (err, user) {
-        User.beforeSave = function (next, data) {
+    it('beforeSave should be able to skip next', function(done) {
+      User.create(function(err, user) {
+        User.beforeSave = function(next, data) {
           next(null, 'XYZ');
         };
         user.save(function(err, result) {
@@ -212,97 +212,97 @@ describe('hooks', function () {
 
   });
 
-  describe('update', function () {
+  describe('update', function() {
     afterEach(removeHooks('Update'));
 
-    it('should not be triggered on create', function () {
-      User.beforeUpdate = function (next) {
+    it('should not be triggered on create', function() {
+      User.beforeUpdate = function(next) {
         should.fail('This should not be called');
         next();
       };
       User.create();
     });
 
-    it('should not be triggered on new+save', function () {
-      User.beforeUpdate = function (next) {
+    it('should not be triggered on new+save', function() {
+      User.beforeUpdate = function(next) {
         should.fail('This should not be called');
         next();
       };
       (new User).save();
     });
 
-    it('should be triggered on updateAttributes', function (done) {
-      User.create(function (err, user) {
+    it('should be triggered on updateAttributes', function(done) {
+      User.create(function(err, user) {
         addHooks('Update', done);
-        user.updateAttributes({name: 'Anatoliy'});
+        user.updateAttributes({ name: 'Anatoliy' });
       });
     });
 
-    it('should be triggered on save', function (done) {
-      User.create(function (err, user) {
+    it('should be triggered on save', function(done) {
+      User.create(function(err, user) {
         addHooks('Update', done);
         user.name = 'Hamburger';
         user.save();
       });
     });
 
-    it('should update limited set of fields', function (done) {
-      User.create(function (err, user) {
-        User.beforeUpdate = function (next, data) {
+    it('should update limited set of fields', function(done) {
+      User.create(function(err, user) {
+        User.beforeUpdate = function(next, data) {
           data.should.have.keys('name', 'email');
           done();
         };
-        user.updateAttributes({name: 1, email: 2});
+        user.updateAttributes({ name: 1, email: 2 });
       });
     });
 
-    it('should not trigger after-hook on failed save', function (done) {
-      User.afterUpdate = function () {
+    it('should not trigger after-hook on failed save', function(done) {
+      User.afterUpdate = function() {
         should.fail('afterUpdate shouldn\'t be called');
       };
-      User.create(function (err, user) {
+      User.create(function(err, user) {
         var save = User.dataSource.connector.save;
-        User.dataSource.connector.save = function (modelName, id, cb) {
+        User.dataSource.connector.save = function(modelName, id, cb) {
           User.dataSource.connector.save = save;
           cb(new Error('Error'));
-        }
+        };
 
-        user.save(function (err) {
+        user.save(function(err) {
           done();
         });
       });
     });
   });
 
-  describe('destroy', function () {
+  describe('destroy', function() {
 
     afterEach(removeHooks('Destroy'));
 
-    it('should be triggered on destroy', function (done) {
+    it('should be triggered on destroy', function(done) {
       var hook = 'not called';
-      User.beforeDestroy = function (next) {
+      User.beforeDestroy = function(next) {
         hook = 'called';
         next();
       };
-      User.afterDestroy = function (next) {
+      User.afterDestroy = function(next) {
         hook.should.eql('called');
         next();
       };
-      User.create(function (err, user) {
+      User.create(function(err, user) {
         user.destroy(done);
       });
     });
 
-    it('should not trigger after-hook on failed destroy', function (done) {
+    it('should not trigger after-hook on failed destroy', function(done) {
       var destroy = User.dataSource.connector.destroy;
-      User.dataSource.connector.destroy = function (modelName, id, cb) {
+      User.dataSource.connector.destroy = function(modelName, id, cb) {
         cb(new Error('error'));
-      }
-      User.afterDestroy = function () {
-        should.fail('afterDestroy shouldn\'t be called')
       };
-      User.create(function (err, user) {
-        user.destroy(function (err) {
+      User.afterDestroy = function() {
+        should.fail('afterDestroy shouldn\'t be called');
+      };
+      User.create(function(err, user) {
+        user.destroy(function(err) {
           User.dataSource.connector.destroy = destroy;
           done();
         });
@@ -311,64 +311,64 @@ describe('hooks', function () {
 
   });
 
-  describe('lifecycle', function () {
+  describe('lifecycle', function() {
     var life = [], user;
-    before(function (done) {
-      User.beforeSave = function (d) {
+    before(function(done) {
+      User.beforeSave = function(d) {
         life.push('beforeSave');
         d();
       };
-      User.beforeCreate = function (d) {
+      User.beforeCreate = function(d) {
         life.push('beforeCreate');
         d();
       };
-      User.beforeUpdate = function (d) {
+      User.beforeUpdate = function(d) {
         life.push('beforeUpdate');
         d();
       };
-      User.beforeDestroy = function (d) {
+      User.beforeDestroy = function(d) {
         life.push('beforeDestroy');
         d();
       };
-      User.beforeValidate = function (d) {
+      User.beforeValidate = function(d) {
         life.push('beforeValidate');
         d();
       };
-      User.afterInitialize = function () {
+      User.afterInitialize = function() {
         life.push('afterInitialize');
       };
-      User.afterSave = function (d) {
+      User.afterSave = function(d) {
         life.push('afterSave');
         d();
       };
-      User.afterCreate = function (d) {
+      User.afterCreate = function(d) {
         life.push('afterCreate');
         d();
       };
-      User.afterUpdate = function (d) {
+      User.afterUpdate = function(d) {
         life.push('afterUpdate');
         d();
       };
-      User.afterDestroy = function (d) {
+      User.afterDestroy = function(d) {
         life.push('afterDestroy');
         d();
       };
-      User.afterValidate = function (d) {
+      User.afterValidate = function(d) {
         life.push('afterValidate');
         d();
       };
-      User.create(function (e, u) {
+      User.create(function(e, u) {
         user = u;
         life = [];
         done();
       });
     });
-    beforeEach(function () {
+    beforeEach(function() {
       life = [];
     });
 
-    it('should describe create sequence', function (done) {
-      User.create(function () {
+    it('should describe create sequence', function(done) {
+      User.create(function() {
         life.should.eql([
           'afterInitialize',
           'beforeValidate',
@@ -376,15 +376,15 @@ describe('hooks', function () {
           'beforeCreate',
           'beforeSave',
           'afterSave',
-          'afterCreate'
+          'afterCreate',
         ]);
         done();
       });
     });
 
-    it('should describe new+save sequence', function (done) {
+    it('should describe new+save sequence', function(done) {
       var u = new User;
-      u.save(function () {
+      u.save(function() {
         life.should.eql([
           'afterInitialize',
           'beforeValidate',
@@ -392,14 +392,14 @@ describe('hooks', function () {
           'beforeCreate',
           'beforeSave',
           'afterSave',
-          'afterCreate'
+          'afterCreate',
         ]);
         done();
       });
     });
 
-    it('should describe updateAttributes sequence', function (done) {
-      user.updateAttributes({name: 'Antony'}, function () {
+    it('should describe updateAttributes sequence', function(done) {
+      user.updateAttributes({ name: 'Antony' }, function() {
         life.should.eql([
           'beforeValidate',
           'afterValidate',
@@ -412,25 +412,25 @@ describe('hooks', function () {
       });
     });
 
-    it('should describe isValid sequence', function (done) {
+    it('should describe isValid sequence', function(done) {
       should.not.exist(
         user.constructor._validations,
         'Expected user to have no validations, but she have');
-      user.isValid(function (valid) {
+      user.isValid(function(valid) {
         valid.should.be.true;
         life.should.eql([
           'beforeValidate',
-          'afterValidate'
+          'afterValidate',
         ]);
         done();
       });
     });
 
-    it('should describe destroy sequence', function (done) {
-      user.destroy(function () {
+    it('should describe destroy sequence', function(done) {
+      user.destroy(function() {
         life.should.eql([
           'beforeDestroy',
-          'afterDestroy'
+          'afterDestroy',
         ]);
         done();
       });
@@ -443,12 +443,12 @@ describe('hooks', function () {
 
 function addHooks(name, done) {
   var called = false, random = String(Math.floor(Math.random() * 1000));
-  User['before' + name] = function (next, data) {
+  User['before' + name] = function(next, data) {
     called = true;
     data.email = random;
     next();
   };
-  User['after' + name] = function (next) {
+  User['after' + name] = function(next) {
     (new Boolean(called)).should.equal(true);
     this.should.have.property('email', random);
     done();
@@ -456,7 +456,7 @@ function addHooks(name, done) {
 }
 
 function removeHooks(name) {
-  return function () {
+  return function() {
     User['after' + name] = null;
     User['before' + name] = null;
   };
diff --git a/test/include.test.js b/test/include.test.js
index b5124985..b2fa0711 100644
--- a/test/include.test.js
+++ b/test/include.test.js
@@ -12,14 +12,14 @@ var DataSource = require('../').DataSource;
 
 var db, User, Profile, AccessToken, Post, Passport, City, Street, Building, Assembly, Part;
 
-describe('include', function () {
+describe('include', function() {
 
   before(setup);
 
-  it('should fetch belongsTo relation', function (done) {
-    Passport.find({include: 'owner'}, function (err, passports) {
+  it('should fetch belongsTo relation', function(done) {
+    Passport.find({ include: 'owner' }, function(err, passports) {
       passports.length.should.be.ok;
-      passports.forEach(function (p) {
+      passports.forEach(function(p) {
         p.__cachedRelations.should.have.property('owner');
 
         // The relation should be promoted as the 'owner' property
@@ -39,19 +39,19 @@ describe('include', function () {
     });
   });
 
-  it('should fetch hasMany relation', function (done) {
-    User.find({include: 'posts'}, function (err, users) {
+  it('should fetch hasMany relation', function(done) {
+    User.find({ include: 'posts' }, function(err, users) {
       should.not.exist(err);
       should.exist(users);
       users.length.should.be.ok;
-      users.forEach(function (u) {
+      users.forEach(function(u) {
         // The relation should be promoted as the 'owner' property
         u.should.have.property('posts');
         // The __cachedRelations should be removed from json output
         u.toJSON().should.not.have.property('__cachedRelations');
 
         u.__cachedRelations.should.have.property('posts');
-        u.__cachedRelations.posts.forEach(function (p) {
+        u.__cachedRelations.posts.forEach(function(p) {
           p.userId.should.eql(u.id);
         });
       });
@@ -59,13 +59,13 @@ describe('include', function () {
     });
   });
 
-  it('should fetch Passport - Owner - Posts', function (done) {
-    Passport.find({include: {owner: 'posts'}}, function (err, passports) {
+  it('should fetch Passport - Owner - Posts', function(done) {
+    Passport.find({ include: { owner: 'posts' }}, function(err, passports) {
 
       should.not.exist(err);
       should.exist(passports);
       passports.length.should.be.ok;
-      passports.forEach(function (p) {
+      passports.forEach(function(p) {
         p.__cachedRelations.should.have.property('owner');
 
         // The relation should be promoted as the 'owner' property
@@ -82,7 +82,7 @@ describe('include', function () {
           user.__cachedRelations.should.have.property('posts');
           user.should.have.property('posts');
           user.toJSON().should.have.property('posts').and.be.an.Array;
-          user.__cachedRelations.posts.forEach(function (pp) {
+          user.__cachedRelations.posts.forEach(function(pp) {
             pp.userId.should.eql(user.id);
           });
         }
@@ -91,8 +91,8 @@ describe('include', function () {
     });
   });
 
-  it('should fetch Passport - Owner - empty Posts', function (done) {
-    Passport.findOne({where: {number: '4'}, include: {owner: 'posts'}}, function (err, passport) {
+  it('should fetch Passport - Owner - empty Posts', function(done) {
+    Passport.findOne({ where: { number: '4' }, include: { owner: 'posts' }}, function(err, passport) {
       should.not.exist(err);
       should.exist(passport);
       passport.__cachedRelations.should.have.property('owner');
@@ -113,8 +113,8 @@ describe('include', function () {
     });
   });
 
-  it('should fetch Passport - Owner - Posts - alternate syntax', function (done) {
-    Passport.find({include: {owner: {relation: 'posts'}}}, function (err, passports) {
+  it('should fetch Passport - Owner - Posts - alternate syntax', function(done) {
+    Passport.find({ include: { owner: { relation: 'posts' }}}, function(err, passports) {
       should.not.exist(err);
       should.exist(passports);
       passports.length.should.be.ok;
@@ -124,14 +124,14 @@ describe('include', function () {
     });
   });
 
-  it('should fetch Passports - User - Posts - User', function (done) {
+  it('should fetch Passports - User - Posts - User', function(done) {
     Passport.find({
-      include: {owner: {posts: 'author'}}
-    }, function (err, passports) {
+      include: { owner: { posts: 'author' }},
+    }, function(err, passports) {
       should.not.exist(err);
       should.exist(passports);
       passports.length.should.be.ok;
-      passports.forEach(function (p) {
+      passports.forEach(function(p) {
         p.__cachedRelations.should.have.property('owner');
         var user = p.__cachedRelations.owner;
         if (!p.ownerId) {
@@ -140,7 +140,7 @@ describe('include', function () {
           should.exist(user);
           user.id.should.eql(p.ownerId);
           user.__cachedRelations.should.have.property('posts');
-          user.__cachedRelations.posts.forEach(function (pp) {
+          user.__cachedRelations.posts.forEach(function(pp) {
             pp.should.have.property('id');
             pp.userId.should.eql(user.id);
             pp.should.have.property('author');
@@ -154,13 +154,13 @@ describe('include', function () {
     });
   });
 
-  it('should fetch Passports with include scope on Posts', function (done) {
+  it('should fetch Passports with include scope on Posts', function(done) {
     Passport.find({
-      include: {owner: {relation: 'posts', scope:{
+      include: { owner: { relation: 'posts', scope:{
         fields: ['title'], include: ['author'],
-        order: 'title DESC'
-      }}}
-    }, function (err, passports) {
+        order: 'title DESC',
+      }}},
+    }, function(err, passports) {
       should.not.exist(err);
       should.exist(passports);
       passports.length.should.equal(4);
@@ -196,11 +196,11 @@ describe('include', function () {
           relation: 'posts', scope: {
             fields: ['title'], include: ['author'],
             order: 'title DESC',
-            limit: 2
-          }
-        }
+            limit: 2,
+          },
+        },
       },
-      limit: 1
+      limit: 1,
     }, function(err, passports) {
       if (err) return done(err);
       passports.length.should.equal(1);
@@ -209,29 +209,29 @@ describe('include', function () {
     });
   });
 
-  it('should fetch Users with include scope on Posts - belongsTo', function (done) {
-      Post.find({
-        include: { relation: 'author', scope:{ fields: ['name'] }}
-      }, function (err, posts) {
-        should.not.exist(err);
-        should.exist(posts);
-        posts.length.should.equal(5);
+  it('should fetch Users with include scope on Posts - belongsTo', function(done) {
+    Post.find({
+      include: { relation: 'author', scope:{ fields: ['name'] }},
+    }, function(err, posts) {
+      should.not.exist(err);
+      should.exist(posts);
+      posts.length.should.equal(5);
 
-        var author = posts[0].author();
-        author.name.should.equal('User A');
-        author.should.have.property('id');
-        author.should.have.property('age', undefined);
+      var author = posts[0].author();
+      author.name.should.equal('User A');
+      author.should.have.property('id');
+      author.should.have.property('age', undefined);
 
-        done();
-      });
+      done();
     });
+  });
 
-  it('should fetch Users with include scope on Posts - hasMany', function (done) {
+  it('should fetch Users with include scope on Posts - hasMany', function(done) {
     User.find({
-      include: {relation: 'posts', scope:{
-        order: 'title DESC'
-      }}
-    }, function (err, users) {
+      include: { relation: 'posts', scope:{
+        order: 'title DESC',
+      }},
+    }, function(err, users) {
       should.not.exist(err);
       should.exist(users);
       users.length.should.equal(5);
@@ -256,12 +256,12 @@ describe('include', function () {
     });
   });
 
-  it('should fetch Users with include scope on Passports - hasMany', function (done) {
+  it('should fetch Users with include scope on Passports - hasMany', function(done) {
     User.find({
-      include: {relation: 'passports', scope:{
-        where: { number: '2' }
-      }}
-    }, function (err, users) {
+      include: { relation: 'passports', scope:{
+        where: { number: '2' },
+      }},
+    }, function(err, users) {
       should.not.exist(err);
       should.exist(users);
       users.length.should.equal(5);
@@ -277,12 +277,12 @@ describe('include', function () {
     });
   });
 
-  it('should fetch User - Posts AND Passports', function (done) {
-    User.find({include: ['posts', 'passports']}, function (err, users) {
+  it('should fetch User - Posts AND Passports', function(done) {
+    User.find({ include: ['posts', 'passports'] }, function(err, users) {
       should.not.exist(err);
       should.exist(users);
       users.length.should.be.ok;
-      users.forEach(function (user) {
+      users.forEach(function(user) {
         // The relation should be promoted as the 'owner' property
         user.should.have.property('posts');
         user.should.have.property('passports');
@@ -298,10 +298,10 @@ describe('include', function () {
 
         user.__cachedRelations.should.have.property('posts');
         user.__cachedRelations.should.have.property('passports');
-        user.__cachedRelations.posts.forEach(function (p) {
+        user.__cachedRelations.posts.forEach(function(p) {
           p.userId.should.eql(user.id);
         });
-        user.__cachedRelations.passports.forEach(function (pp) {
+        user.__cachedRelations.passports.forEach(function(pp) {
           pp.ownerId.should.eql(user.id);
         });
       });
@@ -311,12 +311,12 @@ describe('include', function () {
 
   it('should fetch User - Posts AND Passports in relation syntax',
     function(done) {
-      User.find({include: [
-        {relation: 'posts', scope: {
-          where: {title: 'Post A'}
+      User.find({ include: [
+        { relation: 'posts', scope: {
+          where: { title: 'Post A' },
         }},
-        'passports'
-      ]}, function(err, users) {
+        'passports',
+      ] }, function(err, users) {
         should.not.exist(err);
         should.exist(users);
         users.length.should.be.ok;
@@ -348,12 +348,12 @@ describe('include', function () {
       });
     });
 
-  it('should not fetch User - AccessTokens', function (done) {
-    User.find({include: ['accesstokens']}, function (err, users) {
+  it('should not fetch User - AccessTokens', function(done) {
+    User.find({ include: ['accesstokens'] }, function(err, users) {
       should.not.exist(err);
       should.exist(users);
       users.length.should.be.ok;
-      users.forEach(function (user) {
+      users.forEach(function(user) {
         var userObj = user.toJSON();
         userObj.should.not.have.property('accesstokens');
       });
@@ -361,20 +361,20 @@ describe('include', function () {
     });
   });
 
-  it('should support hasAndBelongsToMany', function (done) {
-    Assembly.create({name: 'car'}, function (err, assembly) {
-      Part.create({partNumber: 'engine'}, function (err, part) {
-        assembly.parts.add(part, function (err, data) {
-          assembly.parts(function (err, parts) {
+  it('should support hasAndBelongsToMany', function(done) {
+    Assembly.create({ name: 'car' }, function(err, assembly) {
+      Part.create({ partNumber: 'engine' }, function(err, part) {
+        assembly.parts.add(part, function(err, data) {
+          assembly.parts(function(err, parts) {
             should.not.exist(err);
             should.exists(parts);
             parts.length.should.equal(1);
             parts[0].partNumber.should.equal('engine');
 
             // Create a part
-            assembly.parts.create({partNumber: 'door'}, function (err, part4) {
+            assembly.parts.create({ partNumber: 'door' }, function(err, part4) {
 
-              Assembly.find({include: 'parts'}, function (err, assemblies) {
+              Assembly.find({ include: 'parts' }, function(err, assemblies) {
                 assemblies.length.should.equal(1);
                 assemblies[0].parts().length.should.equal(2);
                 done();
@@ -387,13 +387,13 @@ describe('include', function () {
     });
   });
 
-  it('should fetch User - Profile (HasOne)', function (done) {
-    User.find({include: ['profile']}, function (err, users) {
+  it('should fetch User - Profile (HasOne)', function(done) {
+    User.find({ include: ['profile'] }, function(err, users) {
       should.not.exist(err);
       should.exist(users);
       users.length.should.be.ok;
       var usersWithProfile = 0;
-      users.forEach(function (user) {
+      users.forEach(function(user) {
         // The relation should be promoted as the 'owner' property
         user.should.have.property('profile');
         var userObj = user.toJSON();
@@ -421,10 +421,10 @@ describe('include', function () {
 
   // Not implemented correctly, see: loopback-datasource-juggler/issues/166
   // fixed by DB optimization
-  it('should support include scope on hasAndBelongsToMany', function (done) {
-    Assembly.find({include: { relation: 'parts', scope: {
-     where: { partNumber: 'engine' }
-    }}}, function (err, assemblies) {
+  it('should support include scope on hasAndBelongsToMany', function(done) {
+    Assembly.find({ include: { relation: 'parts', scope: {
+      where: { partNumber: 'engine' },
+    }}}, function(err, assemblies) {
       assemblies.length.should.equal(1);
       var parts = assemblies[0].parts();
       parts.should.have.length(1);
@@ -435,7 +435,7 @@ describe('include', function () {
 
   it('should save related items separately', function(done) {
     User.find({
-      include: 'posts'
+      include: 'posts',
     })
       .then(function(users) {
         var posts = users[0].posts();
@@ -444,7 +444,7 @@ describe('include', function () {
       })
       .then(function(updatedUser) {
         return User.findById(updatedUser.id, {
-          include: 'posts'
+          include: 'posts',
         });
       })
       .then(function(user) {
@@ -455,7 +455,7 @@ describe('include', function () {
       .catch(done);
   });
 
-  describe('performance', function () {
+  describe('performance', function() {
     var all;
     beforeEach(function() {
       this.called = 0;
@@ -469,11 +469,11 @@ describe('include', function () {
     afterEach(function() {
       db.connector.all = all;
     });
-    it('including belongsTo should make only 2 db calls', function (done) {
+    it('including belongsTo should make only 2 db calls', function(done) {
       var self = this;
-      Passport.find({include: 'owner'}, function (err, passports) {
+      Passport.find({ include: 'owner' }, function(err, passports) {
         passports.length.should.be.ok;
-        passports.forEach(function (p) {
+        passports.forEach(function(p) {
           p.__cachedRelations.should.have.property('owner');
           // The relation should be promoted as the 'owner' property
           p.should.have.property('owner');
@@ -492,16 +492,16 @@ describe('include', function () {
       });
     });
 
-    it('including hasManyThrough should make only 3 db calls', function (done) {
+    it('including hasManyThrough should make only 3 db calls', function(done) {
       var self = this;
-      Assembly.create([{name: 'sedan'}, {name: 'hatchback'},
-          {name: 'SUV'}],
-        function (err, assemblies) {
-          Part.create([{partNumber: 'engine'}, {partNumber: 'bootspace'},
-              {partNumber: 'silencer'}],
-            function (err, parts) {
-              async.each(parts, function (part, next) {
-                async.each(assemblies, function (assembly, next) {
+      Assembly.create([{ name: 'sedan' }, { name: 'hatchback' },
+          { name: 'SUV' }],
+        function(err, assemblies) {
+          Part.create([{ partNumber: 'engine' }, { partNumber: 'bootspace' },
+              { partNumber: 'silencer' }],
+            function(err, parts) {
+              async.each(parts, function(part, next) {
+                async.each(assemblies, function(assembly, next) {
                   if (assembly.name === 'SUV') {
                     return next();
                   }
@@ -509,20 +509,20 @@ describe('include', function () {
                     part.partNumber === 'bootspace') {
                     return next();
                   }
-                  assembly.parts.add(part, function (err, data) {
+                  assembly.parts.add(part, function(err, data) {
                     next();
                   });
                 }, next);
-              }, function (err) {
+              }, function(err) {
                 self.called = 0;
                 Assembly.find({
                   where: {
                     name: {
-                      inq: ['sedan', 'hatchback', 'SUV']
-                    }
+                      inq: ['sedan', 'hatchback', 'SUV'],
+                    },
                   },
-                  include: 'parts'
-                }, function (err, result) {
+                  include: 'parts',
+                }, function(err, result) {
                   should.not.exist(err);
                   should.exists(result);
                   result.length.should.equal(3);
@@ -545,13 +545,13 @@ describe('include', function () {
         });
     });
 
-    it('including hasMany should make only 2 db calls', function (done) {
+    it('including hasMany should make only 2 db calls', function(done) {
       var self = this;
-      User.find({include: ['posts', 'passports']}, function (err, users) {
+      User.find({ include: ['posts', 'passports'] }, function(err, users) {
         should.not.exist(err);
         should.exist(users);
         users.length.should.be.ok;
-        users.forEach(function (user) {
+        users.forEach(function(user) {
           // The relation should be promoted as the 'owner' property
           user.should.have.property('posts');
           user.should.have.property('passports');
@@ -567,10 +567,10 @@ describe('include', function () {
 
           user.__cachedRelations.should.have.property('posts');
           user.__cachedRelations.should.have.property('passports');
-          user.__cachedRelations.posts.forEach(function (p) {
+          user.__cachedRelations.posts.forEach(function(p) {
             p.userId.should.eql(user.id);
           });
-          user.__cachedRelations.passports.forEach(function (pp) {
+          user.__cachedRelations.passports.forEach(function(pp) {
             pp.ownerId.should.eql(user.id);
           });
         });
@@ -581,15 +581,15 @@ describe('include', function () {
 
 
     it('should not make n+1 db calls in relation syntax',
-      function (done) {
+      function(done) {
         var self = this;
-        User.find({include: [{ relation: 'posts', scope: {
-              where: {title: 'Post A'}
-            }}, 'passports']}, function (err, users) {
+        User.find({ include: [{ relation: 'posts', scope: {
+          where: { title: 'Post A' },
+        }}, 'passports'] }, function(err, users) {
           should.not.exist(err);
           should.exist(users);
           users.length.should.be.ok;
-          users.forEach(function (user) {
+          users.forEach(function(user) {
             // The relation should be promoted as the 'owner' property
             user.should.have.property('posts');
             user.should.have.property('passports');
@@ -605,11 +605,11 @@ describe('include', function () {
 
             user.__cachedRelations.should.have.property('posts');
             user.__cachedRelations.should.have.property('passports');
-            user.__cachedRelations.posts.forEach(function (p) {
+            user.__cachedRelations.posts.forEach(function(p) {
               p.userId.should.eql(user.id);
               p.title.should.be.equal('Post A');
             });
-            user.__cachedRelations.passports.forEach(function (pp) {
+            user.__cachedRelations.passports.forEach(function(pp) {
               pp.ownerId.should.eql(user.id);
             });
           });
@@ -627,44 +627,44 @@ function setup(done) {
   Building = db.define('Building');
   User = db.define('User', {
     name: String,
-    age: Number
+    age: Number,
   });
   Profile = db.define('Profile', {
-    profileName: String
+    profileName: String,
   });
   AccessToken = db.define('AccessToken', {
-    token: String
+    token: String,
   });
   Passport = db.define('Passport', {
-    number: String
+    number: String,
   });
   Post = db.define('Post', {
-    title: String
+    title: String,
   });
 
-  Passport.belongsTo('owner', {model: User});
-  User.hasMany('passports', {foreignKey: 'ownerId'});
-  User.hasMany('posts', {foreignKey: 'userId'});
+  Passport.belongsTo('owner', { model: User });
+  User.hasMany('passports', { foreignKey: 'ownerId' });
+  User.hasMany('posts', { foreignKey: 'userId' });
   User.hasMany('accesstokens', {
     foreignKey: 'userId',
-    options: {disableInclude: true}
+    options: { disableInclude: true },
   });
-  Profile.belongsTo('user', {model: User});
-  User.hasOne('profile', {foreignKey: 'userId'});
-  Post.belongsTo('author', {model: User, foreignKey: 'userId'});
+  Profile.belongsTo('user', { model: User });
+  User.hasOne('profile', { foreignKey: 'userId' });
+  Post.belongsTo('author', { model: User, foreignKey: 'userId' });
 
   Assembly = db.define('Assembly', {
-    name: String
+    name: String,
   });
 
   Part = db.define('Part', {
-    partNumber: String
+    partNumber: String,
   });
 
   Assembly.hasAndBelongsToMany(Part);
   Part.hasAndBelongsToMany(Assembly);
 
-  db.automigrate(function () {
+  db.automigrate(function() {
     var createdUsers = [];
     var createdPassports = [];
     var createdProfiles = [];
@@ -674,13 +674,13 @@ function setup(done) {
       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}
+          { 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) {
+        function(items) {
           createdUsers = items;
           createPassports();
           createAccessTokens();
@@ -692,10 +692,10 @@ function setup(done) {
       clearAndCreate(
         AccessToken,
         [
-          {token: '1', userId: createdUsers[0].id},
-          {token: '2', userId: createdUsers[1].id}
+          { token: '1', userId: createdUsers[0].id },
+          { token: '2', userId: createdUsers[1].id },
         ],
-        function (items) {}
+        function(items) {}
       );
     }
 
@@ -703,12 +703,12 @@ function setup(done) {
       clearAndCreate(
         Passport,
         [
-          {number: '1', ownerId: createdUsers[0].id},
-          {number: '2', ownerId: createdUsers[1].id},
-          {number: '3'},
-          {number: '4', ownerId: createdUsers[2].id},
+          { number: '1', ownerId: createdUsers[0].id },
+          { number: '2', ownerId: createdUsers[1].id },
+          { number: '3' },
+          { number: '4', ownerId: createdUsers[2].id },
         ],
-        function (items) {
+        function(items) {
           createdPassports = items;
           createPosts();
         }
@@ -719,12 +719,12 @@ function setup(done) {
       clearAndCreate(
         Profile,
         [
-          {profileName: 'Profile A', userId: createdUsers[0].id},
-          {profileName: 'Profile B', userId: createdUsers[1].id},
-          {profileName: 'Profile Z'}
+          { profileName: 'Profile A', userId: createdUsers[0].id },
+          { profileName: 'Profile B', userId: createdUsers[1].id },
+          { profileName: 'Profile Z' },
         ],
-        function (items) {
-          createdProfiles = items
+        function(items) {
+          createdProfiles = items;
           done();
         }
       );
@@ -734,13 +734,13 @@ function setup(done) {
       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'}
+          { 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) {
+        function(items) {
           createdPosts = items;
           createProfiles();
         }
@@ -752,7 +752,7 @@ function setup(done) {
 
 function clearAndCreate(model, data, callback) {
   var createdItems = [];
-  model.destroyAll(function () {
+  model.destroyAll(function() {
     nextItem(null, null);
   });
 
@@ -775,38 +775,38 @@ describe('Model instance with included relation .toJSON()', function() {
   var db, ChallengerModel, GameParticipationModel, ResultModel;
 
   before(function(done) {
-    db = new DataSource({connector: 'memory'});
+    db = new DataSource({ connector: 'memory' });
     ChallengerModel = db.createModel('Challenger',
       {
-        name: String
+        name: String,
       },
       {
         relations: {
           gameParticipations: {
             type: 'hasMany',
             model: 'GameParticipation',
-            foreignKey: ''
-          }
-        }
+            foreignKey: '',
+          },
+        },
       }
     );
     GameParticipationModel = db.createModel('GameParticipation',
       {
-        date: Date
+        date: Date,
       },
       {
         relations: {
           challenger: {
             type: 'belongsTo',
             model: 'Challenger',
-            foreignKey: ''
+            foreignKey: '',
           },
           results: {
             type: 'hasMany',
             model: 'Result',
-            foreignKey: ''
-          }
-        }
+            foreignKey: '',
+          },
+        },
       }
     );
     ResultModel = db.createModel('Result', {
@@ -816,9 +816,9 @@ describe('Model instance with included relation .toJSON()', function() {
         gameParticipation: {
           type: 'belongsTo',
           model: 'GameParticipation',
-          foreignKey: ''
-        }
-      }
+          foreignKey: '',
+        },
+      },
     });
 
     async.waterfall([
@@ -832,25 +832,25 @@ describe('Model instance with included relation .toJSON()', function() {
   });
 
   function createChallengers(callback) {
-    ChallengerModel.create([{name: 'challenger1'}, {name: 'challenger2'}], callback);
+    ChallengerModel.create([{ name: 'challenger1' }, { name: 'challenger2' }], callback);
   }
 
   function createGameParticipations(challengers, callback) {
     GameParticipationModel.create([
-      {challengerId: challengers[0].id, date: Date.now()},
-      {challengerId: challengers[0].id, date: Date.now()}
+      { challengerId: challengers[0].id, date: Date.now() },
+      { challengerId: challengers[0].id, date: Date.now() },
     ], callback);
   }
 
   function createResults(gameParticipations, callback) {
     ResultModel.create([
-      {gameParticipationId: gameParticipations[0].id, points: 10},
-      {gameParticipationId: gameParticipations[0].id, points: 20}
+      { gameParticipationId: gameParticipations[0].id, points: 10 },
+      { gameParticipationId: gameParticipations[0].id, points: 20 },
     ], callback);
   }
 
   it('should recursively serialize objects', function(done) {
-    var filter = {include: {gameParticipations: 'results'}};
+    var filter = { include: { gameParticipations: 'results' }};
     ChallengerModel.find(filter, function(err, challengers) {
 
       var levelOneInclusion = challengers[0].toJSON().gameParticipations[0];
diff --git a/test/include_util.test.js b/test/include_util.test.js
index 5be7edd8..65cf8891 100644
--- a/test/include_util.test.js
+++ b/test/include_util.test.js
@@ -3,44 +3,44 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-var assert = require("assert");
-var should = require("should");
+var assert = require('assert');
+var should = require('should');
 
-var includeUtils = require("../lib/include_utils");
+var includeUtils = require('../lib/include_utils');
 
-describe('include_util', function(){
-  describe('#buildOneToOneIdentityMapWithOrigKeys', function(){
-    it('should return an object with keys', function(){
+describe('include_util', function() {
+  describe('#buildOneToOneIdentityMapWithOrigKeys', function() {
+    it('should return an object with keys', function() {
       var objs = [
-          {id: 11, letter: "A"},
-          {id: 22, letter: "B"}
+          { id: 11, letter: 'A' },
+          { id: 22, letter: 'B' },
       ];
-      var result = includeUtils.buildOneToOneIdentityMapWithOrigKeys(objs, "id");
+      var result = includeUtils.buildOneToOneIdentityMapWithOrigKeys(objs, 'id');
       result.get(11).should.be.ok;
       result.get(22).should.be.ok;
     });
 
-    it('should overwrite keys in case of collision', function(){
-        var objs = [
-            {id: 11, letter: "A"},
-            {id: 22, letter: "B"},
-            {id: 33, letter: "C"},
-            {id: 11, letter: "HA!"}
-        ];
+    it('should overwrite keys in case of collision', function() {
+      var objs = [
+            { id: 11, letter: 'A' },
+            { id: 22, letter: 'B' },
+            { id: 33, letter: 'C' },
+            { id: 11, letter: 'HA!' },
+      ];
 
-        var result = includeUtils.buildOneToOneIdentityMapWithOrigKeys(objs, "id");
-        result.getKeys().should.containEql(11);
-        result.getKeys().should.containEql(22);
-        result.getKeys().should.containEql(33);
-        result.get(11)["letter"].should.equal("HA!");
-        result.get(33)["letter"].should.equal("C");
+      var result = includeUtils.buildOneToOneIdentityMapWithOrigKeys(objs, 'id');
+      result.getKeys().should.containEql(11);
+      result.getKeys().should.containEql(22);
+      result.getKeys().should.containEql(33);
+      result.get(11)['letter'].should.equal('HA!');
+      result.get(33)['letter'].should.equal('C');
     });
   });
-  describe('#buildOneToOneIdentityMapWithOrigKeys', function(){
-    it('should return an object with keys', function(){
+  describe('#buildOneToOneIdentityMapWithOrigKeys', function() {
+    it('should return an object with keys', function() {
       var objs = [
-        {id: 11, letter: "A"},
-        {id: 22, letter: "B"}
+        { id: 11, letter: 'A' },
+        { id: 22, letter: 'B' },
       ];
       var result = includeUtils.buildOneToOneIdentityMapWithOrigKeys(objs, 'id');
       result.get(11).should.be.ok;
@@ -48,36 +48,36 @@ describe('include_util', function(){
       result.getKeys().should.have.lengthOf(2);  // no additional properties
     });
   });
-  describe('#buildOneToManyIdentityMap', function(){
-        it('should return an object with keys', function(){
-            var objs = [
-                {id: 11, letter: "A"},
-                {id: 22, letter: "B"}
-            ];
-            var result = includeUtils.buildOneToManyIdentityMapWithOrigKeys(objs, "id");
-            result.exist(11).should.be.true;
-            result.exist(22).should.be.true;
-        });
-
-        it('should collect keys in case of collision', function(){
-            var objs = [
-                {fk_id: 11, letter: "A"},
-                {fk_id: 22, letter: "B"},
-                {fk_id: 33, letter: "C"},
-                {fk_id: 11, letter: "HA!"}
-            ];
-
-            var result = includeUtils.buildOneToManyIdentityMapWithOrigKeys(objs, "fk_id");
-            result.get(11)[0]["letter"].should.equal("A");
-            result.get(11)[1]["letter"].should.equal("HA!");
-            result.get(33)[0]["letter"].should.equal("C");
-        });
+  describe('#buildOneToManyIdentityMap', function() {
+    it('should return an object with keys', function() {
+      var objs = [
+                { id: 11, letter: 'A' },
+                { id: 22, letter: 'B' },
+          ];
+      var result = includeUtils.buildOneToManyIdentityMapWithOrigKeys(objs, 'id');
+      result.exist(11).should.be.true;
+      result.exist(22).should.be.true;
     });
+
+    it('should collect keys in case of collision', function() {
+      var objs = [
+                { fk_id: 11, letter: 'A' },
+                { fk_id: 22, letter: 'B' },
+                { fk_id: 33, letter: 'C' },
+                { fk_id: 11, letter: 'HA!' },
+          ];
+
+      var result = includeUtils.buildOneToManyIdentityMapWithOrigKeys(objs, 'fk_id');
+      result.get(11)[0]['letter'].should.equal('A');
+      result.get(11)[1]['letter'].should.equal('HA!');
+      result.get(33)[0]['letter'].should.equal('C');
+    });
+  });
 });
 
 
-describe('KVMap', function(){
-  it('should allow to set and get value with key string', function(){
+describe('KVMap', function() {
+  it('should allow to set and get value with key string', function() {
     var map = new includeUtils.KVMap();
     map.set('name', 'Alex');
     map.set('gender', true);
@@ -86,23 +86,23 @@ describe('KVMap', function(){
     map.get('gender').should.be.equal(true);
     map.get('age').should.be.equal(25);
   });
-  it('should allow to set and get value with arbitrary key type', function(){
+  it('should allow to set and get value with arbitrary key type', function() {
     var map = new includeUtils.KVMap();
     map.set('name', 'Alex');
     map.set(true, 'male');
     map.set(false, false);
-    map.set({isTrue: 'yes'}, 25);
+    map.set({ isTrue: 'yes' }, 25);
     map.get('name').should.be.equal('Alex');
     map.get(true).should.be.equal('male');
     map.get(false).should.be.equal(false);
-    map.get({isTrue: 'yes'}).should.be.equal(25);
+    map.get({ isTrue: 'yes' }).should.be.equal(25);
   });
-  it('should not allow to get values with [] operator', function(){
+  it('should not allow to get values with [] operator', function() {
     var map = new includeUtils.KVMap();
     map.set('name', 'Alex');
     (map['name'] === undefined).should.be.equal(true);
   });
-  it('should provide .exist() method for checking if key presented', function(){
+  it('should provide .exist() method for checking if key presented', function() {
     var map = new includeUtils.KVMap();
     map.set('one', 1);
     map.set(2, 'two');
@@ -112,7 +112,7 @@ describe('KVMap', function(){
     map.exist(true).should.be.true;
     map.exist('two').should.be.false;
   });
-  it('should return array of original keys with .getKeys()', function(){
+  it('should return array of original keys with .getKeys()', function() {
     var map = new includeUtils.KVMap();
     map.set('one', 1);
     map.set(2, 'two');
@@ -122,7 +122,7 @@ describe('KVMap', function(){
     keys.should.containEql(2);
     keys.should.containEql(true);
   });
-  it('should allow to store and fetch arrays', function(){
+  it('should allow to store and fetch arrays', function() {
     var map = new includeUtils.KVMap();
     map.set(1, [1, 2, 3]);
     map.set(2, [2, 3, 4]);
diff --git a/test/init.js b/test/init.js
index 73e53b66..038e201a 100644
--- a/test/init.js
+++ b/test/init.js
@@ -21,13 +21,13 @@ var ModelBuilder = require('../').ModelBuilder;
 var Schema = require('../').Schema;
 
 if (!('getSchema' in global)) {
-  global.getSchema = function (connector, settings) {
+  global.getSchema = function(connector, settings) {
     return new Schema(connector || 'memory', settings);
   };
 }
 
 if (!('getModelBuilder' in global)) {
-  global.getModelBuilder = function () {
+  global.getModelBuilder = function() {
     return new ModelBuilder();
   };
 }
diff --git a/test/introspection.test.js b/test/introspection.test.js
index 5086aa45..481007b4 100644
--- a/test/introspection.test.js
+++ b/test/introspection.test.js
@@ -19,19 +19,19 @@ var json = {
     city: 'San Jose',
     state: 'CA',
     zipcode: '95131',
-    country: 'US'
+    country: 'US',
   },
   friends: ['John', 'Mary'],
   emails: [
-    {label: 'work', id: 'x@sample.com'},
-    {label: 'home', id: 'x@home.com'}
+    { label: 'work', id: 'x@sample.com' },
+    { label: 'home', id: 'x@home.com' },
   ],
-  tags: []
+  tags: [],
 };
 
-describe('Introspection of model definitions from JSON', function () {
+describe('Introspection of model definitions from JSON', function() {
 
-  it('should handle simple types', function () {
+  it('should handle simple types', function() {
     assert.equal(introspectType('123'), 'string');
     assert.equal(introspectType(true), 'boolean');
     assert.equal(introspectType(false), 'boolean');
@@ -39,7 +39,7 @@ describe('Introspection of model definitions from JSON', function () {
     assert.equal(introspectType(new Date()), 'date');
   });
 
-  it('should handle array types', function () {
+  it('should handle array types', function() {
     var type = introspectType(['123']);
     assert.deepEqual(type, ['string'], 'type should be ["string"]');
     type = introspectType([1]);
@@ -54,21 +54,21 @@ describe('Introspection of model definitions from JSON', function () {
     assert.equal(type, 'array');
   });
 
-  it('should return Any for null or undefined', function () {
+  it('should return Any for null or undefined', function() {
     assert.equal(introspectType(null), ModelBuilder.Any);
     assert.equal(introspectType(undefined), ModelBuilder.Any);
   });
 
-  it('should return a schema for object', function () {
-    var json = {a: 'str', b: 0, c: true};
+  it('should return a schema for object', function() {
+    var json = { a: 'str', b: 0, c: true };
     var type = introspectType(json);
     assert.equal(type.a, 'string');
     assert.equal(type.b, 'number');
     assert.equal(type.c, 'boolean');
   });
 
-  it('should handle nesting objects', function () {
-    var json = {a: 'str', b: 0, c: true, d: {x: 10, y: 5}};
+  it('should handle nesting objects', function() {
+    var json = { a: 'str', b: 0, c: true, d: { x: 10, y: 5 }};
     var type = introspectType(json);
     assert.equal(type.a, 'string');
     assert.equal(type.b, 'number');
@@ -77,8 +77,8 @@ describe('Introspection of model definitions from JSON', function () {
     assert.equal(type.d.y, 'number');
   });
 
-  it('should handle nesting arrays', function () {
-    var json = {a: 'str', b: 0, c: true, d: [1, 2]};
+  it('should handle nesting arrays', function() {
+    var json = { a: 'str', b: 0, c: true, d: [1, 2] };
     var type = introspectType(json);
     assert.equal(type.a, 'string');
     assert.equal(type.b, 'number');
@@ -86,13 +86,13 @@ describe('Introspection of model definitions from JSON', function () {
     assert.deepEqual(type.d, ['number']);
   });
 
-  it('should build a model from the introspected schema', function (done) {
+  it('should build a model from the introspected schema', function(done) {
     var copy = traverse(json).clone();
 
     var schema = introspectType(json);
 
     var builder = new ModelBuilder();
-    var Model = builder.define('MyModel', schema, {idInjection: false});
+    var Model = builder.define('MyModel', schema, { idInjection: false });
 
     // FIXME: [rfeng] The constructor mutates the arguments
     var obj = new Model(json);
@@ -103,11 +103,11 @@ describe('Introspection of model definitions from JSON', function () {
     done();
   });
 
-  it('should build a model using buildModelFromInstance', function (done) {
+  it('should build a model using buildModelFromInstance', function(done) {
     var copy = traverse(json).clone();
 
     var builder = new ModelBuilder();
-    var Model = builder.buildModelFromInstance('MyModel', copy, {idInjection: false});
+    var Model = builder.buildModelFromInstance('MyModel', copy, { idInjection: false });
 
     var obj = new Model(json);
     obj = obj.toObject();
@@ -115,12 +115,12 @@ describe('Introspection of model definitions from JSON', function () {
     done();
   });
 
-  it('should build a model using DataSource.buildModelFromInstance', function (done) {
+  it('should build a model using DataSource.buildModelFromInstance', function(done) {
     var copy = traverse(json).clone();
 
     var builder = new DataSource('memory');
     var Model = builder.buildModelFromInstance('MyModel', copy,
-      {idInjection: false});
+      { idInjection: false });
 
     assert.equal(Model.dataSource, builder);
 
diff --git a/test/json.test.js b/test/json.test.js
index 27430e40..d21b2fab 100644
--- a/test/json.test.js
+++ b/test/json.test.js
@@ -9,33 +9,33 @@ var should = require('./init.js');
 var Schema = require('../').Schema;
 var ModelBuilder = require('../').ModelBuilder;
 
-describe('JSON property', function () {
+describe('JSON property', function() {
   var dataSource, Model;
 
-  it('should be defined', function () {
+  it('should be defined', function() {
     dataSource = getSchema();
-    Model = dataSource.define('Model', {propertyName: ModelBuilder.JSON});
+    Model = dataSource.define('Model', { propertyName: ModelBuilder.JSON });
     var m = new Model;
     (new Boolean('propertyName' in m)).should.eql(true);
     should.not.exist(m.propertyName);
   });
 
-  it('should accept JSON in constructor and return object', function () {
+  it('should accept JSON in constructor and return object', function() {
     var m = new Model({
-      propertyName: '{"foo": "bar"}'
+      propertyName: '{"foo": "bar"}',
     });
     m.propertyName.should.be.an.Object;
     m.propertyName.foo.should.equal('bar');
   });
 
-  it('should accept object in setter and return object', function () {
+  it('should accept object in setter and return object', function() {
     var m = new Model;
-    m.propertyName = {"foo": "bar"};
+    m.propertyName = { 'foo': 'bar' };
     m.propertyName.should.be.an.Object;
     m.propertyName.foo.should.equal('bar');
   });
 
-  it('should accept string in setter and return string', function () {
+  it('should accept string in setter and return string', function() {
     var m = new Model;
     m.propertyName = '{"foo": "bar"}';
     m.propertyName.should.be.a.String;
diff --git a/test/loopback-data.test.js b/test/loopback-data.test.js
index bc90c098..05e9fa22 100644
--- a/test/loopback-data.test.js
+++ b/test/loopback-data.test.js
@@ -8,8 +8,8 @@ var should = require('./init.js');
 
 var loopbackData = require('../');
 
-describe('loopback-datasource-juggler', function () {
-  it('should expose version', function () {
+describe('loopback-datasource-juggler', function() {
+  it('should expose version', function() {
     loopbackData.version.should.equal(require('../package.json').version);
   });
 });
diff --git a/test/loopback-dl.test.js b/test/loopback-dl.test.js
index d8f3c438..0ea60b79 100644
--- a/test/loopback-dl.test.js
+++ b/test/loopback-dl.test.js
@@ -12,9 +12,9 @@ var jdb = require('../');
 var ModelBuilder = jdb.ModelBuilder;
 var DataSource = jdb.DataSource;
 
-describe('ModelBuilder define model', function () {
+describe('ModelBuilder define model', function() {
 
-  it('should be able to define plain models', function (done) {
+  it('should be able to define plain models', function(done) {
     var modelBuilder = new ModelBuilder();
 
     var User = modelBuilder.define('User', {
@@ -22,18 +22,18 @@ describe('ModelBuilder define model', function () {
       bio: ModelBuilder.Text,
       approved: Boolean,
       joinedAt: Date,
-      age: Number
+      age: Number,
     });
 
     // define any custom method
-    User.prototype.getNameAndAge = function () {
+    User.prototype.getNameAndAge = function() {
       return this.name + ', ' + this.age;
     };
 
     modelBuilder.models.should.be.type('object').and.have.property('User').exactly(User);
     modelBuilder.definitions.should.be.type('object').and.have.property('User');
 
-    var user = new User({name: 'Joe', age: 20, xyz: false});
+    var user = new User({ name: 'Joe', age: 20, xyz: false });
 
     User.modelName.should.equal('User');
     user.should.be.type('object').and.have.property('name', 'Joe');
@@ -44,12 +44,12 @@ describe('ModelBuilder define model', function () {
     done(null, User);
   });
 
-  it('should not take unknown properties in strict mode', function (done) {
+  it('should not take unknown properties in strict mode', function(done) {
     var modelBuilder = new ModelBuilder();
 
-    var User = modelBuilder.define('User', {name: String, bio: String}, {strict: true});
+    var User = modelBuilder.define('User', { name: String, bio: String }, { strict: true });
 
-    var user = new User({name: 'Joe', age: 20});
+    var user = new User({ name: 'Joe', age: 20 });
 
     User.modelName.should.equal('User');
     user.should.be.type('object');
@@ -61,12 +61,12 @@ describe('ModelBuilder define model', function () {
     done(null, User);
   });
 
-  it('should ignore non-predefined properties in strict mode', function (done) {
+  it('should ignore non-predefined properties in strict mode', function(done) {
     var modelBuilder = new ModelBuilder();
 
-    var User = modelBuilder.define('User', {name: String, bio: String}, {strict: true});
+    var User = modelBuilder.define('User', { name: String, bio: String }, { strict: true });
 
-    var user = new User({name: 'Joe'});
+    var user = new User({ name: 'Joe' });
     user.age = 10;
     user.bio = 'me';
 
@@ -85,13 +85,13 @@ describe('ModelBuilder define model', function () {
     done(null, User);
   });
 
-  it('should throw when unknown properties are used if strict=throw', function (done) {
+  it('should throw when unknown properties are used if strict=throw', function(done) {
     var modelBuilder = new ModelBuilder();
 
-    var User = modelBuilder.define('User', {name: String, bio: String}, {strict: 'throw'});
+    var User = modelBuilder.define('User', { name: String, bio: String }, { strict: 'throw' });
 
     try {
-      var user = new User({name: 'Joe', age: 20});
+      var user = new User({ name: 'Joe', age: 20 });
       assert(false, 'The code should have thrown an error');
     } catch (e) {
       assert(true, 'The code is expected to throw an error');
@@ -99,12 +99,12 @@ describe('ModelBuilder define model', function () {
     done(null, User);
   });
 
-  it('should be able to define open models', function (done) {
+  it('should be able to define open models', function(done) {
     var modelBuilder = new ModelBuilder();
 
-    var User = modelBuilder.define('User', {}, {strict: false});
+    var User = modelBuilder.define('User', {}, { strict: false });
 
-    var user = new User({name: 'Joe', age: 20});
+    var user = new User({ name: 'Joe', age: 20 });
 
     User.modelName.should.equal('User');
     user.should.be.type('object').and.have.property('name', 'Joe');
@@ -114,12 +114,12 @@ describe('ModelBuilder define model', function () {
     done(null, User);
   });
 
-  it('should take non-predefined properties in non-strict mode', function (done) {
+  it('should take non-predefined properties in non-strict mode', function(done) {
     var modelBuilder = new ModelBuilder();
 
-    var User = modelBuilder.define('User', {name: String, bio: String}, {strict: false});
+    var User = modelBuilder.define('User', { name: String, bio: String }, { strict: false });
 
-    var user = new User({name: 'Joe'});
+    var user = new User({ name: 'Joe' });
     user.age = 10;
     user.bio = 'me';
 
@@ -139,12 +139,12 @@ describe('ModelBuilder define model', function () {
     done(null, User);
   });
 
-  it('should use false as the default value for strict', function (done) {
+  it('should use false as the default value for strict', function(done) {
     var modelBuilder = new ModelBuilder();
 
     var User = modelBuilder.define('User', {});
 
-    var user = new User({name: 'Joe', age: 20});
+    var user = new User({ name: 'Joe', age: 20 });
 
     User.modelName.should.equal('User');
     user.should.be.type('object').and.have.property('name', 'Joe');
@@ -154,7 +154,7 @@ describe('ModelBuilder define model', function () {
     done(null, User);
   });
 
-  it('should be able to define nesting models', function (done) {
+  it('should be able to define nesting models', function(done) {
     var modelBuilder = new ModelBuilder();
 
     // simplier way to describe model
@@ -169,19 +169,19 @@ describe('ModelBuilder define model', function () {
         city: String,
         state: String,
         zipCode: String,
-        country: String
+        country: String,
       },
       emails: [
         {
           label: String,
-          email: String
-        }
+          email: String,
+        },
       ],
-      friends: [String]
+      friends: [String],
     });
 
     // define any custom method
-    User.prototype.getNameAndAge = function () {
+    User.prototype.getNameAndAge = function() {
       return this.name + ', ' + this.age;
     };
 
@@ -190,11 +190,11 @@ describe('ModelBuilder define model', function () {
 
     var user = new User({
       name: 'Joe', age: 20,
-      address: {street: '123 Main St', 'city': 'San Jose', state: 'CA'},
+      address: { street: '123 Main St', 'city': 'San Jose', state: 'CA' },
       emails: [
-        {label: 'work', email: 'xyz@sample.com'}
+        { label: 'work', email: 'xyz@sample.com' },
       ],
-      friends: ['Mary', 'John']
+      friends: ['Mary', 'John'],
     });
 
     User.modelName.should.equal('User');
@@ -216,14 +216,14 @@ describe('ModelBuilder define model', function () {
     done(null, User);
   });
 
-  it('should be able to reference models by name before they are defined', function (done) {
+  it('should be able to reference models by name before they are defined', function(done) {
     var modelBuilder = new ModelBuilder();
 
-    var User = modelBuilder.define('User', {name: String, address: 'Address'});
+    var User = modelBuilder.define('User', { name: String, address: 'Address' });
 
     var user;
     try {
-      user = new User({name: 'Joe', address: {street: '123 Main St', 'city': 'San Jose', state: 'CA'}});
+      user = new User({ name: 'Joe', address: { street: '123 Main St', 'city': 'San Jose', state: 'CA' }});
       assert(false, 'An exception should have been thrown');
     } catch (e) {
       // Ignore
@@ -234,10 +234,10 @@ describe('ModelBuilder define model', function () {
       city: String,
       state: String,
       zipCode: String,
-      country: String
+      country: String,
     });
 
-    user = new User({name: 'Joe', address: {street: '123 Main St', 'city': 'San Jose', state: 'CA'}});
+    user = new User({ name: 'Joe', address: { street: '123 Main St', 'city': 'San Jose', state: 'CA' }});
 
     User.modelName.should.equal('User');
     User.definition.properties.address.should.have.property('type', Address);
@@ -248,12 +248,12 @@ describe('ModelBuilder define model', function () {
     done(null, User);
   });
 
-  it('should define an id property for composite ids', function () {
+  it('should define an id property for composite ids', function() {
     var modelBuilder = new ModelBuilder();
     var Follow = modelBuilder.define('Follow', {
       followerId: { type: String, id: 1 },
       followeeId: { type: String, id: 2 },
-      followAt: Date
+      followAt: Date,
     });
     var follow = new Follow({ followerId: 1, followeeId: 2 });
 
@@ -272,7 +272,7 @@ describe('DataSource ping', function() {
   };
   ds.connector.ping = function(cb) {
     cb(new Error('bad connection 2'));
-  }
+  };
 
   it('should report connection errors during ping', function(done) {
     ds.ping(function(err) {
@@ -285,7 +285,7 @@ describe('DataSource ping', function() {
   it('should cancel invocation after timeout', function(done) {
     ds.connected = false; // Force connect
     var Post = ds.define('Post', {
-      title: { type: String, length: 255 }
+      title: { type: String, length: 255 },
     });
     Post.create(function(err) {
       (!!err).should.be.true;
@@ -295,19 +295,19 @@ describe('DataSource ping', function() {
   });
 });
 
-describe('DataSource define model', function () {
-  it('should be able to define plain models', function () {
+describe('DataSource define model', function() {
+  it('should be able to define plain models', function() {
     var ds = new DataSource('memory');
 
 // define models
     var Post = ds.define('Post', {
       title: { type: String, length: 255 },
       content: { type: ModelBuilder.Text },
-      date: { type: Date, default: function () {
+      date: { type: Date, default: function() {
         return new Date();
       } },
       timestamp: { type: Number, default: Date.now },
-      published: { type: Boolean, default: false, index: true }
+      published: { type: Boolean, default: false, index: true },
     });
 
 // simpler way to describe model
@@ -315,63 +315,63 @@ describe('DataSource define model', function () {
       name: String,
       bio: ModelBuilder.Text,
       approved: Boolean,
-      joinedAt: {type: Date, default: Date},
-      age: Number
+      joinedAt: { type: Date, default: Date },
+      age: Number,
     });
 
-    var Group = ds.define('Group', {group: String});
+    var Group = ds.define('Group', { group: String });
     User.mixin(Group);
 
 // define any custom method
-    User.prototype.getNameAndAge = function () {
+    User.prototype.getNameAndAge = function() {
       return this.name + ', ' + this.age;
     };
 
-    var user = new User({name: 'Joe', group: 'G1'});
+    var user = new User({ name: 'Joe', group: 'G1' });
     assert.equal(user.name, 'Joe');
     assert.equal(user.group, 'G1');
 
     assert(user.joinedAt instanceof Date);
 
     // setup relationships
-    User.hasMany(Post, {as: 'posts', foreignKey: 'userId'});
+    User.hasMany(Post, { as: 'posts', foreignKey: 'userId' });
 
-    Post.belongsTo(User, {as: 'author', foreignKey: 'userId'});
+    Post.belongsTo(User, { as: 'author', foreignKey: 'userId' });
 
     User.hasAndBelongsToMany('groups');
 
-    var user2 = new User({name: 'Smith'});
-    user2.save(function (err) {
-      var post = user2.posts.build({title: 'Hello world'});
-      post.save(function (err, data) {
+    var user2 = new User({ name: 'Smith' });
+    user2.save(function(err) {
+      var post = user2.posts.build({ title: 'Hello world' });
+      post.save(function(err, data) {
         // console.log(err ? err : data);
       });
     });
 
-    Post.findOne({where: {published: false}, order: 'date DESC'}, function (err, data) {
+    Post.findOne({ where: { published: false }, order: 'date DESC' }, function(err, data) {
       // console.log(data);
     });
 
-    User.create({name: 'Jeff'}, function (err, data) {
+    User.create({ name: 'Jeff' }, function(err, data) {
       if (err) {
         console.log(err);
         return;
       }
-      var post = data.posts.build({title: 'My Post'});
+      var post = data.posts.build({ title: 'My Post' });
     });
 
-    User.create({name: 'Ray'}, function (err, data) {
+    User.create({ name: 'Ray' }, function(err, data) {
       // console.log(data);
     });
 
-    var Article = ds.define('Article', {title: String});
-    var Tag = ds.define('Tag', {name: String});
+    var Article = ds.define('Article', { title: String });
+    var Tag = ds.define('Tag', { name: String });
     Article.hasAndBelongsToMany('tags');
 
-    Article.create(function (e, article) {
-      article.tags.create({name: 'popular'}, function (err, data) {
-        Article.findOne(function (e, article) {
-          article.tags(function (e, tags) {
+    Article.create(function(e, article) {
+      article.tags.create({ name: 'popular' }, function(err, data) {
+        Article.findOne(function(e, article) {
+          article.tags(function(e, tags) {
             // console.log(tags);
           });
         });
@@ -382,7 +382,7 @@ describe('DataSource define model', function () {
     var modelBuilder = new ModelBuilder();
 
     var Color = modelBuilder.define('Color', {
-      name: String
+      name: String,
     });
 
     Color.should.not.have.property('create');
@@ -391,11 +391,11 @@ describe('DataSource define model', function () {
     ds.attach(Color);
     Color.should.have.property('create');
 
-    Color.create({name: 'red'});
-    Color.create({name: 'green'});
-    Color.create({name: 'blue'});
+    Color.create({ name: 'red' });
+    Color.create({ name: 'green' });
+    Color.create({ name: 'blue' });
 
-    Color.all(function (err, colors) {
+    Color.all(function(err, colors) {
       colors.should.have.lengthOf(3);
     });
 
@@ -406,20 +406,20 @@ describe('DataSource define model', function () {
     var modelBuilder = new ModelBuilder();
 
     var User = modelBuilder.define('User', {
-      name: String
+      name: String,
     });
 
     var seq = 0;
     var dataAccessConfigured = -1;
     var dataSourceAttached = -1;
 
-    User.on('dataAccessConfigured', function (model) {
+    User.on('dataAccessConfigured', function(model) {
       dataAccessConfigured = seq++;
       assert(User.create);
       assert(User.hasMany);
     });
 
-    User.on('dataSourceAttached', function (model) {
+    User.on('dataSourceAttached', function(model) {
       assert(User.dataSource instanceof DataSource);
       dataSourceAttached = seq++;
     });
@@ -429,12 +429,12 @@ describe('DataSource define model', function () {
     assert.equal(dataSourceAttached, 1);
   });
 
-  it('should not take unknown properties in strict mode', function (done) {
+  it('should not take unknown properties in strict mode', function(done) {
     var ds = new DataSource('memory');
 
-    var User = ds.define('User', {name: String, bio: String}, {strict: true});
+    var User = ds.define('User', { name: String, bio: String }, { strict: true });
 
-    User.create({name: 'Joe', age: 20}, function (err, user) {
+    User.create({ name: 'Joe', age: 20 }, function(err, user) {
 
       User.modelName.should.equal('User');
       user.should.be.type('object');
@@ -447,13 +447,13 @@ describe('DataSource define model', function () {
     });
   });
 
-  it('should throw when unknown properties are used if strict=throw', function (done) {
+  it('should throw when unknown properties are used if strict=throw', function(done) {
     var ds = new DataSource('memory');
 
-    var User = ds.define('User', {name: String, bio: String}, {strict: 'throw'});
+    var User = ds.define('User', { name: String, bio: String }, { strict: 'throw' });
 
     try {
-      var user = new User({name: 'Joe', age: 20});
+      var user = new User({ name: 'Joe', age: 20 });
       assert(false, 'The code should have thrown an error');
     } catch (e) {
       assert(true, 'The code is expected to throw an error');
@@ -472,20 +472,20 @@ describe('DataSource define model', function () {
     });
   });
 
-  it('should be able to define open models', function (done) {
+  it('should be able to define open models', function(done) {
     var ds = new DataSource('memory');
 
-    var User = ds.define('User', {}, {strict: false});
+    var User = ds.define('User', {}, { strict: false });
     User.modelName.should.equal('User');
 
-    User.create({name: 'Joe', age: 20}, function (err, user) {
+    User.create({ name: 'Joe', age: 20 }, function(err, user) {
 
       user.should.be.type('object').and.have.property('name', 'Joe');
       user.should.have.property('name', 'Joe');
       user.should.have.property('age', 20);
       user.should.not.have.property('bio');
 
-      User.findById(user.id, function (err, user) {
+      User.findById(user.id, function(err, user) {
         user.should.be.type('object').and.have.property('name', 'Joe');
         user.should.have.property('name', 'Joe');
         user.should.have.property('age', 20);
@@ -495,12 +495,12 @@ describe('DataSource define model', function () {
     });
   });
 
-  it('should use false as the default value for strict', function (done) {
+  it('should use false as the default value for strict', function(done) {
     var ds = new DataSource('memory');
 
     var User = ds.define('User', {});
 
-    User.create({name: 'Joe', age: 20}, function (err, user) {
+    User.create({ name: 'Joe', age: 20 }, function(err, user) {
 
       User.modelName.should.equal('User');
       user.should.be.type('object').and.have.property('name', 'Joe');
@@ -511,13 +511,13 @@ describe('DataSource define model', function () {
     });
   });
 
-  it('should use true as the default value for strict for relational DBs', function (done) {
+  it('should use true as the default value for strict for relational DBs', function(done) {
     var ds = new DataSource('memory');
     ds.connector.relational = true; // HACK
 
-    var User = ds.define('User', {name: String, bio: String}, {strict: true});
+    var User = ds.define('User', { name: String, bio: String }, { strict: true });
 
-    var user = new User({name: 'Joe', age: 20});
+    var user = new User({ name: 'Joe', age: 20 });
 
     User.modelName.should.equal('User');
     user.should.be.type('object');
@@ -529,14 +529,14 @@ describe('DataSource define model', function () {
     done(null, User);
   });
 
-  it('should throw when unknown properties are used if strict=false for relational DBs', function (done) {
+  it('should throw when unknown properties are used if strict=false for relational DBs', function(done) {
     var ds = new DataSource('memory');
     ds.connector.relational = true; // HACK
 
-    var User = ds.define('User', {name: String, bio: String}, {strict: 'throw'});
+    var User = ds.define('User', { name: String, bio: String }, { strict: 'throw' });
 
     try {
-      var user = new User({name: 'Joe', age: 20});
+      var user = new User({ name: 'Joe', age: 20 });
       assert(false, 'The code should have thrown an error');
     } catch (e) {
       assert(true, 'The code is expected to throw an error');
@@ -544,26 +544,26 @@ describe('DataSource define model', function () {
     done(null, User);
   });
 
-  it('should change the property value for save if strict=false', function (done) {
+  it('should change the property value for save if strict=false', function(done) {
     var ds = new DataSource('memory');// define models
     var Post = ds.define('Post');
 
-    Post.create({price: 900}, function (err, post) {
+    Post.create({ price: 900 }, function(err, post) {
       assert.equal(post.price, 900);
       post.price = 1000;
-      post.save(function (err, result) {
+      post.save(function(err, result) {
         assert.equal(1000, result.price);
         done(err, result);
       });
     });
   });
 
-  it('supports instance level strict mode', function () {
+  it('supports instance level strict mode', function() {
     var ds = new DataSource('memory');
 
-    var User = ds.define('User', {name: String, bio: String}, {strict: true});
+    var User = ds.define('User', { name: String, bio: String }, { strict: true });
 
-    var user = new User({name: 'Joe', age: 20}, {strict: false});
+    var user = new User({ name: 'Joe', age: 20 }, { strict: false });
 
     user.should.have.property('__strict', false);
     user.should.be.type('object');
@@ -579,21 +579,21 @@ describe('DataSource define model', function () {
 
   });
 
-  it('should update the instance with unknown properties', function (done) {
+  it('should update the instance with unknown properties', function(done) {
     var ds = new DataSource('memory');// define models
     Post = ds.define('Post', {
       title: { type: String, length: 255, index: true },
-      content: { type: String }
+      content: { type: String },
     });
 
-    Post.create({title: 'a', content: 'AAA'}, function (err, post) {
-      post.updateAttributes({title: 'b', xyz: 'xyz'}, function (err, p) {
+    Post.create({ title: 'a', content: 'AAA' }, function(err, post) {
+      post.updateAttributes({ title: 'b', xyz: 'xyz' }, function(err, p) {
         should.not.exist(err);
         p.id.should.be.equal(post.id);
         p.content.should.be.equal(post.content);
         p.xyz.should.be.equal('xyz');
 
-        Post.findById(post.id, function (err, p) {
+        Post.findById(post.id, function(err, p) {
           p.id.should.be.equal(post.id);
           p.content.should.be.equal(post.content);
           p.xyz.should.be.equal('xyz');
@@ -605,72 +605,72 @@ describe('DataSource define model', function () {
     });
   });
 
-  it('injects id by default', function (done) {
+  it('injects id by default', function(done) {
     var ds = new ModelBuilder();
 
     var User = ds.define('User', {});
     assert.deepEqual(User.definition.properties.id,
-      {type: Number, id: 1, generated: true});
+      { type: Number, id: 1, generated: true });
 
     done();
   });
 
-  it('disables idInjection if the value is false', function (done) {
+  it('disables idInjection if the value is false', function(done) {
     var ds = new ModelBuilder();
 
-    var User1 = ds.define('User', {}, {idInjection: false});
+    var User1 = ds.define('User', {}, { idInjection: false });
     assert(!User1.definition.properties.id);
     done();
   });
 
-  it('updates generated id type by the connector', function (done) {
+  it('updates generated id type by the connector', function(done) {
     var builder = new ModelBuilder();
 
-    var User = builder.define('User', {id: {type: String, generated: true, id: true}});
+    var User = builder.define('User', { id: { type: String, generated: true, id: true }});
     assert.deepEqual(User.definition.properties.id,
-      {type: String, id: 1, generated: true});
+      { type: String, id: 1, generated: true });
 
     var ds = new DataSource('memory');// define models
     User.attachTo(ds);
 
     assert.deepEqual(User.definition.properties.id,
-      {type: Number, id: 1, generated: true});
+      { type: Number, id: 1, generated: true });
 
     done();
   });
 
-  it('should allow an explicit remoting path', function () {
+  it('should allow an explicit remoting path', function() {
     var ds = new DataSource('memory');
 
-    var User = ds.define('User', {name: String, bio: String}, {
-      http: { path: 'accounts' }
+    var User = ds.define('User', { name: String, bio: String }, {
+      http: { path: 'accounts' },
     });
     User.http.path.should.equal('/accounts');
   });
 
-  it('should allow an explicit remoting path with leading /', function () {
+  it('should allow an explicit remoting path with leading /', function() {
     var ds = new DataSource('memory');
 
-    var User = ds.define('User', {name: String, bio: String}, {
-      http: { path: '/accounts' }
+    var User = ds.define('User', { name: String, bio: String }, {
+      http: { path: '/accounts' },
     });
     User.http.path.should.equal('/accounts');
   });
 
 });
 
-describe('Load models with base', function () {
-  it('should set up base class via base option', function () {
+describe('Load models with base', function() {
+  it('should set up base class via base option', function() {
     var ds = new ModelBuilder();
 
-    var User = ds.define('User', {name: String});
+    var User = ds.define('User', { name: String });
 
     User.staticMethod = function staticMethod() {
     };
     User.prototype.instanceMethod = function instanceMethod() {
     };
 
-    var Customer = ds.define('Customer', {vip: Boolean}, {base: 'User'});
+    var Customer = ds.define('Customer', { vip: Boolean }, { base: 'User' });
 
     assert(Customer.prototype instanceof User);
     assert(Customer.staticMethod === User.staticMethod);
@@ -679,30 +679,30 @@ describe('Load models with base', function () {
     assert.equal(Customer.base, Customer.super_);
 
     try {
-      var Customer1 = ds.define('Customer1', {vip: Boolean}, {base: 'User1'});
+      var Customer1 = ds.define('Customer1', { vip: Boolean }, { base: 'User1' });
     } catch (e) {
       assert(e);
     }
   });
 
-  it('should inherit properties from base option', function () {
+  it('should inherit properties from base option', function() {
     var ds = new ModelBuilder();
 
-    var User = ds.define('User', {name: String});
+    var User = ds.define('User', { name: String });
 
-    var Customer = ds.define('Customer', {vip: Boolean}, {base: 'User'});
+    var Customer = ds.define('Customer', { vip: Boolean }, { base: 'User' });
 
     Customer.definition.properties.should.have.property('name');
     Customer.definition.properties.name.should.have.property('type', String);
   });
 
-  it('should inherit properties by clone from base option', function () {
+  it('should inherit properties by clone from base option', function() {
     var ds = new ModelBuilder();
 
-    var User = ds.define('User', {name: String});
+    var User = ds.define('User', { name: String });
 
-    var Customer1 = ds.define('Customer1', {vip: Boolean}, {base: 'User'});
-    var Customer2 = ds.define('Customer2', {vip: Boolean}, {base: 'User'});
+    var Customer1 = ds.define('Customer1', { vip: Boolean }, { base: 'User' });
+    var Customer2 = ds.define('Customer2', { vip: Boolean }, { base: 'User' });
 
     Customer1.definition.properties.should.have.property('name');
     Customer2.definition.properties.should.have.property('name');
@@ -715,38 +715,38 @@ describe('Load models with base', function () {
   it('should revert properties from base model', function() {
     var ds = new ModelBuilder();
 
-    var User = ds.define('User', {username: String, email: String});
+    var User = ds.define('User', { username: String, email: String });
 
     var Customer = ds.define('Customer',
-      {name: String, username: null, email: false},
-      {base: 'User'});
+      { name: String, username: null, email: false },
+      { base: 'User' });
 
     Customer.definition.properties.should.have.property('name');
     // username/email are now shielded
     Customer.definition.properties.should.not.have.property('username');
     Customer.definition.properties.should.not.have.property('email');
-    var c = new Customer({name: 'John'});
+    var c = new Customer({ name: 'John' });
     c.should.have.property('username', undefined);
     c.should.have.property('email', undefined);
     c.should.have.property('name', 'John');
-    var u = new User({username: 'X', email: 'x@y.com'});
+    var u = new User({ username: 'X', email: 'x@y.com' });
     u.should.not.have.property('name');
     u.should.have.property('username', 'X');
     u.should.have.property('email', 'x@y.com');
   });
 
 
-  it('should set up base class via parent arg', function () {
+  it('should set up base class via parent arg', function() {
     var ds = new ModelBuilder();
 
-    var User = ds.define('User', {name: String});
+    var User = ds.define('User', { name: String });
 
     User.staticMethod = function staticMethod() {
     };
     User.prototype.instanceMethod = function instanceMethod() {
     };
 
-    var Customer = ds.define('Customer', {vip: Boolean}, {}, User);
+    var Customer = ds.define('Customer', { vip: Boolean }, {}, User);
 
     Customer.definition.properties.should.have.property('name');
     Customer.definition.properties.name.should.have.property('type', String);
@@ -766,7 +766,7 @@ describe('Models attached to a dataSource', function() {
     Post = ds.define('Post', {
       title: { type: String, length: 255, index: true },
       content: { type: String },
-      comments: [String]
+      comments: [String],
     });
   });
 
@@ -774,16 +774,16 @@ describe('Models attached to a dataSource', function() {
     Post.destroyAll(done);
   });
 
-  it('updateOrCreate should update the instance', function (done) {
-    Post.create({title: 'a', content: 'AAA'}, function (err, post) {
+  it('updateOrCreate should update the instance', function(done) {
+    Post.create({ title: 'a', content: 'AAA' }, function(err, post) {
       post.title = 'b';
-      Post.updateOrCreate(post, function (err, p) {
+      Post.updateOrCreate(post, function(err, p) {
         should.not.exist(err);
         p.id.should.be.equal(post.id);
         p.content.should.be.equal(post.content);
         should.not.exist(p._id);
 
-        Post.findById(post.id, function (err, p) {
+        Post.findById(post.id, function(err, p) {
           p.id.should.be.equal(post.id);
           should.not.exist(p._id);
           p.content.should.be.equal(post.content);
@@ -796,18 +796,18 @@ describe('Models attached to a dataSource', function() {
     });
   });
 
-  it('updateOrCreate should update the instance without removing existing properties', function (done) {
-    Post.create({title: 'a', content: 'AAA', comments: ['Comment1']}, function (err, post) {
+  it('updateOrCreate should update the instance without removing existing properties', function(done) {
+    Post.create({ title: 'a', content: 'AAA', comments: ['Comment1'] }, function(err, post) {
       post = post.toObject();
       delete post.title;
       delete post.comments;
-      Post.updateOrCreate(post, function (err, p) {
+      Post.updateOrCreate(post, function(err, p) {
         should.not.exist(err);
         p.id.should.be.equal(post.id);
         p.content.should.be.equal(post.content);
         should.not.exist(p._id);
 
-        Post.findById(post.id, function (err, p) {
+        Post.findById(post.id, function(err, p) {
           p.id.should.be.equal(post.id);
           should.not.exist(p._id);
           p.content.should.be.equal(post.content);
@@ -821,15 +821,15 @@ describe('Models attached to a dataSource', function() {
     });
   });
 
-  it('updateOrCreate should create a new instance if it does not exist', function (done) {
-    var post = {id: 123, title: 'a', content: 'AAA'};
-    Post.updateOrCreate(post, function (err, p) {
+  it('updateOrCreate should create a new instance if it does not exist', function(done) {
+    var post = { id: 123, title: 'a', content: 'AAA' };
+    Post.updateOrCreate(post, function(err, p) {
       should.not.exist(err);
       p.title.should.be.equal(post.title);
       p.content.should.be.equal(post.content);
       p.id.should.be.equal(post.id);
 
-      Post.findById(p.id, function (err, p) {
+      Post.findById(p.id, function(err, p) {
         p.id.should.be.equal(post.id);
         should.not.exist(p._id);
         p.content.should.be.equal(post.content);
@@ -842,16 +842,16 @@ describe('Models attached to a dataSource', function() {
 
   });
 
-  it('save should update the instance with the same id', function (done) {
-    Post.create({title: 'a', content: 'AAA'}, function (err, post) {
+  it('save should update the instance with the same id', function(done) {
+    Post.create({ title: 'a', content: 'AAA' }, function(err, post) {
       post.title = 'b';
-      post.save(function (err, p) {
+      post.save(function(err, p) {
         should.not.exist(err);
         p.id.should.be.equal(post.id);
         p.content.should.be.equal(post.content);
         should.not.exist(p._id);
 
-        Post.findById(post.id, function (err, p) {
+        Post.findById(post.id, function(err, p) {
           p.id.should.be.equal(post.id);
           should.not.exist(p._id);
           p.content.should.be.equal(post.content);
@@ -864,16 +864,16 @@ describe('Models attached to a dataSource', function() {
     });
   });
 
-  it('save should update the instance without removing existing properties', function (done) {
-    Post.create({title: 'a', content: 'AAA'}, function (err, post) {
+  it('save should update the instance without removing existing properties', function(done) {
+    Post.create({ title: 'a', content: 'AAA' }, function(err, post) {
       delete post.title;
-      post.save(function (err, p) {
+      post.save(function(err, p) {
         should.not.exist(err);
         p.id.should.be.equal(post.id);
         p.content.should.be.equal(post.content);
         should.not.exist(p._id);
 
-        Post.findById(post.id, function (err, p) {
+        Post.findById(post.id, function(err, p) {
           p.id.should.be.equal(post.id);
           should.not.exist(p._id);
           p.content.should.be.equal(post.content);
@@ -886,15 +886,15 @@ describe('Models attached to a dataSource', function() {
     });
   });
 
-  it('save should create a new instance if it does not exist', function (done) {
-    var post = new Post({id: '123', title: 'a', content: 'AAA'});
-    post.save(post, function (err, p) {
+  it('save should create a new instance if it does not exist', function(done) {
+    var post = new Post({ id: '123', title: 'a', content: 'AAA' });
+    post.save(post, function(err, p) {
       should.not.exist(err);
       p.title.should.be.equal(post.title);
       p.content.should.be.equal(post.content);
       p.id.should.be.equal(post.id);
 
-      Post.findById(p.id, function (err, p) {
+      Post.findById(p.id, function(err, p) {
         p.id.should.be.equal(post.id);
         should.not.exist(p._id);
         p.content.should.be.equal(post.content);
@@ -944,9 +944,9 @@ describe('DataSource connector types', function() {
 
 });
 
-describe('DataSource constructor', function () {
+describe('DataSource constructor', function() {
   // Mocked require
-  var loader = function (name) {
+  var loader = function(name) {
     if (name.indexOf('./connectors/') !== -1) {
       // ./connectors/<name> doesn't exist
       return null;
@@ -956,107 +956,107 @@ describe('DataSource constructor', function () {
       return null;
     }
     return {
-      name: name
+      name: name,
     };
   };
 
-  it('should resolve connector by path', function () {
+  it('should resolve connector by path', function() {
     var connector = DataSource._resolveConnector(__dirname + '/../lib/connectors/memory');
     assert(connector.connector);
   });
-  it('should resolve connector by internal name', function () {
+  it('should resolve connector by internal name', function() {
     var connector = DataSource._resolveConnector('memory');
     assert(connector.connector);
   });
-  it('should try to resolve connector by module name starts with loopback-connector-', function () {
+  it('should try to resolve connector by module name starts with loopback-connector-', function() {
     var connector = DataSource._resolveConnector('loopback-connector-xyz', loader);
     assert(connector.connector);
   });
-  it('should try to resolve connector by short module name with full name first', function () {
+  it('should try to resolve connector by short module name with full name first', function() {
     var connector = DataSource._resolveConnector('xyz', loader);
     assert(connector.connector);
     assert.equal(connector.connector.name, 'loopback-connector-xyz');
   });
-  it('should try to resolve connector by short module name', function () {
+  it('should try to resolve connector by short module name', function() {
     var connector = DataSource._resolveConnector('abc', loader);
     assert(connector.connector);
     assert.equal(connector.connector.name, 'abc');
   });
-  it('should try to resolve connector by short module name for known connectors', function () {
+  it('should try to resolve connector by short module name for known connectors', function() {
     var connector = DataSource._resolveConnector('oracle', loader);
     assert(connector.connector);
     assert.equal(connector.connector.name, 'loopback-connector-oracle');
   });
-  it('should try to resolve connector by full module name', function () {
+  it('should try to resolve connector by full module name', function() {
     var connector = DataSource._resolveConnector('loopback-xyz', loader);
     assert(connector.connector);
   });
-  it('should fail to resolve connector by module name starts with loopback-connector-', function () {
+  it('should fail to resolve connector by module name starts with loopback-connector-', function() {
     var connector = DataSource._resolveConnector('loopback-connector-xyz');
     assert(!connector.connector);
     assert(connector.error.indexOf('loopback-connector-xyz') !== -1);
   });
-  it('should fail to resolve connector by short module name', function () {
+  it('should fail to resolve connector by short module name', function() {
     var connector = DataSource._resolveConnector('xyz');
     assert(!connector.connector);
     assert(connector.error.indexOf('loopback-connector-xyz') !== -1);
   });
-  it('should fail to resolve connector by full module name', function () {
+  it('should fail to resolve connector by full module name', function() {
     var connector = DataSource._resolveConnector('loopback-xyz');
     assert(!connector.connector);
     assert(connector.error.indexOf('loopback-connector-loopback-xyz') !== -1);
   });
 });
 
-describe('Load models with relations', function () {
-  it('should set up relations', function (done) {
+describe('Load models with relations', function() {
+  it('should set up relations', function(done) {
     var ds = new DataSource('memory');
 
-    var Post = ds.define('Post', {userId: Number, content: String});
-    var User = ds.define('User', {name: String}, {relations: {posts: {type: 'hasMany', model: 'Post'}}});
+    var Post = ds.define('Post', { userId: Number, content: String });
+    var User = ds.define('User', { name: String }, { relations: { posts: { type: 'hasMany', model: 'Post' }}});
 
     assert(User.relations['posts']);
     done();
   });
 
-  it('should set up belongsTo relations', function (done) {
+  it('should set up belongsTo relations', function(done) {
     var ds = new DataSource('memory');
 
-    var User = ds.define('User', {name: String});
-    var Post = ds.define('Post', {userId: Number, content: String}, {relations: {user: {type: 'belongsTo', model: 'User'}}});
+    var User = ds.define('User', { name: String });
+    var Post = ds.define('Post', { userId: Number, content: String }, { relations: { user: { type: 'belongsTo', model: 'User' }}});
 
     assert(Post.relations['user']);
     done();
   });
 
-  it('should set up referencesMany relations', function (done) {
+  it('should set up referencesMany relations', function(done) {
     var ds = new DataSource('memory');
 
-    var Post = ds.define('Post', {userId: Number, content: String});
-    var User = ds.define('User', {name: String}, {relations: {posts: {type: 'referencesMany', model: 'Post'}}});
+    var Post = ds.define('Post', { userId: Number, content: String });
+    var User = ds.define('User', { name: String }, { relations: { posts: { type: 'referencesMany', model: 'Post' }}});
 
     assert(User.relations['posts']);
     done();
   });
 
-  it('should set up embedsMany relations', function (done) {
+  it('should set up embedsMany relations', function(done) {
     var ds = new DataSource('memory');
 
-    var Post = ds.define('Post', {userId: Number, content: String});
-    var User = ds.define('User', {name: String}, {relations: {posts: {type: 'embedsMany', model: 'Post' }}});
+    var Post = ds.define('Post', { userId: Number, content: String });
+    var User = ds.define('User', { name: String }, { relations: { posts: { type: 'embedsMany', model: 'Post' }}});
 
     assert(User.relations['posts']);
     done();
   });
 
-  it('should set up polymorphic relations', function (done) {
+  it('should set up polymorphic relations', function(done) {
     var ds = new DataSource('memory');
 
-    var Author = ds.define('Author', {name: String}, {relations: {
-      pictures: {type: 'hasMany', model: 'Picture', polymorphic: 'imageable'}
+    var Author = ds.define('Author', { name: String }, { relations: {
+      pictures: { type: 'hasMany', model: 'Picture', polymorphic: 'imageable' },
     }});
-    var Picture = ds.define('Picture', {name: String}, {relations: {
-      imageable: {type: 'belongsTo', polymorphic: true}
+    var Picture = ds.define('Picture', { name: String }, { relations: {
+      imageable: { type: 'belongsTo', polymorphic: true },
     }});
 
     assert(Author.relations['pictures']);
@@ -1071,8 +1071,8 @@ describe('Load models with relations', function () {
       polymorphic: {
         as: 'imageable',
         foreignKey: 'imageableId',
-        discriminator: 'imageableType'
-      }
+        discriminator: 'imageableType',
+      },
     });
 
     assert(Picture.relations['imageable']);
@@ -1087,17 +1087,17 @@ describe('Load models with relations', function () {
       polymorphic: {
         as: 'imageable',
         foreignKey: 'imageableId',
-        discriminator: 'imageableType'
-      }
+        discriminator: 'imageableType',
+      },
     });
     done();
   });
 
-  it('should set up foreign key with the correct type', function (done) {
+  it('should set up foreign key with the correct type', function(done) {
     var ds = new DataSource('memory');
 
-    var User = ds.define('User', {name: String, id: {type: String, id: true}});
-    var Post = ds.define('Post', {content: String}, {relations: {user: {type: 'belongsTo', model: 'User'}}});
+    var User = ds.define('User', { name: String, id: { type: String, id: true }});
+    var Post = ds.define('Post', { content: String }, { relations: { user: { type: 'belongsTo', model: 'User' }}});
 
     var fk = Post.definition.properties['userId'];
     assert(fk, 'The foreign key should be added');
@@ -1106,17 +1106,17 @@ describe('Load models with relations', function () {
     done();
   });
 
-  it('should set up hasMany and belongsTo relations', function (done) {
+  it('should set up hasMany and belongsTo relations', function(done) {
     var ds = new DataSource('memory');
 
-    var User = ds.define('User', {name: String}, {relations: {posts: {type: 'hasMany', model: 'Post'}, accounts: {type: 'hasMany', model: 'Account'}}});
+    var User = ds.define('User', { name: String }, { relations: { posts: { type: 'hasMany', model: 'Post' }, accounts: { type: 'hasMany', model: 'Account' }}});
 
     assert(!User.relations['posts']);
     assert(!User.relations['accounts']);
 
-    var Post = ds.define('Post', {userId: Number, content: String}, {relations: {user: {type: 'belongsTo', model: 'User'}}});
+    var Post = ds.define('Post', { userId: Number, content: String }, { relations: { user: { type: 'belongsTo', model: 'User' }}});
 
-    var Account = ds.define('Account', {userId: Number, type: String}, {relations: {user: {type: 'belongsTo', model: 'User'}}});
+    var Account = ds.define('Account', { userId: Number, type: String }, { relations: { user: { type: 'belongsTo', model: 'User' }}});
 
     assert(Post.relations['user']);
     assert.deepEqual(Post.relations['user'].toJSON(), {
@@ -1126,7 +1126,7 @@ describe('Load models with relations', function () {
       keyFrom: 'userId',
       modelTo: 'User',
       keyTo: 'id',
-      multiple: false
+      multiple: false,
     });
     assert(User.relations['posts']);
     assert.deepEqual(User.relations['posts'].toJSON(), {
@@ -1136,7 +1136,7 @@ describe('Load models with relations', function () {
       keyFrom: 'id',
       modelTo: 'Post',
       keyTo: 'userId',
-      multiple: true
+      multiple: true,
     });
     assert(User.relations['accounts']);
     assert.deepEqual(User.relations['accounts'].toJSON(), {
@@ -1146,47 +1146,47 @@ describe('Load models with relations', function () {
       keyFrom: 'id',
       modelTo: 'Account',
       keyTo: 'userId',
-      multiple: true
+      multiple: true,
     });
 
     done();
   });
 
-  it('should throw if a relation is missing type', function (done) {
+  it('should throw if a relation is missing type', function(done) {
     var ds = new DataSource('memory');
 
-    var Post = ds.define('Post', {userId: Number, content: String});
+    var Post = ds.define('Post', { userId: Number, content: String });
 
     try {
-      var User = ds.define('User', {name: String}, {relations: {posts: {model: 'Post'}}});
+      var User = ds.define('User', { name: String }, { relations: { posts: { model: 'Post' }}});
     } catch (e) {
       done();
     }
 
   });
 
-  it('should throw if the relation type is invalid', function (done) {
+  it('should throw if the relation type is invalid', function(done) {
     var ds = new DataSource('memory');
 
-    var Post = ds.define('Post', {userId: Number, content: String});
+    var Post = ds.define('Post', { userId: Number, content: String });
 
     try {
-      var User = ds.define('User', {name: String}, {relations: {posts: {type: 'hasXYZ', model: 'Post'}}});
+      var User = ds.define('User', { name: String }, { relations: { posts: { type: 'hasXYZ', model: 'Post' }}});
     } catch (e) {
       done();
     }
 
   });
 
-  it('should handle hasMany through', function (done) {
+  it('should handle hasMany through', function(done) {
     var ds = new DataSource('memory');
     var Physician = ds.createModel('Physician', {
-      name: String
-    }, {relations: {patients: {model: 'Patient', type: 'hasMany', through: 'Appointment'}}});
+      name: String,
+    }, { relations: { patients: { model: 'Patient', type: 'hasMany', through: 'Appointment' }}});
 
     var Patient = ds.createModel('Patient', {
-      name: String
-    }, {relations: {physicians: {model: 'Physician', type: 'hasMany', through: 'Appointment'}}});
+      name: String,
+    }, { relations: { physicians: { model: 'Physician', type: 'hasMany', through: 'Appointment' }}});
 
     assert(!Physician.relations['patients']); // Appointment hasn't been resolved yet
     assert(!Patient.relations['physicians']); // Appointment hasn't been resolved yet
@@ -1194,41 +1194,41 @@ describe('Load models with relations', function () {
     var Appointment = ds.createModel('Appointment', {
       physicianId: Number,
       patientId: Number,
-      appointmentDate: Date
-    }, {relations: {patient: {type: 'belongsTo', model: 'Patient'}, physician: {type: 'belongsTo', model: 'Physician'}}});
+      appointmentDate: Date,
+    }, { relations: { patient: { type: 'belongsTo', model: 'Patient' }, physician: { type: 'belongsTo', model: 'Physician' }}});
 
     assert(Physician.relations['patients']);
     assert(Patient.relations['physicians']);
     done();
   });
 
-  it('should handle hasMany through options', function (done) {
+  it('should handle hasMany through options', function(done) {
     var ds = new DataSource('memory');
     var Physician = ds.createModel('Physician', {
-      name: String
-    }, {relations: {patients: {model: 'Patient', type: 'hasMany', foreignKey: 'leftId', through: 'Appointment'}}});
+      name: String,
+    }, { relations: { patients: { model: 'Patient', type: 'hasMany', foreignKey: 'leftId', through: 'Appointment' }}});
 
     var Patient = ds.createModel('Patient', {
-      name: String
-    }, {relations: {physicians: {model: 'Physician', type: 'hasMany', foreignKey: 'rightId', through: 'Appointment'}}});
+      name: String,
+    }, { relations: { physicians: { model: 'Physician', type: 'hasMany', foreignKey: 'rightId', through: 'Appointment' }}});
 
     var Appointment = ds.createModel('Appointment', {
       physicianId: Number,
       patientId: Number,
-      appointmentDate: Date
-    }, {relations: {patient: {type: 'belongsTo', model: 'Patient'}, physician: {type: 'belongsTo', model: 'Physician'}}});
+      appointmentDate: Date,
+    }, { relations: { patient: { type: 'belongsTo', model: 'Patient' }, physician: { type: 'belongsTo', model: 'Physician' }}});
 
     assert(Physician.relations['patients'].keyTo === 'leftId');
     assert(Patient.relations['physicians'].keyTo === 'rightId');
     done();
   });
 
-  it('should set up relations after attach', function (done) {
+  it('should set up relations after attach', function(done) {
     var ds = new DataSource('memory');
     var modelBuilder = new ModelBuilder();
 
-    var Post = modelBuilder.define('Post', {userId: Number, content: String});
-    var User = modelBuilder.define('User', {name: String}, {relations: {posts: {type: 'hasMany', model: 'Post'}}});
+    var Post = modelBuilder.define('Post', { userId: Number, content: String });
+    var User = modelBuilder.define('User', { name: String }, { relations: { posts: { type: 'hasMany', model: 'Post' }}});
 
     assert(!User.relations['posts']);
     Post.attachTo(ds);
@@ -1239,25 +1239,25 @@ describe('Load models with relations', function () {
 
 });
 
-describe('Model with scopes', function () {
-  it('should create scopes', function (done) {
+describe('Model with scopes', function() {
+  it('should create scopes', function(done) {
     var ds = new DataSource('memory');
-    var User = ds.define('User', {name: String, vip: Boolean, age: Number},
-      {scopes: {vips: {where: {vip: true}}, top5: {limit: 5, order: 'age'}}});
+    var User = ds.define('User', { name: String, vip: Boolean, age: Number },
+      { scopes: { vips: { where: { vip: true }}, top5: { limit: 5, order: 'age' }}});
 
     var users = [];
     for (var i = 0; i < 10; i++) {
-      users.push({name: 'User' + i, vip: i % 3 === 0, age: 20 + i * 2});
+      users.push({ name: 'User' + i, vip: i % 3 === 0, age: 20 + i * 2 });
     }
-    async.each(users, function (user, callback) {
+    async.each(users, function(user, callback) {
       User.create(user, callback);
-    }, function (err) {
-      User.vips(function (err, vips) {
-        if(err) {
+    }, function(err) {
+      User.vips(function(err, vips) {
+        if (err) {
           return done(err);
         }
         assert.equal(vips.length, 4);
-        User.top5(function (err, top5) {
+        User.top5(function(err, top5) {
           assert.equal(top5.length, 5);
           done(err);
         });
@@ -1266,30 +1266,30 @@ describe('Model with scopes', function () {
   });
 });
 
-describe('DataAccessObject', function () {
+describe('DataAccessObject', function() {
   var ds, model, where, error;
 
-  before(function () {
+  before(function() {
     ds = new DataSource('memory');
     model = ds.createModel('M1', {
-      id: {type: String, id: true},
+      id: { type: String, id: true },
       age: Number,
       vip: Boolean,
       date: Date,
       location: 'GeoPoint',
-      scores: [Number]
+      scores: [Number],
     });
   });
 
-  beforeEach(function () {
+  beforeEach(function() {
     error = null;
   });
 
-  it('should be able to coerce where clause for string types', function () {
-    where = model._coerce({id: 1});
-    assert.deepEqual(where, {id: '1'});
-    where = model._coerce({id: '1'});
-    assert.deepEqual(where, {id: '1'});
+  it('should be able to coerce where clause for string types', function() {
+    where = model._coerce({ id: 1 });
+    assert.deepEqual(where, { id: '1' });
+    where = model._coerce({ id: '1' });
+    assert.deepEqual(where, { id: '1' });
 
     // Mockup MongoDB ObjectID
     function ObjectID(id) {
@@ -1300,76 +1300,76 @@ describe('DataAccessObject', function () {
       return this.id;
     };
 
-    where = model._coerce({id: new ObjectID('1')});
-    assert.deepEqual(where, {id: '1'});
+    where = model._coerce({ id: new ObjectID('1') });
+    assert.deepEqual(where, { id: '1' });
   });
 
-  it('should be able to coerce where clause for number types', function () {
-    where = model._coerce({age: '10'});
-    assert.deepEqual(where, {age: 10});
+  it('should be able to coerce where clause for number types', function() {
+    where = model._coerce({ age: '10' });
+    assert.deepEqual(where, { age: 10 });
 
-    where = model._coerce({age: 10});
-    assert.deepEqual(where, {age: 10});
+    where = model._coerce({ age: 10 });
+    assert.deepEqual(where, { age: 10 });
 
-    where = model._coerce({age: {gt: 10}});
-    assert.deepEqual(where, {age: {gt: 10}});
+    where = model._coerce({ age: { gt: 10 }});
+    assert.deepEqual(where, { age: { gt: 10 }});
 
-    where = model._coerce({age: {gt: '10'}});
-    assert.deepEqual(where, {age: {gt: 10}});
+    where = model._coerce({ age: { gt: '10' }});
+    assert.deepEqual(where, { age: { gt: 10 }});
 
-    where = model._coerce({age: {between: ['10', '20']}});
-    assert.deepEqual(where, {age: {between: [10, 20]}});
+    where = model._coerce({ age: { between: ['10', '20'] }});
+    assert.deepEqual(where, { age: { between: [10, 20] }});
   });
 
-  it('should be able to coerce where clause for array types', function () {
-    where = model._coerce({scores: ['10', '20']});
-    assert.deepEqual(where, {scores: [10, 20]});
+  it('should be able to coerce where clause for array types', function() {
+    where = model._coerce({ scores: ['10', '20'] });
+    assert.deepEqual(where, { scores: [10, 20] });
   });
 
-  it('should be able to coerce where clause for date types', function () {
+  it('should be able to coerce where clause for date types', function() {
     var d = new Date();
-    where = model._coerce({date: d});
-    assert.deepEqual(where, {date: d});
+    where = model._coerce({ date: d });
+    assert.deepEqual(where, { date: d });
 
-    where = model._coerce({date: d.toISOString()});
-    assert.deepEqual(where, {date: d});
+    where = model._coerce({ date: d.toISOString() });
+    assert.deepEqual(where, { date: d });
   });
 
-  it('should be able to coerce where clause for boolean types', function () {
-    where = model._coerce({vip: 'true'});
-    assert.deepEqual(where, {vip: true});
+  it('should be able to coerce where clause for boolean types', function() {
+    where = model._coerce({ vip: 'true' });
+    assert.deepEqual(where, { vip: true });
 
-    where = model._coerce({vip: true});
-    assert.deepEqual(where, {vip: true});
+    where = model._coerce({ vip: true });
+    assert.deepEqual(where, { vip: true });
 
-    where = model._coerce({vip: 'false'});
-    assert.deepEqual(where, {vip: false});
+    where = model._coerce({ vip: 'false' });
+    assert.deepEqual(where, { vip: false });
 
-    where = model._coerce({vip: false});
-    assert.deepEqual(where, {vip: false});
+    where = model._coerce({ vip: false });
+    assert.deepEqual(where, { vip: false });
 
-    where = model._coerce({vip: '1'});
-    assert.deepEqual(where, {vip: true});
+    where = model._coerce({ vip: '1' });
+    assert.deepEqual(where, { vip: true });
 
-    where = model._coerce({vip: 0});
-    assert.deepEqual(where, {vip: false});
+    where = model._coerce({ vip: 0 });
+    assert.deepEqual(where, { vip: false });
 
-    where = model._coerce({vip: ''});
-    assert.deepEqual(where, {vip: false});
+    where = model._coerce({ vip: '' });
+    assert.deepEqual(where, { vip: false });
 
   });
 
-  it('should be able to coerce where clause with and operators', function () {
-    where = model._coerce({and: [{age: '10'}, {vip: 'true'}]});
-    assert.deepEqual(where, {and: [{age: 10}, {vip: true}]});
+  it('should be able to coerce where clause with and operators', function() {
+    where = model._coerce({ and: [{ age: '10' }, { vip: 'true' }] });
+    assert.deepEqual(where, { and: [{ age: 10 }, { vip: true }] });
   });
 
-  it('should be able to coerce where clause with or operators', function () {
-    where = model._coerce({or: [{age: '10'}, {vip: 'true'}]});
-    assert.deepEqual(where, {or: [{age: 10}, {vip: true}]});
+  it('should be able to coerce where clause with or operators', function() {
+    where = model._coerce({ or: [{ age: '10' }, { vip: 'true' }] });
+    assert.deepEqual(where, { or: [{ age: 10 }, { vip: true }] });
   });
 
-  it('should throw if the where property is not an object', function () {
+  it('should throw if the where property is not an object', function() {
     try {
       // The where clause has to be an object
       model._coerce('abc');
@@ -1379,11 +1379,11 @@ describe('DataAccessObject', function () {
     assert(error, 'An error should have been thrown');
   });
 
-  it('should throw if the where property is an array', function () {
+  it('should throw if the where property is an array', function() {
     try {
       // The where clause cannot be an array
       model._coerce([
-        {vip: true}
+        { vip: true },
       ]);
     } catch (err) {
       error = err;
@@ -1391,37 +1391,37 @@ describe('DataAccessObject', function () {
     assert(error, 'An error should have been thrown');
   });
 
-  it('should throw if the and operator does not take an array', function () {
+  it('should throw if the and operator does not take an array', function() {
     try {
       // The and operator only takes an array of objects
-      model._coerce({and: {x: 1}});
+      model._coerce({ and: { x: 1 }});
     } catch (err) {
       error = err;
     }
     assert(error, 'An error should have been thrown');
   });
 
-  it('should throw if the or operator does not take an array', function () {
+  it('should throw if the or operator does not take an array', function() {
     try {
       // The or operator only takes an array of objects
-      model._coerce({or: {x: 1}});
+      model._coerce({ or: { x: 1 }});
     } catch (err) {
       error = err;
     }
     assert(error, 'An error should have been thrown');
   });
 
-  it('should throw if the or operator does not take an array of objects', function () {
+  it('should throw if the or operator does not take an array of objects', function() {
     try {
       // The or operator only takes an array of objects
-      model._coerce({or: ['x']});
-    } catch(err) {
+      model._coerce({ or: ['x'] });
+    } catch (err) {
       error = err;
     }
     assert(error, 'An error should have been thrown');
   });
 
-  it('should throw if filter property is not an object', function () {
+  it('should throw if filter property is not an object', function() {
     var filter = null;
     try {
       // The filter clause has to be an object
@@ -1432,112 +1432,112 @@ describe('DataAccessObject', function () {
     assert(error, 'An error should have been thrown');
   });
 
-  it('should throw if filter.limit property is not a number', function () {
+  it('should throw if filter.limit property is not a number', function() {
     try {
       // The limit param must be a valid number
-      filter = model._normalize({limit: 'x'});
+      filter = model._normalize({ limit: 'x' });
     } catch (err) {
       error = err;
     }
     assert(error, 'An error should have been thrown');
   });
 
-  it('should throw if filter.limit property is nagative', function () {
+  it('should throw if filter.limit property is nagative', function() {
     try {
       // The limit param must be a valid number
-      filter = model._normalize({limit: -1});
+      filter = model._normalize({ limit: -1 });
     } catch (err) {
       error = err;
     }
     assert(error, 'An error should have been thrown');
   });
 
-  it('should throw if filter.limit property is not an integer', function () {
+  it('should throw if filter.limit property is not an integer', function() {
     try {
       // The limit param must be a valid number
-      filter = model._normalize({limit: 5.8});
+      filter = model._normalize({ limit: 5.8 });
     } catch (err) {
       error = err;
     }
     assert(error, 'An error should have been thrown');
   });
 
-  it('should throw if filter.offset property is not a number', function () {
+  it('should throw if filter.offset property is not a number', function() {
     try {
       // The limit param must be a valid number
-      filter = model._normalize({offset: 'x'});
+      filter = model._normalize({ offset: 'x' });
     } catch (err) {
       error = err;
     }
     assert(error, 'An error should have been thrown');
   });
 
-  it('should throw if filter.skip property is not a number', function () {
+  it('should throw if filter.skip property is not a number', function() {
     try {
       // The limit param must be a valid number
-      filter = model._normalize({skip: '_'});
+      filter = model._normalize({ skip: '_' });
     } catch (err) {
       error = err;
     }
     assert(error, 'An error should have been thrown');
   });
 
-  it('should normalize limit/offset/skip', function () {
-    filter = model._normalize({limit: '10', skip: 5});
-    assert.deepEqual(filter, {limit: 10, offset: 5, skip: 5});
+  it('should normalize limit/offset/skip', function() {
+    filter = model._normalize({ limit: '10', skip: 5 });
+    assert.deepEqual(filter, { limit: 10, offset: 5, skip: 5 });
   });
 
-  it('should set the default value for limit', function () {
-    filter = model._normalize({skip: 5});
-    assert.deepEqual(filter, {limit: 100, offset: 5, skip: 5});
+  it('should set the default value for limit', function() {
+    filter = model._normalize({ skip: 5 });
+    assert.deepEqual(filter, { limit: 100, offset: 5, skip: 5 });
   });
 
-  it('should apply settings for handling undefined', function () {
-    filter = model._normalize({filter: { x: undefined }});
-    assert.deepEqual(filter, {filter: {}});
+  it('should apply settings for handling undefined', function() {
+    filter = model._normalize({ filter: { x: undefined }});
+    assert.deepEqual(filter, { filter: {}});
 
     ds.settings.normalizeUndefinedInQuery = 'ignore';
-    filter = model._normalize({filter: { x: undefined }});
-    assert.deepEqual(filter, {filter: {}}, 'Should ignore undefined');
+    filter = model._normalize({ filter: { x: undefined }});
+    assert.deepEqual(filter, { filter: {}}, 'Should ignore undefined');
 
     ds.settings.normalizeUndefinedInQuery = 'nullify';
-    filter = model._normalize({filter: { x: undefined }});
-    assert.deepEqual(filter, {filter: { x: null }}, 'Should nullify undefined');
+    filter = model._normalize({ filter: { x: undefined }});
+    assert.deepEqual(filter, { filter: { x: null }}, 'Should nullify undefined');
 
     ds.settings.normalizeUndefinedInQuery = 'throw';
-    (function(){ model._normalize({filter: { x: undefined }}) }).should.throw(/`undefined` in query/);
+    (function() { model._normalize({ filter: { x: undefined }}); }).should.throw(/`undefined` in query/);
   });
 
-  it('should skip GeoPoint', function () {
-    where = model._coerce({location: {near: {lng: 10, lat: 20}, maxDistance: 20}});
-    assert.deepEqual(where, {location: {near: {lng: 10, lat: 20}, maxDistance: 20}});
+  it('should skip GeoPoint', function() {
+    where = model._coerce({ location: { near: { lng: 10, lat: 20 }, maxDistance: 20 }});
+    assert.deepEqual(where, { location: { near: { lng: 10, lat: 20 }, maxDistance: 20 }});
   });
 
-  it('should skip null values', function () {
-    where = model._coerce({date: null});
-    assert.deepEqual(where, {date: null});
+  it('should skip null values', function() {
+    where = model._coerce({ date: null });
+    assert.deepEqual(where, { date: null });
   });
 
-  it('should skip undefined values', function () {
-    where = model._coerce({date: undefined});
-    assert.deepEqual(where, {date: undefined});
+  it('should skip undefined values', function() {
+    where = model._coerce({ date: undefined });
+    assert.deepEqual(where, { date: undefined });
   });
 
   it('should skip conversion if a simple property produces NaN for numbers',
-    function () {
-      where = model._coerce({age: 'xyz'});
-      assert.deepEqual(where, {age: 'xyz'});
+    function() {
+      where = model._coerce({ age: 'xyz' });
+      assert.deepEqual(where, { age: 'xyz' });
     });
 
   it('should skip conversion if an array property produces NaN for numbers',
-    function () {
-      where = model._coerce({age: {inq: ['xyz', '12']}});
-      assert.deepEqual(where, {age: {inq: ['xyz', 12]}});
+    function() {
+      where = model._coerce({ age: { inq: ['xyz', '12'] }});
+      assert.deepEqual(where, { age: { inq: ['xyz', 12] }});
     });
 
   // settings
   it('should get settings in priority',
-    function () {
+    function() {
       ds.settings.test = 'test';
       assert.equal(model._getSetting('test'), ds.settings.test, 'Should get datasource setting');
       ds.settings.test = undefined;
@@ -1551,7 +1551,7 @@ describe('DataAccessObject', function () {
 
 });
 
-describe('Load models from json', function () {
+describe('Load models from json', function() {
   var path = require('path'),
     fs = require('fs');
 
@@ -1575,14 +1575,14 @@ describe('Load models from json', function () {
     return modelBuilder.buildModels(schemas, createModel);
   }
 
-  it('should be able to define models from json', function () {
+  it('should be able to define models from json', function() {
 
     var models = loadSchemasSync(path.join(__dirname, 'test1-schemas.json'));
 
     models.should.have.property('AnonymousModel_0');
     models.AnonymousModel_0.should.have.property('modelName', 'AnonymousModel_0');
 
-    var m1 = new models.AnonymousModel_0({title: 'Test'});
+    var m1 = new models.AnonymousModel_0({ title: 'Test' });
     m1.should.have.property('title', 'Test');
     m1.should.have.property('author', 'Raymond');
 
@@ -1606,7 +1606,7 @@ describe('Load models from json', function () {
     assert.equal(models.Address.dataSource, ds);
   });
 
-  it('should allow customization of default model base class', function () {
+  it('should allow customization of default model base class', function() {
     var modelBuilder = new ModelBuilder();
 
     var User = modelBuilder.define('User', {
@@ -1614,16 +1614,16 @@ describe('Load models from json', function () {
       bio: ModelBuilder.Text,
       approved: Boolean,
       joinedAt: Date,
-      age: Number
+      age: Number,
     });
 
     modelBuilder.defaultModelBaseClass = User;
 
-    var Customer = modelBuilder.define('Customer', {customerId: {type: String, id: true}});
+    var Customer = modelBuilder.define('Customer', { customerId: { type: String, id: true }});
     assert(Customer.prototype instanceof User);
   });
 
-  it('should allow model base class', function () {
+  it('should allow model base class', function() {
     var modelBuilder = new ModelBuilder();
 
     var User = modelBuilder.define('User', {
@@ -1631,15 +1631,15 @@ describe('Load models from json', function () {
       bio: ModelBuilder.Text,
       approved: Boolean,
       joinedAt: Date,
-      age: Number
+      age: Number,
     });
 
     var Customer = modelBuilder.define('Customer',
-      {customerId: {type: String, id: true}}, {}, User);
+      { customerId: { type: String, id: true }}, {}, User);
     assert(Customer.prototype instanceof User);
   });
 
-  it('should be able to extend models', function (done) {
+  it('should be able to extend models', function(done) {
     var modelBuilder = new ModelBuilder();
 
     var User = modelBuilder.define('User', {
@@ -1647,12 +1647,12 @@ describe('Load models from json', function () {
       bio: ModelBuilder.Text,
       approved: Boolean,
       joinedAt: Date,
-      age: Number
+      age: Number,
     });
 
-    var Customer = User.extend('Customer', {customerId: {type: String, id: true}});
+    var Customer = User.extend('Customer', { customerId: { type: String, id: true }});
 
-    var customer = new Customer({name: 'Joe', age: 20, customerId: 'c01'});
+    var customer = new Customer({ name: 'Joe', age: 20, customerId: 'c01' });
 
     customer.should.be.type('object').and.have.property('name', 'Joe');
     customer.should.have.property('name', 'Joe');
@@ -1661,7 +1661,7 @@ describe('Load models from json', function () {
     customer.should.have.property('bio', undefined);
 
     // The properties are defined at prototype level
-    assert.equal(Object.keys(customer).filter(function (k) {
+    assert.equal(Object.keys(customer).filter(function(k) {
       // Remove internal properties
       return k.indexOf('__') === -1;
     }).length, 0);
@@ -1675,7 +1675,7 @@ describe('Load models from json', function () {
       }
     }
     assert.equal(count, 7); // Please note there is an injected id from User prototype
-    assert.equal(Object.keys(customer.toObject()).filter(function (k) {
+    assert.equal(Object.keys(customer.toObject()).filter(function(k) {
       // Remove internal properties
       return k.indexOf('__') === -1;
     }).length, 6);
@@ -1683,45 +1683,45 @@ describe('Load models from json', function () {
     done(null, customer);
   });
 
-  it('should be able to extend models with merged settings', function (done) {
+  it('should be able to extend models with merged settings', function(done) {
     var modelBuilder = new ModelBuilder();
 
     var User = modelBuilder.define('User', {
-      name: String
+      name: String,
     }, {
       defaultPermission: 'ALLOW',
       acls: [
         {
           principalType: 'ROLE',
           principalId: '$everyone',
-          permission: 'ALLOW'
-        }
+          permission: 'ALLOW',
+        },
       ],
       relations: {
         posts: {
           type: 'hasMany',
-          model: 'Post'
-        }
-      }
+          model: 'Post',
+        },
+      },
     });
 
     var Customer = User.extend('Customer',
-      {customerId: {type: String, id: true}},
+      { customerId: { type: String, id: true }},
       {
         defaultPermission: 'DENY',
         acls: [
           {
             principalType: 'ROLE',
             principalId: '$unauthenticated',
-            permission: 'DENY'
-          }
+            permission: 'DENY',
+          },
         ],
         relations: {
           orders: {
             type: 'hasMany',
-            model: 'Order'
-          }
-        }
+            model: 'Order',
+          },
+        },
       }
     );
 
@@ -1731,16 +1731,16 @@ describe('Load models from json', function () {
         {
           principalType: 'ROLE',
           principalId: '$everyone',
-          permission: 'ALLOW'
-        }
+          permission: 'ALLOW',
+        },
       ],
       relations: {
         posts: {
           type: 'hasMany',
-          model: 'Post'
-        }
+          model: 'Post',
+        },
       },
-      strict: false
+      strict: false,
     });
 
     assert.deepEqual(Customer.settings, {
@@ -1749,80 +1749,80 @@ describe('Load models from json', function () {
         {
           principalType: 'ROLE',
           principalId: '$everyone',
-          permission: 'ALLOW'
+          permission: 'ALLOW',
         },
         {
           principalType: 'ROLE',
           principalId: '$unauthenticated',
-          permission: 'DENY'
-        }
+          permission: 'DENY',
+        },
       ],
       relations: {
         posts: {
           type: 'hasMany',
-          model: 'Post'
+          model: 'Post',
         },
         orders: {
           type: 'hasMany',
-          model: 'Order'
-        }
+          model: 'Order',
+        },
       },
       strict: false,
-      base: User
+      base: User,
     });
 
     done();
   });
 });
 
-describe('DataSource constructor', function () {
-  it('Takes url as the settings', function () {
+describe('DataSource constructor', function() {
+  it('Takes url as the settings', function() {
     var ds = new DataSource('memory://localhost/mydb?x=1');
     assert.equal(ds.connector.name, 'memory');
   });
 
-  it('Takes connector name', function () {
+  it('Takes connector name', function() {
     var ds = new DataSource('memory');
     assert.equal(ds.connector.name, 'memory');
   });
 
-  it('Takes settings object', function () {
-    var ds = new DataSource({connector: 'memory'});
+  it('Takes settings object', function() {
+    var ds = new DataSource({ connector: 'memory' });
     assert.equal(ds.connector.name, 'memory');
   });
 
-  it('Takes settings object and name', function () {
-    var ds = new DataSource('x', {connector: 'memory'});
+  it('Takes settings object and name', function() {
+    var ds = new DataSource('x', { connector: 'memory' });
     assert.equal(ds.connector.name, 'memory');
   });
 });
 
-describe('ModelBuilder options.models', function () {
-  it('should inject model classes from models', function () {
+describe('ModelBuilder options.models', function() {
+  it('should inject model classes from models', function() {
     var builder = new ModelBuilder();
     var M1 = builder.define('M1');
-    var M2 = builder.define('M2', {}, {models: {
-      'M1': M1
+    var M2 = builder.define('M2', {}, { models: {
+      'M1': M1,
     }});
 
     assert.equal(M2.M1, M1, 'M1 should be injected to M2');
   });
 
-  it('should inject model classes by name in the models', function () {
+  it('should inject model classes by name in the models', function() {
     var builder = new ModelBuilder();
     var M1 = builder.define('M1');
-    var M2 = builder.define('M2', {}, {models: {
-      'M1': 'M1'
+    var M2 = builder.define('M2', {}, { models: {
+      'M1': 'M1',
     }});
 
     assert.equal(M2.M1, M1, 'M1 should be injected to M2');
   });
 
   it('should inject model classes by name in the models before the class is defined',
-    function () {
+    function() {
       var builder = new ModelBuilder();
-      var M2 = builder.define('M2', {}, {models: {
-        'M1': 'M1'
+      var M2 = builder.define('M2', {}, { models: {
+        'M1': 'M1',
       }});
       assert(M2.M1, 'M1 should be injected to M2');
       assert(M2.M1.settings.unresolved, 'M1 is still a proxy');
diff --git a/test/manipulation.test.js b/test/manipulation.test.js
index 3dd574df..1449e9a2 100644
--- a/test/manipulation.test.js
+++ b/test/manipulation.test.js
@@ -12,18 +12,18 @@ var ValidationError = require('..').ValidationError;
 
 var UUID_REGEXP = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 
-describe('manipulation', function () {
+describe('manipulation', function() {
 
-  before(function (done) {
+  before(function(done) {
     db = getSchema();
 
     Person = db.define('Person', {
       name: String,
       gender: String,
       married: Boolean,
-      age: {type: Number, index: true},
+      age: { type: Number, index: true },
       dob: Date,
-      createdAt: {type: Date, default: Date}
+      createdAt: { type: Date, default: Date },
     }, { forceId: true, strict: true });
 
     db.automigrate(['Person'], done);
@@ -55,18 +55,18 @@ describe('manipulation', function () {
     stubPasswordCounter = 0;
   });
 
-  describe('create', function () {
+  describe('create', function() {
 
-    before(function (done) {
+    before(function(done) {
       Person.destroyAll(done);
     });
 
-    it('should create instance', function (done) {
-      Person.create({name: 'Anatoliy'}, function (err, p) {
+    it('should create instance', function(done) {
+      Person.create({ name: 'Anatoliy' }, function(err, p) {
         p.name.should.equal('Anatoliy');
         should.not.exist(err);
         should.exist(p);
-        Person.findById(p.id, function (err, person) {
+        Person.findById(p.id, function(err, person) {
           person.id.should.eql(p.id);
           person.name.should.equal('Anatoliy');
           done();
@@ -74,13 +74,13 @@ describe('manipulation', function () {
       });
     });
 
-    it('should create instance (promise variant)', function (done) {
-      Person.create({name: 'Anatoliy'})
-        .then (function (p) {
+    it('should create instance (promise variant)', function(done) {
+      Person.create({ name: 'Anatoliy' })
+        .then (function(p) {
           p.name.should.equal('Anatoliy');
           should.exist(p);
           return Person.findById(p.id)
-            .then (function (person) {
+            .then (function(person) {
               person.id.should.eql(p.id);
               person.name.should.equal('Anatoliy');
               done();
@@ -89,8 +89,8 @@ describe('manipulation', function () {
         .catch(done);
     });
 
-    it('should instantiate an object', function (done) {
-      var p = new Person({name: 'Anatoliy'});
+    it('should instantiate an object', function(done) {
+      var p = new Person({ name: 'Anatoliy' });
       p.name.should.equal('Anatoliy');
       p.isNewRecord().should.be.true;
       p.save(function(err, inst) {
@@ -101,8 +101,8 @@ describe('manipulation', function () {
       });
     });
 
-    it('should instantiate an object (promise variant)', function (done) {
-      var p = new Person({name: 'Anatoliy'});
+    it('should instantiate an object (promise variant)', function(done) {
+      var p = new Person({ name: 'Anatoliy' });
       p.name.should.equal('Anatoliy');
       p.isNewRecord().should.be.true;
       p.save()
@@ -115,8 +115,8 @@ describe('manipulation', function () {
 
     });
 
-    it('should return instance of object', function (done) {
-      var person = Person.create(function (err, p) {
+    it('should return instance of object', function(done) {
+      var person = Person.create(function(err, p) {
         p.id.should.eql(person.id);
         done();
       });
@@ -125,8 +125,8 @@ describe('manipulation', function () {
       should.not.exist(person.id);
     });
 
-    it('should not allow user-defined value for the id of object - create', function (done) {
-      Person.create({id: 123456}, function (err, p) {
+    it('should not allow user-defined value for the id of object - create', function(done) {
+      Person.create({ id: 123456 }, function(err, p) {
         err.should.be.instanceof(ValidationError);
         err.statusCode.should.equal(422);
         err.details.messages.id.should.eql(['can\'t be set']);
@@ -137,11 +137,11 @@ describe('manipulation', function () {
       });
     });
 
-    it('should not allow user-defined value for the id of object - create (promise variant)', function (done) {
-      Person.create({id: 123456})
-        .then (function (p) {
+    it('should not allow user-defined value for the id of object - create (promise variant)', function(done) {
+      Person.create({ id: 123456 })
+        .then (function(p) {
           done(new Error('Person.create should have failed.'));
-        }, function (err) {
+        }, function(err) {
           err.should.be.instanceof(ValidationError);
           err.statusCode.should.equal(422);
           err.details.messages.id.should.eql(['can\'t be set']);
@@ -150,8 +150,8 @@ describe('manipulation', function () {
         .catch(done);
     });
 
-    it('should not allow user-defined value for the id of object - save', function (done) {
-      var p = new Person({id: 123456});
+    it('should not allow user-defined value for the id of object - save', function(done) {
+      var p = new Person({ id: 123456 });
       p.isNewRecord().should.be.true;
       p.save(function(err, inst) {
         err.should.be.instanceof(ValidationError);
@@ -163,13 +163,13 @@ describe('manipulation', function () {
       });
     });
 
-    it('should not allow user-defined value for the id of object - save (promise variant)', function (done) {
-      var p = new Person({id: 123456});
+    it('should not allow user-defined value for the id of object - save (promise variant)', function(done) {
+      var p = new Person({ id: 123456 });
       p.isNewRecord().should.be.true;
       p.save()
         .then (function(inst) {
           done(new Error('save should have failed.'));
-        }, function (err) {
+        }, function(err) {
           err.should.be.instanceof(ValidationError);
           err.statusCode.should.equal(422);
           err.details.messages.id.should.eql(['can\'t be set']);
@@ -178,8 +178,8 @@ describe('manipulation', function () {
         .catch(done);
     });
 
-    it('should work when called without callback', function (done) {
-      Person.afterCreate = function (next) {
+    it('should work when called without callback', function(done) {
+      Person.afterCreate = function(next) {
         this.should.be.an.instanceOf(Person);
         this.name.should.equal('Nickolay');
         should.exist(this.id);
@@ -187,15 +187,15 @@ describe('manipulation', function () {
         next();
         setTimeout(done, 10);
       };
-      Person.create({name: 'Nickolay'});
+      Person.create({ name: 'Nickolay' });
     });
 
-    it('should create instance with blank data', function (done) {
-      Person.create(function (err, p) {
+    it('should create instance with blank data', function(done) {
+      Person.create(function(err, p) {
         should.not.exist(err);
         should.exist(p);
         should.not.exists(p.name);
-        Person.findById(p.id, function (err, person) {
+        Person.findById(p.id, function(err, person) {
           person.id.should.eql(p.id);
           should.not.exists(person.name);
           done();
@@ -203,13 +203,13 @@ describe('manipulation', function () {
       });
     });
 
-    it('should create instance with blank data (promise variant)', function (done) {
+    it('should create instance with blank data (promise variant)', function(done) {
       Person.create()
-        .then (function (p) {
+        .then (function(p) {
           should.exist(p);
           should.not.exists(p.name);
           return Person.findById(p.id)
-          .then (function (person) {
+          .then (function(person) {
             person.id.should.eql(p.id);
             should.not.exists(person.name);
             done();
@@ -217,8 +217,8 @@ describe('manipulation', function () {
         }).catch(done);
     });
 
-    it('should work when called with no data and callback', function (done) {
-      Person.afterCreate = function (next) {
+    it('should work when called with no data and callback', function(done) {
+      Person.afterCreate = function(next) {
         this.should.be.an.instanceOf(Person);
         should.not.exist(this.name);
         should.exist(this.id);
@@ -229,20 +229,20 @@ describe('manipulation', function () {
       Person.create();
     });
 
-    it('should create batch of objects', function (done) {
+    it('should create batch of objects', function(done) {
       var batch = [
-        {name: 'Shaltay'},
-        {name: 'Boltay'},
-        {}
+        { name: 'Shaltay' },
+        { name: 'Boltay' },
+        {},
       ];
-      Person.create(batch,function (e, ps) {
+      Person.create(batch, function(e, ps) {
         should.not.exist(e);
         should.exist(ps);
         ps.should.be.instanceOf(Array);
         ps.should.have.lengthOf(batch.length);
 
         Person.validatesPresenceOf('name');
-        Person.create(batch,function (errors, persons) {
+        Person.create(batch, function(errors, persons) {
           delete Person.validations;
           should.exist(errors);
           errors.should.have.lengthOf(batch.length);
@@ -261,22 +261,22 @@ describe('manipulation', function () {
     it('should create batch of objects with beforeCreate', function(done) {
       Person.beforeCreate = function(next, data) {
         if (data && data.name === 'A') {
-          return next(null, {id: 'a', name: 'A'});
+          return next(null, { id: 'a', name: 'A' });
         } else {
           return next();
         }
       };
       var batch = [
-        {name: 'A'},
-        {name: 'B'},
-        undefined
+        { name: 'A' },
+        { name: 'B' },
+        undefined,
       ];
       Person.create(batch, function(e, ps) {
         should.not.exist(e);
         should.exist(ps);
         ps.should.be.instanceOf(Array);
         ps.should.have.lengthOf(batch.length);
-        ps[0].should.be.eql({id: 'a', name: 'A'});
+        ps[0].should.be.eql({ id: 'a', name: 'A' });
         done();
       });
     });
@@ -289,7 +289,7 @@ describe('manipulation', function () {
           created.toObject().should.have.properties({
             id: created.id,
             name: 'a-name',
-            gender: undefined
+            gender: undefined,
           });
 
           Person.findById(created.id, function(err, found) {
@@ -297,7 +297,7 @@ describe('manipulation', function () {
             var result = found.toObject();
             result.should.have.properties({
               id: created.id,
-              name: 'a-name'
+              name: 'a-name',
             });
             // The gender can be null from a RDB
             should.equal(result.gender, null);
@@ -327,35 +327,35 @@ describe('manipulation', function () {
     });
   });
 
-  describe('save', function () {
+  describe('save', function() {
 
-    it('should save new object', function (done) {
+    it('should save new object', function(done) {
       var p = new Person;
-      p.save(function (err) {
+      p.save(function(err) {
         should.not.exist(err);
         should.exist(p.id);
         done();
       });
     });
 
-    it('should save new object (promise variant)', function (done) {
+    it('should save new object (promise variant)', function(done) {
       var p = new Person;
       p.save()
-        .then(function () {
+        .then(function() {
           should.exist(p.id);
           done();
         })
         .catch(done);
     });
 
-    it('should save existing object', function (done) {
-      Person.findOne(function (err, p) {
+    it('should save existing object', function(done) {
+      Person.findOne(function(err, p) {
         should.not.exist(err);
         p.name = 'Hans';
-        p.save(function (err) {
+        p.save(function(err) {
           should.not.exist(err);
           p.name.should.equal('Hans');
-          Person.findOne(function (err, p) {
+          Person.findOne(function(err, p) {
             should.not.exist(err);
             p.name.should.equal('Hans');
             done();
@@ -364,14 +364,14 @@ describe('manipulation', function () {
       });
     });
 
-    it('should save existing object (promise variant)', function (done) {
+    it('should save existing object (promise variant)', function(done) {
       Person.findOne()
-        .then(function (p) {
+        .then(function(p) {
           p.name = 'Fritz';
           return p.save()
-            .then(function () {
+            .then(function() {
               return Person.findOne()
-                .then(function (p) {
+                .then(function(p) {
                   p.name.should.equal('Fritz');
                   done();
                 });
@@ -380,17 +380,17 @@ describe('manipulation', function () {
         .catch(done);
     });
 
-    it('should save invalid object (skipping validation)', function (done) {
-      Person.findOne(function (err, p) {
+    it('should save invalid object (skipping validation)', function(done) {
+      Person.findOne(function(err, p) {
         should.not.exist(err);
-        p.isValid = function (done) {
+        p.isValid = function(done) {
           process.nextTick(done);
           return false;
         };
         p.name = 'Nana';
-        p.save(function (err) {
+        p.save(function(err) {
           should.exist(err);
-          p.save({validate: false}, function (err) {
+          p.save({ validate: false }, function(err) {
             should.not.exist(err);
             done();
           });
@@ -398,21 +398,21 @@ describe('manipulation', function () {
       });
     });
 
-    it('should save invalid object (skipping validation - promise variant)', function (done) {
+    it('should save invalid object (skipping validation - promise variant)', function(done) {
       Person.findOne()
-        .then(function (p) {
-          p.isValid = function (done) {
+        .then(function(p) {
+          p.isValid = function(done) {
             process.nextTick(done);
             return false;
           };
           p.name = 'Nana';
           return p.save()
-            .then(function (d) {
+            .then(function(d) {
               done(new Error('save should have failed.'));
-            }, function (err) {
+            }, function(err) {
               should.exist(err);
-              p.save({validate: false})
-                .then(function (d) {
+              p.save({ validate: false })
+                .then(function(d) {
                   should.exist(d);
                   done();
                 });
@@ -421,16 +421,16 @@ describe('manipulation', function () {
         .catch(done);
     });
 
-    it('should save throw error on validation', function () {
-      Person.findOne(function (err, p) {
+    it('should save throw error on validation', function() {
+      Person.findOne(function(err, p) {
         should.not.exist(err);
-        p.isValid = function (cb) {
+        p.isValid = function(cb) {
           cb(false);
           return false;
         };
-        (function () {
+        (function() {
           p.save({
-            'throws': true
+            'throws': true,
           });
         }).should.throw(ValidationError);
       });
@@ -455,12 +455,12 @@ describe('manipulation', function () {
     });
   });
 
-  describe('updateAttributes', function () {
+  describe('updateAttributes', function() {
     var person;
 
-    before(function (done) {
-      Person.destroyAll(function () {
-        Person.create({name: 'Mary', age: 15}, function(err, p) {
+    before(function(done) {
+      Person.destroyAll(function() {
+        Person.create({ name: 'Mary', age: 15 }, function(err, p) {
           if (err) return done(err);
           person = p;
           done();
@@ -492,7 +492,7 @@ describe('manipulation', function () {
     it('should update one attribute', function(done) {
       person.updateAttribute('name', 'Paul Graham', function(err, p) {
         if (err) return done(err);
-        Person.all(function (e, ps) {
+        Person.all(function(e, ps) {
           if (e) return done(e);
           ps.should.have.lengthOf(1);
           ps.pop().name.should.equal('Paul Graham');
@@ -501,11 +501,11 @@ describe('manipulation', function () {
       });
     });
 
-    it('should update one attribute (promise variant)', function (done) {
+    it('should update one attribute (promise variant)', function(done) {
       person.updateAttribute('name', 'Teddy Graham')
-      .then(function (p) {
+      .then(function(p) {
         return Person.all()
-        .then(function (ps) {
+        .then(function(ps) {
           ps.should.have.lengthOf(1);
           ps.pop().name.should.equal('Teddy Graham');
           done();
@@ -514,7 +514,7 @@ describe('manipulation', function () {
     });
 
     it('should ignore undefined values on updateAttributes', function(done) {
-      person.updateAttributes({'name': 'John', age: undefined},
+      person.updateAttributes({ 'name': 'John', age: undefined },
         function(err, p) {
           if (err) return done(err);
           Person.findById(p.id, function(e, p) {
@@ -530,7 +530,7 @@ describe('manipulation', function () {
       // Using {foo: 'bar'} only causes dependent test failures due to the
       // stripping of object properties when in strict mode (ie. {foo: 'bar'}
       // changes to '{}' and breaks other tests
-      person.updateAttributes({name: 'John', foo:'bar'},
+      person.updateAttributes({ name: 'John', foo:'bar' },
         function(err, p) {
           if (err) return done(err);
           should.not.exist(p.foo);
@@ -545,7 +545,7 @@ describe('manipulation', function () {
     it('should throw error on unknown attributes when strict: throw', function(done) {
       Person.definition.settings.strict = 'throw';
       Person.findById(person.id, function(err, p) {
-        p.updateAttributes({foo:'bar'},
+        p.updateAttributes({ foo:'bar' },
           function(err, p) {
             should.exist(err);
             err.name.should.equal('Error');
@@ -563,7 +563,7 @@ describe('manipulation', function () {
     it('should throw error on unknown attributes when strict: throw', function(done) {
       Person.definition.settings.strict = 'validate';
       Person.findById(person.id, function(err, p) {
-        p.updateAttributes({foo:'bar'},
+        p.updateAttributes({ foo:'bar' },
           function(err, p) {
             should.exist(err);
             err.name.should.equal('ValidationError');
@@ -578,7 +578,7 @@ describe('manipulation', function () {
     });
 
     it('should allow same id value on updateAttributes', function(done) {
-      person.updateAttributes({id: person.id, name: 'John'},
+      person.updateAttributes({ id: person.id, name: 'John' },
         function(err, p) {
           if (err) return done(err);
           Person.findById(p.id, function(e, p) {
@@ -597,7 +597,7 @@ describe('manipulation', function () {
           // For example MongoDB ObjectId
           pid = person.id.toString();
         }
-        person.updateAttributes({id: pid, name: 'John'},
+        person.updateAttributes({ id: pid, name: 'John' },
           function(err, p) {
             if (err) return done(err);
             Person.findById(p.id, function(e, p) {
@@ -611,15 +611,15 @@ describe('manipulation', function () {
 
     it('should fail if an id value is to be changed on updateAttributes',
       function(done) {
-      person.updateAttributes({id: person.id + 1, name: 'John'},
+        person.updateAttributes({ id: person.id + 1, name: 'John' },
         function(err, p) {
           should.exist(err);
           done();
         });
-    });
+      });
 
     it('should allow model instance on updateAttributes', function(done) {
-      person.updateAttributes(new Person({'name': 'John', age: undefined}),
+      person.updateAttributes(new Person({ 'name': 'John', age: undefined }),
         function(err, p) {
           if (err) return done(err);
           Person.findById(p.id, function(e, p) {
@@ -632,7 +632,7 @@ describe('manipulation', function () {
     });
 
     it('should allow model instance on updateAttributes (promise variant)', function(done) {
-      person.updateAttributes(new Person({'name': 'Jane', age: undefined}))
+      person.updateAttributes(new Person({ 'name': 'Jane', age: undefined }))
         .then(function(p) {
           return Person.findById(p.id)
             .then(function(p) {
@@ -646,12 +646,12 @@ describe('manipulation', function () {
 
     it('should raises on connector error', function(done) {
       var fakeConnector = {
-        updateAttributes: function (model, id, data, options, cb) {
+        updateAttributes: function(model, id, data, options, cb) {
           cb(new Error('Database Error'));
-        }
+        },
       };
-      person.getConnector = function () { return fakeConnector; };
-      person.updateAttributes({name: 'John'}, function(err, p) {
+      person.getConnector = function() { return fakeConnector; };
+      person.updateAttributes({ name: 'John' }, function(err, p) {
         should.exist(err);
         done();
       });
@@ -699,7 +699,7 @@ describe('manipulation', function () {
           instance.toObject().should.have.properties({
             id: instance.id,
             name: 'a-name',
-            gender: undefined
+            gender: undefined,
           });
 
           Person.updateOrCreate(
@@ -709,7 +709,7 @@ describe('manipulation', function () {
               var result = updated.toObject();
               result.should.have.properties({
                 id: instance.id,
-                name: 'updated name'
+                name: 'updated name',
               });
               should.equal(result.gender, null);
               done();
@@ -728,7 +728,7 @@ describe('manipulation', function () {
   });
 
   if (!getSchema().connector.replaceById) {
-    describe.skip('replaceById - not implemented', function(){});
+    describe.skip('replaceById - not implemented', function() {});
   } else {
     describe('replaceOrCreate', function() {
       var Post;
@@ -737,23 +737,23 @@ describe('manipulation', function () {
         Post = ds.define('Post', {
           title: { type: String, length: 255, index: true },
           content: { type: String },
-          comments: [String]
+          comments: [String],
         });
         ds.automigrate('Post', done);
       });
 
       it('works without options on create (promise variant)', function(done) {
-        var post = {id: 123, title: 'a', content: 'AAA'};
+        var post = { id: 123, title: 'a', content: 'AAA' };
         Post.replaceOrCreate(post)
         .then(function(p) {
           should.exist(p);
           p.should.be.instanceOf(Post);
           p.id.should.be.equal(post.id);
           p.should.not.have.property('_id');
-          p.title.should.equal(post.title);          
+          p.title.should.equal(post.title);
           p.content.should.equal(post.content);
           return Post.findById(p.id)
-          .then(function (p) {
+          .then(function(p) {
             p.id.should.equal(post.id);
             p.id.should.not.have.property('_id');
             p.title.should.equal(p.title);
@@ -765,17 +765,17 @@ describe('manipulation', function () {
       });
 
       it('works with options on create (promise variant)', function(done) {
-        var post = {id: 123, title: 'a', content: 'AAA'};
-        Post.replaceOrCreate(post, {validate: false})
+        var post = { id: 123, title: 'a', content: 'AAA' };
+        Post.replaceOrCreate(post, { validate: false })
         .then(function(p) {
           should.exist(p);
           p.should.be.instanceOf(Post);
           p.id.should.be.equal(post.id);
           p.should.not.have.property('_id');
-          p.title.should.equal(post.title);          
+          p.title.should.equal(post.title);
           p.content.should.equal(post.content);
           return Post.findById(p.id)
-          .then(function (p) {
+          .then(function(p) {
             p.id.should.equal(post.id);
             p.id.should.not.have.property('_id');
             p.title.should.equal(p.title);
@@ -787,7 +787,7 @@ describe('manipulation', function () {
       });
 
       it('works without options on update (promise variant)', function(done) {
-        var post = {title: 'a', content: 'AAA', comments: ['Comment1']};
+        var post = { title: 'a', content: 'AAA', comments: ['Comment1'] };
         Post.create(post)
           .then(function(created) {
             created = created.toObject();
@@ -804,7 +804,7 @@ describe('manipulation', function () {
               p.should.not.have.property(p.content);
               p.should.not.have.property(p.comments);
               return Post.findById(created.id)
-              .then(function (p) {
+              .then(function(p) {
                 p.should.not.have.property('_id');
                 p.title.should.equal('b');
                 should.not.exist(p.content);
@@ -817,14 +817,14 @@ describe('manipulation', function () {
       });
 
       it('works with options on update (promise variant)', function(done) {
-        var post = {title: 'a', content: 'AAA', comments: ['Comment1']};
+        var post = { title: 'a', content: 'AAA', comments: ['Comment1'] };
         Post.create(post)
           .then(function(created) {
             created = created.toObject();
             delete created.comments;
             delete created.content;
             created.title = 'b';
-            return Post.replaceOrCreate(created, {validate: false})
+            return Post.replaceOrCreate(created, { validate: false })
             .then(function(p) {
               should.exist(p);
               p.should.be.instanceOf(Post);
@@ -834,7 +834,7 @@ describe('manipulation', function () {
               p.should.not.have.property(p.content);
               p.should.not.have.property(p.comments);
               return Post.findById(created.id)
-              .then(function (p) {
+              .then(function(p) {
                 p.should.not.have.property('_id');
                 p.title.should.equal('b');
                 should.not.exist(p.content);
@@ -847,7 +847,7 @@ describe('manipulation', function () {
       });
 
       it('works without options on update (callback variant)', function(done) {
-        Post.create({title: 'a', content: 'AAA', comments: ['Comment1']},
+        Post.create({ title: 'a', content: 'AAA', comments: ['Comment1'] },
           function(err, post) {
             if (err) return done(err);
             post = post.toObject();
@@ -875,8 +875,8 @@ describe('manipulation', function () {
       });
 
       it('works with options on update (callback variant)', function(done) {
-        Post.create({title: 'a', content: 'AAA', comments: ['Comment1']},
-          {validate: false},
+        Post.create({ title: 'a', content: 'AAA', comments: ['Comment1'] },
+          { validate: false },
           function(err, post) {
             if (err) return done(err);
             post = post.toObject();
@@ -904,7 +904,7 @@ describe('manipulation', function () {
       });
 
       it('works without options on create (callback variant)', function(done) {
-        var post = {id: 123, title: 'a', content: 'AAA'};
+        var post = { id: 123, title: 'a', content: 'AAA' };
         Post.replaceOrCreate(post, function(err, p) {
           if (err) return done(err);
           p.id.should.equal(post.id);
@@ -923,8 +923,8 @@ describe('manipulation', function () {
       });
 
       it('works with options on create (callback variant)', function(done) {
-        var post = {id: 123, title: 'a', content: 'AAA'};
-        Post.replaceOrCreate(post, {validate: false}, function (err, p) {
+        var post = { id: 123, title: 'a', content: 'AAA' };
+        Post.replaceOrCreate(post, { validate: false }, function(err, p) {
           if (err) return done(err);
           p.id.should.equal(post.id);
           p.should.not.have.property('_id');
@@ -944,23 +944,23 @@ describe('manipulation', function () {
   }
 
   if (!getSchema().connector.replaceById) {
-    describe.skip('replaceAttributes/replaceById - not implemented', function(){});
+    describe.skip('replaceAttributes/replaceById - not implemented', function() {});
   } else {
     describe('replaceAttributes', function() {
       var postInstance;
       var Post;
       var ds = getSchema();
-      before(function (done) {
+      before(function(done) {
         Post = ds.define('Post', {
-          title: {type: String, length: 255, index: true},
-          content: {type: String},
-          comments: [String]
+          title: { type: String, length: 255, index: true },
+          content: { type: String },
+          comments: [String],
         });
         ds.automigrate('Post', done);
       });
-      beforeEach(function (done) {
-        Post.destroyAll(function () {
-          Post.create({title: 'a', content: 'AAA'}, function (err, p) {
+      beforeEach(function(done) {
+        Post.destroyAll(function() {
+          Post.create({ title: 'a', content: 'AAA' }, function(err, p) {
             if (err) return done(err);
             postInstance = p;
             done();
@@ -995,7 +995,7 @@ describe('manipulation', function () {
           p.title.should.equal('b');
           p.should.not.have.property('content', undefined);
           return Post.findById(postInstance.id)
-          .then(function (p) {
+          .then(function(p) {
             p.title.should.equal('b');
             should.not.exist(p.content);
             done();
@@ -1003,19 +1003,19 @@ describe('manipulation', function () {
         });
       })
       .catch(done);
-    });
+      });
 
-    it('works with options(promise variant)', function(done) {
-      Post.findById(postInstance.id)
-      .then(function(p){
-        p.replaceAttributes({title: 'b'}, {validate: false})
+      it('works with options(promise variant)', function(done) {
+        Post.findById(postInstance.id)
+      .then(function(p) {
+        p.replaceAttributes({ title: 'b' }, { validate: false })
         .then(function(p) {
           should.exist(p);
           p.should.be.instanceOf(Post);
           p.title.should.equal('b');
           p.should.not.have.property('content', undefined);
           return Post.findById(postInstance.id)
-          .then(function (p) {
+          .then(function(p) {
             p.title.should.equal('b');
             should.not.exist(p.content);
             done();
@@ -1023,31 +1023,31 @@ describe('manipulation', function () {
         });
       })
       .catch(done);
-    });
+      });
 
-    it('works without options(callback variant)', function(done) {
-      Post.findById(postInstance.id, function(err, p) {
-        if (err) return done(err);
-        p.replaceAttributes({title: 'b'}, function(err, p) {
+      it('works without options(callback variant)', function(done) {
+        Post.findById(postInstance.id, function(err, p) {
+          if (err) return done(err);
+          p.replaceAttributes({ title: 'b' }, function(err, p) {
           if (err) return done(err);
           p.should.not.have.property('content', undefined);
           p.title.should.equal('b');
           done();
         });
-      });     
-    });
+        });
+      });
 
-    it('works with options(callback variant)', function(done) {
-      Post.findById(postInstance.id, function(err, p) {
-        if (err) return done(err);
-        p.replaceAttributes({title: 'b'}, {validate: false}, function(err, p) {
+      it('works with options(callback variant)', function(done) {
+        Post.findById(postInstance.id, function(err, p) {
+          if (err) return done(err);
+          p.replaceAttributes({ title: 'b' }, { validate: false }, function(err, p) {
           if (err) return done(err);
           p.should.not.have.property('content', undefined);
           p.title.should.equal('b');
           done();
         });
-      });     
-    });      
+        });
+      });
     });
   }
 
@@ -1067,8 +1067,8 @@ describe('manipulation', function () {
 
     it('should find a record if exists', function(done) {
       Person.findOrCreate(
-        {where: {name: 'Zed'}},
-        {name: 'Zed', gender: 'male'},
+        { where: { name: 'Zed' }},
+        { name: 'Zed', gender: 'male' },
         function(err, p, created) {
           if (err) return done(err);
           should.exist(p);
@@ -1099,8 +1099,8 @@ describe('manipulation', function () {
 
     it('should find a record if exists (promise variant)', function(done) {
       Person.findOrCreate(
-        {where: {name: 'Jed'}},
-        {name: 'Jed', gender: 'male'})
+        { where: { name: 'Jed' }},
+        { name: 'Jed', gender: 'male' })
       .then(function(res) {
         res.should.be.instanceOf(Array);
         res.should.have.lengthOf(2);
@@ -1116,13 +1116,13 @@ describe('manipulation', function () {
     });
   });
 
-  describe('destroy', function () {
+  describe('destroy', function() {
 
-    it('should destroy record', function (done) {
-      Person.create(function (err, p) {
-        p.destroy(function (err) {
+    it('should destroy record', function(done) {
+      Person.create(function(err, p) {
+        p.destroy(function(err) {
           should.not.exist(err);
-          Person.exists(p.id, function (err, ex) {
+          Person.exists(p.id, function(err, ex) {
             ex.should.not.be.ok;
             done();
           });
@@ -1130,13 +1130,13 @@ describe('manipulation', function () {
       });
     });
 
-    it('should destroy record (promise variant)', function (done) {
+    it('should destroy record (promise variant)', function(done) {
       Person.create()
-        .then(function (p) {
+        .then(function(p) {
           return p.destroy()
-            .then(function () {
+            .then(function() {
               return Person.exists(p.id)
-                .then(function (ex) {
+                .then(function(ex) {
                   ex.should.not.be.ok;
                   done();
                 });
@@ -1145,12 +1145,12 @@ describe('manipulation', function () {
         .catch(done);
     });
 
-    it('should destroy all records', function (done) {
-      Person.destroyAll(function (err) {
+    it('should destroy all records', function(done) {
+      Person.destroyAll(function(err) {
         should.not.exist(err);
-        Person.all(function (err, posts) {
+        Person.all(function(err, posts) {
           posts.should.have.lengthOf(0);
-          Person.count(function (err, count) {
+          Person.count(function(err, count) {
             count.should.eql(0);
             done();
           });
@@ -1158,16 +1158,16 @@ describe('manipulation', function () {
       });
     });
 
-    it('should destroy all records (promise variant)', function (done) {
+    it('should destroy all records (promise variant)', function(done) {
       Person.create()
         .then(function() {
           return Person.destroyAll()
-            .then(function () {
+            .then(function() {
               return Person.all()
-                .then(function (ps) {
+                .then(function(ps) {
                   ps.should.have.lengthOf(0);
                   return Person.count()
-                    .then(function (count) {
+                    .then(function(count) {
                       count.should.eql(0);
                       done();
                     });
@@ -1182,16 +1182,16 @@ describe('manipulation', function () {
     it('should destroy filtered set of records');
   });
 
-  describe('deleteAll/destroyAll', function () {
+  describe('deleteAll/destroyAll', function() {
     beforeEach(function clearOldData(done) {
       Person.deleteAll(done);
     });
 
     beforeEach(function createTestData(done) {
       Person.create([{
-        name: 'John'
+        name: 'John',
       }, {
-        name: 'Jane'
+        name: 'Jane',
       }], done);
     });
 
@@ -1202,46 +1202,46 @@ describe('manipulation', function () {
 
     it('should only delete instances that satisfy the where condition',
         function(done) {
-      Person.deleteAll({name: 'John'}, function(err, info) {
-        if (err) return done(err);
-        info.should.have.property('count', 1);
-        Person.find({where: {name: 'John'}}, function(err, data) {
-          if (err) return done(err);
-          data.should.have.length(0);
-          Person.find({where: {name: 'Jane'}}, function(err, data) {
+          Person.deleteAll({ name: 'John' }, function(err, info) {
+            if (err) return done(err);
+            info.should.have.property('count', 1);
+            Person.find({ where: { name: 'John' }}, function(err, data) {
+              if (err) return done(err);
+              data.should.have.length(0);
+              Person.find({ where: { name: 'Jane' }}, function(err, data) {
             if (err) return done(err);
             data.should.have.length(1);
             done();
           });
+            });
+          });
         });
-      });
-    });
 
     it('should report zero deleted instances when no matches are found',
         function(done) {
-      Person.deleteAll({name: 'does-not-match'}, function(err, info) {
-        if (err) return done(err);
-        info.should.have.property('count', 0);
-        Person.count(function(err, count) {
-          if (err) return done(err);
-          count.should.equal(2);
-          done();
+          Person.deleteAll({ name: 'does-not-match' }, function(err, info) {
+            if (err) return done(err);
+            info.should.have.property('count', 0);
+            Person.count(function(err, count) {
+              if (err) return done(err);
+              count.should.equal(2);
+              done();
+            });
+          });
         });
-      });
-    });
 
     it('should delete all instances when the where condition is not provided',
         function(done) {
-      Person.deleteAll(function (err, info) {
-        if (err) return done(err);
-        info.should.have.property('count', 2);
-        Person.count(function(err, count) {
-          if (err) return done(err);
-          count.should.equal(0);
-          done();
+          Person.deleteAll(function(err, info) {
+            if (err) return done(err);
+            info.should.have.property('count', 2);
+            Person.count(function(err, count) {
+              if (err) return done(err);
+              count.should.equal(0);
+              done();
+            });
+          });
         });
-      });
-    });
   });
 
   describe('deleteById', function() {
@@ -1250,8 +1250,8 @@ describe('manipulation', function () {
       Person.settings.strictDelete = false;
     });
 
-    it('should allow deleteById(id) - success', function (done) {
-      Person.findOne(function (e, p) {
+    it('should allow deleteById(id) - success', function(done) {
+      Person.findOne(function(e, p) {
         Person.deleteById(p.id, function(err, info) {
           if (err) return done(err);
           info.should.have.property('count', 1);
@@ -1260,7 +1260,7 @@ describe('manipulation', function () {
       });
     });
 
-    it('should allow deleteById(id) - fail', function (done) {
+    it('should allow deleteById(id) - fail', function(done) {
       Person.settings.strictDelete = false;
       Person.deleteById(9999, function(err, info) {
         if (err) return done(err);
@@ -1269,7 +1269,7 @@ describe('manipulation', function () {
       });
     });
 
-    it('should allow deleteById(id) - fail with error', function (done) {
+    it('should allow deleteById(id) - fail with error', function(done) {
       Person.settings.strictDelete = true;
       Person.deleteById(9999, function(err) {
         should.exist(err);
@@ -1287,8 +1287,8 @@ describe('manipulation', function () {
       Person.settings.strictDelete = false;
     });
 
-    it('should allow delete(id) - success', function (done) {
-      Person.findOne(function (e, p) {
+    it('should allow delete(id) - success', function(done) {
+      Person.findOne(function(e, p) {
         p.delete(function(err, info) {
           if (err) return done(err);
           info.should.have.property('count', 1);
@@ -1297,9 +1297,9 @@ describe('manipulation', function () {
       });
     });
 
-    it('should allow delete(id) - fail', function (done) {
+    it('should allow delete(id) - fail', function(done) {
       Person.settings.strictDelete = false;
-      Person.findOne(function (e, p) {
+      Person.findOne(function(e, p) {
         p.delete(function(err, info) {
           if (err) return done(err);
           info.should.have.property('count', 1);
@@ -1312,9 +1312,9 @@ describe('manipulation', function () {
       });
     });
 
-    it('should allow delete(id) - fail with error', function (done) {
+    it('should allow delete(id) - fail with error', function(done) {
       Person.settings.strictDelete = true;
-      Person.findOne(function (e, u) {
+      Person.findOne(function(e, u) {
         u.delete(function(err, info) {
           if (err) return done(err);
           info.should.have.property('count', 1);
@@ -1330,11 +1330,11 @@ describe('manipulation', function () {
     });
   });
 
-  describe('initialize', function () {
-    it('should initialize object properly', function () {
+  describe('initialize', function() {
+    it('should initialize object properly', function() {
       var hw = 'Hello word',
         now = Date.now(),
-        person = new Person({name: hw});
+        person = new Person({ name: hw });
 
       person.name.should.equal(hw);
       person.name = 'Goodbye, Lenin';
@@ -1347,7 +1347,7 @@ describe('manipulation', function () {
 
       before(function(done) {
         CustomModel = db.define('CustomModel1', {
-          createdAt: { type: Date, default: '$now' }
+          createdAt: { type: Date, default: '$now' },
         });
         db.automigrate('CustomModel1', done);
       });
@@ -1371,7 +1371,7 @@ describe('manipulation', function () {
 
       before(function(done) {
         CustomModel = db.define('CustomModel2', {
-          now: { type: String, default: '$now' }
+          now: { type: String, default: '$now' },
         });
         db.automigrate('CustomModel2', done);
       });
@@ -1393,7 +1393,7 @@ describe('manipulation', function () {
 
       before(function(done) {
         CustomModel = db.define('CustomModel3', {
-          now: { type: Date, defaultFn: 'now' }
+          now: { type: Date, defaultFn: 'now' },
         });
         db.automigrate('CustomModel3', done);
       });
@@ -1415,7 +1415,7 @@ describe('manipulation', function () {
 
       before(function(done) {
         CustomModel = db.define('CustomModel4', {
-          guid: { type: String, defaultFn: 'guid' }
+          guid: { type: String, defaultFn: 'guid' },
         });
         db.automigrate('CustomModel4', done);
       });
@@ -1434,7 +1434,7 @@ describe('manipulation', function () {
 
       before(function(done) {
         CustomModel = db.define('CustomModel5', {
-          guid: { type: String, defaultFn: 'uuid' }
+          guid: { type: String, defaultFn: 'uuid' },
         });
         db.automigrate('CustomModel5', done);
       });
@@ -1454,7 +1454,7 @@ describe('manipulation', function () {
 
       before(function(done) {
         CustomModel = db.define('CustomModel5', {
-          guid: { type: String, defaultFn: 'uuidv4' }
+          guid: { type: String, defaultFn: 'uuidv4' },
         });
         db.automigrate('CustomModel5', done);
       });
@@ -1475,70 +1475,70 @@ describe('manipulation', function () {
     // });
   });
 
-  describe('property value coercion', function () {
+  describe('property value coercion', function() {
     it('should coerce boolean types properly', function() {
-      var p1 = new Person({name: 'John', married: 'false'});
+      var p1 = new Person({ name: 'John', married: 'false' });
       p1.married.should.equal(false);
 
-      p1 = new Person({name: 'John', married: 'true'});
+      p1 = new Person({ name: 'John', married: 'true' });
       p1.married.should.equal(true);
 
-      p1 = new Person({name: 'John', married: '1'});
+      p1 = new Person({ name: 'John', married: '1' });
       p1.married.should.equal(true);
 
-      p1 = new Person({name: 'John', married: '0'});
+      p1 = new Person({ name: 'John', married: '0' });
       p1.married.should.equal(false);
 
-      p1 = new Person({name: 'John', married: true});
+      p1 = new Person({ name: 'John', married: true });
       p1.married.should.equal(true);
 
-      p1 = new Person({name: 'John', married: false});
+      p1 = new Person({ name: 'John', married: false });
       p1.married.should.equal(false);
 
-      p1 = new Person({name: 'John', married: 'null'});
+      p1 = new Person({ name: 'John', married: 'null' });
       p1.married.should.equal(true);
 
-      p1 = new Person({name: 'John', married: ''});
+      p1 = new Person({ name: 'John', married: '' });
       p1.married.should.equal(false);
 
-      p1 = new Person({name: 'John', married: 'X'});
+      p1 = new Person({ name: 'John', married: 'X' });
       p1.married.should.equal(true);
 
-      p1 = new Person({name: 'John', married: 0});
+      p1 = new Person({ name: 'John', married: 0 });
       p1.married.should.equal(false);
 
-      p1 = new Person({name: 'John', married: 1});
+      p1 = new Person({ name: 'John', married: 1 });
       p1.married.should.equal(true);
 
-      p1 = new Person({name: 'John', married: null});
+      p1 = new Person({ name: 'John', married: null });
       p1.should.have.property('married', null);
 
-      p1 = new Person({name: 'John', married: undefined});
+      p1 = new Person({ name: 'John', married: undefined });
       p1.should.have.property('married', undefined);
 
     });
 
     it('should coerce boolean types properly', function() {
-      var p1 = new Person({name: 'John', dob: '2/1/2015'});
+      var p1 = new Person({ name: 'John', dob: '2/1/2015' });
       p1.dob.should.eql(new Date('2/1/2015'));
 
-      p1 = new Person({name: 'John', dob: '2/1/2015'});
+      p1 = new Person({ name: 'John', dob: '2/1/2015' });
       p1.dob.should.eql(new Date('2/1/2015'));
 
-      p1 = new Person({name: 'John', dob: '12'});
+      p1 = new Person({ name: 'John', dob: '12' });
       p1.dob.should.eql(new Date('12'));
 
-      p1 = new Person({name: 'John', dob: 12});
+      p1 = new Person({ name: 'John', dob: 12 });
       p1.dob.should.eql(new Date(12));
 
-      p1 = new Person({name: 'John', dob: null});
+      p1 = new Person({ name: 'John', dob: null });
       p1.should.have.property('dob', null);
 
-      p1 = new Person({name: 'John', dob: undefined});
+      p1 = new Person({ name: 'John', dob: undefined });
       p1.should.have.property('dob', undefined);
 
       try {
-        p1 = new Person({name: 'John', dob: 'X'});
+        p1 = new Person({ name: 'John', dob: 'X' });
         throw new Error('new Person() should have thrown');
       } catch (e) {
         e.should.be.eql(new Error('Invalid date: X'));
@@ -1554,19 +1554,19 @@ describe('manipulation', function () {
     beforeEach(function createTestData(done) {
       Person.create([{
         name: 'Brett Boe',
-        age: 19
+        age: 19,
       }, {
         name: 'Carla Coe',
-        age: 20
+        age: 20,
       }, {
         name: 'Donna Doe',
-        age: 21
+        age: 21,
       }, {
         name: 'Frank Foe',
-        age: 22
+        age: 22,
       }, {
         name: 'Grace Goe',
-        age: 23
+        age: 23,
       }], done);
     });
 
@@ -1577,73 +1577,73 @@ describe('manipulation', function () {
 
     it('should not update instances that do not satisfy the where condition',
         function(done) {
-      Person.update({name: 'Harry Hoe'}, {name: 'Marta Moe'}, function(err,
+          Person.update({ name: 'Harry Hoe' }, { name: 'Marta Moe' }, function(err,
           info) {
-        if (err) return done(err);
-        info.should.have.property('count', 0);
-        Person.find({where: {name: 'Harry Hoe'}}, function(err, people) {
-          if (err) return done(err);
-          people.should.be.empty;
-          done();
+            if (err) return done(err);
+            info.should.have.property('count', 0);
+            Person.find({ where: { name: 'Harry Hoe' }}, function(err, people) {
+              if (err) return done(err);
+              people.should.be.empty;
+              done();
+            });
+          });
         });
-      });
-    });
 
     it('should only update instances that satisfy the where condition',
         function(done) {
-      Person.update({name: 'Brett Boe'}, {name: 'Harry Hoe'}, function(err,
+          Person.update({ name: 'Brett Boe' }, { name: 'Harry Hoe' }, function(err,
           info) {
-        if (err) return done(err);
-        info.should.have.property('count', 1);
-        Person.find({where: {age: 19}}, function(err, people) {
-          if (err) return done(err);
-          people.should.have.length(1);
-          people[0].name.should.equal('Harry Hoe');
-          done();
+            if (err) return done(err);
+            info.should.have.property('count', 1);
+            Person.find({ where: { age: 19 }}, function(err, people) {
+              if (err) return done(err);
+              people.should.have.length(1);
+              people[0].name.should.equal('Harry Hoe');
+              done();
+            });
+          });
         });
-      });
-    });
 
     it('should update all instances when the where condition is not provided',
         function(done) {
-      Person.update({name: 'Harry Hoe'}, function(err, info) {
-        if (err) return done(err);
-        info.should.have.property('count', 5);
-        Person.find({where: {name: 'Brett Boe'}}, function(err, people) {
-          if (err) return done(err);
-          people.should.be.empty;
-          Person.find({where: {name: 'Harry Hoe'}}, function(err, people) {
+          Person.update({ name: 'Harry Hoe' }, function(err, info) {
+            if (err) return done(err);
+            info.should.have.property('count', 5);
+            Person.find({ where: { name: 'Brett Boe' }}, function(err, people) {
+              if (err) return done(err);
+              people.should.be.empty;
+              Person.find({ where: { name: 'Harry Hoe' }}, function(err, people) {
             if (err) return done(err);
             people.should.have.length(5);
             done();
           });
+            });
+          });
         });
-      });
-    });
 
     it('should ignore where conditions with undefined values',
         function(done) {
-      Person.update({name: 'Brett Boe'}, {name: undefined, gender: 'male'},
+          Person.update({ name: 'Brett Boe' }, { name: undefined, gender: 'male' },
           function(err, info) {
-        if (err) return done(err);
-        info.should.have.property('count', 1);
-        Person.find({where: {name: 'Brett Boe'}}, function(err, people) {
-          if (err) return done(err);
-          people.should.have.length(1);
-          people[0].name.should.equal('Brett Boe');
-          done();
+            if (err) return done(err);
+            info.should.have.property('count', 1);
+            Person.find({ where: { name: 'Brett Boe' }}, function(err, people) {
+              if (err) return done(err);
+              people.should.have.length(1);
+              people[0].name.should.equal('Brett Boe');
+              done();
+            });
+          });
         });
-      });
-    });
 
     it('should not coerce invalid values provided in where conditions',
         function(done) {
-      Person.update({name: 'Brett Boe'}, {dob: 'Carla Coe'}, function(err) {
-        should.exist(err);
-        err.message.should.equal('Invalid date: Carla Coe');
-        done();
-      });
-    });
+          Person.update({ name: 'Brett Boe' }, { dob: 'Carla Coe' }, function(err) {
+            should.exist(err);
+            err.message.should.equal('Invalid date: Carla Coe');
+            done();
+          });
+        });
   });
 });
 
@@ -1654,13 +1654,13 @@ function givenSomePeople(done) {
     { name: 'George Harrison', gender: 'male' },
     { name: 'Ringo Starr', gender: 'male' },
     { name: 'Pete Best', gender: 'male' },
-    { name: 'Stuart Sutcliffe', gender: 'male' }
+    { name: 'Stuart Sutcliffe', gender: 'male' },
   ];
 
   async.series([
     Person.destroyAll.bind(Person),
     function(cb) {
       async.each(beatles, Person.create.bind(Person), cb);
-    }
+    },
   ], done);
 }
diff --git a/test/memory.test.js b/test/memory.test.js
index ec191c5e..040877f2 100644
--- a/test/memory.test.js
+++ b/test/memory.test.js
@@ -36,20 +36,20 @@ describe('Memory connector', function() {
     function createUserModel() {
       var ds = new DataSource({
         connector: 'memory',
-        file: file
+        file: file,
       });
 
       var User = ds.createModel('User', {
         id: {
           type: Number,
           id: true,
-          generated: true
+          generated: true,
         },
         name: String,
         bio: String,
         approved: Boolean,
         joinedAt: Date,
-        age: Number
+        age: Number,
       });
       return User;
     }
@@ -64,7 +64,7 @@ describe('Memory connector', function() {
     it('should persist create', function(done) {
       var count = 0;
       async.eachSeries(['John1', 'John2', 'John3'], function(item, cb) {
-        User.create({name: item}, function(err, result) {
+        User.create({ name: item }, function(err, result) {
           ids.push(result.id);
           count++;
           readModels(function(err, json) {
@@ -92,7 +92,7 @@ describe('Memory connector', function() {
     });
 
     it('should persist upsert', function(done) {
-      User.upsert({id: ids[1], name: 'John'}, function(err, result) {
+      User.upsert({ id: ids[1], name: 'John' }, function(err, result) {
         if (err) {
           return done(err);
         }
@@ -110,7 +110,7 @@ describe('Memory connector', function() {
     });
 
     it('should persist update', function(done) {
-      User.update({id: ids[1]}, {name: 'John1'},
+      User.update({ id: ids[1] }, { name: 'John1' },
         function(err, result) {
           if (err) {
             return done(err);
@@ -141,33 +141,33 @@ describe('Memory connector', function() {
 
   describe('Query for memory connector', function() {
     var ds = new DataSource({
-      connector: 'memory'
+      connector: 'memory',
     });
 
     var User = ds.define('User', {
-      seq: {type: Number, index: true},
-      name: {type: String, index: true, sort: true},
-      email: {type: String, index: true},
-      birthday: {type: Date, index: true},
-      role: {type: String, index: true},
-      order: {type: Number, index: true, sort: true},
-      vip: {type: Boolean},
+      seq: { type: Number, index: true },
+      name: { type: String, index: true, sort: true },
+      email: { type: String, index: true },
+      birthday: { type: Date, index: true },
+      role: { type: String, index: true },
+      order: { type: Number, index: true, sort: true },
+      vip: { type: Boolean },
       address: {
         street: String,
         city: String,
         state: String,
-        zipCode: String
+        zipCode: String,
       },
       friends: [
         {
-          name: String
-        }
-      ]
+          name: String,
+        },
+      ],
     });
 
     before(seed);
     it('should allow to find using like', function(done) {
-      User.find({where: {name: {like: '%St%'}}}, function(err, posts) {
+      User.find({ where: { name: { like: '%St%' }}}, function(err, posts) {
         should.not.exist(err);
         posts.should.have.property('length', 2);
         done();
@@ -175,7 +175,7 @@ describe('Memory connector', function() {
     });
 
     it('should allow to find using like with regexp', function(done) {
-      User.find({where: {name: {like: /.*St.*/}}}, function(err, posts) {
+      User.find({ where: { name: { like: /.*St.*/ }}}, function(err, posts) {
         should.not.exist(err);
         posts.should.have.property('length', 2);
         done();
@@ -183,7 +183,7 @@ describe('Memory connector', function() {
     });
 
     it('should support like for no match', function(done) {
-      User.find({where: {name: {like: 'M%XY'}}}, function(err, posts) {
+      User.find({ where: { name: { like: 'M%XY' }}}, function(err, posts) {
         should.not.exist(err);
         posts.should.have.property('length', 0);
         done();
@@ -191,7 +191,7 @@ describe('Memory connector', function() {
     });
 
     it('should allow to find using nlike', function(done) {
-      User.find({where: {name: {nlike: '%St%'}}}, function(err, posts) {
+      User.find({ where: { name: { nlike: '%St%' }}}, function(err, posts) {
         should.not.exist(err);
         posts.should.have.property('length', 4);
         done();
@@ -199,7 +199,7 @@ describe('Memory connector', function() {
     });
 
     it('should allow to find using nlike with regexp', function(done) {
-      User.find({where: {name: {nlike: /.*St.*/}}}, function(err, posts) {
+      User.find({ where: { name: { nlike: /.*St.*/ }}}, function(err, posts) {
         should.not.exist(err);
         posts.should.have.property('length', 4);
         done();
@@ -207,7 +207,7 @@ describe('Memory connector', function() {
     });
 
     it('should support nlike for no match', function(done) {
-      User.find({where: {name: {nlike: 'M%XY'}}}, function(err, posts) {
+      User.find({ where: { name: { nlike: 'M%XY' }}}, function(err, posts) {
         should.not.exist(err);
         posts.should.have.property('length', 6);
         done();
@@ -215,73 +215,73 @@ describe('Memory connector', function() {
     });
 
     it('should throw if the like value is not string or regexp', function(done) {
-      User.find({where: {name: {like: 123}}}, function(err, posts) {
+      User.find({ where: { name: { like: 123 }}}, function(err, posts) {
         should.exist(err);
         done();
       });
     });
 
     it('should throw if the nlike value is not string or regexp', function(done) {
-      User.find({where: {name: {nlike: 123}}}, function(err, posts) {
+      User.find({ where: { name: { nlike: 123 }}}, function(err, posts) {
         should.exist(err);
         done();
       });
     });
 
     it('should throw if the inq value is not an array', function(done) {
-      User.find({where: {name: {inq: '12'}}}, function(err, posts) {
+      User.find({ where: { name: { inq: '12' }}}, function(err, posts) {
         should.exist(err);
         done();
       });
     });
 
     it('should throw if the nin value is not an array', function(done) {
-      User.find({where: {name: {nin: '12'}}}, function(err, posts) {
+      User.find({ where: { name: { nin: '12' }}}, function(err, posts) {
         should.exist(err);
         done();
       });
     });
 
     it('should throw if the between value is not an array', function(done) {
-      User.find({where: {name: {between: '12'}}}, function(err, posts) {
+      User.find({ where: { name: { between: '12' }}}, function(err, posts) {
         should.exist(err);
         done();
       });
     });
 
     it('should throw if the between value is not an array of length 2', function(done) {
-      User.find({where: {name: {between: ['12']}}}, function(err, posts) {
+      User.find({ where: { name: { between: ['12'] }}}, function(err, posts) {
         should.exist(err);
         done();
       });
     });
 
     it('should successfully extract 5 users from the db', function(done) {
-      User.find({where: {seq: {between: [1,5]}}}, function(err, users) {
+      User.find({ where: { seq: { between: [1, 5] }}}, function(err, users) {
         should(users.length).be.equal(5);
         done();
       });
     });
 
     it('should successfully extract 1 user (Lennon) from the db', function(done) {
-      User.find({where: {birthday: {between: [new Date(1970,0),new Date(1990,0)]}}},
+      User.find({ where: { birthday: { between: [new Date(1970, 0), new Date(1990, 0)] }}},
                 function(err, users) {
-        should(users.length).be.equal(1);
-        should(users[0].name).be.equal('John Lennon');
-        done();
-      });
+                  should(users.length).be.equal(1);
+                  should(users[0].name).be.equal('John Lennon');
+                  done();
+                });
     });
 
     it('should successfully extract 2 users from the db', function(done) {
-      User.find({where: {birthday: {between: [new Date(1940,0),new Date(1990,0)]}}},
+      User.find({ where: { birthday: { between: [new Date(1940, 0), new Date(1990, 0)] }}},
                 function(err, users) {
-        should(users.length).be.equal(2);
-        done();
-      });
+                  should(users.length).be.equal(2);
+                  done();
+                });
     });
 
     it('should successfully extract 2 users using implied and', function(done) {
-      User.find({where: {role:'lead', vip:true}}, function(err, users) {
+      User.find({ where: { role:'lead', vip:true }}, function(err, users) {
         should(users.length).be.equal(2);
         should(users[0].name).be.equal('John Lennon');
         should(users[1].name).be.equal('Paul McCartney');
@@ -290,7 +290,7 @@ describe('Memory connector', function() {
     });
 
     it('should successfully extract 2 users using implied and & and', function(done) {
-      User.find({where: { name: 'John Lennon',and: [{role:'lead'}, {vip:true}]}}, function(err, users) {
+      User.find({ where: { name: 'John Lennon', and: [{ role:'lead' }, { vip:true }] }}, function(err, users) {
         should(users.length).be.equal(1);
         should(users[0].name).be.equal('John Lennon');
         done();
@@ -298,8 +298,8 @@ describe('Memory connector', function() {
     });
 
     it('should successfully extract 2 users using date range', function(done) {
-      User.find({where: {birthday: {between:
-          [new Date(1940, 0).toISOString(), new Date(1990, 0).toISOString()]}}},
+      User.find({ where: { birthday: { between:
+          [new Date(1940, 0).toISOString(), new Date(1990, 0).toISOString()] }}},
         function(err, users) {
           should(users.length).be.equal(2);
           done();
@@ -307,21 +307,21 @@ describe('Memory connector', function() {
     });
 
     it('should successfully extract 0 user from the db', function(done) {
-      User.find({where: {birthday: {between: [new Date(1990,0), Date.now()]}}},
+      User.find({ where: { birthday: { between: [new Date(1990, 0), Date.now()] }}},
                 function(err, users) {
-        should(users.length).be.equal(0);
-        done();
-      });
+                  should(users.length).be.equal(0);
+                  done();
+                });
     });
 
-    it('should successfully extract 2 users matching over array values', function (done) {
+    it('should successfully extract 2 users matching over array values', function(done) {
       User.find({
         where: {
           children: {
-            regexp: /an/
-          }
-        }
-      }, function (err, users) {
+            regexp: /an/,
+          },
+        },
+      }, function(err, users) {
         should.not.exist(err);
         users.length.should.be.equal(2);
         users[0].name.should.be.equal('John Lennon');
@@ -330,12 +330,12 @@ describe('Memory connector', function() {
       });
     });
 
-    it('should successfully extract 1 users matching over array values', function (done) {
+    it('should successfully extract 1 users matching over array values', function(done) {
       User.find({
         where: {
-          children: 'Dhani'
-        }
-      }, function (err, users) {
+          children: 'Dhani',
+        },
+      }, function(err, users) {
         should.not.exist(err);
         users.length.should.be.equal(1);
         users[0].name.should.be.equal('George Harrison');
@@ -343,12 +343,12 @@ describe('Memory connector', function() {
       });
     });
 
-    it('should successfully extract 5 users matching a neq filter over array values', function (done) {
+    it('should successfully extract 5 users matching a neq filter over array values', function(done) {
       User.find({
         where: {
-          'children': {neq: 'Dhani'}
-        }
-      }, function (err, users) {
+          'children': { neq: 'Dhani' },
+        },
+      }, function(err, users) {
         should.not.exist(err);
         users.length.should.be.equal(5);
         done();
@@ -356,7 +356,7 @@ describe('Memory connector', function() {
     });
 
     it('should count using date string', function(done) {
-      User.count({birthday: {lt: new Date(1990,0).toISOString()}},
+      User.count({ birthday: { lt: new Date(1990, 0).toISOString() }},
         function(err, count) {
           should(count).be.equal(2);
           done();
@@ -364,7 +364,7 @@ describe('Memory connector', function() {
     });
 
     it('should support order with multiple fields', function(done) {
-      User.find({order: 'vip ASC, seq DESC'}, function(err, posts) {
+      User.find({ order: 'vip ASC, seq DESC' }, function(err, posts) {
         should.not.exist(err);
         posts[0].seq.should.be.eql(4);
         posts[1].seq.should.be.eql(3);
@@ -373,7 +373,7 @@ describe('Memory connector', function() {
     });
 
     it('should sort undefined values to the end when ordered DESC', function(done) {
-      User.find({order: 'vip ASC, order DESC'}, function(err, posts) {
+      User.find({ order: 'vip ASC, order DESC' }, function(err, posts) {
         should.not.exist(err);
 
         posts[4].seq.should.be.eql(1);
@@ -383,14 +383,14 @@ describe('Memory connector', function() {
     });
 
     it('should throw if order has wrong direction', function(done) {
-      User.find({order: 'seq ABC'}, function(err, posts) {
+      User.find({ order: 'seq ABC' }, function(err, posts) {
         should.exist(err);
         done();
       });
     });
 
     it('should support neq operator for number', function(done) {
-      User.find({where: {seq: {neq: 4}}}, function(err, users) {
+      User.find({ where: { seq: { neq: 4 }}}, function(err, users) {
         should.not.exist(err);
         users.length.should.be.equal(5);
         for (var i = 0; i < users.length; i++) {
@@ -401,7 +401,7 @@ describe('Memory connector', function() {
     });
 
     it('should support neq operator for string', function(done) {
-      User.find({where: {role: {neq: 'lead'}}}, function(err, users) {
+      User.find({ where: { role: { neq: 'lead' }}}, function(err, users) {
         should.not.exist(err);
         users.length.should.be.equal(4);
         for (var i = 0; i < users.length; i++) {
@@ -414,7 +414,7 @@ describe('Memory connector', function() {
     });
 
     it('should support neq operator for null', function(done) {
-      User.find({where: {role: {neq: null}}}, function(err, users) {
+      User.find({ where: { role: { neq: null }}}, function(err, users) {
         should.not.exist(err);
         users.length.should.be.equal(2);
         for (var i = 0; i < users.length; i++) {
@@ -426,16 +426,16 @@ describe('Memory connector', function() {
 
     it('should work when a regex is provided without the regexp operator',
         function(done) {
-      User.find({where: {name: /John.*/i}}, function(err, users) {
-        should.not.exist(err);
-        users.length.should.equal(1);
-        users[0].name.should.equal('John Lennon');
-        done();
-      });
-    });
+          User.find({ where: { name: /John.*/i }}, function(err, users) {
+            should.not.exist(err);
+            users.length.should.equal(1);
+            users[0].name.should.equal('John Lennon');
+            done();
+          });
+        });
 
     it('should support the regexp operator with regex strings', function(done) {
-      User.find({where: {name: {regexp: '^J'}}}, function(err, users) {
+      User.find({ where: { name: { regexp: '^J' }}}, function(err, users) {
         should.not.exist(err);
         users.length.should.equal(1);
         users[0].name.should.equal('John Lennon');
@@ -444,7 +444,7 @@ describe('Memory connector', function() {
     });
 
     it('should support the regexp operator with regex literals', function(done) {
-      User.find({where: {name: {regexp: /^J/}}}, function(err, users) {
+      User.find({ where: { name: { regexp: /^J/ }}}, function(err, users) {
         should.not.exist(err);
         users.length.should.equal(1);
         users[0].name.should.equal('John Lennon');
@@ -453,7 +453,7 @@ describe('Memory connector', function() {
     });
 
     it('should support the regexp operator with regex objects', function(done) {
-      User.find({where: {name: {regexp: new RegExp(/^J/)}}}, function(err,
+      User.find({ where: { name: { regexp: new RegExp(/^J/) }}}, function(err,
           users) {
         should.not.exist(err);
         users.length.should.equal(1);
@@ -463,7 +463,7 @@ describe('Memory connector', function() {
     });
 
     it('should support nested property in query', function(done) {
-      User.find({where: {'address.city': 'San Jose'}}, function(err, users) {
+      User.find({ where: { 'address.city': 'San Jose' }}, function(err, users) {
         should.not.exist(err);
         users.length.should.be.equal(1);
         for (var i = 0; i < users.length; i++) {
@@ -474,7 +474,7 @@ describe('Memory connector', function() {
     });
 
     it('should support nested property with regex over arrays in query', function(done) {
-      User.find({where: {'friends.name': {regexp: /^Ringo/}}}, function(err, users) {
+      User.find({ where: { 'friends.name': { regexp: /^Ringo/ }}}, function(err, users) {
         should.not.exist(err);
         users.length.should.be.equal(2);
         users[0].name.should.be.equal('John Lennon');
@@ -484,18 +484,18 @@ describe('Memory connector', function() {
     });
 
     it('should support nested property with gt in query', function(done) {
-        User.find({where: {'address.city': {gt: 'San'}}}, function(err, users) {
-          should.not.exist(err);
-          users.length.should.be.equal(2);
-          for (var i = 0; i < users.length; i++) {
+      User.find({ where: { 'address.city': { gt: 'San' }}}, function(err, users) {
+        should.not.exist(err);
+        users.length.should.be.equal(2);
+        for (var i = 0; i < users.length; i++) {
             users[i].address.state.should.be.eql('CA');
           }
-          done();
-        });
+        done();
+      });
     });
 
     it('should support nested property for order in query', function(done) {
-      User.find({where: {'address.state': 'CA'}, order: 'address.city DESC'},
+      User.find({ where: { 'address.state': 'CA' }, order: 'address.city DESC' },
         function(err, users) {
           should.not.exist(err);
           users.length.should.be.equal(2);
@@ -506,8 +506,8 @@ describe('Memory connector', function() {
     });
 
     it('should deserialize values after saving in upsert', function(done) {
-      User.findOne({where: {seq: 1}}, function(err, paul) {
-        User.updateOrCreate({id: paul.id, name: 'Sir Paul McCartney'},
+      User.findOne({ where: { seq: 1 }}, function(err, paul) {
+        User.updateOrCreate({ id: paul.id, name: 'Sir Paul McCartney' },
           function(err, sirpaul) {
             should.not.exist(err);
             sirpaul.birthday.should.be.instanceOf(Date);
@@ -531,14 +531,14 @@ describe('Memory connector', function() {
             street: '123 A St',
             city: 'San Jose',
             state: 'CA',
-            zipCode: '95131'
+            zipCode: '95131',
           },
           friends: [
             { name: 'Paul McCartney' },
             { name: 'George Harrison' },
             { name: 'Ringo Starr' },
           ],
-          children: ['Sean', 'Julian']
+          children: ['Sean', 'Julian'],
         },
         {
           seq: 1,
@@ -552,26 +552,26 @@ describe('Memory connector', function() {
             street: '456 B St',
             city: 'San Mateo',
             state: 'CA',
-            zipCode: '94065'
+            zipCode: '94065',
           },
           friends: [
             { name: 'John Lennon' },
             { name: 'George Harrison' },
             { name: 'Ringo Starr' },
           ],
-          children: ['Stella', 'Mary', 'Heather', 'Beatrice', 'James']
+          children: ['Stella', 'Mary', 'Heather', 'Beatrice', 'James'],
         },
-        {seq: 2, name: 'George Harrison', order: 5, vip: false, children: ['Dhani']},
-        {seq: 3, name: 'Ringo Starr', order: 6, vip: false},
-        {seq: 4, name: 'Pete Best', order: 4, children: []},
-        {seq: 5, name: 'Stuart Sutcliffe', order: 3, vip: true}
+        { seq: 2, name: 'George Harrison', order: 5, vip: false, children: ['Dhani'] },
+        { seq: 3, name: 'Ringo Starr', order: 6, vip: false },
+        { seq: 4, name: 'Pete Best', order: 4, children: [] },
+        { seq: 5, name: 'Stuart Sutcliffe', order: 3, vip: true },
       ];
 
       async.series([
         User.destroyAll.bind(User),
         function(cb) {
           async.each(beatles, User.create.bind(User), cb);
-        }
+        },
       ], done);
     }
 
@@ -579,20 +579,20 @@ describe('Memory connector', function() {
 
   it('should use collection setting', function(done) {
     var ds = new DataSource({
-      connector: 'memory'
+      connector: 'memory',
     });
 
     var Product = ds.createModel('Product', {
-      name: String
+      name: String,
     });
 
     var Tool = ds.createModel('Tool', {
-      name: String
-    }, {memory: {collection: 'Product'}});
+      name: String,
+    }, { memory: { collection: 'Product' }});
 
     var Widget = ds.createModel('Widget', {
-      name: String
-    }, {memory: {collection: 'Product'}});
+      name: String,
+    }, { memory: { collection: 'Product' }});
 
     ds.connector.getCollection('Tool').should.equal('Product');
     ds.connector.getCollection('Widget').should.equal('Product');
@@ -606,7 +606,7 @@ describe('Memory connector', function() {
       },
       function(next) {
         Widget.create({ name: 'Widget A' }, next);
-      }
+      },
     ], function(err) {
       Product.find(function(err, products) {
         should.not.exist(err);
@@ -623,11 +623,11 @@ describe('Memory connector', function() {
     var ds;
     beforeEach(function() {
       ds = new DataSource({
-        connector: 'memory'
+        connector: 'memory',
       });
 
       ds.createModel('m1', {
-        name: String
+        name: String,
       });
     });
 
@@ -642,7 +642,7 @@ describe('Memory connector', function() {
         .then(function(result) {
           done();
         })
-        .catch(function(err){
+        .catch(function(err) {
           done(err);
         });
     });
@@ -658,7 +658,7 @@ describe('Memory connector', function() {
         .then(function(result) {
           done();
         })
-        .catch(function(err){
+        .catch(function(err) {
           done(err);
         });
     });
@@ -674,7 +674,7 @@ describe('Memory connector', function() {
         .then(function(result) {
           done();
         })
-        .catch(function(err){
+        .catch(function(err) {
           done(err);
         });
     });
@@ -688,10 +688,10 @@ describe('Memory connector', function() {
 
     it('automigrate reports errors for models not attached - promise variant', function(done) {
       ds.automigrate(['m1', 'm2'])
-        .then(function(){
+        .then(function() {
           done(new Error('automigrate() should have failed'));
         })
-        .catch(function(err){
+        .catch(function(err) {
           err.should.be.an.instanceOf(Error);
           done();
         });
@@ -702,17 +702,17 @@ describe('Memory connector', function() {
   describe('findOrCreate', function() {
     var ds, Cars;
     before(function() {
-      ds = new DataSource({connector: 'memory'});
+      ds = new DataSource({ connector: 'memory' });
       Cars = ds.define('Cars', {
-        color: String
+        color: String,
       });
     });
 
     it('should create a specific object once and in the subsequent calls it should find it', function(done) {
       var creationNum = 0;
       async.times(100, function(n, next) {
-        var initialData = {color: 'white'};
-        var query = {'where': initialData};
+        var initialData = { color: 'white' };
+        var query = { 'where': initialData };
         Cars.findOrCreate(query, initialData, function(err, car, created) {
           if (created) creationNum++;
           next(err, car);
@@ -735,20 +735,20 @@ describe('Memory connector', function() {
     var ds;
     beforeEach(function() {
       ds = new DataSource({
-        connector: 'memory'
+        connector: 'memory',
       });
     });
 
     it('automigrate does NOT report error when NO models are attached', function(done) {
       ds.automigrate(function(err) {
         done();
-      })
+      });
     });
 
     it('automigrate does NOT report error when NO models are attached - promise variant', function(done) {
       ds.automigrate()
         .then(done)
-        .catch(function(err){
+        .catch(function(err) {
           done(err);
         });
     });
@@ -758,7 +758,7 @@ describe('Memory connector', function() {
     var ds, model;
     beforeEach(function() {
       ds = new DataSource({
-        connector: 'memory'
+        connector: 'memory',
       });
 
       ds.connector.autoupdate = function(models, cb) {
@@ -766,19 +766,19 @@ describe('Memory connector', function() {
       };
 
       model = ds.createModel('m1', {
-        name: String
+        name: String,
       });
 
       ds.automigrate();
 
       ds.createModel('m1', {
         name: String,
-        address: String
+        address: String,
       });
     });
 
     it('autoupdates all models', function(done) {
-      ds.autoupdate(function(err, result){
+      ds.autoupdate(function(err, result) {
         done(err);
       });
     });
@@ -786,9 +786,9 @@ describe('Memory connector', function() {
     it('autoupdates all models - promise variant', function(done) {
       ds.autoupdate()
         .then(function(result) {
-            done();
-          })
-        .catch(function(err){
+          done();
+        })
+        .catch(function(err) {
           done(err);
         });
     });
@@ -804,7 +804,7 @@ describe('Memory connector', function() {
         .then(function(result) {
           done();
         })
-        .catch(function(err){
+        .catch(function(err) {
           done(err);
         });
     });
@@ -820,7 +820,7 @@ describe('Memory connector', function() {
         .then(function(result) {
           done();
         })
-        .catch(function(err){
+        .catch(function(err) {
           done(err);
         });
     });
@@ -834,10 +834,10 @@ describe('Memory connector', function() {
 
     it('autoupdate reports errors for models not attached - promise variant', function(done) {
       ds.autoupdate(['m1', 'm2'])
-        .then(function(){
+        .then(function() {
           done(new Error('automigrate() should have failed'));
         })
-        .catch(function(err){
+        .catch(function(err) {
           err.should.be.an.instanceOf(Error);
           done();
         });
@@ -849,16 +849,16 @@ describe('Optimized connector', function() {
   var ds = new DataSource({ connector: Memory });
 
   // optimized methods
-  ds.connector.findOrCreate = function (model, query, data, callback) {
-    this.all(model, query, {}, function (err, list) {
+  ds.connector.findOrCreate = function(model, query, data, callback) {
+    this.all(model, query, {}, function(err, list) {
       if (err || (list && list[0])) return callback(err, list && list[0], false);
-      this.create(model, data, {}, function (err) {
+      this.create(model, data, {}, function(err) {
         callback(err, data, true);
       });
     }.bind(this));
   };
 
-  require('./persistence-hooks.suite')(ds, should, {replaceOrCreateReportsNewInstance: true});
+  require('./persistence-hooks.suite')(ds, should, { replaceOrCreateReportsNewInstance: true });
 });
 
 describe('Unoptimized connector', function() {
@@ -867,14 +867,14 @@ describe('Unoptimized connector', function() {
   ds.connector.updateOrCreate = false;
   ds.connector.findOrCreate = false;
 
-  require('./persistence-hooks.suite')(ds, should, {replaceOrCreateReportsNewInstance: true});
+  require('./persistence-hooks.suite')(ds, should, { replaceOrCreateReportsNewInstance: true });
 });
 
 describe('Memory connector with options', function() {
   var ds, savedOptions = {}, Post;
 
   before(function() {
-    ds = new DataSource({connector: 'memory'});
+    ds = new DataSource({ connector: 'memory' });
     ds.connector.create = function(model, data, options, cb) {
       savedOptions.create = options;
       process.nextTick(function() {
@@ -885,33 +885,33 @@ describe('Memory connector with options', function() {
     ds.connector.update = function(model, where, data, options, cb) {
       savedOptions.update = options;
       process.nextTick(function() {
-        cb(null, {count: 1});
+        cb(null, { count: 1 });
       });
     };
 
     ds.connector.all = function(model, filter, options, cb) {
       savedOptions.find = options;
       process.nextTick(function() {
-        cb(null, [{title: 't1', content: 'c1'}]);
+        cb(null, [{ title: 't1', content: 'c1' }]);
       });
     };
 
     Post = ds.define('Post', {
       title: String,
-      content: String
+      content: String,
     });
   });
 
   it('should receive options from the find method', function(done) {
-    var opts = {transaction: 'tx1'};
-    Post.find({where: {title: 't1'}}, opts, function(err, p) {
+    var opts = { transaction: 'tx1' };
+    Post.find({ where: { title: 't1' }}, opts, function(err, p) {
       savedOptions.find.should.be.eql(opts);
       done(err);
     });
   });
 
   it('should receive options from the find method', function(done) {
-    var opts = {transaction: 'tx2'};
+    var opts = { transaction: 'tx2' };
     Post.find({}, opts, function(err, p) {
       savedOptions.find.should.be.eql(opts);
       done(err);
@@ -919,7 +919,7 @@ describe('Memory connector with options', function() {
   });
 
   it('should treat first object arg as filter for find', function(done) {
-    var filter = {title: 't1'};
+    var filter = { title: 't1' };
     Post.find(filter, function(err, p) {
       savedOptions.find.should.be.eql({});
       done(err);
@@ -927,16 +927,16 @@ describe('Memory connector with options', function() {
   });
 
   it('should receive options from the create method', function(done) {
-    var opts = {transaction: 'tx3'};
-    Post.create({title: 't1', content: 'c1'}, opts, function(err, p) {
+    var opts = { transaction: 'tx3' };
+    Post.create({ title: 't1', content: 'c1' }, opts, function(err, p) {
       savedOptions.create.should.be.eql(opts);
       done(err);
     });
   });
 
   it('should receive options from the update method', function(done) {
-    var opts = {transaction: 'tx4'};
-    Post.update({title: 't1'}, {content: 'c1 --> c2'},
+    var opts = { transaction: 'tx4' };
+    Post.update({ title: 't1' }, { content: 'c1 --> c2' },
       opts, function(err, p) {
         savedOptions.update.should.be.eql(opts);
         done(err);
@@ -947,7 +947,7 @@ describe('Memory connector with options', function() {
 
 describe('Memory connector with observers', function() {
   var ds = new DataSource({
-    connector: 'memory'
+    connector: 'memory',
   });
 
   it('should have observer mixed into the connector', function() {
@@ -959,7 +959,7 @@ describe('Memory connector with observers', function() {
     var events = [];
     ds.connector.execute = function(command, params, options, cb) {
       var self = this;
-      var context = {command: command, params: params, options: options};
+      var context = { command: command, params: params, options: options };
       self.notifyObserversOf('before execute', context, function(err) {
         process.nextTick(function() {
           if (err) return cb(err);
@@ -981,7 +981,7 @@ describe('Memory connector with observers', function() {
       next();
     });
 
-    ds.connector.execute('test', [1, 2], {x: 2}, function(err) {
+    ds.connector.execute('test', [1, 2], { x: 2 }, function(err) {
       if (err) return done(err);
       events.should.eql(['before execute', 'execute', 'after execute']);
       done();
diff --git a/test/mixins.test.js b/test/mixins.test.js
index a7b40607..d72e8ad7 100644
--- a/test/mixins.test.js
+++ b/test/mixins.test.js
@@ -45,7 +45,7 @@ function timestamps(Model, options) {
 
 mixins.define('TimeStamp', timestamps);
 
-describe('Model class', function () {
+describe('Model class', function() {
 
   it('should define mixins', function() {
     mixins.define('Example', function(Model, options) {
@@ -65,12 +65,12 @@ describe('Model class', function () {
   it('should apply a mixin class', function() {
     var Address = modelBuilder.define('Address', {
       street: { type: 'string', required: true },
-      city: { type: 'string', required: true }
+      city: { type: 'string', required: true },
     });
 
-    var memory = new DataSource('mem', {connector: Memory}, modelBuilder);
+    var memory = new DataSource('mem', { connector: Memory }, modelBuilder);
     var Item = memory.createModel('Item', { name: 'string' }, {
-      mixins: { Address: true }
+      mixins: { Address: true },
     });
 
     var properties = Item.definition.properties;
@@ -80,15 +80,15 @@ describe('Model class', function () {
   });
 
   it('should apply mixins', function(done) {
-    var memory = new DataSource('mem', {connector: Memory}, modelBuilder);
+    var memory = new DataSource('mem', { connector: Memory }, modelBuilder);
     var Item = memory.createModel('Item', { name: 'string' }, {
       mixins: {
         TimeStamp: true, Demo: { value: true },
         Multi: [
           { key: 'foo', value: 'bar' },
-          { key: 'fox', value: 'baz' }
-        ]
-      }
+          { key: 'fox', value: 'baz' },
+        ],
+      },
     });
 
     Item.mixin('Example', { foo: 'bar' });
@@ -110,31 +110,31 @@ describe('Model class', function () {
     });
   });
 
-  describe('#mixin()', function () {
+  describe('#mixin()', function() {
 
     var Person, Author, Address;
 
-    beforeEach(function () {
+    beforeEach(function() {
       Address = modelBuilder.define('Address', {
         street: { type: 'string', required: true },
-        city: { type: 'string', required: true }
+        city: { type: 'string', required: true },
       });
-      var memory = new DataSource('mem', {connector: Memory}, modelBuilder);
+      var memory = new DataSource('mem', { connector: Memory }, modelBuilder);
       Person = memory.createModel('Person', { name: 'string' });
       Author = memory.createModel('Author', { name: 'string' });
     });
 
-    it('should register mixin class into _mixins', function () {
+    it('should register mixin class into _mixins', function() {
       Person.mixin(Address);
       Person._mixins.should.containEql(Address);
     });
 
-    it('should NOT share mixins registry', function () {
+    it('should NOT share mixins registry', function() {
       Person.mixin(Address);
       Author._mixins.should.not.containEql(Address);
     });
 
-    it('should able to mixin same class', function () {
+    it('should able to mixin same class', function() {
       Person.mixin(Address);
       Author.mixin(Address);
       Author._mixins.should.containEql(Address);
diff --git a/test/model-definition.test.js b/test/model-definition.test.js
index ed871f44..65a87d11 100644
--- a/test/model-definition.test.js
+++ b/test/model-definition.test.js
@@ -14,21 +14,21 @@ var Memory = require('../lib/connectors/memory');
 
 var ModelDefinition = require('../lib/model-definition');
 
-describe('ModelDefinition class', function () {
+describe('ModelDefinition class', function() {
   var memory;
   beforeEach(function() {
-    memory = new DataSource({connector: Memory});
+    memory = new DataSource({ connector: Memory });
   });
 
-  it('should be able to define plain models', function (done) {
+  it('should be able to define plain models', function(done) {
     var modelBuilder = new ModelBuilder();
 
     var User = new ModelDefinition(modelBuilder, 'User', {
-      name: "string",
+      name: 'string',
       bio: ModelBuilder.Text,
       approved: Boolean,
       joinedAt: Date,
-      age: "number"
+      age: 'number',
     });
 
     User.build();
@@ -39,12 +39,12 @@ describe('ModelDefinition class', function () {
     assert.equal(User.properties.age.type, Number);
 
     var json = User.toJSON();
-    assert.equal(json.name, "User");
-    assert.equal(json.properties.name.type, "String");
-    assert.equal(json.properties.bio.type, "Text");
-    assert.equal(json.properties.approved.type, "Boolean");
-    assert.equal(json.properties.joinedAt.type, "Date");
-    assert.equal(json.properties.age.type, "Number");
+    assert.equal(json.name, 'User');
+    assert.equal(json.properties.name.type, 'String');
+    assert.equal(json.properties.bio.type, 'Text');
+    assert.equal(json.properties.approved.type, 'Boolean');
+    assert.equal(json.properties.joinedAt.type, 'Date');
+    assert.equal(json.properties.age.type, 'Number');
 
     assert.deepEqual(User.toJSON(), json);
 
@@ -52,22 +52,22 @@ describe('ModelDefinition class', function () {
 
   });
 
-  it('should be able to define additional properties', function (done) {
+  it('should be able to define additional properties', function(done) {
     var modelBuilder = new ModelBuilder();
 
     var User = new ModelDefinition(modelBuilder, 'User', {
-      name: "string",
+      name: 'string',
       bio: ModelBuilder.Text,
       approved: Boolean,
       joinedAt: Date,
-      age: "number"
+      age: 'number',
     });
 
     User.build();
 
     var json = User.toJSON();
 
-    User.defineProperty("id", {type: "number", id: true});
+    User.defineProperty('id', { type: 'number', id: true });
     assert.equal(User.properties.name.type, String);
     assert.equal(User.properties.bio.type, ModelBuilder.Text);
     assert.equal(User.properties.approved.type, Boolean);
@@ -77,13 +77,13 @@ describe('ModelDefinition class', function () {
     assert.equal(User.properties.id.type, Number);
 
     json = User.toJSON();
-    assert.deepEqual(json.properties.id, {type: 'Number', id: true});
+    assert.deepEqual(json.properties.id, { type: 'Number', id: true });
 
     done();
 
   });
 
-  it('should be able to define nesting models', function (done) {
+  it('should be able to define nesting models', function(done) {
     var modelBuilder = new ModelBuilder();
 
     var User = new ModelDefinition(modelBuilder, 'User', {
@@ -96,8 +96,8 @@ describe('ModelDefinition class', function () {
         street: String,
         city: String,
         zipCode: String,
-        state: String
-      }
+        state: String,
+      },
     });
 
     User.build();
@@ -109,30 +109,30 @@ describe('ModelDefinition class', function () {
     assert.equal(typeof User.properties.address.type, 'function');
 
     var json = User.toJSON();
-    assert.equal(json.name, "User");
-    assert.equal(json.properties.name.type, "String");
-    assert.equal(json.properties.bio.type, "Text");
-    assert.equal(json.properties.approved.type, "Boolean");
-    assert.equal(json.properties.joinedAt.type, "Date");
-    assert.equal(json.properties.age.type, "Number");
+    assert.equal(json.name, 'User');
+    assert.equal(json.properties.name.type, 'String');
+    assert.equal(json.properties.bio.type, 'Text');
+    assert.equal(json.properties.approved.type, 'Boolean');
+    assert.equal(json.properties.joinedAt.type, 'Date');
+    assert.equal(json.properties.age.type, 'Number');
 
     assert.deepEqual(json.properties.address.type, { street: { type: 'String' },
       city: { type: 'String' },
       zipCode: { type: 'String' },
-      state: { type: 'String' } });
+      state: { type: 'String' }});
 
     done();
 
   });
 
-  it('should be able to define referencing models', function (done) {
+  it('should be able to define referencing models', function(done) {
     var modelBuilder = new ModelBuilder();
 
     var Address = modelBuilder.define('Address', {
       street: String,
       city: String,
       zipCode: String,
-      state: String
+      state: String,
     });
     var User = new ModelDefinition(modelBuilder, 'User', {
       name: String,
@@ -140,7 +140,7 @@ describe('ModelDefinition class', function () {
       approved: Boolean,
       joinedAt: Date,
       age: Number,
-      address: Address
+      address: Address,
 
     });
 
@@ -153,12 +153,12 @@ describe('ModelDefinition class', function () {
     assert.equal(User.properties.address.type, Address);
 
     var json = User.toJSON();
-    assert.equal(json.name, "User");
-    assert.equal(json.properties.name.type, "String");
-    assert.equal(json.properties.bio.type, "Text");
-    assert.equal(json.properties.approved.type, "Boolean");
-    assert.equal(json.properties.joinedAt.type, "Date");
-    assert.equal(json.properties.age.type, "Number");
+    assert.equal(json.name, 'User');
+    assert.equal(json.properties.name.type, 'String');
+    assert.equal(json.properties.bio.type, 'Text');
+    assert.equal(json.properties.approved.type, 'Boolean');
+    assert.equal(json.properties.joinedAt.type, 'Date');
+    assert.equal(json.properties.age.type, 'Number');
 
     assert.equal(json.properties.address.type, 'Address');
 
@@ -166,14 +166,14 @@ describe('ModelDefinition class', function () {
 
   });
 
-  it('should be able to define referencing models by name', function (done) {
+  it('should be able to define referencing models by name', function(done) {
     var modelBuilder = new ModelBuilder();
 
     var Address = modelBuilder.define('Address', {
       street: String,
       city: String,
       zipCode: String,
-      state: String
+      state: String,
     });
     var User = new ModelDefinition(modelBuilder, 'User', {
       name: String,
@@ -181,7 +181,7 @@ describe('ModelDefinition class', function () {
       approved: Boolean,
       joinedAt: Date,
       age: Number,
-      address: 'Address'
+      address: 'Address',
 
     });
 
@@ -194,12 +194,12 @@ describe('ModelDefinition class', function () {
     assert.equal(User.properties.address.type, Address);
 
     var json = User.toJSON();
-    assert.equal(json.name, "User");
-    assert.equal(json.properties.name.type, "String");
-    assert.equal(json.properties.bio.type, "Text");
-    assert.equal(json.properties.approved.type, "Boolean");
-    assert.equal(json.properties.joinedAt.type, "Date");
-    assert.equal(json.properties.age.type, "Number");
+    assert.equal(json.name, 'User');
+    assert.equal(json.properties.name.type, 'String');
+    assert.equal(json.properties.bio.type, 'Text');
+    assert.equal(json.properties.approved.type, 'Boolean');
+    assert.equal(json.properties.joinedAt.type, 'Date');
+    assert.equal(json.properties.age.type, 'Number');
 
     assert.equal(json.properties.address.type, 'Address');
 
@@ -207,16 +207,16 @@ describe('ModelDefinition class', function () {
 
   });
 
-  it('should report correct id names', function (done) {
+  it('should report correct id names', function(done) {
     var modelBuilder = new ModelBuilder();
 
     var User = new ModelDefinition(modelBuilder, 'User', {
-      userId: {type: String, id: true},
-      name: "string",
+      userId: { type: String, id: true },
+      name: 'string',
       bio: ModelBuilder.Text,
       approved: Boolean,
       joinedAt: Date,
-      age: "number"
+      age: 'number',
     });
 
     assert.equal(User.idName(), 'userId');
@@ -224,17 +224,17 @@ describe('ModelDefinition class', function () {
     done();
   });
 
-  it('should sort id properties by its index', function () {
+  it('should sort id properties by its index', function() {
     var modelBuilder = new ModelBuilder();
 
     var User = new ModelDefinition(modelBuilder, 'User', {
-      userId: {type: String, id: 2},
-      userType: {type: String, id: 1},
-      name: "string",
+      userId: { type: String, id: 2 },
+      userType: { type: String, id: 1 },
+      name: 'string',
       bio: ModelBuilder.Text,
       approved: Boolean,
       joinedAt: Date,
-      age: "number"
+      age: 'number',
     });
 
     var ids = User.ids();
@@ -246,13 +246,13 @@ describe('ModelDefinition class', function () {
     assert.equal(ids[1].name, 'userId');
   });
 
-  it('should report correct table/column names', function (done) {
+  it('should report correct table/column names', function(done) {
     var modelBuilder = new ModelBuilder();
 
     var User = new ModelDefinition(modelBuilder, 'User', {
-      userId: {type: String, id: true, oracle: {column: 'ID'}},
-      name: "string"
-    }, {oracle: {table: 'USER'}});
+      userId: { type: String, id: true, oracle: { column: 'ID' }},
+      name: 'string',
+    }, { oracle: { table: 'USER' }});
 
     assert.equal(User.tableName('oracle'), 'USER');
     assert.equal(User.tableName('mysql'), 'User');
@@ -261,15 +261,15 @@ describe('ModelDefinition class', function () {
     done();
   });
 
-  it('should inherit prototype using option.base', function () {
+  it('should inherit prototype using option.base', function() {
     var modelBuilder = memory.modelBuilder;
     var parent = memory.createModel('parent', {}, {
       relations: {
         children: {
           type: 'hasMany',
-          model: 'anotherChild'
-        }
-      }
+          model: 'anotherChild',
+        },
+      },
     });
     var baseChild = modelBuilder.define('baseChild');
     baseChild.attachTo(memory);
@@ -301,30 +301,30 @@ describe('ModelDefinition class', function () {
   it('should serialize protected properties into JSON', function() {
     var modelBuilder = memory.modelBuilder;
     var ProtectedModel = memory.createModel('protected', {}, {
-      protected: ['protectedProperty']
+      protected: ['protectedProperty'],
     });
     var pm = new ProtectedModel({
-      id: 1, foo: 'bar', protectedProperty: 'protected'
+      id: 1, foo: 'bar', protectedProperty: 'protected',
     });
     var serialized = pm.toJSON();
     assert.deepEqual(serialized, {
-      id: 1, foo: 'bar', protectedProperty: 'protected'
+      id: 1, foo: 'bar', protectedProperty: 'protected',
     });
   });
 
-  it('should not serialize protected properties of nested models into JSON', function(done){
+  it('should not serialize protected properties of nested models into JSON', function(done) {
     var modelBuilder = memory.modelBuilder;
     var Parent = memory.createModel('parent');
-    var Child = memory.createModel('child', {}, {protected: ['protectedProperty']});
+    var Child = memory.createModel('child', {}, { protected: ['protectedProperty'] });
     Parent.hasMany(Child);
     Parent.create({
-      name: 'parent'
+      name: 'parent',
     }, function(err, parent) {
       parent.children.create({
         name: 'child',
-        protectedProperty: 'protectedValue'
+        protectedProperty: 'protectedValue',
       }, function(err, child) {
-        Parent.find({include: 'children'}, function(err, parents) {
+        Parent.find({ include: 'children' }, function(err, parents) {
           var serialized = parents[0].toJSON();
           var child = serialized.children[0];
           assert.equal(child.name, 'child');
@@ -335,36 +335,36 @@ describe('ModelDefinition class', function () {
     });
   });
 
-  it('should not serialize hidden properties into JSON', function () {
+  it('should not serialize hidden properties into JSON', function() {
     var modelBuilder = memory.modelBuilder;
     var HiddenModel = memory.createModel('hidden', {}, {
-      hidden: ['secret']
+      hidden: ['secret'],
     });
     var hm = new HiddenModel({
       id: 1,
       foo: 'bar',
-      secret: 'secret'
+      secret: 'secret',
     });
     var serialized = hm.toJSON();
     assert.deepEqual(serialized, {
       id: 1,
-      foo: 'bar'
+      foo: 'bar',
     });
   });
 
-  it('should not serialize hidden properties of nested models into JSON', function (done) {
+  it('should not serialize hidden properties of nested models into JSON', function(done) {
     var modelBuilder = memory.modelBuilder;
     var Parent = memory.createModel('parent');
-    var Child = memory.createModel('child', {}, {hidden: ['secret']});
+    var Child = memory.createModel('child', {}, { hidden: ['secret'] });
     Parent.hasMany(Child);
     Parent.create({
-      name: 'parent'
+      name: 'parent',
     }, function(err, parent) {
       parent.children.create({
         name: 'child',
-        secret: 'secret'
+        secret: 'secret',
       }, function(err, child) {
-        Parent.find({include: 'children'}, function(err, parents) {
+        Parent.find({ include: 'children' }, function(err, parents) {
           var serialized = parents[0].toJSON();
           var child = serialized.children[0];
           assert.equal(child.name, 'child');
@@ -399,7 +399,7 @@ describe('ModelDefinition class', function () {
   it('should support "array" type shortcut', function() {
     var Model = memory.createModel('TwoArrays', {
       regular: Array,
-      sugar: 'array'
+      sugar: 'array',
     });
 
     var props = Model.definition.properties;
@@ -411,11 +411,11 @@ describe('ModelDefinition class', function () {
       var Todo;
       before(function prepModel() {
         Todo = new ModelDefinition(new ModelBuilder(), 'Todo', {
-          content: 'string'
+          content: 'string',
         });
         Todo.defineProperty('id', {
           type: 'number',
-          id: true
+          id: true,
         });
         Todo.build();
       });
@@ -429,7 +429,7 @@ describe('ModelDefinition class', function () {
       var Todo;
       before(function prepModel() {
         Todo = new ModelDefinition(new ModelBuilder(), 'Todo', {
-          content: 'string'
+          content: 'string',
         });
         Todo.build();
       });
diff --git a/test/optional-validation.test.js b/test/optional-validation.test.js
index e0d11d7a..e898f56d 100644
--- a/test/optional-validation.test.js
+++ b/test/optional-validation.test.js
@@ -12,31 +12,31 @@ var ValidationError = j.ValidationError;
 
 var INITIAL_NAME = 'Bert';
 var NEW_NAME = 'Ernie';
-var INVALID_DATA = {name: null};
-var VALID_DATA = {name: INITIAL_NAME};
+var INVALID_DATA = { name: null };
+var VALID_DATA = { name: INITIAL_NAME };
 
-describe('optional-validation', function () {
+describe('optional-validation', function() {
 
-  before(function (done) {
+  before(function(done) {
     db = getSchema();
     ModelWithForceId = db.createModel(
     'ModelWithForceId',
     { name: String },
     { forceId: true });
     User = db.define('User', {
-      seq: {type: Number, index: true},
-      name: {type: String, index: true, sort: true},
-      email: {type: String, index: true},
-      birthday: {type: Date, index: true},
-      role: {type: String, index: true},
-      order: {type: Number, index: true, sort: true},
-      vip: {type: Boolean}
+      seq: { type: Number, index: true },
+      name: { type: String, index: true, sort: true },
+      email: { type: String, index: true },
+      birthday: { type: Date, index: true },
+      role: { type: String, index: true },
+      order: { type: Number, index: true, sort: true },
+      vip: { type: Boolean },
     }, { forceId: true, strict: true });
     db.automigrate(['ModelWithForceId', 'User'], done);
   });
 
-  beforeEach(function (done) {
-    User.destroyAll(function () {
+  beforeEach(function(done) {
+    User.destroyAll(function() {
       delete User.validations;
       User.validatesPresenceOf('name');
       done();
@@ -44,7 +44,7 @@ describe('optional-validation', function () {
   });
 
   function expectValidationError(done) {
-    return function (err, result) {
+    return function(err, result) {
       should.exist(err);
       err.should.be.instanceOf(Error);
       err.should.be.instanceOf(ValidationError);
@@ -87,27 +87,27 @@ describe('optional-validation', function () {
   }
 
   function createUserAndChangeName(name, cb) {
-    User.create(VALID_DATA, {validate: true}, function (err, d) {
+    User.create(VALID_DATA, { validate: true }, function(err, d) {
       d.name = name;
       cb(err, d);
     });
   }
 
   function createUser(cb) {
-    User.create(VALID_DATA, {validate: true}, cb);
+    User.create(VALID_DATA, { validate: true }, cb);
   }
 
-  function callUpdateOrCreateWithExistingUserId(name, options, cb){
-    User.create({'name': 'Groover'}, function(err, user){
+  function callUpdateOrCreateWithExistingUserId(name, options, cb) {
+    User.create({ 'name': 'Groover' }, function(err, user) {
       if (err) return cb(err);
-      var data = {name: name};
+      var data = { name: name };
       data.id = user.id;
       User.updateOrCreate(data, options, cb);
     });
   }
 
   function getNewWhere() {
-    return {name: 'DoesNotExist' + (whereCount++)};
+    return { name: 'DoesNotExist' + (whereCount++) };
   }
 
   describe('forceId', function() {
@@ -136,284 +136,283 @@ describe('optional-validation', function () {
     });
   });
 
-
   describe('no model setting', function() {
 
     describe('method create', function() {
-      it('should throw on create with validate:true with invalid data', function (done) {
-        User.create(INVALID_DATA, {validate: true}, expectValidationError(done));
+      it('should throw on create with validate:true with invalid data', function(done) {
+        User.create(INVALID_DATA, { validate: true }, expectValidationError(done));
       });
 
-      it('should NOT throw on create with validate:false with invalid data', function (done) {
-        User.create(INVALID_DATA, {validate: false}, expectCreateSuccess(INVALID_DATA, done));
+      it('should NOT throw on create with validate:false with invalid data', function(done) {
+        User.create(INVALID_DATA, { validate: false }, expectCreateSuccess(INVALID_DATA, done));
       });
 
-      it('should NOT throw on create with validate:true with valid data', function (done) {
-        User.create(VALID_DATA, {validate: true}, expectCreateSuccess(done));
+      it('should NOT throw on create with validate:true with valid data', function(done) {
+        User.create(VALID_DATA, { validate: true }, expectCreateSuccess(done));
       });
 
-      it('should NOT throw on create with validate:false with valid data', function (done) {
-        User.create(VALID_DATA, {validate: false}, expectCreateSuccess(done));
+      it('should NOT throw on create with validate:false with valid data', function(done) {
+        User.create(VALID_DATA, { validate: false }, expectCreateSuccess(done));
       });
 
-      it('should throw on create with invalid data', function (done) {
+      it('should throw on create with invalid data', function(done) {
         User.create(INVALID_DATA, expectValidationError(done));
       });
 
-      it('should NOT throw on create with valid data', function (done) {
+      it('should NOT throw on create with valid data', function(done) {
         User.create(VALID_DATA, expectCreateSuccess(done));
       });
     });
 
     describe('method findOrCreate', function() {
-      it('should throw on findOrCreate with validate:true with invalid data', function (done) {
-        User.findOrCreate(getNewWhere(), INVALID_DATA, {validate: true}, expectValidationError(done));
+      it('should throw on findOrCreate with validate:true with invalid data', function(done) {
+        User.findOrCreate(getNewWhere(), INVALID_DATA, { validate: true }, expectValidationError(done));
       });
 
-      it('should NOT throw on findOrCreate with validate:false with invalid data', function (done) {
-        User.findOrCreate(getNewWhere(), INVALID_DATA, {validate: false}, expectCreateSuccess(INVALID_DATA, done));
+      it('should NOT throw on findOrCreate with validate:false with invalid data', function(done) {
+        User.findOrCreate(getNewWhere(), INVALID_DATA, { validate: false }, expectCreateSuccess(INVALID_DATA, done));
       });
 
-      it('should NOT throw on findOrCreate with validate:true with valid data', function (done) {
-        User.findOrCreate(getNewWhere(), VALID_DATA, {validate: true}, expectCreateSuccess(done));
+      it('should NOT throw on findOrCreate with validate:true with valid data', function(done) {
+        User.findOrCreate(getNewWhere(), VALID_DATA, { validate: true }, expectCreateSuccess(done));
       });
 
-      it('should NOT throw on findOrCreate with validate:false with valid data', function (done) {
-        User.findOrCreate(getNewWhere(), VALID_DATA, {validate: false}, expectCreateSuccess(done));
+      it('should NOT throw on findOrCreate with validate:false with valid data', function(done) {
+        User.findOrCreate(getNewWhere(), VALID_DATA, { validate: false }, expectCreateSuccess(done));
       });
 
-      it('should throw on findOrCreate with invalid data', function (done) {
+      it('should throw on findOrCreate with invalid data', function(done) {
         User.findOrCreate(getNewWhere(), INVALID_DATA, expectValidationError(done));
       });
 
-      it('should NOT throw on findOrCreate with valid data', function (done) {
+      it('should NOT throw on findOrCreate with valid data', function(done) {
         User.findOrCreate(getNewWhere(), VALID_DATA, expectCreateSuccess(done));
       });
     });
 
     describe('method updateOrCreate on existing data', function() {
-      it('should throw on updateOrCreate(id) with validate:true with invalid data', function (done) {
-        callUpdateOrCreateWithExistingUserId(null, {validate: true}, expectValidationError(done));
+      it('should throw on updateOrCreate(id) with validate:true with invalid data', function(done) {
+        callUpdateOrCreateWithExistingUserId(null, { validate: true }, expectValidationError(done));
       });
 
-      it('should NOT throw on updateOrCreate(id) with validate:false with invalid data', function (done) {
-        callUpdateOrCreateWithExistingUserId(null, {validate: false}, expectChangeSuccess(INVALID_DATA, done));
+      it('should NOT throw on updateOrCreate(id) with validate:false with invalid data', function(done) {
+        callUpdateOrCreateWithExistingUserId(null, { validate: false }, expectChangeSuccess(INVALID_DATA, done));
       });
 
-      it('should NOT throw on updateOrCreate(id) with validate:true with valid data', function (done) {
-        callUpdateOrCreateWithExistingUserId(NEW_NAME, {validate: true}, expectChangeSuccess(done));
+      it('should NOT throw on updateOrCreate(id) with validate:true with valid data', function(done) {
+        callUpdateOrCreateWithExistingUserId(NEW_NAME, { validate: true }, expectChangeSuccess(done));
       });
 
-      it('should NOT throw on updateOrCreate(id) with validate:false with valid data', function (done) {
-        callUpdateOrCreateWithExistingUserId(NEW_NAME, {validate: false}, expectChangeSuccess(done));
+      it('should NOT throw on updateOrCreate(id) with validate:false with valid data', function(done) {
+        callUpdateOrCreateWithExistingUserId(NEW_NAME, { validate: false }, expectChangeSuccess(done));
       });
 
       // backwards compatible with validateUpsert
-      it('should NOT throw on updateOrCreate(id) with invalid data', function (done) {
+      it('should NOT throw on updateOrCreate(id) with invalid data', function(done) {
         callUpdateOrCreateWithExistingUserId(null, expectChangeSuccess(INVALID_DATA, done));
       });
 
-      it('should NOT throw on updateOrCreate(id) with valid data', function (done) {
+      it('should NOT throw on updateOrCreate(id) with valid data', function(done) {
         callUpdateOrCreateWithExistingUserId(NEW_NAME, expectChangeSuccess(done));
       });
     });
 
     describe('method save', function() {
-      it('should throw on save with {validate:true} with invalid data', function (done) {
-        createUserAndChangeName(null, function (err, d) {
-          d.save({validate: true}, expectValidationError(done));
+      it('should throw on save with {validate:true} with invalid data', function(done) {
+        createUserAndChangeName(null, function(err, d) {
+          d.save({ validate: true }, expectValidationError(done));
         });
       });
 
-      it('should NOT throw on save with {validate:false} with invalid data', function (done) {
-        createUserAndChangeName(null, function (err, d) {
-          d.save({validate: false}, expectChangeSuccess(INVALID_DATA, done));
+      it('should NOT throw on save with {validate:false} with invalid data', function(done) {
+        createUserAndChangeName(null, function(err, d) {
+          d.save({ validate: false }, expectChangeSuccess(INVALID_DATA, done));
         });
       });
 
-      it('should NOT throw on save with {validate:true} with valid data', function (done) {
-        createUserAndChangeName(NEW_NAME, function (err, d) {
-          d.save({validate: true}, expectChangeSuccess(done));
+      it('should NOT throw on save with {validate:true} with valid data', function(done) {
+        createUserAndChangeName(NEW_NAME, function(err, d) {
+          d.save({ validate: true }, expectChangeSuccess(done));
         });
       });
 
-      it('should NOT throw on save with {validate:false} with valid data', function (done) {
-        createUserAndChangeName(NEW_NAME, function (err, d) {
-          d.save({validate: false}, expectChangeSuccess(done));
+      it('should NOT throw on save with {validate:false} with valid data', function(done) {
+        createUserAndChangeName(NEW_NAME, function(err, d) {
+          d.save({ validate: false }, expectChangeSuccess(done));
         });
       });
 
-      it('should throw on save(cb) with invalid data', function (done) {
-        createUserAndChangeName(null, function (err, d) {
+      it('should throw on save(cb) with invalid data', function(done) {
+        createUserAndChangeName(null, function(err, d) {
           d.save(expectValidationError(done));
         });
       });
 
-      it('should NOT throw on save(cb) with valid data', function (done) {
-        createUserAndChangeName(NEW_NAME, function (err, d) {
+      it('should NOT throw on save(cb) with valid data', function(done) {
+        createUserAndChangeName(NEW_NAME, function(err, d) {
           d.save(expectChangeSuccess(done));
         });
       });
     });
 
     describe('method updateAttributes', function() {
-      it('should throw on updateAttributes with {validate:true} with invalid data', function (done) {
-        createUser(function (err, d) {
-          d.updateAttributes(INVALID_DATA, {validate: true}, expectValidationError(done));
+      it('should throw on updateAttributes with {validate:true} with invalid data', function(done) {
+        createUser(function(err, d) {
+          d.updateAttributes(INVALID_DATA, { validate: true }, expectValidationError(done));
         });
       });
 
-      it('should NOT throw on updateAttributes with {validate:false} with invalid data', function (done) {
-        createUser(function (err, d) {
-          d.updateAttributes(INVALID_DATA, {validate: false}, expectChangeSuccess(INVALID_DATA, done));
+      it('should NOT throw on updateAttributes with {validate:false} with invalid data', function(done) {
+        createUser(function(err, d) {
+          d.updateAttributes(INVALID_DATA, { validate: false }, expectChangeSuccess(INVALID_DATA, done));
         });
       });
 
-      it('should NOT throw on updateAttributes with {validate:true} with valid data', function (done) {
-        createUser(function (err, d) {
-          d.updateAttributes({'name': NEW_NAME}, {validate: true}, expectChangeSuccess(done));
+      it('should NOT throw on updateAttributes with {validate:true} with valid data', function(done) {
+        createUser(function(err, d) {
+          d.updateAttributes({ 'name': NEW_NAME }, { validate: true }, expectChangeSuccess(done));
         });
       });
 
-      it('should NOT throw on updateAttributes with {validate:false} with valid data', function (done) {
-        createUser(function (err, d) {
-          d.updateAttributes({'name': NEW_NAME}, {validate: false}, expectChangeSuccess(done));
+      it('should NOT throw on updateAttributes with {validate:false} with valid data', function(done) {
+        createUser(function(err, d) {
+          d.updateAttributes({ 'name': NEW_NAME }, { validate: false }, expectChangeSuccess(done));
         });
       });
 
-      it('should throw on updateAttributes(cb) with invalid data', function (done) {
-        createUser(function (err, d) {
+      it('should throw on updateAttributes(cb) with invalid data', function(done) {
+        createUser(function(err, d) {
           d.updateAttributes(INVALID_DATA, expectValidationError(done));
         });
       });
 
-      it('should NOT throw on updateAttributes(cb) with valid data', function (done) {
-        createUser(function (err, d) {
-          d.updateAttributes({'name': NEW_NAME}, expectChangeSuccess(done));
+      it('should NOT throw on updateAttributes(cb) with valid data', function(done) {
+        createUser(function(err, d) {
+          d.updateAttributes({ 'name': NEW_NAME }, expectChangeSuccess(done));
         });
       });
     });
 
   });
 
-  describe('model setting: automaticValidation: false', function () {
+  describe('model setting: automaticValidation: false', function() {
 
-    before(function (done) {
+    before(function(done) {
       User.settings.automaticValidation = false;
       done();
     });
 
     describe('method create', function() {
-      it('should throw on create with validate:true with invalid data', function (done) {
-        User.create(INVALID_DATA, {validate: true}, expectValidationError(done));
+      it('should throw on create with validate:true with invalid data', function(done) {
+        User.create(INVALID_DATA, { validate: true }, expectValidationError(done));
       });
 
-      it('should NOT throw on create with validate:false with invalid data', function (done) {
-        User.create(INVALID_DATA, {validate: false}, expectCreateSuccess(INVALID_DATA, done));
+      it('should NOT throw on create with validate:false with invalid data', function(done) {
+        User.create(INVALID_DATA, { validate: false }, expectCreateSuccess(INVALID_DATA, done));
       });
 
-      it('should NOT throw on create with validate:true with valid data', function (done) {
-        User.create(VALID_DATA, {validate: true}, expectCreateSuccess(done));
+      it('should NOT throw on create with validate:true with valid data', function(done) {
+        User.create(VALID_DATA, { validate: true }, expectCreateSuccess(done));
       });
 
-      it('should NOT throw on create with validate:false with valid data', function (done) {
-        User.create(VALID_DATA, {validate: false}, expectCreateSuccess(done));
+      it('should NOT throw on create with validate:false with valid data', function(done) {
+        User.create(VALID_DATA, { validate: false }, expectCreateSuccess(done));
       });
 
-      it('should NOT throw on create with invalid data', function (done) {
+      it('should NOT throw on create with invalid data', function(done) {
         User.create(INVALID_DATA, expectCreateSuccess(INVALID_DATA, done));
       });
 
-      it('should NOT throw on create with valid data', function (done) {
+      it('should NOT throw on create with valid data', function(done) {
         User.create(VALID_DATA, expectCreateSuccess(done));
       });
     });
 
     describe('method findOrCreate', function() {
-      it('should throw on findOrCreate with validate:true with invalid data', function (done) {
-        User.findOrCreate(getNewWhere(), INVALID_DATA, {validate: true}, expectValidationError(done));
+      it('should throw on findOrCreate with validate:true with invalid data', function(done) {
+        User.findOrCreate(getNewWhere(), INVALID_DATA, { validate: true }, expectValidationError(done));
       });
 
-      it('should NOT throw on findOrCreate with validate:false with invalid data', function (done) {
-        User.findOrCreate(getNewWhere(), INVALID_DATA, {validate: false}, expectCreateSuccess(INVALID_DATA, done));
+      it('should NOT throw on findOrCreate with validate:false with invalid data', function(done) {
+        User.findOrCreate(getNewWhere(), INVALID_DATA, { validate: false }, expectCreateSuccess(INVALID_DATA, done));
       });
 
-      it('should NOT throw on findOrCreate with validate:true with valid data', function (done) {
-        User.findOrCreate(getNewWhere(), VALID_DATA, {validate: true}, expectCreateSuccess(done));
+      it('should NOT throw on findOrCreate with validate:true with valid data', function(done) {
+        User.findOrCreate(getNewWhere(), VALID_DATA, { validate: true }, expectCreateSuccess(done));
       });
 
-      it('should NOT throw on findOrCreate with validate:false with valid data', function (done) {
-        User.findOrCreate(getNewWhere(), VALID_DATA, {validate: false}, expectCreateSuccess(done));
+      it('should NOT throw on findOrCreate with validate:false with valid data', function(done) {
+        User.findOrCreate(getNewWhere(), VALID_DATA, { validate: false }, expectCreateSuccess(done));
       });
 
-      it('should NOT throw on findOrCreate with invalid data', function (done) {
+      it('should NOT throw on findOrCreate with invalid data', function(done) {
         User.findOrCreate(getNewWhere(), INVALID_DATA, expectCreateSuccess(INVALID_DATA, done));
       });
 
-      it('should NOT throw on findOrCreate with valid data', function (done) {
+      it('should NOT throw on findOrCreate with valid data', function(done) {
         User.findOrCreate(getNewWhere(), VALID_DATA, expectCreateSuccess(done));
       });
     });
 
     describe('method updateOrCreate on existing data', function() {
-      it('should throw on updateOrCreate(id) with validate:true with invalid data', function (done) {
-        callUpdateOrCreateWithExistingUserId(null, {validate: true}, expectValidationError(done));
+      it('should throw on updateOrCreate(id) with validate:true with invalid data', function(done) {
+        callUpdateOrCreateWithExistingUserId(null, { validate: true }, expectValidationError(done));
       });
 
-      it('should NOT throw on updateOrCreate(id) with validate:false with invalid data', function (done) {
-        callUpdateOrCreateWithExistingUserId(null, {validate: false}, expectChangeSuccess(INVALID_DATA, done));
+      it('should NOT throw on updateOrCreate(id) with validate:false with invalid data', function(done) {
+        callUpdateOrCreateWithExistingUserId(null, { validate: false }, expectChangeSuccess(INVALID_DATA, done));
       });
 
-      it('should NOT throw on updateOrCreate(id) with validate:true with valid data', function (done) {
-        callUpdateOrCreateWithExistingUserId(NEW_NAME, {validate: true}, expectChangeSuccess(done));
+      it('should NOT throw on updateOrCreate(id) with validate:true with valid data', function(done) {
+        callUpdateOrCreateWithExistingUserId(NEW_NAME, { validate: true }, expectChangeSuccess(done));
       });
 
-      it('should NOT throw on updateOrCreate(id) with validate:false with valid data', function (done) {
-        callUpdateOrCreateWithExistingUserId(NEW_NAME, {validate: false}, expectChangeSuccess(done));
+      it('should NOT throw on updateOrCreate(id) with validate:false with valid data', function(done) {
+        callUpdateOrCreateWithExistingUserId(NEW_NAME, { validate: false }, expectChangeSuccess(done));
       });
 
-      it('should NOT throw on updateOrCreate(id) with invalid data', function (done) {
+      it('should NOT throw on updateOrCreate(id) with invalid data', function(done) {
         callUpdateOrCreateWithExistingUserId(null, expectChangeSuccess(INVALID_DATA, done));
       });
 
-      it('should NOT throw on updateOrCreate(id) with valid data', function (done) {
+      it('should NOT throw on updateOrCreate(id) with valid data', function(done) {
         callUpdateOrCreateWithExistingUserId(NEW_NAME, expectChangeSuccess(done));
       });
     });
 
     describe('method save', function() {
-      it('should throw on save with {validate:true} with invalid data', function (done) {
-        createUserAndChangeName(null, function (err, d) {
-          d.save({validate: true}, expectValidationError(done));
+      it('should throw on save with {validate:true} with invalid data', function(done) {
+        createUserAndChangeName(null, function(err, d) {
+          d.save({ validate: true }, expectValidationError(done));
         });
       });
 
-      it('should NOT throw on save with {validate:false} with invalid data', function (done) {
-        createUserAndChangeName(null, function (err, d) {
-          d.save({validate: false}, expectChangeSuccess(INVALID_DATA, done));
+      it('should NOT throw on save with {validate:false} with invalid data', function(done) {
+        createUserAndChangeName(null, function(err, d) {
+          d.save({ validate: false }, expectChangeSuccess(INVALID_DATA, done));
         });
       });
 
-      it('should NOT throw on save with {validate:true} with valid data', function (done) {
-        createUserAndChangeName(NEW_NAME, function (err, d) {
-          d.save({validate: true}, expectChangeSuccess(done));
+      it('should NOT throw on save with {validate:true} with valid data', function(done) {
+        createUserAndChangeName(NEW_NAME, function(err, d) {
+          d.save({ validate: true }, expectChangeSuccess(done));
         });
       });
 
-      it('should NOT throw on save with {validate:false} with valid data', function (done) {
-        createUserAndChangeName(NEW_NAME, function (err, d) {
-          d.save({validate: false}, expectChangeSuccess(done));
+      it('should NOT throw on save with {validate:false} with valid data', function(done) {
+        createUserAndChangeName(NEW_NAME, function(err, d) {
+          d.save({ validate: false }, expectChangeSuccess(done));
         });
       });
 
-      it('should NOT throw on save(cb) with invalid data', function (done) {
-        createUserAndChangeName(null, function (err, d) {
+      it('should NOT throw on save(cb) with invalid data', function(done) {
+        createUserAndChangeName(null, function(err, d) {
           d.save(expectChangeSuccess(INVALID_DATA, done));
         });
       });
 
-      it('should NOT throw on save(cb) with valid data', function (done) {
-        createUserAndChangeName(NEW_NAME, function (err, d) {
+      it('should NOT throw on save(cb) with valid data', function(done) {
+        createUserAndChangeName(NEW_NAME, function(err, d) {
           d.save(expectChangeSuccess(done));
         });
       });
@@ -421,124 +420,124 @@ describe('optional-validation', function () {
 
   });
 
-  describe('model setting: automaticValidation: true', function () {
+  describe('model setting: automaticValidation: true', function() {
 
-    before(function (done) {
+    before(function(done) {
       User.settings.automaticValidation = true;
       done();
     });
 
     describe('method create', function() {
-      it('should throw on create with validate:true with invalid data', function (done) {
-        User.create(INVALID_DATA, {validate: true}, expectValidationError(done));
+      it('should throw on create with validate:true with invalid data', function(done) {
+        User.create(INVALID_DATA, { validate: true }, expectValidationError(done));
       });
 
-      it('should NOT throw on create with validate:false with invalid data', function (done) {
-        User.create(INVALID_DATA, {validate: false}, expectCreateSuccess(INVALID_DATA, done));
+      it('should NOT throw on create with validate:false with invalid data', function(done) {
+        User.create(INVALID_DATA, { validate: false }, expectCreateSuccess(INVALID_DATA, done));
       });
 
-      it('should NOT throw on create with validate:true with valid data', function (done) {
-        User.create(VALID_DATA, {validate: true}, expectCreateSuccess(done));
+      it('should NOT throw on create with validate:true with valid data', function(done) {
+        User.create(VALID_DATA, { validate: true }, expectCreateSuccess(done));
       });
 
-      it('should NOT throw on create with validate:false with valid data', function (done) {
-        User.create(VALID_DATA, {validate: false}, expectCreateSuccess(done));
+      it('should NOT throw on create with validate:false with valid data', function(done) {
+        User.create(VALID_DATA, { validate: false }, expectCreateSuccess(done));
       });
 
-      it('should throw on create with invalid data', function (done) {
+      it('should throw on create with invalid data', function(done) {
         User.create(INVALID_DATA, expectValidationError(done));
       });
 
-      it('should NOT throw on create with valid data', function (done) {
+      it('should NOT throw on create with valid data', function(done) {
         User.create(VALID_DATA, expectCreateSuccess(done));
       });
     });
 
     describe('method findOrCreate', function() {
-      it('should throw on findOrCreate with validate:true with invalid data', function (done) {
-        User.findOrCreate(getNewWhere(), INVALID_DATA, {validate: true}, expectValidationError(done));
+      it('should throw on findOrCreate with validate:true with invalid data', function(done) {
+        User.findOrCreate(getNewWhere(), INVALID_DATA, { validate: true }, expectValidationError(done));
       });
 
-      it('should NOT throw on findOrCreate with validate:false with invalid data', function (done) {
-        User.findOrCreate(getNewWhere(), INVALID_DATA, {validate: false}, expectCreateSuccess(INVALID_DATA, done));
+      it('should NOT throw on findOrCreate with validate:false with invalid data', function(done) {
+        User.findOrCreate(getNewWhere(), INVALID_DATA, { validate: false }, expectCreateSuccess(INVALID_DATA, done));
       });
 
-      it('should NOT throw on findOrCreate with validate:true with valid data', function (done) {
-        User.findOrCreate(getNewWhere(), VALID_DATA, {validate: true}, expectCreateSuccess(done));
+      it('should NOT throw on findOrCreate with validate:true with valid data', function(done) {
+        User.findOrCreate(getNewWhere(), VALID_DATA, { validate: true }, expectCreateSuccess(done));
       });
 
-      it('should NOT throw on findOrCreate with validate:false with valid data', function (done) {
-        User.findOrCreate(getNewWhere(), VALID_DATA, {validate: false}, expectCreateSuccess(done));
+      it('should NOT throw on findOrCreate with validate:false with valid data', function(done) {
+        User.findOrCreate(getNewWhere(), VALID_DATA, { validate: false }, expectCreateSuccess(done));
       });
 
-      it('should throw on findOrCreate with invalid data', function (done) {
+      it('should throw on findOrCreate with invalid data', function(done) {
         User.findOrCreate(getNewWhere(), INVALID_DATA, expectValidationError(done));
       });
 
-      it('should NOT throw on findOrCreate with valid data', function (done) {
+      it('should NOT throw on findOrCreate with valid data', function(done) {
         User.findOrCreate(getNewWhere(), VALID_DATA, expectCreateSuccess(done));
       });
     });
 
     describe('method updateOrCreate on existing data', function() {
-      it('should throw on updateOrCreate(id) with validate:true with invalid data', function (done) {
-        callUpdateOrCreateWithExistingUserId(null, {validate: true}, expectValidationError(done));
+      it('should throw on updateOrCreate(id) with validate:true with invalid data', function(done) {
+        callUpdateOrCreateWithExistingUserId(null, { validate: true }, expectValidationError(done));
       });
 
-      it('should NOT throw on updateOrCreate(id) with validate:false with invalid data', function (done) {
-        callUpdateOrCreateWithExistingUserId(null, {validate: false}, expectChangeSuccess(INVALID_DATA, done));
+      it('should NOT throw on updateOrCreate(id) with validate:false with invalid data', function(done) {
+        callUpdateOrCreateWithExistingUserId(null, { validate: false }, expectChangeSuccess(INVALID_DATA, done));
       });
 
-      it('should NOT throw on updateOrCreate(id) with validate:true with valid data', function (done) {
-        callUpdateOrCreateWithExistingUserId(NEW_NAME, {validate: true}, expectChangeSuccess(done));
+      it('should NOT throw on updateOrCreate(id) with validate:true with valid data', function(done) {
+        callUpdateOrCreateWithExistingUserId(NEW_NAME, { validate: true }, expectChangeSuccess(done));
       });
 
-      it('should NOT throw on updateOrCreate(id) with validate:false with valid data', function (done) {
-        callUpdateOrCreateWithExistingUserId(NEW_NAME, {validate: false}, expectChangeSuccess(done));
+      it('should NOT throw on updateOrCreate(id) with validate:false with valid data', function(done) {
+        callUpdateOrCreateWithExistingUserId(NEW_NAME, { validate: false }, expectChangeSuccess(done));
       });
 
-      it('should throw on updateOrCreate(id) with invalid data', function (done) {
+      it('should throw on updateOrCreate(id) with invalid data', function(done) {
         callUpdateOrCreateWithExistingUserId(null, expectValidationError(done));
       });
 
-      it('should NOT throw on updateOrCreate(id) with valid data', function (done) {
+      it('should NOT throw on updateOrCreate(id) with valid data', function(done) {
         callUpdateOrCreateWithExistingUserId(NEW_NAME, expectChangeSuccess(done));
       });
     });
 
     describe('method save', function() {
-      it('should throw on save with {validate:true} with invalid data', function (done) {
-        createUserAndChangeName(null, function (err, d) {
+      it('should throw on save with {validate:true} with invalid data', function(done) {
+        createUserAndChangeName(null, function(err, d) {
           d.save(options, expectValidationError(done));
         });
       });
 
-      it('should NOT throw on save with {validate:false} with invalid data', function (done) {
-        createUserAndChangeName(null, function (err, d) {
-          d.save({validate: false}, expectChangeSuccess(INVALID_DATA, done));
+      it('should NOT throw on save with {validate:false} with invalid data', function(done) {
+        createUserAndChangeName(null, function(err, d) {
+          d.save({ validate: false }, expectChangeSuccess(INVALID_DATA, done));
         });
       });
 
-      it('should NOT throw on save with {validate:true} with valid data', function (done) {
-        createUserAndChangeName(NEW_NAME, function (err, d) {
-          d.save({validate: true}, expectChangeSuccess(done));
+      it('should NOT throw on save with {validate:true} with valid data', function(done) {
+        createUserAndChangeName(NEW_NAME, function(err, d) {
+          d.save({ validate: true }, expectChangeSuccess(done));
         });
       });
 
-      it('should NOT throw on save with {validate:false} with valid data', function (done) {
-        createUserAndChangeName(NEW_NAME, function (err, d) {
-          d.save({validate: false}, expectChangeSuccess(done));
+      it('should NOT throw on save with {validate:false} with valid data', function(done) {
+        createUserAndChangeName(NEW_NAME, function(err, d) {
+          d.save({ validate: false }, expectChangeSuccess(done));
         });
       });
 
-      it('should throw on save(cb) with invalid data', function (done) {
-        createUserAndChangeName(null, function (err, d) {
+      it('should throw on save(cb) with invalid data', function(done) {
+        createUserAndChangeName(null, function(err, d) {
           d.save(expectValidationError(done));
         });
       });
 
-      it('should NOT throw on save(cb) with valid data', function (done) {
-        createUserAndChangeName(NEW_NAME, function (err, d) {
+      it('should NOT throw on save(cb) with valid data', function(done) {
+        createUserAndChangeName(NEW_NAME, function(err, d) {
           d.save(expectChangeSuccess(done));
         });
       });
diff --git a/test/persistence-hooks.suite.js b/test/persistence-hooks.suite.js
index 5c050e85..1ac99211 100644
--- a/test/persistence-hooks.suite.js
+++ b/test/persistence-hooks.suite.js
@@ -36,7 +36,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
         // Set id.generated to false to honor client side values
         id: { type: String, id: true, generated: false, default: uid.next },
         name: { type: String, required: true },
-        extra: { type: String, required: false }
+        extra: { type: String, required: false },
       });
 
       uid.reset();
@@ -73,13 +73,13 @@ module.exports = function(dataSource, should, connectorCapabilities) {
         monitorHookExecution();
 
         TestModel.find(
-          { where: { id: '1' } },
+          { where: { id: '1' }},
           function(err, list) {
             if (err) return done(err);
 
             hookMonitor.names.should.eql([
               'access',
-              'loaded'
+              'loaded',
             ]);
             done();
           });
@@ -88,7 +88,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
       it('triggers `access` hook', function(done) {
         TestModel.observe('access', ctxRecorder.recordAndNext());
 
-        TestModel.find({ where: { id: '1' } }, function(err, list) {
+        TestModel.find({ where: { id: '1' }}, function(err, list) {
           if (err) return done(err);
           ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
             query: { where: { id: '1' }},
@@ -108,7 +108,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
 
       it('applies updates from `access` hook', function(done) {
         TestModel.observe('access', function(ctx, next) {
-          ctx.query = { where: { id: existingInstance.id } };
+          ctx.query = { where: { id: existingInstance.id }};
           next();
         });
 
@@ -133,11 +133,11 @@ module.exports = function(dataSource, should, connectorCapabilities) {
 
       it('applies updates from `access` hook for geo queries', function(done) {
         TestModel.observe('access', function(ctx, next) {
-          ctx.query = { where: { id: existingInstance.id } };
+          ctx.query = { where: { id: existingInstance.id }};
           next();
         });
 
-        TestModel.find({ where: { geo: { near: '10,20' } } }, function(err, list) {
+        TestModel.find({ where: { geo: { near: '10,20' }}}, function(err, list) {
           if (err) return done(err);
           list.map(get('name')).should.eql([existingInstance.name]);
           done();
@@ -150,8 +150,8 @@ module.exports = function(dataSource, should, connectorCapabilities) {
         }));
 
         TestModel.find(
-          {where: {id: 1}},
-          function (err, list) {
+          { where: { id: 1 }},
+          function(err, list) {
             if (err) return done(err);
 
             ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
@@ -165,12 +165,12 @@ module.exports = function(dataSource, should, connectorCapabilities) {
             }));
             done();
           });
-      })
+      });
 
       it('emits error when `loaded` hook fails', function(done) {
         TestModel.observe('loaded', nextWithError(expectedError));
         TestModel.find(
-          {where: {id: 1}},
+          { where: { id: 1 }},
           function(err, list) {
             [err].should.eql([expectedError]);
             done();
@@ -191,7 +191,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               'before save',
               'persist',
               'loaded',
-              'after save'
+              'after save',
             ]);
             done();
           });
@@ -206,9 +206,9 @@ module.exports = function(dataSource, should, connectorCapabilities) {
             instance: {
               id: instance.id,
               name: 'created',
-              extra: undefined
+              extra: undefined,
             },
-            isNewInstance: true
+            isNewInstance: true,
           }));
           done();
         });
@@ -251,12 +251,12 @@ module.exports = function(dataSource, should, connectorCapabilities) {
             ctxRecorder.records.should.eql([
               aCtxForModel(TestModel, {
                 instance: { id: list[0].id, name: '1', extra: undefined },
-                isNewInstance: true
+                isNewInstance: true,
               }),
               aCtxForModel(TestModel, {
                 instance: { id: list[1].id, name: '2', extra: undefined  },
-                isNewInstance: true
-               }),
+                isNewInstance: true,
+              }),
             ]);
             done();
           });
@@ -283,7 +283,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
             ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
               data: { id: 'new-id', name: 'a name' },
               isNewInstance: true,
-              currentInstance: { extra: null, id: 'new-id', name: 'a name' }
+              currentInstance: { extra: null, id: 'new-id', name: 'a name' },
             }));
 
             done();
@@ -315,7 +315,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               dbInstance.toObject(true).should.eql({
                 id: 'new-id',
                 name: 'a name',
-                extra: 'hook data'
+                extra: 'hook data',
               });
               done();
             });
@@ -338,7 +338,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
 
             ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
               data: { id: 'new-id', name: 'a name' },
-              isNewInstance: true
+              isNewInstance: true,
             }));
 
             done();
@@ -384,9 +384,9 @@ module.exports = function(dataSource, should, connectorCapabilities) {
             instance: {
               id: instance.id,
               name: 'created',
-              extra: undefined
+              extra: undefined,
             },
-            isNewInstance: true
+            isNewInstance: true,
           }));
           done();
         });
@@ -429,11 +429,11 @@ module.exports = function(dataSource, should, connectorCapabilities) {
             ctxRecorder.records.should.eql([
               aCtxForModel(TestModel, {
                 instance: { id: list[0].id, name: '1', extra: undefined },
-                isNewInstance: true
+                isNewInstance: true,
               }),
               aCtxForModel(TestModel, {
                 instance: { id: list[1].id, name: '2', extra: undefined },
-                isNewInstance: true
+                isNewInstance: true,
               }),
             ]);
             done();
@@ -463,7 +463,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
 
             ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
               instance: { id: list[0].id, name: 'ok', extra: undefined },
-              isNewInstance: true
+              isNewInstance: true,
             }));
             done();
           });
@@ -475,7 +475,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
         TestModel.observe('access', ctxRecorder.recordAndNext());
 
         TestModel.findOrCreate(
-          { where: { name: 'new-record' } },
+          { where: { name: 'new-record' }},
           { name: 'new-record' },
           function(err, record, created) {
             if (err) return done(err);
@@ -483,7 +483,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               where: { name: 'new-record' },
               limit: 1,
               offset: 0,
-              skip: 0
+              skip: 0,
             }}));
             done();
           });
@@ -494,7 +494,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
           TestModel.observe('before save', ctxRecorder.recordAndNext());
 
           TestModel.findOrCreate(
-            { where: { name: existingInstance.name } },
+            { where: { name: existingInstance.name }},
             { name: existingInstance.name },
             function(err, record, created) {
               if (err) return done(err);
@@ -503,9 +503,9 @@ module.exports = function(dataSource, should, connectorCapabilities) {
                 instance: {
                   id: getLastGeneratedUid(),
                   name: existingInstance.name,
-                  extra: undefined
+                  extra: undefined,
                 },
-                isNewInstance: true
+                isNewInstance: true,
               }));
               done();
             });
@@ -516,7 +516,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
         TestModel.observe('before save', ctxRecorder.recordAndNext());
 
         TestModel.findOrCreate(
-          { where: { name: 'new-record' } },
+          { where: { name: 'new-record' }},
           { name: 'new-record' },
           function(err, record, created) {
             if (err) return done(err);
@@ -524,9 +524,9 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               instance: {
                 id: record.id,
                 name: 'new-record',
-                extra: undefined
+                extra: undefined,
               },
-              isNewInstance: true
+              isNewInstance: true,
             }));
             done();
           });
@@ -536,7 +536,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
         TestModel.observe('before save', invalidateTestModel());
 
         TestModel.findOrCreate(
-          { where: { name: 'new-record' } },
+          { where: { name: 'new-record' }},
           { name: 'new-record' },
           function(err) {
             (err || {}).should.be.instanceOf(ValidationError);
@@ -549,7 +549,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
         monitorHookExecution();
 
         TestModel.findOrCreate(
-          { where: { name: 'new-record' } },
+          { where: { name: 'new-record' }},
           { name: 'new-record' },
           function(err, record, created) {
             if (err) return done(err);
@@ -558,7 +558,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               'before save',
               'persist',
               'loaded',
-              'after save'
+              'after save',
             ]);
             done();
           });
@@ -568,7 +568,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
         monitorHookExecution();
 
         TestModel.findOrCreate(
-          { where: { name: existingInstance.name } },
+          { where: { name: existingInstance.name }},
           { name: existingInstance.name },
           function(err, record, created) {
             if (err) return done(err);
@@ -578,12 +578,12 @@ module.exports = function(dataSource, should, connectorCapabilities) {
                 'access',
                 'before save',
                 'persist',
-                'loaded'
+                'loaded',
               ]);
             } else {
               hookMonitor.names.should.eql([
                 'access',
-                'loaded'
+                'loaded',
               ]);
             }
             done();
@@ -594,7 +594,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
         TestModel.observe('access', nextWithError(expectedError));
 
         TestModel.findOrCreate(
-          { where: { id: 'does-not-exist' } },
+          { where: { id: 'does-not-exist' }},
           { name: 'does-not-exist' },
           function(err, instance) {
             [err].should.eql([expectedError]);
@@ -606,7 +606,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
         TestModel.observe('before save', nextWithError(expectedError));
 
         TestModel.findOrCreate(
-          { where: { id: 'does-not-exist' } },
+          { where: { id: 'does-not-exist' }},
           { name: 'does-not-exist' },
           function(err, instance) {
             [err].should.eql([expectedError]);
@@ -619,7 +619,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
           TestModel.observe('persist', ctxRecorder.recordAndNext());
 
           TestModel.findOrCreate(
-            { where: { name: existingInstance.name } },
+            { where: { name: existingInstance.name }},
             { name: existingInstance.name },
             function(err, record, created) {
               if (err) return done(err);
@@ -635,15 +635,15 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
                 data: {
                   id: getLastGeneratedUid(),
-                  name: existingInstance.name
+                  name: existingInstance.name,
                 },
                 isNewInstance: true,
                 currentInstance: {
                   id: getLastGeneratedUid(),
                   name: record.name,
-                  extra: null
+                  extra: null,
                 },
-                where: { name: existingInstance.name }
+                where: { name: existingInstance.name },
               }));
 
               done();
@@ -655,7 +655,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
         TestModel.observe('persist', ctxRecorder.recordAndNext());
 
         TestModel.findOrCreate(
-          { where: { name: 'new-record' } },
+          { where: { name: 'new-record' }},
           { name: 'new-record' },
           function(err, record, created) {
             if (err) return done(err);
@@ -666,24 +666,24 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
                 data: {
                   id: record.id,
-                  name: 'new-record'
+                  name: 'new-record',
                 },
                 isNewInstance: true,
                 currentInstance: {
                   id: record.id,
                   name: record.name,
-                  extra: null
+                  extra: null,
                 },
-                where: { name: 'new-record' }
+                where: { name: 'new-record' },
               }));
             } else {
               ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
                 data: {
                   id: record.id,
-                  name: 'new-record'
+                  name: 'new-record',
                 },
                 isNewInstance: true,
-                currentInstance: { id: record.id, name: record.name, extra: null }
+                currentInstance: { id: record.id, name: record.name, extra: null },
               }));
             }
             done();
@@ -697,7 +697,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
           }));
 
           TestModel.findOrCreate(
-            { where: { name: existingInstance.name } },
+            { where: { name: existingInstance.name }},
             { name: existingInstance.name },
             function(err, instance) {
               if (err) return done(err);
@@ -715,7 +715,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
                 dbInstance.toObject(true).should.eql({
                   id: existingInstance.id,
                   name: existingInstance.name,
-                  extra: undefined
+                  extra: undefined,
                 });
               });
 
@@ -730,7 +730,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
         }));
 
         TestModel.findOrCreate(
-          { where: { name: 'new-record' } },
+          { where: { name: 'new-record' }},
           { name: 'new-record' },
           function(err, instance) {
             if (err) return done(err);
@@ -753,7 +753,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
                 dbInstance.toObject(true).should.eql({
                   id: instance.id,
                   name: instance.name,
-                  extra: 'hook data'
+                  extra: 'hook data',
                 });
               });
             }
@@ -766,7 +766,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
           TestModel.observe('loaded', ctxRecorder.recordAndNext());
 
           TestModel.findOrCreate(
-            { where: { name: existingInstance.name } },
+            { where: { name: existingInstance.name }},
             { name: existingInstance.name },
             function(err, record, created) {
               if (err) return done(err);
@@ -779,9 +779,9 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
                 data: {
                   id: existingInstance.id,
-                  name: existingInstance.name
+                  name: existingInstance.name,
                 },
-                isNewInstance: false
+                isNewInstance: false,
               }));
 
               done();
@@ -793,7 +793,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
         TestModel.observe('loaded', ctxRecorder.recordAndNext());
 
         TestModel.findOrCreate(
-          { where: { name: 'new-record' } },
+          { where: { name: 'new-record' }},
           { name: 'new-record' },
           function(err, record, created) {
             if (err) return done(err);
@@ -801,9 +801,9 @@ module.exports = function(dataSource, should, connectorCapabilities) {
             ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
               data: {
                 id: record.id,
-                name: 'new-record'
+                name: 'new-record',
               },
-              isNewInstance: true
+              isNewInstance: true,
             }));
 
             done();
@@ -813,7 +813,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
       it('emits error when `loaded` hook fails', function(done) {
         TestModel.observe('loaded', nextWithError(expectedError));
         TestModel.findOrCreate(
-          { where: { name: 'new-record' } },
+          { where: { name: 'new-record' }},
           { name: 'new-record' },
           function(err, instance) {
             [err].should.eql([expectedError]);
@@ -828,7 +828,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
           }));
 
           TestModel.findOrCreate(
-            { where: { name: existingInstance.name } },
+            { where: { name: existingInstance.name }},
             { name: existingInstance.name },
             function(err, instance) {
               if (err) return done(err);
@@ -854,7 +854,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
         // unoptimized connector.
         TestModel.settings.updateOnLoad = true;
         TestModel.findOrCreate(
-          { where: { name: 'new-record' } },
+          { where: { name: 'new-record' }},
           { name: 'new-record' },
           function(err, instance) {
             if (err) return done(err);
@@ -868,7 +868,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
         TestModel.observe('after save', ctxRecorder.recordAndNext());
 
         TestModel.findOrCreate(
-          { where: { name: 'new name' } },
+          { where: { name: 'new name' }},
           { name: 'new name' },
           function(err, instance) {
             if (err) return done(err);
@@ -876,9 +876,9 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               instance: {
                 id: instance.id,
                 name: 'new name',
-                extra: undefined
+                extra: undefined,
               },
-              isNewInstance: true
+              isNewInstance: true,
             }));
             done();
           });
@@ -888,7 +888,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
         TestModel.observe('after save', ctxRecorder.recordAndNext());
 
         TestModel.findOrCreate(
-          { where: { id: existingInstance.id } },
+          { where: { id: existingInstance.id }},
           { name: existingInstance.name },
           function(err, instance) {
             if (err) return done(err);
@@ -936,7 +936,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               'before save',
               'persist',
               'loaded',
-              'after save'
+              'after save',
             ]);
             done();
           });
@@ -952,7 +952,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
             id: existingInstance.id,
             name: 'changed',
             extra: undefined,
-          }, options: { throws: false, validate: true } }));
+          }, options: { throws: false, validate: true }}));
           done();
         });
       });
@@ -1003,14 +1003,14 @@ module.exports = function(dataSource, should, connectorCapabilities) {
           ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
             data: {
               id: existingInstance.id,
-              name: 'changed'
+              name: 'changed',
             },
             currentInstance: {
               id: existingInstance.id,
-              name: 'changed'
+              name: 'changed',
             },
             where: { id: existingInstance.id },
-            options: { throws: false, validate: true }
+            options: { throws: false, validate: true },
           }));
 
           done();
@@ -1043,7 +1043,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               extra: 'changed',
             },
             isNewInstance: false,
-            options: { throws: false, validate: true }
+            options: { throws: false, validate: true },
           }));
 
           done();
@@ -1081,10 +1081,10 @@ module.exports = function(dataSource, should, connectorCapabilities) {
             instance: {
               id: existingInstance.id,
               name: 'changed',
-              extra: undefined
+              extra: undefined,
             },
             isNewInstance: false,
-            options: { throws: false, validate: true }
+            options: { throws: false, validate: true },
           }));
           done();
         });
@@ -1103,10 +1103,10 @@ module.exports = function(dataSource, should, connectorCapabilities) {
             instance: {
               id: instance.id,
               name: 'created',
-              extra: undefined
+              extra: undefined,
             },
             isNewInstance: true,
-            options: { throws: false, validate: true }
+            options: { throws: false, validate: true },
           }));
           done();
         });
@@ -1148,7 +1148,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               'before save',
               'persist',
               'loaded',
-              'after save'
+              'after save',
             ]);
             done();
           });
@@ -1165,7 +1165,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
           ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
             where: { id: existingInstance.id },
             data: { name: 'changed' },
-            currentInstance: currentInstance
+            currentInstance: currentInstance,
           }));
           done();
         });
@@ -1197,7 +1197,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
             instance.toObject(true).should.eql({
               id: existingInstance.id,
               name: 'hooked name',
-              extra: 'extra data'
+              extra: 'extra data',
             });
             done();
           });
@@ -1225,9 +1225,9 @@ module.exports = function(dataSource, should, connectorCapabilities) {
             currentInstance: {
               id: existingInstance.id,
               name: 'changed',
-              extra: null
+              extra: null,
             },
-            isNewInstance: false
+            isNewInstance: false,
           }));
 
           done();
@@ -1255,19 +1255,19 @@ module.exports = function(dataSource, should, connectorCapabilities) {
         var Address = dataSource.createModel('NestedAddress', {
           id: { type: String, id: true, default: 1 },
           city: { type: String, required: true },
-          country: { type: String, required: true }
+          country: { type: String, required: true },
         });
 
         var User = dataSource.createModel('UserWithAddress', {
           id: { type: String, id: true, default: uid.next },
           name: { type: String, required: true },
-          address: {type: Address, required: false},
-          extra: {type: String}
+          address: { type: Address, required: false },
+          extra: { type: String },
         });
 
         dataSource.automigrate(['UserWithAddress', 'NestedAddress'], function(err) {
           if (err) return done(err);
-          User.create({name: 'Joe'}, function(err, instance) {
+          User.create({ name: 'Joe' }, function(err, instance) {
             if (err) return done(err);
 
             var existingUser = instance;
@@ -1286,7 +1286,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
             // which if set, will apply these changes to the model instance too.
             User.settings.updateOnLoad = true;
             existingUser.updateAttributes(
-              {address: new Address({city: 'Springfield', country: 'USA'})},
+              { address: new Address({ city: 'Springfield', country: 'USA' }) },
               function(err, inst) {
                 if (err) return done(err);
 
@@ -1297,8 +1297,8 @@ module.exports = function(dataSource, should, connectorCapabilities) {
                   dbInstance.toObject(true).should.eql({
                     id: existingUser.id,
                     name: existingUser.name,
-                    address: {id: '1', city: 'Springfield', country: 'USA'},
-                    extra: 'hook data'
+                    address: { id: '1', city: 'Springfield', country: 'USA' },
+                    extra: 'hook data',
                   });
                   done();
                 });
@@ -1357,9 +1357,9 @@ module.exports = function(dataSource, should, connectorCapabilities) {
             instance: {
               id: existingInstance.id,
               name: 'changed',
-              extra: undefined
+              extra: undefined,
             },
-            isNewInstance: false
+            isNewInstance: false,
           }));
           done();
         });
@@ -1390,7 +1390,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
     });
 
     if (!getSchema().connector.replaceById) {
-      describe.skip('replaceById - not implemented', function(){});
+      describe.skip('replaceById - not implemented', function() {});
     } else {
       describe('PersistedModel.prototype.replaceAttributes', function() {
         it('triggers hooks in the correct order', function(done) {
@@ -1404,7 +1404,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
                 'before save',
                 'persist',
                 'loaded',
-                'after save'
+                'after save',
               ]);
               done();
             });
@@ -1421,7 +1421,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
                 name: 'changed',
                 extra: undefined,
               },
-              isNewInstance: false
+              isNewInstance: false,
             }));
             done();
           });
@@ -1451,7 +1451,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               instance.toObject(true).should.eql({
                 id: existingInstance.id,
                 name: 'hooked name',
-                extra: 'extra data'
+                extra: 'extra data',
               });
               done();
             });
@@ -1477,14 +1477,14 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               where: { id: existingInstance.id },
               data: {
                 name: 'replacedName',
-                id: existingInstance.id
+                id: existingInstance.id,
               },
               currentInstance: {
                 id: existingInstance.id,
                 name: 'replacedName',
-                extra: null
+                extra: null,
               },
-              isNewInstance: false
+              isNewInstance: false,
             }));
 
             done();
@@ -1507,19 +1507,19 @@ module.exports = function(dataSource, should, connectorCapabilities) {
           var Address = dataSource.createModel('NestedAddress', {
             id: { type: String, id: true, default: 1 },
             city: { type: String, required: true },
-            country: { type: String, required: true }
+            country: { type: String, required: true },
           });
 
           var User = dataSource.createModel('UserWithAddress', {
             id: { type: String, id: true, default: uid.next },
             name: { type: String, required: true },
-            address: {type: Address, required: false},
-            extra: {type: String}
+            address: { type: Address, required: false },
+            extra: { type: String },
           });
 
           dataSource.automigrate(['UserWithAddress', 'NestedAddress'], function(err) {
             if (err) return done(err);
-            User.create({name: 'Joe'}, function(err, instance) {
+            User.create({ name: 'Joe' }, function(err, instance) {
               if (err) return done(err);
 
               var existingUser = instance;
@@ -1533,7 +1533,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               }));
 
               existingUser.replaceAttributes(
-                {name: 'John', address: new Address({city: 'Springfield', country: 'USA'})},
+                { name: 'John', address: new Address({ city: 'Springfield', country: 'USA' }) },
                 function(err, inst) {
                   if (err) return done(err);
 
@@ -1544,8 +1544,8 @@ module.exports = function(dataSource, should, connectorCapabilities) {
                     dbInstance.toObject(true).should.eql({
                       id: existingUser.id,
                       name: 'John',
-                      address: {id: '1', city: 'Springfield', country: 'USA'},
-                      extra: 'hook data'
+                      address: { id: '1', city: 'Springfield', country: 'USA' },
+                      extra: 'hook data',
                     });
                     done();
                   });
@@ -1562,9 +1562,9 @@ module.exports = function(dataSource, should, connectorCapabilities) {
             ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
               data: {
                 name: 'changed',
-                id: data.id
+                id: data.id,
               },
-              isNewInstance : false
+              isNewInstance : false,
             }));
             done();
           });
@@ -1602,9 +1602,9 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               instance: {
                 id: existingInstance.id,
                 name: 'replaced',
-                extra: undefined
+                extra: undefined,
               },
-              isNewInstance: false
+              isNewInstance: false,
             }));
             done();
           });
@@ -1648,7 +1648,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               'before save',
               'persist',
               'loaded',
-              'after save'
+              'after save',
             ]);
             done();
           });
@@ -1667,7 +1667,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
                 'before save',
                 'persist',
                 'loaded',
-                'after save'
+                'after save',
               ]);
             } else {
               hookMonitor.names.should.eql([
@@ -1676,7 +1676,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
                 'before save',
                 'persist',
                 'loaded',
-                'after save'
+                'after save',
               ]);
             }
             done();
@@ -1725,7 +1725,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
 
       it('applies updates from `access` hook when found', function(done) {
         TestModel.observe('access', function(ctx, next) {
-          ctx.query = { where: { id: { neq: existingInstance.id } } };
+          ctx.query = { where: { id: { neq: existingInstance.id }}};
           next();
         });
 
@@ -1733,20 +1733,20 @@ module.exports = function(dataSource, should, connectorCapabilities) {
           { id: existingInstance.id, name: 'new name' },
           function(err, instance) {
             if (err) return done(err);
-            findTestModels({ fields: ['id', 'name' ] }, function(err, list) {
+            findTestModels({ fields: ['id', 'name'] }, function(err, list) {
               if (err) return done(err);
-              (list||[]).map(toObject).should.eql([
+              (list || []).map(toObject).should.eql([
                 { id: existingInstance.id, name: existingInstance.name, extra: undefined },
-                { id: instance.id, name: 'new name', extra: undefined }
+                { id: instance.id, name: 'new name', extra: undefined },
               ]);
               done();
             });
-        });
+          });
       });
 
       it('applies updates from `access` hook when not found', function(done) {
         TestModel.observe('access', function(ctx, next) {
-          ctx.query = { where: { id: 'not-found' } };
+          ctx.query = { where: { id: 'not-found' }};
           next();
         });
 
@@ -1754,23 +1754,23 @@ module.exports = function(dataSource, should, connectorCapabilities) {
           { id: existingInstance.id, name: 'new name' },
           function(err, instance) {
             if (err) return done(err);
-            findTestModels({ fields: ['id', 'name' ] }, function(err, list) {
+            findTestModels({ fields: ['id', 'name'] }, function(err, list) {
               if (err) return done(err);
-              (list||[]).map(toObject).should.eql([
+              (list || []).map(toObject).should.eql([
                 { id: existingInstance.id, name: existingInstance.name, extra: undefined },
                 { id: list[1].id, name: 'second', extra: undefined },
-                { id: instance.id, name: 'new name', extra: undefined }
+                { id: instance.id, name: 'new name', extra: undefined },
               ]);
               done();
             });
-        });
+          });
       });
 
       it('triggers hooks only once', function(done) {
         monitorHookExecution(['access', 'before save']);
 
         TestModel.observe('access', function(ctx, next) {
-          ctx.query = { where: { id: { neq: existingInstance.id } } };
+          ctx.query = { where: { id: { neq: existingInstance.id }}};
           next();
         });
 
@@ -1796,7 +1796,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               // UPDATE or CREATE will be triggered
               ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
                 where: { id: existingInstance.id },
-                data: { id: existingInstance.id, name: 'updated name' }
+                data: { id: existingInstance.id, name: 'updated name' },
               }));
             } else {
               // currentInstance is set, because a non-atomic `updateOrCreate`
@@ -1805,7 +1805,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
                 where: { id: existingInstance.id },
                 data: { id: existingInstance.id, name: 'updated name' },
-                currentInstance: existingInstance
+                currentInstance: existingInstance,
               }));
             }
             done();
@@ -1826,14 +1826,14 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               // UPDATE or CREATE will be triggered
               ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
                 where: { id: 'new-id' },
-                data: { id: 'new-id', name: 'a name' }
+                data: { id: 'new-id', name: 'a name' },
               }));
             } else {
               // The default unoptimized implementation runs
               // `instance.save` and thus a full instance is availalbe
               ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
                 instance: { id: 'new-id', name: 'a name', extra: undefined },
-                isNewInstance: true
+                isNewInstance: true,
               }));
             }
 
@@ -1918,21 +1918,21 @@ module.exports = function(dataSource, should, connectorCapabilities) {
                 currentInstance: {
                   id: 'new-id',
                   name: 'a name',
-                  extra: undefined
-                }
+                  extra: undefined,
+                },
               }));
             } else {
               ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
                 data: {
                   id: 'new-id',
-                  name: 'a name'
+                  name: 'a name',
                 },
                 isNewInstance: true,
                 currentInstance: {
                   id: 'new-id',
                   name: 'a name',
-                  extra: undefined
-                }
+                  extra: undefined,
+                },
               }));
             }
             done();
@@ -1951,13 +1951,13 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               where: { id: existingInstance.id },
               data: {
                 id: existingInstance.id,
-                name: 'updated name'
+                name: 'updated name',
               },
               currentInstance: {
                 id: existingInstance.id,
                 name: 'updated name',
-                extra: undefined
-              }
+                extra: undefined,
+              },
             });
 
             if (!dataSource.connector.updateOrCreate) {
@@ -1987,9 +1987,9 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
                 data: {
                   id: 'new-id',
-                  name: 'a name'
+                  name: 'a name',
                 },
-                isNewInstance: true
+                isNewInstance: true,
               }));
             }
             done();
@@ -2008,8 +2008,8 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
                 data: {
                   id: existingInstance.id,
-                  name: 'updated name'
-                }
+                  name: 'updated name',
+                },
               }));
             } else {
               // For Unoptimized connector, the callback function `contextRecorder.recordAndNext`
@@ -2020,17 +2020,17 @@ module.exports = function(dataSource, should, connectorCapabilities) {
                   instance: {
                     id: existingInstance.id,
                     name: 'first',
-                    extra: null
+                    extra: null,
                   },
                   isNewInstance: false,
-                  options: { notify: false }
+                  options: { notify: false },
                 }),
                 aCtxForModel(TestModel, {
                   data: {
                     id: existingInstance.id,
-                    name: 'updated name'
-                  }
-                })
+                    name: 'updated name',
+                  },
+                }),
               ]);
             }
             done();
@@ -2058,9 +2058,9 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               instance: {
                 id: existingInstance.id,
                 name: 'updated name',
-                extra: undefined
+                extra: undefined,
               },
-              isNewInstance: false
+              isNewInstance: false,
             }));
             done();
           });
@@ -2077,9 +2077,9 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               instance: {
                 id: instance.id,
                 name: 'a name',
-                extra: undefined
+                extra: undefined,
               },
-              isNewInstance: true
+              isNewInstance: true,
             }));
             done();
           });
@@ -2087,7 +2087,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
     });
 
     if (!getSchema().connector.replaceById) {
-      describe.skip('replaceById - not implemented', function(){});
+      describe.skip('replaceById - not implemented', function() {});
     } else {
       describe('PersistedModel.replaceOrCreate', function() {
         it('triggers hooks in the correct order on create', function(done) {
@@ -2102,7 +2102,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
                 'before save',
                 'persist',
                 'loaded',
-                'after save'
+                'after save',
               ]);
               done();
             });
@@ -2121,7 +2121,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
                   'before save',
                   'persist',
                   'loaded',
-                  'after save'
+                  'after save',
                 ]);
               } else {
                 // TODO: Please see loopback-datasource-juggler/issues#836
@@ -2139,7 +2139,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
                   'before save',
                   'persist',
                   'loaded',
-                  'after save'
+                  'after save',
                 ]);
               };
               done();
@@ -2188,7 +2188,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
 
         it('applies updates from `access` hook when found', function(done) {
           TestModel.observe('access', function(ctx, next) {
-            ctx.query = { where: { id: { neq: existingInstance.id } } };
+            ctx.query = { where: { id: { neq: existingInstance.id }}};
             next();
           });
 
@@ -2196,20 +2196,20 @@ module.exports = function(dataSource, should, connectorCapabilities) {
             { id: existingInstance.id, name: 'new name' },
             function(err, instance) {
               if (err) return done(err);
-              findTestModels({ fields: ['id', 'name' ] }, function(err, list) {
+              findTestModels({ fields: ['id', 'name'] }, function(err, list) {
                 if (err) return done(err);
-                (list||[]).map(toObject).should.eql([
+                (list || []).map(toObject).should.eql([
                   { id: existingInstance.id, name: existingInstance.name, extra: undefined },
-                  { id: instance.id, name: 'new name', extra: undefined }
+                  { id: instance.id, name: 'new name', extra: undefined },
                 ]);
                 done();
               });
-          });
+            });
         });
 
         it('applies updates from `access` hook when not found', function(done) {
           TestModel.observe('access', function(ctx, next) {
-            ctx.query = { where: { id: 'not-found' } };
+            ctx.query = { where: { id: 'not-found' }};
             next();
           });
 
@@ -2217,23 +2217,23 @@ module.exports = function(dataSource, should, connectorCapabilities) {
             { id: existingInstance.id, name: 'new name' },
             function(err, instance) {
               if (err) return done(err);
-              findTestModels({ fields: ['id', 'name' ] }, function(err, list) {
+              findTestModels({ fields: ['id', 'name'] }, function(err, list) {
                 if (err) return done(err);
-                (list||[]).map(toObject).should.eql([
+                (list || []).map(toObject).should.eql([
                   { id: existingInstance.id, name: existingInstance.name, extra: undefined },
                   { id: list[1].id, name: 'second', extra: undefined },
-                  { id: instance.id, name: 'new name', extra: undefined }
+                  { id: instance.id, name: 'new name', extra: undefined },
                 ]);
                 done();
               });
-          });
+            });
         });
 
         it('triggers hooks only once', function(done) {
           monitorHookExecution(['access', 'before save']);
 
           TestModel.observe('access', function(ctx, next) {
-            ctx.query = { where: { id: { neq: existingInstance.id } } };
+            ctx.query = { where: { id: { neq: existingInstance.id }}};
             next();
           });
 
@@ -2275,8 +2275,8 @@ module.exports = function(dataSource, should, connectorCapabilities) {
                 instance: {
                   id: existingInstance.id,
                   name: 'replaced name',
-                  extra: undefined
-                }
+                  extra: undefined,
+                },
               });
 
               if (!dataSource.connector.replaceOrCreate) {
@@ -2300,8 +2300,8 @@ module.exports = function(dataSource, should, connectorCapabilities) {
                 instance: {
                   id: 'new-id',
                   name: 'a name',
-                  extra: undefined
-                }
+                  extra: undefined,
+                },
               });
 
               if (!dataSource.connector.replaceOrCreate) {
@@ -2385,13 +2385,13 @@ module.exports = function(dataSource, should, connectorCapabilities) {
                 where: { id: existingInstance.id },
                 data: {
                   id: existingInstance.id,
-                  name: 'replaced name'
+                  name: 'replaced name',
                 },
                 currentInstance: {
                   id: existingInstance.id,
                   name: 'replaced name',
-                  extra: undefined
-                }
+                  extra: undefined,
+                },
               };
 
               var expectedContext = aCtxForModel(TestModel, expected);
@@ -2417,8 +2417,8 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               var expected = {
                 data: {
                   id: 'new-id',
-                  name: 'a name'
-                }
+                  name: 'a name',
+                },
               };
 
               expected.isNewInstance =
@@ -2441,8 +2441,8 @@ module.exports = function(dataSource, should, connectorCapabilities) {
               var expected = {
                 data: {
                   id: existingInstance.id,
-                  name: 'replaced name'
-                }
+                  name: 'replaced name',
+                },
               };
 
               expected.isNewInstance =
@@ -2465,18 +2465,18 @@ module.exports = function(dataSource, should, connectorCapabilities) {
                   aCtxForModel(TestModel, {
                     data: {
                       id: existingInstance.id,
-                      name: 'first'
+                      name: 'first',
                     },
                     isNewInstance: false,
-                    options: { notify: false }
+                    options: { notify: false },
                   }),
                   aCtxForModel(TestModel, {
                     data: {
                       id: existingInstance.id,
-                      name: 'replaced name'
+                      name: 'replaced name',
                     },
-                    isNewInstance: false
-                  })
+                    isNewInstance: false,
+                  }),
                 ]);
               }
               done();
@@ -2505,8 +2505,8 @@ module.exports = function(dataSource, should, connectorCapabilities) {
                 instance: {
                   id: existingInstance.id,
                   name: 'replaced name',
-                  extra: undefined
-                }
+                  extra: undefined,
+                },
               };
 
               expected.isNewInstance =
@@ -2530,8 +2530,8 @@ module.exports = function(dataSource, should, connectorCapabilities) {
                 instance: {
                   id: instance.id,
                   name: 'a name',
-                  extra: undefined
-                }
+                  extra: undefined,
+                },
               };
               expected.isNewInstance =
                 connectorCapabilities.replaceOrCreateReportsNewInstance ?
@@ -2569,7 +2569,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
 
       it('applies updates from `access` hook', function(done) {
         TestModel.observe('access', function(ctx, next) {
-          ctx.query = { where: { id: { neq: existingInstance.id } } };
+          ctx.query = { where: { id: { neq: existingInstance.id }}};
           next();
         });
 
@@ -2607,7 +2607,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
 
       it('applies updates from `before delete` hook', function(done) {
         TestModel.observe('before delete', function(ctx, next) {
-          ctx.where = { id: { neq: existingInstance.id } };
+          ctx.where = { id: { neq: existingInstance.id }};
           next();
         });
 
@@ -2682,7 +2682,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
 
       it('applies updated from `access` hook', function(done) {
         TestModel.observe('access', function(ctx, next) {
-          ctx.query = { where: { id: { neq: existingInstance.id } } };
+          ctx.query = { where: { id: { neq: existingInstance.id }}};
           next();
         });
 
@@ -2711,7 +2711,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
 
       it('applies updated from `before delete` hook', function(done) {
         TestModel.observe('before delete', function(ctx, next) {
-          ctx.where = { id: { neq: existingInstance.id } };
+          ctx.where = { id: { neq: existingInstance.id }};
           next();
         });
 
@@ -2746,7 +2746,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
           if (err) return done(err);
           ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
             where: { id: existingInstance.id },
-            instance: existingInstance
+            instance: existingInstance,
           }));
           done();
         });
@@ -2788,13 +2788,13 @@ module.exports = function(dataSource, should, connectorCapabilities) {
             aCtxForModel(TestModel, {
               hookState: { foo: 'bar' },
               where: { id: '1' },
-              instance: existingInstance
+              instance: existingInstance,
             }),
             aCtxForModel(TestModel, {
               hookState: { foo: 'BAR' },
               where: { id: '1' },
-              instance: existingInstance
-            })
+              instance: existingInstance,
+            }),
           ]);
           done();
         });
@@ -2803,7 +2803,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
       it('triggers hooks only once', function(done) {
         monitorHookExecution();
         TestModel.observe('access', function(ctx, next) {
-          ctx.query = { where: { id: { neq: existingInstance.id } } };
+          ctx.query = { where: { id: { neq: existingInstance.id }}};
           next();
         });
 
@@ -2833,7 +2833,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
 
       it('applies updates from `access` hook', function(done) {
         TestModel.observe('access', function(ctx, next) {
-          ctx.query = { where: { id: { neq: existingInstance.id } } };
+          ctx.query = { where: { id: { neq: existingInstance.id }}};
           next();
         });
 
@@ -2842,15 +2842,15 @@ module.exports = function(dataSource, should, connectorCapabilities) {
           { name: 'new name' },
           function(err) {
             if (err) return done(err);
-            findTestModels({ fields: ['id', 'name' ] }, function(err, list) {
+            findTestModels({ fields: ['id', 'name'] }, function(err, list) {
               if (err) return done(err);
-              (list||[]).map(toObject).should.eql([
+              (list || []).map(toObject).should.eql([
                 { id: existingInstance.id, name: existingInstance.name, extra: undefined },
-                { id: '2', name: 'new name', extra: undefined }
+                { id: '2', name: 'new name', extra: undefined },
               ]);
               done();
             });
-        });
+          });
       });
 
       it('triggers `before save` hook', function(done) {
@@ -2900,7 +2900,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
 
             ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
               data: { name: 'changed' },
-              where: { name: existingInstance.name }
+              where: { name: existingInstance.name },
             }));
 
             done();
@@ -2947,7 +2947,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
             if (err) return done(err);
             ctxRecorder.records.should.eql(aCtxForModel(TestModel, {
               where: { id: existingInstance.id },
-              data: { name: 'updated name' }
+              data: { name: 'updated name' },
             }));
             done();
           });
@@ -2998,7 +2998,7 @@ module.exports = function(dataSource, should, connectorCapabilities) {
     }
 
     function loadTestModel(id, cb) {
-      TestModel.findOne({ where: { id: id } }, { notify: false }, cb);
+      TestModel.findOne({ where: { id: id }}, { notify: false }, cb);
     }
 
     function monitorHookExecution(hookNames) {
diff --git a/test/relations.test.js b/test/relations.test.js
index c06a698a..21c1250d 100644
--- a/test/relations.test.js
+++ b/test/relations.test.js
@@ -16,34 +16,34 @@ var Person, Address;
 var Link;
 
 var getTransientDataSource = function(settings) {
-    return new DataSource('transient', settings, db.modelBuilder);
+  return new DataSource('transient', settings, db.modelBuilder);
 };
 
 var getMemoryDataSource = function(settings) {
-    return new DataSource('memory', settings, db.modelBuilder);
+  return new DataSource('memory', settings, db.modelBuilder);
 };
 
-describe('relations', function () {
+describe('relations', function() {
 
   before(function() {
     db = getSchema();
   });
 
-  describe('hasMany', function () {
-    before(function (done) {
-      Book = db.define('Book', {name: String, type: String});
-      Chapter = db.define('Chapter', {name: {type: String, index: true},
-        bookType: String});
-      Author = db.define('Author', {name: String});
-      Reader = db.define('Reader', {name: String});
+  describe('hasMany', function() {
+    before(function(done) {
+      Book = db.define('Book', { name: String, type: String });
+      Chapter = db.define('Chapter', { name: { type: String, index: true },
+        bookType: String });
+      Author = db.define('Author', { name: String });
+      Reader = db.define('Reader', { name: String });
 
       db.automigrate(['Book', 'Chapter', 'Author', 'Reader'], done);
     });
 
-    it('can be declared in different ways', function (done) {
+    it('can be declared in different ways', function(done) {
       Book.hasMany(Chapter);
-      Book.hasMany(Reader, {as: 'users'});
-      Book.hasMany(Author, {foreignKey: 'projectId'});
+      Book.hasMany(Reader, { as: 'users' });
+      Book.hasMany(Author, { foreignKey: 'projectId' });
       var b = new Book;
       b.chapters.should.be.an.instanceOf(Function);
       b.users.should.be.an.instanceOf(Function);
@@ -54,7 +54,7 @@ describe('relations', function () {
       db.automigrate(['Book', 'Chapter', 'Author', 'Reader'], done);
     });
 
-    it('can be declared in short form', function (done) {
+    it('can be declared in short form', function(done) {
       Author.hasMany('readers');
       (new Author).readers.should.be.an.instanceOf(Function);
       Object.keys((new Reader).toObject()).should.containEql('authorId');
@@ -64,22 +64,22 @@ describe('relations', function () {
 
     describe('with scope', function() {
 
-      before(function (done) {
+      before(function(done) {
         Book.hasMany(Chapter);
         done();
       });
 
-      it('should build record on scope', function (done) {
-        Book.create(function (err, book) {
+      it('should build record on scope', function(done) {
+        Book.create(function(err, book) {
           var c = book.chapters.build();
           c.bookId.should.eql(book.id);
           c.save(done);
         });
       });
 
-      it('should create record on scope', function (done) {
-        Book.create(function (err, book) {
-          book.chapters.create(function (err, c) {
+      it('should create record on scope', function(done) {
+        Book.create(function(err, book) {
+          book.chapters.create(function(err, c) {
             should.not.exist(err);
             should.exist(c);
             c.bookId.should.eql(book.id);
@@ -88,11 +88,11 @@ describe('relations', function () {
         });
       });
 
-      it('should create record on scope with promises', function (done) {
+      it('should create record on scope with promises', function(done) {
         Book.create()
-        .then (function (book) {
+        .then (function(book) {
           return book.chapters.create()
-          .then (function (c) {
+          .then (function(c) {
             should.exist(c);
             c.bookId.should.eql(book.id);
             done();
@@ -100,14 +100,14 @@ describe('relations', function () {
         }).catch(done);
       });
 
-      it('should create a batch of records on scope', function (done) {
+      it('should create a batch of records on scope', function(done) {
         var chapters = [
-          {name: 'a'},
-          {name: 'z'},
-          {name: 'c'}
+          { name: 'a' },
+          { name: 'z' },
+          { name: 'c' },
         ];
-        Book.create(function (err, book) {
-          book.chapters.create(chapters, function (err, chs) {
+        Book.create(function(err, book) {
+          book.chapters.create(chapters, function(err, chs) {
             should.not.exist(err);
             should.exist(chs);
             chs.should.have.lengthOf(chapters.length);
@@ -119,15 +119,15 @@ describe('relations', function () {
         });
       });
 
-      it('should create a batch of records on scope with promises', function (done) {
+      it('should create a batch of records on scope with promises', function(done) {
         var chapters = [
-          {name: 'a'},
-          {name: 'z'},
-          {name: 'c'}
+          { name: 'a' },
+          { name: 'z' },
+          { name: 'c' },
         ];
-        Book.create(function (err, book) {
+        Book.create(function(err, book) {
           book.chapters.create(chapters)
-          .then(function (chs) {
+          .then(function(chs) {
             should.exist(chs);
             chs.should.have.lengthOf(chapters.length);
             chs.forEach(function(c) {
@@ -138,18 +138,18 @@ describe('relations', function () {
         });
       });
 
-      it('should fetch all scoped instances', function (done) {
-        Book.create(function (err, book) {
-          book.chapters.create({name: 'a'}, function () {
-            book.chapters.create({name: 'z'}, function () {
-              book.chapters.create({name: 'c'}, function () {
+      it('should fetch all scoped instances', function(done) {
+        Book.create(function(err, book) {
+          book.chapters.create({ name: 'a' }, function() {
+            book.chapters.create({ name: 'z' }, function() {
+              book.chapters.create({ name: 'c' }, function() {
                 verify(book);
               });
             });
           });
         });
         function verify(book) {
-          book.chapters(function (err, ch) {
+          book.chapters(function(err, ch) {
             should.not.exist(err);
             should.exist(ch);
             ch.should.have.lengthOf(3);
@@ -157,7 +157,7 @@ describe('relations', function () {
             var chapters = book.chapters();
             chapters.should.eql(ch);
 
-            book.chapters({order: 'name DESC'}, function (e, c) {
+            book.chapters({ order: 'name DESC' }, function(e, c) {
               should.not.exist(e);
               should.exist(c);
 
@@ -169,32 +169,32 @@ describe('relations', function () {
         }
       });
 
-      it('should fetch all scoped instances with promises', function (done) {
+      it('should fetch all scoped instances with promises', function(done) {
         Book.create()
-        .then(function (book) {
-          return book.chapters.create({name: 'a'})
-          .then(function () {
-            return book.chapters.create({name: 'z'})
+        .then(function(book) {
+          return book.chapters.create({ name: 'a' })
+          .then(function() {
+            return book.chapters.create({ name: 'z' });
           })
-          .then(function () {
-            return book.chapters.create({name: 'c'})
+          .then(function() {
+            return book.chapters.create({ name: 'c' });
           })
-          .then(function () {
+          .then(function() {
             return verify(book);
           });
         }).catch(done);
 
         function verify(book) {
           return book.chapters.getAsync()
-          .then(function (ch) {
+          .then(function(ch) {
             should.exist(ch);
             ch.should.have.lengthOf(3);
 
             var chapters = book.chapters();
             chapters.should.eql(ch);
 
-            return book.chapters.getAsync({order: 'name DESC'})
-            .then(function (c) {
+            return book.chapters.getAsync({ order: 'name DESC' })
+            .then(function(c) {
               should.exist(c);
 
               c.shift().name.should.equal('z');
@@ -205,18 +205,18 @@ describe('relations', function () {
         }
       });
 
-      it('should fetch all scoped instances with getAsync with callback and condition', function (done) {
-        Book.create(function (err, book) {
-          book.chapters.create({name: 'a'}, function () {
-            book.chapters.create({name: 'z'}, function () {
-              book.chapters.create({name: 'c'}, function () {
+      it('should fetch all scoped instances with getAsync with callback and condition', function(done) {
+        Book.create(function(err, book) {
+          book.chapters.create({ name: 'a' }, function() {
+            book.chapters.create({ name: 'z' }, function() {
+              book.chapters.create({ name: 'c' }, function() {
                 verify(book);
               });
             });
           });
         });
         function verify(book) {
-          book.chapters(function (err, ch) {
+          book.chapters(function(err, ch) {
             should.not.exist(err);
             should.exist(ch);
             ch.should.have.lengthOf(3);
@@ -224,7 +224,7 @@ describe('relations', function () {
             var chapters = book.chapters();
             chapters.should.eql(ch);
 
-            book.chapters.getAsync({order: 'name DESC'}, function (e, c) {
+            book.chapters.getAsync({ order: 'name DESC' }, function(e, c) {
               should.not.exist(e);
               should.exist(c);
 
@@ -236,18 +236,18 @@ describe('relations', function () {
         }
       });
 
-      it('should fetch all scoped instances with getAsync with callback and no condition', function (done) {
-        Book.create(function (err, book) {
-          book.chapters.create({name: 'a'}, function () {
-            book.chapters.create({name: 'z'}, function () {
-              book.chapters.create({name: 'c'}, function () {
+      it('should fetch all scoped instances with getAsync with callback and no condition', function(done) {
+        Book.create(function(err, book) {
+          book.chapters.create({ name: 'a' }, function() {
+            book.chapters.create({ name: 'z' }, function() {
+              book.chapters.create({ name: 'c' }, function() {
                 verify(book);
               });
             });
           });
         });
         function verify(book) {
-          book.chapters(function (err, ch) {
+          book.chapters(function(err, ch) {
             should.not.exist(err);
             should.exist(ch);
             ch.should.have.lengthOf(3);
@@ -255,7 +255,7 @@ describe('relations', function () {
             var chapters = book.chapters();
             chapters.should.eql(ch);
 
-            book.chapters.getAsync(function (e, c) {
+            book.chapters.getAsync(function(e, c) {
               should.not.exist(e);
               should.exist(c);
               should.exist(c.length);
@@ -267,13 +267,13 @@ describe('relations', function () {
         }
       });
 
-      it('should find scoped record', function (done) {
+      it('should find scoped record', function(done) {
         var id;
-        Book.create(function (err, book) {
-          book.chapters.create({name: 'a'}, function (err, ch) {
+        Book.create(function(err, book) {
+          book.chapters.create({ name: 'a' }, function(err, ch) {
             id = ch.id;
-            book.chapters.create({name: 'z'}, function () {
-              book.chapters.create({name: 'c'}, function () {
+            book.chapters.create({ name: 'z' }, function() {
+              book.chapters.create({ name: 'c' }, function() {
                 verify(book);
               });
             });
@@ -281,7 +281,7 @@ describe('relations', function () {
         });
 
         function verify(book) {
-          book.chapters.findById(id, function (err, ch) {
+          book.chapters.findById(id, function(err, ch) {
             should.not.exist(err);
             should.exist(ch);
             ch.id.should.eql(id);
@@ -290,26 +290,26 @@ describe('relations', function () {
         }
       });
 
-      it('should find scoped record with promises', function (done) {
+      it('should find scoped record with promises', function(done) {
         var id;
         Book.create()
-        .then(function (book) {
-          return book.chapters.create({name: 'a'})
-          .then(function (ch) {
+        .then(function(book) {
+          return book.chapters.create({ name: 'a' })
+          .then(function(ch) {
             id = ch.id;
-            return book.chapters.create({name: 'z'})
+            return book.chapters.create({ name: 'z' });
           })
-          .then(function () {
-            return book.chapters.create({name: 'c'})
+          .then(function() {
+            return book.chapters.create({ name: 'c' });
           })
-          .then(function () {
+          .then(function() {
             return verify(book);
-          })
+          });
         }).catch(done);
 
         function verify(book) {
           return book.chapters.findById(id)
-          .then(function (ch) {
+          .then(function(ch) {
             should.exist(ch);
             ch.id.should.eql(id);
             done();
@@ -317,11 +317,11 @@ describe('relations', function () {
         }
       });
 
-      it('should count scoped records - all and filtered', function (done) {
-        Book.create(function (err, book) {
-          book.chapters.create({name: 'a'}, function (err, ch) {
-            book.chapters.create({name: 'b'}, function () {
-              book.chapters.create({name: 'c'}, function () {
+      it('should count scoped records - all and filtered', function(done) {
+        Book.create(function(err, book) {
+          book.chapters.create({ name: 'a' }, function(err, ch) {
+            book.chapters.create({ name: 'b' }, function() {
+              book.chapters.create({ name: 'c' }, function() {
                 verify(book);
               });
             });
@@ -329,10 +329,10 @@ describe('relations', function () {
         });
 
         function verify(book) {
-          book.chapters.count(function (err, count) {
+          book.chapters.count(function(err, count) {
             should.not.exist(err);
             count.should.equal(3);
-            book.chapters.count({ name: 'b' }, function (err, count) {
+            book.chapters.count({ name: 'b' }, function(err, count) {
               should.not.exist(err);
               count.should.equal(1);
               done();
@@ -341,28 +341,28 @@ describe('relations', function () {
         }
       });
 
-      it('should count scoped records - all and filtered with promises', function (done) {
+      it('should count scoped records - all and filtered with promises', function(done) {
         Book.create()
-        .then(function (book) {
-          book.chapters.create({name: 'a'})
-          .then(function () {
-            return book.chapters.create({name: 'b'})
+        .then(function(book) {
+          book.chapters.create({ name: 'a' })
+          .then(function() {
+            return book.chapters.create({ name: 'b' });
           })
-          .then(function () {
-            return book.chapters.create({name: 'c'})
+          .then(function() {
+            return book.chapters.create({ name: 'c' });
           })
-          .then(function () {
+          .then(function() {
             return verify(book);
           });
         }).catch(done);
 
         function verify(book) {
           return book.chapters.count()
-          .then(function (count) {
+          .then(function(count) {
             count.should.equal(3);
-            return book.chapters.count({ name: 'b' })
+            return book.chapters.count({ name: 'b' });
           })
-          .then(function (count) {
+          .then(function(count) {
             count.should.equal(1);
             done();
           });
@@ -373,19 +373,19 @@ describe('relations', function () {
         should.equal(Book.prototype.chapters._targetClass, 'Chapter');
       });
 
-      it('should update scoped record', function (done) {
+      it('should update scoped record', function(done) {
         var id;
-        Book.create(function (err, book) {
-          book.chapters.create({name: 'a'}, function (err, ch) {
+        Book.create(function(err, book) {
+          book.chapters.create({ name: 'a' }, function(err, ch) {
             id = ch.id;
-            book.chapters.updateById(id, {name: 'aa'}, function(err, ch) {
+            book.chapters.updateById(id, { name: 'aa' }, function(err, ch) {
               verify(book);
             });
           });
         });
 
         function verify(book) {
-          book.chapters.findById(id, function (err, ch) {
+          book.chapters.findById(id, function(err, ch) {
             should.not.exist(err);
             should.exist(ch);
             ch.id.should.eql(id);
@@ -395,14 +395,14 @@ describe('relations', function () {
         }
       });
 
-      it('should update scoped record with promises', function (done) {
+      it('should update scoped record with promises', function(done) {
         var id;
         Book.create()
-        .then(function (book) {
-          return book.chapters.create({name: 'a'})
-          .then(function (ch) {
+        .then(function(book) {
+          return book.chapters.create({ name: 'a' })
+          .then(function(ch) {
             id = ch.id;
-            return book.chapters.updateById(id, {name: 'aa'})
+            return book.chapters.updateById(id, { name: 'aa' });
           })
           .then(function(ch) {
             return verify(book);
@@ -412,7 +412,7 @@ describe('relations', function () {
 
         function verify(book) {
           return book.chapters.findById(id)
-          .then(function (ch) {
+          .then(function(ch) {
             should.exist(ch);
             ch.id.should.eql(id);
             ch.name.should.equal('aa');
@@ -421,10 +421,10 @@ describe('relations', function () {
         }
       });
 
-      it('should destroy scoped record', function (done) {
+      it('should destroy scoped record', function(done) {
         var id;
-        Book.create(function (err, book) {
-          book.chapters.create({name: 'a'}, function (err, ch) {
+        Book.create(function(err, book) {
+          book.chapters.create({ name: 'a' }, function(err, ch) {
             id = ch.id;
             book.chapters.destroy(id, function(err, ch) {
               verify(book);
@@ -433,21 +433,21 @@ describe('relations', function () {
         });
 
         function verify(book) {
-          book.chapters.findById(id, function (err, ch) {
+          book.chapters.findById(id, function(err, ch) {
             should.exist(err);
             done();
           });
         }
       });
 
-      it('should destroy scoped record with promises', function (done) {
+      it('should destroy scoped record with promises', function(done) {
         var id;
         Book.create()
-        .then(function (book) {
-          return book.chapters.create({name: 'a'})
-          .then(function (ch) {
+        .then(function(book) {
+          return book.chapters.create({ name: 'a' })
+          .then(function(ch) {
             id = ch.id;
-            return book.chapters.destroy(id)
+            return book.chapters.destroy(id);
           })
           .then(function(ch) {
             return verify(book);
@@ -457,20 +457,20 @@ describe('relations', function () {
 
         function verify(book) {
           return book.chapters.findById(id)
-          .catch(function (err) {
+          .catch(function(err) {
             should.exist(err);
             done();
           });
         }
       });
 
-      it('should check existence of a scoped record', function (done) {
+      it('should check existence of a scoped record', function(done) {
         var id;
-        Book.create(function (err, book) {
-          book.chapters.create({name: 'a'}, function (err, ch) {
+        Book.create(function(err, book) {
+          book.chapters.create({ name: 'a' }, function(err, ch) {
             id = ch.id;
-            book.chapters.create({name: 'z'}, function () {
-              book.chapters.create({name: 'c'}, function () {
+            book.chapters.create({ name: 'z' }, function() {
+              book.chapters.create({ name: 'c' }, function() {
                 verify(book);
               });
             });
@@ -478,7 +478,7 @@ describe('relations', function () {
         });
 
         function verify(book) {
-          book.chapters.exists(id, function (err, flag) {
+          book.chapters.exists(id, function(err, flag) {
             should.not.exist(err);
             flag.should.be.eql(true);
             done();
@@ -486,34 +486,34 @@ describe('relations', function () {
         }
       });
 
-      it('should check existence of a scoped record with promises', function (done) {
+      it('should check existence of a scoped record with promises', function(done) {
         var id;
         Book.create()
-        .then(function (book) {
-          return book.chapters.create({name: 'a'})
-          .then(function (ch) {
+        .then(function(book) {
+          return book.chapters.create({ name: 'a' })
+          .then(function(ch) {
             id = ch.id;
-            return book.chapters.create({name: 'z'})
+            return book.chapters.create({ name: 'z' });
           })
-          .then(function () {
-            return book.chapters.create({name: 'c'})
+          .then(function() {
+            return book.chapters.create({ name: 'c' });
           })
-          .then(function () {
+          .then(function() {
             return verify(book);
           });
         }).catch(done);
 
         function verify(book) {
           return book.chapters.exists(id)
-          .then(function (flag) {
+          .then(function(flag) {
             flag.should.be.eql(true);
             done();
           });
         }
       });
 
-      it('should check ignore related data on creation - array', function (done) {
-        Book.create({ chapters: [] }, function (err, book) {
+      it('should check ignore related data on creation - array', function(done) {
+        Book.create({ chapters: [] }, function(err, book) {
           should.not.exist(err);
           book.chapters.should.be.a.function;
           var obj = book.toObject();
@@ -522,9 +522,9 @@ describe('relations', function () {
         });
       });
 
-      it('should check ignore related data on creation with promises - array', function (done) {
+      it('should check ignore related data on creation with promises - array', function(done) {
         Book.create({ chapters: [] })
-        .then(function (book) {
+        .then(function(book) {
           book.chapters.should.be.a.function;
           var obj = book.toObject();
           should.not.exist(obj.chapters);
@@ -532,8 +532,8 @@ describe('relations', function () {
         }).catch(done);
       });
 
-      it('should check ignore related data on creation - object', function (done) {
-        Book.create({ chapters: {} }, function (err, book) {
+      it('should check ignore related data on creation - object', function(done) {
+        Book.create({ chapters: {}}, function(err, book) {
           should.not.exist(err);
           book.chapters.should.be.a.function;
           var obj = book.toObject();
@@ -542,9 +542,9 @@ describe('relations', function () {
         });
       });
 
-      it('should check ignore related data on creation with promises - object', function (done) {
-        Book.create({ chapters: {} })
-        .then(function (book) {
+      it('should check ignore related data on creation with promises - object', function(done) {
+        Book.create({ chapters: {}})
+        .then(function(book) {
           book.chapters.should.be.a.function;
           var obj = book.toObject();
           should.not.exist(obj.chapters);
@@ -555,21 +555,21 @@ describe('relations', function () {
 
   });
 
-  describe('hasMany through', function () {
+  describe('hasMany through', function() {
     var Physician, Patient, Appointment, Address;
 
-    before(function (done) {
+    before(function(done) {
       // db = getSchema();
-      Physician = db.define('Physician', {name: String});
-      Patient = db.define('Patient', {name: String});
-      Appointment = db.define('Appointment', {date: {type: Date,
-        default: function () {
+      Physician = db.define('Physician', { name: String });
+      Patient = db.define('Patient', { name: String });
+      Appointment = db.define('Appointment', { date: { type: Date,
+        default: function() {
           return new Date();
-        }}});
-      Address = db.define('Address', {name: String});
+        } }});
+      Address = db.define('Address', { name: String });
 
-      Physician.hasMany(Patient, {through: Appointment});
-      Patient.hasMany(Physician, {through: Appointment});
+      Physician.hasMany(Patient, { through: Appointment });
+      Patient.hasMany(Physician, { through: Appointment });
       Patient.belongsTo(Address);
       Appointment.belongsTo(Patient);
       Appointment.belongsTo(Physician);
@@ -577,83 +577,83 @@ describe('relations', function () {
       db.automigrate(['Physician', 'Patient', 'Appointment', 'Address'], done);
     });
 
-    it('should build record on scope', function (done) {
-      Physician.create(function (err, physician) {
+    it('should build record on scope', function(done) {
+      Physician.create(function(err, physician) {
         var patient = physician.patients.build();
         patient.physicianId.should.eql(physician.id);
         patient.save(done);
       });
     });
 
-    it('should create record on scope', function (done) {
-      Physician.create(function (err, physician) {
-        physician.patients.create(function (err, patient) {
+    it('should create record on scope', function(done) {
+      Physician.create(function(err, physician) {
+        physician.patients.create(function(err, patient) {
           should.not.exist(err);
           should.exist(patient);
-          Appointment.find({where: {physicianId: physician.id, patientId: patient.id}},
+          Appointment.find({ where: { physicianId: physician.id, patientId: patient.id }},
             function(err, apps) {
               should.not.exist(err);
               apps.should.have.lengthOf(1);
               done();
-          });
+            });
         });
       });
     });
 
-    it('should create record on scope with promises', function (done) {
+    it('should create record on scope with promises', function(done) {
       Physician.create()
-      .then(function (physician) {
+      .then(function(physician) {
         return physician.patients.create()
-        .then(function (patient) {
+        .then(function(patient) {
           should.exist(patient);
-          return Appointment.find({where: {physicianId: physician.id, patientId: patient.id}})
-          .then(function (apps) {
-              apps.should.have.lengthOf(1);
-              done();
+          return Appointment.find({ where: { physicianId: physician.id, patientId: patient.id }})
+          .then(function(apps) {
+            apps.should.have.lengthOf(1);
+            done();
           });
         });
       }).catch(done);
     });
 
-    it('should create multiple records on scope', function (done) {
+    it('should create multiple records on scope', function(done) {
       var async = require('async');
-      Physician.create(function (err, physician) {
-        physician.patients.create([{}, {}], function (err, patients) {
+      Physician.create(function(err, physician) {
+        physician.patients.create([{}, {}], function(err, patients) {
           should.not.exist(err);
           should.exist(patients);
           patients.should.have.lengthOf(2);
           function verifyPatient(patient, next) {
-            Appointment.find({where: {
+            Appointment.find({ where: {
               physicianId: physician.id,
-              patientId: patient.id
+              patientId: patient.id,
             }},
               function(err, apps) {
                 should.not.exist(err);
                 apps.should.have.lengthOf(1);
                 next();
-            });
+              });
           }
           async.forEach(patients, verifyPatient, done);
         });
       });
     });
 
-    it('should create multiple records on scope with promises', function (done) {
+    it('should create multiple records on scope with promises', function(done) {
       var async = require('async');
       Physician.create()
-      .then(function (physician) {
+      .then(function(physician) {
         return physician.patients.create([{}, {}])
-        .then(function (patients) {
+        .then(function(patients) {
           should.exist(patients);
           patients.should.have.lengthOf(2);
           function verifyPatient(patient, next) {
-            Appointment.find({where: {
+            Appointment.find({ where: {
               physicianId: physician.id,
-              patientId: patient.id
+              patientId: patient.id,
             }})
             .then(function(apps) {
-                apps.should.have.lengthOf(1);
-                next();
+              apps.should.have.lengthOf(1);
+              next();
             });
           }
           async.forEach(patients, verifyPatient, done);
@@ -661,18 +661,18 @@ describe('relations', function () {
       }).catch(done);
     });
 
-    it('should fetch all scoped instances', function (done) {
-      Physician.create(function (err, physician) {
-        physician.patients.create({name: 'a'}, function () {
-          physician.patients.create({name: 'z'}, function () {
-            physician.patients.create({name: 'c'}, function () {
+    it('should fetch all scoped instances', function(done) {
+      Physician.create(function(err, physician) {
+        physician.patients.create({ name: 'a' }, function() {
+          physician.patients.create({ name: 'z' }, function() {
+            physician.patients.create({ name: 'c' }, function() {
               verify(physician);
             });
           });
         });
       });
       function verify(physician) {
-        physician.patients(function (err, ch) {
+        physician.patients(function(err, ch) {
 
           var patients = physician.patients();
           patients.should.eql(ch);
@@ -685,23 +685,23 @@ describe('relations', function () {
       }
     });
 
-    it('should fetch all scoped instances with promises', function (done) {
+    it('should fetch all scoped instances with promises', function(done) {
       Physician.create()
-      .then(function (physician) {
-        return physician.patients.create({name: 'a'})
-        .then(function () {
-          return physician.patients.create({name: 'z'})
+      .then(function(physician) {
+        return physician.patients.create({ name: 'a' })
+        .then(function() {
+          return physician.patients.create({ name: 'z' });
         })
-        .then(function () {
-          return physician.patients.create({name: 'c'})
+        .then(function() {
+          return physician.patients.create({ name: 'c' });
         })
-        .then(function () {
+        .then(function() {
           return verify(physician);
-        })
+        });
       }).catch(done);
       function verify(physician) {
         return physician.patients.getAsync()
-        .then(function (ch) {
+        .then(function(ch) {
 
           var patients = physician.patients();
           patients.should.eql(ch);
@@ -713,11 +713,11 @@ describe('relations', function () {
       }
     });
 
-    it('should fetch scoped instances with paging filters', function (done) {
-      Physician.create(function (err, physician) {
-        physician.patients.create({name: 'a'}, function () {
-          physician.patients.create({name: 'z'}, function () {
-            physician.patients.create({name: 'c'}, function () {
+    it('should fetch scoped instances with paging filters', function(done) {
+      Physician.create(function(err, physician) {
+        physician.patients.create({ name: 'a' }, function() {
+          physician.patients.create({ name: 'z' }, function() {
+            physician.patients.create({ name: 'c' }, function() {
               verify(physician);
             });
           });
@@ -725,19 +725,19 @@ describe('relations', function () {
       });
       function verify(physician) {
         //limit plus skip
-        physician.patients({ limit:1, skip:1 },function (err, ch) {
+        physician.patients({ limit:1, skip:1 }, function(err, ch) {
           should.not.exist(err);
           should.exist(ch);
           ch.should.have.lengthOf(1);
           ch[0].name.should.eql('z');
           //offset plus skip
-          physician.patients({ limit:1, offset:1 },function (err1, ch1) {
+          physician.patients({ limit:1, offset:1 }, function(err1, ch1) {
             should.not.exist(err1);
             should.exist(ch1);
             ch1.should.have.lengthOf(1);
             ch1[0].name.should.eql('z');
             //order
-            physician.patients({ order: "patientId DESC" },function (err2, ch2) {
+            physician.patients({ order: 'patientId DESC' }, function(err2, ch2) {
               should.not.exist(err2);
               should.exist(ch2);
               ch2.should.have.lengthOf(3);
@@ -749,13 +749,13 @@ describe('relations', function () {
       }
     });
 
-    it('should find scoped record', function (done) {
+    it('should find scoped record', function(done) {
       var id;
-      Physician.create(function (err, physician) {
-        physician.patients.create({name: 'a'}, function (err, ch) {
+      Physician.create(function(err, physician) {
+        physician.patients.create({ name: 'a' }, function(err, ch) {
           id = ch.id;
-          physician.patients.create({name: 'z'}, function () {
-            physician.patients.create({name: 'c'}, function () {
+          physician.patients.create({ name: 'z' }, function() {
+            physician.patients.create({ name: 'c' }, function() {
               verify(physician);
             });
           });
@@ -763,7 +763,7 @@ describe('relations', function () {
       });
 
       function verify(physician) {
-        physician.patients.findById(id, function (err, ch) {
+        physician.patients.findById(id, function(err, ch) {
           should.not.exist(err);
           should.exist(ch);
           ch.id.should.eql(id);
@@ -772,25 +772,25 @@ describe('relations', function () {
       }
     });
 
-    it('should find scoped record with promises', function (done) {
+    it('should find scoped record with promises', function(done) {
       var id;
       Physician.create()
-      .then(function (physician) {
-        return physician.patients.create({name: 'a'})
-        .then(function (ch) {
+      .then(function(physician) {
+        return physician.patients.create({ name: 'a' })
+        .then(function(ch) {
           id = ch.id;
-          return physician.patients.create({name: 'z'})
+          return physician.patients.create({ name: 'z' });
         })
-        .then(function () {
-          return physician.patients.create({name: 'c'})
+        .then(function() {
+          return physician.patients.create({ name: 'c' });
         })
-        .then(function () {
+        .then(function() {
           return verify(physician);
         });
       }).catch(done);
 
       function verify(physician) {
-        return physician.patients.findById(id, function (err, ch) {
+        return physician.patients.findById(id, function(err, ch) {
           should.not.exist(err);
           should.exist(ch);
           ch.id.should.eql(id);
@@ -799,10 +799,10 @@ describe('relations', function () {
       }
     });
 
-    it('should allow to use include syntax on related data', function (done) {
-      Physician.create(function (err, physician) {
-        physician.patients.create({name: 'a'}, function (err, patient) {
-          Address.create({name: 'z'}, function (err, address) {
+    it('should allow to use include syntax on related data', function(done) {
+      Physician.create(function(err, physician) {
+        physician.patients.create({ name: 'a' }, function(err, patient) {
+          Address.create({ name: 'z' }, function(err, address) {
             should.not.exist(err);
             patient.address(address);
             patient.save(function() {
@@ -812,7 +812,7 @@ describe('relations', function () {
         });
       });
       function verify(physician, addressId) {
-        physician.patients({include: 'address'}, function (err, ch) {
+        physician.patients({ include: 'address' }, function(err, ch) {
           should.not.exist(err);
           should.exist(ch);
           ch.should.have.lengthOf(1);
@@ -826,13 +826,13 @@ describe('relations', function () {
       }
     });
 
-    it('should allow to use include syntax on related data with promises', function (done) {
+    it('should allow to use include syntax on related data with promises', function(done) {
       Physician.create()
-      .then(function (physician) {
-        return physician.patients.create({name: 'a'})
-        .then(function (patient) {
-          return Address.create({name: 'z'})
-          .then(function (address) {
+      .then(function(physician) {
+        return physician.patients.create({ name: 'a' })
+        .then(function(patient) {
+          return Address.create({ name: 'z' })
+          .then(function(address) {
             patient.address(address);
             return patient.save()
             .then(function() {
@@ -843,8 +843,8 @@ describe('relations', function () {
       }).catch(done);
 
       function verify(physician, addressId) {
-        return physician.patients.getAsync({include: 'address'})
-        .then(function (ch) {
+        return physician.patients.getAsync({ include: 'address' })
+        .then(function(ch) {
           should.exist(ch);
           ch.should.have.lengthOf(1);
           ch[0].addressId.should.eql(addressId);
@@ -861,19 +861,19 @@ describe('relations', function () {
       should.equal(Physician.prototype.patients._targetClass, 'Patient');
     });
 
-    it('should update scoped record', function (done) {
+    it('should update scoped record', function(done) {
       var id;
-      Physician.create(function (err, physician) {
-        physician.patients.create({name: 'a'}, function (err, ch) {
+      Physician.create(function(err, physician) {
+        physician.patients.create({ name: 'a' }, function(err, ch) {
           id = ch.id;
-          physician.patients.updateById(id, {name: 'aa'}, function(err, ch) {
+          physician.patients.updateById(id, { name: 'aa' }, function(err, ch) {
             verify(physician);
           });
         });
       });
 
       function verify(physician) {
-        physician.patients.findById(id, function (err, ch) {
+        physician.patients.findById(id, function(err, ch) {
           should.not.exist(err);
           should.exist(ch);
           ch.id.should.eql(id);
@@ -883,14 +883,14 @@ describe('relations', function () {
       }
     });
 
-    it('should update scoped record with promises', function (done) {
+    it('should update scoped record with promises', function(done) {
       var id;
       Physician.create()
-      .then(function (physician) {
-        return physician.patients.create({name: 'a'})
-        .then(function (ch) {
+      .then(function(physician) {
+        return physician.patients.create({ name: 'a' })
+        .then(function(ch) {
           id = ch.id;
-          return physician.patients.updateById(id, {name: 'aa'})
+          return physician.patients.updateById(id, { name: 'aa' })
           .then(function(ch) {
             return verify(physician);
           });
@@ -899,7 +899,7 @@ describe('relations', function () {
 
       function verify(physician) {
         return physician.patients.findById(id)
-        .then(function (ch) {
+        .then(function(ch) {
           should.exist(ch);
           ch.id.should.eql(id);
           ch.name.should.equal('aa');
@@ -908,10 +908,10 @@ describe('relations', function () {
       }
     });
 
-    it('should destroy scoped record', function (done) {
+    it('should destroy scoped record', function(done) {
       var id;
-      Physician.create(function (err, physician) {
-        physician.patients.create({name: 'a'}, function (err, ch) {
+      Physician.create(function(err, physician) {
+        physician.patients.create({ name: 'a' }, function(err, ch) {
           id = ch.id;
           physician.patients.destroy(id, function(err, ch) {
             verify(physician);
@@ -920,19 +920,19 @@ describe('relations', function () {
       });
 
       function verify(physician) {
-        physician.patients.findById(id, function (err, ch) {
+        physician.patients.findById(id, function(err, ch) {
           should.exist(err);
           done();
         });
       }
     });
 
-    it('should destroy scoped record with promises', function (done) {
+    it('should destroy scoped record with promises', function(done) {
       var id;
       Physician.create()
-      .then(function (physician) {
-        return physician.patients.create({name: 'a'})
-        .then(function (ch) {
+      .then(function(physician) {
+        return physician.patients.create({ name: 'a' })
+        .then(function(ch) {
           id = ch.id;
           return physician.patients.destroy(id)
           .then(function(ch) {
@@ -943,25 +943,25 @@ describe('relations', function () {
 
       function verify(physician) {
         return physician.patients.findById(id)
-        .then(function (ch) {
+        .then(function(ch) {
           should.not.exist(ch);
           done();
         })
-        .catch(function (err) {
+        .catch(function(err) {
           should.exist(err);
           done();
         });
       }
     });
 
-    it('should check existence of a scoped record', function (done) {
+    it('should check existence of a scoped record', function(done) {
       var id;
-      Physician.create(function (err, physician) {
-        physician.patients.create({name: 'a'}, function (err, ch) {
+      Physician.create(function(err, physician) {
+        physician.patients.create({ name: 'a' }, function(err, ch) {
           should.not.exist(err);
           id = ch.id;
-          physician.patients.create({name: 'z'}, function () {
-            physician.patients.create({name: 'c'}, function () {
+          physician.patients.create({ name: 'z' }, function() {
+            physician.patients.create({ name: 'c' }, function() {
               verify(physician);
             });
           });
@@ -969,7 +969,7 @@ describe('relations', function () {
       });
 
       function verify(physician) {
-        physician.patients.exists(id, function (err, flag) {
+        physician.patients.exists(id, function(err, flag) {
           should.not.exist(err);
           flag.should.be.eql(true);
           done();
@@ -977,36 +977,36 @@ describe('relations', function () {
       }
     });
 
-    it('should check existence of a scoped record with promises', function (done) {
+    it('should check existence of a scoped record with promises', function(done) {
       var id;
       Physician.create()
-      .then(function (physician) {
-        return physician.patients.create({name: 'a'})
-        .then(function (ch) {
+      .then(function(physician) {
+        return physician.patients.create({ name: 'a' })
+        .then(function(ch) {
           id = ch.id;
-          return physician.patients.create({name: 'z'})
+          return physician.patients.create({ name: 'z' });
         })
-        .then(function () {
-          return physician.patients.create({name: 'c'})
+        .then(function() {
+          return physician.patients.create({ name: 'c' });
         })
-        .then(function () {
+        .then(function() {
           return verify(physician);
         });
       }).catch(done);
 
       function verify(physician) {
         return physician.patients.exists(id)
-        .then(function (flag) {
+        .then(function(flag) {
           flag.should.be.eql(true);
           done();
         });
       }
     });
 
-    it('should allow to add connection with instance', function (done) {
-      Physician.create({name: 'ph1'}, function (e, physician) {
-        Patient.create({name: 'pa1'}, function (e, patient) {
-          physician.patients.add(patient, function (e, app) {
+    it('should allow to add connection with instance', function(done) {
+      Physician.create({ name: 'ph1' }, function(e, physician) {
+        Patient.create({ name: 'pa1' }, function(e, patient) {
+          physician.patients.add(patient, function(e, app) {
             should.not.exist(e);
             should.exist(app);
             app.should.be.an.instanceOf(Appointment);
@@ -1018,13 +1018,13 @@ describe('relations', function () {
       });
     });
 
-    it('should allow to add connection with instance with promises', function (done) {
-      Physician.create({name: 'ph1'})
-      .then(function (physician) {
-        return Patient.create({name: 'pa1'})
-        .then(function (patient) {
+    it('should allow to add connection with instance with promises', function(done) {
+      Physician.create({ name: 'ph1' })
+      .then(function(physician) {
+        return Patient.create({ name: 'pa1' })
+        .then(function(patient) {
           return physician.patients.add(patient)
-          .then(function (app) {
+          .then(function(app) {
             should.exist(app);
             app.should.be.an.instanceOf(Appointment);
             app.physicianId.should.eql(physician.id);
@@ -1035,11 +1035,11 @@ describe('relations', function () {
       }).catch(done);
     });
 
-    it('should allow to add connection with through data', function (done) {
-      Physician.create({name: 'ph1'}, function (e, physician) {
-        Patient.create({name: 'pa1'}, function (e, patient) {
+    it('should allow to add connection with through data', function(done) {
+      Physician.create({ name: 'ph1' }, function(e, physician) {
+        Patient.create({ name: 'pa1' }, function(e, patient) {
           var now = Date.now();
-          physician.patients.add(patient, { date: new Date(now) }, function (e, app) {
+          physician.patients.add(patient, { date: new Date(now) }, function(e, app) {
             should.not.exist(e);
             should.exist(app);
             app.should.be.an.instanceOf(Appointment);
@@ -1053,14 +1053,14 @@ describe('relations', function () {
       });
     });
 
-    it('should allow to add connection with through data with promises', function (done) {
-      Physician.create({name: 'ph1'})
-      .then(function (physician) {
-        return Patient.create({name: 'pa1'})
-        .then(function (patient) {
+    it('should allow to add connection with through data with promises', function(done) {
+      Physician.create({ name: 'ph1' })
+      .then(function(physician) {
+        return Patient.create({ name: 'pa1' })
+        .then(function(patient) {
           var now = Date.now();
           return physician.patients.add(patient, { date: new Date(now) })
-          .then(function (app) {
+          .then(function(app) {
             should.exist(app);
             app.should.be.an.instanceOf(Appointment);
             app.physicianId.should.eql(physician.id);
@@ -1073,19 +1073,19 @@ describe('relations', function () {
       }).catch(done);
     });
 
-    it('should allow to remove connection with instance', function (done) {
+    it('should allow to remove connection with instance', function(done) {
       var id;
-      Physician.create(function (err, physician) {
-        physician.patients.create({name: 'a'}, function (err, patient) {
+      Physician.create(function(err, physician) {
+        physician.patients.create({ name: 'a' }, function(err, patient) {
           id = patient.id;
-          physician.patients.remove(id, function (err, ch) {
+          physician.patients.remove(id, function(err, ch) {
             verify(physician);
           });
         });
       });
 
       function verify(physician) {
-        physician.patients.exists(id, function (err, flag) {
+        physician.patients.exists(id, function(err, flag) {
           should.not.exist(err);
           flag.should.be.eql(false);
           done();
@@ -1093,15 +1093,15 @@ describe('relations', function () {
       }
     });
 
-    it('should allow to remove connection with instance with promises', function (done) {
+    it('should allow to remove connection with instance with promises', function(done) {
       var id;
       Physician.create()
-      .then(function (physician) {
-        return physician.patients.create({name: 'a'})
-        .then(function (patient) {
+      .then(function(physician) {
+        return physician.patients.create({ name: 'a' })
+        .then(function(patient) {
           id = patient.id;
           return physician.patients.remove(id)
-          .then(function (ch) {
+          .then(function(ch) {
             return verify(physician);
           });
         });
@@ -1109,16 +1109,16 @@ describe('relations', function () {
 
       function verify(physician) {
         return physician.patients.exists(id)
-        .then(function (flag) {
+        .then(function(flag) {
           flag.should.be.eql(false);
           done();
         });
       }
     });
 
-    beforeEach(function (done) {
-      Appointment.destroyAll(function (err) {
-        Physician.destroyAll(function (err) {
+    beforeEach(function(done) {
+      Appointment.destroyAll(function(err) {
+        Physician.destroyAll(function(err) {
           Patient.destroyAll(done);
         });
       });
@@ -1126,116 +1126,116 @@ describe('relations', function () {
 
   });
 
-  describe('hasMany through - collect', function () {
+  describe('hasMany through - collect', function() {
     var Physician, Patient, Appointment, Address;
 
-    beforeEach(function (done) {
+    beforeEach(function(done) {
       // db = getSchema();
-      Physician = db.define('Physician', {name: String});
-      Patient = db.define('Patient', {name: String});
-      Appointment = db.define('Appointment', {date: {type: Date,
-        default: function () {
+      Physician = db.define('Physician', { name: String });
+      Patient = db.define('Patient', { name: String });
+      Appointment = db.define('Appointment', { date: { type: Date,
+        default: function() {
           return new Date();
-        }}});
-      Address = db.define('Address', {name: String});
+        } }});
+      Address = db.define('Address', { name: String });
 
       db.automigrate(['Physician', 'Patient', 'Appointment', 'Address'], done);
     });
 
-    describe('with default options', function () {
-      it('can determine the collect by modelTo\'s name as default', function () {
-        Physician.hasMany(Patient, {through: Appointment});
-        Patient.hasMany(Physician, {through: Appointment, as: 'yyy'});
+    describe('with default options', function() {
+      it('can determine the collect by modelTo\'s name as default', function() {
+        Physician.hasMany(Patient, { through: Appointment });
+        Patient.hasMany(Physician, { through: Appointment, as: 'yyy' });
         Patient.belongsTo(Address);
         Appointment.belongsTo(Physician);
         Appointment.belongsTo(Patient);
-        var physician = new Physician({id: 1});
+        var physician = new Physician({ id: 1 });
         var scope1 = physician.patients._scope;
         scope1.should.have.property('collect', 'patient');
         scope1.should.have.property('include', 'patient');
-        var patient = new Patient({id: 1});
+        var patient = new Patient({ id: 1 });
         var scope2 = patient.yyy._scope;
         scope2.should.have.property('collect', 'physician');
         scope2.should.have.property('include', 'physician');
       });
     });
 
-    describe('when custom reverse belongsTo names for both sides', function () {
-      it('can determine the collect via keyThrough', function () {
-        Physician.hasMany(Patient, {through: Appointment, foreignKey: 'fooId', keyThrough: 'barId'});
-        Patient.hasMany(Physician, {through: Appointment, foreignKey: 'barId', keyThrough: 'fooId', as: 'yyy'});
-        Appointment.belongsTo(Physician, {as: 'foo'});
-        Appointment.belongsTo(Patient, {as: 'bar'});
+    describe('when custom reverse belongsTo names for both sides', function() {
+      it('can determine the collect via keyThrough', function() {
+        Physician.hasMany(Patient, { through: Appointment, foreignKey: 'fooId', keyThrough: 'barId' });
+        Patient.hasMany(Physician, { through: Appointment, foreignKey: 'barId', keyThrough: 'fooId', as: 'yyy' });
+        Appointment.belongsTo(Physician, { as: 'foo' });
+        Appointment.belongsTo(Patient, { as: 'bar' });
         Patient.belongsTo(Address); // jam.
-        Appointment.belongsTo(Patient, {as: 'car'}); // jam. Should we complain in this case???
+        Appointment.belongsTo(Patient, { as: 'car' }); // jam. Should we complain in this case???
 
-        var physician = new Physician({id: 1});
+        var physician = new Physician({ id: 1 });
         var scope1 = physician.patients._scope;
         scope1.should.have.property('collect', 'bar');
         scope1.should.have.property('include', 'bar');
-        var patient = new Patient({id: 1});
+        var patient = new Patient({ id: 1 });
         var scope2 = patient.yyy._scope;
         scope2.should.have.property('collect', 'foo');
         scope2.should.have.property('include', 'foo');
       });
 
-      it('can determine the collect via modelTo name', function () {
-        Physician.hasMany(Patient, {through: Appointment});
-        Patient.hasMany(Physician, {through: Appointment, as: 'yyy'});
-        Appointment.belongsTo(Physician, {as: 'foo', foreignKey: 'physicianId'});
-        Appointment.belongsTo(Patient, {as: 'bar', foreignKey: 'patientId'});
+      it('can determine the collect via modelTo name', function() {
+        Physician.hasMany(Patient, { through: Appointment });
+        Patient.hasMany(Physician, { through: Appointment, as: 'yyy' });
+        Appointment.belongsTo(Physician, { as: 'foo', foreignKey: 'physicianId' });
+        Appointment.belongsTo(Patient, { as: 'bar', foreignKey: 'patientId' });
         Patient.belongsTo(Address); // jam.
 
-        var physician = new Physician({id: 1});
+        var physician = new Physician({ id: 1 });
         var scope1 = physician.patients._scope;
         scope1.should.have.property('collect', 'bar');
         scope1.should.have.property('include', 'bar');
-        var patient = new Patient({id: 1});
+        var patient = new Patient({ id: 1 });
         var scope2 = patient.yyy._scope;
         scope2.should.have.property('collect', 'foo');
         scope2.should.have.property('include', 'foo');
       });
 
-      it('can determine the collect via modelTo name (with jams)', function () {
-        Physician.hasMany(Patient, {through: Appointment});
-        Patient.hasMany(Physician, {through: Appointment, as: 'yyy'});
-        Appointment.belongsTo(Physician, {as: 'foo', foreignKey: 'physicianId'});
-        Appointment.belongsTo(Patient, {as: 'bar', foreignKey: 'patientId'});
+      it('can determine the collect via modelTo name (with jams)', function() {
+        Physician.hasMany(Patient, { through: Appointment });
+        Patient.hasMany(Physician, { through: Appointment, as: 'yyy' });
+        Appointment.belongsTo(Physician, { as: 'foo', foreignKey: 'physicianId' });
+        Appointment.belongsTo(Patient, { as: 'bar', foreignKey: 'patientId' });
         Patient.belongsTo(Address); // jam.
-        Appointment.belongsTo(Physician, {as: 'goo', foreignKey: 'physicianId'}); // jam. Should we complain in this case???
-        Appointment.belongsTo(Patient, {as: 'car', foreignKey: 'patientId'}); // jam. Should we complain in this case???
+        Appointment.belongsTo(Physician, { as: 'goo', foreignKey: 'physicianId' }); // jam. Should we complain in this case???
+        Appointment.belongsTo(Patient, { as: 'car', foreignKey: 'patientId' }); // jam. Should we complain in this case???
 
-        var physician = new Physician({id: 1});
+        var physician = new Physician({ id: 1 });
         var scope1 = physician.patients._scope;
         scope1.should.have.property('collect', 'bar');
         scope1.should.have.property('include', 'bar');
-        var patient = new Patient({id: 1});
+        var patient = new Patient({ id: 1 });
         var scope2 = patient.yyy._scope;
         scope2.should.have.property('collect', 'foo'); // first matched relation
         scope2.should.have.property('include', 'foo'); // first matched relation
       });
     });
 
-    describe('when custom reverse belongsTo name for one side only', function () {
+    describe('when custom reverse belongsTo name for one side only', function() {
 
-      beforeEach(function () {
-        Physician.hasMany(Patient, {as: 'xxx', through: Appointment, foreignKey: 'fooId'});
-        Patient.hasMany(Physician, {as: 'yyy', through: Appointment, keyThrough: 'fooId'});
-        Appointment.belongsTo(Physician, {as: 'foo'});
+      beforeEach(function() {
+        Physician.hasMany(Patient, { as: 'xxx', through: Appointment, foreignKey: 'fooId' });
+        Patient.hasMany(Physician, { as: 'yyy', through: Appointment, keyThrough: 'fooId' });
+        Appointment.belongsTo(Physician, { as: 'foo' });
         Appointment.belongsTo(Patient);
         Patient.belongsTo(Address); // jam.
-        Appointment.belongsTo(Physician, {as: 'bar'}); // jam. Should we complain in this case???
+        Appointment.belongsTo(Physician, { as: 'bar' }); // jam. Should we complain in this case???
       });
 
-      it('can determine the collect via model name', function () {
-        var physician = new Physician({id: 1});
+      it('can determine the collect via model name', function() {
+        var physician = new Physician({ id: 1 });
         var scope1 = physician.xxx._scope;
         scope1.should.have.property('collect', 'patient');
         scope1.should.have.property('include', 'patient');
       });
 
-      it('can determine the collect via keyThrough', function () {
-        var patient = new Patient({id: 1});
+      it('can determine the collect via keyThrough', function() {
+        var patient = new Patient({ id: 1 });
         var scope2 = patient.yyy._scope;
         scope2.should.have.property('collect', 'foo');
         scope2.should.have.property('include', 'foo');
@@ -1243,32 +1243,32 @@ describe('relations', function () {
     });
   });
 
-  describe('hasMany through bi-directional relations on the same model', function () {
+  describe('hasMany through bi-directional relations on the same model', function() {
     var User, Follow, Address;
 
-    before(function (done) {
+    before(function(done) {
       // db = getSchema();
-      User = db.define('User', {name: String});
-      Follow = db.define('Follow', {date: {type: Date,
-        default: function () {
+      User = db.define('User', { name: String });
+      Follow = db.define('Follow', { date: { type: Date,
+        default: function() {
           return new Date();
-        }}});
-      Address = db.define('Address', {name: String});
+        } }});
+      Address = db.define('Address', { name: String });
 
-      User.hasMany(User, {as: 'followers', foreignKey: 'followeeId', keyThrough: 'followerId', through: Follow});
-      User.hasMany(User, {as: 'following', foreignKey: 'followerId', keyThrough: 'followeeId', through: Follow});
+      User.hasMany(User, { as: 'followers', foreignKey: 'followeeId', keyThrough: 'followerId', through: Follow });
+      User.hasMany(User, { as: 'following', foreignKey: 'followerId', keyThrough: 'followeeId', through: Follow });
       User.belongsTo(Address);
-      Follow.belongsTo(User, {as: 'follower'});
-      Follow.belongsTo(User, {as: 'followee'});
+      Follow.belongsTo(User, { as: 'follower' });
+      Follow.belongsTo(User, { as: 'followee' });
       db.automigrate(['User', 'Follow'], done);
     });
 
 
     it('should set foreignKeys of through model correctly in first relation',
-      function (done) {
-        var follower = new User({id: 1});
-        var followee = new User({id: 2});
-        followee.followers.add(follower, function (err, throughInst) {
+      function(done) {
+        var follower = new User({ id: 1 });
+        var followee = new User({ id: 2 });
+        followee.followers.add(follower, function(err, throughInst) {
           should.not.exist(err);
           should.exist(throughInst);
           throughInst.followerId.should.eql(follower.id);
@@ -1278,10 +1278,10 @@ describe('relations', function () {
       });
 
     it('should set foreignKeys of through model correctly in second relation',
-      function (done) {
-        var follower = new User({id: 3});
-        var followee = new User({id: 4});
-        follower.following.add(followee, function (err, throughInst) {
+      function(done) {
+        var follower = new User({ id: 3 });
+        var followee = new User({ id: 4 });
+        follower.following.add(followee, function(err, throughInst) {
           should.not.exist(err);
           should.exist(throughInst);
           throughInst.followeeId.should.eql(followee.id);
@@ -1291,30 +1291,30 @@ describe('relations', function () {
       });
   });
 
-  describe('hasMany through - between same models', function () {
+  describe('hasMany through - between same models', function() {
     var User, Follow, Address;
 
-    before(function (done) {
+    before(function(done) {
       // db = getSchema();
-      User = db.define('User', {name: String});
-      Follow = db.define('Follow', {date: {type: Date,
-        default: function () {
+      User = db.define('User', { name: String });
+      Follow = db.define('Follow', { date: { type: Date,
+        default: function() {
           return new Date();
-        }}});
-      Address = db.define('Address', {name: String});
+        } }});
+      Address = db.define('Address', { name: String });
 
-      User.hasMany(User, {as: 'followers', foreignKey: 'followeeId', keyThrough: 'followerId', through: Follow});
-      User.hasMany(User, {as: 'following', foreignKey: 'followerId', keyThrough: 'followeeId', through: Follow});
+      User.hasMany(User, { as: 'followers', foreignKey: 'followeeId', keyThrough: 'followerId', through: Follow });
+      User.hasMany(User, { as: 'following', foreignKey: 'followerId', keyThrough: 'followeeId', through: Follow });
       User.belongsTo(Address);
-      Follow.belongsTo(User, {as: 'follower'});
-      Follow.belongsTo(User, {as: 'followee'});
+      Follow.belongsTo(User, { as: 'follower' });
+      Follow.belongsTo(User, { as: 'followee' });
       db.automigrate(['User', 'Follow', 'Address'], done);
     });
 
-    it('should set the keyThrough and the foreignKey', function (done) {
-      var user = new User({id: 1});
-      var user2 = new User({id: 2});
-      user.following.add(user2, function (err, f) {
+    it('should set the keyThrough and the foreignKey', function(done) {
+      var user = new User({ id: 1 });
+      var user2 = new User({ id: 2 });
+      user.following.add(user2, function(err, f) {
         should.not.exist(err);
         should.exist(f);
         f.followeeId.should.eql(user2.id);
@@ -1323,8 +1323,8 @@ describe('relations', function () {
       });
     });
 
-    it('can determine the collect via keyThrough for each side', function () {
-      var user = new User({id: 1});
+    it('can determine the collect via keyThrough for each side', function() {
+      var user = new User({ id: 1 });
       var scope1 = user.followers._scope;
       scope1.should.have.property('collect', 'follower');
       scope1.should.have.property('include', 'follower');
@@ -1334,15 +1334,15 @@ describe('relations', function () {
     });
   });
 
-  describe('hasMany with properties', function () {
-    it('can be declared with properties', function (done) {
-      Book.hasMany(Chapter, { properties: { type: 'bookType' } });
+  describe('hasMany with properties', function() {
+    it('can be declared with properties', function(done) {
+      Book.hasMany(Chapter, { properties: { type: 'bookType' }});
       db.automigrate(['Book', 'Chapter'], done);
     });
 
-    it('should create record on scope', function (done) {
-      Book.create({ type: 'fiction' }, function (err, book) {
-        book.chapters.create(function (err, c) {
+    it('should create record on scope', function(done) {
+      Book.create({ type: 'fiction' }, function(err, book) {
+        book.chapters.create(function(err, c) {
           should.not.exist(err);
           should.exist(c);
           c.bookId.should.eql(book.id);
@@ -1352,11 +1352,11 @@ describe('relations', function () {
       });
     });
 
-    it('should create record on scope with promises', function (done) {
+    it('should create record on scope with promises', function(done) {
       Book.create({ type: 'fiction' })
-      .then(function (book) {
+      .then(function(book) {
         return book.chapters.create()
-        .then(function (c) {
+        .then(function(c) {
           should.exist(c);
           c.bookId.should.eql(book.id);
           c.bookType.should.equal('fiction');
@@ -1366,11 +1366,11 @@ describe('relations', function () {
     });
   });
 
-  describe('hasMany with scope and properties', function () {
-    it('can be declared with properties', function (done) {
+  describe('hasMany with scope and properties', function() {
+    it('can be declared with properties', function(done) {
       // db = getSchema();
-      Category = db.define('Category', {name: String, jobType: String});
-      Job = db.define('Job', {name: String, type: String});
+      Category = db.define('Category', { name: String, jobType: String });
+      Job = db.define('Job', { name: String, type: String });
 
       Category.hasMany(Job, {
         properties: function(inst, target) {
@@ -1380,13 +1380,13 @@ describe('relations', function () {
         scope: function(inst, filter) {
           var m = this.properties(inst); // re-use properties
           if (m) return { where: m };
-        }
+        },
       });
       db.automigrate(['Category', 'Job'], done);
     });
 
-    it('should create record on scope', function (done) {
-      Category.create(function (err, c) {
+    it('should create record on scope', function(done) {
+      Category.create(function(err, c) {
         should.not.exists(err);
         c.jobs.create({ type: 'book' }, function(err, p) {
           should.not.exists(err);
@@ -1402,15 +1402,15 @@ describe('relations', function () {
       });
     });
 
-    it('should create record on scope with promises', function (done) {
+    it('should create record on scope with promises', function(done) {
       Category.create()
-      .then(function (c) {
+      .then(function(c) {
         return c.jobs.create({ type: 'book' })
-        .then(function (p) {
+        .then(function(p) {
           p.categoryId.should.eql(c.id);
           p.type.should.equal('book');
           return c.jobs.create({ type: 'widget' })
-          .then(function (p) {
+          .then(function(p) {
             p.categoryId.should.eql(c.id);
             p.type.should.equal('widget');
             done();
@@ -1419,8 +1419,8 @@ describe('relations', function () {
       }).catch(done);
     });
 
-    it('should find records on scope', function (done) {
-      Category.findOne(function (err, c) {
+    it('should find records on scope', function(done) {
+      Category.findOne(function(err, c) {
         should.not.exists(err);
         c.jobs(function(err, jobs) {
           should.not.exists(err);
@@ -1430,10 +1430,10 @@ describe('relations', function () {
       });
     });
 
-    it('should find records on scope with promises', function (done) {
+    it('should find records on scope with promises', function(done) {
       Category.findOne()
-      .then(function (c) {
-        return c.jobs.getAsync()
+      .then(function(c) {
+        return c.jobs.getAsync();
       })
       .then(function(jobs) {
         jobs.should.have.length(2);
@@ -1442,10 +1442,10 @@ describe('relations', function () {
       .catch(done);
     });
 
-    it('should find record on scope - filtered', function (done) {
-      Category.findOne(function (err, c) {
+    it('should find record on scope - filtered', function(done) {
+      Category.findOne(function(err, c) {
         should.not.exists(err);
-        c.jobs({ where: { type: 'book' } }, function(err, jobs) {
+        c.jobs({ where: { type: 'book' }}, function(err, jobs) {
           should.not.exists(err);
           jobs.should.have.length(1);
           jobs[0].type.should.equal('book');
@@ -1454,10 +1454,10 @@ describe('relations', function () {
       });
     });
 
-    it('should find record on scope with promises - filtered', function (done) {
+    it('should find record on scope with promises - filtered', function(done) {
       Category.findOne()
-      .then(function (c) {
-        return c.jobs.getAsync({ where: { type: 'book' } })
+      .then(function(c) {
+        return c.jobs.getAsync({ where: { type: 'book' }});
       })
       .then(function(jobs) {
         jobs.should.have.length(1);
@@ -1476,8 +1476,8 @@ describe('relations', function () {
     //
     // The code below simulates this.
 
-    it('should create record on scope - properties', function (done) {
-      Category.findOne(function (err, c) {
+    it('should create record on scope - properties', function(done) {
+      Category.findOne(function(err, c) {
         should.not.exists(err);
         c.jobType = 'tool'; // temporary
         c.jobs.create(function(err, p) {
@@ -1488,8 +1488,8 @@ describe('relations', function () {
       });
     });
 
-    it('should find records on scope', function (done) {
-      Category.findOne(function (err, c) {
+    it('should find records on scope', function(done) {
+      Category.findOne(function(err, c) {
         should.not.exists(err);
         c.jobs(function(err, jobs) {
           should.not.exists(err);
@@ -1499,8 +1499,8 @@ describe('relations', function () {
       });
     });
 
-    it('should find record on scope - scoped', function (done) {
-      Category.findOne(function (err, c) {
+    it('should find record on scope - scoped', function(done) {
+      Category.findOne(function(err, c) {
         should.not.exists(err);
         c.jobType = 'book'; // temporary, for scoping
         c.jobs(function(err, jobs) {
@@ -1512,8 +1512,8 @@ describe('relations', function () {
       });
     });
 
-    it('should find record on scope - scoped', function (done) {
-      Category.findOne(function (err, c) {
+    it('should find record on scope - scoped', function(done) {
+      Category.findOne(function(err, c) {
         should.not.exists(err);
         c.jobType = 'tool'; // temporary, for scoping
         c.jobs(function(err, jobs) {
@@ -1525,8 +1525,8 @@ describe('relations', function () {
       });
     });
 
-    it('should find count of records on scope - scoped', function (done) {
-      Category.findOne(function (err, c) {
+    it('should find count of records on scope - scoped', function(done) {
+      Category.findOne(function(err, c) {
         should.not.exists(err);
         c.jobType = 'tool'; // temporary, for scoping
         c.jobs.count(function(err, count) {
@@ -1537,8 +1537,8 @@ describe('relations', function () {
       });
     });
 
-    it('should delete records on scope - scoped', function (done) {
-      Category.findOne(function (err, c) {
+    it('should delete records on scope - scoped', function(done) {
+      Category.findOne(function(err, c) {
         should.not.exists(err);
         c.jobType = 'tool'; // temporary, for scoping
         c.jobs.destroyAll(function(err, result) {
@@ -1547,8 +1547,8 @@ describe('relations', function () {
       });
     });
 
-    it('should find record on scope - verify', function (done) {
-      Category.findOne(function (err, c) {
+    it('should find record on scope - verify', function(done) {
+      Category.findOne(function(err, c) {
         should.not.exists(err);
         c.jobs(function(err, jobs) {
           should.not.exists(err);
@@ -1560,27 +1560,27 @@ describe('relations', function () {
 
   });
 
-  describe('polymorphic hasOne', function () {
-    before(function (done) {
+  describe('polymorphic hasOne', function() {
+    before(function(done) {
       // db = getSchema();
-      Picture = db.define('Picture', {name: String});
-      Author = db.define('Author', {name: String});
-      Reader = db.define('Reader', {name: String});
+      Picture = db.define('Picture', { name: String });
+      Author = db.define('Author', { name: String });
+      Reader = db.define('Reader', { name: String });
 
       db.automigrate(['Picture', 'Author', 'Reader'], done);
     });
 
-    it('can be declared', function (done) {
+    it('can be declared', function(done) {
       Author.hasOne(Picture, { as: 'avatar', polymorphic: 'imageable' });
       Reader.hasOne(Picture, { as: 'mugshot', polymorphic: 'imageable' });
       Picture.belongsTo('imageable', { polymorphic: true });
       db.automigrate(['Picture', 'Author', 'Reader'], done);
     });
 
-    it('should create polymorphic relation - author', function (done) {
-      Author.create({name: 'Author 1' }, function (err, author) {
+    it('should create polymorphic relation - author', function(done) {
+      Author.create({ name: 'Author 1' }, function(err, author) {
         should.not.exists(err);
-        author.avatar.create({ name: 'Avatar' }, function (err, p) {
+        author.avatar.create({ name: 'Avatar' }, function(err, p) {
           should.not.exist(err);
           should.exist(p);
           p.imageableId.should.eql(author.id);
@@ -1590,11 +1590,11 @@ describe('relations', function () {
       });
     });
 
-    it('should create polymorphic relation with promises - author', function (done) {
-      Author.create({name: 'Author 1' })
-      .then(function (author) {
+    it('should create polymorphic relation with promises - author', function(done) {
+      Author.create({ name: 'Author 1' })
+      .then(function(author) {
         return author.avatar.create({ name: 'Avatar' })
-        .then(function (p) {
+        .then(function(p) {
           should.exist(p);
           p.imageableId.should.eql(author.id);
           p.imageableType.should.equal('Author');
@@ -1603,10 +1603,10 @@ describe('relations', function () {
       }).catch(done);
     });
 
-    it('should create polymorphic relation - reader', function (done) {
-      Reader.create({name: 'Reader 1' }, function (err, reader) {
+    it('should create polymorphic relation - reader', function(done) {
+      Reader.create({ name: 'Reader 1' }, function(err, reader) {
         should.not.exists(err);
-        reader.mugshot.create({ name: 'Mugshot' }, function (err, p) {
+        reader.mugshot.create({ name: 'Mugshot' }, function(err, p) {
           should.not.exist(err);
           should.exist(p);
           p.imageableId.should.eql(reader.id);
@@ -1616,10 +1616,10 @@ describe('relations', function () {
       });
     });
 
-    it('should find polymorphic relation - author', function (done) {
-      Author.findOne(function (err, author) {
+    it('should find polymorphic relation - author', function(done) {
+      Author.findOne(function(err, author) {
         should.not.exists(err);
-        author.avatar(function (err, p) {
+        author.avatar(function(err, p) {
           should.not.exist(err);
 
           var avatar = author.avatar();
@@ -1633,10 +1633,10 @@ describe('relations', function () {
       });
     });
 
-    it('should find polymorphic relation - reader', function (done) {
-      Reader.findOne(function (err, reader) {
+    it('should find polymorphic relation - reader', function(done) {
+      Reader.findOne(function(err, reader) {
         should.not.exists(err);
-        reader.mugshot(function (err, p) {
+        reader.mugshot(function(err, p) {
           should.not.exist(err);
           p.name.should.equal('Mugshot');
           p.imageableId.should.eql(reader.id);
@@ -1646,8 +1646,8 @@ describe('relations', function () {
       });
     });
 
-    it('should include polymorphic relation - author', function (done) {
-      Author.findOne({include: 'avatar'}, function (err, author) {
+    it('should include polymorphic relation - author', function(done) {
+      Author.findOne({ include: 'avatar' }, function(err, author) {
         should.not.exists(err);
         var avatar = author.avatar();
         should.exist(avatar);
@@ -1656,11 +1656,11 @@ describe('relations', function () {
       });
     });
 
-    it('should find polymorphic relation with promises - reader', function (done) {
+    it('should find polymorphic relation with promises - reader', function(done) {
       Reader.findOne()
-      .then(function (reader) {
+      .then(function(reader) {
         return reader.mugshot.getAsync()
-        .then(function (p) {
+        .then(function(p) {
           p.name.should.equal('Mugshot');
           p.imageableId.should.eql(reader.id);
           p.imageableType.should.equal('Reader');
@@ -1669,10 +1669,10 @@ describe('relations', function () {
       }).catch(done);
     });
 
-    it('should find inverse polymorphic relation - author', function (done) {
-      Picture.findOne({ where: { name: 'Avatar' } }, function (err, p) {
+    it('should find inverse polymorphic relation - author', function(done) {
+      Picture.findOne({ where: { name: 'Avatar' }}, function(err, p) {
         should.not.exists(err);
-        p.imageable(function (err, imageable) {
+        p.imageable(function(err, imageable) {
           should.not.exist(err);
           imageable.should.be.instanceof(Author);
           imageable.name.should.equal('Author 1');
@@ -1681,9 +1681,9 @@ describe('relations', function () {
       });
     });
 
-    it('should include inverse polymorphic relation - author', function (done) {
-      Picture.findOne({where: {name: 'Avatar'}, include: 'imageable'},
-        function (err, p) {
+    it('should include inverse polymorphic relation - author', function(done) {
+      Picture.findOne({ where: { name: 'Avatar' }, include: 'imageable' },
+        function(err, p) {
           should.not.exists(err);
           var imageable = p.imageable();
           should.exist(imageable);
@@ -1693,10 +1693,10 @@ describe('relations', function () {
         });
     });
 
-    it('should find inverse polymorphic relation - reader', function (done) {
-      Picture.findOne({ where: { name: 'Mugshot' } }, function (err, p) {
+    it('should find inverse polymorphic relation - reader', function(done) {
+      Picture.findOne({ where: { name: 'Mugshot' }}, function(err, p) {
         should.not.exists(err);
-        p.imageable(function (err, imageable) {
+        p.imageable(function(err, imageable) {
           should.not.exist(err);
           imageable.should.be.instanceof(Reader);
           imageable.name.should.equal('Reader 1');
@@ -1707,52 +1707,52 @@ describe('relations', function () {
 
   });
 
-  describe('polymorphic hasOne with non standard ids', function () {
-    before(function (done) {
+  describe('polymorphic hasOne with non standard ids', function() {
+    before(function(done) {
       // db = getSchema();
-      Picture = db.define('Picture', {name: String});
+      Picture = db.define('Picture', { name: String });
       Author = db.define('Author', {
-        username: {type: String, id: true, generated: true},
-        name: String
+        username: { type: String, id: true, generated: true },
+        name: String,
       });
       Reader = db.define('Reader', {
-        username: {type: String, id: true, generated: true},
-        name: String
+        username: { type: String, id: true, generated: true },
+        name: String,
       });
 
       db.automigrate(['Picture', 'Author', 'Reader'], done);
     });
 
-    it('can be declared with non standard foreign key', function (done) {
+    it('can be declared with non standard foreign key', function(done) {
       Author.hasOne(Picture, {
         as: 'avatar',
         polymorphic: {
           foreignKey: 'oid',
-          discriminator: 'type'
-        }
+          discriminator: 'type',
+        },
       });
       Reader.hasOne(Picture, {
         as: 'mugshot',
         polymorphic: {
           foreignKey: 'oid',
-          discriminator: 'type'
-        }
+          discriminator: 'type',
+        },
       });
       Picture.belongsTo('owner', {
         idName: 'username',
         polymorphic: {
           idType: Author.definition.properties.username.type,
           foreignKey: 'oid',
-          discriminator: 'type'
-        }
+          discriminator: 'type',
+        },
       });
       db.automigrate(['Picture', 'Author', 'Reader'], done);
     });
 
-    it('should create polymorphic relation - author', function (done) {
-      Author.create({name: 'Author 1' }, function (err, author) {
+    it('should create polymorphic relation - author', function(done) {
+      Author.create({ name: 'Author 1' }, function(err, author) {
         should.not.exists(err);
-        author.avatar.create({ name: 'Avatar' }, function (err, p) {
+        author.avatar.create({ name: 'Avatar' }, function(err, p) {
           should.not.exist(err);
           should.exist(p);
           p.oid.toString().should.equal(author.username.toString());
@@ -1762,11 +1762,11 @@ describe('relations', function () {
       });
     });
 
-    it('should create polymorphic relation with promises - author', function (done) {
-      Author.create({name: 'Author 1' })
-      .then(function (author) {
+    it('should create polymorphic relation with promises - author', function(done) {
+      Author.create({ name: 'Author 1' })
+      .then(function(author) {
         return author.avatar.create({ name: 'Avatar' })
-        .then(function (p) {
+        .then(function(p) {
           should.exist(p);
           p.oid.toString().should.equal(author.username.toString());
           p.type.should.equal('Author');
@@ -1775,10 +1775,10 @@ describe('relations', function () {
       }).catch(done);
     });
 
-    it('should create polymorphic relation - reader', function (done) {
-      Reader.create({name: 'Reader 1' }, function (err, reader) {
+    it('should create polymorphic relation - reader', function(done) {
+      Reader.create({ name: 'Reader 1' }, function(err, reader) {
         should.not.exists(err);
-        reader.mugshot.create({ name: 'Mugshot' }, function (err, p) {
+        reader.mugshot.create({ name: 'Mugshot' }, function(err, p) {
           should.not.exist(err);
           should.exist(p);
           p.oid.toString().should.equal(reader.username.toString());
@@ -1788,10 +1788,10 @@ describe('relations', function () {
       });
     });
 
-    it('should find polymorphic relation - author', function (done) {
-      Author.findOne(function (err, author) {
+    it('should find polymorphic relation - author', function(done) {
+      Author.findOne(function(err, author) {
         should.not.exists(err);
-        author.avatar(function (err, p) {
+        author.avatar(function(err, p) {
           should.not.exist(err);
 
           var avatar = author.avatar();
@@ -1805,10 +1805,10 @@ describe('relations', function () {
       });
     });
 
-    it('should find polymorphic relation - reader', function (done) {
-      Reader.findOne(function (err, reader) {
+    it('should find polymorphic relation - reader', function(done) {
+      Reader.findOne(function(err, reader) {
         should.not.exists(err);
-        reader.mugshot(function (err, p) {
+        reader.mugshot(function(err, p) {
           should.not.exist(err);
           p.name.should.equal('Mugshot');
           p.oid.toString().should.equal(reader.username.toString());
@@ -1818,10 +1818,10 @@ describe('relations', function () {
       });
     });
 
-    it('should find inverse polymorphic relation - author', function (done) {
-      Picture.findOne({ where: { name: 'Avatar' } }, function (err, p) {
+    it('should find inverse polymorphic relation - author', function(done) {
+      Picture.findOne({ where: { name: 'Avatar' }}, function(err, p) {
         should.not.exists(err);
-        p.owner(function (err, owner) {
+        p.owner(function(err, owner) {
           should.not.exist(err);
           owner.should.be.instanceof(Author);
           owner.name.should.equal('Author 1');
@@ -1830,10 +1830,10 @@ describe('relations', function () {
       });
     });
 
-    it('should find inverse polymorphic relation - reader', function (done) {
-      Picture.findOne({ where: { name: 'Mugshot' } }, function (err, p) {
+    it('should find inverse polymorphic relation - reader', function(done) {
+      Picture.findOne({ where: { name: 'Mugshot' }}, function(err, p) {
         should.not.exists(err);
-        p.owner(function (err, owner) {
+        p.owner(function(err, owner) {
           should.not.exist(err);
           owner.should.be.instanceof(Reader);
           owner.name.should.equal('Reader 1');
@@ -1842,9 +1842,9 @@ describe('relations', function () {
       });
     });
 
-    it('should include polymorphic relation - reader', function (done) {
-      Reader.findOne({include: 'mugshot'},
-        function (err, reader) {
+    it('should include polymorphic relation - reader', function(done) {
+      Reader.findOne({ include: 'mugshot' },
+        function(err, reader) {
           should.not.exists(err);
           var mugshot = reader.mugshot();
           should.exist(mugshot);
@@ -1853,9 +1853,9 @@ describe('relations', function () {
         });
     });
 
-    it('should include inverse polymorphic relation - reader', function (done) {
-      Picture.findOne({where: {name: 'Mugshot'}, include: 'owner'},
-        function (err, p) {
+    it('should include inverse polymorphic relation - reader', function(done) {
+      Picture.findOne({ where: { name: 'Mugshot' }, include: 'owner' },
+        function(err, p) {
           should.not.exists(err);
           var owner = p.owner();
           should.exist(owner);
@@ -1866,22 +1866,22 @@ describe('relations', function () {
     });
   });
 
-  describe('polymorphic hasMany', function () {
-    before(function (done) {
+  describe('polymorphic hasMany', function() {
+    before(function(done) {
       // db = getSchema();
-      Picture = db.define('Picture', {name: String});
-      Author = db.define('Author', {name: String});
-      Reader = db.define('Reader', {name: String});
+      Picture = db.define('Picture', { name: String });
+      Author = db.define('Author', { name: String });
+      Reader = db.define('Reader', { name: String });
 
       db.automigrate(['Picture', 'Author', 'Reader'], done);
     });
 
-    it('can be declared', function (done) {
+    it('can be declared', function(done) {
       Author.hasMany(Picture, { polymorphic: 'imageable' });
       Reader.hasMany(Picture, { polymorphic: { // alt syntax
         as: 'imageable', foreignKey: 'imageableId',
-        discriminator: 'imageableType'
-      } });
+        discriminator: 'imageableType',
+      }});
       Picture.belongsTo('imageable', { polymorphic: true });
 
       Author.relations['pictures'].toJSON().should.eql({
@@ -1895,8 +1895,8 @@ describe('relations', function () {
         polymorphic: {
           as: 'imageable',
           foreignKey: 'imageableId',
-          discriminator: 'imageableType'
-        }
+          discriminator: 'imageableType',
+        },
       });
 
       Picture.relations['imageable'].toJSON().should.eql({
@@ -1910,17 +1910,17 @@ describe('relations', function () {
         polymorphic: {
           as: 'imageable',
           foreignKey: 'imageableId',
-          discriminator: 'imageableType'
-        }
+          discriminator: 'imageableType',
+        },
       });
 
       db.automigrate(['Picture', 'Author', 'Reader'], done);
     });
 
-    it('should create polymorphic relation - author', function (done) {
-      Author.create({ name: 'Author 1' }, function (err, author) {
+    it('should create polymorphic relation - author', function(done) {
+      Author.create({ name: 'Author 1' }, function(err, author) {
         should.not.exists(err);
-        author.pictures.create({ name: 'Author Pic' }, function (err, p) {
+        author.pictures.create({ name: 'Author Pic' }, function(err, p) {
           should.not.exist(err);
           should.exist(p);
           p.imageableId.should.eql(author.id);
@@ -1930,10 +1930,10 @@ describe('relations', function () {
       });
     });
 
-    it('should create polymorphic relation - reader', function (done) {
-      Reader.create({ name: 'Reader 1' }, function (err, reader) {
+    it('should create polymorphic relation - reader', function(done) {
+      Reader.create({ name: 'Reader 1' }, function(err, reader) {
         should.not.exists(err);
-        reader.pictures.create({ name: 'Reader Pic' }, function (err, p) {
+        reader.pictures.create({ name: 'Reader Pic' }, function(err, p) {
           should.not.exist(err);
           should.exist(p);
           p.imageableId.should.eql(reader.id);
@@ -1943,10 +1943,10 @@ describe('relations', function () {
       });
     });
 
-    it('should find polymorphic items - author', function (done) {
-      Author.findOne(function (err, author) {
+    it('should find polymorphic items - author', function(done) {
+      Author.findOne(function(err, author) {
         should.not.exists(err);
-        author.pictures(function (err, pics) {
+        author.pictures(function(err, pics) {
           should.not.exist(err);
 
           var pictures = author.pictures();
@@ -1959,10 +1959,10 @@ describe('relations', function () {
       });
     });
 
-    it('should find polymorphic items - reader', function (done) {
-      Reader.findOne(function (err, reader) {
+    it('should find polymorphic items - reader', function(done) {
+      Reader.findOne(function(err, reader) {
         should.not.exists(err);
-        reader.pictures(function (err, pics) {
+        reader.pictures(function(err, pics) {
           should.not.exist(err);
           pics.should.have.length(1);
           pics[0].name.should.equal('Reader Pic');
@@ -1971,8 +1971,8 @@ describe('relations', function () {
       });
     });
 
-    it('should find the inverse of polymorphic relation - author', function (done) {
-      Picture.findOne({ where: { name: 'Author Pic' } }, function (err, p) {
+    it('should find the inverse of polymorphic relation - author', function(done) {
+      Picture.findOne({ where: { name: 'Author Pic' }}, function(err, p) {
         should.not.exist(err);
         p.imageableType.should.equal('Author');
         p.imageable(function(err, imageable) {
@@ -1984,8 +1984,8 @@ describe('relations', function () {
       });
     });
 
-    it('should find the inverse of polymorphic relation - reader', function (done) {
-      Picture.findOne({ where: { name: 'Reader Pic' } }, function (err, p) {
+    it('should find the inverse of polymorphic relation - reader', function(done) {
+      Picture.findOne({ where: { name: 'Reader Pic' }}, function(err, p) {
         should.not.exist(err);
         p.imageableType.should.equal('Reader');
         p.imageable(function(err, imageable) {
@@ -1997,8 +1997,8 @@ describe('relations', function () {
       });
     });
 
-    it('should include the inverse of polymorphic relation', function (done) {
-      Picture.find({ include: 'imageable' }, function (err, pics) {
+    it('should include the inverse of polymorphic relation', function(done) {
+      Picture.find({ include: 'imageable' }, function(err, pics) {
         should.not.exist(err);
         pics.should.have.length(2);
         pics[0].name.should.equal('Author Pic');
@@ -2020,10 +2020,10 @@ describe('relations', function () {
       });
     });
 
-    it('should find polymorphic items - author', function (done) {
-      Author.findOne({ where: { name: 'Author 2' } }, function (err, author) {
+    it('should find polymorphic items - author', function(done) {
+      Author.findOne({ where: { name: 'Author 2' }}, function(err, author) {
         should.not.exists(err);
-        author.pictures(function (err, pics) {
+        author.pictures(function(err, pics) {
           should.not.exist(err);
           pics.should.have.length(1);
           pics[0].name.should.equal('Sample');
@@ -2032,8 +2032,8 @@ describe('relations', function () {
       });
     });
 
-    it('should find the inverse of polymorphic relation - author', function (done) {
-      Picture.findOne({ where: { name: 'Sample' } }, function (err, p) {
+    it('should find the inverse of polymorphic relation - author', function(done) {
+      Picture.findOne({ where: { name: 'Sample' }}, function(err, p) {
         should.not.exist(err);
         p.imageableType.should.equal('Author');
         p.imageable(function(err, imageable) {
@@ -2046,9 +2046,9 @@ describe('relations', function () {
     });
 
     it('should include the inverse of polymorphic relation - author',
-      function (done) {
-        Picture.findOne({where: {name: 'Sample'}, include: 'imageable'},
-          function (err, p) {
+      function(done) {
+        Picture.findOne({ where: { name: 'Sample' }, include: 'imageable' },
+          function(err, p) {
             should.not.exist(err);
             var imageable = p.imageable();
             should.exist(imageable);
@@ -2060,18 +2060,18 @@ describe('relations', function () {
 
   });
 
-  describe('polymorphic hasAndBelongsToMany through', function () {
-    before(function (done) {
+  describe('polymorphic hasAndBelongsToMany through', function() {
+    before(function(done) {
       // db = getSchema();
-      Picture = db.define('Picture', {name: String});
-      Author = db.define('Author', {name: String});
-      Reader = db.define('Reader', {name: String});
+      Picture = db.define('Picture', { name: String });
+      Author = db.define('Author', { name: String });
+      Reader = db.define('Reader', { name: String });
       PictureLink = db.define('PictureLink', {});
 
       db.automigrate(['Picture', 'Author', 'Reader', 'PictureLink'], done);
     });
 
-    it('can be declared', function (done) {
+    it('can be declared', function(done) {
       Author.hasAndBelongsToMany(Picture, { through: PictureLink, polymorphic: 'imageable' });
       Reader.hasAndBelongsToMany(Picture, { through: PictureLink, polymorphic: 'imageable' });
       // Optionally, define inverse relations:
@@ -2080,21 +2080,21 @@ describe('relations', function () {
       db.automigrate(['Picture', 'Author', 'Reader', 'PictureLink'], done);
     });
 
-    it('can determine the collect via modelTo name', function () {
+    it('can determine the collect via modelTo name', function() {
       Author.hasAndBelongsToMany(Picture, { through: PictureLink, polymorphic: 'imageable' });
       Reader.hasAndBelongsToMany(Picture, { through: PictureLink, polymorphic: 'imageable' });
       // Optionally, define inverse relations:
       Picture.hasMany(Author, { through: PictureLink, polymorphic: 'imageable', invert: true });
       Picture.hasMany(Reader, { through: PictureLink, polymorphic: 'imageable', invert: true });
-      var author = new Author({id: 1});
+      var author = new Author({ id: 1 });
       var scope1 = author.pictures._scope;
       scope1.should.have.property('collect', 'picture');
       scope1.should.have.property('include', 'picture');
-      var reader = new Reader({id: 1});
+      var reader = new Reader({ id: 1 });
       var scope2 = reader.pictures._scope;
       scope2.should.have.property('collect', 'picture');
       scope2.should.have.property('include', 'picture');
-      var picture = new Picture({id: 1});
+      var picture = new Picture({ id: 1 });
       var scope3 = picture.authors._scope;
       scope3.should.have.property('collect', 'imageable');
       scope3.should.have.property('include', 'imageable');
@@ -2104,14 +2104,14 @@ describe('relations', function () {
     });
 
     var author, reader, pictures = [];
-    it('should create polymorphic relation - author', function (done) {
-      Author.create({ name: 'Author 1' }, function (err, a) {
+    it('should create polymorphic relation - author', function(done) {
+      Author.create({ name: 'Author 1' }, function(err, a) {
         should.not.exist(err);
         author = a;
-        author.pictures.create({ name: 'Author Pic 1' }, function (err, p) {
+        author.pictures.create({ name: 'Author Pic 1' }, function(err, p) {
           should.not.exist(err);
           pictures.push(p);
-          author.pictures.create({ name: 'Author Pic 2' }, function (err, p) {
+          author.pictures.create({ name: 'Author Pic 2' }, function(err, p) {
             should.not.exist(err);
             pictures.push(p);
             done();
@@ -2120,11 +2120,11 @@ describe('relations', function () {
       });
     });
 
-    it('should create polymorphic relation - reader', function (done) {
-      Reader.create({ name: 'Reader 1' }, function (err, r) {
+    it('should create polymorphic relation - reader', function(done) {
+      Reader.create({ name: 'Reader 1' }, function(err, r) {
         should.not.exist(err);
         reader = r;
-        reader.pictures.create({ name: 'Reader Pic 1' }, function (err, p) {
+        reader.pictures.create({ name: 'Reader Pic 1' }, function(err, p) {
           should.not.exist(err);
           pictures.push(p);
           done();
@@ -2132,7 +2132,7 @@ describe('relations', function () {
       });
     });
 
-    it('should create polymorphic through model', function (done) {
+    it('should create polymorphic through model', function(done) {
       PictureLink.findOne(function(err, link) {
         should.not.exist(err);
         link.pictureId.should.eql(pictures[0].id); // eql for mongo ObjectId
@@ -2146,7 +2146,7 @@ describe('relations', function () {
       });
     });
 
-    it('should get polymorphic relation through model - author', function (done) {
+    it('should get polymorphic relation through model - author', function(done) {
       Author.findById(author.id, function(err, author) {
         should.not.exist(err);
         author.name.should.equal('Author 1');
@@ -2160,7 +2160,7 @@ describe('relations', function () {
       });
     });
 
-    it('should get polymorphic relation through model - reader', function (done) {
+    it('should get polymorphic relation through model - reader', function(done) {
       Reader.findById(reader.id, function(err, reader) {
         should.not.exist(err);
         reader.name.should.equal('Reader 1');
@@ -2173,7 +2173,7 @@ describe('relations', function () {
       });
     });
 
-    it('should include polymorphic items', function (done) {
+    it('should include polymorphic items', function(done) {
       Author.find({ include: 'pictures' }, function(err, authors) {
         authors.should.have.length(1);
         authors[0].pictures(function(err, pics) {
@@ -2186,9 +2186,9 @@ describe('relations', function () {
     });
 
     var anotherPicture;
-    it('should add to a polymorphic relation - author', function (done) {
+    it('should add to a polymorphic relation - author', function(done) {
       Author.findById(author.id, function(err, author) {
-        Picture.create({name: 'Example' }, function(err, p) {
+        Picture.create({ name: 'Example' }, function(err, p) {
           should.not.exist(err);
           pictures.push(p);
           anotherPicture = p;
@@ -2203,8 +2203,8 @@ describe('relations', function () {
       });
     });
 
-    it('should create polymorphic through model', function (done) {
-      PictureLink.findOne({ where: { pictureId: anotherPicture.id, imageableType: 'Author' } }, function(err, link) {
+    it('should create polymorphic through model', function(done) {
+      PictureLink.findOne({ where: { pictureId: anotherPicture.id, imageableType: 'Author' }}, function(err, link) {
         should.not.exist(err);
         link.pictureId.should.eql(anotherPicture.id);
         link.imageableId.should.eql(author.id);
@@ -2214,29 +2214,29 @@ describe('relations', function () {
     });
 
     var anotherAuthor, anotherReader;
-    it('should add to a polymorphic relation - author', function (done) {
-      Author.create({ name: 'Author 2' }, function (err, author) {
+    it('should add to a polymorphic relation - author', function(done) {
+      Author.create({ name: 'Author 2' }, function(err, author) {
         should.not.exist(err);
         anotherAuthor = author;
-        author.pictures.add(anotherPicture.id, function (err, p) {
+        author.pictures.add(anotherPicture.id, function(err, p) {
           should.not.exist(err);
           done();
         });
       });
     });
 
-    it('should add to a polymorphic relation - author', function (done) {
-      Reader.create({name: 'Reader 2' }, function (err, reader) {
+    it('should add to a polymorphic relation - author', function(done) {
+      Reader.create({ name: 'Reader 2' }, function(err, reader) {
         should.not.exist(err);
         anotherReader = reader;
-        reader.pictures.add(anotherPicture.id, function (err, p) {
+        reader.pictures.add(anotherPicture.id, function(err, p) {
           should.not.exist(err);
           done();
         });
       });
     });
 
-    it('should get the inverse polymorphic relation - author', function (done) {
+    it('should get the inverse polymorphic relation - author', function(done) {
       Picture.findById(anotherPicture.id, function(err, p) {
         p.authors(function(err, authors) {
           authors.should.have.length(2);
@@ -2247,7 +2247,7 @@ describe('relations', function () {
       });
     });
 
-    it('should get the inverse polymorphic relation - reader', function (done) {
+    it('should get the inverse polymorphic relation - reader', function(done) {
       Picture.findById(anotherPicture.id, function(err, p) {
         p.readers(function(err, readers) {
           readers.should.have.length(1);
@@ -2257,7 +2257,7 @@ describe('relations', function () {
       });
     });
 
-    it('should find polymorphic items - author', function (done) {
+    it('should find polymorphic items - author', function(done) {
       Author.findById(author.id, function(err, author) {
         author.pictures(function(err, pics) {
           pics.should.have.length(3);
@@ -2269,7 +2269,7 @@ describe('relations', function () {
       });
     });
 
-    it('should check if polymorphic relation exists - author', function (done) {
+    it('should check if polymorphic relation exists - author', function(done) {
       Author.findById(author.id, function(err, author) {
         author.pictures.exists(anotherPicture.id, function(err, exists) {
           exists.should.be.true;
@@ -2278,7 +2278,7 @@ describe('relations', function () {
       });
     });
 
-    it('should remove from a polymorphic relation - author', function (done) {
+    it('should remove from a polymorphic relation - author', function(done) {
       Author.findById(author.id, function(err, author) {
         author.pictures.remove(anotherPicture.id, function(err) {
           should.not.exist(err);
@@ -2287,7 +2287,7 @@ describe('relations', function () {
       });
     });
 
-    it('should find polymorphic items - author', function (done) {
+    it('should find polymorphic items - author', function(done) {
       Author.findById(author.id, function(err, author) {
         author.pictures(function(err, pics) {
           pics.should.have.length(2);
@@ -2298,7 +2298,7 @@ describe('relations', function () {
       });
     });
 
-    it('should check if polymorphic relation exists - author', function (done) {
+    it('should check if polymorphic relation exists - author', function(done) {
       Author.findById(author.id, function(err, author) {
         author.pictures.exists(7, function(err, exists) {
           exists.should.be.false;
@@ -2307,7 +2307,7 @@ describe('relations', function () {
       });
     });
 
-    it('should create polymorphic item through relation scope', function (done) {
+    it('should create polymorphic item through relation scope', function(done) {
       Picture.findById(anotherPicture.id, function(err, p) {
         p.authors.create({ name: 'Author 3' }, function(err, a) {
           should.not.exist(err);
@@ -2318,10 +2318,10 @@ describe('relations', function () {
       });
     });
 
-    it('should create polymorphic through model - new author', function (done) {
+    it('should create polymorphic through model - new author', function(done) {
       PictureLink.findOne({ where: {
-          pictureId: anotherPicture.id, imageableId: author.id, imageableType: 'Author'
-        } }, function(err, link) {
+        pictureId: anotherPicture.id, imageableId: author.id, imageableType: 'Author',
+      }}, function(err, link) {
         should.not.exist(err);
         link.pictureId.should.eql(anotherPicture.id);
         link.imageableId.should.eql(author.id);
@@ -2330,7 +2330,7 @@ describe('relations', function () {
       });
     });
 
-    it('should find polymorphic items - new author', function (done) {
+    it('should find polymorphic items - new author', function(done) {
       Author.findById(author.id, function(err, author) {
         author.pictures(function(err, pics) {
           pics.should.have.length(1);
@@ -2343,14 +2343,14 @@ describe('relations', function () {
 
   });
 
-  describe('belongsTo', function () {
+  describe('belongsTo', function() {
     var List, Item, Fear, Mind;
 
     var listId, itemId;
 
-    it('can be declared in different ways', function () {
-      List = db.define('List', {name: String});
-      Item = db.define('Item', {name: String});
+    it('can be declared in different ways', function() {
+      List = db.define('List', { name: String });
+      Item = db.define('Item', { name: String });
       Fear = db.define('Fear');
       Mind = db.define('Mind');
 
@@ -2361,7 +2361,7 @@ describe('relations', function () {
 
       // syntax 2 (new)
       Fear.belongsTo('mind', {
-        methods: { check: function() { return true; } }
+        methods: { check: function() { return true; } },
       });
 
       Object.keys((new Fear).toObject()).should.containEql('mindId');
@@ -2373,7 +2373,7 @@ describe('relations', function () {
       var rel = Fear.relations['mind'];
       rel.defineMethod('other', function() {
         return true;
-      })
+      });
     });
 
     it('should have setup a custom method on accessor', function() {
@@ -2384,16 +2384,16 @@ describe('relations', function () {
       f.mind.other().should.be.true;
     });
 
-    it('can be used to query data', function (done) {
-      List.hasMany('todos', {model: Item});
-      db.automigrate(['List', 'Item', 'Fear', 'Mind'], function () {
-        List.create({name: 'List 1'}, function (e, list) {
+    it('can be used to query data', function(done) {
+      List.hasMany('todos', { model: Item });
+      db.automigrate(['List', 'Item', 'Fear', 'Mind'], function() {
+        List.create({ name: 'List 1' }, function(e, list) {
           listId = list.id;
           should.not.exist(e);
           should.exist(list);
-          list.todos.create({name: 'Item 1'},function (err, todo) {
+          list.todos.create({ name: 'Item 1' }, function(err, todo) {
             itemId = todo.id;
-            todo.list(function (e, l) {
+            todo.list(function(e, l) {
               should.not.exist(e);
               should.exist(l);
               l.should.be.an.instanceOf(List);
@@ -2406,16 +2406,16 @@ describe('relations', function () {
       });
     });
 
-    it('can be used to query data with getAsync with callback', function (done) {
-      List.hasMany('todos', {model: Item});
-      db.automigrate(['List', 'Item', 'Fear', 'Find'], function () {
-        List.create({name: 'List 1'}, function (e, list) {
+    it('can be used to query data with getAsync with callback', function(done) {
+      List.hasMany('todos', { model: Item });
+      db.automigrate(['List', 'Item', 'Fear', 'Find'], function() {
+        List.create({ name: 'List 1' }, function(e, list) {
           listId = list.id;
           should.not.exist(e);
           should.exist(list);
-          list.todos.create({name: 'Item 1'},function (err, todo) {
+          list.todos.create({ name: 'Item 1' }, function(err, todo) {
             itemId = todo.id;
-            todo.list.getAsync(function (e, l) {
+            todo.list.getAsync(function(e, l) {
               should.not.exist(e);
               should.exist(l);
               l.should.be.an.instanceOf(List);
@@ -2428,19 +2428,19 @@ describe('relations', function () {
       });
     });
 
-    it('can be used to query data with promises', function (done) {
-      List.hasMany('todos', {model: Item});
-      db.automigrate(['List', 'Item', 'Fear', 'Find'], function () {
-        List.create({name: 'List 1'})
-        .then(function (list) {
+    it('can be used to query data with promises', function(done) {
+      List.hasMany('todos', { model: Item });
+      db.automigrate(['List', 'Item', 'Fear', 'Find'], function() {
+        List.create({ name: 'List 1' })
+        .then(function(list) {
           listId = list.id;
           should.exist(list);
-          return list.todos.create({name: 'Item 1'})
+          return list.todos.create({ name: 'Item 1' });
         })
-        .then(function (todo) {
+        .then(function(todo) {
           itemId = todo.id;
           return todo.list.getAsync()
-          .then(function (l) {
+          .then(function(l) {
             should.exist(l);
             l.should.be.an.instanceOf(List);
             todo.list().id.should.equal(l.id);
@@ -2452,11 +2452,11 @@ describe('relations', function () {
       });
     });
 
-    it('could accept objects when creating on scope', function (done) {
-      List.create(function (e, list) {
+    it('could accept objects when creating on scope', function(done) {
+      List.create(function(e, list) {
         should.not.exist(e);
         should.exist(list);
-        Item.create({list: list}, function (err, item) {
+        Item.create({ list: list }, function(err, item) {
           should.not.exist(err);
           should.exist(item);
           should.exist(item.listId);
@@ -2468,8 +2468,8 @@ describe('relations', function () {
     });
 
     it('should update related item on scope', function(done) {
-      Item.findById(itemId, function (e, todo) {
-        todo.list.update({name: 'List A'}, function(err, list) {
+      Item.findById(itemId, function(e, todo) {
+        todo.list.update({ name: 'List A' }, function(err, list) {
           should.not.exist(err);
           should.exist(list);
           list.name.should.equal('List A');
@@ -2479,7 +2479,7 @@ describe('relations', function () {
     });
 
     it('should get related item on scope', function(done) {
-      Item.findById(itemId, function (e, todo) {
+      Item.findById(itemId, function(e, todo) {
         todo.list(function(err, list) {
           should.not.exist(err);
           should.exist(list);
@@ -2490,7 +2490,7 @@ describe('relations', function () {
     });
 
     it('should destroy related item on scope', function(done) {
-      Item.findById(itemId, function (e, todo) {
+      Item.findById(itemId, function(e, todo) {
         todo.list.destroy(function(err) {
           should.not.exist(err);
           done();
@@ -2499,7 +2499,7 @@ describe('relations', function () {
     });
 
     it('should get related item on scope - verify', function(done) {
-      Item.findById(itemId, function (e, todo) {
+      Item.findById(itemId, function(e, todo) {
         todo.list(function(err, list) {
           should.not.exist(err);
           should.not.exist(list);
@@ -2509,22 +2509,22 @@ describe('relations', function () {
     });
 
     it('should not have deleted related item', function(done) {
-      List.findById(listId, function (e, list) {
+      List.findById(listId, function(e, list) {
         should.not.exist(e);
         should.exist(list);
         done();
       });
     });
 
-    it('should allow to create belongsTo model in beforeCreate hook', function (done) {
+    it('should allow to create belongsTo model in beforeCreate hook', function(done) {
       var mind;
-      Fear.beforeCreate = function (next) {
-        this.mind.create(function (err, m) {
+      Fear.beforeCreate = function(next) {
+        this.mind.create(function(err, m) {
           mind = m;
           if (err) next(err); else next();
         });
       };
-      Fear.create(function (err, fear) {
+      Fear.create(function(err, fear) {
         should.not.exists(err);
         should.exists(fear);
         fear.mindId.should.be.equal(mind.id);
@@ -2533,17 +2533,17 @@ describe('relations', function () {
       });
     });
 
-    it('should allow to create belongsTo model in beforeCreate hook with promises', function (done) {
+    it('should allow to create belongsTo model in beforeCreate hook with promises', function(done) {
       var mind;
-      Fear.beforeCreate = function (next) {
+      Fear.beforeCreate = function(next) {
         this.mind.create()
-        .then(function (m) {
+        .then(function(m) {
           mind = m;
           next();
         }).catch(next);
       };
       Fear.create()
-      .then(function (fear) {
+      .then(function(fear) {
         should.exists(fear);
         fear.mindId.should.be.equal(mind.id);
         should.exists(fear.mind());
@@ -2553,36 +2553,36 @@ describe('relations', function () {
 
   });
 
-  describe('belongsTo with scope', function () {
+  describe('belongsTo with scope', function() {
     var Person, Passport;
 
-    it('can be declared with scope and properties', function (done) {
-      Person = db.define('Person', {name: String, age: Number, passportNotes: String});
-      Passport = db.define('Passport', {name: String, notes: String});
+    it('can be declared with scope and properties', function(done) {
+      Person = db.define('Person', { name: String, age: Number, passportNotes: String });
+      Passport = db.define('Passport', { name: String, notes: String });
       Passport.belongsTo(Person, {
         properties: { notes: 'passportNotes' },
-        scope: { fields: { id: true, name: true } }
+        scope: { fields: { id: true, name: true }},
       });
       db.automigrate(['Person', 'Passport'], done);
     });
 
     var personCreated;
-    it('should create record on scope', function (done) {
+    it('should create record on scope', function(done) {
       var p = new Passport({ name: 'Passport', notes: 'Some notes...' });
-      p.person.create({name: 'Fred', age: 36 }, function(err, person) {
+      p.person.create({ name: 'Fred', age: 36 }, function(err, person) {
         personCreated = person;
         p.personId.should.equal(person.id);
         person.name.should.equal('Fred');
         person.passportNotes.should.equal('Some notes...');
-        p.save(function (err, passport) {
+        p.save(function(err, passport) {
           should.not.exists(err);
           done();
         });
       });
     });
 
-    it('should find record on scope', function (done) {
-      Passport.findOne(function (err, p) {
+    it('should find record on scope', function(done) {
+      Passport.findOne(function(err, p) {
         p.personId.should.eql(personCreated.id);
         p.person(function(err, person) {
           person.name.should.equal('Fred');
@@ -2593,28 +2593,28 @@ describe('relations', function () {
       });
     });
 
-    it('should create record on scope with promises', function (done) {
+    it('should create record on scope with promises', function(done) {
       var p = new Passport({ name: 'Passport', notes: 'Some notes...' });
-      p.person.create({name: 'Fred', age: 36 })
-      .then(function (person) {
+      p.person.create({ name: 'Fred', age: 36 })
+      .then(function(person) {
         p.personId.should.equal(person.id);
         person.name.should.equal('Fred');
         person.passportNotes.should.equal('Some notes...');
-        return p.save()
+        return p.save();
       })
-      .then(function (passport) {
+      .then(function(passport) {
         done();
       })
       .catch(done);
     });
 
-    it('should find record on scope with promises', function (done) {
+    it('should find record on scope with promises', function(done) {
       Passport.findOne()
-      .then(function (p) {
+      .then(function(p) {
         p.personId.should.eql(personCreated.id);
-        return p.person.getAsync()
+        return p.person.getAsync();
       })
-      .then(function (person) {
+      .then(function(person) {
         person.name.should.equal('Fred');
         person.should.have.property('age', undefined);
         person.should.have.property('passportNotes', undefined);
@@ -2628,36 +2628,36 @@ describe('relations', function () {
   // Disable the tests until the issue in
   // https://github.com/strongloop/loopback-datasource-juggler/pull/399
   // is fixed
-  describe.skip('belongsTo with embed', function () {
+  describe.skip('belongsTo with embed', function() {
     var Person, Passport;
 
-    it('can be declared with embed and properties', function (done) {
-      Person = db.define('Person', {name: String, age: Number});
-      Passport = db.define('Passport', {name: String, notes: String});
+    it('can be declared with embed and properties', function(done) {
+      Person = db.define('Person', { name: String, age: Number });
+      Passport = db.define('Passport', { name: String, notes: String });
       Passport.belongsTo(Person, {
         properties: ['name'],
-        options: { embedsProperties: true, invertProperties: true }
+        options: { embedsProperties: true, invertProperties: true },
       });
       db.automigrate(['Person', 'Passport'], done);
     });
 
-    it('should create record with embedded data', function (done) {
-      Person.create({name: 'Fred', age: 36 }, function(err, person) {
+    it('should create record with embedded data', function(done) {
+      Person.create({ name: 'Fred', age: 36 }, function(err, person) {
         var p = new Passport({ name: 'Passport', notes: 'Some notes...' });
         p.person(person);
         p.personId.should.equal(person.id);
         var data = p.toObject(true);
         data.person.id.should.equal(person.id);
         data.person.name.should.equal('Fred');
-        p.save(function (err) {
+        p.save(function(err) {
           should.not.exists(err);
           done();
         });
       });
     });
 
-    it('should find record with embedded data', function (done) {
-      Passport.findOne(function (err, p) {
+    it('should find record with embedded data', function(done) {
+      Passport.findOne(function(err, p) {
         should.not.exists(err);
         var data = p.toObject(true);
         data.person.id.should.equal(p.personId);
@@ -2666,9 +2666,9 @@ describe('relations', function () {
       });
     });
 
-    it('should find record with embedded data with promises', function (done) {
+    it('should find record with embedded data with promises', function(done) {
       Passport.findOne()
-      .then(function (p) {
+      .then(function(p) {
         var data = p.toObject(true);
         data.person.id.should.equal(p.personId);
         data.person.name.should.equal('Fred');
@@ -2677,20 +2677,20 @@ describe('relations', function () {
     });
   });
 
-  describe('hasOne', function () {
+  describe('hasOne', function() {
     var Supplier, Account;
     var supplierId, accountId;
 
-    before(function () {
+    before(function() {
       // db = getSchema();
-      Supplier = db.define('Supplier', {name: String});
-      Account = db.define('Account', {accountNo: String, supplierName: String});
+      Supplier = db.define('Supplier', { name: String });
+      Account = db.define('Account', { accountNo: String, supplierName: String });
     });
 
-    it('can be declared using hasOne method', function () {
+    it('can be declared using hasOne method', function() {
       Supplier.hasOne(Account, {
         properties: { name: 'supplierName' },
-        methods: { check: function() { return true; } }
+        methods: { check: function() { return true; } },
       });
       Object.keys((new Account()).toObject()).should.containEql('supplierId');
       (new Supplier()).account.should.be.an.instanceOf(Function);
@@ -2700,7 +2700,7 @@ describe('relations', function () {
       var rel = Supplier.relations['account'];
       rel.defineMethod('other', function() {
         return true;
-      })
+      });
     });
 
     it('should have setup a custom method on accessor', function() {
@@ -2711,14 +2711,14 @@ describe('relations', function () {
       s.account.other().should.be.true;
     });
 
-    it('can be used to query data', function (done) {
-      db.automigrate(['Supplier', 'Account'], function () {
-        Supplier.create({name: 'Supplier 1'}, function (e, supplier) {
+    it('can be used to query data', function(done) {
+      db.automigrate(['Supplier', 'Account'], function() {
+        Supplier.create({ name: 'Supplier 1' }, function(e, supplier) {
           supplierId = supplier.id;
           should.not.exist(e);
           should.exist(supplier);
-          supplier.account.create({accountNo: 'a01'}, function (err, account) {
-            supplier.account(function (e, act) {
+          supplier.account.create({ accountNo: 'a01' }, function(err, account) {
+            supplier.account(function(e, act) {
               accountId = act.id;
               should.not.exist(e);
               should.exist(act);
@@ -2732,14 +2732,14 @@ describe('relations', function () {
       });
     });
 
-    it('can be used to query data with getAsync with callback', function (done) {
-      db.automigrate(['Supplier', 'Account'], function () {
-        Supplier.create({name: 'Supplier 1'}, function (e, supplier) {
+    it('can be used to query data with getAsync with callback', function(done) {
+      db.automigrate(['Supplier', 'Account'], function() {
+        Supplier.create({ name: 'Supplier 1' }, function(e, supplier) {
           supplierId = supplier.id;
           should.not.exist(e);
           should.exist(supplier);
-          supplier.account.create({accountNo: 'a01'}, function (err, account) {
-            supplier.account.getAsync(function (e, act) {
+          supplier.account.create({ accountNo: 'a01' }, function(err, account) {
+            supplier.account.getAsync(function(e, act) {
               accountId = act.id;
               should.not.exist(e);
               should.exist(act);
@@ -2753,24 +2753,24 @@ describe('relations', function () {
       });
     });
 
-    it('can be used to query data with promises', function (done) {
-      db.automigrate(['Supplier', 'Account'], function () {
-        Supplier.create({name: 'Supplier 1'})
-        .then(function (supplier) {
+    it('can be used to query data with promises', function(done) {
+      db.automigrate(['Supplier', 'Account'], function() {
+        Supplier.create({ name: 'Supplier 1' })
+        .then(function(supplier) {
           supplierId = supplier.id;
           should.exist(supplier);
-          return supplier.account.create({accountNo: 'a01'})
-          .then(function (account) {
-            return supplier.account.getAsync()
+          return supplier.account.create({ accountNo: 'a01' })
+          .then(function(account) {
+            return supplier.account.getAsync();
           })
-          .then(function (act) {
+          .then(function(act) {
             accountId = act.id;
             should.exist(act);
             act.should.be.an.instanceOf(Account);
             supplier.account().id.should.equal(act.id);
             act.supplierName.should.equal(supplier.name);
             done();
-          })
+          });
         })
         .catch(done);
       });
@@ -2784,7 +2784,7 @@ describe('relations', function () {
       Supplier.findById(supplierId, function(e, supplier) {
         should.not.exist(e);
         should.exist(supplier);
-        supplier.account.update({supplierName: 'Supplier A'}, function(err, act) {
+        supplier.account.update({ supplierName: 'Supplier A' }, function(err, act) {
           should.not.exist(e);
           act.supplierName.should.equal('Supplier A');
           done();
@@ -2796,7 +2796,7 @@ describe('relations', function () {
       Supplier.findById(supplierId)
       .then(function(supplier) {
         should.exist(supplier);
-        return supplier.account.update({supplierName: 'Supplier B'})
+        return supplier.account.update({ supplierName: 'Supplier B' });
       })
       .then(function(act) {
         act.supplierName.should.equal('Supplier B');
@@ -2806,13 +2806,13 @@ describe('relations', function () {
     });
 
     it('should ignore the foreign key in the update', function(done) {
-      Supplier.create({name: 'Supplier 2'}, function (e, supplier) {
+      Supplier.create({ name: 'Supplier 2' }, function(e, supplier) {
         var sid = supplier.id;
         Supplier.findById(supplierId, function(e, supplier) {
           should.not.exist(e);
           should.exist(supplier);
-          supplier.account.update({supplierName: 'Supplier A',
-              supplierId: sid},
+          supplier.account.update({ supplierName: 'Supplier A',
+              supplierId: sid },
             function(err, act) {
               should.not.exist(e);
               act.supplierName.should.equal('Supplier A');
@@ -2840,9 +2840,9 @@ describe('relations', function () {
       Supplier.findById(supplierId)
       .then(function(supplier) {
         should.exist(supplier);
-        return supplier.account.getAsync()
+        return supplier.account.getAsync();
       })
-      .then(function (act) {
+      .then(function(act) {
         should.exist(act);
         act.supplierName.should.equal('Supplier A');
         done();
@@ -2863,13 +2863,13 @@ describe('relations', function () {
 
     it('should destroy the related item on scope with promises', function(done) {
       Supplier.findById(supplierId)
-      .then(function (supplier) {
+      .then(function(supplier) {
         should.exist(supplier);
-        return supplier.account.create({accountNo: 'a01'})
-        .then(function (account) {
-          return supplier.account.destroy()
+        return supplier.account.create({ accountNo: 'a01' })
+        .then(function(account) {
+          return supplier.account.destroy();
         })
-        .then(function (err) {
+        .then(function(err) {
           done();
         });
       })
@@ -2892,7 +2892,7 @@ describe('relations', function () {
       Supplier.findById(supplierId)
       .then(function(supplier) {
         should.exist(supplier);
-        return supplier.account.getAsync()
+        return supplier.account.getAsync();
       })
       .then(function(act) {
         should.not.exist(act);
@@ -2902,7 +2902,7 @@ describe('relations', function () {
     });
 
     it('should have deleted related item', function(done) {
-      Supplier.findById(supplierId, function (e, supplier) {
+      Supplier.findById(supplierId, function(e, supplier) {
         should.not.exist(e);
         should.exist(supplier);
         done();
@@ -2911,26 +2911,26 @@ describe('relations', function () {
 
   });
 
-  describe('hasOne with scope', function () {
+  describe('hasOne with scope', function() {
 
     var Supplier, Account;
     var supplierId, accountId;
 
-    before(function () {
+    before(function() {
       // db = getSchema();
-      Supplier = db.define('Supplier', {name: String});
-      Account = db.define('Account', {accountNo: String, supplierName: String, block: Boolean});
-      Supplier.hasOne(Account, { scope: { where: { block: false } }, properties: { name: 'supplierName' } });
+      Supplier = db.define('Supplier', { name: String });
+      Account = db.define('Account', { accountNo: String, supplierName: String, block: Boolean });
+      Supplier.hasOne(Account, { scope: { where: { block: false }}, properties: { name: 'supplierName' }});
     });
 
-    it('can be used to query data', function (done) {
-      db.automigrate(['Supplier', 'Account'], function () {
-        Supplier.create({name: 'Supplier 1'}, function (e, supplier) {
+    it('can be used to query data', function(done) {
+      db.automigrate(['Supplier', 'Account'], function() {
+        Supplier.create({ name: 'Supplier 1' }, function(e, supplier) {
           supplierId = supplier.id;
           should.not.exist(e);
           should.exist(supplier);
-          supplier.account.create({accountNo: 'a01', block: false}, function (err, account) {
-            supplier.account(function (e, act) {
+          supplier.account.create({ accountNo: 'a01', block: false }, function(err, account) {
+            supplier.account(function(e, act) {
               accountId = act.id;
               should.not.exist(e);
               should.exist(act);
@@ -2947,7 +2947,7 @@ describe('relations', function () {
     });
 
     it('should include record that matches scope', function(done) {
-      Supplier.findById(supplierId, {include: 'account'}, function(err, supplier) {
+      Supplier.findById(supplierId, { include: 'account' }, function(err, supplier) {
         should.exists(supplier.toJSON().account);
         supplier.account(function(err, account) {
           should.exists(account);
@@ -2956,10 +2956,10 @@ describe('relations', function () {
       });
     });
 
-    it('should not find record that does not match scope', function (done) {
-      Account.updateAll({ block: true }, function (err) {
-        Supplier.findById(supplierId, function (err, supplier) {
-          supplier.account(function (err, account) {
+    it('should not find record that does not match scope', function(done) {
+      Account.updateAll({ block: true }, function(err) {
+        Supplier.findById(supplierId, function(err, supplier) {
+          supplier.account(function(err, account) {
             should.not.exists(account);
             done();
           });
@@ -2967,11 +2967,11 @@ describe('relations', function () {
       });
     });
 
-    it('should not include record that does not match scope', function (done) {
-      Account.updateAll({ block: true }, function (err) {
-        Supplier.findById(supplierId, {include: 'account'}, function (err, supplier) {
+    it('should not include record that does not match scope', function(done) {
+      Account.updateAll({ block: true }, function(err) {
+        Supplier.findById(supplierId, { include: 'account' }, function(err, supplier) {
           should.not.exists(supplier.toJSON().account);
-          supplier.account(function (err, account) {
+          supplier.account(function(err, account) {
             should.not.exists(account);
             done();
           });
@@ -2979,17 +2979,17 @@ describe('relations', function () {
       });
     });
 
-    it('can be used to query data with promises', function (done) {
-      db.automigrate(['Supplier', 'Account'], function () {
-        Supplier.create({name: 'Supplier 1'})
-        .then(function (supplier) {
+    it('can be used to query data with promises', function(done) {
+      db.automigrate(['Supplier', 'Account'], function() {
+        Supplier.create({ name: 'Supplier 1' })
+        .then(function(supplier) {
           supplierId = supplier.id;
           should.exist(supplier);
-          return supplier.account.create({accountNo: 'a01', block: false})
-          .then(function (account) {
-            return supplier.account.getAsync()
+          return supplier.account.create({ accountNo: 'a01', block: false })
+          .then(function(account) {
+            return supplier.account.getAsync();
           })
-          .then(function (act) {
+          .then(function(act) {
             accountId = act.id;
             should.exist(act);
             act.should.be.an.instanceOf(Account);
@@ -3004,15 +3004,15 @@ describe('relations', function () {
       });
     });
 
-    it('should find record that match scope with promises', function (done) {
+    it('should find record that match scope with promises', function(done) {
       Account.updateAll({ block: true })
-      .then(function () {
-        return Supplier.findById(supplierId)
+      .then(function() {
+        return Supplier.findById(supplierId);
       })
-      .then(function (supplier) {
-        return supplier.account.getAsync()
+      .then(function(supplier) {
+        return supplier.account.getAsync();
       })
-      .then(function (account) {
+      .then(function(account) {
         should.not.exist(account);
         done();
       })
@@ -3021,47 +3021,47 @@ describe('relations', function () {
 
   });
 
-  describe('hasOne with non standard id', function () {
+  describe('hasOne with non standard id', function() {
     var Supplier, Account;
     var supplierId, accountId;
 
-    before(function () {
+    before(function() {
       // db = getSchema();
       Supplier = db.define('Supplier', {
         sid: {
           type: String,
           id: true,
-          generated: true
+          generated: true,
         },
-        name: String
+        name: String,
       });
       Account = db.define('Account', {
         accid: {
           type: String,
           id: true,
-          generated: false
+          generated: false,
         },
-        supplierName: String
+        supplierName: String,
       });
     });
 
-    it('can be declared with non standard foreignKey', function () {
+    it('can be declared with non standard foreignKey', function() {
       Supplier.hasOne(Account, {
-        properties: {name: 'supplierName'},
-        foreignKey: 'sid'
+        properties: { name: 'supplierName' },
+        foreignKey: 'sid',
       });
       Object.keys((new Account()).toObject()).should.containEql('sid');
       (new Supplier()).account.should.be.an.instanceOf(Function);
     });
 
-    it('can be used to query data', function (done) {
-      db.automigrate(['Supplier', 'Account'], function () {
-        Supplier.create({name: 'Supplier 1'}, function (e, supplier) {
+    it('can be used to query data', function(done) {
+      db.automigrate(['Supplier', 'Account'], function() {
+        Supplier.create({ name: 'Supplier 1' }, function(e, supplier) {
           supplierId = supplier.sid;
           should.not.exist(e);
           should.exist(supplier);
-          supplier.account.create({accid: 'a01'}, function (err, account) {
-            supplier.account(function (e, act) {
+          supplier.account.create({ accid: 'a01' }, function(err, account) {
+            supplier.account(function(e, act) {
               accountId = act.accid;
               should.not.exist(e);
               should.exist(act);
@@ -3099,7 +3099,7 @@ describe('relations', function () {
     });
 
     it('should have deleted related item', function(done) {
-      Supplier.findById(supplierId, function (e, supplier) {
+      Supplier.findById(supplierId, function(e, supplier) {
         should.not.exist(e);
         should.exist(supplier);
         done();
@@ -3108,7 +3108,7 @@ describe('relations', function () {
 
   });
 
-  describe('hasOne with primaryKey different from model PK', function () {
+  describe('hasOne with primaryKey different from model PK', function() {
     var CompanyBoard, Boss;
     var companyBoardId, bossId;
 
@@ -3116,33 +3116,33 @@ describe('relations', function () {
       db = getSchema();
       CompanyBoard = db.define('CompanyBoard', {
         membersNumber: Number,
-        companyId: String
+        companyId: String,
       });
       Boss = db.define('Boss', {
-        id: {type: String, id: true, generated: false},
+        id: { type: String, id: true, generated: false },
         boardMembersNumber: Number,
-        companyId: String
+        companyId: String,
       });
     });
 
-    it('relation can be declared with primaryKey', function () {
+    it('relation can be declared with primaryKey', function() {
       CompanyBoard.hasOne(Boss, {
-        properties: {membersNumber: 'boardMembersNumber'},
+        properties: { membersNumber: 'boardMembersNumber' },
         primaryKey: 'companyId',
-        foreignKey: 'companyId'
+        foreignKey: 'companyId',
       });
       Object.keys((new Boss()).toObject()).should.containEql('companyId');
       (new CompanyBoard()).boss.should.be.an.instanceOf(Function);
     });
 
-    it('can be used to query data', function (done) {
-      db.automigrate(['CompanyBoard', 'Boss'],function () {
-        CompanyBoard.create({membersNumber: 7, companyId: 'Company1'}, function (e, companyBoard) {
+    it('can be used to query data', function(done) {
+      db.automigrate(['CompanyBoard', 'Boss'], function() {
+        CompanyBoard.create({ membersNumber: 7, companyId: 'Company1' }, function(e, companyBoard) {
           companyBoardId = companyBoard.id;
           should.not.exist(e);
           should.exist(companyBoard);
-          companyBoard.boss.create({id: 'a01'}, function (err, account) {
-            companyBoard.boss(function (e, boss) {
+          companyBoard.boss.create({ id: 'a01' }, function(err, account) {
+            companyBoard.boss(function(e, boss) {
               bossId = boss.id;
               should.not.exist(e);
               should.exist(boss);
@@ -3157,22 +3157,22 @@ describe('relations', function () {
       });
     });
 
-    it('should destroy the related item on scope', function (done) {
-      CompanyBoard.findById(companyBoardId, function (e, companyBoard) {
+    it('should destroy the related item on scope', function(done) {
+      CompanyBoard.findById(companyBoardId, function(e, companyBoard) {
         should.not.exist(e);
         should.exist(companyBoard);
-        companyBoard.boss.destroy(function (err) {
+        companyBoard.boss.destroy(function(err) {
           should.not.exist(e);
           done();
         });
       });
     });
 
-    it('should get the related item on scope - verify', function (done) {
-      CompanyBoard.findById(companyBoardId, function (e, companyBoard) {
+    it('should get the related item on scope - verify', function(done) {
+      CompanyBoard.findById(companyBoardId, function(e, companyBoard) {
         should.not.exist(e);
         should.exist(companyBoard);
-        companyBoard.boss(function (err, act) {
+        companyBoard.boss(function(err, act) {
           should.not.exist(e);
           should.not.exist(act);
           done();
@@ -3182,95 +3182,95 @@ describe('relations', function () {
   });
 
 
-  describe('hasMany with primaryKey different from model PK', function () {
+  describe('hasMany with primaryKey different from model PK', function() {
     var Employee, Boss;
-    var COMPANY_ID = "Company1";
+    var COMPANY_ID = 'Company1';
 
-    before(function () {
+    before(function() {
       db = getSchema();
-      Employee = db.define('Employee', {name: String, companyId: String});
-      Boss = db.define('Boss', {address: String, companyId: String});
+      Employee = db.define('Employee', { name: String, companyId: String });
+      Boss = db.define('Boss', { address: String, companyId: String });
     });
 
-    it('relation can be declared with primaryKey', function () {
+    it('relation can be declared with primaryKey', function() {
       Boss.hasMany(Employee, {
         primaryKey: 'companyId',
-        foreignKey: 'companyId'
+        foreignKey: 'companyId',
       });
       (new Boss()).employees.should.be.an.instanceOf(Function);
     });
 
-    it('can be used to query employees for boss', function () {
-      return db.automigrate(['Employee', 'Boss']).then(function () {
-        return Boss.create({address: 'testAddress', companyId: COMPANY_ID})
-          .then(function (boss) {
+    it('can be used to query employees for boss', function() {
+      return db.automigrate(['Employee', 'Boss']).then(function() {
+        return Boss.create({ address: 'testAddress', companyId: COMPANY_ID })
+          .then(function(boss) {
             should.exist(boss);
             should.exist(boss.employees);
-            return boss.employees.create([{name: 'a01'}, {name: 'a02'}])
-              .then(function (employees) {
+            return boss.employees.create([{ name: 'a01' }, { name: 'a02' }])
+              .then(function(employees) {
                 should.exists(employees);
                 return boss.employees();
-              }).then(function (employees) {
+              }).then(function(employees) {
                 var employee = employees[0];
                 should.exist(employee);
                 employees.length.should.equal(2);
                 employee.should.be.an.instanceOf(Employee);
                 employee.companyId.should.be.eql(boss.companyId);
                 return employees;
-              })
+              });
           });
       });
     });
 
-    it('can be used to query employees for boss2', function () {
-      return db.automigrate(['Employee', 'Boss']).then(function () {
-        return Boss.create({address: 'testAddress', companyId: COMPANY_ID})
-          .then(function (boss) {
-            return Employee.create({name: 'a01', companyId: COMPANY_ID})
-              .then(function (employee) {
+    it('can be used to query employees for boss2', function() {
+      return db.automigrate(['Employee', 'Boss']).then(function() {
+        return Boss.create({ address: 'testAddress', companyId: COMPANY_ID })
+          .then(function(boss) {
+            return Employee.create({ name: 'a01', companyId: COMPANY_ID })
+              .then(function(employee) {
                 should.exist(employee);
                 return boss.employees.getAsync();
-              }).then(function (employees) {
+              }).then(function(employees) {
                 should.exists(employees);
                 employees.length.should.equal(1);
-              })
+              });
           });
       });
     });
   });
 
 
-  describe('belongsTo with primaryKey different from model PK', function () {
+  describe('belongsTo with primaryKey different from model PK', function() {
     var Employee, Boss;
-    var COMPANY_ID = "Company1";
+    var COMPANY_ID = 'Company1';
     var bossId;
 
-    before(function () {
+    before(function() {
       db = getSchema();
-      Employee = db.define('Employee', {name: String, companyId: String});
-      Boss = db.define('Boss', {address: String, companyId: String});
+      Employee = db.define('Employee', { name: String, companyId: String });
+      Boss = db.define('Boss', { address: String, companyId: String });
     });
 
-    it('relation can be declared with primaryKey', function () {
+    it('relation can be declared with primaryKey', function() {
       Employee.belongsTo(Boss, {
         primaryKey: 'companyId',
-        foreignKey: 'companyId'
+        foreignKey: 'companyId',
       });
       (new Employee()).boss.should.be.an.instanceOf(Function);
     });
 
-    it('can be used to query data', function () {
-      return db.automigrate(['Employee', 'Boss']).then(function () {
-        return Boss.create({address: 'testAddress', companyId: COMPANY_ID})
-          .then(function (boss) {
+    it('can be used to query data', function() {
+      return db.automigrate(['Employee', 'Boss']).then(function() {
+        return Boss.create({ address: 'testAddress', companyId: COMPANY_ID })
+          .then(function(boss) {
             bossId = boss.id;
-            return Employee.create({name: 'a', companyId: COMPANY_ID})
+            return Employee.create({ name: 'a', companyId: COMPANY_ID });
           })
-          .then(function (employee) {
+          .then(function(employee) {
             should.exists(employee);
             return employee.boss.getAsync();
           })
-          .then(function (boss) {
+          .then(function(boss) {
             should.exists(boss);
             boss.id.should.eql(bossId);
           });
@@ -3278,21 +3278,21 @@ describe('relations', function () {
     });
   });
 
-  describe('hasAndBelongsToMany', function () {
+  describe('hasAndBelongsToMany', function() {
     var Article, TagName, ArticleTag;
-    it('can be declared', function (done) {
-      Article = db.define('Article', {title: String});
-      TagName = db.define('TagName', {name: String, flag: String});
+    it('can be declared', function(done) {
+      Article = db.define('Article', { title: String });
+      TagName = db.define('TagName', { name: String, flag: String });
       Article.hasAndBelongsToMany('tagNames');
       ArticleTag = db.models.ArticleTagName;
       db.automigrate(['Article', 'TagName', 'ArticleTagName'], done);
     });
 
-    it('should allow to create instances on scope', function (done) {
-      Article.create(function (e, article) {
-        article.tagNames.create({name: 'popular'}, function (e, t) {
+    it('should allow to create instances on scope', function(done) {
+      Article.create(function(e, article) {
+        article.tagNames.create({ name: 'popular' }, function(e, t) {
           t.should.be.an.instanceOf(TagName);
-          ArticleTag.findOne(function (e, at) {
+          ArticleTag.findOne(function(e, at) {
             should.exist(at);
             at.tagNameId.toString().should.equal(t.id.toString());
             at.articleId.toString().should.equal(article.id.toString());
@@ -3302,9 +3302,9 @@ describe('relations', function () {
       });
     });
 
-    it('should allow to fetch scoped instances', function (done) {
-      Article.findOne(function (e, article) {
-        article.tagNames(function (e, tags) {
+    it('should allow to fetch scoped instances', function(done) {
+      Article.findOne(function(e, article) {
+        article.tagNames(function(e, tags) {
           should.not.exist(e);
           should.exist(tags);
 
@@ -3315,10 +3315,10 @@ describe('relations', function () {
       });
     });
 
-    it('should allow to add connection with instance', function (done) {
-      Article.findOne(function (e, article) {
-        TagName.create({name: 'awesome'}, function (e, tag) {
-          article.tagNames.add(tag, function (e, at) {
+    it('should allow to add connection with instance', function(done) {
+      Article.findOne(function(e, article) {
+        TagName.create({ name: 'awesome' }, function(e, tag) {
+          article.tagNames.add(tag, function(e, at) {
             should.not.exist(e);
             should.exist(at);
             at.should.be.an.instanceOf(ArticleTag);
@@ -3330,14 +3330,14 @@ describe('relations', function () {
       });
     });
 
-    it('should allow to remove connection with instance', function (done) {
-      Article.findOne(function (e, article) {
-        article.tagNames(function (e, tags) {
+    it('should allow to remove connection with instance', function(done) {
+      Article.findOne(function(e, article) {
+        article.tagNames(function(e, tags) {
           var len = tags.length;
           tags.should.not.be.empty;
-          article.tagNames.remove(tags[0], function (e) {
+          article.tagNames.remove(tags[0], function(e) {
             should.not.exist(e);
-            article.tagNames(true, function (e, tags) {
+            article.tagNames(true, function(e, tags) {
               tags.should.have.lengthOf(len - 1);
               done();
             });
@@ -3346,15 +3346,15 @@ describe('relations', function () {
       });
     });
 
-    it('should allow to create instances on scope with promises', function (done) {
-      db.automigrate(['Article', 'TagName', 'ArticleTagName'], function () {
+    it('should allow to create instances on scope with promises', function(done) {
+      db.automigrate(['Article', 'TagName', 'ArticleTagName'], function() {
         Article.create()
-        .then(function (article) {
-          return article.tagNames.create({name: 'popular'})
-          .then(function (t) {
+        .then(function(article) {
+          return article.tagNames.create({ name: 'popular' })
+          .then(function(t) {
             t.should.be.an.instanceOf(TagName);
             return ArticleTag.findOne()
-            .then(function (at) {
+            .then(function(at) {
               should.exist(at);
               at.tagNameId.toString().should.equal(t.id.toString());
               at.articleId.toString().should.equal(article.id.toString());
@@ -3365,11 +3365,11 @@ describe('relations', function () {
       });
     });
 
-    it('should allow to fetch scoped instances with promises', function (done) {
+    it('should allow to fetch scoped instances with promises', function(done) {
       Article.findOne()
-      .then(function (article) {
+      .then(function(article) {
         return article.tagNames.getAsync()
-        .then(function (tags) {
+        .then(function(tags) {
           should.exist(tags);
           article.tagNames().should.eql(tags);
           done();
@@ -3377,36 +3377,36 @@ describe('relations', function () {
       }).catch(done);
     });
 
-    it('should allow to add connection with instance with promises', function (done) {
+    it('should allow to add connection with instance with promises', function(done) {
       Article.findOne()
-      .then(function (article) {
-        return TagName.create({name: 'awesome'})
-        .then(function (tag) {
+      .then(function(article) {
+        return TagName.create({ name: 'awesome' })
+        .then(function(tag) {
           return article.tagNames.add(tag)
-          .then(function (at) {
+          .then(function(at) {
             should.exist(at);
             at.should.be.an.instanceOf(ArticleTag);
             at.tagNameId.should.eql(tag.id);
             at.articleId.should.eql(article.id);
             done();
           });
-        })
+        });
       })
       .catch(done);
     });
 
-    it('should allow to remove connection with instance with promises', function (done) {
+    it('should allow to remove connection with instance with promises', function(done) {
       Article.findOne()
-      .then(function (article) {
+      .then(function(article) {
         return article.tagNames.getAsync()
-        .then(function (tags) {
+        .then(function(tags) {
           var len = tags.length;
           tags.should.not.be.empty;
           return article.tagNames.remove(tags[0])
-          .then(function () {
-            return article.tagNames.getAsync()
+          .then(function() {
+            return article.tagNames.getAsync();
           })
-          .then(function (tags) {
+          .then(function(tags) {
             tags.should.have.lengthOf(len - 1);
             done();
           });
@@ -3421,13 +3421,13 @@ describe('relations', function () {
     });
 
     it('should apply inclusion fields to the target model', function(done) {
-      Article.create({title: 'a1'}, function (e, article) {
+      Article.create({ title: 'a1' }, function(e, article) {
         should.not.exist(e);
-        article.tagNames.create({name: 't1', flag: '1'}, function(e, t) {
+        article.tagNames.create({ name: 't1', flag: '1' }, function(e, t) {
           should.not.exist(e);
           Article.find({
-              where: {id: article.id},
-              include: {relation: 'tagNames', scope: {fields: ['name']}}},
+            where: { id: article.id },
+            include: { relation: 'tagNames', scope: { fields: ['name'] }}},
             function(e, articles) {
               should.not.exist(e);
               articles.should.have.property('length', 1);
@@ -3446,14 +3446,14 @@ describe('relations', function () {
     });
 
     it('should apply inclusion where to the target model', function(done) {
-      Article.create({title: 'a2'}, function (e, article) {
+      Article.create({ title: 'a2' }, function(e, article) {
         should.not.exist(e);
-        article.tagNames.create({name: 't2', flag: '2'}, function(e, t2) {
+        article.tagNames.create({ name: 't2', flag: '2' }, function(e, t2) {
           should.not.exist(e);
-          article.tagNames.create({name: 't3', flag: '3'}, function(e, t3) {
+          article.tagNames.create({ name: 't3', flag: '3' }, function(e, t3) {
             Article.find({
-                where: {id: article.id},
-                include: {relation: 'tagNames', scope: {where: {flag: '2'}}}},
+              where: { id: article.id },
+              include: { relation: 'tagNames', scope: { where: { flag: '2' }}}},
               function(e, articles) {
                 should.not.exist(e);
                 articles.should.have.property('length', 1);
@@ -3473,28 +3473,28 @@ describe('relations', function () {
     });
   });
 
-  describe('embedsOne', function () {
+  describe('embedsOne', function() {
 
     var person;
     var Passport;
     var Other;
 
-    before(function () {
+    before(function() {
       tmp = getTransientDataSource();
       // db = getSchema();
-      Person = db.define('Person', {name: String});
+      Person = db.define('Person', { name: String });
       Passport = tmp.define('Passport',
-        {name:{type:'string', required: true}},
-        {idInjection: false}
+        { name:{ type:'string', required: true }},
+        { idInjection: false }
       );
       Address = tmp.define('Address', { street: String }, { idInjection: false });
-      Other = db.define('Other', {name: String});
+      Other = db.define('Other', { name: String });
     });
 
-    it('can be declared using embedsOne method', function (done) {
+    it('can be declared using embedsOne method', function(done) {
       Person.embedsOne(Passport, {
-        default: {name: 'Anonymous'}, // a bit contrived
-        methods: { check: function() { return true; } }
+        default: { name: 'Anonymous' }, // a bit contrived
+        methods: { check: function() { return true; } },
       });
       Person.embedsOne(Address); // all by default
       db.automigrate(['Person'], done);
@@ -3513,7 +3513,7 @@ describe('relations', function () {
       var rel = Person.relations['passportItem'];
       rel.defineMethod('other', function() {
         return true;
-      })
+      });
     });
 
     it('should have setup a custom method on accessor', function() {
@@ -3524,12 +3524,12 @@ describe('relations', function () {
       p.passportItem.other().should.be.true;
     });
 
-    it('should behave properly without default or being set', function (done) {
+    it('should behave properly without default or being set', function(done) {
       var p = new Person();
       should.not.exist(p.address);
       var a = p.addressItem();
       should.not.exist(a);
-      Person.create({}, function (err, p) {
+      Person.create({}, function(err, p) {
         should.not.exist(p.address);
         var a = p.addressItem();
         should.not.exist(a);
@@ -3539,7 +3539,7 @@ describe('relations', function () {
 
     it('should return an instance with default values', function() {
       var p = new Person();
-      p.passport.toObject().should.eql({name: 'Anonymous'});
+      p.passport.toObject().should.eql({ name: 'Anonymous' });
       p.passportItem().should.equal(p.passport);
       p.passportItem(function(err, passport) {
         should.not.exist(err);
@@ -3549,26 +3549,26 @@ describe('relations', function () {
 
     it('should embed a model instance', function() {
       var p = new Person();
-      p.passportItem(new Passport({name: 'Fred'}));
-      p.passport.toObject().should.eql({name: 'Fred'});
+      p.passportItem(new Passport({ name: 'Fred' }));
+      p.passport.toObject().should.eql({ name: 'Fred' });
       p.passport.should.be.an.instanceOf(Passport);
     });
 
     it('should not embed an invalid model type', function() {
       var p = new Person();
       p.passportItem(new Other());
-      p.passport.toObject().should.eql({name: 'Anonymous'});
+      p.passport.toObject().should.eql({ name: 'Anonymous' });
       p.passport.should.be.an.instanceOf(Passport);
     });
 
     var personId;
     it('should create an embedded item on scope', function(done) {
-      Person.create({name: 'Fred'}, function(err, p) {
+      Person.create({ name: 'Fred' }, function(err, p) {
         should.not.exist(err);
         personId = p.id;
-        p.passportItem.create({name: 'Fredric'}, function(err, passport) {
+        p.passportItem.create({ name: 'Fredric' }, function(err, passport) {
           should.not.exist(err);
-          p.passport.toObject().should.eql({name: 'Fredric'});
+          p.passport.toObject().should.eql({ name: 'Fredric' });
           p.passport.should.be.an.instanceOf(Passport);
           done();
         });
@@ -3579,7 +3579,7 @@ describe('relations', function () {
       Person.findById(personId, function(err, p) {
         should.not.exist(err);
         var passport = p.passportItem();
-        passport.toObject().should.eql({name: 'Fredric'});
+        passport.toObject().should.eql({ name: 'Fredric' });
         passport.should.be.an.instanceOf(Passport);
         passport.should.equal(p.passport);
         passport.should.equal(p.passportItem.value());
@@ -3588,7 +3588,7 @@ describe('relations', function () {
     });
 
     it('should validate an embedded item on scope - on creation', function(done) {
-      var p = new Person({name: 'Fred'});
+      var p = new Person({ name: 'Fred' });
       p.passportItem.create({}, function(err, passport) {
         should.exist(err);
         err.name.should.equal('ValidationError');
@@ -3613,10 +3613,10 @@ describe('relations', function () {
 
     it('should update an embedded item on scope', function(done) {
       Person.findById(personId, function(err, p) {
-        p.passportItem.update({name: 'Freddy'}, function(err, passport) {
+        p.passportItem.update({ name: 'Freddy' }, function(err, passport) {
           should.not.exist(err);
           var passport = p.passportItem();
-          passport.toObject().should.eql({name: 'Freddy'});
+          passport.toObject().should.eql({ name: 'Freddy' });
           passport.should.be.an.instanceOf(Passport);
           passport.should.equal(p.passport);
           done();
@@ -3628,7 +3628,7 @@ describe('relations', function () {
       Person.findById(personId, function(err, p) {
         should.not.exist(err);
         var passport = p.passportItem();
-        passport.toObject().should.eql({name: 'Freddy'});
+        passport.toObject().should.eql({ name: 'Freddy' });
         done();
       });
     });
@@ -3652,9 +3652,9 @@ describe('relations', function () {
     });
 
     it('should save an unsaved model', function(done) {
-      var p = new Person({name: 'Fred'});
+      var p = new Person({ name: 'Fred' });
       p.isNewRecord().should.be.true;
-      p.passportItem.create({name: 'Fredric'}, function(err, passport) {
+      p.passportItem.create({ name: 'Fredric' }, function(err, passport) {
         should.not.exist(err);
         p.passport.should.equal(passport);
         p.isNewRecord().should.be.false;
@@ -3663,12 +3663,12 @@ describe('relations', function () {
     });
 
     it('should create an embedded item on scope with promises', function(done) {
-      Person.create({name: 'Fred'})
+      Person.create({ name: 'Fred' })
       .then(function(p) {
         personId = p.id;
-        p.passportItem.create({name: 'Fredric'})
+        p.passportItem.create({ name: 'Fredric' })
         .then(function(passport) {
-          p.passport.toObject().should.eql({name: 'Fredric'});
+          p.passport.toObject().should.eql({ name: 'Fredric' });
           p.passport.should.be.an.instanceOf(Passport);
           done();
         });
@@ -3679,7 +3679,7 @@ describe('relations', function () {
       Person.findById(personId)
       .then(function(p) {
         var passport = p.passportItem();
-        passport.toObject().should.eql({name: 'Fredric'});
+        passport.toObject().should.eql({ name: 'Fredric' });
         passport.should.be.an.instanceOf(Passport);
         passport.should.equal(p.passport);
         passport.should.equal(p.passportItem.value());
@@ -3688,13 +3688,13 @@ describe('relations', function () {
     });
 
     it('should validate an embedded item on scope with promises - on creation', function(done) {
-      var p = new Person({name: 'Fred'});
+      var p = new Person({ name: 'Fred' });
       p.passportItem.create({})
       .then(function(passport) {
         should.not.exist(passport);
         done();
       })
-      .catch(function (err) {
+      .catch(function(err) {
         should.exist(err);
         err.name.should.equal('ValidationError');
         err.details.messages.name.should.eql(['can\'t be blank']);
@@ -3708,7 +3708,7 @@ describe('relations', function () {
         var passport = p.passportItem();
         passport.name = null;
         return p.save()
-        .then(function (p) {
+        .then(function(p) {
           should.not.exist(p);
           done();
         })
@@ -3724,11 +3724,11 @@ describe('relations', function () {
 
     it('should update an embedded item on scope with promises', function(done) {
       Person.findById(personId)
-      .then(function (p) {
-        return p.passportItem.update({name: 'Jason'})
+      .then(function(p) {
+        return p.passportItem.update({ name: 'Jason' })
         .then(function(passport) {
           var passport = p.passportItem();
-          passport.toObject().should.eql({name: 'Jason'});
+          passport.toObject().should.eql({ name: 'Jason' });
           passport.should.be.an.instanceOf(Passport);
           passport.should.equal(p.passport);
           done();
@@ -3740,7 +3740,7 @@ describe('relations', function () {
       Person.findById(personId)
       .then(function(p) {
         var passport = p.passportItem();
-        passport.toObject().should.eql({name: 'Jason'});
+        passport.toObject().should.eql({ name: 'Jason' });
         done();
       }).catch(done);
     });
@@ -3765,29 +3765,29 @@ describe('relations', function () {
     });
   });
 
-  describe('embedsOne - persisted model', function () {
+  describe('embedsOne - persisted model', function() {
 
     // This test spefically uses the Memory connector
     // in order to test the use of the auto-generated
     // id, in the sequence of the related model.
 
-    before(function () {
+    before(function() {
       db = getMemoryDataSource();
-      Person = db.define('Person', {name: String});
+      Person = db.define('Person', { name: String });
       Passport = db.define('Passport',
-        {name:{type:'string', required: true}}
+        { name:{ type:'string', required: true }}
       );
     });
 
-    it('can be declared using embedsOne method', function (done) {
+    it('can be declared using embedsOne method', function(done) {
       Person.embedsOne(Passport, {
-        options: {persistent: true}
+        options: { persistent: true },
       });
       db.automigrate(['Person', 'Passport'], done);
     });
 
     it('should create an item - to offset id', function(done) {
-      Passport.create({name:'Wilma'}, function(err, p) {
+      Passport.create({ name:'Wilma' }, function(err, p) {
         should.not.exist(err);
         p.id.should.equal(1);
         p.name.should.equal('Wilma');
@@ -3796,9 +3796,9 @@ describe('relations', function () {
     });
 
     it('should create an embedded item on scope', function(done) {
-      Person.create({name: 'Fred'}, function(err, p) {
+      Person.create({ name: 'Fred' }, function(err, p) {
         should.not.exist(err);
-        p.passportItem.create({name: 'Fredric'}, function(err, passport) {
+        p.passportItem.create({ name: 'Fredric' }, function(err, passport) {
           should.not.exist(err);
           p.passport.id.should.eql(2);
           p.passport.name.should.equal('Fredric');
@@ -3808,9 +3808,9 @@ describe('relations', function () {
     });
 
     it('should create an embedded item on scope with promises', function(done) {
-      Person.create({name: 'Barney'})
+      Person.create({ name: 'Barney' })
       .then(function(p) {
-        return p.passportItem.create({name: 'Barnabus'})
+        return p.passportItem.create({ name: 'Barnabus' })
         .then(function(passport) {
           p.passport.id.should.eql(3);
           p.passport.name.should.equal('Barnabus');
@@ -3821,27 +3821,27 @@ describe('relations', function () {
 
   });
 
-  describe('embedsOne - generated id', function () {
+  describe('embedsOne - generated id', function() {
 
-    before(function () {
+    before(function() {
       tmp = getTransientDataSource();
       // db = getSchema();
-      Person = db.define('Person', {name: String});
+      Person = db.define('Person', { name: String });
       Passport = tmp.define('Passport',
-        {id: {type:'string', id: true, generated:true}},
-        {name: {type:'string', required: true}}
+        { id: { type:'string', id: true, generated:true }},
+        { name: { type:'string', required: true }}
       );
     });
 
-    it('can be declared using embedsOne method', function (done) {
+    it('can be declared using embedsOne method', function(done) {
       Person.embedsOne(Passport);
       db.automigrate(['Person'], done);
     });
 
     it('should create an embedded item on scope', function(done) {
-      Person.create({name: 'Fred'}, function(err, p) {
+      Person.create({ name: 'Fred' }, function(err, p) {
         should.not.exist(err);
-        p.passportItem.create({name: 'Fredric'}, function(err, passport) {
+        p.passportItem.create({ name: 'Fredric' }, function(err, passport) {
           should.not.exist(err);
           passport.id.should.match(/^[0-9a-fA-F]{24}$/);
           p.passport.name.should.equal('Fredric');
@@ -3852,21 +3852,21 @@ describe('relations', function () {
 
   });
 
-  describe('embedsMany', function () {
+  describe('embedsMany', function() {
 
     var address1, address2;
 
-    before(function (done) {
-      tmp = getTransientDataSource({defaultIdType: Number});
+    before(function(done) {
+      tmp = getTransientDataSource({ defaultIdType: Number });
       // db = getSchema();
-      Person = db.define('Person', {name: String});
-      Address = tmp.define('Address', {street: String});
+      Person = db.define('Person', { name: String });
+      Address = tmp.define('Address', { street: String });
       Address.validatesPresenceOf('street');
 
       db.automigrate(['Person'], done);
     });
 
-    it('can be declared', function (done) {
+    it('can be declared', function(done) {
       Person.embedsMany(Address);
       db.automigrate(['Person'], done);
     });
@@ -3931,7 +3931,7 @@ describe('relations', function () {
 
     it('should filter embedded items on scope', function(done) {
       Person.findOne(function(err, p) {
-        p.addressList({ where: { street: 'Street 2' } }, function(err, addresses) {
+        p.addressList({ where: { street: 'Street 2' }}, function(err, addresses) {
           should.not.exist(err);
           addresses.should.have.length(1);
           addresses[0].id.should.eql(address2.id);
@@ -4078,7 +4078,7 @@ describe('relations', function () {
     });
 
     it('should save an unsaved model', function(done) {
-      var p = new Person({name: 'Fred'});
+      var p = new Person({ name: 'Fred' });
       p.isNewRecord().should.be.true;
       p.addressList.create({ street: 'Street 4' }, function(err, address) {
         should.not.exist(err);
@@ -4090,22 +4090,22 @@ describe('relations', function () {
 
   });
 
-  describe('embedsMany - numeric ids + forceId', function () {
+  describe('embedsMany - numeric ids + forceId', function() {
 
-    before(function (done) {
+    before(function(done) {
       tmp = getTransientDataSource();
       // db = getSchema();
-      Person = db.define('Person', {name: String});
+      Person = db.define('Person', { name: String });
       Address = tmp.define('Address', {
-        id: {type: Number, id:true},
-        street: String
+        id: { type: Number, id:true },
+        street: String,
       });
 
       db.automigrate(['Person'], done);
     });
 
-    it('can be declared', function (done) {
-      Person.embedsMany(Address, {options: {forceId: true}});
+    it('can be declared', function(done) {
+      Person.embedsMany(Address, { options: { forceId: true }});
       db.automigrate(['Person'], done);
     });
 
@@ -4127,18 +4127,18 @@ describe('relations', function () {
 
   });
 
-  describe('embedsMany - explicit ids', function () {
-    before(function (done) {
+  describe('embedsMany - explicit ids', function() {
+    before(function(done) {
       tmp = getTransientDataSource();
       // db = getSchema();
-      Person = db.define('Person', {name: String});
-      Address = tmp.define('Address', {street: String});
+      Person = db.define('Person', { name: String });
+      Address = tmp.define('Address', { street: String });
       Address.validatesPresenceOf('street');
 
       db.automigrate(['Person'], done);
     });
 
-    it('can be declared', function (done) {
+    it('can be declared', function(done) {
       Person.embedsMany(Address);
       db.automigrate(['Person'], done);
     });
@@ -4215,7 +4215,7 @@ describe('relations', function () {
       Person.create({ name: 'Wilma', addresses: addresses }, function(err, p) {
         err.name.should.equal('ValidationError');
         err.details.messages.addresses.should.eql([
-          'contains invalid item: `work` (`street` can\'t be blank)'
+          'contains invalid item: `work` (`street` can\'t be blank)',
         ]);
         done();
       });
@@ -4233,7 +4233,7 @@ describe('relations', function () {
     });
 
     it('should have embedded items - verify', function(done) {
-      Person.findOne({ where: { name: 'Wilma' } }, function(err, p) {
+      Person.findOne({ where: { name: 'Wilma' }}, function(err, p) {
         p.name.should.equal('Wilma');
         p.addresses.should.have.length(2);
         p.addresses[0].id.should.equal('home');
@@ -4245,7 +4245,7 @@ describe('relations', function () {
     });
 
     it('should have accessors: at, get, set', function(done) {
-      Person.findOne({ where: { name: 'Wilma' } }, function(err, p) {
+      Person.findOne({ where: { name: 'Wilma' }}, function(err, p) {
         p.name.should.equal('Wilma');
         p.addresses.should.have.length(2);
         p.addressList.at(0).id.should.equal('home');
@@ -4260,10 +4260,10 @@ describe('relations', function () {
 
     it('should create embedded from attributes - property name', function(done) {
       var addresses = [
-        {id: 'home', street: 'Home Street'},
-        {id: 'work', street: 'Work Street'}
+        { id: 'home', street: 'Home Street' },
+        { id: 'work', street: 'Work Street' },
       ];
-      Person.create({name: 'Wilma', addresses: addresses}, function(err, p) {
+      Person.create({ name: 'Wilma', addresses: addresses }, function(err, p) {
         should.not.exist(err);
         p.addressList.at(0).id.should.equal('home');
         p.addressList.at(1).id.should.equal('work');
@@ -4273,10 +4273,10 @@ describe('relations', function () {
 
     it('should not create embedded from attributes - relation name', function(done) {
       var addresses = [
-        {id: 'home', street: 'Home Street'},
-        {id: 'work', street: 'Work Street'}
+        { id: 'home', street: 'Home Street' },
+        { id: 'work', street: 'Work Street' },
       ];
-      Person.create({name: 'Wilma', addressList: addresses}, function(err, p) {
+      Person.create({ name: 'Wilma', addressList: addresses }, function(err, p) {
         should.not.exist(err);
         p.addresses.should.have.length(0);
         done();
@@ -4296,7 +4296,7 @@ describe('relations', function () {
 
   });
 
-  describe('embedsMany - persisted model', function () {
+  describe('embedsMany - persisted model', function() {
 
     var address0, address1, address2;
     var person;
@@ -4305,21 +4305,21 @@ describe('relations', function () {
     // in order to test the use of the auto-generated
     // id, in the sequence of the related model.
 
-    before(function (done) {
+    before(function(done) {
       db = getMemoryDataSource();
-      Person = db.define('Person', {name: String});
-      Address = db.define('Address', {street: String});
+      Person = db.define('Person', { name: String });
+      Address = db.define('Address', { street: String });
       Address.validatesPresenceOf('street');
 
       db.automigrate(['Person', 'Address'], done);
     });
 
-    it('can be declared', function (done) {
+    it('can be declared', function(done) {
       // to save related model itself, set
       // persistent: true
       Person.embedsMany(Address, {
-        scope: {order: 'street'},
-        options: {persistent: true}
+        scope: { order: 'street' },
+        options: { persistent: true },
       });
       db.automigrate(['Person', 'Address'], done);
     });
@@ -4422,27 +4422,27 @@ describe('relations', function () {
 
   });
 
-  describe('embedsMany - relations, scope and properties', function () {
+  describe('embedsMany - relations, scope and properties', function() {
 
     var category, job1, job2, job3;
 
-    before(function () {
+    before(function() {
       // db = getSchema();
-      Category = db.define('Category', {name: String});
-      Job = db.define('Job', {name: String});
-      Link = db.define('Link', {name: String, notes: String});
+      Category = db.define('Category', { name: String });
+      Job = db.define('Job', { name: String });
+      Link = db.define('Link', { name: String, notes: String });
     });
 
-    it('can be declared', function (done) {
+    it('can be declared', function(done) {
       Category.embedsMany(Link, {
         as: 'items', // rename
         scope: { include: 'job' }, // always include
-        options: { belongsTo: 'job' } // optional, for add()/remove()
+        options: { belongsTo: 'job' }, // optional, for add()/remove()
       });
       Link.belongsTo(Job, {
         foreignKey: 'id', // re-use the actual job id
         properties: { id: 'id', name: 'name' }, // denormalize, transfer id
-        options: { invertProperties: true }
+        options: { invertProperties: true },
       });
       db.automigrate(['Category', 'Job', 'Link'], function() {
         Job.create({ name: 'Job 0' }, done); // offset ids for tests
@@ -4601,7 +4601,7 @@ describe('relations', function () {
       Category.findById(category.id, function(err, cat) {
         cat.name.should.equal('Category B');
         cat.links.toObject().should.eql([
-          {id: jobId, name: 'Job 1', notes: 'Some notes...'}
+          { id: jobId, name: 'Job 1', notes: 'Some notes...' },
         ]);
         cat.items.at(0).should.equal(cat.links[0]);
         cat.items(function(err, items) { // alternative access
@@ -4618,7 +4618,7 @@ describe('relations', function () {
     it('should update items on scope - and save parent', function(done) {
       Category.findById(category.id, function(err, cat) {
         var link = cat.items.at(0);
-        link.updateAttributes({notes: 'Updated notes...'}, function(err, link) {
+        link.updateAttributes({ notes: 'Updated notes...' }, function(err, link) {
           link.notes.should.equal('Updated notes...');
           done();
         });
@@ -4629,7 +4629,7 @@ describe('relations', function () {
       Category.findById(category.id, function(err, cat) {
         cat.name.should.equal('Category B');
         cat.links.toObject().should.eql([
-          {id: jobId, name: 'Job 1', notes: 'Updated notes...'}
+          { id: jobId, name: 'Job 1', notes: 'Updated notes...' },
         ]);
         done();
       });
@@ -4654,21 +4654,21 @@ describe('relations', function () {
 
   });
 
-  describe('embedsMany - polymorphic relations', function () {
+  describe('embedsMany - polymorphic relations', function() {
 
     var person1, person2;
 
-    before(function (done) {
+    before(function(done) {
       // db = getSchema();
       tmp = getTransientDataSource();
 
-      Book = db.define('Book', {name: String});
-      Author = db.define('Author', {name: String});
-      Reader = db.define('Reader', {name: String});
+      Book = db.define('Book', { name: String });
+      Author = db.define('Author', { name: String });
+      Reader = db.define('Reader', { name: String });
 
       Link = tmp.define('Link', {
-        id: {type: Number, id: true},
-        name: String, notes: String
+        id: { type: Number, id: true },
+        name: String, notes: String,
       }); // generic model
       Link.validatesPresenceOf('linkedId');
       Link.validatesPresenceOf('linkedType');
@@ -4676,17 +4676,17 @@ describe('relations', function () {
       db.automigrate(['Book', 'Author', 'Reader'], done);
     });
 
-    it('can be declared', function (done) {
+    it('can be declared', function(done) {
       var idType = db.connector.getDefaultIdType();
 
       Book.embedsMany(Link, { as: 'people',
         polymorphic: 'linked',
-        scope: { include: 'linked' }
+        scope: { include: 'linked' },
       });
       Link.belongsTo('linked', {
         polymorphic: { idType: idType },  // native type
         properties: { name: 'name' },     // denormalized
-        options: { invertProperties: true }
+        options: { invertProperties: true },
       });
       db.automigrate(['Book', 'Author', 'Reader'], done);
     });
@@ -4791,19 +4791,19 @@ describe('relations', function () {
 
   });
 
-  describe('referencesMany', function () {
+  describe('referencesMany', function() {
 
     var job1, job2, job3;
 
-    before(function (done) {
+    before(function(done) {
       // db = getSchema();
-      Category = db.define('Category', {name: String});
-      Job = db.define('Job', {name: String});
+      Category = db.define('Category', { name: String });
+      Job = db.define('Job', { name: String });
 
       db.automigrate(['Job', 'Category'], done);
     });
 
-    it('can be declared', function (done) {
+    it('can be declared', function(done) {
       var reverse = function(cb) {
         cb = cb || createPromiseCallback();
         var modelInstance = this.modelInstance;
@@ -4819,8 +4819,8 @@ describe('relations', function () {
       reverse.http = { verb: 'put', path: '/jobs/reverse' };
 
       Category.referencesMany(Job, { scopeMethods: {
-        reverse: reverse
-      } });
+        reverse: reverse,
+      }});
 
       Category.prototype['__reverse__jobs'].should.be.a.function;
       should.exist(Category.prototype['__reverse__jobs'].shared);
@@ -4829,7 +4829,7 @@ describe('relations', function () {
       db.automigrate(['Job', 'Category'], done);
     });
 
-    it('should setup test records', function (done) {
+    it('should setup test records', function(done) {
       Job.create({ name: 'Job 1' }, function(err, p) {
         job1 = p;
         Job.create({ name: 'Job 3' }, function(err, p) {
@@ -4839,7 +4839,7 @@ describe('relations', function () {
       });
     });
 
-    it('should create record on scope', function (done) {
+    it('should create record on scope', function(done) {
       Category.create({ name: 'Category A' }, function(err, cat) {
         cat.jobIds.should.be.an.array;
         cat.jobIds.should.have.length(0);
@@ -4854,7 +4854,7 @@ describe('relations', function () {
       });
     });
 
-    it('should not allow duplicate record on scope', function (done) {
+    it('should not allow duplicate record on scope', function(done) {
       Category.findOne(function(err, cat) {
         cat.jobIds = [job2.id, job2.id];
         cat.save(function(err, p) {
@@ -4866,7 +4866,7 @@ describe('relations', function () {
       });
     });
 
-    it('should find items on scope', function (done) {
+    it('should find items on scope', function(done) {
       Category.findOne(function(err, cat) {
         cat.jobIds.should.eql([job2.id]);
         cat.jobs(function(err, jobs) {
@@ -4879,7 +4879,7 @@ describe('relations', function () {
       });
     });
 
-    it('should find items on scope - findById', function (done) {
+    it('should find items on scope - findById', function(done) {
       Category.findOne(function(err, cat) {
         cat.jobIds.should.eql([job2.id]);
         cat.jobs.findById(job2.id, function(err, p) {
@@ -4892,7 +4892,7 @@ describe('relations', function () {
       });
     });
 
-    it('should check if a record exists on scope', function (done) {
+    it('should check if a record exists on scope', function(done) {
       Category.findOne(function(err, cat) {
         cat.jobs.exists(job2.id, function(err, exists) {
           should.not.exist(err);
@@ -4902,7 +4902,7 @@ describe('relations', function () {
       });
     });
 
-    it('should update a record on scope', function (done) {
+    it('should update a record on scope', function(done) {
       Category.findOne(function(err, cat) {
         var attrs = { name: 'Job 2 - edit' };
         cat.jobs.updateById(job2.id, attrs, function(err, p) {
@@ -4913,7 +4913,7 @@ describe('relations', function () {
       });
     });
 
-    it('should get a record by index - at', function (done) {
+    it('should get a record by index - at', function(done) {
       Category.findOne(function(err, cat) {
         cat.jobs.at(0, function(err, p) {
           should.not.exist(err);
@@ -4925,7 +4925,7 @@ describe('relations', function () {
       });
     });
 
-    it('should add a record to scope - object', function (done) {
+    it('should add a record to scope - object', function(done) {
       Category.findOne(function(err, cat) {
         cat.jobs.add(job1, function(err, prod) {
           should.not.exist(err);
@@ -4937,7 +4937,7 @@ describe('relations', function () {
       });
     });
 
-    it('should add a record to scope - object', function (done) {
+    it('should add a record to scope - object', function(done) {
       Category.findOne(function(err, cat) {
         cat.jobs.add(job3.id, function(err, prod) {
           should.not.exist(err);
@@ -4950,7 +4950,7 @@ describe('relations', function () {
       });
     });
 
-    it('should find items on scope - findById', function (done) {
+    it('should find items on scope - findById', function(done) {
       Category.findOne(function(err, cat) {
         cat.jobs.findById(job3.id, function(err, p) {
           should.not.exist(err);
@@ -4961,9 +4961,9 @@ describe('relations', function () {
       });
     });
 
-    it('should find items on scope - filter', function (done) {
+    it('should find items on scope - filter', function(done) {
       Category.findOne(function(err, cat) {
-        var filter = { where: { name: 'Job 1' } };
+        var filter = { where: { name: 'Job 1' }};
         cat.jobs(filter, function(err, jobs) {
           should.not.exist(err);
           jobs.should.have.length(1);
@@ -4975,7 +4975,7 @@ describe('relations', function () {
       });
     });
 
-    it('should remove items from scope', function (done) {
+    it('should remove items from scope', function(done) {
       Category.findOne(function(err, cat) {
         cat.jobs.remove(job1.id, function(err, ids) {
           should.not.exist(err);
@@ -4987,7 +4987,7 @@ describe('relations', function () {
       });
     });
 
-    it('should find items on scope - verify', function (done) {
+    it('should find items on scope - verify', function(done) {
       Category.findOne(function(err, cat) {
         var expected = [job2.id, job3.id];
         cat.jobIds.should.eql(expected);
@@ -5004,13 +5004,13 @@ describe('relations', function () {
     it('should find items on scope and ordered them by name DESC', function(done) {
       Category.find(function(err, categories) {
         categories.should.have.length(1);
-        categories[0].jobs({order: 'name DESC'}, function (err, jobs) {
+        categories[0].jobs({ order: 'name DESC' }, function(err, jobs) {
           should.not.exist(err);
           jobs.should.have.length(2);
-          jobs[0].id.should.eql(job3.id)
-          jobs[1].id.should.eql(job2.id)
+          jobs[0].id.should.eql(job3.id);
+          jobs[1].id.should.eql(job2.id);
           done();
-        })
+        });
       });
     });
 
@@ -5022,7 +5022,7 @@ describe('relations', function () {
           cat.jobIds.should.eql(expected);
           done();
         });
-      })
+      });
     });
 
     it('should include related items from scope', function(done) {
@@ -5037,7 +5037,7 @@ describe('relations', function () {
       });
     });
 
-    it('should destroy items from scope - destroyById', function (done) {
+    it('should destroy items from scope - destroyById', function(done) {
       Category.findOne(function(err, cat) {
         cat.jobs.destroy(job2.id, function(err) {
           should.not.exist(err);
@@ -5053,7 +5053,7 @@ describe('relations', function () {
       });
     });
 
-    it('should find items on scope - verify', function (done) {
+    it('should find items on scope - verify', function(done) {
       Category.findOne(function(err, cat) {
         var expected = [job3.id];
         cat.jobIds.should.eql(expected);
@@ -5066,21 +5066,21 @@ describe('relations', function () {
       });
     });
 
-    it('should setup test records with promises', function (done) {
-      db.automigrate(['Job', 'Category'], function () {
+    it('should setup test records with promises', function(done) {
+      db.automigrate(['Job', 'Category'], function() {
         return Job.create({ name: 'Job 1' })
-        .then(function (p) {
+        .then(function(p) {
           job1 = p;
-          return Job.create({ name: 'Job 3' })
+          return Job.create({ name: 'Job 3' });
         })
-        .then(function (p) {
-            job3 = p;
-            done();
+        .then(function(p) {
+          job3 = p;
+          done();
         }).catch(done);
       });
     });
 
-    it('should create record on scope with promises', function (done) {
+    it('should create record on scope with promises', function(done) {
       Category.create({ name: 'Category A' })
       .then(function(cat) {
         cat.jobIds.should.be.an.array;
@@ -5098,17 +5098,17 @@ describe('relations', function () {
 
 
 
-    it('should not allow duplicate record on scope with promises', function (done) {
+    it('should not allow duplicate record on scope with promises', function(done) {
       Category.findOne()
-      .then(function (cat) {
+      .then(function(cat) {
         cat.jobIds = [job2.id, job2.id];
-        cat.save()
+        cat.save();
       })
-      .then(function (p) {
+      .then(function(p) {
         should.not.exist(p);
         done();
       })
-      .catch(function (err) {
+      .catch(function(err) {
         should.exist(err);
         err.name.should.equal('ValidationError');
         err.details.codes.jobs.should.eql(['uniqueness']);
@@ -5116,13 +5116,13 @@ describe('relations', function () {
       });
     });
 
-    it('should find items on scope with promises', function (done) {
+    it('should find items on scope with promises', function(done) {
       Category.findOne()
-      .then(function (cat) {
+      .then(function(cat) {
         cat.jobIds.should.eql([job2.id]);
-        return cat.jobs.getAsync()
+        return cat.jobs.getAsync();
       })
-      .then(function (jobs) {
+      .then(function(jobs) {
         var p = jobs[0];
         p.id.should.eql(job2.id);
         p.name.should.equal('Job 2');
@@ -5131,13 +5131,13 @@ describe('relations', function () {
       .catch(done);
     });
 
-    it('should find items on scope with promises - findById', function (done) {
+    it('should find items on scope with promises - findById', function(done) {
       Category.findOne()
-      .then(function (cat) {
+      .then(function(cat) {
         cat.jobIds.should.eql([job2.id]);
-        return cat.jobs.findById(job2.id)
+        return cat.jobs.findById(job2.id);
       })
-      .then(function (p) {
+      .then(function(p) {
         p.should.be.instanceof(Job);
         p.id.should.eql(job2.id);
         p.name.should.equal('Job 2');
@@ -5146,36 +5146,36 @@ describe('relations', function () {
       .catch(done);
     });
 
-    it('should check if a record exists on scope with promises', function (done) {
+    it('should check if a record exists on scope with promises', function(done) {
       Category.findOne()
-      .then(function (cat) {
+      .then(function(cat) {
         return cat.jobs.exists(job2.id)
-        .then(function (exists) {
+        .then(function(exists) {
           should.exist(exists);
           done();
         });
       }).catch(done);
     });
 
-    it('should update a record on scope with promises', function (done) {
+    it('should update a record on scope with promises', function(done) {
       Category.findOne()
-      .then(function (cat) {
+      .then(function(cat) {
         var attrs = { name: 'Job 2 - edit' };
         return cat.jobs.updateById(job2.id, attrs)
-        .then(function (p) {
+        .then(function(p) {
           p.name.should.equal(attrs.name);
           done();
-        })
+        });
       })
       .catch(done);
     });
 
-    it('should get a record by index with promises - at', function (done) {
+    it('should get a record by index with promises - at', function(done) {
       Category.findOne()
-      .then(function (cat) {
-        return cat.jobs.at(0)
+      .then(function(cat) {
+        return cat.jobs.at(0);
       })
-      .then(function (p) {
+      .then(function(p) {
         p.should.be.instanceof(Job);
         p.id.should.eql(job2.id);
         p.name.should.equal('Job 2 - edit');
@@ -5184,11 +5184,11 @@ describe('relations', function () {
       .catch(done);
     });
 
-    it('should add a record to scope with promises - object', function (done) {
+    it('should add a record to scope with promises - object', function(done) {
       Category.findOne()
-      .then(function (cat) {
+      .then(function(cat) {
         return cat.jobs.add(job1)
-        .then(function (prod) {
+        .then(function(prod) {
           cat.jobIds.should.eql([job2.id, job1.id]);
           prod.id.should.eql(job1.id);
           prod.should.have.property('name');
@@ -5198,11 +5198,11 @@ describe('relations', function () {
       .catch(done);
     });
 
-    it('should add a record to scope with promises - object', function (done) {
+    it('should add a record to scope with promises - object', function(done) {
       Category.findOne()
-      .then(function (cat) {
+      .then(function(cat) {
         return cat.jobs.add(job3.id)
-        .then(function (prod) {
+        .then(function(prod) {
           var expected = [job2.id, job1.id, job3.id];
           cat.jobIds.should.eql(expected);
           prod.id.should.eql(job3.id);
@@ -5213,12 +5213,12 @@ describe('relations', function () {
       .catch(done);
     });
 
-    it('should find items on scope with promises - findById', function (done) {
+    it('should find items on scope with promises - findById', function(done) {
       Category.findOne()
-      .then(function (cat) {
-        return cat.jobs.findById(job3.id)
+      .then(function(cat) {
+        return cat.jobs.findById(job3.id);
       })
-      .then(function (p) {
+      .then(function(p) {
         p.id.should.eql(job3.id);
         p.name.should.equal('Job 3');
         done();
@@ -5226,13 +5226,13 @@ describe('relations', function () {
       .catch(done);
     });
 
-    it('should find items on scope with promises - filter', function (done) {
+    it('should find items on scope with promises - filter', function(done) {
       Category.findOne()
-      .then(function (cat) {
-        var filter = { where: { name: 'Job 1' } };
-        return cat.jobs.getAsync(filter)
+      .then(function(cat) {
+        var filter = { where: { name: 'Job 1' }};
+        return cat.jobs.getAsync(filter);
       })
-      .then(function (jobs) {
+      .then(function(jobs) {
         jobs.should.have.length(1);
         var p = jobs[0];
         p.id.should.eql(job1.id);
@@ -5242,11 +5242,11 @@ describe('relations', function () {
       .catch(done);
     });
 
-    it('should remove items from scope with promises', function (done) {
+    it('should remove items from scope with promises', function(done) {
       Category.findOne()
-      .then(function (cat) {
+      .then(function(cat) {
         return cat.jobs.remove(job1.id)
-        .then(function (ids) {
+        .then(function(ids) {
           var expected = [job2.id, job3.id];
           cat.jobIds.should.eql(expected);
           ids.should.eql(cat.jobIds);
@@ -5256,14 +5256,14 @@ describe('relations', function () {
       .catch(done);
     });
 
-    it('should find items on scope with promises - verify', function (done) {
+    it('should find items on scope with promises - verify', function(done) {
       Category.findOne()
-      .then(function (cat) {
+      .then(function(cat) {
         var expected = [job2.id, job3.id];
         cat.jobIds.should.eql(expected);
-        return cat.jobs.getAsync()
+        return cat.jobs.getAsync();
       })
-      .then(function (jobs) {
+      .then(function(jobs) {
         jobs.should.have.length(2);
         jobs[0].id.should.eql(job2.id);
         jobs[1].id.should.eql(job3.id);
@@ -5272,13 +5272,13 @@ describe('relations', function () {
       .catch(done);
     });
 
-    it('should find items on scope and ordered them by name DESC', function (done) {
+    it('should find items on scope and ordered them by name DESC', function(done) {
       Category.find()
-      .then(function (categories) {
+      .then(function(categories) {
         categories.should.have.length(1);
-        return categories[0].jobs.getAsync({order: 'name DESC'})
+        return categories[0].jobs.getAsync({ order: 'name DESC' });
       })
-      .then(function (jobs) {
+      .then(function(jobs) {
         jobs.should.have.length(2);
         jobs[0].id.should.eql(job3.id);
         jobs[1].id.should.eql(job2.id);
@@ -5289,9 +5289,9 @@ describe('relations', function () {
 
     it('should allow custom scope methods with promises - reverse', function(done) {
       Category.findOne()
-      .then(function (cat) {
+      .then(function(cat) {
         return cat.jobs.reverse()
-        .then(function (ids) {
+        .then(function(ids) {
           var expected = [job3.id, job2.id];
           ids.should.eql(expected);
           cat.jobIds.should.eql(expected);
@@ -5303,7 +5303,7 @@ describe('relations', function () {
 
     it('should include related items from scope with promises', function(done) {
       Category.find({ include: 'jobs' })
-      .then(function (categories) {
+      .then(function(categories) {
         categories.should.have.length(1);
         var cat = categories[0].toObject();
         cat.name.should.equal('Category A');
@@ -5314,16 +5314,16 @@ describe('relations', function () {
       }).catch(done);
     });
 
-    it('should destroy items from scope with promises - destroyById', function (done) {
+    it('should destroy items from scope with promises - destroyById', function(done) {
       Category.findOne()
-      .then(function (cat) {
+      .then(function(cat) {
         return cat.jobs.destroy(job2.id)
-        .then(function () {
+        .then(function() {
           var expected = [job3.id];
           cat.jobIds.should.eql(expected);
-          return Job.exists(job2.id)
+          return Job.exists(job2.id);
         })
-        .then(function (exists) {
+        .then(function(exists) {
           should.exist(exists);
           exists.should.be.false;
           done();
@@ -5332,14 +5332,14 @@ describe('relations', function () {
       .catch(done);
     });
 
-    it('should find items on scope with promises - verify', function (done) {
+    it('should find items on scope with promises - verify', function(done) {
       Category.findOne()
-      .then(function (cat) {
+      .then(function(cat) {
         var expected = [job3.id];
         cat.jobIds.should.eql(expected);
-        return cat.jobs.getAsync()
+        return cat.jobs.getAsync();
       })
-      .then(function (jobs) {
+      .then(function(jobs) {
         jobs.should.have.length(1);
         jobs[0].id.should.eql(job3.id);
         done();
@@ -5350,18 +5350,18 @@ describe('relations', function () {
   });
 
 
-  describe('custom relation/scope methods', function () {
+  describe('custom relation/scope methods', function() {
     var categoryId;
 
-    before(function (done) {
+    before(function(done) {
       // db = getSchema();
-      Category = db.define('Category', {name: String});
-      Job = db.define('Job', {name: String});
+      Category = db.define('Category', { name: String });
+      Job = db.define('Job', { name: String });
 
       db.automigrate(['Job', 'Category'], done);
     });
 
-    it('can be declared', function (done) {
+    it('can be declared', function(done) {
       var relation = Category.hasMany(Job);
 
       var summarize = function(cb) {
@@ -5391,21 +5391,21 @@ describe('relations', function () {
       db.automigrate(['Job', 'Category'], done);
     });
 
-    it('should setup test records', function (done) {
+    it('should setup test records', function(done) {
       Category.create({ name: 'Category A' }, function(err, cat) {
         categoryId = cat.id;
         cat.jobs.create({ name: 'Job 1' }, function(err, p) {
           cat.jobs.create({ name: 'Job 2' }, function(err, p) {
             done();
           });
-        })
+        });
       });
     });
 
     it('should allow custom scope methods - summarize', function(done) {
       var expected = [
         { name: 'Job 1', categoryId: categoryId, categoryName: 'Category A' },
-        { name: 'Job 2', categoryId: categoryId, categoryName: 'Category A' }
+        { name: 'Job 2', categoryId: categoryId, categoryName: 'Category A' },
       ];
 
       Category.findOne(function(err, cat) {
@@ -5418,20 +5418,20 @@ describe('relations', function () {
           result.should.eql(expected);
           done();
         });
-      })
+      });
     });
 
     it('should allow custom scope methods with promises - summarize', function(done) {
       var expected = [
         { name: 'Job 1', categoryId: categoryId, categoryName: 'Category A' },
-        { name: 'Job 2', categoryId: categoryId, categoryName: 'Category A' }
+        { name: 'Job 2', categoryId: categoryId, categoryName: 'Category A' },
       ];
 
       Category.findOne()
-      .then(function (cat) {
-        return cat.jobs.summarize()
+      .then(function(cat) {
+        return cat.jobs.summarize();
       })
-      .then(function (summary) {
+      .then(function(summary) {
         var result = summary.map(function(item) {
           delete item.id;
           return item;
diff --git a/test/schema.test.js b/test/schema.test.js
index 7fea45c1..d4497d70 100644
--- a/test/schema.test.js
+++ b/test/schema.test.js
@@ -8,16 +8,16 @@ var should = require('./init.js');
 
 var db = getSchema(), slave = getSchema(), Model, SlaveModel;
 
-describe('dataSource', function () {
+describe('dataSource', function() {
 
-  it('should define Model', function () {
+  it('should define Model', function() {
     Model = db.define('Model');
     Model.dataSource.should.eql(db);
     var m = new Model;
     m.getDataSource().should.eql(db);
   });
 
-  it('should clone existing model', function () {
+  it('should clone existing model', function() {
     SlaveModel = slave.copyModel(Model);
     SlaveModel.dataSource.should.equal(slave);
     slave.should.not.equal(db);
@@ -27,30 +27,30 @@ describe('dataSource', function () {
     sm.getDataSource().should.equal(slave);
   });
 
-  it('should automigrate', function (done) {
+  it('should automigrate', function(done) {
     db.automigrate(done);
   });
 
-  it('should create transaction', function (done) {
+  it('should create transaction', function(done) {
     var tr = db.transaction();
     tr.connected.should.be.false;
     tr.connecting.should.be.false;
     var called = false;
-    tr.models.Model.create(Array(3), function () {
+    tr.models.Model.create(Array(3), function() {
       called = true;
     });
     tr.connected.should.be.false;
     tr.connecting.should.be.true;
 
-    db.models.Model.count(function (err, c) {
+    db.models.Model.count(function(err, c) {
       should.not.exist(err);
       should.exist(c);
       c.should.equal(0);
       called.should.be.false;
-      tr.exec(function () {
-        setTimeout(function () {
+      tr.exec(function() {
+        setTimeout(function() {
           called.should.be.true;
-          db.models.Model.count(function (err, c) {
+          db.models.Model.count(function(err, c) {
             c.should.equal(3);
             done();
           });
diff --git a/test/scope.test.js b/test/scope.test.js
index ba29b78b..9555871b 100644
--- a/test/scope.test.js
+++ b/test/scope.test.js
@@ -8,45 +8,45 @@ var should = require('./init.js');
 
 var db, Railway, Station;
 
-describe('scope', function () {
+describe('scope', function() {
 
-  before(function () {
+  before(function() {
     db = getSchema();
     Railway = db.define('Railway', {
-      URID: {type: String, index: true}
+      URID: { type: String, index: true },
     }, {
       scopes: {
         highSpeed: {
           where: {
-            highSpeed: true
-          }
-        }
-      }
+            highSpeed: true,
+          },
+        },
+      },
     });
     Station = db.define('Station', {
-      USID: {type: String, index: true},
-      capacity: {type: Number, index: true},
-      thoughput: {type: Number, index: true},
-      isActive: {type: Boolean, index: true},
-      isUndeground: {type: Boolean, index: true}
+      USID: { type: String, index: true },
+      capacity: { type: Number, index: true },
+      thoughput: { type: Number, index: true },
+      isActive: { type: Boolean, index: true },
+      isUndeground: { type: Boolean, index: true },
     });
   });
 
-  beforeEach(function (done) {
-    Railway.destroyAll(function () {
+  beforeEach(function(done) {
+    Railway.destroyAll(function() {
       Station.destroyAll(done);
     });
   });
 
-  it('should define scope using options.scopes', function () {
+  it('should define scope using options.scopes', function() {
     Railway.scopes.should.have.property('highSpeed');
     Railway.highSpeed.should.be.function;
   });
 
-  it('should define scope with query', function (done) {
-    Station.scope('active', {where: {isActive: true}});
+  it('should define scope with query', function(done) {
+    Station.scope('active', { where: { isActive: true }});
     Station.scopes.should.have.property('active');
-    Station.active.create(function (err, station) {
+    Station.active.create(function(err, station) {
       should.not.exist(err);
       should.exist(station);
       should.exist(station.isActive);
@@ -55,35 +55,35 @@ describe('scope', function () {
     });
   });
 
-  it('should allow scope chaining', function (done) {
-    Station.scope('active', {where: {isActive: true}});
-    Station.scope('subway', {where: {isUndeground: true}});
-    Station.active.subway.create(function (err, station) {
+  it('should allow scope chaining', function(done) {
+    Station.scope('active', { where: { isActive: true }});
+    Station.scope('subway', { where: { isUndeground: true }});
+    Station.active.subway.create(function(err, station) {
       should.not.exist(err);
       should.exist(station);
       station.isActive.should.be.true;
       station.isUndeground.should.be.true;
       done();
-    })
+    });
   });
 
-  it('should query all', function (done) {
-    Station.scope('active', {where: {isActive: true}});
-    Station.scope('inactive', {where: {isActive: false}});
-    Station.scope('ground', {where: {isUndeground: true}});
-    Station.active.ground.create(function () {
-      Station.inactive.ground.create(function () {
-        Station.ground.inactive(function (err, ss) {
+  it('should query all', function(done) {
+    Station.scope('active', { where: { isActive: true }});
+    Station.scope('inactive', { where: { isActive: false }});
+    Station.scope('ground', { where: { isUndeground: true }});
+    Station.active.ground.create(function() {
+      Station.inactive.ground.create(function() {
+        Station.ground.inactive(function(err, ss) {
           ss.should.have.lengthOf(1);
           done();
         });
       });
     });
   });
-  
-  it('should not cache any results', function (done) {
-    Station.scope('active', {where: {isActive: true}});
-    Station.active.create(function (err, s) {
+
+  it('should not cache any results', function(done) {
+    Station.scope('active', { where: { isActive: true }});
+    Station.active.create(function(err, s) {
       if (err) return done(err);
       s.isActive.should.be.true;
       Station.active(function(err, ss) {
@@ -105,34 +105,34 @@ describe('scope', function () {
 
 });
 
-describe('scope - order', function () {
+describe('scope - order', function() {
 
-  before(function () {
+  before(function() {
     db = getSchema();
     Station = db.define('Station', {
-      name: {type: String, index: true},
-      order: {type: Number, index: true}
+      name: { type: String, index: true },
+      order: { type: Number, index: true },
     });
-    Station.scope('reverse', {order: 'order DESC'});
+    Station.scope('reverse', { order: 'order DESC' });
   });
 
-  beforeEach(function (done) {
+  beforeEach(function(done) {
     Station.destroyAll(done);
   });
 
-  beforeEach(function (done) {
+  beforeEach(function(done) {
     Station.create({ name: 'a', order: 1 }, done);
   });
 
-  beforeEach(function (done) {
+  beforeEach(function(done) {
     Station.create({ name: 'b', order: 2 }, done);
   });
 
-  beforeEach(function (done) {
+  beforeEach(function(done) {
     Station.create({ name: 'c', order: 3 }, done);
   });
 
-  it('should define scope with default order', function (done) {
+  it('should define scope with default order', function(done) {
     Station.reverse(function(err, stations) {
       stations[0].name.should.equal('c');
       stations[0].order.should.equal(3);
@@ -144,8 +144,8 @@ describe('scope - order', function () {
     });
   });
 
-  it('should override default scope order', function (done) {
-    Station.reverse({order: 'order ASC'}, function(err, stations) {
+  it('should override default scope order', function(done) {
+    Station.reverse({ order: 'order ASC' }, function(err, stations) {
       stations[0].name.should.equal('a');
       stations[0].order.should.equal(1);
       stations[1].name.should.equal('b');
@@ -158,128 +158,128 @@ describe('scope - order', function () {
 
 });
 
-describe('scope - filtered count, updateAll and destroyAll', function () {
+describe('scope - filtered count, updateAll and destroyAll', function() {
 
   var stationA;
 
-  before(function () {
+  before(function() {
     db = getSchema();
     Station = db.define('Station', {
-      name: {type: String, index: true},
-      order: {type: Number, index: true},
-      active: {type: Boolean, index: true, default: true},
-      flagged: {type: Boolean, index: true, default: false}
+      name: { type: String, index: true },
+      order: { type: Number, index: true },
+      active: { type: Boolean, index: true, default: true },
+      flagged: { type: Boolean, index: true, default: false },
     });
-    Station.scope('ordered', {order: 'order'});
-    Station.scope('active', {where: { active: true}});
-    Station.scope('inactive', {where: { active: false}});
-    Station.scope('flagged', {where: { flagged: true}});
+    Station.scope('ordered', { order: 'order' });
+    Station.scope('active', { where: { active: true }});
+    Station.scope('inactive', { where: { active: false }});
+    Station.scope('flagged', { where: { flagged: true }});
   });
 
-  beforeEach(function (done) {
+  beforeEach(function(done) {
     Station.destroyAll(done);
   });
 
-  beforeEach(function (done) {
+  beforeEach(function(done) {
     Station.create({ name: 'b', order: 2, active: false }, done);
   });
 
-  beforeEach(function (done) {
+  beforeEach(function(done) {
     Station.create({ name: 'a', order: 1 }, function(err, inst) {
       stationA = inst;
       done();
     });
   });
 
-  beforeEach(function (done) {
+  beforeEach(function(done) {
     Station.create({ name: 'd', order: 4, active: false }, done);
   });
 
-  beforeEach(function (done) {
+  beforeEach(function(done) {
     Station.create({ name: 'c', order: 3 }, done);
   });
 
   it('should find all - verify', function(done) {
     Station.ordered(function(err, stations) {
-        should.not.exist(err);
-        stations.should.have.length(4);
-        stations[0].name.should.equal('a');
-        stations[1].name.should.equal('b');
-        stations[2].name.should.equal('c');
-        stations[3].name.should.equal('d');
-        done();
+      should.not.exist(err);
+      stations.should.have.length(4);
+      stations[0].name.should.equal('a');
+      stations[1].name.should.equal('b');
+      stations[2].name.should.equal('c');
+      stations[3].name.should.equal('d');
+      done();
     });
   });
 
   it('should find one', function(done) {
     Station.active.findOne(function(err, station) {
-        should.not.exist(err);
-        station.name.should.equal('a');
-        done();
+      should.not.exist(err);
+      station.name.should.equal('a');
+      done();
     });
   });
 
   it('should find one - with filter', function(done) {
-    Station.active.findOne({ where: { name: 'c' } }, function(err, station) {
-        should.not.exist(err);
-        station.name.should.equal('c');
-        done();
+    Station.active.findOne({ where: { name: 'c' }}, function(err, station) {
+      should.not.exist(err);
+      station.name.should.equal('c');
+      done();
     });
   });
 
   it('should find by id - match', function(done) {
     Station.active.findById(stationA.id, function(err, station) {
-        should.not.exist(err);
-        station.name.should.equal('a');
-        done();
+      should.not.exist(err);
+      station.name.should.equal('a');
+      done();
     });
   });
 
   it('should find by id - no match', function(done) {
     Station.inactive.findById(stationA.id, function(err, station) {
-        should.not.exist(err);
-        should.not.exist(station);
-        done();
+      should.not.exist(err);
+      should.not.exist(station);
+      done();
     });
   });
 
   it('should count all in scope - active', function(done) {
     Station.active.count(function(err, count) {
-        should.not.exist(err);
-        count.should.equal(2);
-        done();
+      should.not.exist(err);
+      count.should.equal(2);
+      done();
     });
   });
 
   it('should count all in scope - inactive', function(done) {
     Station.inactive.count(function(err, count) {
-        should.not.exist(err);
-        count.should.equal(2);
-        done();
+      should.not.exist(err);
+      count.should.equal(2);
+      done();
     });
   });
 
   it('should count filtered - active', function(done) {
-    Station.active.count({ order: { gt: 1 } }, function(err, count) {
-        should.not.exist(err);
-        count.should.equal(1);
-        done();
+    Station.active.count({ order: { gt: 1 }}, function(err, count) {
+      should.not.exist(err);
+      count.should.equal(1);
+      done();
     });
   });
 
   it('should count filtered - inactive', function(done) {
     Station.inactive.count({ order: 2 }, function(err, count) {
-        should.not.exist(err);
-        count.should.equal(1);
-        done();
+      should.not.exist(err);
+      count.should.equal(1);
+      done();
     });
   });
 
   it('should allow updateAll', function(done) {
     Station.inactive.updateAll({ flagged: true }, function(err, result) {
-        should.not.exist(err);
-        result.count.should.equal(2);
-        verify();
+      should.not.exist(err);
+      result.count.should.equal(2);
+      verify();
     });
 
     var verify = function() {
@@ -293,9 +293,9 @@ describe('scope - filtered count, updateAll and destroyAll', function () {
 
   it('should allow filtered updateAll', function(done) {
     Station.ordered.updateAll({ active: true }, { flagged: true }, function(err, result) {
-        should.not.exist(err);
-        result.count.should.equal(2);
-        verify();
+      should.not.exist(err);
+      result.count.should.equal(2);
+      verify();
     });
 
     var verify = function() {
@@ -309,8 +309,8 @@ describe('scope - filtered count, updateAll and destroyAll', function () {
 
   it('should allow filtered destroyAll', function(done) {
     Station.ordered.destroyAll({ active: false }, function(err) {
-        should.not.exist(err);
-        verify();
+      should.not.exist(err);
+      verify();
     });
 
     var verify = function() {
@@ -318,9 +318,9 @@ describe('scope - filtered count, updateAll and destroyAll', function () {
         should.not.exist(err);
         count.should.equal(2);
         Station.inactive.count(function(err, count) {
-            should.not.exist(err);
-            count.should.equal(0);
-            done();
+          should.not.exist(err);
+          count.should.equal(0);
+          done();
         });
       });
     };
@@ -328,17 +328,17 @@ describe('scope - filtered count, updateAll and destroyAll', function () {
 
 });
 
-describe('scope - dynamic target class', function () {
+describe('scope - dynamic target class', function() {
 
   var Collection, Media, Image, Video;
 
 
-  before(function () {
+  before(function() {
     db = getSchema();
-    Image = db.define('Image', {name: String});
-    Video = db.define('Video', {name: String});
+    Image = db.define('Image', { name: String });
+    Video = db.define('Video', { name: String });
 
-    Collection = db.define('Collection', {name: String, modelName: String});
+    Collection = db.define('Collection', { name: String, modelName: String });
     Collection.scope('items', function() {
       return {}; // could return a scope based on `this` (receiver)
     }, null, {}, { isStatic: false, modelTo: function(receiver) {
@@ -346,36 +346,36 @@ describe('scope - dynamic target class', function () {
     } });
   });
 
-  beforeEach(function (done) {
+  beforeEach(function(done) {
     Collection.destroyAll(function() {
       Image.destroyAll(function() {
         Video.destroyAll(done);
-      })
+      });
     });
   });
 
-  beforeEach(function (done) {
+  beforeEach(function(done) {
     Collection.create({ name: 'Images', modelName: 'Image' }, done);
   });
 
-  beforeEach(function (done) {
+  beforeEach(function(done) {
     Collection.create({ name: 'Videos', modelName: 'Video' }, done);
   });
 
-  beforeEach(function (done) {
+  beforeEach(function(done) {
     Collection.create({ name: 'Things', modelName: 'Unknown' }, done);
   });
 
-  beforeEach(function (done) {
+  beforeEach(function(done) {
     Image.create({ name: 'Image A' }, done);
   });
 
-  beforeEach(function (done) {
+  beforeEach(function(done) {
     Video.create({ name: 'Video A' }, done);
   });
 
   it('should deduce modelTo at runtime - Image', function(done) {
-    Collection.findOne({ where: { modelName: 'Image' } }, function(err, coll) {
+    Collection.findOne({ where: { modelName: 'Image' }}, function(err, coll) {
       should.not.exist(err);
       coll.name.should.equal('Images');
       coll.items(function(err, items) {
@@ -389,7 +389,7 @@ describe('scope - dynamic target class', function () {
   });
 
   it('should deduce modelTo at runtime - Video', function(done) {
-    Collection.findOne({ where: { modelName: 'Video' } }, function(err, coll) {
+    Collection.findOne({ where: { modelName: 'Video' }}, function(err, coll) {
       should.not.exist(err);
       coll.name.should.equal('Videos');
       coll.items(function(err, items) {
@@ -403,10 +403,10 @@ describe('scope - dynamic target class', function () {
   });
 
   it('should throw if modelTo is invalid', function(done) {
-    Collection.findOne({ where: { name: 'Things' } }, function(err, coll) {
+    Collection.findOne({ where: { name: 'Things' }}, function(err, coll) {
       should.not.exist(err);
       coll.modelName.should.equal('Unknown');
-      (function () {
+      (function() {
         coll.items(function(err, items) {});
       }).should.throw();
       done();
@@ -415,34 +415,34 @@ describe('scope - dynamic target class', function () {
 
 });
 
-describe('scope - dynamic function', function () {
+describe('scope - dynamic function', function() {
 
-  var Item,seed=0;
+  var Item, seed = 0;
 
-  before(function () {
+  before(function() {
     db = getSchema();
-    Item = db.define('Item', {title: Number,creator:Number});
-    Item.scope('dynamicQuery', function () {
+    Item = db.define('Item', { title: Number, creator:Number });
+    Item.scope('dynamicQuery', function() {
       seed++;
-      return {where:{creator:seed}};
-    })
+      return { where:{ creator:seed }};
+    });
   });
 
-  beforeEach(function (done) {
-    Item.create({ title:1,creator:1 }, function () {
-      Item.create({ title:2,creator:2 },done)
-    })
+  beforeEach(function(done) {
+    Item.create({ title:1, creator:1 }, function() {
+      Item.create({ title:2, creator:2 }, done);
+    });
   });
 
-  it('should deduce item by runtime creator', function (done) {
-    Item.dynamicQuery.findOne(function (err,firstQuery) {
+  it('should deduce item by runtime creator', function(done) {
+    Item.dynamicQuery.findOne(function(err, firstQuery) {
       should.not.exist(err);
       firstQuery.title.should.equal(1);
-      Item.dynamicQuery.findOne(function (err,secondQuery) {
+      Item.dynamicQuery.findOne(function(err, secondQuery) {
         should.not.exist(err);
         secondQuery.title.should.equal(2);
         done();
-      })
-    })
-  })
+      });
+    });
+  });
 });
diff --git a/test/spec_helper.js b/test/spec_helper.js
index e2f6e087..d2a0221d 100644
--- a/test/spec_helper.js
+++ b/test/spec_helper.js
@@ -28,12 +28,12 @@ function context(name, tests) {
   EXT_EXP[name] = {};
   group_name = name;
   tests({
-    before: function (f) {
+    before: function(f) {
       it('setUp', f);
     },
-    after: function (f) {
+    after: function(f) {
       it('tearDown', f);
-    }
+    },
   });
   group_name = false;
 }
diff --git a/test/transient.test.js b/test/transient.test.js
index e3409b87..6d9745bc 100644
--- a/test/transient.test.js
+++ b/test/transient.test.js
@@ -12,32 +12,32 @@ var should = require('./init.js');
 var db, TransientModel, Person, Widget, Item;
 
 var getTransientDataSource = function(settings) {
-    return new DataSource('transient', settings);
+  return new DataSource('transient', settings);
 };
 
-describe('Transient connector', function () {
-  
-  before(function () {
+describe('Transient connector', function() {
+
+  before(function() {
     db = getTransientDataSource();
     TransientModel = db.define('TransientModel', {}, { idInjection: false });
-    
-    Person = TransientModel.extend('Person', {name: String});
+
+    Person = TransientModel.extend('Person', { name: String });
     Person.attachTo(db);
-    
-    Widget = db.define('Widget', {name: String});
+
+    Widget = db.define('Widget', { name: String });
     Item = db.define('Item', {
-      id: {type: Number, id: true}, name: String
+      id: { type: Number, id: true }, name: String,
     });
   });
-  
+
   it('should respect idInjection being false', function(done) {
     should.not.exist(Person.definition.properties.id);
     should.exist(Person.definition.properties.name);
-    
+
     Person.create({ name: 'Wilma' }, function(err, inst) {
       should.not.exist(err);
       inst.toObject().should.eql({ name: 'Wilma' });
-      
+
       Person.count(function(err, count) {
         should.not.exist(err);
         count.should.equal(0);
@@ -45,18 +45,18 @@ describe('Transient connector', function () {
       });
     });
   });
-  
+
   it('should generate a random string id', function(done) {
     should.exist(Widget.definition.properties.id);
     should.exist(Widget.definition.properties.name);
-    
+
     Widget.definition.properties.id.type.should.equal(String);
-    
+
     Widget.create({ name: 'Thing' }, function(err, inst) {
       should.not.exist(err);
       inst.id.should.match(/^[0-9a-fA-F]{24}$/);
       inst.name.should.equal('Thing');
-      
+
       Widget.findById(inst.id, function(err, widget) {
         should.not.exist(err);
         should.not.exist(widget);
@@ -64,17 +64,17 @@ describe('Transient connector', function () {
       });
     });
   });
-  
+
   it('should generate a random number id', function(done) {
     should.exist(Item.definition.properties.id);
     should.exist(Item.definition.properties.name);
-    
+
     Item.definition.properties.id.type.should.equal(Number);
-    
+
     Item.create({ name: 'Example' }, function(err, inst) {
       should.not.exist(err);
       inst.name.should.equal('Example');
-      
+
       Item.count(function(err, count) {
         should.not.exist(err);
         count.should.equal(0);
@@ -82,5 +82,5 @@ describe('Transient connector', function () {
       });
     });
   });
-  
+
 });
diff --git a/test/util.test.js b/test/util.test.js
index d3ee9df4..30799839 100644
--- a/test/util.test.js
+++ b/test/util.test.js
@@ -12,54 +12,54 @@ var mergeIncludes = utils.mergeIncludes;
 var sortObjectsByIds = utils.sortObjectsByIds;
 var uniq = utils.uniq;
 
-describe('util.fieldsToArray', function () {
+describe('util.fieldsToArray', function() {
   function sample(fields, excludeUnknown) {
     var properties = ['foo', 'bar', 'bat', 'baz'];
     return {
-      expect: function (arr) {
+      expect: function(arr) {
         should.deepEqual(fieldsToArray(fields, properties, excludeUnknown), arr);
-      }
+      },
     };
   }
 
   it('Turn objects and strings into an array of fields' +
-    ' to include when finding models', function () {
+    ' to include when finding models', function() {
 
     sample(false).expect(undefined);
     sample(null).expect(undefined);
     sample({}).expect(undefined);
     sample('foo').expect(['foo']);
     sample(['foo']).expect(['foo']);
-    sample({'foo': 1}).expect(['foo']);
-    sample({'bat': true}).expect(['bat']);
-    sample({'bat': 0}).expect(['foo', 'bar', 'baz']);
-    sample({'bat': false}).expect(['foo', 'bar', 'baz']);
+    sample({ 'foo': 1 }).expect(['foo']);
+    sample({ 'bat': true }).expect(['bat']);
+    sample({ 'bat': 0 }).expect(['foo', 'bar', 'baz']);
+    sample({ 'bat': false }).expect(['foo', 'bar', 'baz']);
   });
 
-  it('should exclude unknown properties', function () {
+  it('should exclude unknown properties', function() {
 
     sample(false, true).expect(undefined);
     sample(null, true).expect(undefined);
     sample({}, true).expect(undefined);
     sample('foo', true).expect(['foo']);
     sample(['foo', 'unknown'], true).expect(['foo']);
-    sample({'foo': 1, unknown: 1}, true).expect(['foo']);
-    sample({'bat': true, unknown: true}, true).expect(['bat']);
-    sample({'bat': 0}, true).expect(['foo', 'bar', 'baz']);
-    sample({'bat': false}, true).expect(['foo', 'bar', 'baz']);
+    sample({ 'foo': 1, unknown: 1 }, true).expect(['foo']);
+    sample({ 'bat': true, unknown: true }, true).expect(['bat']);
+    sample({ 'bat': 0 }, true).expect(['foo', 'bar', 'baz']);
+    sample({ 'bat': false }, true).expect(['foo', 'bar', 'baz']);
   });
 });
 
-describe('util.removeUndefined', function () {
-  it('Remove undefined values from the query object', function () {
-    var q1 = {where: {x: 1, y: undefined}};
-    should.deepEqual(removeUndefined(q1), {where: {x: 1}});
+describe('util.removeUndefined', function() {
+  it('Remove undefined values from the query object', function() {
+    var q1 = { where: { x: 1, y: undefined }};
+    should.deepEqual(removeUndefined(q1), { where: { x: 1 }});
 
-    var q2 = {where: {x: 1, y: 2}};
-    should.deepEqual(removeUndefined(q2), {where: {x: 1, y: 2}});
+    var q2 = { where: { x: 1, y: 2 }};
+    should.deepEqual(removeUndefined(q2), { where: { x: 1, y: 2 }});
 
-    var q3 = {where: {x: 1, y: {in: [2, undefined]}}};
-    should.deepEqual(removeUndefined(q3), {where: {x: 1, y: {in: [2]}}});
+    var q3 = { where: { x: 1, y: { in: [2, undefined] }}};
+    should.deepEqual(removeUndefined(q3), { where: { x: 1, y: { in: [2] }}});
 
     should.equal(removeUndefined(null), null);
 
@@ -68,21 +68,21 @@ describe('util.removeUndefined', function () {
     should.equal(removeUndefined('x'), 'x');
 
     var date = new Date();
-    var q4 = {where: {x: 1, y: date}};
-    should.deepEqual(removeUndefined(q4), {where: {x: 1, y: date}});
+    var q4 = { where: { x: 1, y: date }};
+    should.deepEqual(removeUndefined(q4), { where: { x: 1, y: date }});
 
     // test handling of undefined
-    var q5 = {where: {x: 1, y: undefined}};
-    should.deepEqual(removeUndefined(q5, 'nullify'), {where: {x: 1, y: null}});
+    var q5 = { where: { x: 1, y: undefined }};
+    should.deepEqual(removeUndefined(q5, 'nullify'), { where: { x: 1, y: null }});
 
-    var q6 = {where: {x: 1, y: undefined}};
-    (function(){ removeUndefined(q6, 'throw') }).should.throw(/`undefined` in query/);
+    var q6 = { where: { x: 1, y: undefined }};
+    (function() { removeUndefined(q6, 'throw'); }).should.throw(/`undefined` in query/);
 
   });
 });
 
-describe('util.parseSettings', function () {
-  it('Parse a full url into a settings object', function () {
+describe('util.parseSettings', function() {
+  it('Parse a full url into a settings object', function() {
     var url = 'mongodb://x:y@localhost:27017/mydb?w=2';
     var settings = utils.parseSettings(url);
     should.equal(settings.hostname, 'localhost');
@@ -97,7 +97,7 @@ describe('util.parseSettings', function () {
 
   });
 
-  it('Parse a url without auth into a settings object', function () {
+  it('Parse a url without auth into a settings object', function() {
     var url = 'mongodb://localhost:27017/mydb/abc?w=2';
     var settings = utils.parseSettings(url);
     should.equal(settings.hostname, 'localhost');
@@ -112,7 +112,7 @@ describe('util.parseSettings', function () {
 
   });
 
-  it('Parse a url with complex query into a settings object', function () {
+  it('Parse a url with complex query into a settings object', function() {
     var url = 'mysql://127.0.0.1:3306/mydb?x[a]=1&x[b]=2&engine=InnoDB';
     var settings = utils.parseSettings(url);
     should.equal(settings.hostname, '127.0.0.1');
@@ -129,7 +129,7 @@ describe('util.parseSettings', function () {
 
   });
 
-  it('Parse a url without auth into a settings object', function () {
+  it('Parse a url without auth into a settings object', function() {
     var url = 'memory://?x=1';
     var settings = utils.parseSettings(url);
     should.equal(settings.hostname, '');
@@ -144,12 +144,12 @@ describe('util.parseSettings', function () {
 
 });
 
-describe('mergeSettings', function () {
-  it('should merge settings correctly', function () {
+describe('mergeSettings', function() {
+  it('should merge settings correctly', function() {
     var src = { base: 'User',
       relations: { accessTokens: { model: 'accessToken', type: 'hasMany',
         foreignKey: 'userId' },
-        account: { model: 'account', type: 'belongsTo' } },
+        account: { model: 'account', type: 'belongsTo' }},
       acls: [
         { accessType: '*',
           permission: 'DENY',
@@ -163,7 +163,7 @@ describe('mergeSettings', function () {
         { permission: 'ALLOW',
           property: 'findById',
           principalType: 'ROLE',
-          principalId: '$owner' }
+          principalId: '$owner' },
       ] };
     var tgt = { strict: false,
       acls: [
@@ -174,7 +174,7 @@ describe('mergeSettings', function () {
         { principalType: 'ROLE',
           principalId: '$owner',
           permission: 'ALLOW',
-          property: 'removeById' }
+          property: 'removeById' },
       ],
       maxTTL: 31556926,
       ttl: 1209600 };
@@ -203,20 +203,20 @@ describe('mergeSettings', function () {
         { permission: 'ALLOW',
           property: 'findById',
           principalType: 'ROLE',
-          principalId: '$owner' }
+          principalId: '$owner' },
       ],
       maxTTL: 31556926,
       ttl: 1209600,
       base: 'User',
       relations: { accessTokens: { model: 'accessToken', type: 'hasMany',
         foreignKey: 'userId' },
-        account: { model: 'account', type: 'belongsTo' } } };
+        account: { model: 'account', type: 'belongsTo' }}};
 
     should.deepEqual(dst.acls, expected.acls, 'Merged settings should match the expectation');
   });
 });
 
-describe('sortObjectsByIds', function () {
+describe('sortObjectsByIds', function() {
 
   var items = [
     { id: 1, name: 'a' },
@@ -224,7 +224,7 @@ describe('sortObjectsByIds', function () {
     { id: 3, name: 'c' },
     { id: 4, name: 'd' },
     { id: 5, name: 'e' },
-    { id: 6, name: 'f' }
+    { id: 6, name: 'f' },
   ];
 
   it('should sort', function() {
@@ -247,7 +247,7 @@ describe('sortObjectsByIds', function () {
 
 });
 
-describe('util.mergeIncludes', function () {
+describe('util.mergeIncludes', function() {
 
   function checkInputOutput(baseInclude, updateInclude, expectedInclude) {
     var mergedInclude = mergeIncludes(baseInclude, updateInclude);
@@ -259,8 +259,8 @@ describe('util.mergeIncludes', function () {
     var baseInclude = 'relation1';
     var updateInclude = 'relation2';
     var expectedInclude = [
-      {relation2: true},
-      {relation1: true}
+      { relation2: true },
+      { relation1: true },
     ];
     checkInputOutput(baseInclude, updateInclude, expectedInclude);
   });
@@ -269,18 +269,18 @@ describe('util.mergeIncludes', function () {
     var baseInclude = 'relation1';
     var updateInclude = ['relation2'];
     var expectedInclude = [
-      {relation2: true},
-      {relation1: true}
+      { relation2: true },
+      { relation1: true },
     ];
     checkInputOutput(baseInclude, updateInclude, expectedInclude);
   });
 
   it('Merge string & object values to object', function() {
     var baseInclude = ['relation1'];
-    var updateInclude = {relation2: 'relation2Include'};
+    var updateInclude = { relation2: 'relation2Include' };
     var expectedInclude = [
-      {relation2: 'relation2Include'},
-      {relation1: true}
+      { relation2: 'relation2Include' },
+      { relation1: true },
     ];
     checkInputOutput(baseInclude, updateInclude, expectedInclude);
   });
@@ -289,37 +289,37 @@ describe('util.mergeIncludes', function () {
     var baseInclude = ['relation1'];
     var updateInclude = ['relation2'];
     var expectedInclude = [
-      {relation2: true},
-      {relation1: true}
+      { relation2: true },
+      { relation1: true },
     ];
     checkInputOutput(baseInclude, updateInclude, expectedInclude);
   });
 
   it('Merge array & object values to object', function() {
     var baseInclude = ['relation1'];
-    var updateInclude = {relation2: 'relation2Include'};
+    var updateInclude = { relation2: 'relation2Include' };
     var expectedInclude = [
-      {relation2: 'relation2Include'},
-      {relation1: true}
+      { relation2: 'relation2Include' },
+      { relation1: true },
     ];
     checkInputOutput(baseInclude, updateInclude, expectedInclude);
   });
 
   it('Merge object & object values to object', function() {
-    var baseInclude = {relation1: 'relation1Include'};
-    var updateInclude = {relation2: 'relation2Include'};
+    var baseInclude = { relation1: 'relation1Include' };
+    var updateInclude = { relation2: 'relation2Include' };
     var expectedInclude = [
-      {relation2: 'relation2Include'},
-      {relation1: 'relation1Include'}
+      { relation2: 'relation2Include' },
+      { relation1: 'relation1Include' },
     ];
     checkInputOutput(baseInclude, updateInclude, expectedInclude);
   });
 
   it('Override property collision with update value', function() {
-    var baseInclude = {relation1: 'baseValue'};
-    var updateInclude = {relation1: 'updateValue'};
+    var baseInclude = { relation1: 'baseValue' };
+    var updateInclude = { relation1: 'updateValue' };
     var expectedInclude = [
-      {relation1: 'updateValue'}
+      { relation1: 'updateValue' },
     ];
     checkInputOutput(baseInclude, updateInclude, expectedInclude);
   });
@@ -327,9 +327,9 @@ describe('util.mergeIncludes', function () {
   it('Merge string includes & include with relation syntax properly',
     function() {
       var baseInclude = 'relation1';
-      var updateInclude = {relation: 'relation1'};
+      var updateInclude = { relation: 'relation1' };
       var expectedInclude = [
-        {relation: 'relation1'}
+        { relation: 'relation1' },
       ];
       checkInputOutput(baseInclude, updateInclude, expectedInclude);
     });
@@ -338,10 +338,10 @@ describe('util.mergeIncludes', function () {
     var baseInclude = 'relation1';
     var updateInclude = {
       relation: 'relation1',
-      scope: {include: 'relation2'}
+      scope: { include: 'relation2' },
     };
     var expectedInclude = [
-      {relation: 'relation1', scope: {include: 'relation2'}}
+      { relation: 'relation1', scope: { include: 'relation2' }},
     ];
     checkInputOutput(baseInclude, updateInclude, expectedInclude);
   });
@@ -352,39 +352,39 @@ describe('util.mergeIncludes', function () {
       var baseInclude = ['relation2'];
       var updateInclude = {
         relation: 'relation1',
-        scope: {include: 'relation2'}
+        scope: { include: 'relation2' },
       };
       var expectedInclude = [{
         relation: 'relation1',
-        scope: {include: 'relation2'}
-      }, {relation2: true}];
+        scope: { include: 'relation2' },
+      }, { relation2: true }];
       checkInputOutput(baseInclude, updateInclude, expectedInclude);
 
       //w & w/o relation syntax - collision
       baseInclude = ['relation1'];
-      updateInclude = {relation: 'relation1', scope: {include: 'relation2'}};
+      updateInclude = { relation: 'relation1', scope: { include: 'relation2' }};
       expectedInclude =
-        [{relation: 'relation1', scope: {include: 'relation2'}}];
+        [{ relation: 'relation1', scope: { include: 'relation2' }}];
       checkInputOutput(baseInclude, updateInclude, expectedInclude);
 
       //w & w/o relation syntax - collision
-      baseInclude = {relation: 'relation1', scope: {include: 'relation2'}};
+      baseInclude = { relation: 'relation1', scope: { include: 'relation2' }};
       updateInclude = ['relation1'];
-      expectedInclude = [{relation1: true}];
+      expectedInclude = [{ relation1: true }];
       checkInputOutput(baseInclude, updateInclude, expectedInclude);
     });
 
   it('Merge includes with mixture of strings, arrays & objects properly', function() {
-    var baseInclude = ['relation1', {relation2: true},
-      {relation: 'relation3', scope: {where: {id: 'some id'}}},
-      {relation: 'relation5', scope: {where: {id: 'some id'}}}
+    var baseInclude = ['relation1', { relation2: true },
+      { relation: 'relation3', scope: { where: { id: 'some id' }}},
+      { relation: 'relation5', scope: { where: { id: 'some id' }}},
     ];
-    var updateInclude = ['relation4', {relation3: true},
-      {relation: 'relation2', scope: {where: {id: 'some id'}}}];
-    var expectedInclude = [{relation4: true}, {relation3: true},
-      {relation: 'relation2', scope: {where: {id: 'some id'}}},
-      {relation1: true},
-      {relation: 'relation5', scope: {where: {id: 'some id'}}}];
+    var updateInclude = ['relation4', { relation3: true },
+      { relation: 'relation2', scope: { where: { id: 'some id' }}}];
+    var expectedInclude = [{ relation4: true }, { relation3: true },
+      { relation: 'relation2', scope: { where: { id: 'some id' }}},
+      { relation1: true },
+      { relation: 'relation5', scope: { where: { id: 'some id' }}}];
     checkInputOutput(baseInclude, updateInclude, expectedInclude);
   });
 });
@@ -457,18 +457,18 @@ describe('util.toRegExp', function() {
   context('with a regex string', function() {
     it('should return a RegExp object when no regex flags are provided',
         function() {
-      utils.toRegExp('^regex$').should.be.an.instanceOf(RegExp);
-    });
+          utils.toRegExp('^regex$').should.be.an.instanceOf(RegExp);
+        });
 
     it('should throw an error when invalid regex flags are provided',
         function() {
-      utils.toRegExp('^regex$/abc').should.be.an.Error;
-    });
+          utils.toRegExp('^regex$/abc').should.be.an.Error;
+        });
 
     it('should return a RegExp object when valid flags are provided',
         function() {
-      utils.toRegExp('regex/igm').should.be.an.instanceOf(RegExp);
-    });
+          utils.toRegExp('regex/igm').should.be.an.instanceOf(RegExp);
+        });
   });
 
   context('with a regex literal', function() {
diff --git a/test/validations.test.js b/test/validations.test.js
index 2941ddeb..bc589a75 100644
--- a/test/validations.test.js
+++ b/test/validations.test.js
@@ -18,15 +18,15 @@ function getValidAttributes() {
     age: 26,
     gender: 'male',
     createdByAdmin: false,
-    createdByScript: true
+    createdByScript: true,
   };
 }
 
-describe('validations', function () {
+describe('validations', function() {
 
   var User, Entry;
 
-  before(function (done) {
+  before(function(done) {
     db = getSchema();
     User = db.define('User', {
       email: String,
@@ -39,33 +39,33 @@ describe('validations', function () {
       pendingPeriod: Number,
       createdByAdmin: Boolean,
       createdByScript: Boolean,
-      updatedAt: Date
+      updatedAt: Date,
     });
     Entry = db.define('Entry', {
       id: { type: 'string', id: true, generated: false },
-      name: { type: 'string' }
+      name: { type: 'string' },
     });
     Entry.validatesUniquenessOf('id');
     db.automigrate(done);
   });
 
-  beforeEach(function (done) {
-    User.destroyAll(function () {
+  beforeEach(function(done) {
+    User.destroyAll(function() {
       delete User.validations;
       done();
     });
   });
 
-  after(function () {
+  after(function() {
     // db.disconnect();
   });
 
-  describe('commons', function () {
+  describe('commons', function() {
 
-    describe('skipping', function () {
+    describe('skipping', function() {
 
-      it('should NOT skip when `if` is fulfilled', function () {
-        User.validatesPresenceOf('pendingPeriod', {if: 'createdByAdmin'});
+      it('should NOT skip when `if` is fulfilled', function() {
+        User.validatesPresenceOf('pendingPeriod', { if: 'createdByAdmin' });
         var user = new User;
         user.createdByAdmin = true;
         user.isValid().should.be.false;
@@ -74,8 +74,8 @@ describe('validations', function () {
         user.isValid().should.be.true;
       });
 
-      it('should skip when `if` is NOT fulfilled', function () {
-        User.validatesPresenceOf('pendingPeriod', {if: 'createdByAdmin'});
+      it('should skip when `if` is NOT fulfilled', function() {
+        User.validatesPresenceOf('pendingPeriod', { if: 'createdByAdmin' });
         var user = new User;
         user.createdByAdmin = false;
         user.isValid().should.be.true;
@@ -84,8 +84,8 @@ describe('validations', function () {
         user.isValid().should.be.true;
       });
 
-      it('should NOT skip when `unless` is fulfilled', function () {
-        User.validatesPresenceOf('pendingPeriod', {unless: 'createdByAdmin'});
+      it('should NOT skip when `unless` is fulfilled', function() {
+        User.validatesPresenceOf('pendingPeriod', { unless: 'createdByAdmin' });
         var user = new User;
         user.createdByAdmin = false;
         user.isValid().should.be.false;
@@ -94,8 +94,8 @@ describe('validations', function () {
         user.isValid().should.be.true;
       });
 
-      it('should skip when `unless` is NOT fulfilled', function () {
-        User.validatesPresenceOf('pendingPeriod', {unless: 'createdByAdmin'});
+      it('should skip when `unless` is NOT fulfilled', function() {
+        User.validatesPresenceOf('pendingPeriod', { unless: 'createdByAdmin' });
         var user = new User;
         user.createdByAdmin = true;
         user.isValid().should.be.true;
@@ -106,58 +106,58 @@ describe('validations', function () {
 
     });
 
-    describe('skipping in async validation', function () {
+    describe('skipping in async validation', function() {
 
-      it('should skip when `if` is NOT fulfilled', function (done) {
-        User.validateAsync('pendingPeriod', function (err, done) {
+      it('should skip when `if` is NOT fulfilled', function(done) {
+        User.validateAsync('pendingPeriod', function(err, done) {
           if (!this.pendingPeriod) err();
           done();
-        }, {if: 'createdByAdmin', code: 'presence', message: 'can\'t be blank'});
+        }, { if: 'createdByAdmin', code: 'presence', message: 'can\'t be blank' });
         var user = new User;
         user.createdByAdmin = false;
-        user.isValid(function (valid) {
+        user.isValid(function(valid) {
           valid.should.be.true;
           user.errors.should.be.false;
           done();
         });
       });
 
-      it('should NOT skip when `if` is fulfilled', function (done) {
-        User.validateAsync('pendingPeriod', function (err, done) {
+      it('should NOT skip when `if` is fulfilled', function(done) {
+        User.validateAsync('pendingPeriod', function(err, done) {
           if (!this.pendingPeriod) err();
           done();
-        }, {if: 'createdByAdmin', code: 'presence', message: 'can\'t be blank'});
+        }, { if: 'createdByAdmin', code: 'presence', message: 'can\'t be blank' });
         var user = new User;
         user.createdByAdmin = true;
-        user.isValid(function (valid) {
+        user.isValid(function(valid) {
           valid.should.be.false;
           user.errors.pendingPeriod.should.eql(['can\'t be blank']);
           done();
         });
       });
 
-      it('should skip when `unless` is NOT fulfilled', function (done) {
-        User.validateAsync('pendingPeriod', function (err, done) {
+      it('should skip when `unless` is NOT fulfilled', function(done) {
+        User.validateAsync('pendingPeriod', function(err, done) {
           if (!this.pendingPeriod) err();
           done();
-        }, {unless: 'createdByAdmin', code: 'presence', message: 'can\'t be blank'});
+        }, { unless: 'createdByAdmin', code: 'presence', message: 'can\'t be blank' });
         var user = new User;
         user.createdByAdmin = true;
-        user.isValid(function (valid) {
+        user.isValid(function(valid) {
           valid.should.be.true;
           user.errors.should.be.false;
           done();
         });
       });
 
-      it('should NOT skip when `unless` is fulfilled', function (done) {
-        User.validateAsync('pendingPeriod', function (err, done) {
+      it('should NOT skip when `unless` is fulfilled', function(done) {
+        User.validateAsync('pendingPeriod', function(err, done) {
           if (!this.pendingPeriod) err();
           done();
-        }, {unless: 'createdByAdmin', code: 'presence', message: 'can\'t be blank'});
+        }, { unless: 'createdByAdmin', code: 'presence', message: 'can\'t be blank' });
         var user = new User;
         user.createdByAdmin = false;
-        user.isValid(function (valid) {
+        user.isValid(function(valid) {
           valid.should.be.false;
           user.errors.pendingPeriod.should.eql(['can\'t be blank']);
           done();
@@ -166,33 +166,33 @@ describe('validations', function () {
 
     });
 
-    describe('lifecycle', function () {
+    describe('lifecycle', function() {
 
-      it('should work on create', function (done) {
+      it('should work on create', function(done) {
         delete User.validations;
         User.validatesPresenceOf('name');
-        User.create(function (e, u) {
+        User.create(function(e, u) {
           should.exist(e);
-          User.create({name: 'Valid'}, function (e, d) {
+          User.create({ name: 'Valid' }, function(e, d) {
             should.not.exist(e);
             done();
           });
         });
       });
 
-      it('should work on update', function (done) {
+      it('should work on update', function(done) {
         delete User.validations;
         User.validatesPresenceOf('name');
-        User.create({name: 'Valid'}, function (e, d) {
-          d.updateAttribute('name', null, function (e) {
+        User.create({ name: 'Valid' }, function(e, d) {
+          d.updateAttribute('name', null, function(e) {
             should.exist(e);
             e.should.be.instanceOf(Error);
             e.should.be.instanceOf(ValidationError);
-            d.updateAttribute('name', 'Vasiliy', function (e) {
+            d.updateAttribute('name', 'Vasiliy', function(e) {
               should.not.exist(e);
               done();
             });
-          })
+          });
         });
       });
 
@@ -232,18 +232,18 @@ describe('validations', function () {
         });
       });
 
-      it('should return error code', function (done) {
+      it('should return error code', function(done) {
         delete User.validations;
         User.validatesPresenceOf('name');
-        User.create(function (e, u) {
+        User.create(function(e, u) {
           should.exist(e);
           e.details.codes.name.should.eql(['presence']);
           done();
         });
       });
 
-      it('should allow to modify error after validation', function (done) {
-        User.afterValidate = function (next) {
+      it('should allow to modify error after validation', function(done) {
+        User.afterValidate = function(next) {
           next();
         };
         done();
@@ -252,7 +252,7 @@ describe('validations', function () {
       it('should include validation messages in err.message', function(done) {
         delete User.validations;
         User.validatesPresenceOf('name');
-        User.create(function (e, u) {
+        User.create(function(e, u) {
           should.exist(e);
           e.message.should.match(/`name` can't be blank/);
           done();
@@ -262,7 +262,7 @@ describe('validations', function () {
       it('should include property value in err.message', function(done) {
         delete User.validations;
         User.validatesPresenceOf('name');
-        User.create(function (e, u) {
+        User.create(function(e, u) {
           should.exist(e);
           e.message.should.match(/`name` can't be blank \(value: undefined\)/);
           done();
@@ -272,7 +272,7 @@ describe('validations', function () {
       it('should include model name in err.message', function(done) {
         delete User.validations;
         User.validatesPresenceOf('name');
-        User.create(function (e, u) {
+        User.create(function(e, u) {
           should.exist(e);
           e.message.should.match(/`User` instance/i);
           done();
@@ -280,7 +280,7 @@ describe('validations', function () {
       });
 
       it('should return validation metadata', function() {
-        var expected = {name:[{validation: 'presence', options: {}}]};
+        var expected = { name:[{ validation: 'presence', options: {}}] };
         delete User.validations;
         User.validatesPresenceOf('name');
         var validations = User.validations;
@@ -289,14 +289,14 @@ describe('validations', function () {
     });
   });
 
-  describe('presence', function () {
+  describe('presence', function() {
 
-    it('should validate presence', function () {
+    it('should validate presence', function() {
       User.validatesPresenceOf('name', 'email');
 
       var validations = User.validations;
-      validations.name.should.eql([{validation: 'presence', options: {}}]);
-      validations.email.should.eql([{validation: 'presence', options: {}}]);
+      validations.name.should.eql([{ validation: 'presence', options: {}}]);
+      validations.email.should.eql([{ validation: 'presence', options: {}}]);
 
       var u = new User;
       u.isValid().should.not.be.true;
@@ -324,10 +324,10 @@ describe('validations', function () {
       u.isValid().should.be.true;
     });
 
-    it('should skip validation by property (if/unless)', function () {
-      User.validatesPresenceOf('domain', {unless: 'createdByScript'});
+    it('should skip validation by property (if/unless)', function() {
+      User.validatesPresenceOf('domain', { unless: 'createdByScript' });
 
-      var user = new User(getValidAttributes())
+      var user = new User(getValidAttributes());
       user.isValid().should.be.true;
 
       user.createdByScript = false;
@@ -340,29 +340,29 @@ describe('validations', function () {
 
   });
 
-  describe('absence', function () {
+  describe('absence', function() {
 
-    it('should validate absence', function () {
+    it('should validate absence', function() {
       User.validatesAbsenceOf('reserved', { if: 'locked' });
-      var u = new User({reserved: 'foo', locked: true});
+      var u = new User({ reserved: 'foo', locked: true });
       u.isValid().should.not.be.true;
       u.reserved = null;
       u.isValid().should.be.true;
-      var u = new User({reserved: 'foo', locked: false});
+      var u = new User({ reserved: 'foo', locked: false });
       u.isValid().should.be.true;
     });
 
   });
 
-  describe('uniqueness', function () {
-    it('should validate uniqueness', function (done) {
+  describe('uniqueness', function() {
+    it('should validate uniqueness', function(done) {
       User.validatesUniquenessOf('email');
-      var u = new User({email: 'hey'});
-      Boolean(u.isValid(function (valid) {
+      var u = new User({ email: 'hey' });
+      Boolean(u.isValid(function(valid) {
         valid.should.be.true;
-        u.save(function () {
-          var u2 = new User({email: 'hey'});
-          u2.isValid(function (valid) {
+        u.save(function() {
+          var u2 = new User({ email: 'hey' });
+          u2.isValid(function(valid) {
             valid.should.be.false;
             done();
           });
@@ -370,14 +370,14 @@ describe('validations', function () {
       })).should.be.false;
     });
 
-    it('should handle same object modification', function (done) {
+    it('should handle same object modification', function(done) {
       User.validatesUniquenessOf('email');
-      var u = new User({email: 'hey'});
-      Boolean(u.isValid(function (valid) {
+      var u = new User({ email: 'hey' });
+      Boolean(u.isValid(function(valid) {
         valid.should.be.true;
-        u.save(function () {
+        u.save(function() {
           u.name = 'Goghi';
-          u.isValid(function (valid) {
+          u.isValid(function(valid) {
             valid.should.be.true;
             u.save(done);
           });
@@ -390,7 +390,7 @@ describe('validations', function () {
       var EMAIL = 'user@xample.com';
       var SiteUser = db.define('SiteUser', {
         siteId: String,
-        email: String
+        email: String,
       });
       SiteUser.validatesUniquenessOf('email', { scopedTo: ['siteId'] });
       async.waterfall([
@@ -413,7 +413,7 @@ describe('validations', function () {
             valid.should.be.false;
             next();
           });
-        }
+        },
       ], function(err) {
         if (err && err.name == 'ValidationError') {
           console.error('ValidationError:', err.details.messages);
@@ -422,14 +422,14 @@ describe('validations', function () {
       });
     });
 
-    it('should skip blank values', function (done) {
+    it('should skip blank values', function(done) {
       User.validatesUniquenessOf('email');
-      var u = new User({email: '  '});
-      Boolean(u.isValid(function (valid) {
+      var u = new User({ email: '  ' });
+      Boolean(u.isValid(function(valid) {
         valid.should.be.true;
-        u.save(function () {
-          var u2 = new User({email: null});
-          u2.isValid(function (valid) {
+        u.save(function() {
+          var u2 = new User({ email: null });
+          u2.isValid(function(valid) {
             valid.should.be.true;
             done();
           });
@@ -437,31 +437,31 @@ describe('validations', function () {
       })).should.be.false;
     });
 
-    it('should work with if/unless', function (done) {
+    it('should work with if/unless', function(done) {
       User.validatesUniquenessOf('email', {
         if: function() { return true; },
-        unless: function() { return false; }
+        unless: function() { return false; },
       });
-      var u = new User({email: 'hello'});
-      Boolean(u.isValid(function (valid) {
+      var u = new User({ email: 'hello' });
+      Boolean(u.isValid(function(valid) {
         valid.should.be.true;
         done();
       })).should.be.false;
     });
 
-    it('should work with id property on create', function (done) {
+    it('should work with id property on create', function(done) {
       Entry.create({ id: 'entry' }, function(err, entry) {
         var e = new Entry({ id: 'entry' });
-        Boolean(e.isValid(function (valid) {
+        Boolean(e.isValid(function(valid) {
           valid.should.be.false;
           done();
         })).should.be.false;
       });
     });
 
-    it('should work with id property after create', function (done) {
+    it('should work with id property after create', function(done) {
       Entry.findById('entry', function(err, e) {
-        Boolean(e.isValid(function (valid) {
+        Boolean(e.isValid(function(valid) {
           valid.should.be.true;
           done();
         })).should.be.false;
@@ -469,83 +469,83 @@ describe('validations', function () {
     });
   });
 
-  describe('format', function () {
+  describe('format', function() {
     it('should validate format');
     it('should overwrite default blank message with custom format message');
 
-    it('should skip missing values when allowing null', function () {
+    it('should skip missing values when allowing null', function() {
       User.validatesFormatOf('email', { with: /^\S+@\S+\.\S+$/, allowNull: true });
       var u = new User({});
       u.isValid().should.be.true;
     });
 
-    it('should skip null values when allowing null', function () {
+    it('should skip null values when allowing null', function() {
       User.validatesFormatOf('email', { with: /^\S+@\S+\.\S+$/, allowNull: true });
       var u = new User({ email: null });
       u.isValid().should.be.true;
     });
 
-    it('should not skip missing values', function () {
+    it('should not skip missing values', function() {
       User.validatesFormatOf('email', { with: /^\S+@\S+\.\S+$/ });
       var u = new User({});
       u.isValid().should.be.false;
     });
 
-    it('should not skip null values', function () {
+    it('should not skip null values', function() {
       User.validatesFormatOf('email', { with: /^\S+@\S+\.\S+$/ });
       var u = new User({ email: null });
       u.isValid().should.be.false;
     });
   });
 
-  describe('numericality', function () {
+  describe('numericality', function() {
     it('should validate numericality');
   });
 
-  describe('inclusion', function () {
+  describe('inclusion', function() {
     it('should validate inclusion');
   });
 
-  describe('exclusion', function () {
+  describe('exclusion', function() {
     it('should validate exclusion');
   });
 
-  describe('length', function () {
+  describe('length', function() {
     it('should validate length');
   });
 
-  describe('custom', function () {
+  describe('custom', function() {
     it('should validate using custom sync validation', function() {
-      User.validate('email', function (err) {
+      User.validate('email', function(err) {
         if (this.email === 'hello') err();
       }, { code: 'invalid-email' });
-      var u = new User({email: 'hello'});
+      var u = new User({ email: 'hello' });
       Boolean(u.isValid()).should.be.false;
       u.errors.codes.should.eql({ email: ['invalid-email'] });
     });
 
     it('should validate and return detailed error messages', function() {
-      User.validate('global', function (err) {
+      User.validate('global', function(err) {
         if (this.email === 'hello' || this.email === 'hey') {
           this.errors.add('email', 'Cannot be `' + this.email + '`', 'invalid-email');
           err(false); // false: prevent global error message
         }
       });
-      var u = new User({email: 'hello'});
+      var u = new User({ email: 'hello' });
       Boolean(u.isValid()).should.be.false;
       u.errors.should.eql({ email: ['Cannot be `hello`'] });
       u.errors.codes.should.eql({ email: ['invalid-email'] });
     });
 
     it('should validate using custom async validation', function(done) {
-      User.validateAsync('email', function (err, next) {
+      User.validateAsync('email', function(err, next) {
         process.nextTick(next);
       }, {
         if: function() { return true; },
-        unless: function() { return false; }
+        unless: function() { return false; },
       });
-      var u = new User({email: 'hello'});
-      Boolean(u.isValid(function (valid) {
+      var u = new User({ email: 'hello' });
+      Boolean(u.isValid(function(valid) {
         valid.should.be.true;
         done();
       })).should.be.false;
@@ -578,7 +578,7 @@ describe('validations', function () {
 
     it('should truncate long arrays', function() {
       ValidationError.maxPropertyStringLength = 12;
-      var err = givenValidationError('prop', [{ a: 1, b: 2}], 'is invalid');
+      var err = givenValidationError('prop', [{ a: 1, b: 2 }], 'is invalid');
       getErrorDetails(err)
         .should.equal('`prop` is invalid (value: [ { a...} ]).');
     });
@@ -611,7 +611,7 @@ describe('validations', function () {
 
       var obj = {
         errors: errorVal,
-        toJSON: function() { return jsonVal; }
+        toJSON: function() { return jsonVal; },
       };
       return new ValidationError(obj);
     }