Merge branch 'master' of github.com:sequelize/sequelize

changelog.md

@@ -25,6 +25,8 @@
 - [BUG] Fixed SQL escaping with sqlite and unified escaping [#700](https://github.com/sequelize/sequelize/pull/700). thanks to PiPeep
 - [BUG] Fixed Postgres' pools [ff57af63](https://github.com/sequelize/sequelize/commit/ff57af63c2eb395b4828a5984a22984acdc2a5e1)
 - [BUG] Fixed BLOB/TEXT columns having a default value declared in MySQL [#793](https://github.com/sequelize/sequelize/pull/793). thanks to durango
+- [BUG] You can now use .find() on any single integer primary key when throwing just a number as an argument [#796](https://github.com/sequelize/sequelize/pull/796). thanks to durango
+- [BUG] Adding unique to a column for Postgres in the migrator should be fixed [#795](https://github.com/sequelize/sequelize/pull/795). thanks to durango
 - [FEATURE] Validate a model before it gets saved. [#601](https://github.com/sequelize/sequelize/pull/601). thanks to durango
 - [FEATURE] Schematics. [#564](https://github.com/sequelize/sequelize/pull/564). thanks to durango
 - [FEATURE] Foreign key constraints. [#595](https://github.com/sequelize/sequelize/pull/595). thanks to optilude
@@ -47,6 +49,7 @@
 - [FEATURE] Added support for model instances being referenced [#761](https://github.com/sequelize/sequelize/pull/761) thanks to sdepold
 - [FEATURE] Added support for specifying the path to load a module for a dialect. [#766](https://github.com/sequelize/sequelize/pull/766) thanks to sonnym.
 - [FEATURE] Drop index if exists has been added to sqlite [#766](https://github.com/sequelize/sequelize/pull/776) thanks to coderbuzz
+- [FEATURE] bulkCreate() now has a third argument which gives you the ability to validate each row before attempting to bulkInsert [#797](https://github.com/sequelize/sequelize/pull/797). thanks to durango
 - [REFACTORING] hasMany now uses a single SQL statement when creating and destroying associations, instead of removing each association seperately [690](https://github.com/sequelize/sequelize/pull/690). Inspired by [#104](https://github.com/sequelize/sequelize/issues/104). janmeier
 - [REFACTORING] Consistent handling of offset across dialects. Offset is now always applied, and limit is set to max table size of not limit is given [#725](https://github.com/sequelize/sequelize/pull/725). janmeier
 - [REFACTORING] Moved Jasmine to Buster and then Buster to Mocha + Chai. sdepold and durango

lib/dao-factory.js

@@ -250,14 +250,20 @@ module.exports = (function() {
     }
 
     var primaryKeys = this.primaryKeys
+      , keys        = Object.keys(primaryKeys)
+      , keysLength  = keys.length
 
     // options is not a hash but an id
     if (typeof options === 'number') {
-      options = { where: options }
+      var oldOption = options
+      options = { where: {} }
+      if (keysLength === 1) {
+        options.where[keys[0]] = oldOption
+      } else {
+        options.where.id = oldOption
+      }
     } else if (Utils._.size(primaryKeys) && Utils.argsArePrimaryKeys(arguments, primaryKeys)) {
       var where = {}
-        , self  = this
-        , keys = Object.keys(primaryKeys)
 
       Utils._.each(arguments, function(arg, i) {
         var key = keys[i]
@@ -288,7 +294,6 @@ module.exports = (function() {
       this.options.whereCollection = options.where || null
     } else if (typeof options === "string") {
       var where = {}
-        , keys = Object.keys(primaryKeys)
 
       if (this.primaryKeyCount === 1) {
         where[primaryKeys[keys[0]]] = options;
@@ -434,13 +439,31 @@ module.exports = (function() {
    * generated IDs and other default values in a way that can be mapped to
    * multiple records
    */
-  DAOFactory.prototype.bulkCreate = function(records, fields) {
+  DAOFactory.prototype.bulkCreate = function(records, fields, options) {
+    options = options || {}
+    options.validate = options.validate || false
+    fields = fields || []
+
     var self          = this
-      , daos          = records.map(function(v) { return self.build(v) })
       , updatedAtAttr = self.options.underscored ? 'updated_at' : 'updatedAt'
       , createdAtAttr = self.options.underscored ? 'created_at' : 'createdAt'
-
-    fields = fields || []
+      , errors        = []
+      , daos          = records.map(function(v) {
+                          var build = self.build(v)
+                          if (options.validate === true) {
+                            var valid = build.validate({skip: fields})
+                            if (valid !== null) {
+                              errors[errors.length] = {record: v, errors: valid}
+                            }
+                          }
+                          return build
+                        })
+
+    if (options.validate === true && errors.length > 0) {
+      return new Utils.CustomEventEmitter(function(emitter) {
+        emitter.emit('error', errors)
+      }).run()
+    }
 
     // we will re-create from DAOs, which may have set up default attributes
     records = []
@@ -458,7 +481,7 @@ module.exports = (function() {
         values[updatedAtAttr] = Utils.now()
       }
 
-      records.push(values);
+      records.push(values)
     })
 
     // Validate enums

lib/dao-validator.js

 var Validator = require("validator")
   , Utils     = require("./utils")
 
-var DaoValidator = module.exports = function(model) {
+var DaoValidator = module.exports = function(model, options) {
+  options = options || {}
+  options.skip = options.skip || []
+
   this.model = model
+  this.options = options
 }
 
 DaoValidator.prototype.validate = function() {
@@ -32,17 +36,19 @@ var validateModel = function() {
 }
 
 var validateAttributes = function() {
-  var errors = {}
+  var self = this
+    , errors = {}
 
   // for each field and value
   Utils._.each(this.model.dataValues, function(value, field) {
-    var rawAttribute   = this.model.rawAttributes[field]
+    var rawAttribute   = self.model.rawAttributes[field]
       , hasAllowedNull = ((rawAttribute === undefined || rawAttribute.allowNull === true) && ((value === null) || (value === undefined)))
+      , isSkipped      = self.options.skip.length > 0 && self.options.skip.indexOf(field) === -1
 
-    if (this.model.validators.hasOwnProperty(field) && !hasAllowedNull) {
-      errors = Utils._.merge(errors, validateAttribute.call(this, value, field))
+    if (self.model.validators.hasOwnProperty(field) && !hasAllowedNull && !isSkipped) {
+      errors = Utils._.merge(errors, validateAttribute.call(self, value, field))
     }
-  }.bind(this)) // for each field
+  })
 
   return errors
 }

lib/dao.js

@@ -201,8 +201,8 @@ module.exports = (function() {
    *
    * @return null if and only if validation successful; otherwise an object containing { field name : [error msgs] } entries.
    */
-  DAO.prototype.validate = function() {
-    var validator = new DaoValidator(this)
+  DAO.prototype.validate = function(object) {
+    var validator = new DaoValidator(this, object)
       , errors    = validator.validate()
 
     return (Utils._.isEmpty(errors) ? null : errors)

lib/dialects/postgres/query-generator.js

@@ -189,6 +189,15 @@ module.exports = (function() {
           definition = definition.replace(/^ENUM\(.+\)/, this.quoteIdentifier("enum_" + tableName + "_" + attributeName))
         }
 
+        if (definition.match(/UNIQUE;*$/)) {
+          definition = definition.replace(/UNIQUE;*$/, '')
+
+          attrSql += Utils._.template(query.replace('ALTER COLUMN', ''))({
+            tableName: this.quoteIdentifiers(tableName),
+            query:     'ADD CONSTRAINT ' + this.quoteIdentifier(attributeName + '_unique_idx') + ' UNIQUE (' + this.quoteIdentifier(attributeName) + ')'
+          })
+        }
+
         attrSql += Utils._.template(query)({
           tableName: this.quoteIdentifiers(tableName),
           query:     this.quoteIdentifier(attributeName) + ' TYPE ' + definition

test/assets/migrations/20111205167000-addUniqueNameColumnToUser.js

+module.exports = {
+  up: function(migration, DataTypes, done) {
+    migration.addColumn('User', 'uniqueName', { type: DataTypes.STRING }).complete(function() {
+      migration.changeColumn('User', 'uniqueName', { type: DataTypes.STRING, allowNull: false, unique: true }).complete(done)
+    })
+  },
+
+  down: function(migration, DataTypes, done) {
+    migration.removeColumn('User', 'uniqueName').complete(done)
+  }
+}

test/dao-factory.test.js

@@ -715,6 +715,68 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
       })
     })
 
+    it('emits an error when validate is set to true', function(done) {
+      var Tasks = this.sequelize.define('Task', {
+        name: {
+          type: Sequelize.STRING,
+          validate: {
+            notNull: { args: true, msg: 'name cannot be null' }
+          }
+        },
+        code: {
+          type: Sequelize.STRING,
+          validate: {
+            len: [3, 10]
+          }
+        }
+      })
+
+      Tasks.sync({ force: true }).success(function() {
+        Tasks.bulkCreate([
+          {name: 'foo', code: '123'},
+          {code: '1234'},
+          {name: 'bar', code: '1'}
+        ], null, {validate: true}).error(function(errors) {
+          expect(errors).to.not.be.null
+          expect(errors).to.be.instanceof(Array)
+          expect(errors).to.have.length(2)
+          expect(errors[0].record.code).to.equal('1234')
+          expect(errors[0].errors.name[0]).to.equal('name cannot be null')
+          expect(errors[1].record.name).to.equal('bar')
+          expect(errors[1].record.code).to.equal('1')
+          expect(errors[1].errors.code[0]).to.equal('String is not in range: code')
+          done()
+        })
+      })
+    })
+
+    it("doesn't emit an error when validate is set to true but our selectedValues are fine", function(done) {
+      var Tasks = this.sequelize.define('Task', {
+        name: {
+          type: Sequelize.STRING,
+          validate: {
+            notNull: { args: true, msg: 'name cannot be null' }
+          }
+        },
+        code: {
+          type: Sequelize.STRING,
+          validate: {
+            len: [3, 10]
+          }
+        }
+      })
+
+      Tasks.sync({ force: true }).success(function() {
+        Tasks.bulkCreate([
+          {name: 'foo', code: '123'},
+          {code: '1234'}
+        ], ['code'], {validate: true}).success(function() {
+          // we passed!
+          done()
+        })
+      })
+    })
+
     describe('enums', function() {
       it('correctly restores enum values', function(done) {
         var self = this
@@ -1330,17 +1392,34 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
             {where: {id: 0}},
             {where: {id: '0'}}
           ]
-          , done = _.after(2 * permutations.length, _done);
+          , done = _.after(2 * permutations.length, _done)
 
         this.User.bulkCreate([{username: 'jack'}, {username: 'jack'}]).success(function() {
           permutations.forEach(function(perm) {
             self.User.find(perm).done(function(err, user) {
-              expect(err).to.be.null;
-              expect(user).to.be.null;
-              done();
+              expect(err).to.be.null
+              expect(user).to.be.null
+              done()
             }).on('sql', function(s) {
-              expect(s.indexOf(0)).not.to.equal(-1);
-              done();
+              expect(s.indexOf(0)).not.to.equal(-1)
+              done()
+            })
+          })
+        })
+      })
+
+      it('should allow us to find IDs using capital letters', function(done) {
+        var User = this.sequelize.define('User' + config.rand(), {
+          ID: { type: Sequelize.INTEGER, primaryKey: true, autoIncrement: true },
+          Login: { type: Sequelize.STRING }
+        })
+
+        User.sync({ force: true }).success(function() {
+          User.create({Login: 'foo'}).success(function() {
+            User.find(1).success(function(user) {
+              expect(user).to.exist
+              expect(user.ID).to.equal(1)
+              done()
             })
           })
         })
@@ -2053,6 +2132,23 @@ describe(Support.getTestDialectTeaser("DAOFactory"), function () {
           })
         })
       })
+
+      it('should allow us to find IDs using capital letters', function(done) {
+        var User = this.sequelize.define('User' + config.rand(), {
+          ID: { type: Sequelize.INTEGER, primaryKey: true, autoIncrement: true },
+          Login: { type: Sequelize.STRING }
+        })
+
+        User.sync({ force: true }).success(function() {
+          User.create({Login: 'foo'}).success(function() {
+            User.findAll({ID: 1}).success(function(user) {
+              expect(user).to.be.instanceof(Array)
+              expect(user).to.have.length(1)
+              done()
+            })
+          })
+        })
+      })
     })
   })
 

test/migrator.test.js

 var chai         = require('chai')
   , expect       = chai.expect
   , Support      = require(__dirname + '/support')
-  , DataTypes    = require(__dirname + "/../lib/data-types")
-  , QueryChainer = require("../lib/query-chainer")
   , Migrator     = require("../lib/migrator")
   , dialect      = Support.getTestDialect()
 
@@ -16,6 +14,7 @@ describe(Support.getTestDialectTeaser("Migrator"), function() {
         logging: function(){}
       }, options || {})
 
+      // this.sequelize.options.logging = console.log
       var migrator = new Migrator(this.sequelize, options)
 
       migrator
@@ -87,7 +86,7 @@ describe(Support.getTestDialectTeaser("Migrator"), function() {
         SequelizeMeta.create({ from: null, to: 20111117063700 }).success(function() {
           migrator.getUndoneMigrations(function(err, migrations) {
             expect(err).to.be.null
-            expect(migrations).to.have.length(6)
+            expect(migrations).to.have.length(7)
             expect(migrations[0].filename).to.equal('20111130161100-emptyMigration.js')
             done()
           })
@@ -186,6 +185,31 @@ describe(Support.getTestDialectTeaser("Migrator"), function() {
     })
 
     describe('addColumn', function() {
+      it('adds a unique column to the user table', function(done) {
+        var self = this
+
+        this.init({ from: 20111117063700, to: 20111205167000 }, function(migrator) {
+          migrator.migrate().complete(function(err) {
+            self.sequelize.getQueryInterface().describeTable('User').complete(function(err, data) {
+              var signature = data.signature
+                , isAdmin   = data.isAdmin
+                , shopId    = data.shopId
+
+              expect(signature.allowNull).to.be.true
+              expect(isAdmin.allowNull).to.be.false
+              if (dialect === "postgres" || dialect === "postgres-native" || dialect === "sqlite") {
+                expect(isAdmin.defaultValue).to.be.false
+              } else {
+                expect(isAdmin.defaultValue).to.equal("0")
+              }
+              expect(shopId.allowNull).to.be.true
+
+              done()
+            })
+          })
+        })
+      })
+
       it('adds a column to the user table', function(done) {
         var self = this