Skip to content

public / sequelize

Go to a project

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

Commit d2545644 by Felix Becker Committed by Jan Aagaard Meier
Options

Make instances instanceof Model, with ES6 classes (#5924) 

* Make Instance an ES6 class

* Add esversion: 6 to jshintrc

* Make Model an ES6 class

* Merge Model class into Instance class

* Rename instance.js to model.js

* Remove name parameter from Model.init()

The name is set when subclassing the Model class

* Change sequelize.define() to a Model class factory

* Delete model.js

* Remove Model.Instance and Model.prototype.Model

* Fix JSHint issue

* Remove leftover require('./instance')

* Fix reference to old Instance class

* Remove references to old Instance class from main module

* Reorder imports to hopefully trigger Travis Build

* Fix _addOptionalClassMethods call

* Fix more references to .Instance

* Correct uses of .Model

* Fix use of this in closure

* Fix usage of instanceof Model

* Fix usage of .Model

* Fix usage of this in closure

* Fix usage of $Model

* Fix test for `plain` option

* Fix uses of .$Model

* Fix hooks

* Fix global hooks

* Make more tests pass

* Make more tests pass

* Fix Model.prototype references in findone test

* Change Model.schema()

* Fix instanceof checks in belongs-to-many association

* Fix Model.scope()

* Remove callback support from hooks

* Fix instanceof Model checks

* Fix usage of instanceof Model

* Change another occurence of .Model.name to .constructor.name

* Replace .constructor by .Model again

* Fix this inside closure

* Change test cosntructor assertions to instanceof checks
1 parent 738ea1b2
Inline Side-by-side
Showing with 1467 additions and 1530 deletions
.jshintrc
......@@ -26,6 +26,7 @@
/* questionable */
"loopfunc":true,
"esversion": 6,
"globals": {
"Promise": true
},
......
lib/associations/base.js
......@@ -8,7 +8,7 @@ Association.prototype.toInstanceArray = function (objs) {
objs = [objs];
}
return objs.map(function(obj) {
if (!(obj instanceof this.target.Instance)) {
if (!(obj instanceof this.target)) {
var tmpInstance = {};
tmpInstance[this.target.primaryKeyAttribute] = obj;
return this.target.build(tmpInstance, {
......
lib/associations/belongs-to-many.js
......@@ -521,7 +521,7 @@ BelongsToMany.prototype.injectGetter = function(obj) {
});
where.$or = instances.map(function (instance) {
if (instance instanceof association.target.Instance) {
if (instance instanceof association.target) {
return instance.where();
} else {
var $where = {};
......@@ -592,7 +592,7 @@ BelongsToMany.prototype.injectSetter = function(obj) {
} else {
var throughAttributes = newObj[association.through.model.name];
// Quick-fix for subtle bug when using existing objects that might have the through model attached (not as an attribute object)
if (throughAttributes instanceof association.through.model.Instance) {
if (throughAttributes instanceof association.through.model) {
throughAttributes = {};
}
......@@ -712,7 +712,7 @@ BelongsToMany.prototype.injectSetter = function(obj) {
, attributes = _.defaults({}, throughAttributes, defaultAttributes)
, where = {};
// Quick-fix for subtle bug when using existing objects that might have the through model attached (not as an attribute object)
if (throughAttributes instanceof association.through.model.Instance) {
if (throughAttributes instanceof association.through.model) {
throughAttributes = {};
}
......
lib/associations/belongs-to.js
......@@ -213,7 +213,7 @@ BelongsTo.prototype.injectSetter = function(instancePrototype) {
options = options || {};
var value = associatedInstance;
if (associatedInstance instanceof association.target.Instance) {
if (associatedInstance instanceof association.target) {
value = associatedInstance[association.targetKey];
}
......
lib/associations/has-many.js
......@@ -366,7 +366,7 @@ HasMany.prototype.has = function(sourceInstance, targetInstances, options) {
});
where.$or = targetInstances.map(function (instance) {
if (instance instanceof association.target.Instance) {
if (instance instanceof association.target) {
return instance.where();
} else {
var _where = {};
......
lib/associations/has-one.js
......@@ -228,7 +228,7 @@ HasOne.prototype.injectSetter = function(instancePrototype) {
}
}).then(function() {
if (associatedInstance && !alreadyAssociated) {
if (!(associatedInstance instanceof association.target.Instance)) {
if (!(associatedInstance instanceof association.target)) {
var tmpInstance = {};
tmpInstance[association.target.primaryKeyAttribute] = associatedInstance;
associatedInstance = association.target.build(tmpInstance, {
......
lib/associations/mixin.js
......@@ -91,8 +91,8 @@ var Mixin = module.exports = function() {};
// The logic for hasOne and belongsTo is exactly the same
var singleLinked = function (Type) {
return function(target, options) { // testhint options:none
if (!(target instanceof this.sequelize.Model)) {
throw new Error(this.name + '.' + Utils.lowercaseFirst(Type.toString()) + ' called with something that\'s not an instance of Sequelize.Model');
if (!target.prototype || !(target.prototype instanceof this.sequelize.Model)) {
throw new Error(this.name + '.' + Utils.lowercaseFirst(Type.toString()) + ' called with something that\'s not a subclass of Sequelize.Model');
}
var source = this;
......@@ -107,11 +107,11 @@ var singleLinked = function (Type) {
source.associations[association.associationAccessor] = association.injectAttributes();
if (association.mixin) {
association.mixin(source.Instance.prototype);
association.mixin(source.prototype);
} else {
association.injectGetter(source.Instance.prototype);
association.injectSetter(source.Instance.prototype);
association.injectCreator(source.Instance.prototype);
association.injectGetter(source.prototype);
association.injectSetter(source.prototype);
association.injectCreator(source.prototype);
}
return association;
......@@ -168,8 +168,8 @@ Mixin.belongsTo = singleLinked(BelongsTo);
* @param {boolean} [options.constraints=true] Should on update and on delete constraints be enabled on the foreign key.
*/
Mixin.hasMany = function(target, options) { // testhint options:none
if (!(target instanceof this.sequelize.Model)) {
throw new Error(this.name + '.hasMany called with something that\'s not an instance of Sequelize.Model');
if (!target.prototype || !(target.prototype instanceof this.sequelize.Model)) {
throw new Error(this.name + '.hasMany called with something that\'s not a subclass of Sequelize.Model');
}
var source = this;
......@@ -186,7 +186,7 @@ Mixin.hasMany = function(target, options) { // testhint options:none
source.associations[association.associationAccessor] = association;
association.injectAttributes();
association.mixin(source.Instance.prototype);
association.mixin(source.prototype);
return association;
};
......@@ -247,8 +247,8 @@ Mixin.hasMany = function(target, options) { // testhint options:none
* @param {boolean} [options.constraints=true] Should on update and on delete constraints be enabled on the foreign key.
*/
Mixin.belongsToMany = function(targetModel, options) { // testhint options:none
if (!(targetModel instanceof this.sequelize.Model)) {
throw new Error(this.name + '.belongsToMany called with something that\'s not an instance of Sequelize.Model');
if (!targetModel.prototype || !(targetModel.prototype instanceof this.sequelize.Model)) {
throw new Error(this.name + '.belongsToMany called with something that\'s not a subclass of Sequelize.Model');
}
var sourceModel = this;
......@@ -264,9 +264,9 @@ Mixin.belongsToMany = function(targetModel, options) { // testhint options:none
var association = new BelongsToMany(sourceModel, targetModel, options);
sourceModel.associations[association.associationAccessor] = association.injectAttributes();
association.injectGetter(sourceModel.Instance.prototype);
association.injectSetter(sourceModel.Instance.prototype);
association.injectCreator(sourceModel.Instance.prototype);
association.injectGetter(sourceModel.prototype);
association.injectSetter(sourceModel.prototype);
association.injectCreator(sourceModel.prototype);
return association;
};
......
lib/dialects/abstract/query-generator.js
......@@ -662,7 +662,7 @@ var QueryGenerator = {
options = this.nameIndexes([options], options.prefix)[0];
}
options = Model.prototype.$conformIndex(options);
options = Model.$conformIndex(options);
if (!this._dialect.supports.index.type) {
delete options.type;
......@@ -823,7 +823,7 @@ var QueryGenerator = {
break;
}
if (item instanceof Model) {
if (typeof item === 'function' && item.prototype instanceof Model) {
model = item;
as = undefined;
} else {
......@@ -1528,7 +1528,7 @@ var QueryGenerator = {
} else {
query += ' FOR UPDATE';
}
if (this._dialect.supports.lockOf && options.lock.of instanceof Model) {
if (this._dialect.supports.lockOf && options.lock.of && options.lock.of.prototype instanceof Model) {
query += ' OF ' + this.quoteTable(options.lock.of.name);
}
}
......@@ -1562,7 +1562,7 @@ var QueryGenerator = {
if (Array.isArray(options.order)) {
options.order.forEach(function(t) {
if (Array.isArray(t) && _.size(t) > 1) {
if (t[0] instanceof Model || t[0].model instanceof Model) {
if ((typeof t[0] === 'function' && t[0].prototype instanceof Model) || (typeof t[0].model === 'function' && t[0].model.prototype instanceof Model)) {
if (typeof t[t.length - 2] === 'string') {
validateOrder(_.last(t));
}
......@@ -1571,7 +1571,7 @@ var QueryGenerator = {
}
}
if (subQuery && (Array.isArray(t) && !(t[0] instanceof Model) && !(t[0].model instanceof Model))) {
if (subQuery && (Array.isArray(t) && !(typeof t[0] === 'function' && t[0].prototype instanceof Model) && !(t[0] && typeof t[0].model === 'function' && t[0].model.prototype instanceof Model))) {
subQueryOrder.push(this.quote(t, model));
}
......
lib/hooks.js
......@@ -100,14 +100,9 @@ var Hooks = {
runHooks: function(hooks) {
var self = this
, fn
, fnArgs = Utils.sliceArgs(arguments, 1)
, hookType;
if (typeof fnArgs[fnArgs.length - 1] === 'function') {
fn = fnArgs.pop();
}
if (typeof hooks === 'string') {
hookType = hooks;
hooks = this.options.hooks[hookType] || [];
......@@ -141,10 +136,6 @@ var Hooks = {
return hook.apply(self, fnArgs);
}).return();
if (fn) {
return promise.nodeify(fn);
}
return promise;
},
......@@ -467,7 +458,7 @@ module.exports = {
var allHooks = Object.keys(hookTypes).concat(Object.keys(hookAliases));
allHooks.forEach(function(hook) {
Model.prototype[hook] = function(name, callback) {
Model[hook] = Model.prototype[hook] = function(name, callback) {
return this.addHook(hook, name, callback);
};
});
......
lib/instance-validator.js
......@@ -19,7 +19,7 @@ var InstanceValidator = module.exports = function(modelInstance, options) {
options = _.clone(options) || {};
if (options.fields && !options.skip) {
options.skip = Utils._.difference(Object.keys(modelInstance.Model.attributes), options.fields);
options.skip = Utils._.difference(Object.keys(modelInstance.constructor.attributes), options.fields);
}
// assign defined and default options
......@@ -87,14 +87,14 @@ InstanceValidator.prototype._validate = function() {
*/
InstanceValidator.prototype.validate = function() {
if (this.options.hooks) {
return this.modelInstance.Model.runHooks('beforeValidate', this.modelInstance, this.options).bind(this).then(function() {
return this.modelInstance.constructor.runHooks('beforeValidate', this.modelInstance, this.options).bind(this).then(function() {
return this._validate().bind(this).catch(function(error) {
return this.modelInstance.Model.runHooks('validationFailed', this.modelInstance, this.options, error).then(function(newError) {
return this.modelInstance.constructor.runHooks('validationFailed', this.modelInstance, this.options, error).then(function(newError) {
throw newError || error;
});
});
}).then(function() {
return this.modelInstance.Model.runHooks('afterValidate', this.modelInstance, this.options);
return this.modelInstance.constructor.runHooks('afterValidate', this.modelInstance, this.options);
}).return(this.modelInstance);
}
return this._validate();
......
lib/instance.js deleted 100644 → 0
'use strict';
var Utils = require('./utils')
, BelongsTo = require('./associations/belongs-to')
, BelongsToMany = require('./associations/belongs-to-many')
, InstanceValidator = require('./instance-validator')
, QueryTypes = require('./query-types')
, sequelizeErrors = require('./errors')
, Dottie = require('dottie')
, Promise = require('./promise')
, _ = require('lodash')
, defaultsOptions = { raw: true };
// private
var initValues = function(values, options) {
var defaults
, key;
values = values && _.clone(values) || {};
if (options.isNewRecord) {
defaults = {};
if (this.Model._hasDefaultValues) {
defaults = _.mapValues(this.Model._defaultValues, function(valueFn) {
var value = valueFn();
return (value && value._isSequelizeMethod) ? value : _.cloneDeep(value);
});
}
// set id to null if not passed as value, a newly created dao has no id
// removing this breaks bulkCreate
// do after default values since it might have UUID as a default value
if (!defaults.hasOwnProperty(this.Model.primaryKeyAttribute)) {
defaults[this.Model.primaryKeyAttribute] = null;
}
if (this.Model._timestampAttributes.createdAt && defaults[this.Model._timestampAttributes.createdAt]) {
this.dataValues[this.Model._timestampAttributes.createdAt] = Utils.toDefaultValue(defaults[this.Model._timestampAttributes.createdAt]);
delete defaults[this.Model._timestampAttributes.createdAt];
}
if (this.Model._timestampAttributes.updatedAt && defaults[this.Model._timestampAttributes.updatedAt]) {
this.dataValues[this.Model._timestampAttributes.updatedAt] = Utils.toDefaultValue(defaults[this.Model._timestampAttributes.updatedAt]);
delete defaults[this.Model._timestampAttributes.updatedAt];
}
if (this.Model._timestampAttributes.deletedAt && defaults[this.Model._timestampAttributes.deletedAt]) {
this.dataValues[this.Model._timestampAttributes.deletedAt] = Utils.toDefaultValue(defaults[this.Model._timestampAttributes.deletedAt]);
delete defaults[this.Model._timestampAttributes.deletedAt];
}
if (Object.keys(defaults).length) {
for (key in defaults) {
if (values[key] === undefined) {
this.set(key, Utils.toDefaultValue(defaults[key]), defaultsOptions);
delete values[key];
}
}
}
}
this.set(values, options);
};
/**
* This class represents an single instance, a database row. You might see it referred to as both Instance and instance. You should not
* instantiate the Instance class directly, instead you access it using the finder and creation methods on the model.
*
* Instance instances operate with the concept of a `dataValues` property, which stores the actual values represented by the instance.
* By default, the values from dataValues can also be accessed directly from the Instance, that is:
* ```js
* instance.field
* // is the same as
* instance.get('field')
* // is the same as
* instance.getDataValue('field')
* ```
* However, if getters and/or setters are defined for `field` they will be invoked, instead of returning the value from `dataValues`.
* Accessing properties directly or using `get` is preferred for regular use, `getDataValue` should only be used for custom getters.
*
* @see {Sequelize#define} for more information about getters and setters
* @class Instance
*/
var Instance = function(values, options) {
this.dataValues = {};
this._previousDataValues = {};
this._changed = {};
this.$modelOptions = this.Model.options;
this.$options = options || {};
this.hasPrimaryKeys = this.Model.options.hasPrimaryKeys;
this.__eagerlyLoadedAssociations = [];
/**
* Returns true if this instance has not yet been persisted to the database
* @property isNewRecord
* @return {Boolean}
*/
this.isNewRecord = options.isNewRecord;
/**
* Returns the Model the instance was created from.
* @see {Model}
* @property Model
* @return {Model}
*/
initValues.call(this, values, options);
};
/**
* A reference to the sequelize instance
* @see {Sequelize}
* @property sequelize
* @return {Sequelize}
*/
Object.defineProperty(Instance.prototype, 'sequelize', {
get: function() { return this.Model.modelManager.sequelize; }
});
/**
* Get an object representing the query for this instance, use with `options.where`
*
* @property where
* @return {Object}
*/
Instance.prototype.where = function() {
var where;
where = this.Model.primaryKeyAttributes.reduce(function (result, attribute) {
result[attribute] = this.get(attribute, {raw: true});
return result;
}.bind(this), {});
if (_.size(where) === 0) {
return this.$modelOptions.whereCollection;
}
return Utils.mapWhereFieldNames(where, this.$Model);
};
Instance.prototype.toString = function () {
return '[object SequelizeInstance:'+this.Model.name+']';
};
/**
* Get the value of the underlying data value
*
* @param {String} key
* @return {any}
*/
Instance.prototype.getDataValue = function(key) {
return this.dataValues[key];
};
/**
* Update the underlying data value
*
* @param {String} key
* @param {any} value
*/
Instance.prototype.setDataValue = function(key, value) {
var originalValue = this._previousDataValues[key];
if (!Utils.isPrimitive(value) || value !== originalValue) {
this.changed(key, true);
}
this.dataValues[key] = value;
};
/**
* If no key is given, returns all values of the instance, also invoking virtual getters.
*
* If key is given and a field or virtual getter is present for the key it will call that getter - else it will return the value for key.
*
* @param {String} [key]
* @param {Object} [options]
* @param {Boolean} [options.plain=false] If set to true, included instances will be returned as plain objects
* @param {Boolean} [options.raw=false] If set to true, field and virtual setters will be ignored
* @return {Object|any}
*/
Instance.prototype.get = function(key, options) { // testhint options:none
if (options === undefined && typeof key === 'object') {
options = key;
key = undefined;
}
options = options || {};
if (key) {
if (this._customGetters[key] && !options.raw) {
return this._customGetters[key].call(this, key);
}
if (options.plain && this.$options.include && this.$options.includeNames.indexOf(key) !== -1) {
if (Array.isArray(this.dataValues[key])) {
return this.dataValues[key].map(function (instance) {
return instance.get({plain: options.plain});
});
} else if (this.dataValues[key] instanceof Instance) {
return this.dataValues[key].get({plain: options.plain});
} else {
return this.dataValues[key];
}
}
return this.dataValues[key];
}
if (this._hasCustomGetters || (options.plain && this.$options.include) || options.clone) {
var values = {}
, _key;
if (this._hasCustomGetters) {
for (_key in this._customGetters) {
if (this._customGetters.hasOwnProperty(_key)) {
values[_key] = this.get(_key, options);
}
}
}
for (_key in this.dataValues) {
if (!values.hasOwnProperty(_key) && this.dataValues.hasOwnProperty(_key)) {
values[_key] = this.get(_key, options);
}
}
return values;
}
return this.dataValues;
};
/**
* Set is used to update values on the instance (the sequelize representation of the instance that is, remember that nothing will be persisted before you actually call `save`).
* In its most basic form `set` will update a value stored in the underlying `dataValues` object. However, if a custom setter function is defined for the key, that function
* will be called instead. To bypass the setter, you can pass `raw: true` in the options object.
*
* If set is called with an object, it will loop over the object, and call set recursively for each key, value pair. If you set raw to true, the underlying dataValues will either be
* set directly to the object passed, or used to extend dataValues, if dataValues already contain values.
*
* When set is called, the previous value of the field is stored and sets a changed flag(see `changed`).
*
* Set can also be used to build instances for associations, if you have values for those.
* When using set with associations you need to make sure the property key matches the alias of the association
* while also making sure that the proper include options have been set (from .build() or .find())
*
* If called with a dot.separated key on a JSON/JSONB attribute it will set the value nested and flag the entire object as changed.
*
* @see {Model#find} for more information about includes
* @param {String|Object} key
* @param {any} value
* @param {Object} [options]
* @param {Boolean} [options.raw=false] If set to true, field and virtual setters will be ignored
* @param {Boolean} [options.reset=false] Clear all previously set data values
* @alias setAttributes
*/
Instance.prototype.set = function(key, value, options) { // testhint options:none
var values
, originalValue
, keys
, i
, length;
if (typeof key === 'object' && key !== null) {
values = key;
options = value || {};
if (options.reset) {
this.dataValues = {};
}
// If raw, and we're not dealing with includes or special attributes, just set it straight on the dataValues object
if (options.raw && !(this.$options && this.$options.include) && !(options && options.attributes) && !this.Model._hasBooleanAttributes && !this.Model._hasDateAttributes) {
if (Object.keys(this.dataValues).length) {
this.dataValues = _.extend(this.dataValues, values);
} else {
this.dataValues = values;
}
// If raw, .changed() shouldn't be true
this._previousDataValues = _.clone(this.dataValues);
} else {
// Loop and call set
if (options.attributes) {
keys = options.attributes;
if (this.Model._hasVirtualAttributes) {
keys = keys.concat(this.Model._virtualAttributes);
}
if (this.$options.includeNames) {
keys = keys.concat(this.$options.includeNames);
}
for (i = 0, length = keys.length; i < length; i++) {
if (values[keys[i]] !== undefined) {
this.set(keys[i], values[keys[i]], options);
}
}
} else {
for (key in values) {
this.set(key, values[key], options);
}
}
if (options.raw) {
// If raw, .changed() shouldn't be true
this._previousDataValues = _.clone(this.dataValues);
}
}
} else {
if (!options)
options = {};
if (!options.raw) {
originalValue = this.dataValues[key];
}
// If not raw, and there's a customer setter
if (!options.raw && this._customSetters[key]) {
this._customSetters[key].call(this, value, key);
} else {
// Check if we have included models, and if this key matches the include model names/aliases
if (this.$options && this.$options.include && this.$options.includeNames.indexOf(key) !== -1) {
// Pass it on to the include handler
this._setInclude(key, value, options);
return this;
} else {
// Bunch of stuff we won't do when its raw
if (!options.raw) {
// If attribute is not in model definition, return
if (!this._isAttribute(key)) {
if (key.indexOf('.') > -1 && this.Model._isJsonAttribute(key.split('.')[0])) {
var previousDottieValue = Dottie.get(this.dataValues, key);
if (!_.isEqual(previousDottieValue, value)) {
Dottie.set(this.dataValues, key, value);
this.changed(key.split('.')[0], true);
}
}
return this;
}
// If attempting to set primary key and primary key is already defined, return
if (this.Model._hasPrimaryKeys && originalValue && this.Model._isPrimaryKey(key)) {
return this;
}
// If attempting to set read only attributes, return
if (!this.isNewRecord && this.Model._hasReadOnlyAttributes && this.Model._isReadOnlyAttribute(key)) {
return this;
}
// Convert date fields to real date objects
if (this.Model._hasDateAttributes && this.Model._isDateAttribute(key) && !!value && !value._isSequelizeMethod) {
if (!(value instanceof Date)) {
value = new Date(value);
}
if (!(originalValue instanceof Date)) {
originalValue = new Date(originalValue);
}
if (originalValue && value.getTime() === originalValue.getTime()) {
return this;
}
}
}
// Convert boolean-ish values to booleans
if (this.Model._hasBooleanAttributes && this.Model._isBooleanAttribute(key) && value !== null && value !== undefined && !value._isSequelizeMethod) {
if (Buffer.isBuffer(value) && value.length === 1) {
// Bit fields are returned as buffers
value = value[0];
}
if (_.isString(value)) {
// Only take action on valid boolean strings.
value = (value === 'true') ? true : (value === 'false') ? false : value;
} else if (_.isNumber(value)) {
// Only take action on valid boolean integers.
value = (value === 1) ? true : (value === 0) ? false : value;
}
}
if (!options.raw && ((!Utils.isPrimitive(value) && value !== null) || value !== originalValue)) {
this._previousDataValues[key] = originalValue;
this.changed(key, true);
}
this.dataValues[key] = value;
}
}
}
return this;
};
Instance.prototype.setAttributes = function(updates) {
return this.set(updates);
};
/**
* If changed is called with a string it will return a boolean indicating whether the value of that key in `dataValues` is different from the value in `_previousDataValues`.
*
* If changed is called without an argument, it will return an array of keys that have changed.
*
* If changed is called without an argument and no keys have changed, it will return `false`.
*
* @param {String} [key]
* @return {Boolean|Array}
*/
Instance.prototype.changed = function(key, value) {
if (key) {
if (value !== undefined) {
this._changed[key] = value;
return this;
}
return this._changed[key] || false;
}
var changed = Object.keys(this.dataValues).filter(function(key) {
return this.changed(key);
}.bind(this));
return changed.length ? changed : false;
};
/**
* Returns the previous value for key from `_previousDataValues`.
*
* If called without a key, returns the previous values for all values which have changed
*
* @param {String} [key]
* @return {any|Array<any>}
*/
Instance.prototype.previous = function(key) {
if (key) {
return this._previousDataValues[key];
}
return _.pickBy(this._previousDataValues, function(value, key) {
return this.changed(key);
}.bind(this));
};
Instance.prototype._setInclude = function(key, value, options) {
if (!Array.isArray(value)) value = [value];
if (value[0] instanceof Instance) {
value = value.map(function(instance) {
return instance.dataValues;
});
}
var include = this.$options.includeMap[key]
, association = include.association
, self = this
, accessor = key
, childOptions
, primaryKeyAttribute = include.model.primaryKeyAttribute
, isEmpty;
if (!isEmpty) {
childOptions = {
isNewRecord: this.isNewRecord,
include: include.include,
includeNames: include.includeNames,
includeMap: include.includeMap,
includeValidated: true,
raw: options.raw,
attributes: include.originalAttributes
};
}
if (include.originalAttributes === undefined || include.originalAttributes.length) {
if (association.isSingleAssociation) {
if (Array.isArray(value)) {
value = value[0];
}
isEmpty = (value && value[primaryKeyAttribute] === null) || (value === null);
self[accessor] = self.dataValues[accessor] = isEmpty ? null : include.model.build(value, childOptions);
} else {
isEmpty = value[0] && value[0][primaryKeyAttribute] === null;
self[accessor] = self.dataValues[accessor] = isEmpty ? [] : include.model.bulkBuild(value, childOptions);
}
}
};
/**
* Validate this instance, and if the validation passes, persist it to the database. It will only save changed fields, and do nothing if no fields have changed.
*
* On success, the callback will be called with this instance. On validation error, the callback will be called with an instance of `Sequelize.ValidationError`.
* This error will have a property for each of the fields for which validation failed, with the error message for that field.
*
* @param {Object} [options]
* @param {string[]} [options.fields] An optional array of strings, representing database columns. If fields is provided, only those columns will be validated and saved.
* @param {Boolean} [options.silent=false] If true, the updatedAt timestamp will not be updated.
* @param {Boolean} [options.validate=true] If false, validations won't be run.
* @param {Boolean} [options.hooks=true] Run before and after create / update + validate hooks
* @param {Function} [options.logging=false] A function that gets executed while running the query to log the sql.
* @param {Transaction} [options.transaction]
* @param {String} [options.searchPath=DEFAULT] An optional parameter to specify the schema search_path (Postgres only)
*
* @return {Promise<this|Errors.ValidationError>}
*/
Instance.prototype.save = function(options) {
if (arguments.length > 1) {
throw new Error('The second argument was removed in favor of the options object.');
}
options = Utils.cloneDeep(options);
options = _.defaults(options, {
hooks: true,
validate: true
});
if (!options.fields) {
if (this.isNewRecord) {
options.fields = Object.keys(this.Model.attributes);
} else {
options.fields = _.intersection(this.changed(), Object.keys(this.Model.attributes));
}
options.defaultFields = options.fields;
}
if (options.returning === undefined) {
if (options.association) {
options.returning = false;
} else if (this.isNewRecord) {
options.returning = true;
}
}
var self = this
, primaryKeyName = this.Model.primaryKeyAttribute
, primaryKeyAttribute = primaryKeyName && this.Model.rawAttributes[primaryKeyName]
, updatedAtAttr = this.Model._timestampAttributes.updatedAt
, createdAtAttr = this.Model._timestampAttributes.createdAt
, hook = self.isNewRecord ? 'Create' : 'Update'
, wasNewRecord = this.isNewRecord
, now = Utils.now(this.sequelize.options.dialect);
if (updatedAtAttr && options.fields.length >= 1 && options.fields.indexOf(updatedAtAttr) === -1) {
options.fields.push(updatedAtAttr);
}
if (options.silent === true && !(this.isNewRecord && this.get(updatedAtAttr, {raw: true}))) {
// UpdateAtAttr might have been added as a result of Object.keys(Model.attributes). In that case we have to remove it again
Utils._.remove(options.fields, function(val) {
return val === updatedAtAttr;
});
updatedAtAttr = false;
}
if (this.isNewRecord === true) {
if (createdAtAttr && options.fields.indexOf(createdAtAttr) === -1) {
options.fields.push(createdAtAttr);
}
if (primaryKeyAttribute && primaryKeyAttribute.defaultValue && options.fields.indexOf(primaryKeyName) < 0) {
options.fields.unshift(primaryKeyName);
}
}
if (this.isNewRecord === false) {
if (primaryKeyName && this.get(primaryKeyName, {raw: true}) === undefined) {
throw new Error('You attempted to save an instance with no primary key, this is not allowed since it would result in a global update');
}
}
if (updatedAtAttr && !options.silent && options.fields.indexOf(updatedAtAttr) !== -1) {
this.dataValues[updatedAtAttr] = this.Model.$getDefaultTimestamp(updatedAtAttr) || now;
}
if (this.isNewRecord && createdAtAttr && !this.dataValues[createdAtAttr]) {
this.dataValues[createdAtAttr] = this.Model.$getDefaultTimestamp(createdAtAttr) || now;
}
return Promise.bind(this).then(function() {
// Validate
if (options.validate) {
return this.validate(options);
}
}).then(function() {
return Promise.bind(this).then(function() {
// Run before hook
if (options.hooks) {
var beforeHookValues = _.pick(this.dataValues, options.fields)
, afterHookValues
, hookChanged
, ignoreChanged = _.difference(this.changed(), options.fields); // In case of update where it's only supposed to update the passed values and the hook values
if (updatedAtAttr && options.fields.indexOf(updatedAtAttr) !== -1) {
ignoreChanged = _.without(ignoreChanged, updatedAtAttr);
}
return this.Model.runHooks('before' + hook, this, options).bind(this).then(function() {
if (options.defaultFields && !this.isNewRecord) {
afterHookValues = _.pick(this.dataValues, _.difference(this.changed(), ignoreChanged));
hookChanged = [];
Object.keys(afterHookValues).forEach(function (key) {
if (afterHookValues[key] !== beforeHookValues[key]) {
hookChanged.push(key);
}
});
options.fields = _.uniq(options.fields.concat(hookChanged));
}
if (hookChanged) {
if (options.validate) {
// Validate again
options.skip = _.difference(Object.keys(this.Model.rawAttributes), hookChanged);
return this.validate(options).then(function() {
delete options.skip;
});
}
}
});
}
}).then(function() {
if (!options.fields.length) return this;
if (!this.isNewRecord) return this;
if (!this.$options.include || !this.$options.include.length) return this;
// Nested creation for BelongsTo relations
return Promise.map(this.$options.include.filter(function (include) {
return include.association instanceof BelongsTo;
}), function (include) {
var instance = self.get(include.as);
if (!instance) return Promise.resolve();
var includeOptions = _(Utils.cloneDeep(include))
.omit(['association'])
.defaults({
transaction: options.transaction,
logging: options.logging,
parentRecord: self
}).value();
return instance.save(includeOptions).then(function () {
return self[include.association.accessors.set](instance, {save: false, logging: options.logging});
});
});
})
.then(function() {
if (!options.fields.length) return this;
if (!this.changed() && !this.isNewRecord) return this;
var values = Utils.mapValueFieldNames(this.dataValues, options.fields, this.Model)
, query = null
, args = [];
if (self.isNewRecord) {
query = 'insert';
args = [self, self.$Model.getTableName(options), values, options];
} else {
var where = this.where();
where = Utils.mapValueFieldNames(where, Object.keys(where), this.Model);
query = 'update';
args = [self, self.$Model.getTableName(options), values, where, options];
}
return self.sequelize.getQueryInterface()[query].apply(self.sequelize.getQueryInterface(), args)
.then(function(result) {
// Transfer database generated values (defaults, autoincrement, etc)
Object.keys(self.Model.rawAttributes).forEach(function (attr) {
if (self.Model.rawAttributes[attr].field &&
values[self.Model.rawAttributes[attr].field] !== undefined &&
self.Model.rawAttributes[attr].field !== attr
) {
values[attr] = values[self.Model.rawAttributes[attr].field];
delete values[self.Model.rawAttributes[attr].field];
}
});
values = _.extend(values, result.dataValues);
result.dataValues = _.extend(result.dataValues, values);
return result;
})
.tap(function(result) {
if (!wasNewRecord) return self;
if (!self.$options.include || !self.$options.include.length) return self;
// Nested creation for HasOne/HasMany/BelongsToMany relations
return Promise.map(self.$options.include.filter(function (include) {
return !(include.association instanceof BelongsTo);
}), function (include) {
var instances = self.get(include.as);
if (!instances) return Promise.resolve();
if (!Array.isArray(instances)) instances = [instances];
if (!instances.length) return Promise.resolve();
var includeOptions = _(Utils.cloneDeep(include))
.omit(['association'])
.defaults({
transaction: options.transaction,
logging: options.logging,
parentRecord: self
}).value();
// Instances will be updated in place so we can safely treat HasOne like a HasMany
return Promise.map(instances, function (instance) {
if (include.association instanceof BelongsToMany) {
return instance.save(includeOptions).then(function () {
var values = {};
values[include.association.foreignKey] = self.get(self.Model.primaryKeyAttribute, {raw: true});
values[include.association.otherKey] = instance.get(instance.Model.primaryKeyAttribute, {raw: true});
return include.association.throughModel.create(values, includeOptions);
});
} else {
instance.set(include.association.foreignKey, self.get(self.Model.primaryKeyAttribute, {raw: true}));
return instance.save(includeOptions);
}
});
});
})
.tap(function(result) {
// Run after hook
if (options.hooks) {
return self.Model.runHooks('after' + hook, result, options);
}
})
.then(function(result) {
options.fields.forEach(function (field) {
result._previousDataValues[field] = result.dataValues[field];
self.changed(field, false);
});
self.isNewRecord = false;
return result;
});
});
});
};
/*
* Refresh the current instance in-place, i.e. update the object with current data from the DB and return the same object.
* This is different from doing a `find(Instance.id)`, because that would create and return a new instance. With this method,
* all references to the Instance are updated with the new data and no new objects are created.
*
* @see {Model#find}
* @param {Object} [options] Options that are passed on to `Model.find`
* @param {Function} [options.logging=false] A function that gets executed while running the query to log the sql.
* @return {Promise<this>}
*/
Instance.prototype.reload = function(options) {
options = _.defaults({}, options, {
where: this.where(),
include: this.$options.include || null
});
return this.Model.findOne(options).bind(this)
.tap(function (reload) {
if (!reload) {
throw new sequelizeErrors.InstanceError(
'Instance could not be reloaded because it does not exist anymore (find call returned null)'
);
}
})
.then(function(reload) {
// update the internal options of the instance
this.$options = reload.$options;
// re-set instance values
this.set(reload.dataValues, {
raw: true,
reset: true && !options.attributes
});
}).return(this);
};
/*
* Validate the attribute of this instance according to validation rules set in the model definition.
*
* Emits null if and only if validation successful; otherwise an Error instance containing { field name : [error msgs] } entries.
*
* @param {Object} [options] Options that are passed to the validator
* @param {Array} [options.skip] An array of strings. All properties that are in this array will not be validated
* @param {Boolean} [options.hooks=true] Run before and after validate hooks
* @see {InstanceValidator}
*
* @return {Promise<undefined|Errors.ValidationError>}
*/
Instance.prototype.validate = function(options) {
return new InstanceValidator(this, options).validate();
};
/**
* This is the same as calling `set` and then calling `save` but it only saves the
* exact values passed to it, making it more atomic and safer.
*
* @see {Instance#set}
* @see {Instance#save}
* @param {Object} updates See `set`
* @param {Object} options See `save`
*
* @return {Promise<this>}
* @alias updateAttributes
*/
Instance.prototype.update = function(values, options) {
var changedBefore = this.changed() || []
, sideEffects
, fields
, setOptions;
options = options || {};
if (Array.isArray(options)) options = {fields: options};
options = Utils.cloneDeep(options);
setOptions = Utils.cloneDeep(options);
setOptions.attributes = options.fields;
this.set(values, setOptions);
// Now we need to figure out which fields were actually affected by the setter.
sideEffects = _.without.apply(this, [this.changed() || []].concat(changedBefore));
fields = _.union(Object.keys(values), sideEffects);
if (!options.fields) {
options.fields = _.intersection(fields, this.changed());
options.defaultFields = options.fields;
}
return this.save(options);
};
Instance.prototype.updateAttributes = Instance.prototype.update;
/**
* Destroy the row corresponding to this instance. Depending on your setting for paranoid, the row will either be completely deleted, or have its deletedAt timestamp set to the current time.
*
* @param {Object} [options={}]
* @param {Boolean} [options.force=false] If set to true, paranoid models will actually be deleted
* @param {Function} [options.logging=false] A function that gets executed while running the query to log the sql.
* @param {Transaction} [options.transaction]
* @param {String} [options.searchPath=DEFAULT] An optional parameter to specify the schema search_path (Postgres only)
*
* @return {Promise<undefined>}
*/
Instance.prototype.destroy = function(options) {
options = Utils._.extend({
hooks: true,
force: false
}, options);
return Promise.bind(this).then(function() {
// Run before hook
if (options.hooks) {
return this.Model.runHooks('beforeDestroy', this, options);
}
}).then(function() {
var where = this.where();
if (this.Model._timestampAttributes.deletedAt && options.force === false) {
var attribute = this.Model.rawAttributes[this.Model._timestampAttributes.deletedAt]
, field = attribute.field || this.Model._timestampAttributes.deletedAt
, values = {};
values[field] = new Date();
where[field] = attribute.hasOwnProperty('defaultValue') ? attribute.defaultValue : null;
this.setDataValue(field, values[field]);
return this.sequelize.getQueryInterface().update(this, this.$Model.getTableName(options), values, where, _.defaults({ hooks: false }, options));
} else {
return this.sequelize.getQueryInterface().delete(this, this.$Model.getTableName(options), where, _.assign({ type: QueryTypes.DELETE, limit: null }, options));
}
}).tap(function() {
// Run after hook
if (options.hooks) {
return this.Model.runHooks('afterDestroy', this, options);
}
}).then(function(result) {
return result;
});
};
/**
* Restore the row corresponding to this instance. Only available for paranoid models.
*
* @param {Object} [options={}]
* @param {Function} [options.logging=false] A function that gets executed while running the query to log the sql.
* @param {Transaction} [options.transaction]
*
* @return {Promise<undefined>}
*/
Instance.prototype.restore = function(options) {
if (!this.Model._timestampAttributes.deletedAt) throw new Error('Model is not paranoid');
options = Utils._.extend({
hooks: true,
force: false
}, options);
return Promise.bind(this).then(function() {
// Run before hook
if (options.hooks) {
return this.Model.runHooks('beforeRestore', this, options);
}
}).then(function() {
var deletedAtCol = this.Model._timestampAttributes.deletedAt
, deletedAtAttribute = this.Model.rawAttributes[deletedAtCol]
, deletedAtDefaultValue = deletedAtAttribute.hasOwnProperty('defaultValue') ? deletedAtAttribute.defaultValue : null;
this.setDataValue(deletedAtCol, deletedAtDefaultValue);
return this.save(_.extend({}, options, {hooks : false, omitNull : false}));
}).tap(function() {
// Run after hook
if (options.hooks) {
return this.Model.runHooks('afterRestore', this, options);
}
});
};
/**
* Increment the value of one or more columns. This is done in the database, which means it does not use the values currently stored on the Instance. The increment is done using a
* ```sql
* SET column = column + X
* ```
* query. To get the correct value after an increment into the Instance you should do a reload.
*
*```js
* instance.increment('number') // increment number by 1
* instance.increment(['number', 'count'], { by: 2 }) // increment number and count by 2
* instance.increment({ answer: 42, tries: 1}, { by: 2 }) // increment answer by 42, and tries by 1.
* // `by` is ignored, since each column has its own value
* ```
*
* @see {Instance#reload}
* @param {String|Array|Object} fields If a string is provided, that column is incremented by the value of `by` given in options. If an array is provided, the same is true for each column. If and object is provided, each column is incremented by the value given.
* @param {Object} [options]
* @param {Integer} [options.by=1] The number to increment by
* @param {Function} [options.logging=false] A function that gets executed while running the query to log the sql.
* @param {Transaction} [options.transaction]
* @param {String} [options.searchPath=DEFAULT] An optional parameter to specify the schema search_path (Postgres only)
*
* @return {Promise<this>}
*/
Instance.prototype.increment = function(fields, options) {
var identifier = this.where()
, updatedAtAttr = this.Model._timestampAttributes.updatedAt
, values = {}
, where;
options = _.defaults({}, options, {
by: 1,
attributes: {},
where: {}
});
where = _.extend({}, options.where, identifier);
if (Utils._.isString(fields)) {
values[fields] = options.by;
} else if (Utils._.isArray(fields)) {
Utils._.each(fields, function(field) {
values[field] = options.by;
});
} else { // Assume fields is key-value pairs
values = fields;
}
if (updatedAtAttr && !values[updatedAtAttr]) {
options.attributes[updatedAtAttr] = this.Model.$getDefaultTimestamp(updatedAtAttr) || Utils.now(this.sequelize.options.dialect);
}
Object.keys(values).forEach(function(attr) {
// Field name mapping
if (this.Model.rawAttributes[attr] && this.Model.rawAttributes[attr].field && this.Model.rawAttributes[attr].field !== attr) {
values[this.Model.rawAttributes[attr].field] = values[attr];
delete values[attr];
}
}, this);
return this.sequelize.getQueryInterface().increment(this, this.$Model.getTableName(options), values, where, options).return(this);
};
/**
* Decrement the value of one or more columns. This is done in the database, which means it does not use the values currently stored on the Instance. The decrement is done using a
* ```sql
* SET column = column - X
* ```
* query. To get the correct value after an decrement into the Instance you should do a reload.
*
* ```js
* instance.decrement('number') // decrement number by 1
* instance.decrement(['number', 'count'], { by: 2 }) // decrement number and count by 2
* instance.decrement({ answer: 42, tries: 1}, { by: 2 }) // decrement answer by 42, and tries by 1.
* // `by` is ignored, since each column has its own value
* ```
*
* @see {Instance#reload}
* @param {String|Array|Object} fields If a string is provided, that column is decremented by the value of `by` given in options. If an array is provided, the same is true for each column. If and object is provided, each column is decremented by the value given
* @param {Object} [options]
* @param {Integer} [options.by=1] The number to decrement by
* @param {Function} [options.logging=false] A function that gets executed while running the query to log the sql.
* @param {Transaction} [options.transaction]
* @param {String} [options.searchPath=DEFAULT] An optional parameter to specify the schema search_path (Postgres only)
*
* @return {Promise}
*/
Instance.prototype.decrement = function(fields, options) {
options = _.defaults({}, options, {
by: 1
});
if (!Utils._.isString(fields) && !Utils._.isArray(fields)) { // Assume fields is key-value pairs
Utils._.each(fields, function(value, field) {
fields[field] = -value;
});
}
options.by = 0 - options.by;
return this.increment(fields, options);
};
/**
* Check whether this and `other` Instance refer to the same row
*
* @param {Instance} other
* @return {Boolean}
*/
Instance.prototype.equals = function(other) {
var self = this;
if (!other || !other.Model) {
return false;
}
if (other.Model !== this.Model) {
return false;
}
return Utils._.every(this.Model.primaryKeyAttributes, function(attribute) {
return self.get(attribute, {raw: true}) === other.get(attribute, {raw: true});
});
};
/**
* Check if this is equal to one of `others` by calling equals
*
* @param {Array} others
* @return {Boolean}
*/
Instance.prototype.equalsOneOf = function(others) {
var self = this;
return _.some(others, function(other) {
return self.equals(other);
});
};
Instance.prototype.setValidators = function(attribute, validators) {
this.validators[attribute] = validators;
};
/**
* Convert the instance to a JSON representation. Proxies to calling `get` with no keys. This means get all values gotten from the DB, and apply all custom getters.
*
* @see {Instance#get}
* @return {object}
*/
Instance.prototype.toJSON = function() {
return this.get({
plain: true
});
};
module.exports = Instance;
lib/model.js
'use strict';
/* jshint -W110 */
var Utils = require('./utils')
, Instance = require('./instance')
, BelongsTo = require('./associations/belongs-to')
, BelongsToMany = require('./associations/belongs-to-many')
, InstanceValidator = require('./instance-validator')
, QueryTypes = require('./query-types')
, sequelizeErrors = require('./errors')
, Dottie = require('dottie')
, Promise = require('./promise')
, _ = require('lodash')
, Association = require('./associations/base')
, HasMany = require('./associations/has-many')
, DataTypes = require('./data-types')
, Util = require('util')
, Promise = require('./promise')
, QueryTypes = require('./query-types')
, Hooks = require('./hooks')
, sequelizeErrors = require('./errors')
, _ = require('lodash')
, associationsMixin = require('./associations/mixin');
, associationsMixin = require('./associations/mixin')
, defaultsOptions = { raw: true };
/**
* A Model represents a table in the database. Sometimes you might also see it referred to as model, or simply as factory.
* This class should _not_ be instantiated directly, it is created using `sequelize.define`, and already created models can be loaded using `sequelize.import`
* A Model represents a table in the database. Instances of this class represent a database row.
*
* Model instances operate with the concept of a `dataValues` property, which stores the actual values represented by the instance.
* By default, the values from dataValues can also be accessed directly from the Instance, that is:
* ```js
* instance.field
* // is the same as
* instance.get('field')
* // is the same as
* instance.getDataValue('field')
* ```
* However, if getters and/or setters are defined for `field` they will be invoked, instead of returning the value from `dataValues`.
* Accessing properties directly or using `get` is preferred for regular use, `getDataValue` should only be used for custom getters.
*
* @see {Sequelize#define} for more information about getters and setters
* @class Model
* @mixes Hooks
* @mixes Associations
*/
var Model = function(name, attributes, options) {
this.options = Utils._.extend({
timestamps: true,
instanceMethods: {},
classMethods: {},
validate: {},
freezeTableName: false,
underscored: false,
underscoredAll: false,
paranoid: false,
rejectOnEmpty: false,
whereCollection: null,
schema: null,
schemaDelimiter: '',
defaultScope: {},
scopes: [],
hooks: {},
indexes: []
}, options || {});
this.associations = {};
this.modelManager = null;
this.name = name;
this.options.hooks = _.mapValues(this.replaceHookAliases(this.options.hooks), function (hooks) {
if (!Array.isArray(hooks)) hooks = [hooks];
return hooks;
});
this.sequelize = options.sequelize;
this.underscored = this.underscored || this.underscoredAll;
if (!this.options.tableName) {
this.tableName = this.options.freezeTableName ? name : Utils.underscoredIf(Utils.pluralize(name), this.options.underscoredAll);
} else {
this.tableName = this.options.tableName;
}
this.$schema = this.options.schema;
this.$schemaDelimiter = this.options.schemaDelimiter;
// error check options
_.each(options.validate, function(validator, validatorType) {
if (_.includes(Utils._.keys(attributes), validatorType)) {
throw new Error('A model validator function must not have the same name as a field. Model: ' + name + ', field/validation name: ' + validatorType);
}
if (!_.isFunction(validator)) {
throw new Error('Members of the validate option must be functions. Model: ' + name + ', error with validate member ' + validatorType);
}
});
this.attributes = this.rawAttributes = _.mapValues(attributes, function(attribute, name) {
if (!Utils._.isPlainObject(attribute)) {
attribute = { type: attribute };
}
class Model {
attribute = this.sequelize.normalizeAttribute(attribute);
if (attribute.references) {
if (attribute.references.model instanceof Model) {
attribute.references.model = attribute.references.model.tableName;
}
}
if (attribute.type === undefined) {
throw new Error('Unrecognized data type for field ' + name);
}
return attribute;
}.bind(this));
};
Object.defineProperty(Model.prototype, 'QueryInterface', {
get: function() {
static get QueryInterface() {
return this.modelManager.sequelize.getQueryInterface();
}
});
Object.defineProperty(Model.prototype, 'QueryGenerator', {
get: function() {
static get QueryGenerator() {
return this.QueryInterface.QueryGenerator;
}
});
Model.prototype.toString = function () {
static toString() {
return '[object SequelizeModel:'+this.name+']';
};
// private
}
// validateIncludedElements should have been called before this method
var paranoidClause = function(model, options) {
// validateIncludedElements should have been called before this method
static _paranoidClause(model, options) {
options = options || {};
// Apply on each include
......@@ -125,8 +59,8 @@ var paranoidClause = function(model, options) {
// otherwise this code will never run on includes of a already conditionable where
if (options.include) {
options.include.forEach(function(include) {
paranoidClause(include.model, include);
});
this._paranoidClause(include.model, include);
}.bind(this));
}
if (!model.options.timestamps || !model.options.paranoid || options.paranoid === false) {
......@@ -150,14 +84,14 @@ var paranoidClause = function(model, options) {
}
return options;
};
}
var addOptionalClassMethods = function() {
static _addOptionalClassMethods() {
var self = this;
Utils._.each(this.options.classMethods || {}, function(fct, name) { self[name] = fct; });
};
}
var addDefaultAttributes = function() {
static _addDefaultAttributes() {
var self = this
, tail = {}
, head = {};
......@@ -167,7 +101,7 @@ var addDefaultAttributes = function() {
if (!_.some(this.rawAttributes, 'primaryKey')) {
if ('id' in this.rawAttributes) {
// Something is fishy here!
throw new Error("A column called 'id' was added to the attributes of '" + this.tableName + "' but not marked with 'primaryKey: true'");
throw new Error(`A column called 'id' was added to the attributes of \'${this.tableName}\' but not marked with 'primaryKey: true'`);
}
head = {
......@@ -222,9 +156,9 @@ var addDefaultAttributes = function() {
if (!Object.keys(this.primaryKeys).length) {
self.primaryKeys.id = self.rawAttributes.id;
}
};
}
var findAutoIncrementField = function() {
static _findAutoIncrementField() {
var fields = this.QueryGenerator.findAutoIncrementField(this);
this.autoIncrementField = null;
......@@ -236,9 +170,9 @@ var findAutoIncrementField = function() {
this.autoIncrementField = field;
}
}.bind(this));
};
}
function conformOptions(options, self) {
static _conformOptions(options, self) {
if (self) {
self.$expandAttributes(options);
}
......@@ -256,15 +190,13 @@ function conformOptions(options, self) {
// convert all included elements to { model: Model } form
options.include = options.include.map(function(include) {
include = conformInclude(include, self);
include = this._conformInclude(include, self);
return include;
});
}
Model.$conformOptions = conformOptions;
}.bind(this));
}
function conformInclude(include, self) {
static _conformInclude(include, self) {
var model;
if (include._pseudo) return include;
......@@ -277,7 +209,7 @@ function conformInclude(include, self) {
}
include = { model: model, association: include, as: include.as };
} else if (include instanceof Model) {
} else if (include.prototype && include.prototype instanceof Model) {
include = { model: include };
} else if (_.isPlainObject(include)) {
if (include.association) {
......@@ -297,17 +229,15 @@ function conformInclude(include, self) {
model = include.model;
}
conformOptions(include, model);
this._conformOptions(include, model);
} else {
throw new Error('Include unexpected. Element has to be either a Model, an Association or an object.');
}
return include;
}
Model.$conformInclude = conformInclude;
}
var expandIncludeAllElement = function(includes, include) {
static _expandIncludeAllElement(includes, include) {
// check 'all' attribute provided is valid
var all = include.all;
delete include.all;
......@@ -407,10 +337,9 @@ var expandIncludeAllElement = function(includes, include) {
});
used.pop();
})(this, includes);
};
}
var validateIncludedElement;
var validateIncludedElements = function(options, tableNames) {
static _validateIncludedElements(options, tableNames) {
if (!options.model) options.model = this;
tableNames = tableNames || {};
......@@ -427,10 +356,10 @@ var validateIncludedElements = function(options, tableNames) {
}
options.include = options.include.map(function (include) {
include = conformInclude(include);
include = this._conformInclude(include);
include.parent = options;
validateIncludedElement.call(options.model, include, tableNames, options);
this._validateIncludedElement.call(options.model, include, tableNames, options);
if (include.duplicating === undefined) {
include.duplicating = include.association.isMultiAssociation;
......@@ -444,7 +373,7 @@ var validateIncludedElements = function(options, tableNames) {
options.hasWhere = options.hasWhere || include.hasWhere || !!include.where;
return include;
});
}.bind(this));
options.include.forEach(function (include) {
include.hasParentWhere = options.hasParentWhere || !!options.where;
......@@ -499,10 +428,9 @@ var validateIncludedElements = function(options, tableNames) {
options.subQuery = false;
}
return options;
};
Model.$validateIncludedElements = validateIncludedElements;
}
validateIncludedElement = function(include, tableNames, options) {
static _validateIncludedElement(include, tableNames, options) {
tableNames[include.model.getTableName()] = true;
if (include.attributes && !options.raw) {
......@@ -623,13 +551,13 @@ validateIncludedElement = function(include, tableNames, options) {
// Validate child includes
if (include.hasOwnProperty('include')) {
validateIncludedElements.call(include.model, include, tableNames, options);
this._validateIncludedElements.call(include.model, include, tableNames, options);
}
return include;
};
}
var expandIncludeAll = Model.$expandIncludeAll = function(options) {
static _expandIncludeAll(options) {
var includes = options.include;
if (!includes) {
return;
......@@ -642,18 +570,86 @@ var expandIncludeAll = Model.$expandIncludeAll = function(options) {
includes.splice(index, 1);
index--;
expandIncludeAllElement.call(this, includes, include);
this._expandIncludeAllElement.call(this, includes, include);
}
}
Utils._.forEach(includes, function(include) {
expandIncludeAll.call(include.model, include);
});
};
this._expandIncludeAll.call(include.model, include);
}.bind(this));
}
Model.prototype.init = function(modelManager) {
static init(attributes, options, modelManager) {
var self = this;
this.options = Utils._.extend({
timestamps: true,
instanceMethods: {},
classMethods: {},
validate: {},
freezeTableName: false,
underscored: false,
underscoredAll: false,
paranoid: false,
rejectOnEmpty: false,
whereCollection: null,
schema: null,
schemaDelimiter: '',
defaultScope: {},
scopes: [],
hooks: {},
indexes: []
}, options || {});
this.associations = {};
this.modelManager = null;
this.options.hooks = _.mapValues(this.replaceHookAliases(this.options.hooks), function (hooks) {
if (!Array.isArray(hooks)) hooks = [hooks];
return hooks;
});
this.sequelize = options.sequelize;
this.underscored = this.underscored || this.underscoredAll;
if (!this.options.tableName) {
this.tableName = this.options.freezeTableName ? this.name : Utils.underscoredIf(Utils.pluralize(this.name), this.options.underscoredAll);
} else {
this.tableName = this.options.tableName;
}
this.$schema = this.options.schema;
this.$schemaDelimiter = this.options.schemaDelimiter;
// error check options
_.each(options.validate, function(validator, validatorType) {
if (_.includes(Utils._.keys(attributes), validatorType)) {
throw new Error('A model validator function must not have the same name as a field. Model: ' + this.name + ', field/validation name: ' + validatorType);
}
if (!_.isFunction(validator)) {
throw new Error('Members of the validate option must be functions. Model: ' + this.name + ', error with validate member ' + validatorType);
}
}.bind(this));
this.attributes = this.rawAttributes = _.mapValues(attributes, function(attribute, name) {
if (!Utils._.isPlainObject(attribute)) {
attribute = { type: attribute };
}
attribute = this.sequelize.normalizeAttribute(attribute);
if (attribute.references && attribute.references.model && attribute.references.model.prototype instanceof Model) {
attribute.references.model = attribute.references.model.tableName;
}
if (attribute.type === undefined) {
throw new Error('Unrecognized data type for field ' + name);
}
return attribute;
}.bind(this));
this.modelManager = modelManager;
this.primaryKeys = {};
......@@ -672,14 +668,7 @@ Model.prototype.init = function(modelManager) {
}
// Add head and tail default attributes (id, timestamps)
addOptionalClassMethods.call(this);
// Instance prototype
this.Instance = function() {
Instance.apply(this, arguments);
};
Util.inherits(this.Instance, Instance);
this._addOptionalClassMethods();
this._readOnlyAttributes = Utils._.values(this._timestampAttributes);
this._hasReadOnlyAttributes = this._readOnlyAttributes && this._readOnlyAttributes.length;
......@@ -689,36 +678,33 @@ Model.prototype.init = function(modelManager) {
if (this.options.instanceMethods) {
Utils._.each(this.options.instanceMethods, function(fct, name) {
self.Instance.prototype[name] = fct;
self.prototype[name] = fct;
});
}
addDefaultAttributes.call(this);
this._addDefaultAttributes();
this.refreshAttributes();
findAutoIncrementField.call(this);
this._findAutoIncrementField();
this.$scope = this.options.defaultScope;
if (_.isPlainObject(this.$scope)) {
conformOptions(this.$scope, this);
this._conformOptions(this.$scope, this);
}
_.each(this.options.scopes, function (scope) {
if (_.isPlainObject(scope)) {
conformOptions(scope, this);
this._conformOptions(scope, this);
}
}.bind(this));
this.options.indexes = this.options.indexes.map(this.$conformIndex);
this.Instance.prototype.$Model =
this.Instance.prototype.Model = this;
return this;
};
}
Model.prototype.$conformIndex = function (index) {
static $conformIndex(index) {
index = _.defaults(index, {
type: '',
parser: null
......@@ -729,19 +715,19 @@ Model.prototype.$conformIndex = function (index) {
delete index.type;
}
return index;
};
}
Model.prototype.refreshAttributes = function() {
static refreshAttributes() {
var self = this
, attributeManipulation = {};
this.Instance.prototype._customGetters = {};
this.Instance.prototype._customSetters = {};
this.prototype._customGetters = {};
this.prototype._customSetters = {};
Utils._.each(['get', 'set'], function(type) {
var opt = type + 'terMethods'
, funcs = Utils._.clone(Utils._.isObject(self.options[opt]) ? self.options[opt] : {})
, _custom = type === 'get' ? self.Instance.prototype._customGetters : self.Instance.prototype._customSetters;
, _custom = type === 'get' ? self.prototype._customGetters : self.prototype._customSetters;
Utils._.each(funcs, function(method, attribute) {
_custom[attribute] = method;
......@@ -793,7 +779,7 @@ Model.prototype.refreshAttributes = function() {
this._geometryAttributes = [];
this._virtualAttributes = [];
this._defaultValues = {};
this.Instance.prototype.validators = {};
this.prototype.validators = {};
this.fieldRawAttributesMap = {};
......@@ -858,7 +844,7 @@ Model.prototype.refreshAttributes = function() {
}
if (definition.hasOwnProperty('validate')) {
self.Instance.prototype.validators[name] = definition.validate;
self.prototype.validators[name] = definition.validate;
}
if (definition.index === true && definition.type instanceof DataTypes.JSONB) {
......@@ -920,22 +906,22 @@ Model.prototype.refreshAttributes = function() {
this.attributes = this.rawAttributes;
this.tableAttributes = Utils._.omit(this.rawAttributes, this._virtualAttributes);
this.Instance.prototype._hasCustomGetters = Object.keys(this.Instance.prototype._customGetters).length;
this.Instance.prototype._hasCustomSetters = Object.keys(this.Instance.prototype._customSetters).length;
this.prototype._hasCustomGetters = Object.keys(this.prototype._customGetters).length;
this.prototype._hasCustomSetters = Object.keys(this.prototype._customSetters).length;
Object.keys(attributeManipulation).forEach((function(key){
if (Instance.prototype.hasOwnProperty(key)) {
this.sequelize.log("Not overriding built-in method from model attribute: " + key);
if (Model.prototype.hasOwnProperty(key)) {
this.sequelize.log('Not overriding built-in method from model attribute: ' + key);
return;
}
Object.defineProperty(this.Instance.prototype, key, attributeManipulation[key]);
Object.defineProperty(this.prototype, key, attributeManipulation[key]);
}).bind(this));
this.Instance.prototype.rawAttributes = this.rawAttributes;
this.Instance.prototype.attributes = Object.keys(this.Instance.prototype.rawAttributes);
this.Instance.prototype._isAttribute = Utils._.memoize(function(key) {
return self.Instance.prototype.attributes.indexOf(key) !== -1;
this.prototype.rawAttributes = this.rawAttributes;
this.prototype.attributes = Object.keys(this.prototype.rawAttributes);
this.prototype._isAttribute = Utils._.memoize(function(key) {
return self.prototype.attributes.indexOf(key) !== -1;
});
// Primary key convenience variables
......@@ -952,23 +938,23 @@ Model.prototype.refreshAttributes = function() {
return self.primaryKeyAttributes.indexOf(key) !== -1;
});
};
}
/**
/**
* Remove attribute from model definition
* @param {String} [attribute]
*/
Model.prototype.removeAttribute = function(attribute) {
static removeAttribute(attribute) {
delete this.rawAttributes[attribute];
this.refreshAttributes();
};
}
/**
/**
* Sync this Model to the DB, that is create the table. Upon success, the callback will be called with the model instance (this)
* @see {Sequelize#sync} for options
* @return {Promise<this>}
*/
Model.prototype.sync = function(options) {
static sync(options) {
options = _.extend({}, this.options, options);
options.hooks = options.hooks === undefined ? true : !!options.hooks;
......@@ -1010,9 +996,9 @@ Model.prototype.sync = function(options) {
return self.runHooks('afterSync', options);
}
}).return(this);
};
}
/**
/**
* Drop the table represented by this Model
* @param {Object} [options]
* @param {Boolean} [options.cascade=false] Also drop all objects depending on this table, such as views. Only works in postgres
......@@ -1020,15 +1006,15 @@ Model.prototype.sync = function(options) {
* @param {Boolean} [options.benchmark=false] Pass query execution time in milliseconds as second argument to logging function (options.logging).
* @return {Promise}
*/
Model.prototype.drop = function(options) {
static drop(options) {
return this.QueryInterface.dropTable(this.getTableName(options), options);
};
}
Model.prototype.dropSchema = function(schema) {
static dropSchema(schema) {
return this.QueryInterface.dropSchema(schema);
};
}
/**
/**
* Apply a schema to this model. For postgres, this will actually place the schema in front of the table name - `"schema"."tableName"`,
* while the schema will be prepended to the table name for mysql and sqlite - `'schema.tablename'`.
*
......@@ -1048,9 +1034,10 @@ Model.prototype.dropSchema = function(schema) {
*
* @return {this}
*/
Model.prototype.schema = function(schema, options) { // testhint options:none
var self = this;
var clone = Object.create(self);
static schema(schema, options) { // testhint options:none
var clone = class extends this {};
Object.defineProperty(clone, 'name', {value: this.name});
clone.$schema = schema;
......@@ -1064,16 +1051,10 @@ Model.prototype.schema = function(schema, options) { // testhint options:none
}
}
clone.Instance = function() {
self.Instance.apply(this, arguments);
};
clone.Instance.prototype = Object.create(self.Instance.prototype);
clone.Instance.prototype.$Model = clone;
return clone;
};
}
/**
/**
* Get the tablename of the model, taking schema into account. The method will return The name as a string if the model has no schema,
* or an object with `tableName`, `schema` and `delimiter` properties.
*
......@@ -1082,18 +1063,18 @@ Model.prototype.schema = function(schema, options) { // testhint options:none
* @param {Boolean} [options.benchmark=false] Pass query execution time in milliseconds as second argument to logging function (options.logging).
* @return {String|Object}
*/
Model.prototype.getTableName = function(options) { // testhint options:none
static getTableName(options) { // testhint options:none
return this.QueryGenerator.addSchema(this);
};
}
/**
/**
* @return {Model}
*/
Model.prototype.unscoped = function () {
static unscoped() {
return this.scope();
};
}
/**
/**
* Add a new scope to the model. This is especially useful for adding scopes with includes, when the model you want to include is not available at the time this model is defined.
*
* By default this will throw an error if a scope with that name already exists. Pass `override: true` in the options object to silence this error.
......@@ -1103,7 +1084,7 @@ Model.prototype.unscoped = function () {
* @param {Object} [options]
* @param {Boolean} [options.override=false]
*/
Model.prototype.addScope = function (name, scope, options) {
static addScope(name, scope, options) {
options = _.assign({
override: false
}, options);
......@@ -1112,16 +1093,16 @@ Model.prototype.addScope = function (name, scope, options) {
throw new Error('The scope ' + name + ' already exists. Pass { override: true } as options to silence this error');
}
conformOptions(scope, this);
this._conformOptions(scope, this);
if (name === 'defaultScope') {
this.options.defaultScope = this.$scope = scope;
} else {
this.options.scopes[name] = scope;
}
};
}
/**
/**
* Apply a scope created in `define` to the model. First let's look at how to create scopes:
* ```js
* var Model = sequelize.define('model', attributes, {
......@@ -1167,11 +1148,12 @@ Model.prototype.addScope = function (name, scope, options) {
* @param {Array|Object|String|null} options* The scope(s) to apply. Scopes can either be passed as consecutive arguments, or as an array of arguments. To apply simple scopes and scope functions with no arguments, pass them as strings. For scope function, pass an object, with a `method` property. The value can either be a string, if the method does not take any arguments, or an array, where the first element is the name of the method, and consecutive elements are arguments to that method. Pass null to remove all scopes, including the default.
* @return {Model} A reference to the model, with the scope(s) applied. Calling scope again on the returned model will clear the previous scope.
*/
Model.prototype.scope = function(option) {
var self = Object.create(this)
static scope(option) {
var self = class extends this {}
, options
, scope
, scopeName;
Object.defineProperty(self, 'name', {value: this.name});
self.$scope = {};
self.scoped = true;
......@@ -1207,7 +1189,7 @@ Model.prototype.scope = function(option) {
if (_.isFunction(scope)) {
scope = scope();
conformOptions(scope, self);
this._conformOptions(scope, self);
}
}
}
......@@ -1225,16 +1207,16 @@ Model.prototype.scope = function(option) {
} else {
throw new Error('Invalid scope ' + scopeName + ' called.');
}
});
}.bind(this));
return self;
};
}
Model.prototype.all = function(options) {
static all(options) {
return this.findAll(options);
};
}
/**
/**
* Search for multiple instances.
*
* __Simple search using AND and =__
......@@ -1335,7 +1317,7 @@ Model.prototype.all = function(options) {
* @alias all
*/
Model.prototype.findAll = function(options) {
static findAll(options) {
if (options !== undefined && !_.isPlainObject(options)) {
throw new Error('The argument passed to findAll must be an options object, use findById if you wish to pass a single primary key value');
}
......@@ -1355,14 +1337,14 @@ Model.prototype.findAll = function(options) {
options.rejectOnEmpty = options.rejectOnEmpty || this.options.rejectOnEmpty;
return Promise.bind(this).then(function() {
conformOptions(options, this);
this._conformOptions(options, this);
this.$injectScope(options);
if (options.hooks) {
return this.runHooks('beforeFind', options);
}
}).then(function() {
expandIncludeAll.call(this, options);
this._expandIncludeAll.call(this, options);
if (options.hooks) {
return this.runHooks('beforeFindAfterExpandIncludeAll', options);
......@@ -1371,7 +1353,7 @@ Model.prototype.findAll = function(options) {
if (options.include) {
options.hasJoin = true;
validateIncludedElements.call(this, options, tableNames);
this._validateIncludedElements(options, tableNames);
// If we're not raw, we have to make sure we include the primary key for deduplication
if (options.attributes && !options.raw && this.primaryKeyAttribute && options.attributes.indexOf(this.primaryKeyAttribute) === -1) {
......@@ -1389,7 +1371,7 @@ Model.prototype.findAll = function(options) {
Utils.mapFinderOptions(options, this);
options = paranoidClause(this, options);
options = this._paranoidClause(this, options);
if (options.hooks) {
return this.runHooks('beforeFindAfterOptions', options);
......@@ -1417,9 +1399,9 @@ Model.prototype.findAll = function(options) {
return Model.$findSeparate(results, originalOptions);
});
};
}
Model.$findSeparate = function(results, options) {
static $findSeparate(results, options) {
if (!options.include || options.raw || !results) return Promise.resolve(results);
var original = results;
......@@ -1465,21 +1447,21 @@ Model.$findSeparate = function(results, options) {
});
});
}).return(original);
};
}
/**
* Search for a single instance by its primary key.
*
* @param {Number|String|Buffer} id The value of the desired instance's primary key.
* @param {Object} [options]
* @param {Transaction} [options.transaction] Transaction to run query under
* @param {String} [options.searchPath=DEFAULT] An optional parameter to specify the schema search_path (Postgres only)
*
* @see {Model#findAll} for a full explanation of options
* @return {Promise<Instance>}
* @alias findByPrimary
*/
Model.prototype.findById = function(param, options) {
/**
* Search for a single instance by its primary key.
*
* @param {Number|String|Buffer} id The value of the desired instance's primary key.
* @param {Object} [options]
* @param {Transaction} [options.transaction] Transaction to run query under
* @param {String} [options.searchPath=DEFAULT] An optional parameter to specify the schema search_path (Postgres only)
*
* @see {Model#findAll} for a full explanation of options
* @return {Promise<Instance>}
* @alias findByPrimary
*/
static findById(param, options) {
// return Promise resolved with null if no arguments are passed
if ([null, undefined].indexOf(param) !== -1) {
return Promise.resolve(null);
......@@ -1495,22 +1477,21 @@ Model.prototype.findById = function(param, options) {
}
// Bypass a possible overloaded findOne
return Model.prototype.findOne.call(this, options);
};
Model.prototype.findByPrimary = Model.prototype.findById;
return this.findOne(options);
}
/**
* Search for a single instance. This applies LIMIT 1, so the listener will always be called with a single instance.
*
* @param {Object} [options] A hash of options to describe the scope of the search
* @param {Transaction} [options.transaction] Transaction to run query under
* @param {String} [options.searchPath=DEFAULT] An optional parameter to specify the schema search_path (Postgres only)
*
* @see {Model#findAll} for an explanation of options
* @return {Promise<Instance>}
* @alias find
*/
Model.prototype.findOne = function(options) {
/**
* Search for a single instance. This applies LIMIT 1, so the listener will always be called with a single instance.
*
* @param {Object} [options] A hash of options to describe the scope of the search
* @param {Transaction} [options.transaction] Transaction to run query under
* @param {String} [options.searchPath=DEFAULT] An optional parameter to specify the schema search_path (Postgres only)
*
* @see {Model#findAll} for an explanation of options
* @return {Promise<Instance>}
* @alias find
*/
static findOne(options) {
if (options !== undefined && !_.isPlainObject(options)) {
throw new Error('The argument passed to findOne must be an options object, use findById if you wish to pass a single primary key value');
}
......@@ -1526,14 +1507,13 @@ Model.prototype.findOne = function(options) {
}
// Bypass a possible overloaded findAll.
return Model.prototype.findAll.call(this, _.defaults(options, {
return this.findAll(_.defaults(options, {
plain: true,
rejectOnEmpty: false
}));
};
Model.prototype.find = Model.prototype.findOne;
}
/**
/**
* Run an aggregation method on the specified field
*
* @param {String} field The field to aggregate over. Can be a field name or *
......@@ -1549,15 +1529,15 @@ Model.prototype.find = Model.prototype.findOne;
*
* @return {Promise<options.dataType|object>} Returns the aggregate result cast to `options.dataType`, unless `options.plain` is false, in which case the complete data result is returned.
*/
Model.prototype.aggregate = function(attribute, aggregateFunction, options) {
static aggregate(attribute, aggregateFunction, options) {
options = Utils.cloneDeep(options);
options = _.defaults(options, { attributes: [] });
conformOptions(options, this);
this._conformOptions(options, this);
this.$injectScope(options);
if (options.include) {
expandIncludeAll.call(this, options);
validateIncludedElements.call(this, options);
this._expandIncludeAll(options);
this._validateIncludedElements(options);
}
var attrOptions = this.rawAttributes[attribute]
......@@ -1581,12 +1561,12 @@ Model.prototype.aggregate = function(attribute, aggregateFunction, options) {
}
Utils.mapOptionFieldNames(options, this);
options = paranoidClause(this, options);
options = this._paranoidClause(this, options);
return this.QueryInterface.rawSelect(this.getTableName(options), options, aggregateFunction, this);
};
}
/**
/**
* Count the number of records matching the provided where clause.
*
* If you provide an `include` option, the number of matching associations will be counted instead.
......@@ -1604,14 +1584,14 @@ Model.prototype.aggregate = function(attribute, aggregateFunction, options) {
*
* @return {Promise<Integer>}
*/
Model.prototype.count = function(options) {
static count(options) {
options = Utils.cloneDeep(options);
_.defaults(options, { hooks: true });
var col = '*';
return Promise.bind(this).then(function() {
conformOptions(options, this);
this._conformOptions(options, this);
this.$injectScope(options);
if (options.hooks) {
......@@ -1620,8 +1600,8 @@ Model.prototype.count = function(options) {
}).then(function() {
if (options.include) {
col = this.name + '.' + this.primaryKeyField;
expandIncludeAll.call(this, options);
validateIncludedElements.call(this, options);
this._expandIncludeAll(options);
this._validateIncludedElements(options);
}
Utils.mapOptionFieldNames(options, this);
......@@ -1636,9 +1616,9 @@ Model.prototype.count = function(options) {
return this.aggregate(col, 'count', options);
});
};
}
/**
/**
* Find all the rows matching your query, within a specified offset / limit, and get the total number of rows matching your query. This is very useful for paging
*
* ```js
......@@ -1671,7 +1651,7 @@ Model.prototype.count = function(options) {
* @return {Promise<Object>}
* @alias findAndCountAll
*/
Model.prototype.findAndCount = function(options) {
static findAndCount(options) {
if (options !== undefined && !_.isPlainObject(options)) {
throw new Error('The argument passed to findAndCount must be an options object, use findById if you wish to pass a single primary key value');
}
......@@ -1680,7 +1660,7 @@ Model.prototype.findAndCount = function(options) {
// no limit, offset, order, attributes for the options given to count()
, countOptions = _.omit(_.clone(options), ['offset', 'limit', 'order', 'attributes']);
conformOptions(countOptions, this);
this._conformOptions(countOptions, this);
if (countOptions.include) {
countOptions.include = _.cloneDeepWith(countOptions.include, function (element) {
......@@ -1689,9 +1669,9 @@ Model.prototype.findAndCount = function(options) {
return undefined;
});
expandIncludeAll.call(this, countOptions);
this._expandIncludeAll(countOptions);
validateIncludedElements.call(this, countOptions);
this._validateIncludedElements(countOptions);
var keepNeeded = function(includes) {
return includes.filter(function (include) {
......@@ -1722,11 +1702,9 @@ Model.prototype.findAndCount = function(options) {
};
});
});
};
Model.prototype.findAndCountAll = Model.prototype.findAndCount;
}
/**
/**
* Find the maximum value of field
*
* @param {String} field
......@@ -1735,11 +1713,11 @@ Model.prototype.findAndCountAll = Model.prototype.findAndCount;
*
* @return {Promise<Any>}
*/
Model.prototype.max = function(field, options) {
static max(field, options) {
return this.aggregate(field, 'max', options);
};
}
/**
/**
* Find the minimum value of field
*
* @param {String} field
......@@ -1748,11 +1726,11 @@ Model.prototype.max = function(field, options) {
*
* @return {Promise<Any>}
*/
Model.prototype.min = function(field, options) {
static min(field, options) {
return this.aggregate(field, 'min', options);
};
}
/**
/**
* Find the sum of field
*
* @param {String} field
......@@ -1761,11 +1739,11 @@ Model.prototype.min = function(field, options) {
*
* @return {Promise<Number>}
*/
Model.prototype.sum = function(field, options) {
static sum(field, options) {
return this.aggregate(field, 'sum', options);
};
}
/**
/**
* Builds a new model instance. Values is an object of key value pairs, must be defined but can be empty.
* @param {Object} values
......@@ -1776,7 +1754,7 @@ Model.prototype.sum = function(field, options) {
*
* @return {Instance}
*/
Model.prototype.build = function(values, options) { // testhint options:none
static build(values, options) { // testhint options:none
if (Array.isArray(values)) {
return this.bulkBuild(values, options);
}
......@@ -1793,27 +1771,26 @@ Model.prototype.build = function(values, options) { // testhint options:none
}
if (!options.includeValidated) {
conformOptions(options, this);
this._conformOptions(options, this);
if (options.include) {
expandIncludeAll.call(this, options);
validateIncludedElements.call(this, options);
this._expandIncludeAll(options);
this._validateIncludedElements(options);
}
}
return new this.Instance(values, options);
};
return new this(values, options);
}
Model.prototype.bulkBuild = function(valueSets, options) { // testhint options:none
static bulkBuild(valueSets, options) { // testhint options:none
options = _.extend({
isNewRecord: true
}, options || {});
if (!options.includeValidated) {
conformOptions(options, this);
this._conformOptions(options, this);
if (options.include) {
expandIncludeAll.call(this, options);
validateIncludedElements.call(this, options);
this._expandIncludeAll(options);
this._validateIncludedElements(options);
}
}
......@@ -1826,9 +1803,9 @@ Model.prototype.bulkBuild = function(valueSets, options) { // testhint options:n
return valueSets.map(function(values) {
return this.build(values, options);
}.bind(this));
};
}
/**
/**
* Builds a new model instance and calls save on it.
* @see {Instance#build}
......@@ -1848,7 +1825,7 @@ Model.prototype.bulkBuild = function(valueSets, options) { // testhint options:n
*
* @return {Promise<Instance>}
*/
Model.prototype.create = function(values, options) {
static create(values, options) {
options = Utils.cloneDeep(options || {});
return this.build(values, {
......@@ -1858,9 +1835,9 @@ Model.prototype.create = function(values, options) {
raw: options.raw,
silent: options.silent
}).save(options);
};
}
/**
/**
* Find a row that matches the query, or build (but don't save) the row if none is found.
* The successful result of the promise will be (instance, initialized) - Make sure to use .spread()
*
......@@ -1874,7 +1851,7 @@ Model.prototype.create = function(values, options) {
* @return {Promise<Instance,initialized>}
* @alias findOrBuild
*/
Model.prototype.findOrInitialize = Model.prototype.findOrBuild = function(options) {
static findOrBuild(options) {
if (!options || !options.where || arguments.length > 1) {
throw new Error(
'Missing where attribute in the options parameter passed to findOrInitialize. ' +
......@@ -1899,9 +1876,9 @@ Model.prototype.findOrInitialize = Model.prototype.findOrBuild = function(option
return Promise.resolve([instance, false]);
});
};
}
/**
/**
* Find a row that matches the query, or build and save the row if none is found
* The successful result of the promise will be (instance, created) - Make sure to use .spread()
*
......@@ -1916,7 +1893,7 @@ Model.prototype.findOrInitialize = Model.prototype.findOrBuild = function(option
* @see {Model#findAll} for a full specification of find and options
* @return {Promise<Instance,created>}
*/
Model.prototype.findOrCreate = function(options) {
static findOrCreate(options) {
if (!options || !options.where || arguments.length > 1) {
throw new Error(
'Missing where attribute in the options parameter passed to findOrCreate. '+
......@@ -1992,9 +1969,9 @@ Model.prototype.findOrCreate = function(options) {
return transaction.commit();
}
});
};
}
/**
/**
* A more performant findOrCreate that will not work under a transaction (at least not in postgres)
* Will execute a find call, if empty then attempt to create, if unique constraint then attempt to find again
*
......@@ -2004,7 +1981,7 @@ Model.prototype.findOrCreate = function(options) {
* @see {Model#findAll} for a full specification of find and options
* @return {Promise<Instance,created>}
*/
Model.prototype.findCreateFind = function(options) {
static findCreateFind(options) {
if (!options || !options.where) {
throw new Error(
'Missing where attribute in the options parameter passed to findOrCreate.'
......@@ -2028,9 +2005,9 @@ Model.prototype.findCreateFind = function(options) {
});
});
});
};
}
/**
/**
* Insert or update a single row. An update will be executed if a row which matches the supplied values on either the primary key or a unique key is found. Note that the unique index must be defined in your sequelize model and not just in the table. Otherwise you may experience a unique constraint violation, because sequelize fails to identify the row that should be updated.
*
* **Implementation details:**
......@@ -2053,7 +2030,7 @@ Model.prototype.findCreateFind = function(options) {
* @alias insertOrUpdate
* @return {Promise<created>} Returns a boolean indicating whether the row was created or updated.
*/
Model.prototype.upsert = function (values, options) {
static upsert(values, options) {
options = Utils.cloneDeep(options) || {};
if (!options.fields) {
......@@ -2089,11 +2066,9 @@ Model.prototype.upsert = function (values, options) {
return this.QueryInterface.upsert(this.getTableName(options), insertValues, updateValues, instance.where(), this, options);
});
};
Model.prototype.insertOrUpdate = Model.prototype.upsert;
}
/**
/**
* Create and insert multiple instances in bulk.
*
* The success handler is passed an array of instances, but please notice that these may not completely represent the state of the rows in the DB. This is because MySQL
......@@ -2118,7 +2093,7 @@ Model.prototype.insertOrUpdate = Model.prototype.upsert;
*
* @return {Promise<Array<Instance>>}
*/
Model.prototype.bulkCreate = function(records, options) {
static bulkCreate(records, options) {
if (!records.length) {
return Promise.resolve([]);
}
......@@ -2246,14 +2221,14 @@ Model.prototype.bulkCreate = function(records, options) {
}).then(function() {
return instances;
});
};
}
/**
/**
* Truncate all instances of the model. This is a convenient method for Model.destroy({ truncate: true }).
*
* @param {object} [options] The options passed to Model.destroy in addition to truncate
* @param {Boolean|function} [options.transaction] Transaction to run query under
* @param {Boolean|function} [options.cascade=false] Only used in conjunction with TRUNCATE. Truncates all tables that have foreign-key references to the named table, or to any tables added to the group due to CASCADE.
* @param {Boolean|function} [options.cascade = false] Only used in conjunction with TRUNCATE. Truncates all tables that have foreign-key references to the named table, or to any tables added to the group due to CASCADE.
* @param {Transaction} [options.transaction] Transaction to run query under
* @param {Boolean|function} [options.logging] A function that logs sql queries, or false for no logging
* @param {Boolean} [options.benchmark=false] Pass query execution time in milliseconds as second argument to logging function (options.logging).
......@@ -2263,13 +2238,13 @@ Model.prototype.bulkCreate = function(records, options) {
*
* @see {Model#destroy} for more information
*/
Model.prototype.truncate = function(options) {
static truncate(options) {
options = Utils.cloneDeep(options) || {};
options.truncate = true;
return this.destroy(options);
};
}
/**
/**
* Delete multiple instances, or set their deletedAt timestamp to the current time if `paranoid` is enabled.
*
* @param {Object} options
......@@ -2285,7 +2260,7 @@ Model.prototype.truncate = function(options) {
* @param {Boolean} [options.benchmark=false] Pass query execution time in milliseconds as second argument to logging function (options.logging).
* @return {Promise<Integer>} The number of destroyed rows
*/
Model.prototype.destroy = function(options) {
static destroy(options) {
var self = this
, instances;
......@@ -2357,23 +2332,23 @@ Model.prototype.destroy = function(options) {
}).then(function(affectedRows) {
return affectedRows;
});
};
}
/**
/**
* Restore multiple instances if `paranoid` is enabled.
*
* @param {Object} options
* @param {Object} [options.where] Filter the restore
* @param {Boolean} [options.hooks=true] Run before / after bulk restore hooks?
* @param {Boolean} [options.individualHooks=false] If set to true, restore will find all records within the where parameter and will execute before / after bulkRestore hooks on each row
* @param {Number} [options.limit] How many rows to undelete
* @param {Number} [options.limit] How many rows to undelete (only for mysql)
* @param {Function} [options.logging=false] A function that gets executed while running the query to log the sql.
* @param {Boolean} [options.benchmark=false] Pass query execution time in milliseconds as second argument to logging function (options.logging).
* @param {Transaction} [options.transaction] Transaction to run query under
*
* @return {Promise<undefined>}
*/
Model.prototype.restore = function(options) {
static restore(options) {
if (!this._timestampAttributes.deletedAt) throw new Error('Model is not paranoid');
options = Utils._.extend({
......@@ -2430,9 +2405,9 @@ Model.prototype.restore = function(options) {
}).then(function(affectedRows) {
return affectedRows;
});
};
}
/**
/**
* Update multiple instances that match the where options. The promise returns an array with one or two elements. The first element is always the number
* of affected rows, while the second element is the actual affected rows (only supported in postgres with `options.returning` true.)
*
......@@ -2445,7 +2420,7 @@ Model.prototype.restore = function(options) {
* @param {Boolean} [options.sideEffects=true] Whether or not to update the side effects of any virtual setters.
* @param {Boolean} [options.individualHooks=false] Run before / after update hooks?. If true, this will execute a SELECT followed by individual UPDATEs. A select is needed, because the row data needs to be passed to the hooks
* @param {Boolean} [options.returning=false] Return the affected rows (only for postgres)
* @param {Number} [options.limit] How many rows to update (only for mysql)
* @param {Number} [options.limit] How many rows to update (only for mysql and mariadb)
* @param {Function} [options.logging=false] A function that gets executed while running the query to log the sql.
* @param {Boolean} [options.benchmark=false] Pass query execution time in milliseconds as second argument to logging function (options.logging).
* @param {Transaction} [options.transaction] Transaction to run query under
......@@ -2453,7 +2428,7 @@ Model.prototype.restore = function(options) {
*
* @return {Promise<Array<affectedCount,affectedRows>>}
*/
Model.prototype.update = function(values, options) {
static update(values, options) {
var self = this;
if (!options || !options.where) {
......@@ -2649,25 +2624,25 @@ Model.prototype.update = function(values, options) {
// Return result in form [affectedRows, instances] (instances missed off if options.individualHooks != true)
return result;
});
};
}
/**
/**
* Run a describe query on the table. The result will be return to the listener as a hash of attributes and their types.
*
* @return {Promise}
*/
Model.prototype.describe = function(schema, options) {
static describe(schema, options) {
return this.QueryInterface.describeTable(this.tableName, _.assign({schema: schema || this.$schema || undefined}, options));
};
}
Model.prototype.$getDefaultTimestamp = function(attr) {
static $getDefaultTimestamp(attr) {
if (!!this.rawAttributes[attr] && !!this.rawAttributes[attr].defaultValue) {
return Utils.toDefaultValue(this.rawAttributes[attr].defaultValue);
}
return undefined;
};
}
Model.prototype.$expandAttributes = function (options) {
static $expandAttributes(options) {
if (_.isPlainObject(options.attributes)) {
var attributes = Object.keys(this.rawAttributes);
......@@ -2682,10 +2657,10 @@ Model.prototype.$expandAttributes = function (options) {
options.attributes = attributes;
}
};
}
// Inject $scope into options. Includes should have been conformed (conformOptions) before calling this
Model.prototype.$injectScope = function (options) {
// Inject $scope into options. Includes should have been conformed (conformOptions) before calling this
static $injectScope(options) {
var self = this;
var scope = Utils.cloneDeep(this.$scope);
......@@ -2715,13 +2690,1056 @@ Model.prototype.$injectScope = function (options) {
}
});
}
};
}
Model.prototype.inspect = function() {
static inspect() {
return this.name;
};
}
constructor(values, options) {
this.dataValues = {};
this._previousDataValues = {};
this._changed = {};
this.$modelOptions = this.constructor.options;
this.$options = options || {};
this.hasPrimaryKeys = this.constructor.options.hasPrimaryKeys;
this.__eagerlyLoadedAssociations = [];
/**
* Returns true if this instance has not yet been persisted to the database
* @property isNewRecord
* @return {Boolean}
*/
this.isNewRecord = options.isNewRecord;
/**
* Returns the Model the instance was created from.
* @see {Model}
* @property Model
* @return {Model}
*/
this._initValues(values, options);
}
_initValues(values, options) {
var defaults
, key;
values = values && _.clone(values) || {};
if (options.isNewRecord) {
defaults = {};
if (this.constructor._hasDefaultValues) {
defaults = _.mapValues(this.constructor._defaultValues, function(valueFn) {
var value = valueFn();
return (value && value._isSequelizeMethod) ? value : _.cloneDeep(value);
});
}
// set id to null if not passed as value, a newly created dao has no id
// removing this breaks bulkCreate
// do after default values since it might have UUID as a default value
if (!defaults.hasOwnProperty(this.constructor.primaryKeyAttribute)) {
defaults[this.constructor.primaryKeyAttribute] = null;
}
if (this.constructor._timestampAttributes.createdAt && defaults[this.constructor._timestampAttributes.createdAt]) {
this.dataValues[this.constructor._timestampAttributes.createdAt] = Utils.toDefaultValue(defaults[this.constructor._timestampAttributes.createdAt]);
delete defaults[this.constructor._timestampAttributes.createdAt];
}
if (this.constructor._timestampAttributes.updatedAt && defaults[this.constructor._timestampAttributes.updatedAt]) {
this.dataValues[this.constructor._timestampAttributes.updatedAt] = Utils.toDefaultValue(defaults[this.constructor._timestampAttributes.updatedAt]);
delete defaults[this.constructor._timestampAttributes.updatedAt];
}
if (this.constructor._timestampAttributes.deletedAt && defaults[this.constructor._timestampAttributes.deletedAt]) {
this.dataValues[this.constructor._timestampAttributes.deletedAt] = Utils.toDefaultValue(defaults[this.constructor._timestampAttributes.deletedAt]);
delete defaults[this.constructor._timestampAttributes.deletedAt];
}
if (Object.keys(defaults).length) {
for (key in defaults) {
if (values[key] === undefined) {
this.set(key, Utils.toDefaultValue(defaults[key]), defaultsOptions);
delete values[key];
}
}
}
}
this.set(values, options);
}
/**
* A reference to the sequelize instance
* @see {Sequelize}
* @property sequelize
* @return {Sequelize}
*/
get sequelize() {
return this.constructor.modelManager.sequelize;
}
/**
* Get an object representing the query for this instance, use with `options.where`
*
* @property where
* @return {Object}
*/
where() {
var where;
where = this.constructor.primaryKeyAttributes.reduce(function (result, attribute) {
result[attribute] = this.get(attribute, {raw: true});
return result;
}.bind(this), {});
if (_.size(where) === 0) {
return this.$modelOptions.whereCollection;
}
return Utils.mapWhereFieldNames(where, this.constructor);
}
toString() {
return '[object SequelizeInstance:'+this.constructor.name+']';
}
/**
* Get the value of the underlying data value
*
* @param {String} key
* @return {any}
*/
getDataValue(key) {
return this.dataValues[key];
}
/**
* Update the underlying data value
*
* @param {String} key
* @param {any} value
*/
setDataValue(key, value) {
var originalValue = this._previousDataValues[key];
if (!Utils.isPrimitive(value) || value !== originalValue) {
this.changed(key, true);
}
this.dataValues[key] = value;
}
/**
* If no key is given, returns all values of the instance, also invoking virtual getters.
*
* If key is given and a field or virtual getter is present for the key it will call that getter - else it will return the value for key.
*
* @param {String} [key]
* @param {Object} [options]
* @param {Boolean} [options.plain=false] If set to true, included instances will be returned as plain objects
* @param {Boolean} [options.raw=false] If set to true, field and virtual setters will be ignored
* @return {Object|any}
*/
get(key, options) { // testhint options:none
if (options === undefined && typeof key === 'object') {
options = key;
key = undefined;
}
options = options || {};
if (key) {
if (this._customGetters[key] && !options.raw) {
return this._customGetters[key].call(this, key);
}
if (options.plain && this.$options.include && this.$options.includeNames.indexOf(key) !== -1) {
if (Array.isArray(this.dataValues[key])) {
return this.dataValues[key].map(function (instance) {
return instance.get({plain: options.plain});
});
} else if (this.dataValues[key] instanceof Model) {
return this.dataValues[key].get({plain: options.plain});
} else {
return this.dataValues[key];
}
}
return this.dataValues[key];
}
if (this._hasCustomGetters || (options.plain && this.$options.include) || options.clone) {
var values = {}
, _key;
if (this._hasCustomGetters) {
for (_key in this._customGetters) {
if (this._customGetters.hasOwnProperty(_key)) {
values[_key] = this.get(_key, options);
}
}
}
for (_key in this.dataValues) {
if (!values.hasOwnProperty(_key) && this.dataValues.hasOwnProperty(_key)) {
values[_key] = this.get(_key, options);
}
}
return values;
}
return this.dataValues;
}
/**
* Set is used to update values on the instance (the sequelize representation of the instance that is, remember that nothing will be persisted before you actually call `save`).
* In its most basic form `set` will update a value stored in the underlying `dataValues` object. However, if a custom setter function is defined for the key, that function
* will be called instead. To bypass the setter, you can pass `raw: true` in the options object.
*
* If set is called with an object, it will loop over the object, and call set recursively for each key, value pair. If you set raw to true, the underlying dataValues will either be
* set directly to the object passed, or used to extend dataValues, if dataValues already contain values.
*
* When set is called, the previous value of the field is stored and sets a changed flag(see `changed`).
*
* Set can also be used to build instances for associations, if you have values for those.
* When using set with associations you need to make sure the property key matches the alias of the association
* while also making sure that the proper include options have been set (from .build() or .find())
*
* If called with a dot.separated key on a JSON/JSONB attribute it will set the value nested and flag the entire object as changed.
*
* @see {Model#find} for more information about includes
* @param {String|Object} key
* @param {any} value
* @param {Object} [options]
* @param {Boolean} [options.raw=false] If set to true, field and virtual setters will be ignored
* @param {Boolean} [options.reset=false] Clear all previously set data values
* @alias setAttributes
*/
set(key, value, options) { // testhint options:none
var values
, originalValue
, keys
, i
, length;
if (typeof key === 'object' && key !== null) {
values = key;
options = value || {};
if (options.reset) {
this.dataValues = {};
}
// If raw, and we're not dealing with includes or special attributes, just set it straight on the dataValues object
if (options.raw && !(this.$options && this.$options.include) && !(options && options.attributes) && !this.constructor._hasBooleanAttributes && !this.constructor._hasDateAttributes) {
if (Object.keys(this.dataValues).length) {
this.dataValues = _.extend(this.dataValues, values);
} else {
this.dataValues = values;
}
// If raw, .changed() shouldn't be true
this._previousDataValues = _.clone(this.dataValues);
} else {
// Loop and call set
if (options.attributes) {
keys = options.attributes;
if (this.constructor._hasVirtualAttributes) {
keys = keys.concat(this.constructor._virtualAttributes);
}
if (this.$options.includeNames) {
keys = keys.concat(this.$options.includeNames);
}
for (i = 0, length = keys.length; i < length; i++) {
if (values[keys[i]] !== undefined) {
this.set(keys[i], values[keys[i]], options);
}
}
} else {
for (key in values) {
this.set(key, values[key], options);
}
}
if (options.raw) {
// If raw, .changed() shouldn't be true
this._previousDataValues = _.clone(this.dataValues);
}
}
} else {
if (!options)
options = {};
if (!options.raw) {
originalValue = this.dataValues[key];
}
// If not raw, and there's a customer setter
if (!options.raw && this._customSetters[key]) {
this._customSetters[key].call(this, value, key);
} else {
// Check if we have included models, and if this key matches the include model names/aliases
if (this.$options && this.$options.include && this.$options.includeNames.indexOf(key) !== -1) {
// Pass it on to the include handler
this._setInclude(key, value, options);
return this;
} else {
// Bunch of stuff we won't do when its raw
if (!options.raw) {
// If attribute is not in model definition, return
if (!this._isAttribute(key)) {
if (key.indexOf('.') > -1 && this.constructor._isJsonAttribute(key.split('.')[0])) {
var previousDottieValue = Dottie.get(this.dataValues, key);
if (!_.isEqual(previousDottieValue, value)) {
Dottie.set(this.dataValues, key, value);
this.changed(key.split('.')[0], true);
}
}
return this;
}
// If attempting to set primary key and primary key is already defined, return
if (this.constructor._hasPrimaryKeys && originalValue && this.constructor._isPrimaryKey(key)) {
return this;
}
// If attempting to set read only attributes, return
if (!this.isNewRecord && this.constructor._hasReadOnlyAttributes && this.constructor._isReadOnlyAttribute(key)) {
return this;
}
// Convert date fields to real date objects
if (this.constructor._hasDateAttributes && this.constructor._isDateAttribute(key) && !!value && !value._isSequelizeMethod) {
if (!(value instanceof Date)) {
value = new Date(value);
}
if (!(originalValue instanceof Date)) {
originalValue = new Date(originalValue);
}
if (originalValue && value.getTime() === originalValue.getTime()) {
return this;
}
}
}
// Convert boolean-ish values to booleans
if (this.constructor._hasBooleanAttributes && this.constructor._isBooleanAttribute(key) && value !== null && value !== undefined && !value._isSequelizeMethod) {
if (Buffer.isBuffer(value) && value.length === 1) {
// Bit fields are returned as buffers
value = value[0];
}
if (_.isString(value)) {
// Only take action on valid boolean strings.
value = (value === 'true') ? true : (value === 'false') ? false : value;
} else if (_.isNumber(value)) {
// Only take action on valid boolean integers.
value = (value === 1) ? true : (value === 0) ? false : value;
}
}
if (!options.raw && ((!Utils.isPrimitive(value) && value !== null) || value !== originalValue)) {
this._previousDataValues[key] = originalValue;
this.changed(key, true);
}
this.dataValues[key] = value;
}
}
}
return this;
}
setAttributes(updates) {
return this.set(updates);
}
/**
* If changed is called with a string it will return a boolean indicating whether the value of that key in `dataValues` is different from the value in `_previousDataValues`.
*
* If changed is called without an argument, it will return an array of keys that have changed.
*
* If changed is called without an argument and no keys have changed, it will return `false`.
*
* @param {String} [key]
* @return {Boolean|Array}
*/
changed(key, value) {
if (key) {
if (value !== undefined) {
this._changed[key] = value;
return this;
}
return this._changed[key] || false;
}
var changed = Object.keys(this.dataValues).filter(function(key) {
return this.changed(key);
}.bind(this));
return changed.length ? changed : false;
}
/**
* Returns the previous value for key from `_previousDataValues`.
*
* If called without a key, returns the previous values for all values which have changed
*
* @param {String} [key]
* @return {any|Array<any>}
*/
previous(key) {
if (key) {
return this._previousDataValues[key];
}
return _.pickBy(this._previousDataValues, function(value, key) {
return this.changed(key);
}.bind(this));
}
_setInclude(key, value, options) {
if (!Array.isArray(value)) value = [value];
if (value[0] instanceof Model) {
value = value.map(function(instance) {
return instance.dataValues;
});
}
var include = this.$options.includeMap[key]
, association = include.association
, self = this
, accessor = key
, childOptions
, primaryKeyAttribute = include.model.primaryKeyAttribute
, isEmpty;
if (!isEmpty) {
childOptions = {
isNewRecord: this.isNewRecord,
include: include.include,
includeNames: include.includeNames,
includeMap: include.includeMap,
includeValidated: true,
raw: options.raw,
attributes: include.originalAttributes
};
}
if (include.originalAttributes === undefined || include.originalAttributes.length) {
if (association.isSingleAssociation) {
if (Array.isArray(value)) {
value = value[0];
}
isEmpty = (value && value[primaryKeyAttribute] === null) || (value === null);
self[accessor] = self.dataValues[accessor] = isEmpty ? null : include.model.build(value, childOptions);
} else {
isEmpty = value[0] && value[0][primaryKeyAttribute] === null;
self[accessor] = self.dataValues[accessor] = isEmpty ? [] : include.model.bulkBuild(value, childOptions);
}
}
}
/**
* Validate this instance, and if the validation passes, persist it to the database. It will only save changed fields, and do nothing if no fields have changed.
*
* On success, the callback will be called with this instance. On validation error, the callback will be called with an instance of `Sequelize.ValidationError`.
* This error will have a property for each of the fields for which validation failed, with the error message for that field.
*
* @param {Object} [options]
* @param {string[]} [options.fields] An optional array of strings, representing database columns. If fields is provided, only those columns will be validated and saved.
* @param {Boolean} [options.silent=false] If true, the updatedAt timestamp will not be updated.
* @param {Boolean} [options.validate=true] If false, validations won't be run.
* @param {Boolean} [options.hooks=true] Run before and after create / update + validate hooks
* @param {Function} [options.logging=false] A function that gets executed while running the query to log the sql.
* @param {Transaction} [options.transaction]
* @param {String} [options.searchPath=DEFAULT] An optional parameter to specify the schema search_path (Postgres only)
*
* @return {Promise<this|Errors.ValidationError>}
*/
save(options) {
if (arguments.length > 1) {
throw new Error('The second argument was removed in favor of the options object.');
}
options = Utils.cloneDeep(options);
options = _.defaults(options, {
hooks: true,
validate: true
});
if (!options.fields) {
if (this.isNewRecord) {
options.fields = Object.keys(this.constructor.attributes);
} else {
options.fields = _.intersection(this.changed(), Object.keys(this.constructor.attributes));
}
options.defaultFields = options.fields;
}
if (options.returning === undefined) {
if (options.association) {
options.returning = false;
} else if (this.isNewRecord) {
options.returning = true;
}
}
var self = this
, primaryKeyName = this.constructor.primaryKeyAttribute
, primaryKeyAttribute = primaryKeyName && this.constructor.rawAttributes[primaryKeyName]
, updatedAtAttr = this.constructor._timestampAttributes.updatedAt
, createdAtAttr = this.constructor._timestampAttributes.createdAt
, hook = self.isNewRecord ? 'Create' : 'Update'
, wasNewRecord = this.isNewRecord
, now = Utils.now(this.sequelize.options.dialect);
if (updatedAtAttr && options.fields.length >= 1 && options.fields.indexOf(updatedAtAttr) === -1) {
options.fields.push(updatedAtAttr);
}
if (options.silent === true && !(this.isNewRecord && this.get(updatedAtAttr, {raw: true}))) {
// UpdateAtAttr might have been added as a result of Object.keys(Model.attributes). In that case we have to remove it again
Utils._.remove(options.fields, function(val) {
return val === updatedAtAttr;
});
updatedAtAttr = false;
}
if (this.isNewRecord === true) {
if (createdAtAttr && options.fields.indexOf(createdAtAttr) === -1) {
options.fields.push(createdAtAttr);
}
if (primaryKeyAttribute && primaryKeyAttribute.defaultValue && options.fields.indexOf(primaryKeyName) < 0) {
options.fields.unshift(primaryKeyName);
}
}
if (this.isNewRecord === false) {
if (primaryKeyName && this.get(primaryKeyName, {raw: true}) === undefined) {
throw new Error('You attempted to save an instance with no primary key, this is not allowed since it would result in a global update');
}
}
if (updatedAtAttr && !options.silent && options.fields.indexOf(updatedAtAttr) !== -1) {
this.dataValues[updatedAtAttr] = this.constructor.$getDefaultTimestamp(updatedAtAttr) || now;
}
if (this.isNewRecord && createdAtAttr && !this.dataValues[createdAtAttr]) {
this.dataValues[createdAtAttr] = this.constructor.$getDefaultTimestamp(createdAtAttr) || now;
}
return Promise.bind(this).then(function() {
// Validate
if (options.validate) {
return this.validate(options);
}
}).then(function() {
return Promise.bind(this).then(function() {
// Run before hook
if (options.hooks) {
var beforeHookValues = _.pick(this.dataValues, options.fields)
, afterHookValues
, hookChanged
, ignoreChanged = _.difference(this.changed(), options.fields); // In case of update where it's only supposed to update the passed values and the hook values
if (updatedAtAttr && options.fields.indexOf(updatedAtAttr) !== -1) {
ignoreChanged = _.without(ignoreChanged, updatedAtAttr);
}
return this.constructor.runHooks('before' + hook, this, options).bind(this).then(function() {
if (options.defaultFields && !this.isNewRecord) {
afterHookValues = _.pick(this.dataValues, _.difference(this.changed(), ignoreChanged));
hookChanged = [];
Object.keys(afterHookValues).forEach(function (key) {
if (afterHookValues[key] !== beforeHookValues[key]) {
hookChanged.push(key);
}
});
options.fields = _.uniq(options.fields.concat(hookChanged));
}
if (hookChanged) {
if (options.validate) {
// Validate again
options.skip = _.difference(Object.keys(this.constructor.rawAttributes), hookChanged);
return this.validate(options).then(function() {
delete options.skip;
});
}
}
});
}
}).then(function() {
if (!options.fields.length) return this;
if (!this.isNewRecord) return this;
if (!this.$options.include || !this.$options.include.length) return this;
// Nested creation for BelongsTo relations
return Promise.map(this.$options.include.filter(function (include) {
return include.association instanceof BelongsTo;
}), function (include) {
var instance = self.get(include.as);
if (!instance) return Promise.resolve();
var includeOptions = _(Utils.cloneDeep(include))
.omit(['association'])
.defaults({
transaction: options.transaction,
logging: options.logging,
parentRecord: self
}).value();
return instance.save(includeOptions).then(function () {
return self[include.association.accessors.set](instance, {save: false, logging: options.logging});
});
});
})
.then(function() {
if (!options.fields.length) return this;
if (!this.changed() && !this.isNewRecord) return this;
var values = Utils.mapValueFieldNames(this.dataValues, options.fields, this.constructor)
, query = null
, args = [];
if (self.isNewRecord) {
query = 'insert';
args = [self, self.constructor.getTableName(options), values, options];
} else {
var where = this.where();
where = Utils.mapValueFieldNames(where, Object.keys(where), this.constructor);
query = 'update';
args = [self, self.constructor.getTableName(options), values, where, options];
}
return self.sequelize.getQueryInterface()[query].apply(self.sequelize.getQueryInterface(), args)
.then(function(result) {
// Transfer database generated values (defaults, autoincrement, etc)
Object.keys(self.constructor.rawAttributes).forEach(function (attr) {
if (self.constructor.rawAttributes[attr].field &&
values[self.constructor.rawAttributes[attr].field] !== undefined &&
self.constructor.rawAttributes[attr].field !== attr
) {
values[attr] = values[self.constructor.rawAttributes[attr].field];
delete values[self.constructor.rawAttributes[attr].field];
}
});
values = _.extend(values, result.dataValues);
result.dataValues = _.extend(result.dataValues, values);
return result;
})
.tap(function(result) {
if (!wasNewRecord) return self;
if (!self.$options.include || !self.$options.include.length) return self;
// Nested creation for HasOne/HasMany/BelongsToMany relations
return Promise.map(self.$options.include.filter(function (include) {
return !(include.association instanceof BelongsTo);
}), function (include) {
var instances = self.get(include.as);
if (!instances) return Promise.resolve();
if (!Array.isArray(instances)) instances = [instances];
if (!instances.length) return Promise.resolve();
var includeOptions = _(Utils.cloneDeep(include))
.omit(['association'])
.defaults({
transaction: options.transaction,
logging: options.logging,
parentRecord: self
}).value();
// Instances will be updated in place so we can safely treat HasOne like a HasMany
return Promise.map(instances, function (instance) {
if (include.association instanceof BelongsToMany) {
return instance.save(includeOptions).then(function () {
var values = {};
values[include.association.foreignKey] = self.get(self.constructor.primaryKeyAttribute, {raw: true});
values[include.association.otherKey] = instance.get(instance.constructor.primaryKeyAttribute, {raw: true});
return include.association.throughModel.create(values, includeOptions);
});
} else {
instance.set(include.association.foreignKey, self.get(self.constructor.primaryKeyAttribute, {raw: true}));
return instance.save(includeOptions);
}
});
});
})
.tap(function(result) {
// Run after hook
if (options.hooks) {
return self.constructor.runHooks('after' + hook, result, options);
}
})
.then(function(result) {
options.fields.forEach(function (field) {
result._previousDataValues[field] = result.dataValues[field];
self.changed(field, false);
});
self.isNewRecord = false;
return result;
});
});
});
}
/*
* Refresh the current instance in-place, i.e. update the object with current data from the DB and return the same object.
* This is different from doing a `find(Instance.id)`, because that would create and return a new instance. With this method,
* all references to the Instance are updated with the new data and no new objects are created.
*
* @see {Model#find}
* @param {Object} [options] Options that are passed on to `Model.find`
* @param {Function} [options.logging=false] A function that gets executed while running the query to log the sql.
* @return {Promise<this>}
*/
reload(options) {
options = _.defaults({}, options, {
where: this.where(),
include: this.$options.include || null
});
return this.constructor.findOne(options).bind(this)
.tap(function (reload) {
if (!reload) {
throw new sequelizeErrors.InstanceError(
'Instance could not be reloaded because it does not exist anymore (find call returned null)'
);
}
})
.then(function(reload) {
// update the internal options of the instance
this.$options = reload.$options;
// re-set instance values
this.set(reload.dataValues, {
raw: true,
reset: true && !options.attributes
});
}).return(this);
}
/*
* Validate the attribute of this instance according to validation rules set in the model definition.
*
* Emits null if and only if validation successful; otherwise an Error instance containing { field name : [error msgs] } entries.
*
* @param {Object} [options] Options that are passed to the validator
* @param {Array} [options.skip] An array of strings. All properties that are in this array will not be validated
* @param {Boolean} [options.hooks=true] Run before and after validate hooks
* @see {InstanceValidator}
*
* @return {Promise<undefined|Errors.ValidationError>}
*/
validate(options) {
return new InstanceValidator(this, options).validate();
}
/**
* This is the same as calling `set` and then calling `save` but it only saves the
* exact values passed to it, making it more atomic and safer.
*
* @see {Instance#set}
* @see {Instance#save}
* @param {Object} updates See `set`
* @param {Object} options See `save`
*
* @return {Promise<this>}
* @alias updateAttributes
*/
update(values, options) {
var changedBefore = this.changed() || []
, sideEffects
, fields
, setOptions;
options = options || {};
if (Array.isArray(options)) options = {fields: options};
options = Utils.cloneDeep(options);
setOptions = Utils.cloneDeep(options);
setOptions.attributes = options.fields;
this.set(values, setOptions);
// Now we need to figure out which fields were actually affected by the setter.
sideEffects = _.without.apply(this, [this.changed() || []].concat(changedBefore));
fields = _.union(Object.keys(values), sideEffects);
if (!options.fields) {
options.fields = _.intersection(fields, this.changed());
options.defaultFields = options.fields;
}
return this.save(options);
}
/**
* Destroy the row corresponding to this instance. Depending on your setting for paranoid, the row will either be completely deleted, or have its deletedAt timestamp set to the current time.
*
* @param {Object} [options={}]
* @param {Boolean} [options.force=false] If set to true, paranoid models will actually be deleted
* @param {Function} [options.logging=false] A function that gets executed while running the query to log the sql.
* @param {Transaction} [options.transaction]
* @param {String} [options.searchPath=DEFAULT] An optional parameter to specify the schema search_path (Postgres only)
*
* @return {Promise<undefined>}
*/
destroy(options) {
options = Utils._.extend({
hooks: true,
force: false
}, options);
return Promise.bind(this).then(function() {
// Run before hook
if (options.hooks) {
return this.constructor.runHooks('beforeDestroy', this, options);
}
}).then(function() {
var where = this.where();
if (this.constructor._timestampAttributes.deletedAt && options.force === false) {
var attribute = this.constructor.rawAttributes[this.constructor._timestampAttributes.deletedAt]
, field = attribute.field || this.constructor._timestampAttributes.deletedAt
, values = {};
values[field] = new Date();
where[field] = attribute.hasOwnProperty('defaultValue') ? attribute.defaultValue : null;
this.setDataValue(field, values[field]);
return this.sequelize.getQueryInterface().update(this, this.constructor.getTableName(options), values, where, _.defaults({ hooks: false }, options));
} else {
return this.sequelize.getQueryInterface().delete(this, this.constructor.getTableName(options), where, _.assign({ type: QueryTypes.DELETE, limit: null }, options));
}
}).tap(function() {
// Run after hook
if (options.hooks) {
return this.constructor.runHooks('afterDestroy', this, options);
}
}).then(function(result) {
return result;
});
}
/**
* Restore the row corresponding to this instance. Only available for paranoid models.
*
* @param {Object} [options={}]
* @param {Function} [options.logging=false] A function that gets executed while running the query to log the sql.
* @param {Transaction} [options.transaction]
*
* @return {Promise<undefined>}
*/
restore(options) {
if (!this.constructor._timestampAttributes.deletedAt) throw new Error('Model is not paranoid');
options = Utils._.extend({
hooks: true,
force: false
}, options);
return Promise.bind(this).then(function() {
// Run before hook
if (options.hooks) {
return this.constructor.runHooks('beforeRestore', this, options);
}
}).then(function() {
var deletedAtCol = this.constructor._timestampAttributes.deletedAt
, deletedAtAttribute = this.constructor.rawAttributes[deletedAtCol]
, deletedAtDefaultValue = deletedAtAttribute.hasOwnProperty('defaultValue') ? deletedAtAttribute.defaultValue : null;
this.setDataValue(deletedAtCol, deletedAtDefaultValue);
return this.save(_.extend({}, options, {hooks : false, omitNull : false}));
}).tap(function() {
// Run after hook
if (options.hooks) {
return this.constructor.runHooks('afterRestore', this, options);
}
});
}
/**
* Increment the value of one or more columns. This is done in the database, which means it does not use the values currently stored on the Instance. The increment is done using a
* ```sql
* SET column = column + X
* ```
* query. To get the correct value after an increment into the Instance you should do a reload.
*
*```js
* instance.increment('number') // increment number by 1
* instance.increment(['number', 'count'], { by: 2 }) // increment number and count by 2
* instance.increment({ answer: 42, tries: 1}, { by: 2 }) // increment answer by 42, and tries by 1.
* // `by` is ignored, since each column has its own value
* ```
*
* @see {Instance#reload}
* @param {String|Array|Object} fields If a string is provided, that column is incremented by the value of `by` given in options. If an array is provided, the same is true for each column. If and object is provided, each column is incremented by the value given.
* @param {Object} [options]
* @param {Integer} [options.by=1] The number to increment by
* @param {Function} [options.logging=false] A function that gets executed while running the query to log the sql.
* @param {Transaction} [options.transaction]
* @param {String} [options.searchPath=DEFAULT] An optional parameter to specify the schema search_path (Postgres only)
*
* @return {Promise<this>}
*/
increment(fields, options) {
var identifier = this.where()
, updatedAtAttr = this.constructor._timestampAttributes.updatedAt
, values = {}
, where;
options = _.defaults({}, options, {
by: 1,
attributes: {},
where: {}
});
where = _.extend({}, options.where, identifier);
if (Utils._.isString(fields)) {
values[fields] = options.by;
} else if (Utils._.isArray(fields)) {
Utils._.each(fields, function(field) {
values[field] = options.by;
});
} else { // Assume fields is key-value pairs
values = fields;
}
if (updatedAtAttr && !values[updatedAtAttr]) {
options.attributes[updatedAtAttr] = this.constructor.$getDefaultTimestamp(updatedAtAttr) || Utils.now(this.sequelize.options.dialect);
}
Object.keys(values).forEach(function(attr) {
// Field name mapping
if (this.constructor.rawAttributes[attr] && this.constructor.rawAttributes[attr].field && this.constructor.rawAttributes[attr].field !== attr) {
values[this.constructor.rawAttributes[attr].field] = values[attr];
delete values[attr];
}
}, this);
return this.sequelize.getQueryInterface().increment(this, this.constructor.getTableName(options), values, where, options).return(this);
}
/**
* Decrement the value of one or more columns. This is done in the database, which means it does not use the values currently stored on the Instance. The decrement is done using a
* ```sql
* SET column = column - X
* ```
* query. To get the correct value after an decrement into the Instance you should do a reload.
*
* ```js
* instance.decrement('number') // decrement number by 1
* instance.decrement(['number', 'count'], { by: 2 }) // decrement number and count by 2
* instance.decrement({ answer: 42, tries: 1}, { by: 2 }) // decrement answer by 42, and tries by 1.
* // `by` is ignored, since each column has its own value
* ```
*
* @see {Instance#reload}
* @param {String|Array|Object} fields If a string is provided, that column is decremented by the value of `by` given in options. If an array is provided, the same is true for each column. If and object is provided, each column is decremented by the value given
* @param {Object} [options]
* @param {Integer} [options.by=1] The number to decrement by
* @param {Function} [options.logging=false] A function that gets executed while running the query to log the sql.
* @param {Transaction} [options.transaction]
* @param {String} [options.searchPath=DEFAULT] An optional parameter to specify the schema search_path (Postgres only)
*
* @return {Promise}
*/
decrement(fields, options) {
options = _.defaults({}, options, {
by: 1
});
if (!Utils._.isString(fields) && !Utils._.isArray(fields)) { // Assume fields is key-value pairs
Utils._.each(fields, function(value, field) {
fields[field] = -value;
});
}
options.by = 0 - options.by;
return this.increment(fields, options);
}
/**
* Check whether this and `other` Instance refer to the same row
*
* @param {Instance} other
* @return {Boolean}
*/
equals(other) {
var self = this;
if (!other || !other.constructor) {
return false;
}
if (!(other instanceof self.constructor)) {
return false;
}
return Utils._.every(this.constructor.primaryKeyAttributes, function(attribute) {
return self.get(attribute, {raw: true}) === other.get(attribute, {raw: true});
});
}
/**
* Check if this is equal to one of `others` by calling equals
*
* @param {Array} others
* @return {Boolean}
*/
equalsOneOf(others) {
var self = this;
return _.some(others, function(other) {
return self.equals(other);
});
}
setValidators(attribute, validators) {
this.validators[attribute] = validators;
}
/**
* Convert the instance to a JSON representation. Proxies to calling `get` with no keys. This means get all values gotten from the DB, and apply all custom getters.
*
* @see {Instance#get}
* @return {object}
*/
toJSON() {
return this.get({
plain: true
});
}
}
// Aliases
Model.prototype.updateAttributes = Model.prototype.update;
Model.$conformOptions = Model._conformOptions;
Model.$validateIncludedElements = Model._validateIncludedElements;
Model.$expandIncludeAll = Model._expandIncludeAll;
Model.findByPrimary = Model.findById;
Model.find = Model.findOne;
Model.findAndCountAll = Model.findAndCount;
Model.findOrInitialize = Model.findOrBuild;
Model.insertOrUpdate = Model.upsert;
Utils._.extend(Model.prototype, associationsMixin);
Utils._.extend(Model, associationsMixin);
Hooks.applyTo(Model);
module.exports = Model;
lib/query-interface.js
......@@ -492,8 +492,8 @@ QueryInterface.prototype.removeIndex = function(tableName, indexNameOrAttributes
QueryInterface.prototype.insert = function(instance, tableName, values, options) {
options = Utils.cloneDeep(options);
options.hasTrigger = instance && instance.Model.options.hasTrigger;
var sql = this.QueryGenerator.insertQuery(tableName, values, instance && instance.Model.rawAttributes, options);
options.hasTrigger = instance && instance.constructor.options.hasTrigger;
var sql = this.QueryGenerator.insertQuery(tableName, values, instance && instance.constructor.rawAttributes, options);
options.type = QueryTypes.INSERT;
options.instance = instance;
......@@ -575,18 +575,18 @@ QueryInterface.prototype.update = function(instance, tableName, values, identifi
var self = this
, restrict = false
, sql = self.QueryGenerator.updateQuery(tableName, values, identifier, options, instance.Model.rawAttributes);
, sql = self.QueryGenerator.updateQuery(tableName, values, identifier, options, instance.constructor.rawAttributes);
options.type = QueryTypes.UPDATE;
// Check for a restrict field
if (!!instance.Model && !!instance.Model.associations) {
var keys = Object.keys(instance.Model.associations)
if (instance.constructor && instance.constructor.associations) {
var keys = Object.keys(instance.constructor.associations)
, length = keys.length;
for (var i = 0; i < length; i++) {
if (instance.Model.associations[keys[i]].options && instance.Model.associations[keys[i]].options.onUpdate && instance.Model.associations[keys[i]].options.onUpdate === 'restrict') {
if (instance.constructor.associations[keys[i]].options && instance.constructor.associations[keys[i]].options.onUpdate && instance.constructor.associations[keys[i]].options.onUpdate === 'restrict') {
restrict = true;
}
}
......@@ -611,18 +611,18 @@ QueryInterface.prototype.bulkUpdate = function(tableName, values, identifier, op
QueryInterface.prototype.delete = function(instance, tableName, identifier, options) {
var self = this
, cascades = []
, sql = self.QueryGenerator.deleteQuery(tableName, identifier, null, instance.Model);
, sql = self.QueryGenerator.deleteQuery(tableName, identifier, null, instance.constructor);
options = _.clone(options) || {};
// Check for a restrict field
if (!!instance.Model && !!instance.Model.associations) {
var keys = Object.keys(instance.Model.associations)
if (!!instance.constructor && !!instance.constructor.associations) {
var keys = Object.keys(instance.constructor.associations)
, length = keys.length
, association;
for (var i = 0; i < length; i++) {
association = instance.Model.associations[keys[i]];
association = instance.constructor.associations[keys[i]];
if (association.options && association.options.onDelete &&
association.options.onDelete.toLowerCase() === 'cascade' &&
association.options.useHooks === true) {
......
lib/sequelize.js
......@@ -14,7 +14,6 @@ var url = require('url')
, sequelizeErrors = require('./errors')
, Promise = require('./promise')
, Hooks = require('./hooks')
, Instance = require('./instance')
, Association = require('./associations/index')
, _ = require('lodash');
......@@ -328,13 +327,6 @@ Sequelize.prototype.Transaction = Sequelize.Transaction = Transaction;
Sequelize.prototype.Deferrable = Sequelize.Deferrable = Deferrable;
/**
* A reference to the sequelize instance class.
* @property Instance
* @see {Instance}
*/
Sequelize.prototype.Instance = Sequelize.Instance = Instance;
/**
* A reference to the sequelize association class.
* @property Association
* @see {Association}
......@@ -623,8 +615,9 @@ Sequelize.prototype.define = function(modelName, attributes, options) { // testh
modelName = options.modelName;
delete options.modelName;
var model = new Model(modelName, attributes, options);
model = model.init(this.modelManager);
var model = class extends Model {};
Object.defineProperty(model, 'name', {value: modelName});
model.init(attributes, options, this.modelManager);
this.modelManager.addModel(model);
this.runHooks('afterDefine', model);
......@@ -743,7 +736,7 @@ Sequelize.prototype.query = function(sql, options) {
options = _.assign({}, this.options.query, options);
if (options.instance && !options.model) {
options.model = options.instance.Model;
options.model = options.instance.constructor;
}
// Map raw fields to model field names using the `fieldAttributeMap`
......
test/integration/associations/belongs-to-many.test.js
......@@ -632,7 +632,7 @@ describe(Support.getTestDialectTeaser('BelongsToMany'), function() {
this.task = task;
return task.createUser({ username: 'foo' });
}).then(function(createdUser) {
expect(createdUser.Model).to.equal(User);
expect(createdUser).to.be.instanceof(User);
expect(createdUser.username).to.equal('foo');
return this.task.getUsers();
}).then(function(_users) {
......@@ -717,7 +717,7 @@ describe(Support.getTestDialectTeaser('BelongsToMany'), function() {
this.task = task;
return task.createUser({ username: 'foo' }, {fields: ['username']});
}).then(function(createdUser) {
expect(createdUser.Model).to.equal(User);
expect(createdUser).to.be.instanceof(User);
expect(createdUser.username).to.equal('foo');
return this.task.getUsers();
}).then(function(_users) {
......
test/integration/associations/belongs-to.test.js
......@@ -586,7 +586,7 @@ describe(Support.getTestDialectTeaser('BelongsTo'), function() {
// the `UPDATE` query generated by `save()` uses `id` in the
// `WHERE` clause
var tableName = user.sequelize.getQueryInterface().QueryGenerator.addSchema(user.Model);
var tableName = user.sequelize.getQueryInterface().QueryGenerator.addSchema(user.constructor);
return expect(
user.sequelize.getQueryInterface().update(user, tableName, {id: 999}, {id: user.id})
).to.eventually.be.rejectedWith(Sequelize.ForeignKeyConstraintError).then(function () {
......@@ -620,7 +620,7 @@ describe(Support.getTestDialectTeaser('BelongsTo'), function() {
// the `UPDATE` query generated by `save()` uses `id` in the
// `WHERE` clause
var tableName = user.sequelize.getQueryInterface().QueryGenerator.addSchema(user.Model);
var tableName = user.sequelize.getQueryInterface().QueryGenerator.addSchema(user.constructor);
return user.sequelize.getQueryInterface().update(user, tableName, {id: 999}, {id: user.id})
.then(function() {
return Task.findAll().then(function(tasks) {
......
test/integration/associations/has-many.test.js
......@@ -1052,7 +1052,7 @@ describe(Support.getTestDialectTeaser('HasMany'), function() {
// the `UPDATE` query generated by `save()` uses `id` in the
// `WHERE` clause
var tableName = user.sequelize.getQueryInterface().QueryGenerator.addSchema(user.Model);
var tableName = user.sequelize.getQueryInterface().QueryGenerator.addSchema(user.constructor);
return user.sequelize.getQueryInterface().update(user, tableName, {id: 999}, {id: user.id});
}).then(function() {
return Task.findAll();
......@@ -1109,7 +1109,7 @@ describe(Support.getTestDialectTeaser('HasMany'), function() {
// the `UPDATE` query generated by `save()` uses `id` in the
// `WHERE` clause
var tableName = user.sequelize.getQueryInterface().QueryGenerator.addSchema(user.Model);
var tableName = user.sequelize.getQueryInterface().QueryGenerator.addSchema(user.constructor);
return user.sequelize.getQueryInterface().update(user, tableName, {id: 999}, {id: user.id})
.catch (self.sequelize.ForeignKeyConstraintError, function() {
// Should fail due to FK violation
......
test/integration/associations/has-one.test.js
......@@ -493,7 +493,7 @@ describe(Support.getTestDialectTeaser('HasOne'), function() {
// the `UPDATE` query generated by `save()` uses `id` in the
// `WHERE` clause
var tableName = user.sequelize.getQueryInterface().QueryGenerator.addSchema(user.Model);
var tableName = user.sequelize.getQueryInterface().QueryGenerator.addSchema(user.constructor);
return user.sequelize.getQueryInterface().update(user, tableName, {id: 999}, {id: user.id}).then(function() {
return Task.findAll().then(function(tasks) {
expect(tasks).to.have.length(1);
......@@ -549,7 +549,7 @@ describe(Support.getTestDialectTeaser('HasOne'), function() {
// the `UPDATE` query generated by `save()` uses `id` in the
// `WHERE` clause
var tableName = user.sequelize.getQueryInterface().QueryGenerator.addSchema(user.Model);
var tableName = user.sequelize.getQueryInterface().QueryGenerator.addSchema(user.constructor);
return expect(
user.sequelize.getQueryInterface().update(user, tableName, {id: 999}, {id: user.id})
).to.eventually.be.rejectedWith(Sequelize.ForeignKeyConstraintError).then(function () {
......
test/integration/associations/scope.test.js
......@@ -199,9 +199,9 @@ describe(Support.getTestDialectTeaser('associations'), function() {
questionComment.getItem()
);
}).spread(function(post, image, question) {
expect(post.Model).to.equal(self.Post);
expect(image.Model).to.equal(self.Image);
expect(question.Model).to.equal(self.Question);
expect(post).to.be.instanceof(self.Post);
expect(image).to.be.instanceof(self.Image);
expect(question).to.be.instanceof(self.Question);
}).then(function() {
return Promise.join(
self.Post.find({
......
test/integration/hooks/hooks.test.js
......@@ -113,12 +113,12 @@ describe(Support.getTestDialectTeaser('Hooks'), function() {
}, {
hooks: {
beforeValidate: function(user, options, fn) {
expect(user).to.be.instanceof(User.Instance);
expect(user).to.be.instanceof(User);
beforeHooked = true;
fn();
},
afterValidate: function(user, options, fn) {
expect(user).to.be.instanceof(User.Instance);
expect(user).to.be.instanceof(User);
afterHooked = true;
fn();
}
......@@ -143,12 +143,12 @@ describe(Support.getTestDialectTeaser('Hooks'), function() {
}, {
hooks: {
beforeCreate: function(user, options, fn) {
expect(user).to.be.instanceof(User.Instance);
expect(user).to.be.instanceof(User);
beforeHooked = true;
fn();
},
afterCreate: function(user, options, fn) {
expect(user).to.be.instanceof(User.Instance);
expect(user).to.be.instanceof(User);
afterHooked = true;
fn();
}
......@@ -173,12 +173,12 @@ describe(Support.getTestDialectTeaser('Hooks'), function() {
}, {
hooks: {
beforeDestroy: function(user, options, fn) {
expect(user).to.be.instanceof(User.Instance);
expect(user).to.be.instanceof(User);
beforeHooked = true;
fn();
},
afterDestroy: function(user, options, fn) {
expect(user).to.be.instanceof(User.Instance);
expect(user).to.be.instanceof(User);
afterHooked = true;
fn();
}
......@@ -205,12 +205,12 @@ describe(Support.getTestDialectTeaser('Hooks'), function() {
}, {
hooks: {
beforeDelete: function(user, options, fn) {
expect(user).to.be.instanceof(User.Instance);
expect(user).to.be.instanceof(User);
beforeHooked = true;
fn();
},
afterDelete: function(user, options, fn) {
expect(user).to.be.instanceof(User.Instance);
expect(user).to.be.instanceof(User);
afterHooked = true;
fn();
}
......@@ -237,12 +237,12 @@ describe(Support.getTestDialectTeaser('Hooks'), function() {
}, {
hooks: {
beforeUpdate: function(user, options, fn) {
expect(user).to.be.instanceof(User.Instance);
expect(user).to.be.instanceof(User);
beforeHooked = true;
fn();
},
afterUpdate: function(user, options, fn) {
expect(user).to.be.instanceof(User.Instance);
expect(user).to.be.instanceof(User);
afterHooked = true;
fn();
}
......
test/integration/instance/values.test.js
......@@ -183,9 +183,9 @@ describe(Support.getTestDialectTeaser('DAO'), function() {
expect(product.tags).to.be.ok;
expect(product.tags.length).to.equal(2);
expect(product.tags[0].Model).to.equal(Tag);
expect(product.tags[0]).to.be.instanceof(Tag);
expect(product.user).to.be.ok;
expect(product.user.Model).to.equal(User);
expect(product.user).to.be.instanceof(User);
});
it('should support basic includes (with raw: true)', function() {
......@@ -227,9 +227,9 @@ describe(Support.getTestDialectTeaser('DAO'), function() {
expect(product.tags).to.be.ok;
expect(product.tags.length).to.equal(2);
expect(product.tags[0].Model).to.equal(Tag);
expect(product.tags[0]).to.be.instanceof(Tag);
expect(product.user).to.be.ok;
expect(product.user.Model).to.equal(User);
expect(product.user).to.be.instanceof(User);
});
});
});
......@@ -350,8 +350,8 @@ describe(Support.getTestDialectTeaser('DAO'), function() {
}
}, {raw: true});
expect(product.get('user', {plain: true}).$Model).not.to.be.ok;
expect(product.get({plain: true}).user.$Model).not.to.be.ok;
expect(product.get('user', {plain: true})).not.to.be.instanceof(User);
expect(product.get({plain: true}).user).not.to.be.instanceof(User);
});
});
......
test/integration/model.test.js
......@@ -623,9 +623,9 @@ describe(Support.getTestDialectTeaser('Model'), function() {
expect(product.Tags).to.be.ok;
expect(product.Tags.length).to.equal(2);
expect(product.Tags[0].Model).to.equal(Tag);
expect(product.Tags[0]).to.be.instanceof(Tag);
expect(product.User).to.be.ok;
expect(product.User.Model).to.equal(User);
expect(product.User).to.be.instanceof(User);
});
it('should support includes with aliases', function() {
......@@ -674,10 +674,10 @@ describe(Support.getTestDialectTeaser('Model'), function() {
expect(product.categories).to.be.ok;
expect(product.categories.length).to.equal(4);
expect(product.categories[0].Model).to.equal(Tag);
expect(product.categories[0]).to.be.instanceof(Tag);
expect(product.followers).to.be.ok;
expect(product.followers.length).to.equal(2);
expect(product.followers[0].Model).to.equal(User);
expect(product.followers[0]).to.be.instanceof(User);
});
});
});
......
test/integration/model/find.test.js
......@@ -899,21 +899,21 @@ describe(Support.getTestDialectTeaser('Model'), function() {
it('should return a DAO when queryOptions are not set', function() {
var self = this;
return this.User.findOne({ where: { username: 'barfooz'}}).then(function(user) {
expect(user).to.be.instanceOf(self.User.Instance);
expect(user).to.be.instanceOf(self.User);
});
});
it('should return a DAO when raw is false', function() {
var self = this;
return this.User.findOne({ where: { username: 'barfooz'}, raw: false }).then(function(user) {
expect(user).to.be.instanceOf(self.User.Instance);
expect(user).to.be.instanceOf(self.User);
});
});
it('should return raw data when raw is true', function() {
var self = this;
return this.User.findOne({ where: { username: 'barfooz'}, raw: true }).then(function(user) {
expect(user).to.not.be.instanceOf(self.User.Instance);
expect(user).to.not.be.instanceOf(self.User);
expect(user).to.be.instanceOf(Object);
});
});
......
test/integration/model/findAll.test.js
......@@ -737,7 +737,7 @@ describe(Support.getTestDialectTeaser('Model'), function() {
var self = this;
return this.User.findAll({ where: { username: 'barfooz'}}).then(function(users) {
users.forEach(function(user) {
expect(user).to.be.instanceOf(self.User.Instance);
expect(user).to.be.instanceOf(self.User);
});
});
});
......@@ -746,7 +746,7 @@ describe(Support.getTestDialectTeaser('Model'), function() {
var self = this;
return this.User.findAll({ where: { username: 'barfooz'}, raw: false }).then(function(users) {
users.forEach(function(user) {
expect(user).to.be.instanceOf(self.User.Instance);
expect(user).to.be.instanceOf(self.User);
});
});
});
......@@ -755,7 +755,7 @@ describe(Support.getTestDialectTeaser('Model'), function() {
var self = this;
return this.User.findAll({ where: { username: 'barfooz'}, raw: true }).then(function(users) {
users.forEach(function(user) {
expect(user).to.not.be.instanceOf(self.User.Instance);
expect(user).to.not.be.instanceOf(self.User);
expect(users[0]).to.be.instanceOf(Object);
});
});
......
test/integration/sequelize.test.js
......@@ -393,7 +393,7 @@ describe(Support.getTestDialectTeaser('Sequelize'), function() {
model: this.User
});
}).then(function(users) {
expect(users[0].Model).to.equal(this.User);
expect(users[0]).to.be.instanceof(this.User);
});
});
......
test/supportShim.js
......@@ -11,8 +11,8 @@ var QueryInterface = require(__dirname + '/../lib/query-interface')
module.exports = function(Sequelize) {
// Shim all Sequelize methods
shimAll(Sequelize.prototype);
shimAll(Sequelize.Model);
shimAll(Sequelize.Model.prototype);
shimAll(Sequelize.Instance.prototype);
shimAll(QueryInterface.prototype);
// Shim Model.prototype to then shim getter/setter methods
......@@ -23,7 +23,7 @@ module.exports = function(Sequelize) {
association = original.apply(this, arguments);
_.forIn(association.accessors, function(accessor) {
shim(model.Instance.prototype, accessor, model.Instance.prototype[accessor].length);
shim(model.prototype, accessor, model.prototype[accessor].length);
});
return association;
......
test/unit/associations/belongs-to-many.test.js
......@@ -429,10 +429,10 @@ describe(Support.getTestDialectTeaser('belongsToMany'), function() {
});
it('should work for belongsTo associations defined before belongsToMany', function () {
expect(this.UserProjects.Instance.prototype.getUser).to.be.ok;
expect(this.UserProjects.prototype.getUser).to.be.ok;
});
it('should work for belongsTo associations defined after belongsToMany', function () {
expect(this.UserProjects.Instance.prototype.getProject).to.be.ok;
expect(this.UserProjects.prototype.getProject).to.be.ok;
});
});
......@@ -484,22 +484,21 @@ describe(Support.getTestDialectTeaser('belongsToMany'), function() {
it('works with singular and plural name for self-associations', function () {
// Models taken from https://github.com/sequelize/sequelize/issues/3796
var Service = current.define('service', {})
, Instance = Service.Instance;
var Service = current.define('service', {});
Service.belongsToMany(Service, {through: 'Supplements', as: 'supplements'});
Service.belongsToMany(Service, {through: 'Supplements', as: {singular: 'supplemented', plural: 'supplemented'}});
expect(Instance.prototype).to.have.property('getSupplements').which.is.a.function;
expect(Service.prototype).to.have.property('getSupplements').which.is.a.function;
expect(Instance.prototype).to.have.property('addSupplement').which.is.a.function;
expect(Instance.prototype).to.have.property('addSupplements').which.is.a.function;
expect(Service.prototype).to.have.property('addSupplement').which.is.a.function;
expect(Service.prototype).to.have.property('addSupplements').which.is.a.function;
expect(Instance.prototype).to.have.property('getSupplemented').which.is.a.function;
expect(Instance.prototype).not.to.have.property('getSupplementeds').which.is.a.function;
expect(Service.prototype).to.have.property('getSupplemented').which.is.a.function;
expect(Service.prototype).not.to.have.property('getSupplementeds').which.is.a.function;
expect(Instance.prototype).to.have.property('addSupplemented').which.is.a.function;
expect(Instance.prototype).not.to.have.property('addSupplementeds').which.is.a.function;
expect(Service.prototype).to.have.property('addSupplemented').which.is.a.function;
expect(Service.prototype).not.to.have.property('addSupplementeds').which.is.a.function;
});
});
......
test/unit/model/findone.test.js
......@@ -12,14 +12,14 @@ var chai = require('chai')
describe(Support.getTestDialectTeaser('Model'), function() {
describe('method findOne', function () {
before(function () {
this.oldFindAll = current.Model.prototype.findAll;
this.oldFindAll = current.Model.findAll;
});
after(function () {
current.Model.prototype.findAll = this.oldFindAll;
current.Model.findAll = this.oldFindAll;
});
beforeEach(function () {
this.stub = current.Model.prototype.findAll = sinon.stub().returns(Promise.resolve());
this.stub = current.Model.findAll = sinon.stub().returns(Promise.resolve());
});
describe('should not add limit when querying on a primary key', function () {
......
test/unit/model/scope.test.js
......@@ -298,7 +298,7 @@ describe(Support.getTestDialectTeaser('Model'), function() {
limit: 9
};
current.Model.prototype.$injectScope.call({
current.Model.$injectScope.call({
$scope: scope
}, options);
......@@ -322,7 +322,7 @@ describe(Support.getTestDialectTeaser('Model'), function() {
var options = {};
current.Model.prototype.$injectScope.call({
current.Model.$injectScope.call({
$scope: scope
}, options);
......@@ -339,7 +339,7 @@ describe(Support.getTestDialectTeaser('Model'), function() {
include: [{ model: Project, where: { something: true }}]
};
current.Model.prototype.$injectScope.call({
current.Model.$injectScope.call({
$scope: scope
}, options);
......@@ -356,7 +356,7 @@ describe(Support.getTestDialectTeaser('Model'), function() {
include: [{model: User, as: 'otherUser'}]
};
current.Model.prototype.$injectScope.call({
current.Model.$injectScope.call({
$scope: scope
}, options);
......@@ -378,7 +378,7 @@ describe(Support.getTestDialectTeaser('Model'), function() {
]
};
current.Model.prototype.$injectScope.call({
current.Model.$injectScope.call({
$scope: scope
}, options);
......@@ -401,7 +401,7 @@ describe(Support.getTestDialectTeaser('Model'), function() {
]
};
current.Model.prototype.$injectScope.call({
current.Model.$injectScope.call({
$scope: scope
}, options);
......@@ -424,7 +424,7 @@ describe(Support.getTestDialectTeaser('Model'), function() {
]
};
current.Model.prototype.$injectScope.call({
current.Model.$injectScope.call({
$scope: scope
}, options);
......
Markdown is supported
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!