Skip to content

public / sequelize

Go to a project

不要怂，就是干，撸起袖子干！

Commit d4c4e698 by Mick Hansen
Options

Merge pull request #3265 from sequelize/remove-events 

refactor: remove events support
2 parents 2cd9db34 84a7655c
Inline Side-by-side
Showing with 11 additions and 727 deletions
changelog.md
......@@ -3,8 +3,11 @@
- [BUG] instance.removeAssociation(s) do not fire the select query twice anymore
- [BUG] Error messages thrown by the db in languages other than english do not crash the app anymore (mysql, mariadb and postgres only) [#3567](https://github.com/sequelize/sequelize/pull/3567)
- [FEATURE] All querys can be logged individually by inserting `logging: fn` in the query option.
- [DEPRECATED] The query-chainer is deprecated and will be removed in version 2.2. Please use promises instead.
- [REMOVED] Events are no longer supported.
- The query-chainer is deprecated and will be removed in version 2.2. Please use promises instead.
#### Backwards compatibility changes
- Events support have been removed so using `.on('succes')` or `.succes()` is no longer supported.
# 2.0.6
- [BUG] Don't update virtual attributes in Model.update. Fixes [#2860](https://github.com/sequelize/sequelize/issues/2860)
......
lib/dialects/mssql/query.js
......@@ -61,11 +61,8 @@ module.exports = (function() {
var results = [];
var request = new self.connection.lib.Request(self.sql, function(err) {
promise.emit('sql', self.sql, self.connection.uuid);
if (err) {
err.sql = sql;
reject(self.formatError(err));
} else {
resolve(self.formatResults(results));
......
lib/dialects/mysql/query.js
......@@ -29,8 +29,6 @@ module.exports = (function() {
var promise = new Utils.Promise(function(resolve, reject) {
self.connection.query(self.sql, function(err, results) {
promise.emit('sql', self.sql, self.connection.uuid);
if (err) {
err.sql = sql;
......
lib/dialects/postgres/query.js
......@@ -102,7 +102,6 @@ module.exports = (function() {
query.on('error', function(err) {
receivedError = true;
err.sql = sql;
promise.emit('sql', sql, self.client.uuid);
reject(self.formatError(err));
});
......@@ -111,7 +110,6 @@ module.exports = (function() {
return;
}
promise.emit('sql', self.sql, self.client.uuid);
resolve([rows, sql, result]);
});
}).spread(function(rows, sql, result) {
......
lib/dialects/sqlite/query.js
......@@ -38,16 +38,10 @@ module.exports = (function() {
self.database.serialize(function() {
var executeSql = function() {
if (self.sql.indexOf('-- ') === 0) {
// the sql query starts with a comment. don't bother the server with that ...
Utils.tick(function () {
promise.emit('sql', self.sql, self.options.uuid);
});
return resolve();
} else {
resolve(new Utils.Promise(function(resolve, reject) {
self.database[self.getDatabaseMethod()](self.sql, function(err, results) {
// allow clients to listen to sql to do their own logging or whatnot
promise.emit('sql', self.sql, self.options.uuid);
if (err) {
err.sql = self.sql;
reject(self.formatError(err));
......
lib/promise.js
'use strict';
var Promise = require('bluebird/js/main/promise')() // use this syntax to be able to modify bluebird without affecting other users
, EventEmitter = require('events').EventEmitter
, proxyEventKeys = ['success', 'error', 'sql']
, Utils = require('./utils')
, deprecatedSeen = {}
, deprecated = function(message) {
if (deprecatedSeen[message]) return;
console.warn(message);
deprecatedSeen[message] = true;
};
var Promise = require('bluebird')
, _then = Promise.prototype._then;
/**
* A slightly modified version of bluebird promises. This means that, on top of the methods below, you can also call all the methods listed on the link below.
*
* The main difference is that sequelize promises allows you to attach a listener that will be called with the generated SQL, each time a query is run.
*
* The sequelize promise class works seamlessly with other A+/thenable libraries, with one exception.
* If you want to propagate SQL events across `then`, `all` calls etc., you must use sequelize promises exclusively.
*
* @mixes https://github.com/petkaantonov/bluebird/blob/master/API.md
* @class Promise
*/
var SequelizePromise = function (resolver) {
var self = this;
var promise = new Promise(function sequelizeResolver(resolve, reject) {
self.seqResolve = resolve;
self.seqReject = reject;
return resolver(resolve, reject);
});
promise.seqResolve = this.seqResolve;
promise.seqReject = this.seqReject;
promise.$sql = [];
return promise;
};
var util = require('util');
util.inherits(SequelizePromise, Promise);
for (var method in Promise) {
if (Promise.hasOwnProperty(method)) {
SequelizePromise[method] = Promise[method];
}
}
var bluebirdThen = Promise.prototype._then;
Promise.prototype._then = function (didFulfill, didReject, didProgress, receiver, internalData) {
if (SequelizePromise.Sequelize.cls) {
var ns = SequelizePromise.Sequelize.cls;
if (Promise.Sequelize.cls) {
var ns = Promise.Sequelize.cls;
if (typeof didFulfill === 'function') didFulfill = ns.bind(didFulfill);
if (typeof didReject === 'function') didReject = ns.bind(didReject);
if (typeof didProgress === 'function') didProgress = ns.bind(didProgress);
}
var ret = bluebirdThen.call(this, didFulfill, didReject, didProgress, receiver, internalData);
// Needed to transfer sql events accross .then() calls
if (ret && ret.emit) {
if (!ret.$sql) {
ret.$sql = [];
}
this.proxySql(ret);
}
return ret;
};
var bluebirdSettle = Promise.prototype._settlePromiseAt;
Promise.prototype._settlePromiseAt = function (index) {
var receiver = this._receiverAt(index);
bluebirdSettle.call(this, index);
if (this.$sql && receiver && receiver.emit) {
this.$sql.forEach(function (sql) {
receiver.emit('sql', sql);
});
}
};
var bluebirdAll = Promise.all;
SequelizePromise.all = function (promises) {
var ret = bluebirdAll.call(this, promises);
// Propagate sql events
if (Array.isArray(promises)) {
promises.forEach(function (promise) {
if (Promise.is(promise)) {
promise.on('sql', function (sql) {
ret.emit('sql', sql);
});
if (!promise.$sql) {
promise.$sql = [];
}
promise.$sql.forEach(function (sql) {
ret.emit('sql', sql);
});
}
});
}
return ret;
};
/**
* Listen for events, event emitter style. Mostly for backwards compat. with EventEmitter
*
* @param {String} evt
* @param {Function} fct
*
* @deprecated
*/
Promise.prototype.on = function(evt, fct) {
if (evt === 'success') {
this.then(fct);
}
else if (evt === 'error') {
this.then(null, fct);
}
else {
EventEmitter.prototype.on.call(this, evt, fct);
}
return this;
};
/**
* Emit an event from the emitter
* @param {string} type The type of event
* @param {any} value(s)* All other arguments will be passed to the event listeners
*
* @deprecated
*/
Promise.prototype.emit = function(evt) {
var args = arguments.length > 1 ? Array.prototype.slice.call(arguments, 1) : [];
if (evt === 'success') {
this.seqResolve.apply(this, args);
} else if (evt === 'error') {
this.seqReject.apply(this, args);
} else {
// Needed to transfer sql across .then() calls
if (evt === 'sql') {
if (!this.$sql) {
this.$sql = [];
}
this.$sql.push(args[0]);
}
EventEmitter.prototype.emit.apply(this, [evt].concat(args));
}
return this;
};
/**
* Listen for success events.
*
* ```js
* promise.success(function (result) {
* //...
* });
* ```
*
* @param {function} onSuccess
* @method success
* @alias ok
* @return this
*
* @deprecated
*/
Promise.prototype.success =
Promise.prototype.ok = function(fct) {
deprecated('success|ok() is deprecated and will be removed in 2.1, please use promise-style instead.');
if (fct.length > 1) {
return this.spread(fct);
} else {
return this.then(fct);
}
};
/**
* Listen for error events
*
* ```js
* promise.error(function (err) {
* //...
* });
* ```
*
* @param {function} onError
* @method error
* @alias fail
* @alias failure
* @return this
*
* @deprecated
*/
Promise.prototype.error =
Promise.prototype.failure =
Promise.prototype.fail = function(fct) {
deprecated('failure|fail|error() is deprecated and will be removed in 2.1, please use promise-style instead.');
return this.then(null, fct);
};
/**
* Listen for both success and error events.
*
* ```js
* promise.done(function (err, result) {
* //...
* });
* ```
*
* @param {function} onDone
* @method done
* @alias complete
* @return this
*
* @deprecated done(fct) is deprecated, done() is regular promise syntax to explicitly signal the end of a promise chain and will not be deprecated
*/
var bluebirdDone = Promise.prototype.done;
Promise.prototype.done =
Promise.prototype.complete = function(fct) {
if (!fct) {
// If no callback is provided, map to the promise.done function, which explicitly ends a promise chain
return bluebirdDone.call(this);
}
if (fct.length > 2) {
deprecated('complete|done() is deprecatedand will be removed in 2.1, please use promise-style instead.');
return this.spread(function() {
fct.apply(null, [null].concat(Array.prototype.slice.call(arguments)));
}, fct);
} else {
return this.then(function() {
fct.apply(null, [null].concat(Array.prototype.slice.call(arguments)));
}, fct);
}
};
/*
* Attach a function that is called every time the function that created this emitter executes a query.
* @param {function} onSQL
* @return this
*/
Promise.prototype.sql = function(fct) {
this.on('sql', fct);
return this;
};
/**
* Proxy every event of this promise to another one.
*
* @param {SequelizePromise} promise The promise that should receive the events.
* @param {Object} [options]
* @param {Array} [options.events] An array of the events to proxy. Defaults to sql, error and success
* @return this
*
* @deprecated
*/
Promise.prototype.proxy = function(promise, options) {
options = Utils._.extend({
events: proxyEventKeys,
skipEvents: []
}, options || {});
options.events = Utils._.difference(options.events, options.skipEvents);
options.events.forEach(function(eventKey) {
this.on(eventKey, function() {
var args = [eventKey].concat([].slice.apply(arguments));
promise.emit.apply(promise, args);
});
}.bind(this));
return this;
};
Promise.prototype.proxySql = function(promise) {
return this.proxy(promise, {
events: ['sql']
});
return _then.call(this, didFulfill, didReject, didProgress, receiver, internalData);
};
module.exports = SequelizePromise;
module.exports = Promise;
\ No newline at end of file
lib/query-chainer.js
......@@ -182,11 +182,6 @@ module.exports = (function() {
self.finishedEmits++;
self.fails.push(err);
finish.call(self, 'emitterResults');
})
.on('sql', function(sql) {
if (self.eventEmitter) {
self.eventEmitter.emit('sql', sql);
}
});
};
......
test/integration/promise.test.js deleted 100644 → 0
'use strict';
/* jshint -W030 */
var chai = require('chai')
, expect = chai.expect
, Support = require(__dirname + '/support')
, DataTypes = require(__dirname + '/../../lib/data-types')
, SequelizePromise = require(__dirname + '/../../lib/promise')
, sinon = require('sinon');
chai.config.includeStack = true;
describe(Support.getTestDialectTeaser('Promise'), function() {
beforeEach(function() {
return Support.prepareTransactionTest(this.sequelize).bind(this).then(function(sequelize) {
this.sequelize = sequelize;
this.User = this.sequelize.define('User', {
username: { type: DataTypes.STRING },
touchedAt: { type: DataTypes.DATE, defaultValue: DataTypes.NOW },
aNumber: { type: DataTypes.INTEGER },
bNumber: { type: DataTypes.INTEGER },
validateTest: {
type: DataTypes.INTEGER,
allowNull: true,
validate: {isInt: true}
},
validateCustom: {
type: DataTypes.STRING,
allowNull: true,
validate: {len: {msg: 'Length failed.', args: [1, 20]}}
},
dateAllowNullTrue: {
type: DataTypes.DATE,
allowNull: true
}
});
return this.User.sync({ force: true });
});
});
describe('increment', function() {
beforeEach(function() {
return this.User.create({ id: 1, aNumber: 0, bNumber: 0 });
});
it('with array', function() {
var self = this;
return this.User
.find(1)
.then(function(user) {
expect(user.id).to.equal(1);
return user.increment(['aNumber'], { by: 2 });
})
.then(function() {
// The following assertion would rock hard, but it's not implemented :(
// expect(user.aNumber).to.equal(2)
return self.User.find(1);
})
.then(function(user) {
expect(user.aNumber).to.equal(2);
});
});
it('should still work right with other concurrent updates', function() {
var self = this;
// Select something
return this.User
.find(1)
.then(function(user1) {
// Select the user again (simulating a concurrent query)
return self.User.find(1)
.then(function(user2) {
return user2
.updateAttributes({ aNumber: user2.aNumber + 1 })
.then(function() { return user1.increment(['aNumber'], { by: 2 }); })
.then(function() { return self.User.find(1); })
.then(function(user5) {
expect(user5.aNumber).to.equal(3);
});
});
});
});
it('with key value pair', function() {
var self = this;
return this.User
.find(1)
.then(function(user1) {
return user1.increment({ 'aNumber': 1, 'bNumber': 2});
})
.then(function() {
return self.User.find(1);
})
.then(function(user3) {
expect(user3.aNumber).to.equal(1);
expect(user3.bNumber).to.equal(2);
});
});
});
describe('decrement', function() {
beforeEach(function() {
return this.User.create({ id: 1, aNumber: 0, bNumber: 0 });
});
it('with array', function() {
var self = this;
return this.User
.find(1)
.then(function(user1) {
return user1.decrement(['aNumber'], { by: 2 });
})
.then(function() {
return self.User.find(1);
})
.then(function(user3) {
expect(user3.aNumber).to.equal(-2);
});
});
it('with single field', function() {
var self = this;
return this.User
.find(1)
.then(function(user1) {
return user1.decrement(['aNumber'], { by: 2 });
})
.then(function() {
return self.User.find(1);
})
.then(function(user3) {
expect(user3.aNumber).to.equal(-2);
});
});
it('should still work right with other concurrent decrements', function() {
var self = this;
return this.User
.find(1)
.then(function(user1) {
return this.sequelize.Promise.all([
user1.decrement(['aNumber'], { by: 2 }),
user1.decrement(['aNumber'], { by: 2 }),
user1.decrement(['aNumber'], { by: 2 })
]).then(function() {
return self.User
.find(1)
.then(function(user2) {
expect(user2.aNumber).to.equal(-6);
});
});
});
});
});
describe('reload', function() {
it('should return a reference to the same DAO instead of creating a new one', function() {
return this.User
.create({ username: 'John Doe' })
.then(function(originalUser) {
return originalUser
.updateAttributes({ username: 'Doe John' })
.then(function() {
return originalUser.reload();
})
.then(function(updatedUser) {
expect(originalUser === updatedUser).to.be.true;
});
});
});
it('should update the values on all references to the DAO', function() {
var self = this;
return this.User
.create({ username: 'John Doe' })
.then(function(originalUser) {
return self.User
.find(originalUser.id)
.then(function(updater) {
return updater.updateAttributes({ username: 'Doe John' });
})
.then(function() {
// We used a different reference when calling updateAttributes, so originalUser is now out of sync
expect(originalUser.username).to.equal('John Doe');
return originalUser.reload();
}).then(function(updatedUser) {
expect(originalUser.username).to.equal('Doe John');
expect(updatedUser.username).to.equal('Doe John');
});
});
});
it('should update the associations as well', function() {
var Book = this.sequelize.define('Book', { title: DataTypes.STRING })
, Page = this.sequelize.define('Page', { content: DataTypes.TEXT });
Book.hasMany(Page);
Page.belongsTo(Book);
return Book
.sync({ force: true })
.then(function() {
return Page
.sync({ force: true })
.then(function() {
return Book.create({ title: 'A very old book' });
})
.then(function(book) {
return Page
.create({ content: 'om nom nom' })
.then(function(page) {
return book
.setPages([page])
.then(function() {
return Book
.find({
where: {id: book.id},
include: [Page]
})
.then(function(leBook) {
return page
.updateAttributes({ content: 'something totally different' })
.then(function(page) {
expect(leBook.Pages[0].content).to.equal('om nom nom');
expect(page.content).to.equal('something totally different');
return leBook
.reload()
.then(function(leBook) {
expect(leBook.Pages[0].content).to.equal('something totally different');
expect(page.content).to.equal('something totally different');
});
});
});
});
});
});
});
});
});
describe('complete', function() {
it('gets triggered if an error occurs', function() {
return expect( this.User.find({ where: 'asdasdasd' })).to.be.rejected;
});
it('gets triggered if everything was ok', function() {
return this.User.count().then(function(result) {
expect(result).to.not.be.undefined;
});
});
});
describe('save', function() {
it('should fail a validation upon creating', function() {
return this.User.create({aNumber: 0, validateTest: 'hello'})
.catch (function(err) {
expect(err).to.be.ok;
expect(err).to.be.an('object');
expect(err.get('validateTest')).to.be.an('array');
expect(err.get('validateTest')[0]).to.be.ok;
expect(err.get('validateTest')[0].message).to.equal('Validation isInt failed');
});
});
it('should fail a validation upon building', function() {
return this.User.build({aNumber: 0, validateCustom: 'aaaaaaaaaaaaaaaaaaaaaaaaaa'}).save()
.catch (function(err) {
expect(err).to.be.ok;
expect(err).to.be.an('object');
expect(err.get('validateCustom')).to.be.ok;
expect(err.get('validateCustom')).to.be.an('array');
expect(err.get('validateCustom')[0]).to.be.ok;
expect(err.get('validateCustom')[0].message).to.equal('Length failed.');
});
});
it('should fail a validation when updating', function() {
return this.User.create({aNumber: 0}).then(function(user) {
return user.updateAttributes({validateTest: 'hello'});
}).catch (function(err) {
expect(err).to.be.ok;
expect(err).to.be.an('object');
expect(err.get('validateTest')).to.be.ok;
expect(err.get('validateTest')).to.be.an('array');
expect(err.get('validateTest')[0]).to.be.ok;
expect(err.get('validateTest')[0].message).to.equal('Validation isInt failed');
});
});
});
describe('findOrCreate', function() {
beforeEach(function() {
return this.User.create({ id: 1, aNumber: 0, bNumber: 0 });
});
describe('with spread', function() {
it('user not created', function() {
return this.User
.findOrCreate({ where: { id: 1}})
.spread(function(user, created) {
expect(user.id).to.equal(1);
expect(created).to.equal(false);
expect(arguments.length).to.equal(2);
});
});
it('user created', function() {
return this.User
.findOrCreate({ where: { id: 2}})
.spread(function(user, created) {
expect(user.id).to.equal(2);
expect(created).to.equal(true);
expect(arguments.length).to.equal(2);
});
});
});
});
describe('backwards compat', function() {
it('should still work with .complete() when resolving', function(done) {
var spy = sinon.spy()
, promise = new SequelizePromise(function(resolve, reject) {
resolve('abc');
});
promise.complete(spy);
promise.then(function() {
expect(spy.calledOnce).to.be.true;
expect(spy.firstCall.args).to.deep.equal([null, 'abc']);
done();
});
});
it('should still work with .success() when resolving', function(done) {
var spy = sinon.spy()
, promise = new SequelizePromise(function(resolve, reject) {
resolve('yay');
});
promise.success(spy);
promise.then(function() {
expect(spy.calledOnce).to.be.true;
expect(spy.firstCall.args).to.deep.equal(['yay']);
done();
});
});
it('should still work with then when resolving', function(done) {
var spy = sinon.spy()
, promise = new SequelizePromise(function(resolve, reject) {
resolve('yoohoo');
});
promise.then(spy);
promise.then(function() {
expect(spy.calledOnce).to.be.true;
expect(spy.firstCall.args).to.deep.equal(['yoohoo']);
done();
});
});
it('should still work with .done() when resolving multiple results', function(done) {
var spy = sinon.spy()
, promise = new SequelizePromise(function(resolve, reject) {
resolve(SequelizePromise.all(['MyModel', true]));
});
promise.spread(spy);
promise.done(function(err, model, created) {
expect(model).to.equal('MyModel');
expect(created).to.be.true;
expect(spy.calledOnce).to.be.true;
expect(spy.firstCall.args).to.deep.equal(['MyModel', true]);
done();
});
});
it('should still work with .complete() after chaining', function() {
var promise = new SequelizePromise(function(resolve, reject) {
resolve('Heyo');
});
return promise.then(function(result) {
return result + '123';
}).complete(function(err, result) {
expect(err).not.to.be.ok;
expect(result).to.equal('Heyo123');
});
});
it('should still work with .done() when rejecting', function(done) {
var spy = sinon.spy()
, promise = new SequelizePromise(function(resolve, reject) {
reject(new Error('no'));
});
promise.done(spy);
promise.catch(function() {
expect(spy.calledOnce).to.be.true;
expect(spy.firstCall.args[0]).to.be.an.instanceof(Error);
done();
});
});
it('should still work with .error() when throwing', function(done) {
var spy = sinon.spy()
, promise = new SequelizePromise(function(resolve, reject) {
throw new Error('no');
});
promise.error(spy);
promise.catch(function() {
expect(spy.calledOnce).to.be.true;
expect(spy.firstCall.args[0]).to.be.an.instanceof(Error);
done();
});
});
});
});
Markdown is supported
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!