primer cambio
This commit is contained in:
beseira13
566
node_modules/sequelize/lib/associations/belongs-to-many.js
generated
vendored
Normal file
566
node_modules/sequelize/lib/associations/belongs-to-many.js
generated
vendored
Normal file
@@ -0,0 +1,566 @@
|
||||
"use strict";
|
||||
var __defProp = Object.defineProperty;
|
||||
var __defProps = Object.defineProperties;
|
||||
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
|
||||
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
|
||||
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
||||
var __propIsEnum = Object.prototype.propertyIsEnumerable;
|
||||
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
||||
var __spreadValues = (a, b) => {
|
||||
for (var prop in b || (b = {}))
|
||||
if (__hasOwnProp.call(b, prop))
|
||||
__defNormalProp(a, prop, b[prop]);
|
||||
if (__getOwnPropSymbols)
|
||||
for (var prop of __getOwnPropSymbols(b)) {
|
||||
if (__propIsEnum.call(b, prop))
|
||||
__defNormalProp(a, prop, b[prop]);
|
||||
}
|
||||
return a;
|
||||
};
|
||||
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
|
||||
const Utils = require("./../utils");
|
||||
const Helpers = require("./helpers");
|
||||
const _ = require("lodash");
|
||||
const Association = require("./base");
|
||||
const BelongsTo = require("./belongs-to");
|
||||
const HasMany = require("./has-many");
|
||||
const HasOne = require("./has-one");
|
||||
const AssociationError = require("../errors").AssociationError;
|
||||
const EmptyResultError = require("../errors").EmptyResultError;
|
||||
const Op = require("../operators");
|
||||
class BelongsToMany extends Association {
|
||||
constructor(source, target, options) {
|
||||
super(source, target, options);
|
||||
if (this.options.through === void 0 || this.options.through === true || this.options.through === null) {
|
||||
throw new AssociationError(`${source.name}.belongsToMany(${target.name}) requires through option, pass either a string or a model`);
|
||||
}
|
||||
if (!this.options.through.model) {
|
||||
this.options.through = {
|
||||
model: options.through
|
||||
};
|
||||
}
|
||||
this.associationType = "BelongsToMany";
|
||||
this.targetAssociation = null;
|
||||
this.sequelize = source.sequelize;
|
||||
this.through = __spreadValues({}, this.options.through);
|
||||
this.isMultiAssociation = true;
|
||||
this.doubleLinked = false;
|
||||
if (!this.as && this.isSelfAssociation) {
|
||||
throw new AssociationError("'as' must be defined for many-to-many self-associations");
|
||||
}
|
||||
if (this.as) {
|
||||
this.isAliased = true;
|
||||
if (_.isPlainObject(this.as)) {
|
||||
this.options.name = this.as;
|
||||
this.as = this.as.plural;
|
||||
} else {
|
||||
this.options.name = {
|
||||
plural: this.as,
|
||||
singular: Utils.singularize(this.as)
|
||||
};
|
||||
}
|
||||
} else {
|
||||
this.as = this.target.options.name.plural;
|
||||
this.options.name = this.target.options.name;
|
||||
}
|
||||
this.combinedTableName = Utils.combineTableNames(this.source.tableName, this.isSelfAssociation ? this.as || this.target.tableName : this.target.tableName);
|
||||
if (this.isSelfAssociation) {
|
||||
this.targetAssociation = this;
|
||||
}
|
||||
_.each(this.target.associations, (association) => {
|
||||
if (association.associationType !== "BelongsToMany")
|
||||
return;
|
||||
if (association.target !== this.source)
|
||||
return;
|
||||
if (this.options.through.model === association.options.through.model) {
|
||||
this.paired = association;
|
||||
association.paired = this;
|
||||
}
|
||||
});
|
||||
this.sourceKey = this.options.sourceKey || this.source.primaryKeyAttribute;
|
||||
this.sourceKeyField = this.source.rawAttributes[this.sourceKey].field || this.sourceKey;
|
||||
if (this.options.targetKey) {
|
||||
this.targetKey = this.options.targetKey;
|
||||
this.targetKeyField = this.target.rawAttributes[this.targetKey].field || this.targetKey;
|
||||
} else {
|
||||
this.targetKeyDefault = true;
|
||||
this.targetKey = this.target.primaryKeyAttribute;
|
||||
this.targetKeyField = this.target.rawAttributes[this.targetKey].field || this.targetKey;
|
||||
}
|
||||
this._createForeignAndOtherKeys();
|
||||
if (typeof this.through.model === "string") {
|
||||
if (!this.sequelize.isDefined(this.through.model)) {
|
||||
this.through.model = this.sequelize.define(this.through.model, {}, Object.assign(this.options, {
|
||||
tableName: this.through.model,
|
||||
indexes: [],
|
||||
paranoid: this.through.paranoid ? this.through.paranoid : false,
|
||||
validate: {}
|
||||
}));
|
||||
} else {
|
||||
this.through.model = this.sequelize.model(this.through.model);
|
||||
}
|
||||
}
|
||||
Object.assign(this.options, _.pick(this.through.model.options, [
|
||||
"timestamps",
|
||||
"createdAt",
|
||||
"updatedAt",
|
||||
"deletedAt",
|
||||
"paranoid"
|
||||
]));
|
||||
if (this.paired) {
|
||||
let needInjectPaired = false;
|
||||
if (this.targetKeyDefault) {
|
||||
this.targetKey = this.paired.sourceKey;
|
||||
this.targetKeyField = this.paired.sourceKeyField;
|
||||
this._createForeignAndOtherKeys();
|
||||
}
|
||||
if (this.paired.targetKeyDefault) {
|
||||
if (this.paired.targetKey !== this.sourceKey) {
|
||||
delete this.through.model.rawAttributes[this.paired.otherKey];
|
||||
this.paired.targetKey = this.sourceKey;
|
||||
this.paired.targetKeyField = this.sourceKeyField;
|
||||
this.paired._createForeignAndOtherKeys();
|
||||
needInjectPaired = true;
|
||||
}
|
||||
}
|
||||
if (this.otherKeyDefault) {
|
||||
this.otherKey = this.paired.foreignKey;
|
||||
}
|
||||
if (this.paired.otherKeyDefault) {
|
||||
if (this.paired.otherKey !== this.foreignKey) {
|
||||
delete this.through.model.rawAttributes[this.paired.otherKey];
|
||||
this.paired.otherKey = this.foreignKey;
|
||||
needInjectPaired = true;
|
||||
}
|
||||
}
|
||||
if (needInjectPaired) {
|
||||
this.paired._injectAttributes();
|
||||
}
|
||||
}
|
||||
if (this.through) {
|
||||
this.throughModel = this.through.model;
|
||||
}
|
||||
this.options.tableName = this.combinedName = this.through.model === Object(this.through.model) ? this.through.model.tableName : this.through.model;
|
||||
this.associationAccessor = this.as;
|
||||
const plural = _.upperFirst(this.options.name.plural);
|
||||
const singular = _.upperFirst(this.options.name.singular);
|
||||
this.accessors = {
|
||||
get: `get${plural}`,
|
||||
set: `set${plural}`,
|
||||
addMultiple: `add${plural}`,
|
||||
add: `add${singular}`,
|
||||
create: `create${singular}`,
|
||||
remove: `remove${singular}`,
|
||||
removeMultiple: `remove${plural}`,
|
||||
hasSingle: `has${singular}`,
|
||||
hasAll: `has${plural}`,
|
||||
count: `count${plural}`
|
||||
};
|
||||
}
|
||||
_createForeignAndOtherKeys() {
|
||||
if (_.isObject(this.options.foreignKey)) {
|
||||
this.foreignKeyAttribute = this.options.foreignKey;
|
||||
this.foreignKey = this.foreignKeyAttribute.name || this.foreignKeyAttribute.fieldName;
|
||||
} else {
|
||||
this.foreignKeyAttribute = {};
|
||||
this.foreignKey = this.options.foreignKey || Utils.camelize([
|
||||
this.source.options.name.singular,
|
||||
this.sourceKey
|
||||
].join("_"));
|
||||
}
|
||||
if (_.isObject(this.options.otherKey)) {
|
||||
this.otherKeyAttribute = this.options.otherKey;
|
||||
this.otherKey = this.otherKeyAttribute.name || this.otherKeyAttribute.fieldName;
|
||||
} else {
|
||||
if (!this.options.otherKey) {
|
||||
this.otherKeyDefault = true;
|
||||
}
|
||||
this.otherKeyAttribute = {};
|
||||
this.otherKey = this.options.otherKey || Utils.camelize([
|
||||
this.isSelfAssociation ? Utils.singularize(this.as) : this.target.options.name.singular,
|
||||
this.targetKey
|
||||
].join("_"));
|
||||
}
|
||||
}
|
||||
_injectAttributes() {
|
||||
this.identifier = this.foreignKey;
|
||||
this.foreignIdentifier = this.otherKey;
|
||||
_.each(this.through.model.rawAttributes, (attribute, attributeName) => {
|
||||
if (attribute.primaryKey === true && attribute._autoGenerated === true) {
|
||||
if ([this.foreignKey, this.otherKey].includes(attributeName)) {
|
||||
attribute.primaryKey = false;
|
||||
} else {
|
||||
delete this.through.model.rawAttributes[attributeName];
|
||||
}
|
||||
this.primaryKeyDeleted = true;
|
||||
}
|
||||
});
|
||||
const sourceKey = this.source.rawAttributes[this.sourceKey];
|
||||
const sourceKeyType = sourceKey.type;
|
||||
const sourceKeyField = this.sourceKeyField;
|
||||
const targetKey = this.target.rawAttributes[this.targetKey];
|
||||
const targetKeyType = targetKey.type;
|
||||
const targetKeyField = this.targetKeyField;
|
||||
const sourceAttribute = __spreadValues({ type: sourceKeyType }, this.foreignKeyAttribute);
|
||||
const targetAttribute = __spreadValues({ type: targetKeyType }, this.otherKeyAttribute);
|
||||
if (this.primaryKeyDeleted === true) {
|
||||
targetAttribute.primaryKey = sourceAttribute.primaryKey = true;
|
||||
} else if (this.through.unique !== false) {
|
||||
let uniqueKey;
|
||||
if (typeof this.options.uniqueKey === "string" && this.options.uniqueKey !== "") {
|
||||
uniqueKey = this.options.uniqueKey;
|
||||
} else {
|
||||
uniqueKey = [this.through.model.tableName, this.foreignKey, this.otherKey, "unique"].join("_");
|
||||
}
|
||||
targetAttribute.unique = sourceAttribute.unique = uniqueKey;
|
||||
}
|
||||
if (!this.through.model.rawAttributes[this.foreignKey]) {
|
||||
this.through.model.rawAttributes[this.foreignKey] = {
|
||||
_autoGenerated: true
|
||||
};
|
||||
}
|
||||
if (!this.through.model.rawAttributes[this.otherKey]) {
|
||||
this.through.model.rawAttributes[this.otherKey] = {
|
||||
_autoGenerated: true
|
||||
};
|
||||
}
|
||||
if (this.options.constraints !== false) {
|
||||
sourceAttribute.references = {
|
||||
model: this.source.getTableName(),
|
||||
key: sourceKeyField
|
||||
};
|
||||
sourceAttribute.onDelete = this.options.onDelete || this.through.model.rawAttributes[this.foreignKey].onDelete;
|
||||
sourceAttribute.onUpdate = this.options.onUpdate || this.through.model.rawAttributes[this.foreignKey].onUpdate;
|
||||
if (!sourceAttribute.onDelete)
|
||||
sourceAttribute.onDelete = "CASCADE";
|
||||
if (!sourceAttribute.onUpdate)
|
||||
sourceAttribute.onUpdate = "CASCADE";
|
||||
targetAttribute.references = {
|
||||
model: this.target.getTableName(),
|
||||
key: targetKeyField
|
||||
};
|
||||
targetAttribute.onDelete = this.through.model.rawAttributes[this.otherKey].onDelete || this.options.onDelete;
|
||||
targetAttribute.onUpdate = this.through.model.rawAttributes[this.otherKey].onUpdate || this.options.onUpdate;
|
||||
if (!targetAttribute.onDelete)
|
||||
targetAttribute.onDelete = "CASCADE";
|
||||
if (!targetAttribute.onUpdate)
|
||||
targetAttribute.onUpdate = "CASCADE";
|
||||
}
|
||||
Object.assign(this.through.model.rawAttributes[this.foreignKey], sourceAttribute);
|
||||
Object.assign(this.through.model.rawAttributes[this.otherKey], targetAttribute);
|
||||
this.through.model.refreshAttributes();
|
||||
this.identifierField = this.through.model.rawAttributes[this.foreignKey].field || this.foreignKey;
|
||||
this.foreignIdentifierField = this.through.model.rawAttributes[this.otherKey].field || this.otherKey;
|
||||
if (this.options.sequelize.options.dialect === "db2" && this.source.rawAttributes[this.sourceKey].primaryKey !== true) {
|
||||
this.source.rawAttributes[this.sourceKey].unique = true;
|
||||
}
|
||||
if (this.paired && !this.paired.foreignIdentifierField) {
|
||||
this.paired.foreignIdentifierField = this.through.model.rawAttributes[this.paired.otherKey].field || this.paired.otherKey;
|
||||
}
|
||||
this.toSource = new BelongsTo(this.through.model, this.source, {
|
||||
foreignKey: this.foreignKey
|
||||
});
|
||||
this.manyFromSource = new HasMany(this.source, this.through.model, {
|
||||
foreignKey: this.foreignKey
|
||||
});
|
||||
this.oneFromSource = new HasOne(this.source, this.through.model, {
|
||||
foreignKey: this.foreignKey,
|
||||
sourceKey: this.sourceKey,
|
||||
as: this.through.model.name
|
||||
});
|
||||
this.toTarget = new BelongsTo(this.through.model, this.target, {
|
||||
foreignKey: this.otherKey
|
||||
});
|
||||
this.manyFromTarget = new HasMany(this.target, this.through.model, {
|
||||
foreignKey: this.otherKey
|
||||
});
|
||||
this.oneFromTarget = new HasOne(this.target, this.through.model, {
|
||||
foreignKey: this.otherKey,
|
||||
sourceKey: this.targetKey,
|
||||
as: this.through.model.name
|
||||
});
|
||||
if (this.paired && this.paired.otherKeyDefault) {
|
||||
this.paired.toTarget = new BelongsTo(this.paired.through.model, this.paired.target, {
|
||||
foreignKey: this.paired.otherKey
|
||||
});
|
||||
this.paired.oneFromTarget = new HasOne(this.paired.target, this.paired.through.model, {
|
||||
foreignKey: this.paired.otherKey,
|
||||
sourceKey: this.paired.targetKey,
|
||||
as: this.paired.through.model.name
|
||||
});
|
||||
}
|
||||
Helpers.checkNamingCollision(this);
|
||||
return this;
|
||||
}
|
||||
mixin(obj) {
|
||||
const methods = ["get", "count", "hasSingle", "hasAll", "set", "add", "addMultiple", "remove", "removeMultiple", "create"];
|
||||
const aliases = {
|
||||
hasSingle: "has",
|
||||
hasAll: "has",
|
||||
addMultiple: "add",
|
||||
removeMultiple: "remove"
|
||||
};
|
||||
Helpers.mixinMethods(this, obj, methods, aliases);
|
||||
}
|
||||
async get(instance, options) {
|
||||
options = Utils.cloneDeep(options) || {};
|
||||
const through = this.through;
|
||||
let scopeWhere;
|
||||
let throughWhere;
|
||||
if (this.scope) {
|
||||
scopeWhere = __spreadValues({}, this.scope);
|
||||
}
|
||||
options.where = {
|
||||
[Op.and]: [
|
||||
scopeWhere,
|
||||
options.where
|
||||
]
|
||||
};
|
||||
if (Object(through.model) === through.model) {
|
||||
throughWhere = {};
|
||||
throughWhere[this.foreignKey] = instance.get(this.sourceKey);
|
||||
if (through.scope) {
|
||||
Object.assign(throughWhere, through.scope);
|
||||
}
|
||||
if (options.through && options.through.where) {
|
||||
throughWhere = {
|
||||
[Op.and]: [throughWhere, options.through.where]
|
||||
};
|
||||
}
|
||||
options.include = options.include || [];
|
||||
options.include.push({
|
||||
association: this.oneFromTarget,
|
||||
attributes: options.joinTableAttributes,
|
||||
required: true,
|
||||
paranoid: _.get(options.through, "paranoid", true),
|
||||
where: throughWhere
|
||||
});
|
||||
}
|
||||
let model = this.target;
|
||||
if (Object.prototype.hasOwnProperty.call(options, "scope")) {
|
||||
if (!options.scope) {
|
||||
model = model.unscoped();
|
||||
} else {
|
||||
model = model.scope(options.scope);
|
||||
}
|
||||
}
|
||||
if (Object.prototype.hasOwnProperty.call(options, "schema")) {
|
||||
model = model.schema(options.schema, options.schemaDelimiter);
|
||||
}
|
||||
return model.findAll(options);
|
||||
}
|
||||
async count(instance, options) {
|
||||
const sequelize = this.target.sequelize;
|
||||
options = Utils.cloneDeep(options);
|
||||
options.attributes = [
|
||||
[sequelize.fn("COUNT", sequelize.col([this.target.name, this.targetKeyField].join("."))), "count"]
|
||||
];
|
||||
options.joinTableAttributes = [];
|
||||
options.raw = true;
|
||||
options.plain = true;
|
||||
const result = await this.get(instance, options);
|
||||
return parseInt(result.count, 10);
|
||||
}
|
||||
async has(sourceInstance, instances, options) {
|
||||
if (!Array.isArray(instances)) {
|
||||
instances = [instances];
|
||||
}
|
||||
options = __spreadProps(__spreadValues({
|
||||
raw: true
|
||||
}, options), {
|
||||
scope: false,
|
||||
attributes: [this.targetKey],
|
||||
joinTableAttributes: []
|
||||
});
|
||||
const instancePrimaryKeys = instances.map((instance) => {
|
||||
if (instance instanceof this.target) {
|
||||
return instance.where();
|
||||
}
|
||||
return {
|
||||
[this.targetKey]: instance
|
||||
};
|
||||
});
|
||||
options.where = {
|
||||
[Op.and]: [
|
||||
{ [Op.or]: instancePrimaryKeys },
|
||||
options.where
|
||||
]
|
||||
};
|
||||
const associatedObjects = await this.get(sourceInstance, options);
|
||||
return _.differenceWith(instancePrimaryKeys, associatedObjects, (a, b) => _.isEqual(a[this.targetKey], b[this.targetKey])).length === 0;
|
||||
}
|
||||
async set(sourceInstance, newAssociatedObjects, options) {
|
||||
options = options || {};
|
||||
const sourceKey = this.sourceKey;
|
||||
const targetKey = this.targetKey;
|
||||
const identifier = this.identifier;
|
||||
const foreignIdentifier = this.foreignIdentifier;
|
||||
if (newAssociatedObjects === null) {
|
||||
newAssociatedObjects = [];
|
||||
} else {
|
||||
newAssociatedObjects = this.toInstanceArray(newAssociatedObjects);
|
||||
}
|
||||
const where = __spreadValues({
|
||||
[identifier]: sourceInstance.get(sourceKey)
|
||||
}, this.through.scope);
|
||||
const updateAssociations = (currentRows) => {
|
||||
const obsoleteAssociations = [];
|
||||
const promises = [];
|
||||
const defaultAttributes = options.through || {};
|
||||
const unassociatedObjects = newAssociatedObjects.filter((obj) => !currentRows.some((currentRow) => currentRow[foreignIdentifier] === obj.get(targetKey)));
|
||||
for (const currentRow of currentRows) {
|
||||
const newObj = newAssociatedObjects.find((obj) => currentRow[foreignIdentifier] === obj.get(targetKey));
|
||||
if (!newObj) {
|
||||
obsoleteAssociations.push(currentRow);
|
||||
} else {
|
||||
let throughAttributes = newObj[this.through.model.name];
|
||||
if (throughAttributes instanceof this.through.model) {
|
||||
throughAttributes = {};
|
||||
}
|
||||
const attributes = __spreadValues(__spreadValues({}, defaultAttributes), throughAttributes);
|
||||
if (Object.keys(attributes).length) {
|
||||
promises.push(this.through.model.update(attributes, Object.assign(options, {
|
||||
where: {
|
||||
[identifier]: sourceInstance.get(sourceKey),
|
||||
[foreignIdentifier]: newObj.get(targetKey)
|
||||
}
|
||||
})));
|
||||
}
|
||||
}
|
||||
}
|
||||
if (obsoleteAssociations.length > 0) {
|
||||
promises.push(this.through.model.destroy(__spreadProps(__spreadValues({}, options), {
|
||||
where: __spreadValues({
|
||||
[identifier]: sourceInstance.get(sourceKey),
|
||||
[foreignIdentifier]: obsoleteAssociations.map((obsoleteAssociation) => obsoleteAssociation[foreignIdentifier])
|
||||
}, this.through.scope)
|
||||
})));
|
||||
}
|
||||
if (unassociatedObjects.length > 0) {
|
||||
const bulk = unassociatedObjects.map((unassociatedObject) => {
|
||||
return __spreadValues(__spreadProps(__spreadValues(__spreadValues({}, defaultAttributes), unassociatedObject[this.through.model.name]), {
|
||||
[identifier]: sourceInstance.get(sourceKey),
|
||||
[foreignIdentifier]: unassociatedObject.get(targetKey)
|
||||
}), this.through.scope);
|
||||
});
|
||||
promises.push(this.through.model.bulkCreate(bulk, __spreadValues({ validate: true }, options)));
|
||||
}
|
||||
return Promise.all(promises);
|
||||
};
|
||||
try {
|
||||
const currentRows = await this.through.model.findAll(__spreadProps(__spreadValues({}, options), { where, raw: true }));
|
||||
return await updateAssociations(currentRows);
|
||||
} catch (error) {
|
||||
if (error instanceof EmptyResultError)
|
||||
return updateAssociations([]);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
async add(sourceInstance, newInstances, options) {
|
||||
if (!newInstances)
|
||||
return Promise.resolve();
|
||||
options = __spreadValues({}, options);
|
||||
const association = this;
|
||||
const sourceKey = association.sourceKey;
|
||||
const targetKey = association.targetKey;
|
||||
const identifier = association.identifier;
|
||||
const foreignIdentifier = association.foreignIdentifier;
|
||||
const defaultAttributes = options.through || {};
|
||||
newInstances = association.toInstanceArray(newInstances);
|
||||
const where = __spreadValues({
|
||||
[identifier]: sourceInstance.get(sourceKey),
|
||||
[foreignIdentifier]: newInstances.map((newInstance) => newInstance.get(targetKey))
|
||||
}, association.through.scope);
|
||||
const updateAssociations = (currentRows) => {
|
||||
const promises = [];
|
||||
const unassociatedObjects = [];
|
||||
const changedAssociations = [];
|
||||
for (const obj of newInstances) {
|
||||
const existingAssociation = currentRows && currentRows.find((current) => current[foreignIdentifier] === obj.get(targetKey));
|
||||
if (!existingAssociation) {
|
||||
unassociatedObjects.push(obj);
|
||||
} else {
|
||||
const throughAttributes = obj[association.through.model.name];
|
||||
const attributes = __spreadValues(__spreadValues({}, defaultAttributes), throughAttributes);
|
||||
if (Object.keys(attributes).some((attribute) => attributes[attribute] !== existingAssociation[attribute])) {
|
||||
changedAssociations.push(obj);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (unassociatedObjects.length > 0) {
|
||||
const bulk = unassociatedObjects.map((unassociatedObject) => {
|
||||
const throughAttributes = unassociatedObject[association.through.model.name];
|
||||
const attributes = __spreadValues(__spreadValues({}, defaultAttributes), throughAttributes);
|
||||
attributes[identifier] = sourceInstance.get(sourceKey);
|
||||
attributes[foreignIdentifier] = unassociatedObject.get(targetKey);
|
||||
Object.assign(attributes, association.through.scope);
|
||||
return attributes;
|
||||
});
|
||||
promises.push(association.through.model.bulkCreate(bulk, __spreadValues({ validate: true }, options)));
|
||||
}
|
||||
for (const assoc of changedAssociations) {
|
||||
let throughAttributes = assoc[association.through.model.name];
|
||||
const attributes = __spreadValues(__spreadValues({}, defaultAttributes), throughAttributes);
|
||||
if (throughAttributes instanceof association.through.model) {
|
||||
throughAttributes = {};
|
||||
}
|
||||
promises.push(association.through.model.update(attributes, Object.assign(options, { where: {
|
||||
[identifier]: sourceInstance.get(sourceKey),
|
||||
[foreignIdentifier]: assoc.get(targetKey)
|
||||
} })));
|
||||
}
|
||||
return Promise.all(promises);
|
||||
};
|
||||
try {
|
||||
const currentRows = await association.through.model.findAll(__spreadProps(__spreadValues({}, options), { where, raw: true }));
|
||||
const [associations] = await updateAssociations(currentRows);
|
||||
return associations;
|
||||
} catch (error) {
|
||||
if (error instanceof EmptyResultError)
|
||||
return updateAssociations();
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
remove(sourceInstance, oldAssociatedObjects, options) {
|
||||
const association = this;
|
||||
options = options || {};
|
||||
oldAssociatedObjects = association.toInstanceArray(oldAssociatedObjects);
|
||||
const where = {
|
||||
[association.identifier]: sourceInstance.get(association.sourceKey),
|
||||
[association.foreignIdentifier]: oldAssociatedObjects.map((newInstance) => newInstance.get(association.targetKey))
|
||||
};
|
||||
return association.through.model.destroy(__spreadProps(__spreadValues({}, options), { where }));
|
||||
}
|
||||
async create(sourceInstance, values, options) {
|
||||
const association = this;
|
||||
options = options || {};
|
||||
values = values || {};
|
||||
if (Array.isArray(options)) {
|
||||
options = {
|
||||
fields: options
|
||||
};
|
||||
}
|
||||
if (association.scope) {
|
||||
Object.assign(values, association.scope);
|
||||
if (options.fields) {
|
||||
options.fields = options.fields.concat(Object.keys(association.scope));
|
||||
}
|
||||
}
|
||||
const newAssociatedObject = await association.target.create(values, options);
|
||||
await sourceInstance[association.accessors.add](newAssociatedObject, _.omit(options, ["fields"]));
|
||||
return newAssociatedObject;
|
||||
}
|
||||
verifyAssociationAlias(alias) {
|
||||
if (typeof alias === "string") {
|
||||
return this.as === alias;
|
||||
}
|
||||
if (alias && alias.plural) {
|
||||
return this.as === alias.plural;
|
||||
}
|
||||
return !this.isAliased;
|
||||
}
|
||||
}
|
||||
module.exports = BelongsToMany;
|
||||
module.exports.BelongsToMany = BelongsToMany;
|
||||
module.exports.default = BelongsToMany;
|
||||
//# sourceMappingURL=belongs-to-many.js.map
|
||||
Reference in New Issue
Block a user