@vsaas/loopback-datasource-juggler 10.0.0

package/dist/lib/include.js

@@ -0,0 +1,795 @@
+"use strict";
+const require_runtime = require("../_virtual/_rolldown/runtime.js");
+const require_lib_globalize = require("./globalize.js");
+const require_lib_utils = require("./utils.js");
+const require_lib_list = require("./list.js");
+const require_lib_include_utils = require("./include_utils.js");
+//#region src/lib/include.ts
+var require_include = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const g = require_lib_globalize();
+	const utils = require_lib_utils;
+	const List = require_lib_list;
+	const includeUtils = require_lib_include_utils;
+	const isPlainObject = utils.isPlainObject;
+	const defineCachedRelations = utils.defineCachedRelations;
+	const uniq = utils.uniq;
+	const idName = utils.idName;
+	const debug = require("debug")("loopback:include");
+	const DISALLOWED_TYPES = [
+		"boolean",
+		"number",
+		"symbol",
+		"function"
+	];
+	/*!
+	* Normalize the include to be an array
+	* @param include
+	* @returns {*}
+	*/
+	function normalizeInclude(include) {
+		let newInclude;
+		if (typeof include === "string") return [include];
+		else if (isPlainObject(include)) {
+			newInclude = [];
+			const rel = include.rel || include.relation;
+			const obj = {};
+			if (typeof rel === "string") {
+				obj[rel] = new IncludeScope(include.scope);
+				newInclude.push(obj);
+			} else for (const key in include) {
+				obj[key] = include[key];
+				newInclude.push(obj);
+			}
+			return newInclude;
+		} else if (Array.isArray(include)) {
+			newInclude = [];
+			for (let i = 0, n = include.length; i < n; i++) {
+				const subIncludes = normalizeInclude(include[i]);
+				for (let j = 0, m = subIncludes.length; j < m; j++) newInclude.push(subIncludes[j]);
+			}
+			return newInclude;
+		} else if (DISALLOWED_TYPES.includes(typeof include)) {
+			debug("Ignoring invalid \"include\" value of type %s:", typeof include, include);
+			return [];
+		} else return include;
+	}
+	function IncludeScope(scope) {
+		this._scope = utils.deepMerge({}, scope || {});
+		if (this._scope.include) {
+			this._include = normalizeInclude(this._scope.include);
+			delete this._scope.include;
+		} else this._include = null;
+	}
+	IncludeScope.prototype.conditions = function() {
+		return utils.deepMerge({}, this._scope);
+	};
+	IncludeScope.prototype.include = function() {
+		return this._include;
+	};
+	/*!
+	* Look up a model by name from the list of given models
+	* @param {Object} models Models keyed by name
+	* @param {String} modelName The model name
+	* @returns {*} The matching model class
+	*/
+	function lookupModel(models, modelName) {
+		if (models[modelName]) return models[modelName];
+		const lookupClassName = modelName.toLowerCase();
+		for (const name in models) if (name.toLowerCase() === lookupClassName) return models[name];
+	}
+	/**
+	* Utility Function to allow interleave before and after high computation tasks
+	* @param tasks
+	* @param callback
+	*/
+	function execTasksWithInterLeave(tasks, callback) {
+		process.nextTick(function() {
+			try {
+				runParallelTasks(tasks, function(err, info) {
+					process.nextTick(function() {
+						callback(err, info);
+					});
+				});
+			} catch (err) {
+				callback(err);
+			}
+		});
+	}
+	function once(fn) {
+		let called = false;
+		return function() {
+			if (called) return;
+			called = true;
+			fn.apply(this, arguments);
+		};
+	}
+	function runParallelTasks(tasks, callback) {
+		if (!tasks || tasks.length === 0) return callback(null, []);
+		const results = Array.from({ length: tasks.length });
+		let pending = tasks.length;
+		let finished = false;
+		for (let i = 0; i < tasks.length; i++) {
+			const task = tasks[i];
+			const done = once(function(err, result) {
+				if (finished) return;
+				if (err) {
+					finished = true;
+					return callback(err);
+				}
+				results[i] = result;
+				pending--;
+				if (pending === 0) callback(null, results);
+			});
+			try {
+				task(done);
+			} catch (err) {
+				done(err);
+			}
+		}
+	}
+	function eachParallel(items, iterator, callback) {
+		if (!items || items.length === 0) return callback();
+		let pending = items.length;
+		let finished = false;
+		for (let i = 0; i < items.length; i++) {
+			const item = items[i];
+			const done = once(function(err) {
+				if (finished) return;
+				if (err) {
+					finished = true;
+					return callback(err);
+				}
+				pending--;
+				if (pending === 0) callback();
+			});
+			try {
+				iterator(item, done);
+			} catch (err) {
+				done(err);
+			}
+		}
+	}
+	/*!
+	* Include mixin for ./model.js
+	*/
+	module.exports = Inclusion;
+	/**
+	* Inclusion - Model mixin.
+	*
+	* @class
+	*/
+	function Inclusion() {}
+	/**
+	* Normalize includes - used in DataAccessObject
+	*
+	*/
+	Inclusion.normalizeInclude = normalizeInclude;
+	/**
+	* Enables you to load relations of several objects and optimize numbers of requests.
+	*
+	* Examples:
+	*
+	* Load all users' posts with only one additional request:
+	* `User.include(users, 'posts', function() {});`
+	* Or
+	* `User.include(users, ['posts'], function() {});`
+	*
+	* Load all users posts and passports with two additional requests:
+	* `User.include(users, ['posts', 'passports'], function() {});`
+	*
+	* Load all passports owner (users), and all posts of each owner loaded:
+	*```Passport.include(passports, {owner: 'posts'}, function() {});
+	*``` Passport.include(passports, {owner: ['posts', 'passports']});
+	*``` Passport.include(passports, {owner: [{posts: 'images'}, 'passports']});
+	*
+	* @param {Array} objects Array of instances
+	* @param {String|Object|Array} include Which relations to load.
+	* @param {Object} [options] Options for CRUD
+	* @param {Function} cb Callback called when relations are loaded
+	*
+	*/
+	Inclusion.include = function(objects, include, options, cb) {
+		if (typeof options === "function" && cb === void 0) {
+			cb = options;
+			options = {};
+		}
+		const self = this;
+		if (!include || Array.isArray(include) && include.length === 0 || Array.isArray(objects) && objects.length === 0 || isPlainObject(include) && Object.keys(include).length === 0) return process.nextTick(function() {
+			if (cb) cb(null, objects);
+		});
+		include = normalizeInclude(include);
+		debug("include: %j", include);
+		let inqLimit = 256;
+		if (self.dataSource && self.dataSource.settings && self.dataSource.settings.inqLimit) inqLimit = self.dataSource.settings.inqLimit;
+		eachParallel(include, function(item, callback) {
+			try {
+				processIncludeItem(objects, item, options, callback);
+			} catch (err) {
+				callback(err);
+			}
+		}, function(err) {
+			debug(err, objects);
+			if (cb) cb(err, objects);
+		});
+		/**
+		* Find related items with an array of foreign keys by page
+		* @param model The model class
+		* @param filter The query filter
+		* @param fkName The name of the foreign key property
+		* @param pageSize The size of page
+		* @param options Options
+		* @param cb
+		*/
+		function findWithForeignKeysByPage(model, filter, fkName, pageSize, options, cb) {
+			try {
+				const opts = Object.assign({ prohibitProtectedPropertiesInQuery: true }, options);
+				model._sanitizeQuery(filter.where, opts);
+				model._coerce(filter.where, options);
+			} catch (e) {
+				return cb(e);
+			}
+			let foreignKeys = [];
+			if (filter.where[fkName]) foreignKeys = filter.where[fkName].inq;
+			else if (filter.where.and) {
+				for (const j in filter.where.and) if (filter.where.and[j][fkName] && Array.isArray(filter.where.and[j][fkName].inq)) {
+					foreignKeys = filter.where.and[j][fkName].inq;
+					break;
+				}
+			}
+			if (!foreignKeys.length) return cb(null, []);
+			if (filter.limit || filter.skip || filter.offset) pageSize = 1;
+			const size = foreignKeys.length;
+			if (size > inqLimit && pageSize <= 0) pageSize = inqLimit;
+			if (pageSize <= 0) return model.find(filter, options, cb);
+			let listOfFKs = [];
+			for (let i = 0; i < size; i += pageSize) {
+				let end = i + pageSize;
+				if (end > size) end = size;
+				listOfFKs.push(foreignKeys.slice(i, end));
+			}
+			const items = [];
+			listOfFKs = listOfFKs.filter(function(keys) {
+				return keys.length > 0;
+			});
+			eachParallel(listOfFKs, function(foreignKeys, done) {
+				const newFilter = {};
+				for (const f in filter) newFilter[f] = filter[f];
+				if (filter.where) {
+					newFilter.where = {};
+					for (const w in filter.where) newFilter.where[w] = filter.where[w];
+				}
+				newFilter.where[fkName] = foreignKeys.length === 1 ? foreignKeys[0] : { inq: foreignKeys };
+				model.find(newFilter, options, function(err, results) {
+					if (err) return done(err);
+					for (let i = 0; i < results.length; i++) items.push(results[i]);
+					done();
+				});
+			}, function(err) {
+				if (err) return cb(err);
+				cb(null, items);
+			});
+		}
+		function processIncludeItem(objs, include, options, cb) {
+			const relations = self.relations;
+			let relationName;
+			let subInclude = null, scope = null;
+			if (isPlainObject(include)) {
+				relationName = Object.keys(include)[0];
+				if (include[relationName] instanceof IncludeScope) {
+					scope = include[relationName];
+					subInclude = scope.include();
+				} else {
+					subInclude = include[relationName];
+					if (subInclude === true) subInclude = null;
+				}
+			} else {
+				relationName = include;
+				subInclude = null;
+			}
+			const relation = relations[relationName];
+			if (!relation) {
+				cb(new Error(g.f("Relation \"%s\" is not defined for %s model", relationName, self.modelName)));
+				return;
+			}
+			debug("Relation: %j", relation);
+			const polymorphic = relation.polymorphic;
+			if (!relation.modelTo) {
+				if (!relation.polymorphic) {
+					cb(new Error(g.f("{{Relation.modelTo}} is not defined for relation %s and is no {{polymorphic}}", relationName)));
+					return;
+				}
+			}
+			if (relation.options.disableInclude) {
+				debug("Relation is disabled from include", relation);
+				return cb();
+			}
+			const filter = scope && scope.conditions() || {};
+			if ((relation.multiple || relation.type === "belongsTo") && scope) {
+				const includeScope = {};
+				if (filter.fields && Array.isArray(subInclude) && relation.modelTo.relations) {
+					includeScope.fields = [];
+					subInclude.forEach(function(name) {
+						const rel = relation.modelTo.relations[name];
+						if (rel && rel.type === "belongsTo") includeScope.fields.push(rel.keyFrom);
+					});
+				}
+				utils.mergeQuery(filter, includeScope, { fields: false });
+			}
+			filter.where = filter.where || {};
+			let fields = filter.fields;
+			if (typeof fields === "string") filter.fields = fields = [fields];
+			if (Array.isArray(fields) && fields.indexOf(relation.keyTo) === -1) fields.push(relation.keyTo);
+			else if (isPlainObject(fields) && !fields[relation.keyTo]) fields[relation.keyTo] = true;
+			if (relation.multiple) {
+				if (relation.modelThrough) return includeHasManyThrough(cb);
+				if (relation.type === "embedsMany") return includeEmbeds(cb);
+				if (relation.type === "referencesMany") return includeReferencesMany(cb);
+				if (relation.type === "hasMany" && relation.multiple && !subInclude) return includeHasManySimple(cb);
+				return includeHasMany(cb);
+			} else {
+				if (polymorphic) {
+					if (relation.type === "hasOne") return includePolymorphicHasOne(cb);
+					return includePolymorphicBelongsTo(cb);
+				}
+				if (relation.type === "embedsOne") return includeEmbeds(cb);
+				return includeOneToOne(cb);
+			}
+			/**
+			* Handle inclusion of HasManyThrough/HasAndBelongsToMany/Polymorphic
+			* HasManyThrough relations
+			* @param callback
+			*/
+			function includeHasManyThrough(callback) {
+				const sourceIds = [];
+				const objIdMap = {};
+				for (let i = 0; i < objs.length; i++) {
+					const obj = objs[i];
+					const sourceId = obj[relation.keyFrom];
+					if (sourceId) {
+						sourceIds.push(sourceId);
+						objIdMap[sourceId.toString()] = obj;
+					}
+					defineCachedRelations(obj);
+					obj.__cachedRelations[relationName] = [];
+				}
+				const throughFilter = { where: {} };
+				throughFilter.where[relation.keyTo] = { inq: uniq(sourceIds) };
+				if (polymorphic) {
+					const throughModel = polymorphic.invert ? relation.modelTo : relation.modelFrom;
+					throughFilter.where[polymorphic.discriminator] = throughModel.definition.name;
+				}
+				findWithForeignKeysByPage(relation.modelThrough, throughFilter, relation.keyTo, 0, options, throughFetchHandler);
+				/**
+				* Handle the results of Through model objects and fetch the modelTo items
+				* @param err
+				* @param {Array<Model>} throughObjs
+				* @returns {*}
+				*/
+				function throughFetchHandler(err, throughObjs) {
+					if (err) return callback(err);
+					const targetIds = [];
+					const targetObjsMap = {};
+					for (let i = 0; i < throughObjs.length; i++) {
+						const throughObj = throughObjs[i];
+						const targetId = throughObj[relation.keyThrough];
+						if (targetId) {
+							targetIds.push(targetId);
+							const sourceObj = objIdMap[throughObj[relation.keyTo]];
+							const targetIdStr = targetId.toString();
+							(targetObjsMap[targetIdStr] = targetObjsMap[targetIdStr] || []).push(sourceObj);
+						}
+					}
+					const modelToIdName = idName(relation.modelTo);
+					filter.where[modelToIdName] = { inq: uniq(targetIds) };
+					if (Array.isArray(fields) && fields.indexOf(modelToIdName) === -1) fields.push(modelToIdName);
+					else if (isPlainObject(fields) && !fields[modelToIdName]) fields[modelToIdName] = true;
+					findWithForeignKeysByPage(relation.modelTo, filter, modelToIdName, 0, options, targetsFetchHandler);
+					function targetsFetchHandler(err, targets) {
+						if (err) return callback(err);
+						const tasks = [];
+						if (subInclude && targets) tasks.push(function subIncludesTask(next) {
+							relation.modelTo.include(targets, subInclude, options, next);
+						});
+						tasks.push(targetLinkingTask);
+						function targetLinkingTask(next) {
+							eachParallel(targets, linkManyToMany, next);
+							function linkManyToMany(target, next) {
+								const targetId = target[modelToIdName];
+								if (!targetId) return next(new Error(g.f("LinkManyToMany received target that doesn't contain required \"%s\"", modelToIdName)));
+								const objList = targetObjsMap[targetId.toString()];
+								eachParallel(objList, function(obj, next) {
+									if (!obj) return next();
+									obj.__cachedRelations[relationName].push(target);
+									processTargetObj(obj, next);
+								}, next);
+							}
+						}
+						execTasksWithInterLeave(tasks, callback);
+					}
+				}
+			}
+			/**
+			* Handle inclusion of ReferencesMany relation
+			* @param callback
+			*/
+			function includeReferencesMany(callback) {
+				const modelToIdName = idName(relation.modelTo);
+				const allTargetIds = [];
+				const targetObjsMap = {};
+				for (let i = 0; i < objs.length; i++) {
+					const obj = objs[i];
+					let targetIds = obj[relation.keyFrom];
+					if (targetIds) {
+						if (typeof targetIds === "string") targetIds = JSON.parse(targetIds);
+						for (let j = 0; j < targetIds.length; j++) allTargetIds.push(targetIds[j]);
+						for (let j = 0; j < targetIds.length; j++) {
+							const targetIdStr = targetIds[j].toString();
+							(targetObjsMap[targetIdStr] = targetObjsMap[targetIdStr] || []).push(obj);
+						}
+					}
+					defineCachedRelations(obj);
+					obj.__cachedRelations[relationName] = [];
+				}
+				filter.where[relation.keyTo] = { inq: uniq(allTargetIds) };
+				relation.applyScope(null, filter);
+				/**
+				* Make the DB Call, fetch all target objects
+				*/
+				findWithForeignKeysByPage(relation.modelTo, filter, relation.keyTo, 0, options, targetFetchHandler);
+				/**
+				* Handle the fetched target objects
+				* @param err
+				* @param {Array<Model>}targets
+				* @returns {*}
+				*/
+				function targetFetchHandler(err, targets) {
+					if (err) return callback(err);
+					const tasks = [];
+					if (subInclude && targets) tasks.push(function subIncludesTask(next) {
+						relation.modelTo.include(targets, subInclude, options, next);
+					});
+					targets = utils.sortObjectsByIds(modelToIdName, allTargetIds, targets);
+					tasks.push(targetLinkingTask);
+					function targetLinkingTask(next) {
+						eachParallel(targets, linkManyToMany, next);
+						function linkManyToMany(target, next) {
+							const objList = targetObjsMap[target[relation.keyTo].toString()];
+							eachParallel(objList, function(obj, next) {
+								if (!obj) return next();
+								obj.__cachedRelations[relationName].push(target);
+								processTargetObj(obj, next);
+							}, next);
+						}
+					}
+					execTasksWithInterLeave(tasks, callback);
+				}
+			}
+			/**
+			* Handle inclusion of HasMany relation
+			* @param callback
+			*/
+			function includeHasManySimple(callback) {
+				const objIdMap2 = includeUtils.buildOneToOneIdentityMapWithOrigKeys(objs, relation.keyFrom);
+				filter.where[relation.keyTo] = { inq: uniq(objIdMap2.getKeys()) };
+				relation.applyScope(null, filter);
+				findWithForeignKeysByPage(relation.modelTo, filter, relation.keyTo, 0, options, targetFetchHandler);
+				function targetFetchHandler(err, targets) {
+					if (err) return callback(err);
+					const targetsIdMap = includeUtils.buildOneToManyIdentityMapWithOrigKeys(targets, relation.keyTo);
+					includeUtils.join(objIdMap2, targetsIdMap, function(obj1, valueToMergeIn) {
+						defineCachedRelations(obj1);
+						obj1.__cachedRelations[relationName] = valueToMergeIn;
+						processTargetObj(obj1, function() {});
+					});
+					callback(err, objs);
+				}
+			}
+			/**
+			* Handle inclusion of HasMany relation
+			* @param callback
+			*/
+			function includeHasMany(callback) {
+				const sourceIds = [];
+				const objIdMap = {};
+				for (let i = 0; i < objs.length; i++) {
+					const obj = objs[i];
+					const sourceId = obj[relation.keyFrom];
+					if (sourceId) {
+						sourceIds.push(sourceId);
+						objIdMap[sourceId.toString()] = obj;
+					}
+					defineCachedRelations(obj);
+					obj.__cachedRelations[relationName] = [];
+				}
+				filter.where[relation.keyTo] = { inq: uniq(sourceIds) };
+				relation.applyScope(null, filter);
+				options.partitionBy = relation.keyTo;
+				findWithForeignKeysByPage(relation.modelTo, filter, relation.keyTo, 0, options, targetFetchHandler);
+				/**
+				* Process fetched related objects
+				* @param err
+				* @param {Array<Model>} targets
+				* @returns {*}
+				*/
+				function targetFetchHandler(err, targets) {
+					if (err) return callback(err);
+					const tasks = [];
+					if (subInclude && targets) tasks.push(function subIncludesTask(next) {
+						relation.modelTo.include(targets, subInclude, options, next);
+					});
+					tasks.push(targetLinkingTask);
+					function targetLinkingTask(next) {
+						if (targets.length === 0) return eachParallel(objs, function(obj, next) {
+							processTargetObj(obj, next);
+						}, next);
+						eachParallel(targets, linkManyToOne, function(err) {
+							if (err) return next(err);
+							const objsWithEmptyRelation = [];
+							for (let i = 0; i < objs.length; i++) if (objs[i].__cachedRelations[relationName].length === 0) objsWithEmptyRelation.push(objs[i]);
+							eachParallel(objsWithEmptyRelation, function(obj, next) {
+								processTargetObj(obj, next);
+							}, next);
+						});
+						function linkManyToOne(target, next) {
+							const relationValue = target[relation.keyTo];
+							eachParallel(Array.isArray(relationValue) ? relationValue : [relationValue], function(targetId, next) {
+								const obj = objIdMap[targetId.toString()];
+								if (!obj) return next();
+								obj.__cachedRelations[relationName].push(target);
+								processTargetObj(obj, next);
+							}, next);
+						}
+					}
+					execTasksWithInterLeave(tasks, callback);
+				}
+			}
+			/**
+			* Handle Inclusion of Polymorphic BelongsTo relation
+			* @param callback
+			*/
+			function includePolymorphicBelongsTo(callback) {
+				const targetIdsByType = {};
+				const targetObjMapByType = {};
+				for (let i = 0; i < objs.length; i++) {
+					const obj = objs[i];
+					const modelType = obj[polymorphic.discriminator];
+					if (modelType) {
+						targetIdsByType[modelType] = targetIdsByType[modelType] || [];
+						targetObjMapByType[modelType] = targetObjMapByType[modelType] || {};
+						const targetIds = targetIdsByType[modelType];
+						const targetObjsMap = targetObjMapByType[modelType];
+						const targetId = obj[relation.keyFrom];
+						if (targetId) {
+							targetIds.push(targetId);
+							const targetIdStr = targetId.toString();
+							targetObjsMap[targetIdStr] = targetObjsMap[targetIdStr] || [];
+							targetObjsMap[targetIdStr].push(obj);
+						}
+					}
+					defineCachedRelations(obj);
+					obj.__cachedRelations[relationName] = null;
+				}
+				eachParallel(Object.keys(targetIdsByType), processPolymorphicType, callback);
+				/**
+				* Process Polymorphic objects of each type (modelType)
+				* @param {String} modelType
+				* @param callback
+				*/
+				function processPolymorphicType(modelType, callback) {
+					const typeFilter = { where: {} };
+					utils.mergeQuery(typeFilter, filter);
+					const targetIds = targetIdsByType[modelType];
+					typeFilter.where[relation.keyTo] = { inq: uniq(targetIds) };
+					const Model = lookupModel(relation.modelFrom.dataSource.modelBuilder.models, modelType);
+					if (!Model) {
+						callback(new Error(g.f("Discriminator type %s specified but no model exists with such name", modelType)));
+						return;
+					}
+					relation.applyScope(null, typeFilter);
+					findWithForeignKeysByPage(Model, typeFilter, relation.keyTo, 0, options, targetFetchHandler);
+					/**
+					* Process fetched related objects
+					* @param err
+					* @param {Array<Model>} targets
+					* @returns {*}
+					*/
+					function targetFetchHandler(err, targets) {
+						if (err) return callback(err);
+						const tasks = [];
+						if (subInclude && targets) tasks.push(function subIncludesTask(next) {
+							Model.include(targets, subInclude, options, next);
+						});
+						tasks.push(targetLinkingTask);
+						function targetLinkingTask(next) {
+							const targetObjsMap = targetObjMapByType[modelType];
+							eachParallel(targets, linkOneToMany, next);
+							function linkOneToMany(target, next) {
+								const objList = targetObjsMap[target[relation.keyTo].toString()];
+								eachParallel(objList, function(obj, next) {
+									if (!obj) return next();
+									obj.__cachedRelations[relationName] = target;
+									processTargetObj(obj, next);
+								}, next);
+							}
+						}
+						execTasksWithInterLeave(tasks, callback);
+					}
+				}
+			}
+			/**
+			* Handle Inclusion of Polymorphic HasOne relation
+			* @param callback
+			*/
+			function includePolymorphicHasOne(callback) {
+				const sourceIds = [];
+				const objIdMap = {};
+				for (let i = 0; i < objs.length; i++) {
+					const obj = objs[i];
+					const sourceId = obj[relation.keyFrom];
+					if (sourceId) {
+						sourceIds.push(sourceId);
+						objIdMap[sourceId.toString()] = obj;
+					}
+					defineCachedRelations(obj);
+					obj.__cachedRelations[relationName] = null;
+				}
+				filter.where[relation.keyTo] = { inq: uniq(sourceIds) };
+				relation.applyScope(null, filter);
+				findWithForeignKeysByPage(relation.modelTo, filter, relation.keyTo, 0, options, targetFetchHandler);
+				/**
+				* Process fetched related objects
+				* @param err
+				* @param {Array<Model>} targets
+				* @returns {*}
+				*/
+				function targetFetchHandler(err, targets) {
+					if (err) return callback(err);
+					const tasks = [];
+					if (subInclude && targets) tasks.push(function subIncludesTask(next) {
+						relation.modelTo.include(targets, subInclude, options, next);
+					});
+					tasks.push(targetLinkingTask);
+					function targetLinkingTask(next) {
+						eachParallel(targets, linkOneToOne, next);
+						function linkOneToOne(target, next) {
+							const sourceId = target[relation.keyTo];
+							if (!sourceId) return next();
+							const obj = objIdMap[sourceId.toString()];
+							if (!obj) return next();
+							obj.__cachedRelations[relationName] = target;
+							processTargetObj(obj, next);
+						}
+					}
+					execTasksWithInterLeave(tasks, callback);
+				}
+			}
+			/**
+			* Handle Inclusion of BelongsTo/HasOne relation
+			* @param callback
+			*/
+			function includeOneToOne(callback) {
+				const targetIds = [];
+				const objTargetIdMap = {};
+				for (let i = 0; i < objs.length; i++) {
+					const obj = objs[i];
+					if (relation.type === "belongsTo") {
+						if (obj[relation.keyFrom] == null) {
+							defineCachedRelations(obj);
+							obj.__cachedRelations[relationName] = null;
+							debug("ID property \"%s\" is missing in item %j", relation.keyFrom, obj);
+							continue;
+						}
+					}
+					const targetId = obj[relation.keyFrom];
+					if (targetId) {
+						targetIds.push(targetId);
+						const targetIdStr = targetId.toString();
+						objTargetIdMap[targetIdStr] = objTargetIdMap[targetIdStr] || [];
+						objTargetIdMap[targetIdStr].push(obj);
+					} else debug("ID property \"%s\" is missing in item %j", relation.keyFrom, obj);
+					defineCachedRelations(obj);
+					obj.__cachedRelations[relationName] = null;
+				}
+				filter.where[relation.keyTo] = { inq: uniq(targetIds) };
+				relation.applyScope(null, filter);
+				findWithForeignKeysByPage(relation.modelTo, filter, relation.keyTo, 0, options, targetFetchHandler);
+				/**
+				* Process fetched related objects
+				* @param err
+				* @param {Array<Model>} targets
+				* @returns {*}
+				*/
+				function targetFetchHandler(err, targets) {
+					if (err) return callback(err);
+					const tasks = [];
+					if (subInclude && targets) tasks.push(function subIncludesTask(next) {
+						relation.modelTo.include(targets, subInclude, options, next);
+					});
+					tasks.push(targetLinkingTask);
+					function targetLinkingTask(next) {
+						eachParallel(targets, linkOneToMany, next);
+						function linkOneToMany(target, next) {
+							const objList = objTargetIdMap[target[relation.keyTo].toString()];
+							eachParallel(objList, function(obj, next) {
+								if (!obj) return next();
+								obj.__cachedRelations[relationName] = target;
+								processTargetObj(obj, next);
+							}, next);
+						}
+					}
+					execTasksWithInterLeave(tasks, callback);
+				}
+			}
+			/**
+			* Handle Inclusion of EmbedsMany/EmbedsManyWithBelongsTo/EmbedsOne
+			* Relations. Since Embedded docs are part of parents, no need to make
+			* db calls. Let the related function be called for each object to fetch
+			* the results from cache.
+			*
+			* TODO: Optimize EmbedsManyWithBelongsTo relation DB Calls
+			* @param callback
+			*/
+			function includeEmbeds(callback) {
+				eachParallel(objs, function(obj, next) {
+					processTargetObj(obj, next);
+				}, callback);
+			}
+			/**
+			* Process Each Model Object and make sure specified relations are included
+			* @param {Model} obj - Single Mode object for which inclusion is needed
+			* @param callback
+			* @returns {*}
+			*/
+			function processTargetObj(obj, callback) {
+				const isInst = obj instanceof self;
+				if (relation.type === "belongsTo") {
+					if (obj[relation.keyFrom] === null || obj[relation.keyFrom] === void 0) {
+						defineCachedRelations(obj);
+						obj.__cachedRelations[relationName] = null;
+						if (isInst) obj.__data[relationName] = null;
+						else obj[relationName] = null;
+						return callback();
+					}
+				}
+				/**
+				* Sets the related objects as a property of Parent Object
+				* @param {Array<Model>|Model|null} result - Related Object/Objects
+				* @param cb
+				*/
+				function setIncludeData(result, cb) {
+					if (isInst) {
+						if (Array.isArray(result) && !(result instanceof List)) result = new List(result, relation.modelTo);
+						obj.__data[relationName] = result;
+					} else obj[relationName] = result;
+					cb(null, result);
+				}
+				if (obj.__cachedRelations && obj.__cachedRelations[relationName] !== void 0) return setIncludeData(obj.__cachedRelations[relationName], callback);
+				const inst = obj instanceof self ? obj : new self(obj);
+				let related;
+				if ((relation.multiple || relation.type === "belongsTo") && scope) {
+					const includeScope = {};
+					const filter = scope.conditions();
+					if (filter.fields && Array.isArray(subInclude) && relation.modelTo.relations) {
+						includeScope.fields = [];
+						subInclude.forEach(function(name) {
+							const rel = relation.modelTo.relations[name];
+							if (rel && rel.type === "belongsTo") includeScope.fields.push(rel.keyFrom);
+						});
+					}
+					utils.mergeQuery(filter, includeScope, { fields: false });
+					related = inst[relationName].bind(inst, filter);
+				} else related = inst[relationName].bind(inst, void 0);
+				related(options, function(err, result) {
+					if (err) return callback(err);
+					else {
+						defineCachedRelations(obj);
+						obj.__cachedRelations[relationName] = result;
+						return setIncludeData(result, callback);
+					}
+				});
+			}
+		}
+	};
+}));
+//#endregion
+module.exports = require_include();