@vsaas/loopback-datasource-juggler 10.0.0

package/dist/lib/dao.js

@@ -0,0 +1,2445 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.js");
+const require_lib_globalize = require("./globalize.js");
+const require_lib_jutil = require("./jutil.js");
+const require_lib_geo = require("./geo.js");
+const require_lib_utils = require("./utils.js");
+const require_lib_list = require("./list.js");
+require("./model-utils.js");
+const require_lib_validations = require("./validations.js");
+require("./model.js");
+const require_lib_scope = require("./scope.js");
+const require_lib_connectors_memory = require("./connectors/memory.js");
+const require_lib_relations = require("./relations.js");
+const require_lib_include = require("./include.js");
+const require_lib_transaction = require("./transaction.js");
+//#region src/lib/dao.ts
+var require_dao = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	/*!
+	* Module exports class Model
+	*/
+	module.exports = DataAccessObject;
+	/*!
+	* Module dependencies
+	*/
+	const g = require_lib_globalize();
+	const jutil = require_lib_jutil;
+	const ValidationError = require_lib_validations.ValidationError;
+	const Relation = require_lib_relations;
+	const Inclusion = require_lib_include;
+	const List = require_lib_list;
+	const geo = require_lib_geo;
+	const Memory = require_lib_connectors_memory.Memory;
+	const utils = require_lib_utils;
+	utils.fieldsToArray;
+	utils.sanitizeQuery;
+	const setScopeValuesFromWhere = utils.setScopeValuesFromWhere;
+	const idEquals = utils.idEquals;
+	const mergeQuery = utils.mergeQuery;
+	const assert = require("assert");
+	require("debug")("loopback:dao");
+	/**
+	* Base class for all persistent objects.
+	* Provides a common API to access any database connector.
+	* This class describes only abstract behavior.  Refer to the specific connector for additional details.
+	*
+	* `DataAccessObject` mixes `Inclusion` classes methods.
+	* @class DataAccessObject
+	*/
+	function DataAccessObject() {
+		if (DataAccessObject._mixins) {
+			const self = this;
+			const args = arguments;
+			DataAccessObject._mixins.forEach(function(m) {
+				m.call(self, args);
+			});
+		}
+	}
+	function idName(m) {
+		return m.definition.idName() || "id";
+	}
+	function getIdValue(m, data) {
+		return data && data[idName(m)];
+	}
+	function copyData(from, to) {
+		for (const key in from) to[key] = from[key];
+	}
+	function once(fn) {
+		let called = false;
+		return function() {
+			if (called) return;
+			called = true;
+			fn.apply(this, arguments);
+		};
+	}
+	function mapParallel(items, iterator, callback) {
+		if (!items || items.length === 0) return callback(null, []);
+		const results = Array.from({ length: items.length });
+		let pending = items.length;
+		let finished = false;
+		for (let i = 0; i < items.length; i++) {
+			const item = items[i];
+			const index = i;
+			const done = once(function(err, result) {
+				if (finished) return;
+				if (err) {
+					finished = true;
+					return callback(err);
+				}
+				results[index] = result;
+				pending--;
+				if (pending === 0) callback(null, results);
+			});
+			try {
+				iterator(item, done);
+			} catch (err) {
+				done(err);
+			}
+		}
+	}
+	function convertSubsetOfPropertiesByType(inst, data) {
+		const typedData = {};
+		for (const key in data) {
+			typedData[key] = inst[key];
+			if (typeof typedData[key] === "object" && typedData[key] !== null && typeof typedData[key].toObject === "function") typedData[key] = typedData[key].toObject();
+		}
+		return typedData;
+	}
+	/**
+	* Apply strict check for model's data.
+	* Notice: Please note this method modifies `inst` when `strict` is `validate`.
+	*/
+	function applyStrictCheck(model, strict, data, inst, cb) {
+		const props = model.definition.properties;
+		const keys = Object.keys(data);
+		const result = {};
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			if (props[key]) result[key] = data[key];
+			else if (strict && strict !== "filter") inst.__unknownProperties.push(key);
+		}
+		cb(null, result);
+	}
+	function byIdQuery(m, id) {
+		const pk = idName(m);
+		const query = { where: {} };
+		query.where[pk] = id;
+		return query;
+	}
+	function isWhereByGivenId(Model, where, idValue) {
+		const keys = Object.keys(where);
+		if (keys.length != 1) return false;
+		const pk = idName(Model);
+		if (keys[0] !== pk) return false;
+		return where[pk] === idValue;
+	}
+	function errorModelNotFound(idValue) {
+		const msg = g.f("Could not update attributes. {{Object}} with {{id}} %s does not exist!", idValue);
+		const error = new Error(msg);
+		error.statusCode = error.status = 404;
+		return error;
+	}
+	function invokeConnectorMethod(connector, method, Model, args, options, cb) {
+		const dataSource = Model.getDataSource();
+		const opts = dataSource.isTransaction && !options.transaction ? Object.assign(options, { transaction: dataSource.currentTransaction }) : options;
+		const optionsSupported = connector[method].length >= args.length + 3;
+		const transaction = opts.transaction;
+		if (transaction) {
+			if (!optionsSupported) return process.nextTick(function() {
+				cb(new Error(g.f("The connector does not support {{method}} within a transaction", method)));
+			});
+			if (transaction.ensureActive && !transaction.ensureActive(cb)) return;
+		}
+		const modelName = Model.modelName;
+		let fullArgs;
+		if (!optionsSupported && method === "count") fullArgs = [
+			modelName,
+			cb,
+			args[0]
+		];
+		else {
+			fullArgs = [modelName].concat(args);
+			if (optionsSupported) fullArgs.push(opts);
+			fullArgs.push(cb);
+		}
+		connector[method].apply(connector, fullArgs);
+	}
+	DataAccessObject._forDB = function(data) {
+		if (!(this.getDataSource().isRelational && this.getDataSource().isRelational())) return data;
+		const res = {};
+		for (const propName in data) {
+			const type = this.getPropertyType(propName);
+			const value = data[propName];
+			if (value !== null && (type === "JSON" || type === "Any" || type === "Object" || value instanceof Array)) res[propName] = JSON.stringify(value);
+			else res[propName] = value;
+		}
+		return res;
+	};
+	DataAccessObject.defaultScope = function(target, inst) {
+		let scope = this.definition.settings.scope;
+		if (typeof scope === "function") scope = this.definition.settings.scope.call(this, target, inst);
+		return scope;
+	};
+	DataAccessObject.applyScope = function(query, inst) {
+		const scope = this.defaultScope(query, inst) || {};
+		if (typeof scope === "object") mergeQuery(query, scope || {}, this.definition.settings.scope);
+	};
+	DataAccessObject.applyProperties = function(data, inst) {
+		let properties = this.definition.settings.properties;
+		properties = properties || this.definition.settings.attributes;
+		if (typeof properties === "object") Object.assign(data, properties);
+		else if (typeof properties === "function") Object.assign(data, properties.call(this, data, inst) || {});
+		else if (properties !== false) {
+			const scope = this.defaultScope(data, inst) || {};
+			if (typeof scope.where === "object") setScopeValuesFromWhere(data, scope.where, this);
+		}
+	};
+	DataAccessObject.lookupModel = function(_data) {
+		return this;
+	};
+	/**
+	* Get the connector instance for the given model class
+	* @returns {Connector} The connector instance
+	*/
+	DataAccessObject.getConnector = function() {
+		return this.getDataSource().connector;
+	};
+	/**
+	* Create an instance of Model with given data and save to the attached data source. Callback is optional.
+	* Example:
+	*```js
+	* User.create({first: 'Joe', last: 'Bob'}, function(err, user) {
+	*  console.log(user instanceof User); // true
+	* });
+	* ```
+	* Note: You must include a callback and use the created model provided in the callback if your code depends on your model being
+	* saved or having an ID.
+	*
+	* @param {Object} [data] Optional data object
+	* @param {Object} [options] Options for create
+	* @param {Function} [cb]  Callback function called with these arguments:
+	*   - err (null or Error)
+	*   - instance (null or Model)
+	*/
+	DataAccessObject.create = function(data, options, cb) {
+		const connectionPromise = stillConnecting(this.getDataSource(), this, arguments);
+		if (connectionPromise) return connectionPromise;
+		let Model = this;
+		const connector = Model.getConnector();
+		assert(typeof connector.create === "function", "create() must be implemented by the connector");
+		const self = this;
+		if (options === void 0 && cb === void 0) {
+			if (typeof data === "function") {
+				cb = data;
+				data = {};
+			}
+		} else if (cb === void 0) {
+			if (typeof options === "function") {
+				cb = options;
+				options = {};
+			}
+		}
+		data = data || {};
+		options = options || {};
+		cb = cb || utils.createPromiseCallback();
+		assert(typeof data === "object", "The data argument must be an object or array");
+		assert(typeof options === "object", "The options argument must be an object");
+		assert(typeof cb === "function", "The cb argument must be a function");
+		const hookState = {};
+		if (Array.isArray(data)) {
+			for (let i = 0, n = data.length; i < n; i++) if (data[i] === void 0) data[i] = {};
+			mapParallel(data, function(item, done) {
+				self.create(item, options, function(err, result) {
+					done(null, {
+						err,
+						result: result || item
+					});
+				});
+			}, function(err, results) {
+				if (err) return cb(err, results);
+				let errors = null;
+				const data = [];
+				for (let i = 0, n = results.length; i < n; i++) {
+					if (results[i].err) {
+						if (!errors) errors = [];
+						errors[i] = results[i].err;
+					}
+					data[i] = results[i].result;
+				}
+				cb(errors, data);
+			});
+			return cb.promise;
+		}
+		const enforced = {};
+		let obj;
+		const idValue = getIdValue(this, data);
+		try {
+			if (data instanceof Model && !idValue) obj = data;
+			else obj = new Model(data);
+			this.applyProperties(enforced, obj);
+			obj.setAttributes(enforced);
+		} catch (err) {
+			process.nextTick(function() {
+				cb(err);
+			});
+			return cb.promise;
+		}
+		Model = this.lookupModel(data);
+		if (Model !== obj.constructor) obj = new Model(data);
+		let context = {
+			Model,
+			instance: obj,
+			isNewInstance: true,
+			hookState,
+			options
+		};
+		Model.notifyObserversOf("before save", context, function(err) {
+			if (err) return cb(err);
+			data = obj.toObject(true);
+			if (options.validate === false) return create();
+			if (options.validate === void 0 && Model.settings.automaticValidation === false) return create();
+			obj.isValid(function(valid) {
+				if (valid) create();
+				else cb(new ValidationError(obj), obj);
+			}, data, options);
+		});
+		function create() {
+			obj.trigger("create", function(createDone) {
+				obj.trigger("save", function(saveDone) {
+					const _idName = idName(Model);
+					let val = Model._sanitizeData(obj.toObject(true), options);
+					function createCallback(err, id, rev) {
+						if (id) {
+							obj.__data[_idName] = id;
+							defineReadonlyProp(obj, _idName, id);
+						}
+						if (rev) obj._rev = rev;
+						if (err) return cb(err, obj);
+						obj.__persisted = true;
+						const context = {
+							Model,
+							data: val,
+							isNewInstance: true,
+							hookState,
+							options
+						};
+						Model.notifyObserversOf("loaded", context, function(err) {
+							if (err) return cb(err);
+							if (Model.settings.updateOnLoad) obj.setAttributes(context.data);
+							saveDone.call(obj, function() {
+								createDone.call(obj, function() {
+									if (err) return cb(err, obj);
+									const context = {
+										Model,
+										instance: obj,
+										isNewInstance: true,
+										hookState,
+										options
+									};
+									if (options.notify !== false) Model.notifyObserversOf("after save", context, function(err) {
+										cb(err, obj);
+									});
+									else cb(null, obj);
+								});
+							});
+						});
+					}
+					val = applyDefaultsOnWrites(val, Model.definition);
+					context = {
+						Model,
+						data: val,
+						isNewInstance: true,
+						currentInstance: obj,
+						hookState,
+						options
+					};
+					Model.notifyObserversOf("persist", context, function(err, ctx) {
+						if (err) return cb(err);
+						val = ctx.data;
+						invokeConnectorMethod(connector, "create", Model, [obj.constructor._forDB(ctx.data)], options, createCallback);
+					});
+				}, obj, cb);
+			}, obj, cb);
+		}
+		return cb.promise;
+	};
+	/**
+	* Create an instances of Model with given data array and save to the attached data source. Callback is optional.
+	* Example:
+	*```js
+	* User.createAll([{first: 'Joe', last: 'Bob'},{first: 'Tom', last: 'Cat'}], function(err, users) {
+	*  console.log(users[0] instanceof User); // true
+	* });
+	* ```
+	* Note: You must include a callback and use the created models provided in the callback if your code depends on your model being
+	* saved or having an ID.
+	*
+	* @param {Object} [dataArray] Optional data object with array of records
+	* @param {Object} [options] Options for create
+	* @param {Function} [cb]  Callback function called with these arguments:
+	*   - err (null or Error)
+	*   - instance (null or Models)
+	*/
+	DataAccessObject.createAll = function(dataArray, options, cb) {
+		const connectionPromise = stillConnecting(this.getDataSource(), this, arguments);
+		if (connectionPromise) return connectionPromise;
+		let Model = this;
+		const connector = Model.getConnector();
+		if (!connector.multiInsertSupported) return this.create(dataArray, options, cb);
+		assert(typeof connector.createAll === "function", "createAll() must be implemented by the connector");
+		if (options === void 0 && cb === void 0) {
+			if (typeof dataArray === "function") {
+				cb = dataArray;
+				dataArray = [];
+			}
+		} else if (cb === void 0) {
+			if (typeof options === "function") {
+				cb = options;
+				options = {};
+			}
+		}
+		dataArray = dataArray || [];
+		options = options || {};
+		cb = cb || utils.createPromiseCallback();
+		assert(typeof dataArray === "object" && dataArray.length, "The data argument must be an array with length > 0");
+		assert(typeof options === "object", "The options argument must be an object");
+		assert(typeof cb === "function", "The cb argument must be a function");
+		const validationPromises = [];
+		for (let index = 0; index < dataArray.length; index++) {
+			const data = dataArray[index];
+			const hookState = {};
+			const enforced = {};
+			let obj;
+			try {
+				obj = new Model(data);
+				this.applyProperties(enforced, obj);
+				obj.setAttributes(enforced);
+			} catch (err) {
+				process.nextTick(function() {
+					cb(err);
+				});
+				return cb.promise;
+			}
+			Model = this.lookupModel(data);
+			if (Model !== obj.constructor) obj = new Model(data);
+			const context = {
+				Model,
+				instance: obj,
+				isNewInstance: true,
+				hookState,
+				options
+			};
+			const promise = new Promise((resolve, reject) => {
+				Model.notifyObserversOf("before save", context, function(err) {
+					if (err) return reject({
+						error: err,
+						data: obj
+					});
+					const d = obj.toObject(true);
+					if (options.validate === false) return resolve(obj);
+					if (options.validate === void 0 && Model.settings.automaticValidation === false) return resolve(obj);
+					obj.isValid(function(valid) {
+						if (valid) resolve(obj);
+						else reject({
+							error: new ValidationError(obj),
+							data: obj
+						});
+					}, d, options);
+				});
+			});
+			validationPromises.push(promise);
+		}
+		Promise.all(validationPromises).then((objArray) => {
+			const values = [];
+			const valMap = /* @__PURE__ */ new Map();
+			objArray.forEach((obj) => {
+				const val = Model._sanitizeData(obj.toObject(true), options);
+				values.push(val);
+				valMap.set(obj, applyDefaultsOnWrites(val, Model.definition));
+			});
+			const _idName = idName(Model);
+			function createCallback(err, savedArray) {
+				if (err) return cb(err, objArray);
+				const contextArr = savedArray.map((obj, i) => {
+					return {
+						Model,
+						data: obj,
+						isNewInstance: true,
+						hookState: context[i].hookState,
+						options: context[i].options
+					};
+				});
+				Model.notifyObserversOf("loaded", contextArr, function(err) {
+					if (err) return cb(err);
+					const afterSavePromises = [];
+					savedArray.map((obj, i) => {
+						const dataModel = context[i].currentInstance;
+						const id = obj[_idName];
+						if (id) {
+							dataModel.__data[_idName] = id;
+							defineReadonlyProp(dataModel, _idName, id);
+						}
+						dataModel.__persisted = true;
+						if (Model.settings.updateOnLoad) dataModel.setAttributes(obj);
+						const contxt = {
+							Model,
+							instance: dataModel,
+							isNewInstance: true,
+							hookState: context[i].hookState,
+							options: context[i].options
+						};
+						let afterSavePromise;
+						if (options.notify !== false) {
+							afterSavePromise = new Promise((resolve, reject) => {
+								Model.notifyObserversOf("after save", contxt, function(err) {
+									if (err) reject(err);
+									else resolve(dataModel);
+								});
+							});
+							afterSavePromises.push(afterSavePromise);
+						} else afterSavePromises.push(Promise.resolve(dataModel));
+					});
+					Promise.all(afterSavePromises).then((saved) => {
+						cb(null, saved);
+					}).catch((err) => {
+						cb(err, objArray);
+					});
+				});
+			}
+			const context = objArray.map((obj) => {
+				return {
+					Model,
+					data: valMap.get(obj),
+					isNewInstance: true,
+					currentInstance: obj,
+					hookState: {},
+					options
+				};
+			});
+			new Promise((resolve, reject) => {
+				Model.notifyObserversOf("persist", context, function(err, ctx) {
+					if (err) return reject(err);
+					resolve(ctx.map((obj) => {
+						return obj.currentInstance.constructor._forDB(obj.data);
+					}).filter((objData) => !!objData));
+				});
+			}).then((objDataArray) => {
+				invokeConnectorMethod(connector, "createAll", Model, [objDataArray], options, createCallback);
+			}).catch((err) => {
+				if (err) cb(err);
+			});
+		}).catch((err) => {
+			if (err) cb(err.error, err.data);
+		});
+		return cb.promise;
+	};
+	function applyDefaultsOnWrites(obj, modelDefinition) {
+		for (const key in modelDefinition.properties) {
+			const prop = modelDefinition.properties[key];
+			if ("applyDefaultOnWrites" in prop && !prop.applyDefaultOnWrites && prop.default !== void 0 && prop.default === obj[key]) delete obj[key];
+		}
+		return obj;
+	}
+	function stillConnecting(dataSource, obj, args) {
+		if (typeof args[args.length - 1] === "function") return dataSource.ready(obj, args);
+		const promiseArgs = Array.prototype.slice.call(args);
+		promiseArgs.callee = args.callee;
+		const cb = utils.createPromiseCallback();
+		promiseArgs.push(cb);
+		if (dataSource.ready(obj, promiseArgs)) return cb.promise;
+		else return false;
+	}
+	/**
+	* Update or insert a model instance: update exiting record if one is found, such that parameter `data.id` matches `id` of model instance;
+	* otherwise, insert a new record.
+	*
+	* NOTE: No setters, validations, or hooks are applied when using upsert.
+	* `updateOrCreate` and `patchOrCreate` are aliases
+	* @param {Object} data The model instance data
+	* @param {Object} [options] Options for upsert
+	* @param {Function} cb The callback function (optional).
+	*/
+	DataAccessObject.updateOrCreate = DataAccessObject.patchOrCreate = DataAccessObject.upsert = function(data, options, cb) {
+		const connectionPromise = stillConnecting(this.getDataSource(), this, arguments);
+		if (connectionPromise) return connectionPromise;
+		if (options === void 0 && cb === void 0) {
+			if (typeof data === "function") {
+				cb = data;
+				data = {};
+			}
+		} else if (cb === void 0) {
+			if (typeof options === "function") {
+				cb = options;
+				options = {};
+			}
+		}
+		cb = cb || utils.createPromiseCallback();
+		data = data || {};
+		options = options || {};
+		assert(typeof data === "object", "The data argument must be an object");
+		assert(typeof options === "object", "The options argument must be an object");
+		assert(typeof cb === "function", "The cb argument must be a function");
+		if (Array.isArray(data)) {
+			cb(/* @__PURE__ */ new Error("updateOrCreate does not support bulk mode or any array input"));
+			return cb.promise;
+		}
+		const hookState = {};
+		const self = this;
+		let Model = this;
+		const connector = Model.getConnector();
+		const id = getIdValue(this, data);
+		if (id === void 0 || id === null) return this.create(data, options, cb);
+		let doValidate = void 0;
+		if (options.validate === void 0) if (Model.settings.validateUpsert === void 0) {
+			if (Model.settings.automaticValidation !== void 0) doValidate = Model.settings.automaticValidation;
+		} else doValidate = Model.settings.validateUpsert;
+		else doValidate = options.validate;
+		if (this.settings.forceId) {
+			options = Object.create(options);
+			options.validate = !!doValidate;
+			Model.findById(id, options, function(err, model) {
+				if (err) return cb(err);
+				if (!model) return cb(errorModelNotFound(id));
+				model.updateAttributes(data, options, cb);
+			});
+			return cb.promise;
+		}
+		const context = {
+			Model,
+			query: byIdQuery(Model, id),
+			hookState,
+			options
+		};
+		Model.notifyObserversOf("access", context, doUpdateOrCreate);
+		function doUpdateOrCreate(err, ctx) {
+			if (err) return cb(err);
+			const isOriginalQuery = isWhereByGivenId(Model, ctx.query.where, id);
+			if (connector.updateOrCreate && isOriginalQuery) {
+				let context = {
+					Model,
+					where: ctx.query.where,
+					data,
+					hookState,
+					options
+				};
+				Model.notifyObserversOf("before save", context, function(err, ctx) {
+					if (err) return cb(err);
+					data = ctx.data;
+					let update = data;
+					let inst = data;
+					if (!(data instanceof Model)) inst = new Model(data, { applyDefaultValues: false });
+					update = inst.toObject(false);
+					Model.applyProperties(update, inst);
+					Model = Model.lookupModel(update);
+					if (doValidate === false) callConnector();
+					else inst.isValid(function(valid) {
+						if (!valid) if (doValidate) return cb(new ValidationError(inst), inst);
+						else {
+							g.warn("Ignoring validation errors in {{updateOrCreate()}}:");
+							g.warn("  %s", new ValidationError(inst).message);
+						}
+						callConnector();
+					}, update, options);
+					function callConnector() {
+						update = Model._sanitizeData(update, options);
+						context = {
+							Model,
+							where: ctx.where,
+							data: update,
+							currentInstance: inst,
+							hookState: ctx.hookState,
+							options
+						};
+						Model.notifyObserversOf("persist", context, function(err) {
+							if (err) return done(err);
+							invokeConnectorMethod(connector, "updateOrCreate", Model, [update], options, done);
+						});
+					}
+					function done(err, data, info) {
+						if (err) return cb(err);
+						const context = {
+							Model,
+							data,
+							isNewInstance: info && info.isNewInstance,
+							hookState: ctx.hookState,
+							options
+						};
+						Model.notifyObserversOf("loaded", context, function(err) {
+							if (err) return cb(err);
+							let obj;
+							if (data && !(data instanceof Model)) {
+								inst._initProperties(data, { persisted: true });
+								obj = inst;
+							} else obj = data;
+							if (err) cb(err, obj);
+							else {
+								const context = {
+									Model,
+									instance: obj,
+									isNewInstance: info ? info.isNewInstance : void 0,
+									hookState,
+									options
+								};
+								if (options.notify !== false) Model.notifyObserversOf("after save", context, function(err) {
+									cb(err, obj);
+								});
+								else cb(null, obj);
+							}
+						});
+					}
+				});
+			} else {
+				const opts = { notify: false };
+				if (ctx.options && ctx.options.transaction) opts.transaction = ctx.options.transaction;
+				Model.findOne({ where: ctx.query.where }, opts, function(err, inst) {
+					if (err) return cb(err);
+					if (!isOriginalQuery) delete data[idName(Model)];
+					if (inst) inst.updateAttributes(data, options, cb);
+					else {
+						Model = self.lookupModel(data);
+						new Model(data).save(options, cb);
+					}
+				});
+			}
+		}
+		return cb.promise;
+	};
+	/**
+	* Update or insert a model instance based on the search criteria.
+	* If there is a single instance retrieved, update the retrieved model.
+	* Creates a new model if no model instances were found.
+	* Returns an error if multiple instances are found.
+	* @param {Object} [where]  `where` filter, like
+	* ```
+	* { key: val, key2: {gt: 'val2'}, ...}
+	* ```
+	* <br/>see
+	* [Where filter](https://docs.strongloop.com/display/LB/Where+filter#Wherefilter-Whereclauseforothermethods).
+	* @param {Object} data The model instance data to insert.
+	* @callback {Function} callback Callback function called with `cb(err, obj)` signature.
+	* @param {Error} err Error object; see [Error object](http://docs.strongloop.com/display/LB/Error+object).
+	* @param {Object} model Updated model instance.
+	*/
+	DataAccessObject.patchOrCreateWithWhere = DataAccessObject.upsertWithWhere = function(where, data, options, cb) {
+		const connectionPromise = stillConnecting(this.getDataSource(), this, arguments);
+		if (connectionPromise) return connectionPromise;
+		if (cb === void 0) {
+			if (typeof options === "function") {
+				cb = options;
+				options = {};
+			}
+		}
+		cb = cb || utils.createPromiseCallback();
+		options = options || {};
+		assert(typeof where === "object", "The where argument must be an object");
+		assert(typeof data === "object", "The data argument must be an object");
+		assert(typeof options === "object", "The options argument must be an object");
+		assert(typeof cb === "function", "The cb argument must be a function");
+		if (Object.keys(data).length === 0) {
+			const err = /* @__PURE__ */ new Error("data object cannot be empty!");
+			err.statusCode = 400;
+			process.nextTick(function() {
+				cb(err);
+			});
+			return cb.promise;
+		}
+		const hookState = {};
+		const self = this;
+		let Model = this;
+		const connector = Model.getConnector();
+		const query = { where };
+		const context = {
+			Model,
+			query,
+			hookState,
+			options
+		};
+		Model.notifyObserversOf("access", context, doUpsertWithWhere);
+		function doUpsertWithWhere(err, ctx) {
+			if (err) return cb(err);
+			ctx.data = data;
+			if (connector.upsertWithWhere) {
+				let context = {
+					Model,
+					where: ctx.query.where,
+					data: ctx.data,
+					hookState,
+					options
+				};
+				Model.notifyObserversOf("before save", context, function(err, ctx) {
+					if (err) return cb(err);
+					data = ctx.data;
+					let update = data;
+					let inst = data;
+					if (!(data instanceof Model)) inst = new Model(data, { applyDefaultValues: false });
+					update = inst.toObject(false);
+					Model.applyScope(query);
+					Model.applyProperties(update, inst);
+					Model = Model.lookupModel(update);
+					if (options.validate === false) return callConnector();
+					if (options.validate === void 0 && Model.settings.automaticValidation === false) return callConnector();
+					inst.isValid(function(valid) {
+						if (!valid) return cb(new ValidationError(inst), inst);
+						callConnector();
+					}, update, options);
+					function callConnector() {
+						try {
+							ctx.where = Model._sanitizeQuery(ctx.where, options);
+							ctx.where = Model._coerce(ctx.where, options);
+							update = Model._sanitizeData(update, options);
+							update = Model._coerce(update, options);
+						} catch (err) {
+							return process.nextTick(function() {
+								cb(err);
+							});
+						}
+						context = {
+							Model,
+							where: ctx.where,
+							data: update,
+							currentInstance: inst,
+							hookState: ctx.hookState,
+							options
+						};
+						Model.notifyObserversOf("persist", context, function(err) {
+							if (err) return done(err);
+							invokeConnectorMethod(connector, "upsertWithWhere", Model, [ctx.where, update], options, done);
+						});
+					}
+					function done(err, data, info) {
+						if (err) return cb(err);
+						const contxt = {
+							Model,
+							data,
+							isNewInstance: info && info.isNewInstance,
+							hookState: ctx.hookState,
+							options
+						};
+						Model.notifyObserversOf("loaded", contxt, function(err) {
+							if (err) return cb(err);
+							let obj;
+							if (contxt.data && !(contxt.data instanceof Model)) {
+								inst._initProperties(contxt.data, { persisted: true });
+								obj = inst;
+							} else obj = contxt.data;
+							const context = {
+								Model,
+								instance: obj,
+								isNewInstance: info ? info.isNewInstance : void 0,
+								hookState,
+								options
+							};
+							Model.notifyObserversOf("after save", context, function(err) {
+								cb(err, obj);
+							});
+						});
+					}
+				});
+			} else {
+				const opts = { notify: false };
+				if (ctx.options && ctx.options.transaction) opts.transaction = ctx.options.transaction;
+				self.find({ where: ctx.query.where }, opts, function(err, instances) {
+					if (err) return cb(err);
+					const modelsLength = instances.length;
+					if (modelsLength === 0) self.create(data, options, cb);
+					else if (modelsLength === 1) instances[0].updateAttributes(data, options, cb);
+					else process.nextTick(function() {
+						const error = /* @__PURE__ */ new Error("There are multiple instances found.Upsert Operation will not be performed!");
+						error.statusCode = 400;
+						cb(error);
+					});
+				});
+			}
+		}
+		return cb.promise;
+	};
+	/**
+	* Replace or insert a model instance: replace exiting record if one is found, such that parameter `data.id` matches `id` of model instance;
+	* otherwise, insert a new record.
+	*
+	* @param {Object} data The model instance data
+	* @param {Object} [options] Options for replaceOrCreate
+	* @param {Function} cb The callback function (optional).
+	*/
+	DataAccessObject.replaceOrCreate = function replaceOrCreate(data, options, cb) {
+		const connectionPromise = stillConnecting(this.getDataSource(), this, arguments);
+		if (connectionPromise) return connectionPromise;
+		if (cb === void 0) {
+			if (typeof options === "function") {
+				cb = options;
+				options = {};
+			}
+		}
+		cb = cb || utils.createPromiseCallback();
+		data = data || {};
+		options = options || {};
+		assert(typeof data === "object", "The data argument must be an object");
+		assert(typeof options === "object", "The options argument must be an object");
+		assert(typeof cb === "function", "The cb argument must be a function");
+		const hookState = {};
+		const self = this;
+		let Model = this;
+		const connector = Model.getConnector();
+		let id = getIdValue(this, data);
+		if (id === void 0 || id === null) return this.create(data, options, cb);
+		if (this.settings.forceId) return Model.replaceById(id, data, options, cb);
+		let inst;
+		if (data instanceof Model) inst = data;
+		else inst = new Model(data);
+		const strict = inst.__strict;
+		const context = {
+			Model,
+			query: byIdQuery(Model, id),
+			hookState,
+			options
+		};
+		Model.notifyObserversOf("access", context, doReplaceOrCreate);
+		function doReplaceOrCreate(err, ctx) {
+			if (err) return cb(err);
+			const isOriginalQuery = isWhereByGivenId(Model, ctx.query.where, id);
+			const where = ctx.query.where;
+			if (connector.replaceOrCreate && isOriginalQuery) {
+				let context = {
+					Model,
+					instance: inst,
+					hookState,
+					options
+				};
+				Model.notifyObserversOf("before save", context, function(err, ctx) {
+					if (err) return cb(err);
+					let update = inst.toObject(false);
+					if (strict) applyStrictCheck(Model, strict, update, inst, validateAndCallConnector);
+					else validateAndCallConnector();
+					function validateAndCallConnector(err) {
+						if (err) return cb(err);
+						Model.applyProperties(update, inst);
+						Model = Model.lookupModel(update);
+						if (options.validate === false) return callConnector();
+						if (options.validate === void 0 && Model.settings.automaticValidation === false) return callConnector();
+						inst.isValid(function(valid) {
+							if (!valid) return cb(new ValidationError(inst), inst);
+							callConnector();
+						}, update, options);
+						function callConnector() {
+							update = Model._sanitizeData(update, options);
+							context = {
+								Model,
+								where,
+								data: update,
+								currentInstance: inst,
+								hookState: ctx.hookState,
+								options
+							};
+							Model.notifyObserversOf("persist", context, function(err) {
+								if (err) return done(err);
+								invokeConnectorMethod(connector, "replaceOrCreate", Model, [context.data], options, done);
+							});
+						}
+						function done(err, data, info) {
+							if (err) return cb(err);
+							const context = {
+								Model,
+								data,
+								isNewInstance: info ? info.isNewInstance : void 0,
+								hookState: ctx.hookState,
+								options
+							};
+							Model.notifyObserversOf("loaded", context, function(err) {
+								if (err) return cb(err);
+								let obj;
+								if (data && !(data instanceof Model)) {
+									inst._initProperties(data, { persisted: true });
+									obj = inst;
+								} else obj = data;
+								if (err) cb(err, obj);
+								else {
+									const context = {
+										Model,
+										instance: obj,
+										isNewInstance: info ? info.isNewInstance : void 0,
+										hookState,
+										options
+									};
+									Model.notifyObserversOf("after save", context, function(err) {
+										cb(err, obj, info);
+									});
+								}
+							});
+						}
+					}
+				});
+			} else {
+				const opts = { notify: false };
+				if (ctx.options && ctx.options.transaction) opts.transaction = ctx.options.transaction;
+				Model.findOne({ where: ctx.query.where }, opts, function(err, found) {
+					if (err) return cb(err);
+					if (!isOriginalQuery) {
+						const pkName = idName(Model);
+						delete data[pkName];
+						if (found) id = found[pkName];
+					}
+					if (found) self.replaceById(id, data, options, cb);
+					else {
+						Model = self.lookupModel(data);
+						new Model(data).save(options, cb);
+					}
+				});
+			}
+		}
+		return cb.promise;
+	};
+	/**
+	* Find one record that matches specified query criteria.  Same as `find`, but limited to one record, and this function returns an
+	* object, not a collection.
+	* If the specified instance is not found, then create it using data provided as second argument.
+	*
+	* @param {Object} query Search conditions. See [find](#dataaccessobjectfindquery-callback) for query format.
+	* For example: `{where: {test: 'me'}}`.
+	* @param {Object} data Object to create.
+	* @param {Object} [options] Option for findOrCreate
+	* @param {Function} cb Callback called with (err, instance, created)
+	*/
+	DataAccessObject.findOrCreate = function findOrCreate(query, data, options, cb) {
+		const connectionPromise = stillConnecting(this.getDataSource(), this, arguments);
+		if (connectionPromise) return connectionPromise;
+		assert(arguments.length >= 1, "At least one argument is required");
+		if (data === void 0 && options === void 0 && cb === void 0) {
+			assert(typeof query === "object", "Single argument must be data object");
+			data = query;
+			query = { where: data };
+		} else if (options === void 0 && cb === void 0) {
+			if (typeof data === "function") {
+				cb = data;
+				data = query;
+				query = { where: data };
+			}
+		} else if (cb === void 0) {
+			if (typeof options === "function") {
+				cb = options;
+				options = {};
+			}
+		}
+		cb = cb || utils.createPromiseCallback();
+		query = query || { where: {} };
+		data = data || {};
+		options = options || {};
+		assert(typeof query === "object", "The query argument must be an object");
+		assert(typeof data === "object", "The data argument must be an object");
+		assert(typeof options === "object", "The options argument must be an object");
+		assert(typeof cb === "function", "The cb argument must be a function");
+		const hookState = {};
+		const Model = this;
+		const self = this;
+		const connector = Model.getConnector();
+		function _findOrCreate(query, data, currentInstance) {
+			function findOrCreateCallback(err, data, created) {
+				if (err) return cb(err);
+				const context = {
+					Model,
+					data,
+					isNewInstance: created,
+					hookState,
+					options
+				};
+				Model.notifyObserversOf("loaded", context, function(err, ctx) {
+					if (err) return cb(err);
+					data = ctx.data;
+					const Model = self.lookupModel(data);
+					let obj;
+					if (data) {
+						const ctorOpts = {
+							fields: query.fields,
+							applySetters: false,
+							persisted: true,
+							applyDefaultValues: false
+						};
+						obj = new Model(data, ctorOpts);
+					}
+					if (created) {
+						const context = {
+							Model,
+							instance: obj,
+							isNewInstance: true,
+							hookState,
+							options
+						};
+						Model.notifyObserversOf("after save", context, function(err) {
+							if (cb.promise) cb(err, [obj, created]);
+							else cb(err, obj, created);
+						});
+					} else if (cb.promise) cb(err, [obj, created]);
+					else cb(err, obj, created);
+				});
+			}
+			data = Model._sanitizeData(data, options);
+			const context = {
+				Model,
+				where: query.where,
+				data,
+				isNewInstance: true,
+				currentInstance,
+				hookState,
+				options
+			};
+			Model.notifyObserversOf("persist", context, function(err) {
+				if (err) return cb(err);
+				invokeConnectorMethod(connector, "findOrCreate", Model, [query, self._forDB(context.data)], options, findOrCreateCallback);
+			});
+		}
+		if (connector.findOrCreate) {
+			query.limit = 1;
+			try {
+				this._normalize(query, options);
+			} catch (err) {
+				process.nextTick(function() {
+					cb(err);
+				});
+				return cb.promise;
+			}
+			this.applyScope(query);
+			const context = {
+				Model,
+				query,
+				hookState,
+				options
+			};
+			Model.notifyObserversOf("access", context, function(err, ctx) {
+				if (err) return cb(err);
+				const query = ctx.query;
+				const enforced = {};
+				const Model = self.lookupModel(data);
+				const obj = data instanceof Model ? data : new Model(data);
+				Model.applyProperties(enforced, obj);
+				obj.setAttributes(enforced);
+				const context = {
+					Model,
+					instance: obj,
+					isNewInstance: true,
+					hookState,
+					options
+				};
+				Model.notifyObserversOf("before save", context, function(err, ctx) {
+					if (err) return cb(err);
+					const obj = ctx.instance;
+					const data = obj.toObject(true);
+					if (options.validate === false) return _findOrCreate(query, data, obj);
+					if (options.validate === void 0 && Model.settings.automaticValidation === false) return _findOrCreate(query, data, obj);
+					obj.isValid(function(valid) {
+						if (valid) _findOrCreate(query, data, obj);
+						else cb(new ValidationError(obj), obj);
+					}, data, options);
+				});
+			});
+		} else Model.findOne(query, options, function(err, record) {
+			if (err) return cb(err);
+			if (record) if (cb.promise) return cb(null, [record, false]);
+			else return cb(null, record, false);
+			Model.create(data, options, function(err, record) {
+				if (cb.promise) cb(err, [record, record != null]);
+				else cb(err, record, record != null);
+			});
+		});
+		return cb.promise;
+	};
+	/**
+	* Check whether a model instance exists in database
+	*
+	* @param {id} id Identifier of object (primary key value)
+	* @param {Object} [options] Options
+	* @param {Function} cb Callback function called with (err, exists: Bool)
+	*/
+	DataAccessObject.exists = function exists(id, options, cb) {
+		const connectionPromise = stillConnecting(this.getDataSource(), this, arguments);
+		if (connectionPromise) return connectionPromise;
+		assert(arguments.length >= 1, "The id argument is required");
+		if (cb === void 0) {
+			if (typeof options === "function") {
+				cb = options;
+				options = {};
+			}
+		}
+		cb = cb || utils.createPromiseCallback();
+		options = options || {};
+		assert(typeof options === "object", "The options argument must be an object");
+		assert(typeof cb === "function", "The cb argument must be a function");
+		if (id !== void 0 && id !== null && id !== "") this.count(byIdQuery(this, id).where, options, function(err, count) {
+			cb(err, err ? false : count === 1);
+		});
+		else process.nextTick(function() {
+			cb(new Error(g.f("{{Model::exists}} requires the {{id}} argument")));
+		});
+		return cb.promise;
+	};
+	/**
+	* Find model instance by ID.
+	*
+	* Example:
+	* ```js
+	* User.findById(23, function(err, user) {
+	*   console.info(user.id); // 23
+	* });
+	* ```
+	*
+	* @param {*} id Primary key value
+	* @param {Object} [filter] The filter that contains `include` or `fields`.
+	* Other settings such as `where`, `order`, `limit`, or `offset` will be
+	* ignored.
+	* @param {Object} [options] Options
+	* @param {Function} cb Callback called with (err, instance)
+	*/
+	DataAccessObject.findById = function findById(id, filter, options, cb) {
+		const connectionPromise = stillConnecting(this.getDataSource(), this, arguments);
+		if (connectionPromise) return connectionPromise;
+		assert(arguments.length >= 1, "The id argument is required");
+		if (options === void 0 && cb === void 0) {
+			if (typeof filter === "function") {
+				cb = filter;
+				filter = {};
+			}
+		} else if (cb === void 0) {
+			if (typeof options === "function") {
+				cb = options;
+				options = {};
+				if (typeof filter === "object" && !(filter.include || filter.fields)) {
+					options = filter;
+					filter = {};
+				}
+			}
+		}
+		cb = cb || utils.createPromiseCallback();
+		options = options || {};
+		filter = filter || {};
+		assert(typeof filter === "object", "The filter argument must be an object");
+		assert(typeof options === "object", "The options argument must be an object");
+		assert(typeof cb === "function", "The cb argument must be a function");
+		if (isPKMissing(this, cb)) return cb.promise;
+		else if (id == null || id === "") process.nextTick(function() {
+			cb(new Error(g.f("{{Model::findById}} requires the {{id}} argument")));
+		});
+		else {
+			const query = byIdQuery(this, id);
+			if (filter.include) query.include = filter.include;
+			if (filter.fields) query.fields = filter.fields;
+			this.findOne(query, options, cb);
+		}
+		return cb.promise;
+	};
+	/**
+	* Find model instances by ids
+	* @param {Array} ids An array of ids
+	* @param {Object} query Query filter
+	* @param {Object} [options] Options
+	* @param {Function} cb Callback called with (err, instance)
+	*/
+	DataAccessObject.findByIds = function(ids, query, options, cb) {
+		if (options === void 0 && cb === void 0) {
+			if (typeof query === "function") {
+				cb = query;
+				query = {};
+			}
+		} else if (cb === void 0) {
+			if (typeof options === "function") {
+				cb = options;
+				options = {};
+			}
+		}
+		cb = cb || utils.createPromiseCallback();
+		options = options || {};
+		query = query || {};
+		assert(Array.isArray(ids), "The ids argument must be an array");
+		assert(typeof query === "object", "The query argument must be an object");
+		assert(typeof options === "object", "The options argument must be an object");
+		assert(typeof cb === "function", "The cb argument must be a function");
+		if (isPKMissing(this, cb)) return cb.promise;
+		else if (ids.length === 0) {
+			process.nextTick(function() {
+				cb(null, []);
+			});
+			return cb.promise;
+		}
+		const filter = { where: {} };
+		const pk = idName(this);
+		filter.where[pk] = { inq: [].concat(ids) };
+		mergeQuery(filter, query || {});
+		const toSortObjectsByIds = filter.order ? false : true;
+		this.find(filter, options, function(err, results) {
+			cb(err, toSortObjectsByIds ? utils.sortObjectsByIds(pk, ids, results) : results);
+		});
+		return cb.promise;
+	};
+	DataAccessObject.all = function() {
+		return DataAccessObject.find.apply(this, arguments);
+	};
+	/**
+	* Find all instances of Model that match the specified query.
+	* Fields used for filter and sort should be declared with `{index: true}` in model definition.
+	* See [Querying models](http://docs.strongloop.com/display/DOC/Querying+models) for more information.
+	*
+	* For example, find the second page of ten users over age 21 in descending order exluding the password property.
+	*
+	* ```js
+	* User.find({
+	*   where: {
+	*     age: {gt: 21}},
+	*     order: 'age DESC',
+	*     limit: 10,
+	*     skip: 10,
+	*     fields: {password: false}
+	*   },
+	*   console.log
+	* );
+	* ```
+	*
+	* @options {Object} [query] Optional JSON object that specifies query criteria and parameters.
+	* @property {Object} where Search criteria in JSON format `{ key: val, key2: {gt: 'val2'}}`.
+	* Operations:
+	* - gt: >
+	* - gte: >=
+	* - lt: <
+	* - lte: <=
+	* - between
+	* - inq: IN
+	* - nin: NOT IN
+	* - neq: !=
+	* - like: LIKE
+	* - nlike: NOT LIKE
+	* - ilike: ILIKE
+	* - nilike: NOT ILIKE
+	* - regexp: REGEXP
+	*
+	* You can also use `and` and `or` operations.  See [Querying models](http://docs.strongloop.com/display/DOC/Querying+models) for more information.
+	* @property {String|Object|Array} include Allows you to load relations of several objects and optimize numbers of requests.
+	* Format examples;
+	* - `'posts'`: Load posts
+	* - `['posts', 'passports']`: Load posts and passports
+	* - `{'owner': 'posts'}`: Load owner and owner's posts
+	* - `{'owner': ['posts', 'passports']}`: Load owner, owner's posts, and owner's passports
+	* - `{'owner': [{posts: 'images'}, 'passports']}`: Load owner, owner's posts, owner's posts' images, and owner's passports
+	* See `DataAccessObject.include()`.
+	* @property {String} order Sort order.  Format: `'key1 ASC, key2 DESC'`
+	* @property {Number} limit Maximum number of instances to return.
+	* @property {Number} skip Number of instances to skip.
+	* @property {Number} offset Alias for `skip`.
+	* @property {Object|Array|String} fields Included/excluded fields.
+	* - `['foo']` or `'foo'` - include only the foo property
+	*  - `['foo', 'bar']` - include the foo and bar properties.  Format:
+	*  - `{foo: true}` - include only foo
+	* - `{bat: false}` - include all properties, exclude bat
+	*
+	* @param {Function} cb Optional callback function.  Call this function with two arguments: `err` (null or Error) and an array of instances.
+	* @return {Promise} results If no callback function is provided, a promise (which resolves to an array of instances) is returned
+	*/
+	DataAccessObject.find = function find(query, options, cb) {
+		const connectionPromise = stillConnecting(this.getDataSource(), this, arguments);
+		if (connectionPromise) return connectionPromise;
+		if (options === void 0 && cb === void 0) {
+			if (typeof query === "function") {
+				cb = query;
+				query = {};
+			}
+		} else if (cb === void 0) {
+			if (typeof options === "function") {
+				cb = options;
+				options = {};
+			}
+		}
+		cb = cb || utils.createPromiseCallback();
+		query = query || {};
+		options = options || {};
+		assert(typeof query === "object", "The query argument must be an object");
+		assert(typeof options === "object", "The options argument must be an object");
+		assert(typeof cb === "function", "The cb argument must be a function");
+		const hookState = {};
+		const self = this;
+		const connector = self.getConnector();
+		assert(typeof connector.all === "function", "all() must be implemented by the connector");
+		try {
+			this._normalize(query, options);
+		} catch (err) {
+			process.nextTick(function() {
+				cb(err);
+			});
+			return cb.promise;
+		}
+		this.applyScope(query);
+		let near = query && geo.nearFilter(query.where);
+		const supportsGeo = !!connector.buildNearFilter;
+		let geoQueryObject;
+		if (near) {
+			if (supportsGeo) connector.buildNearFilter(query, near);
+			else if (query.where) {
+				if (options.notify === false) queryGeo(query);
+				else withNotifyGeo();
+				function withNotifyGeo() {
+					const context = {
+						Model: self,
+						query,
+						hookState,
+						options
+					};
+					self.notifyObserversOf("access", context, function(err, ctx) {
+						if (err) return cb(err);
+						queryGeo(ctx.query);
+					});
+				}
+				return cb.promise;
+			}
+		}
+		function geoCallback(err, data) {
+			const memory = new Memory();
+			const modelName = self.modelName;
+			if (err) cb(err);
+			else if (Array.isArray(data)) {
+				memory.define({
+					properties: self.dataSource.definitions[modelName].properties,
+					settings: self.dataSource.definitions[modelName].settings,
+					model: self
+				});
+				data.forEach(function(obj) {
+					memory.create(modelName, obj, options, function() {});
+				});
+				memory.all(modelName, geoQueryObject, options, allCb);
+			} else cb(null, []);
+		}
+		function queryGeo(query) {
+			geoQueryObject = query;
+			near = query && geo.nearFilter(query.where);
+			invokeConnectorMethod(connector, "all", self, [{}], options, geoCallback);
+		}
+		function allCb(err, data) {
+			let normalizedIncludes = null;
+			let includedRelationNames = null;
+			if (query && query.include && !query.collect) {
+				normalizedIncludes = Inclusion.normalizeInclude(query.include || []);
+				includedRelationNames = [];
+				for (let i = 0; i < normalizedIncludes.length; i++) {
+					const inc = normalizedIncludes[i];
+					includedRelationNames.push(utils.isPlainObject(inc) ? Object.keys(inc)[0] : inc);
+				}
+			}
+			if (!err && Array.isArray(data)) mapParallel(data, function(item, next) {
+				const Model = self.lookupModel(item);
+				if (options.notify === false) buildResult(item, next);
+				else withNotify(item, next);
+				function buildResult(data, callback) {
+					const ctorOpts = {
+						fields: query.fields,
+						applySetters: false,
+						persisted: true,
+						applyDefaultValues: false
+					};
+					let obj;
+					try {
+						obj = new Model(data, ctorOpts);
+					} catch (err) {
+						return callback(err);
+					}
+					if (query && query.include) if (query.collect) {
+						obj = obj.__cachedRelations[query.collect];
+						if (obj === null) obj = void 0;
+					} else {
+						for (let i = 0; i < includedRelationNames.length; i++) {
+							const relationName = includedRelationNames[i];
+							let included = obj.__cachedRelations[relationName];
+							if (Array.isArray(included)) included = new List(included, null, obj);
+							if (included) obj.__data[relationName] = included;
+						}
+						delete obj.__data.__cachedRelations;
+					}
+					callback(null, obj);
+				}
+				function withNotify(data, callback) {
+					const context = {
+						Model,
+						data,
+						isNewInstance: false,
+						hookState,
+						options
+					};
+					Model.notifyObserversOf("loaded", context, function(err) {
+						if (err) return callback(err);
+						buildResult(context.data, callback);
+					});
+				}
+			}, function(err, results) {
+				if (err) return cb(err);
+				results = results.filter(isDefined);
+				if (data && data.countBeforeLimit) results.countBeforeLimit = data.countBeforeLimit;
+				if (!supportsGeo && near) results = geo.filter(results, near);
+				cb(err, results);
+			});
+			else cb(err, data || []);
+		}
+		if (options.notify === false) invokeConnectorMethod(connector, "all", self, [query], options, allCb);
+		else {
+			const context = {
+				Model: this,
+				query,
+				hookState,
+				options
+			};
+			this.notifyObserversOf("access", context, function(err, ctx) {
+				if (err) return cb(err);
+				invokeConnectorMethod(connector, "all", self, [ctx.query], options, allCb);
+			});
+		}
+		return cb.promise;
+	};
+	function isDefined(value) {
+		return value !== void 0;
+	}
+	/**
+	* Find one record, same as `find`, but limited to one result. This function returns an object, not a collection.
+	*
+	* @param {Object} query Search conditions.  See [find](#dataaccessobjectfindquery-callback) for query format.
+	* For example: `{where: {test: 'me'}}`.
+	* @param {Object} [options] Options
+	* @param {Function} cb Callback function called with (err, instance)
+	*/
+	DataAccessObject.findOne = function findOne(query, options, cb) {
+		const connectionPromise = stillConnecting(this.getDataSource(), this, arguments);
+		if (connectionPromise) return connectionPromise;
+		if (options === void 0 && cb === void 0) {
+			if (typeof query === "function") {
+				cb = query;
+				query = {};
+			}
+		} else if (cb === void 0) {
+			if (typeof options === "function") {
+				cb = options;
+				options = {};
+			}
+		}
+		cb = cb || utils.createPromiseCallback();
+		query = query || {};
+		options = options || {};
+		assert(typeof query === "object", "The query argument must be an object");
+		assert(typeof options === "object", "The options argument must be an object");
+		assert(typeof cb === "function", "The cb argument must be a function");
+		query.limit = 1;
+		this.find(query, options, function(err, collection) {
+			if (err || !collection || !collection.length > 0) return cb(err, null);
+			cb(err, collection[0]);
+		});
+		return cb.promise;
+	};
+	/**
+	* Destroy all matching records.
+	* Delete all model instances from data source. Note: destroyAll method does not destroy hooks.
+	* Example:
+	*````js
+	* Product.destroyAll({price: {gt: 99}}, function(err) {
+	// removed matching products
+	* });
+	* ````
+	*
+	* @param {Object} [where] Optional object that defines the criteria.  This is a "where" object. Do NOT pass a filter object.
+	* @param {Object) [options] Options
+	* @param {Function} [cb] Callback called with (err, info)
+	*/
+	DataAccessObject.remove = DataAccessObject.deleteAll = DataAccessObject.destroyAll = function destroyAll(where, options, cb) {
+		const connectionPromise = stillConnecting(this.getDataSource(), this, arguments);
+		if (connectionPromise) return connectionPromise;
+		const Model = this;
+		const connector = Model.getConnector();
+		assert(typeof connector.destroyAll === "function", "destroyAll() must be implemented by the connector");
+		if (options === void 0 && cb === void 0) {
+			if (typeof where === "function") {
+				cb = where;
+				where = {};
+			}
+		} else if (cb === void 0) {
+			if (typeof options === "function") {
+				cb = options;
+				options = {};
+			}
+		}
+		cb = cb || utils.createPromiseCallback();
+		where = where || {};
+		options = options || {};
+		assert(typeof where === "object", "The where argument must be an object");
+		assert(typeof options === "object", "The options argument must be an object");
+		assert(typeof cb === "function", "The cb argument must be a function");
+		const hookState = {};
+		let query = { where };
+		this.applyScope(query);
+		where = query.where;
+		if (options.notify === false) doDelete(where);
+		else {
+			query = { where: whereIsEmpty(where) ? {} : where };
+			const context = {
+				Model,
+				query,
+				hookState,
+				options
+			};
+			Model.notifyObserversOf("access", context, function(err, ctx) {
+				if (err) return cb(err);
+				const context = {
+					Model,
+					where: ctx.query.where,
+					hookState,
+					options
+				};
+				Model.notifyObserversOf("before delete", context, function(err, ctx) {
+					if (err) return cb(err);
+					doDelete(ctx.where);
+				});
+			});
+		}
+		function doDelete(where) {
+			whereIsEmpty(where);
+			if (whereIsEmpty(where)) invokeConnectorMethod(connector, "destroyAll", Model, [{}], options, done);
+			else {
+				try {
+					where = Model._sanitizeQuery(where, options);
+					where = Model._coerce(where, options);
+				} catch (err) {
+					return process.nextTick(function() {
+						cb(err);
+					});
+				}
+				invokeConnectorMethod(connector, "destroyAll", Model, [where], options, done);
+			}
+			function done(err, info) {
+				if (err) return cb(err);
+				if (options.notify === false) return cb(err, info);
+				const context = {
+					Model,
+					where,
+					hookState,
+					options,
+					info
+				};
+				Model.notifyObserversOf("after delete", context, function(err) {
+					cb(err, info);
+				});
+			}
+		}
+		return cb.promise;
+	};
+	function whereIsEmpty(where) {
+		return !where || typeof where === "object" && Object.keys(where).length === 0;
+	}
+	/**
+	* Delete the record with the specified ID.
+	* Aliases are `destroyById` and `deleteById`.
+	* @param {*} id The id value
+	* @param {Function} cb Callback called with (err)
+	*/
+	DataAccessObject.removeById = DataAccessObject.destroyById = DataAccessObject.deleteById = function deleteById(id, options, cb) {
+		const connectionPromise = stillConnecting(this.getDataSource(), this, arguments);
+		if (connectionPromise) return connectionPromise;
+		assert(arguments.length >= 1, "The id argument is required");
+		if (cb === void 0) {
+			if (typeof options === "function") {
+				cb = options;
+				options = {};
+			}
+		}
+		options = options || {};
+		cb = cb || utils.createPromiseCallback();
+		assert(typeof options === "object", "The options argument must be an object");
+		assert(typeof cb === "function", "The cb argument must be a function");
+		if (isPKMissing(this, cb)) return cb.promise;
+		else if (id == null || id === "") {
+			process.nextTick(function() {
+				cb(new Error(g.f("{{Model::deleteById}} requires the {{id}} argument")));
+			});
+			return cb.promise;
+		}
+		const Model = this;
+		this.remove(byIdQuery(this, id).where, options, function(err, info) {
+			if (err) return cb(err);
+			const deleted = info && info.count > 0;
+			if (Model.settings.strictDelete && !deleted) {
+				err = new Error(g.f("No instance with {{id}} %s found for %s", id, Model.modelName));
+				err.code = "NOT_FOUND";
+				err.statusCode = 404;
+				return cb(err);
+			}
+			cb(null, info);
+		});
+		return cb.promise;
+	};
+	/**
+	* Return count of matched records. Optional query parameter allows you to count filtered set of model instances.
+	* Example:
+	*
+	*```js
+	* User.count({approved: true}, function(err, count) {
+	*     console.log(count); // 2081
+	* });
+	* ```
+	*
+	* @param {Object} [where] Search conditions (optional)
+	* @param {Object} [options] Options
+	* @param {Function} cb Callback, called with (err, count)
+	*/
+	DataAccessObject.count = function(where, options, cb) {
+		const connectionPromise = stillConnecting(this.getDataSource(), this, arguments);
+		if (connectionPromise) return connectionPromise;
+		if (options === void 0 && cb === void 0) {
+			if (typeof where === "function") {
+				cb = where;
+				where = {};
+			}
+		} else if (cb === void 0) {
+			if (typeof options === "function") {
+				cb = options;
+				options = {};
+			}
+		}
+		cb = cb || utils.createPromiseCallback();
+		where = where || {};
+		options = options || {};
+		assert(typeof where === "object", "The where argument must be an object");
+		assert(typeof options === "object", "The options argument must be an object");
+		assert(typeof cb === "function", "The cb argument must be a function");
+		const Model = this;
+		const connector = Model.getConnector();
+		assert(typeof connector.count === "function", "count() must be implemented by the connector");
+		assert(connector.count.length >= 3, "count() must take at least 3 arguments");
+		const hookState = {};
+		const query = { where };
+		this.applyScope(query);
+		where = query.where;
+		try {
+			where = Model._sanitizeQuery(where, options);
+			where = this._coerce(where, options);
+		} catch (err) {
+			process.nextTick(function() {
+				cb(err);
+			});
+			return cb.promise;
+		}
+		const context = {
+			Model,
+			query: { where },
+			hookState,
+			options
+		};
+		this.notifyObserversOf("access", context, function(err, ctx) {
+			if (err) return cb(err);
+			invokeConnectorMethod(connector, "count", Model, [ctx.query.where], options, cb);
+		});
+		return cb.promise;
+	};
+	/**
+	* Save instance. If the instance does not have an ID, call `create` instead.
+	* Triggers: validate, save, update or create.
+	* @options {Object} options Optional options to use.
+	* @property {Boolean} validate Default is true.
+	* @property {Boolean} throws  Default is false.
+	* @param {Function} cb Callback function with err and object arguments
+	*/
+	DataAccessObject.prototype.save = function(options, cb) {
+		const connectionPromise = stillConnecting(this.getDataSource(), this, arguments);
+		if (connectionPromise) return connectionPromise;
+		const Model = this.constructor;
+		if (typeof options === "function") {
+			cb = options;
+			options = {};
+		}
+		cb = cb || utils.createPromiseCallback();
+		options = options || {};
+		assert(typeof options === "object", "The options argument should be an object");
+		assert(typeof cb === "function", "The cb argument should be a function");
+		if (isPKMissing(Model, cb)) return cb.promise;
+		else if (this.isNewRecord()) return Model.create(this, options, cb);
+		const hookState = {};
+		if (options.validate === void 0) if (Model.settings.automaticValidation === void 0) options.validate = true;
+		else options.validate = Model.settings.automaticValidation;
+		if (options.throws === void 0) options.throws = false;
+		const inst = this;
+		const connector = inst.getConnector();
+		let context = {
+			Model,
+			instance: inst,
+			hookState,
+			options
+		};
+		Model.notifyObserversOf("before save", context, function(err) {
+			if (err) return cb(err);
+			let data = inst.toObject(true);
+			Model.applyProperties(data, inst);
+			inst.setAttributes(data);
+			if (!options.validate) return save();
+			inst.isValid(function(valid) {
+				if (valid) save();
+				else {
+					const err = new ValidationError(inst);
+					if (options.throws) throw err;
+					cb(err, inst);
+				}
+			}, data, options);
+			function save() {
+				inst.trigger("save", function(saveDone) {
+					inst.trigger("update", function(updateDone) {
+						data = Model._sanitizeData(data, options);
+						function saveCallback(err, unusedData, result) {
+							if (err) return cb(err, inst);
+							const context = {
+								Model,
+								data,
+								isNewInstance: result && result.isNewInstance,
+								hookState,
+								options
+							};
+							Model.notifyObserversOf("loaded", context, function(err, ctx) {
+								if (err) return cb(err);
+								data = ctx.data;
+								inst._initProperties(data, { persisted: true });
+								const context = {
+									Model,
+									instance: inst,
+									isNewInstance: result && result.isNewInstance,
+									hookState,
+									options
+								};
+								Model.notifyObserversOf("after save", context, function(err) {
+									if (err) return cb(err, inst);
+									updateDone.call(inst, function() {
+										saveDone.call(inst, function() {
+											cb(err, inst);
+										});
+									});
+								});
+							});
+						}
+						context = {
+							Model,
+							data,
+							where: byIdQuery(Model, getIdValue(Model, inst)).where,
+							currentInstance: inst,
+							hookState,
+							options
+						};
+						Model.notifyObserversOf("persist", context, function(err, ctx) {
+							if (err) return cb(err);
+							data = ctx.data;
+							invokeConnectorMethod(connector, "save", Model, [Model._forDB(data)], options, saveCallback);
+						});
+					}, data, cb);
+				}, data, cb);
+			}
+		});
+		return cb.promise;
+	};
+	/**
+	* Update multiple instances that match the where clause
+	*
+	* Example:
+	*
+	*```js
+	* Employee.update({managerId: 'x001'}, {managerId: 'x002'}, function(err) {
+	*     ...
+	* });
+	* ```
+	*
+	* @param {Object} [where] Search conditions (optional)
+	* @param {Object} data Changes to be made
+	* @param {Object} [options] Options for update
+	* @param {Function} cb Callback, called with (err, info)
+	*/
+	DataAccessObject.update = DataAccessObject.updateAll = function(where, data, options, cb) {
+		const connectionPromise = stillConnecting(this.getDataSource(), this, arguments);
+		if (connectionPromise) return connectionPromise;
+		assert(arguments.length >= 1, "At least one argument is required");
+		if (data === void 0 && options === void 0 && cb === void 0 && arguments.length === 1) {
+			data = where;
+			where = {};
+		} else if (options === void 0 && cb === void 0) {
+			if (typeof data === "function") {
+				cb = data;
+				data = where;
+				where = {};
+			}
+		} else if (cb === void 0) {
+			if (typeof options === "function") {
+				cb = options;
+				options = {};
+			}
+		}
+		data = data || {};
+		options = options || {};
+		cb = cb || utils.createPromiseCallback();
+		assert(typeof where === "object", "The where argument must be an object");
+		assert(typeof data === "object", "The data argument must be an object");
+		assert(typeof options === "object", "The options argument must be an object");
+		assert(typeof cb === "function", "The cb argument must be a function");
+		const Model = this;
+		const connector = Model.getDataSource().connector;
+		assert(typeof connector.update === "function", "update() must be implemented by the connector");
+		const hookState = {};
+		const query = { where };
+		this.applyScope(query);
+		this.applyProperties(data);
+		let doValidate = false;
+		if (options.validate === void 0) if (Model.settings.validateUpdate === void 0) {
+			if (Model.settings.automaticValidation !== void 0) doValidate = Model.settings.automaticValidation;
+		} else doValidate = Model.settings.validateUpdate;
+		else doValidate = options.validate;
+		where = query.where;
+		const context = {
+			Model,
+			query: { where },
+			hookState,
+			options
+		};
+		Model.notifyObserversOf("access", context, function(err, ctx) {
+			if (err) return cb(err);
+			const context = {
+				Model,
+				where: ctx.query.where,
+				data,
+				hookState,
+				options
+			};
+			Model.notifyObserversOf("before save", context, function(err, ctx) {
+				if (err) return cb(err);
+				data = ctx.data;
+				let inst = data;
+				if (!(data instanceof Model)) try {
+					inst = new Model(data, { applyDefaultValues: false });
+				} catch (err) {
+					return cb(err);
+				}
+				if (doValidate === false) doUpdate(ctx.where, ctx.data);
+				else inst.isValid(function(valid) {
+					if (!valid) return cb(new ValidationError(inst));
+					doUpdate(ctx.where, ctx.data);
+				}, options);
+			});
+		});
+		function doUpdate(where, data) {
+			try {
+				where = Model._sanitizeQuery(where, options);
+				where = Model._coerce(where, options);
+				data = Model._sanitizeData(data, options);
+				data = Model._coerce(data, options);
+			} catch (err) {
+				return process.nextTick(function() {
+					cb(err);
+				});
+			}
+			function updateCallback(err, info) {
+				if (err) return cb(err);
+				const context = {
+					Model,
+					where,
+					data,
+					hookState,
+					options,
+					info
+				};
+				Model.notifyObserversOf("after save", context, function(err, _ctx) {
+					return cb(err, info);
+				});
+			}
+			const context = {
+				Model,
+				where,
+				data,
+				hookState,
+				options
+			};
+			Model.notifyObserversOf("persist", context, function(err, ctx) {
+				if (err) return cb(err);
+				data = ctx.data;
+				invokeConnectorMethod(connector, "update", Model, [where, Model._forDB(data)], options, updateCallback);
+			});
+		}
+		return cb.promise;
+	};
+	DataAccessObject.prototype.isNewRecord = function() {
+		return !this.__persisted;
+	};
+	/**
+	* Return connector of current record
+	* @private
+	*/
+	DataAccessObject.prototype.getConnector = function() {
+		return this.getDataSource().connector;
+	};
+	/**
+	* Delete object from persistence
+	*
+	* Triggers `destroy` hook (async) before and after destroying object
+	*
+	* @param {Object} [options] Options for delete
+	* @param {Function} cb Callback
+	*/
+	DataAccessObject.prototype.remove = DataAccessObject.prototype.delete = DataAccessObject.prototype.destroy = function(options, cb) {
+		const connectionPromise = stillConnecting(this.getDataSource(), this, arguments);
+		if (connectionPromise) return connectionPromise;
+		if (cb === void 0 && typeof options === "function") {
+			cb = options;
+			options = {};
+		}
+		cb = cb || utils.createPromiseCallback();
+		options = options || {};
+		assert(typeof options === "object", "The options argument should be an object");
+		assert(typeof cb === "function", "The cb argument should be a function");
+		const inst = this;
+		const connector = this.getConnector();
+		const Model = this.constructor;
+		const id = getIdValue(this.constructor, this);
+		const hookState = {};
+		if (isPKMissing(Model, cb)) return cb.promise;
+		const context = {
+			Model,
+			query: byIdQuery(Model, id),
+			hookState,
+			options
+		};
+		Model.notifyObserversOf("access", context, function(err, ctx) {
+			if (err) return cb(err);
+			const context = {
+				Model,
+				where: ctx.query.where,
+				instance: inst,
+				hookState,
+				options
+			};
+			Model.notifyObserversOf("before delete", context, function(err, ctx) {
+				if (err) return cb(err);
+				doDeleteInstance(ctx.where);
+			});
+		});
+		function doDeleteInstance(where) {
+			if (!isWhereByGivenId(Model, where, id)) {
+				Model.deleteAll(where, { notify: false }, function(err, info) {
+					if (err) return cb(err, false);
+					const deleted = info && info.count > 0;
+					if (Model.settings.strictDelete && !deleted) {
+						err = new Error(g.f("No instance with {{id}} %s found for %s", id, Model.modelName));
+						err.code = "NOT_FOUND";
+						err.statusCode = 404;
+						return cb(err, false);
+					}
+					const context = {
+						Model,
+						where,
+						instance: inst,
+						hookState,
+						options,
+						info
+					};
+					Model.notifyObserversOf("after delete", context, function(err) {
+						cb(err, info);
+					});
+				});
+				return;
+			}
+			inst.trigger("destroy", function(destroyed) {
+				function destroyCallback(err, info) {
+					if (err) return cb(err);
+					const deleted = info && info.count > 0;
+					if (Model.settings.strictDelete && !deleted) {
+						err = new Error(g.f("No instance with {{id}} %s found for %s", id, Model.modelName));
+						err.code = "NOT_FOUND";
+						err.statusCode = 404;
+						return cb(err);
+					}
+					destroyed(function() {
+						const context = {
+							Model,
+							where,
+							instance: inst,
+							hookState,
+							options,
+							info
+						};
+						Model.notifyObserversOf("after delete", context, function(err) {
+							cb(err, info);
+						});
+					});
+				}
+				invokeConnectorMethod(connector, "destroy", Model, [id], options, destroyCallback);
+			}, null, cb);
+		}
+		return cb.promise;
+	};
+	/**
+	* Set a single attribute.
+	* Equivalent to `setAttributes({name: value})`
+	*
+	* @param {String} name Name of property
+	* @param {Mixed} value Value of property
+	*/
+	DataAccessObject.prototype.setAttribute = function setAttribute(name, value) {
+		this[name] = value;
+	};
+	/**
+	* Update a single attribute.
+	* Equivalent to `updateAttributes({name: value}, cb)`
+	*
+	* @param {String} name Name of property
+	* @param {Mixed} value Value of property
+	* @param {Function} cb Callback function called with (err, instance)
+	*/
+	DataAccessObject.prototype.updateAttribute = function updateAttribute(name, value, options, cb) {
+		const data = {};
+		data[name] = value;
+		return this.updateAttributes(data, options, cb);
+	};
+	/**
+	* Update set of attributes.
+	*
+	* @trigger `change` hook
+	* @param {Object} data Data to update
+	*/
+	DataAccessObject.prototype.setAttributes = function setAttributes(data) {
+		if (typeof data !== "object") return;
+		this.constructor.applyProperties(data, this);
+		const Model = this.constructor;
+		const inst = this;
+		for (const key in data) inst.setAttribute(key, data[key]);
+		Model.emit("set", inst);
+	};
+	DataAccessObject.prototype.unsetAttribute = function unsetAttribute(name, nullify) {
+		if (nullify || this.constructor.definition.settings.persistUndefinedAsNull) this[name] = this.__data[name] = null;
+		else {
+			delete this[name];
+			delete this.__data[name];
+		}
+	};
+	/**
+	* Replace set of attributes.
+	* Performs validation before replacing.
+	*
+	* @trigger `validation`, `save` and `update` hooks
+	* @param {Object} data Data to replace
+	* @param {Object} [options] Options for replace
+	* @param {Function} cb Callback function called with (err, instance)
+	*/
+	DataAccessObject.prototype.replaceAttributes = function(data, options, cb) {
+		const Model = this.constructor;
+		const id = getIdValue(this.constructor, this);
+		return Model.replaceById(id, data, options, cb);
+	};
+	DataAccessObject.replaceById = function(id, data, options, cb) {
+		const connectionPromise = stillConnecting(this.getDataSource(), this, arguments);
+		if (connectionPromise) return connectionPromise;
+		if (cb === void 0) {
+			if (typeof options === "function") {
+				cb = options;
+				options = {};
+			}
+		}
+		cb = cb || utils.createPromiseCallback();
+		options = options || {};
+		assert(typeof data === "object" && data !== null, "The data argument must be an object");
+		assert(typeof options === "object", "The options argument must be an object");
+		assert(typeof cb === "function", "The cb argument must be a function");
+		const connector = this.getConnector();
+		let err;
+		if (typeof connector.replaceById !== "function") {
+			err = new Error(g.f("The connector %s does not support {{replaceById}} operation. This is not a bug in LoopBack. Please contact the authors of the connector, preferably via GitHub issues.", connector.name));
+			return cb(err);
+		}
+		const pkName = idName(this);
+		if (!data[pkName]) data[pkName] = id;
+		let Model = this;
+		let inst;
+		try {
+			inst = new Model(data, { persisted: true });
+			const enforced = {};
+			this.applyProperties(enforced, inst);
+			inst.setAttributes(enforced);
+		} catch (err) {
+			process.nextTick(function() {
+				cb(err);
+			});
+			return cb.promise;
+		}
+		Model = this.lookupModel(data);
+		if (Model !== inst.constructor) inst = new Model(data);
+		const strict = inst.__strict;
+		if (isPKMissing(Model, cb)) return cb.promise;
+		const hookState = {};
+		if (id !== data[pkName]) {
+			err = new Error(g.f("{{id}} property (%s) cannot be updated from %s to %s", pkName, id, data[pkName]));
+			err.statusCode = 400;
+			process.nextTick(function() {
+				cb(err);
+			});
+			return cb.promise;
+		} else id = inst[pkName];
+		let context = {
+			Model,
+			instance: inst,
+			isNewInstance: false,
+			hookState,
+			options
+		};
+		Model.notifyObserversOf("before save", context, function(err, ctx) {
+			if (err) return cb(err);
+			if (ctx.instance[pkName] !== id && !Model._warned.cannotOverwritePKInBeforeSaveHook) {
+				Model._warned.cannotOverwritePKInBeforeSaveHook = true;
+				g.warn("WARNING: {{id}} property cannot be changed from %s to %s for model:%s in {{'before save'}} operation hook", id, inst[pkName], Model.modelName);
+			}
+			data = inst.toObject(false);
+			if (strict) applyStrictCheck(Model, strict, data, inst, validateAndCallConnector);
+			else validateAndCallConnector(null, data);
+			function validateAndCallConnector(err, data) {
+				if (err) return cb(err);
+				data = Model._sanitizeData(data, options);
+				inst.setAttributes(data);
+				let doValidate = true;
+				if (options.validate === void 0) {
+					if (Model.settings.automaticValidation !== void 0) doValidate = Model.settings.automaticValidation;
+				} else doValidate = options.validate;
+				if (doValidate) inst.isValid(function(valid) {
+					if (!valid) return cb(new ValidationError(inst), inst);
+					callConnector();
+				}, data, options);
+				else callConnector();
+				function callConnector() {
+					copyData(data, inst);
+					const typedData = convertSubsetOfPropertiesByType(inst, data);
+					context.data = typedData;
+					function replaceCallback(err, dbResponse) {
+						if (err) return cb(err);
+						if (typeof connector.generateContextData === "function") context = connector.generateContextData(context, dbResponse);
+						const ctx = {
+							Model,
+							hookState,
+							data: context.data,
+							isNewInstance: false,
+							options
+						};
+						Model.notifyObserversOf("loaded", ctx, function(err) {
+							if (err) return cb(err);
+							if (ctx.data[pkName] !== id && !Model._warned.cannotOverwritePKInLoadedHook) {
+								Model._warned.cannotOverwritePKInLoadedHook = true;
+								g.warn("WARNING: {{id}} property cannot be changed from %s to %s for model:%s in {{'loaded'}} operation hook", id, ctx.data[pkName], Model.modelName);
+							}
+							inst.__persisted = true;
+							ctx.data[pkName] = id;
+							inst.setAttributes(ctx.data);
+							const context = {
+								Model,
+								instance: inst,
+								isNewInstance: false,
+								hookState,
+								options
+							};
+							Model.notifyObserversOf("after save", context, function(err) {
+								cb(err, inst);
+							});
+						});
+					}
+					const ctx = {
+						Model,
+						where: byIdQuery(Model, id).where,
+						data: context.data,
+						isNewInstance: false,
+						currentInstance: inst,
+						hookState,
+						options
+					};
+					Model.notifyObserversOf("persist", ctx, function(err) {
+						if (err) return cb(err);
+						context.data = ctx.data;
+						invokeConnectorMethod(connector, "replaceById", Model, [id, Model._forDB(ctx.data)], options, replaceCallback);
+					});
+				}
+			}
+		});
+		return cb.promise;
+	};
+	/**
+	* Update set of attributes.
+	* Performs validation before updating.
+	* NOTE: `patchOrCreate` is an alias.
+	*
+	* @trigger `validation`, `save` and `update` hooks
+	* @param {Object} data Data to update
+	* @param {Object} [options] Options for updateAttributes
+	* @param {Function} cb Callback function called with (err, instance)
+	*/
+	DataAccessObject.prototype.updateAttributes = DataAccessObject.prototype.patchAttributes = function(data, options, cb) {
+		const self = this;
+		const connectionPromise = stillConnecting(this.getDataSource(), this, arguments);
+		if (connectionPromise) return connectionPromise;
+		if (options === void 0 && cb === void 0) {
+			if (typeof data === "function") {
+				cb = data;
+				data = void 0;
+			}
+		} else if (cb === void 0) {
+			if (typeof options === "function") {
+				cb = options;
+				options = {};
+			}
+		}
+		cb = cb || utils.createPromiseCallback();
+		options = options || {};
+		assert(typeof data === "object" && data !== null, "The data argument must be an object");
+		assert(typeof options === "object", "The options argument must be an object");
+		assert(typeof cb === "function", "The cb argument must be a function");
+		const inst = this;
+		const Model = this.constructor;
+		const connector = inst.getConnector();
+		assert(typeof connector.updateAttributes === "function", "updateAttributes() must be implemented by the connector");
+		if (isPKMissing(Model, cb)) return cb.promise;
+		const allowExtendedOperators = Model._allowExtendedOperators(options);
+		const strict = this.__strict;
+		const hookState = {};
+		if (data instanceof Model) data = data.toObject(false);
+		data = Model._sanitizeData(data, options);
+		const idNames = Model.definition.idNames();
+		for (let i = 0, n = idNames.length; i < n; i++) {
+			const idName = idNames[i];
+			if (data[idName] !== void 0 && !idEquals(data[idName], inst[idName])) {
+				const err = new Error(g.f("{{id}} cannot be updated from %s to %s when {{forceId}} is set to true", inst[idName], data[idName]));
+				err.statusCode = 400;
+				process.nextTick(function() {
+					cb(err);
+				});
+				return cb.promise;
+			}
+		}
+		let context = {
+			Model,
+			where: byIdQuery(Model, getIdValue(Model, inst)).where,
+			data,
+			currentInstance: inst,
+			hookState,
+			options
+		};
+		Model.notifyObserversOf("before save", context, function(err, ctx) {
+			if (err) return cb(err);
+			data = ctx.data;
+			if (strict && !allowExtendedOperators) applyStrictCheck(self.constructor, strict, data, inst, validateAndSave);
+			else validateAndSave(null, data);
+			function validateAndSave(err, data) {
+				if (err) return cb(err);
+				let doValidate = true;
+				if (options.validate === void 0) {
+					if (Model.settings.automaticValidation !== void 0) doValidate = Model.settings.automaticValidation;
+				} else doValidate = options.validate;
+				try {
+					inst.setAttributes(data);
+				} catch (err) {
+					return cb(err);
+				}
+				if (doValidate) inst.isValid(function(valid) {
+					if (!valid) {
+						cb(new ValidationError(inst), inst);
+						return;
+					}
+					triggerSave();
+				}, data, options);
+				else triggerSave();
+				function triggerSave() {
+					inst.trigger("save", function(saveDone) {
+						inst.trigger("update", function(done) {
+							copyData(data, inst);
+							const typedData = convertSubsetOfPropertiesByType(inst, data);
+							context.data = Model._sanitizeData(typedData, options);
+							function updateAttributesCallback(err, dbResponse) {
+								if (err) return cb(err);
+								if (typeof connector.generateContextData === "function") context = connector.generateContextData(context, dbResponse);
+								const ctx = {
+									Model,
+									data: context.data,
+									hookState,
+									options,
+									isNewInstance: false
+								};
+								Model.notifyObserversOf("loaded", ctx, function(err) {
+									if (err) return cb(err);
+									inst.__persisted = true;
+									if (Model.settings.updateOnLoad) inst.setAttributes(ctx.data);
+									done.call(inst, function() {
+										saveDone.call(inst, function() {
+											if (err) return cb(err, inst);
+											const context = {
+												Model,
+												instance: inst,
+												isNewInstance: false,
+												hookState,
+												options
+											};
+											Model.notifyObserversOf("after save", context, function(err) {
+												cb(err, inst);
+											});
+										});
+									});
+								});
+							}
+							const ctx = {
+								Model,
+								where: byIdQuery(Model, getIdValue(Model, inst)).where,
+								data: context.data,
+								currentInstance: inst,
+								isNewInstance: false,
+								hookState,
+								options
+							};
+							Model.notifyObserversOf("persist", ctx, function(err) {
+								if (err) return cb(err);
+								context.data = ctx.data;
+								invokeConnectorMethod(connector, "updateAttributes", Model, [getIdValue(Model, inst), Model._forDB(ctx.data)], options, updateAttributesCallback);
+							});
+						}, data, cb);
+					}, data, cb);
+				}
+			}
+		});
+		return cb.promise;
+	};
+	/**
+	* Reload object from persistence
+	* Requires `id` member of `object` to be able to call `find`
+	* @param {Function} cb Called with (err, instance) arguments
+	* @private
+	*/
+	DataAccessObject.prototype.reload = function reload(cb) {
+		const connectionPromise = stillConnecting(this.getDataSource(), this, arguments);
+		if (connectionPromise) return connectionPromise;
+		return this.constructor.findById(getIdValue(this.constructor, this), cb);
+	};
+	function defineReadonlyProp(obj, key, value) {
+		Object.defineProperty(obj, key, {
+			writable: false,
+			enumerable: true,
+			configurable: true,
+			value
+		});
+	}
+	const defineScope = require_lib_scope.defineScope;
+	/**
+	* Define a scope for the model class. Scopes enable you to specify commonly-used
+	* queries that you can reference as method calls on a model.
+	*
+	* @param {String} name The scope name
+	* @param {Object} query The query object for DataAccessObject.find()
+	* @param {ModelClass} [targetClass] The model class for the query, default to
+	* the declaring model
+	*/
+	DataAccessObject.scope = function(name, query, targetClass, methods, options) {
+		let cls = this;
+		if (options && options.isStatic === false) cls = cls.prototype;
+		return defineScope(cls, targetClass || cls, name, query, methods, options);
+	};
+	jutil.mixin(DataAccessObject, Inclusion);
+	jutil.mixin(DataAccessObject, Relation);
+	jutil.mixin(DataAccessObject, require_lib_transaction);
+	function PKMissingError(modelName) {
+		this.name = "PKMissingError";
+		this.message = "Primary key is missing for the " + modelName + " model";
+	}
+	PKMissingError.prototype = /* @__PURE__ */ new Error();
+	function isPKMissing(modelClass, cb) {
+		if (modelClass.definition.hasPK()) return false;
+		process.nextTick(function() {
+			cb(new PKMissingError(modelClass.modelName));
+		});
+		return true;
+	}
+}));
+//#endregion
+module.exports = require_dao();