text: 'use strict';
  
  const Utils = require('./../utils');
  const Helpers = require('./helpers');
  const _ = require('lodash');
  const Association = require('./base');
  const Op = require('../operators');
  
  /**
   * One-to-many association
   *
   * In the API reference below, add the name of the association to the method, e.g. for `User.hasMany(Project)` the getter will be `user.getProjects()`.
   * If the association is aliased, use the alias instead, e.g. `User.hasMany(Project, { as: 'jobs' })` will be `user.getJobs()`.
   *
   * @see {@link Model.hasMany}
   */
  class HasMany extends Association {
  	constructor(source, target, options) {
  		super(source, target, options);
  
  		this.associationType = 'HasMany';
  		this.targetAssociation = null;
  		this.sequelize = source.sequelize;
  		this.isMultiAssociation = true;
  		this.foreignKeyAttribute = {};
  
  		if (this.options.through) {
  			throw new Error('N:M associations are not supported with hasMany. Use belongsToMany instead');
  		}
  
  		/*
  		 * If self association, this is the target association
  		 */
  		if (this.isSelfAssociation) {
  			this.targetAssociation = this;
  		}
  
  		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;
  		}
  
  		/*
  		 * Foreign key setup
  		 */
  		if (_.isObject(this.options.foreignKey)) {
  			this.foreignKeyAttribute = this.options.foreignKey;
  			this.foreignKey = this.foreignKeyAttribute.name || this.foreignKeyAttribute.fieldName;
  		} else if (this.options.foreignKey) {
  			this.foreignKey = this.options.foreignKey;
  		}
  
  		if (!this.foreignKey) {
  			this.foreignKey = Utils.camelize(
  				[this.source.options.name.singular, this.source.primaryKeyAttribute].join('_')
  			);
  		}
  
  		if (this.target.rawAttributes[this.foreignKey]) {
  			this.identifierField = this.target.rawAttributes[this.foreignKey].field || this.foreignKey;
  			this.foreignKeyField = this.target.rawAttributes[this.foreignKey].field || this.foreignKey;
  		}
  
  		/*
  		 * Source key setup
  		 */
  		this.sourceKey = this.options.sourceKey || this.source.primaryKeyAttribute;
  
  		if (this.source.rawAttributes[this.sourceKey]) {
  			this.sourceKeyAttribute = this.sourceKey;
  			this.sourceKeyField = this.source.rawAttributes[this.sourceKey].field || this.sourceKey;
  		} else {
  			this.sourceKeyAttribute = this.source.primaryKeyAttribute;
  			this.sourceKeyField = this.source.primaryKeyField;
  		}
  
  		// Get singular and plural names
  		// try to uppercase the first letter, unless the model forbids it
  		const plural = _.upperFirst(this.options.name.plural);
  		const singular = _.upperFirst(this.options.name.singular);
  
  		this.associationAccessor = this.as;
  		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}`,
  		};
  	}
  
  	// the id is in the target table
  	// or in an extra table which connects two tables
  	_injectAttributes() {
  		const newAttributes = {
  			[this.foreignKey]: {
  				type: this.options.keyType || this.source.rawAttributes[this.sourceKeyAttribute].type,
  				allowNull: true,
  				...this.foreignKeyAttribute,
  			},
  		};
  
  		// Create a new options object for use with addForeignKeyConstraints, to avoid polluting this.options in case it is later used for a n:m
  		const constraintOptions = { ...this.options };
  
  		if (this.options.constraints !== false) {
  			const target = this.target.rawAttributes[this.foreignKey] || newAttributes[this.foreignKey];
  			constraintOptions.onDelete = constraintOptions.onDelete || (target.allowNull ? 'SET NULL' : 'CASCADE');
  			constraintOptions.onUpdate = constraintOptions.onUpdate || 'CASCADE';
  		}
  
  		Helpers.addForeignKeyConstraints(
  			newAttributes[this.foreignKey],
  			this.source,
  			this.target,
  			constraintOptions,
  			this.sourceKeyField
  		);
  		Utils.mergeDefaults(this.target.rawAttributes, newAttributes);
  
  		this.target.refreshAttributes();
  		this.source.refreshAttributes();
  
  		this.identifierField = this.target.rawAttributes[this.foreignKey].field || this.foreignKey;
  		this.foreignKeyField = this.target.rawAttributes[this.foreignKey].field || this.foreignKey;
  		this.sourceKeyField = this.source.rawAttributes[this.sourceKey].field || this.sourceKey;
  
  		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);
  	}
  
  	/**
  	 * Get everything currently associated with this, using an optional where clause.
  	 *
  	 * @param {Model|Array<Model>} instances source instances
  	 * @param {object} [options] find options
  	 * @param {object} [options.where] An optional where clause to limit the associated models
  	 * @param {string|boolean} [options.scope] Apply a scope on the related model, or remove its default scope by passing false
  	 * @param {string} [options.schema] Apply a schema on the related model
  	 *
  	 * @see
  	 * {@link Model.findAll}  for a full explanation of options
  	 *
  	 * @returns {Promise<Array<Model>>}
  	 */
  	async get(instances, options = {}) {
  		const where = {};
  
  		let Model = this.target;
  		let instance;
  		let values;
  
  		if (!Array.isArray(instances)) {
  			instance = instances;
  			instances = undefined;
  		}
  
  		options = { ...options };
  
  		if (this.scope) {
  			Object.assign(where, this.scope);
  		}
  
  		if (instances) {
  			values = instances.map((_instance) => _instance.get(this.sourceKey, { raw: true }));
  
  			if (options.limit && instances.length > 1) {
  				options.groupedLimit = {
  					limit: options.limit,
  					on: this, // association
  					values,
  				};
  
  				delete options.limit;
  			} else {
  				where[this.foreignKey] = {
  					[Op.in]: values,
  				};
  				delete options.groupedLimit;
  			}
  		} else {
  			where[this.foreignKey] = instance.get(this.sourceKey, { raw: true });
  		}
  
  		options.where = options.where ? { [Op.and]: [where, options.where] } : where;
  
  		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);
  		}
  
  		const results = await Model.findAll(options);
  		if (instance) return results;
  
  		const result = {};
  		for (const _instance of instances) {
  			result[_instance.get(this.sourceKey, { raw: true })] = [];
  		}
  
  		for (const _instance of results) {
  			result[_instance.get(this.foreignKey, { raw: true })].push(_instance);
  		}
  
  		return result;
  	}
  
  	/**
  	 * Count everything currently associated with this, using an optional where clause.
  	 *
  	 * @param {Model}        instance the source instance
  	 * @param {object}         [options] find & count options
  	 * @param {object}         [options.where] An optional where clause to limit the associated models
  	 * @param {string|boolean} [options.scope] Apply a scope on the related model, or remove its default scope by passing false
  	 *
  	 * @returns {Promise<number>}
  	 */
  	async count(instance, options) {
  		options = Utils.cloneDeep(options);
  
  		options.attributes = [
  			[
  				this.sequelize.fn('COUNT', this.sequelize.col(`${this.target.name}.${this.target.primaryKeyField}`)),
  				'count',
  			],
  		];
  		options.raw = true;
  		options.plain = true;
  
  		const result = await this.get(instance, options);
  
  		return parseInt(result.count, 10);
  	}
  
  	/**
  	 * Check if one or more rows are associated with `this`.
  	 *
  	 * @param {Model} sourceInstance the source instance
  	 * @param {Model|Model[]|string[]|string|number[]|number} [targetInstances] Can be an array of instances or their primary keys
  	 * @param {object} [options] Options passed to getAssociations
  	 *
  	 * @returns {Promise}
  	 */
  	async has(sourceInstance, targetInstances, options) {
  		const where = {};
  
  		if (!Array.isArray(targetInstances)) {
  			targetInstances = [targetInstances];
  		}
  
  		options = {
  			...options,
  			scope: false,
  			attributes: [this.target.primaryKeyAttribute],
  			raw: true,
  		};
  
  		where[Op.or] = targetInstances.map((instance) => {
  			if (instance instanceof this.target) {
  				return instance.where();
  			}
  			return {
  				[this.target.primaryKeyAttribute]: instance,
  			};
  		});
  
  		options.where = {
  			[Op.and]: [where, options.where],
  		};
  
  		const associatedObjects = await this.get(sourceInstance, options);
  
  		return associatedObjects.length === targetInstances.length;
  	}
  
  	/**
  	 * Set the associated models by passing an array of persisted instances or their primary keys. Everything that is not in the passed array will be un-associated
  	 *
  	 * @param {Model} sourceInstance source instance to associate new instances with
  	 * @param {Model|Model[]|string[]|string|number[]|number} [targetInstances] An array of persisted instances or primary key of instances to associate with this. Pass `null` or `undefined` to remove all associations.
  	 * @param {object} [options] Options passed to `target.findAll` and `update`.
  	 * @param {object} [options.validate] Run validation for the join model
  	 *
  	 * @returns {Promise}
  	 */
  	async set(sourceInstance, targetInstances, options) {
  		if (targetInstances === null) {
  			targetInstances = [];
  		} else {
  			targetInstances = this.toInstanceArray(targetInstances);
  		}
  
  		const oldAssociations = await this.get(sourceInstance, {
  			...options,
  			scope: false,
  			raw: true,
  		});
  		const promises = [];
  		const obsoleteAssociations = oldAssociations.filter(
  			(old) =>
  				!targetInstances.find(
  					(obj) => obj[this.target.primaryKeyAttribute] === old[this.target.primaryKeyAttribute]
  				)
  		);
  		const unassociatedObjects = targetInstances.filter(
  			(obj) =>
  				!oldAssociations.find(
  					(old) => obj[this.target.primaryKeyAttribute] === old[this.target.primaryKeyAttribute]
  				)
  		);
  		let updateWhere;
  		let update;
  
  		if (obsoleteAssociations.length > 0) {
  			update = {};
  			update[this.foreignKey] = null;
  
  			updateWhere = {
  				[this.target.primaryKeyAttribute]: obsoleteAssociations.map(
  					(associatedObject) => associatedObject[this.target.primaryKeyAttribute]
  				),
  			};
  
  			promises.push(
  				this.target.unscoped().update(update, {
  					...options,
  					where: updateWhere,
  				})
  			);
  		}
  
  		if (unassociatedObjects.length > 0) {
  			updateWhere = {};
  
  			update = {};
  			update[this.foreignKey] = sourceInstance.get(this.sourceKey);
  
  			Object.assign(update, this.scope);
  			updateWhere[this.target.primaryKeyAttribute] = unassociatedObjects.map(
  				(unassociatedObject) => unassociatedObject[this.target.primaryKeyAttribute]
  			);
  
  			promises.push(
  				this.target.unscoped().update(update, {
  					...options,
  					where: updateWhere,
  				})
  			);
  		}
  
  		await Promise.all(promises);
  
  		return sourceInstance;
  	}
  
  	/**
  	 * Associate one or more target rows with `this`. This method accepts a Model / string / number to associate a single row,
  	 * or a mixed array of Model / string / numbers to associate multiple rows.
  	 *
  	 * @param {Model} sourceInstance the source instance
  	 * @param {Model|Model[]|string[]|string|number[]|number} [targetInstances] A single instance or primary key, or a mixed array of persisted instances or primary keys
  	 * @param {object} [options] Options passed to `target.update`.
  	 *
  	 * @returns {Promise}
  	 */
  	async add(sourceInstance, targetInstances, options = {}) {
  		if (!targetInstances) return Promise.resolve();
  
  		targetInstances = this.toInstanceArray(targetInstances);
  
  		const update = {
  			[this.foreignKey]: sourceInstance.get(this.sourceKey),
  			...this.scope,
  		};
  
  		const where = {
  			[this.target.primaryKeyAttribute]: targetInstances.map((unassociatedObject) =>
  				unassociatedObject.get(this.target.primaryKeyAttribute)
  			),
  		};
  
  		await this.target.unscoped().update(update, { ...options, where });
  
  		return sourceInstance;
  	}
  
  	/**
  	 * Un-associate one or several target rows.
  	 *
  	 * @param {Model} sourceInstance instance to un associate instances with
  	 * @param {Model|Model[]|string|string[]|number|number[]} [targetInstances] Can be an Instance or its primary key, or a mixed array of instances and primary keys
  	 * @param {object} [options] Options passed to `target.update`
  	 *
  	 * @returns {Promise}
  	 */
  	async remove(sourceInstance, targetInstances, options = {}) {
  		const update = {
  			[this.foreignKey]: null,
  		};
  
  		targetInstances = this.toInstanceArray(targetInstances);
  
  		const where = {
  			[this.foreignKey]: sourceInstance.get(this.sourceKey),
  			[this.target.primaryKeyAttribute]: targetInstances.map((targetInstance) =>
  				targetInstance.get(this.target.primaryKeyAttribute)
  			),
  		};
  
  		await this.target.unscoped().update(update, { ...options, where });
  
  		return this;
  	}
  
  	/**
  	 * Create a new instance of the associated model and associate it with this.
  	 *
  	 * @param {Model} sourceInstance source instance
  	 * @param {object} [values] values for target model instance
  	 * @param {object} [options] Options passed to `target.create`
  	 *
  	 * @returns {Promise}
  	 */
  	async create(sourceInstance, values, options = {}) {
  		if (Array.isArray(options)) {
  			options = {
  				fields: options,
  			};
  		}
  
  		if (values === undefined) {
  			values = {};
  		}
  
  		if (this.scope) {
  			for (const attribute of Object.keys(this.scope)) {
  				values[attribute] = this.scope[attribute];
  				if (options.fields) options.fields.push(attribute);
  			}
  		}
  
  		values[this.foreignKey] = sourceInstance.get(this.sourceKey);
  		if (options.fields) options.fields.push(this.foreignKey);
  		return await this.target.create(values, options);
  	}
  
  	verifyAssociationAlias(alias) {
  		if (typeof alias === 'string') {
  			return this.as === alias;
  		}
  
  		if (alias && alias.plural) {
  			return this.as === alias.plural;
  		}
  
  		return !this.isAliased;
  	}
  }
  
  module.exports = HasMany;
  module.exports.HasMany = HasMany;
  module.exports.default = HasMany;
  