@vsaas/loopback-datasource-juggler 10.0.0

package/dist/lib/connectors/memory.js

@@ -0,0 +1,810 @@
+"use strict";
+const require_runtime = require("../../_virtual/_rolldown/runtime.js");
+const require_lib_globalize = require("../globalize.js");
+const require_lib_geo = require("../geo.js");
+const require_lib_utils = require("../utils.js");
+//#region src/lib/connectors/memory.ts
+var require_memory = /* @__PURE__ */ require_runtime.__commonJSMin(((exports) => {
+	const g = require_lib_globalize();
+	const util = require("util");
+	const Connector = require("@vsaas/loopback-connector").Connector;
+	const geo = require_lib_geo;
+	const utils = require_lib_utils;
+	const fs = require("fs");
+	const debug = require("debug")("loopback:connector:memory");
+	const hasOwnProperty = Object.prototype.hasOwnProperty;
+	function callbackToPromise(fn) {
+		return new Promise(function(resolve, reject) {
+			fn(function(err, result) {
+				if (err) return reject(err);
+				resolve(result);
+			});
+		});
+	}
+	async function eachSeries(items, iterator) {
+		for (let i = 0; i < items.length; i++) await callbackToPromise(function(done) {
+			iterator(items[i], done);
+		});
+	}
+	async function eachParallel(items, iterator) {
+		await Promise.all(items.map(function(item) {
+			return callbackToPromise(function(done) {
+				iterator(item, done);
+			});
+		}));
+	}
+	function createSerialQueue(worker) {
+		const tasks = [];
+		let running = false;
+		function runNext() {
+			if (running || tasks.length === 0) return;
+			running = true;
+			const task = tasks.shift();
+			let completed = false;
+			function done() {
+				if (completed) return;
+				completed = true;
+				running = false;
+				runNext();
+			}
+			try {
+				worker(task, done);
+			} catch (err) {
+				running = false;
+				(task.callback || function() {})(err);
+				runNext();
+			}
+		}
+		return { push: function(task) {
+			tasks.push(task);
+			runNext();
+		} };
+	}
+	/**
+	* Initialize the Memory connector against the given data source
+	*
+	* @param {DataSource} dataSource The loopback-datasource-juggler dataSource
+	* @param {Function} [callback] The callback function
+	*/
+	exports.initialize = function initializeDataSource(dataSource, callback) {
+		dataSource.connector = new Memory(null, dataSource.settings);
+		dataSource.connect(callback);
+	};
+	exports.Memory = Memory;
+	exports.applyFilter = applyFilter;
+	function Memory(m, settings) {
+		if (m instanceof Memory) {
+			this.isTransaction = true;
+			this.cache = m.cache;
+			this.ids = m.ids;
+			this.constructor.super_.call(this, "memory", settings);
+			this._models = m._models;
+		} else {
+			this.isTransaction = false;
+			this.cache = {};
+			this.ids = {};
+			this.constructor.super_.call(this, "memory", settings);
+		}
+	}
+	util.inherits(Memory, Connector);
+	Memory.prototype.multiInsertSupported = true;
+	Memory.prototype.getDefaultIdType = function() {
+		return Number;
+	};
+	Memory.prototype.getTypes = function() {
+		return [
+			"db",
+			"nosql",
+			"memory"
+		];
+	};
+	Memory.prototype.connect = function(callback) {
+		if (this.isTransaction) this.onTransactionExec = callback;
+		else this.loadFromFile(callback);
+	};
+	function serialize(obj) {
+		if (obj === null || obj === void 0) return obj;
+		return JSON.stringify(obj);
+	}
+	function deserialize(dbObj) {
+		if (dbObj === null || dbObj === void 0) return dbObj;
+		if (typeof dbObj === "string") return JSON.parse(dbObj);
+		else return dbObj;
+	}
+	Memory.prototype.getCollection = function(model) {
+		const modelClass = this._models[model];
+		if (modelClass && modelClass.settings.memory) model = modelClass.settings.memory.collection || model;
+		return model;
+	};
+	Memory.prototype.initCollection = function(model) {
+		this.collection(model, {});
+		this.collectionSeq(model, 1);
+	};
+	Memory.prototype.collection = function(model, val) {
+		model = this.getCollection(model);
+		if (arguments.length > 1) this.cache[model] = val;
+		return this.cache[model];
+	};
+	Memory.prototype.collectionSeq = function(model, val) {
+		model = this.getCollection(model);
+		if (arguments.length > 1) this.ids[model] = val;
+		return this.ids[model];
+	};
+	/**
+	* Create a queue to serialize file read/write operations
+	* @returns {*} The file operation queue
+	*/
+	Memory.prototype.setupFileQueue = function() {
+		const self = this;
+		if (!this.fileQueue) this.fileQueue = createSerialQueue(function(task, done) {
+			const callback = task.callback || function() {};
+			const file = self.settings.file;
+			if (task.operation === "write") {
+				const data = JSON.stringify({
+					ids: self.ids,
+					models: self.cache
+				}, null, "  ");
+				debug("Writing cache to %s: %s", file, data);
+				fs.writeFile(file, data, function(err) {
+					debug("Cache has been written to %s", file);
+					done();
+					callback(err, task.data);
+				});
+			} else if (task.operation === "read") {
+				debug("Reading cache from %s", file);
+				fs.readFile(file, {
+					encoding: "utf8",
+					flag: "r"
+				}, function(err, data) {
+					if (err && err.code !== "ENOENT") {
+						done();
+						callback(err);
+					} else {
+						debug("Cache has been read from %s: %s", file, data);
+						self.parseAndLoad(data, function(err) {
+							done();
+							callback(err);
+						});
+					}
+				});
+			} else {
+				const err = /* @__PURE__ */ new Error("Unknown type of task");
+				done();
+				callback(err);
+			}
+		});
+		return this.fileQueue;
+	};
+	Memory.prototype.parseAndLoad = function(data, callback) {
+		if (data) {
+			try {
+				data = JSON.parse(data.toString());
+			} catch (e) {
+				if (callback) return callback(e);
+				return;
+			}
+			this.ids = data.ids || {};
+			this.cache = data.models || {};
+		} else if (!this.cache) {
+			this.ids = {};
+			this.cache = {};
+		}
+		if (callback) callback();
+	};
+	Memory.prototype.loadFromFile = function(callback) {
+		const localStorage = typeof window !== "undefined" && window.localStorage && this.settings.localStorage;
+		if (this.settings.file) {
+			debug("Queueing read %s", this.settings.file);
+			this.setupFileQueue().push({
+				operation: "read",
+				callback
+			});
+		} else if (localStorage) {
+			let data = window.localStorage.getItem(localStorage);
+			data = data || "{}";
+			this.parseAndLoad(data, callback);
+		} else process.nextTick(callback);
+	};
+	/*!
+	* Flush the cache into the json file if necessary
+	* @param {Function} callback
+	*/
+	Memory.prototype.saveToFile = function(result, callback) {
+		const file = this.settings.file;
+		const localStorage = typeof window !== "undefined" && window.localStorage && this.settings.localStorage;
+		if (file) {
+			debug("Queueing write %s", this.settings.file);
+			this.setupFileQueue().push({
+				operation: "write",
+				data: result,
+				callback
+			});
+		} else if (localStorage) {
+			const data = JSON.stringify({
+				ids: this.ids,
+				models: this.cache
+			}, null, "  ");
+			window.localStorage.setItem(localStorage, data);
+			process.nextTick(function() {
+				if (callback) callback(null, result);
+			});
+		} else process.nextTick(function() {
+			if (callback) callback(null, result);
+		});
+	};
+	Memory.prototype.define = function defineModel(definition) {
+		this.constructor.super_.prototype.define.apply(this, [].slice.call(arguments));
+		const m = definition.model.modelName;
+		if (!this.collection(m)) this.initCollection(m);
+	};
+	Memory.prototype._createSync = function(model, data, fn) {
+		let currentId = this.collectionSeq(model);
+		if (currentId === void 0) currentId = this.collectionSeq(model, 1);
+		let id = this.getIdValue(model, data) || currentId;
+		if (id > currentId) currentId = id;
+		this.collectionSeq(model, Number(currentId) + 1);
+		const props = this._models[model].properties;
+		const idName = this.idName(model);
+		id = props[idName] && props[idName].type && props[idName].type(id) || id;
+		this.setIdValue(model, data, id);
+		if (!this.collection(model)) this.collection(model, {});
+		if (this.collection(model)[id]) {
+			const error = new Error(g.f("Duplicate entry for %s.%s", model, idName));
+			error.statusCode = error.status = 409;
+			return fn(error);
+		}
+		this.collection(model)[id] = serialize(data);
+		fn(null, id);
+	};
+	Memory.prototype.create = function create(model, data, options, callback) {
+		const self = this;
+		this._createSync(model, data, function(err, id) {
+			if (err) return process.nextTick(function() {
+				callback(err);
+			});
+			self.saveToFile(id, callback);
+		});
+	};
+	Memory.prototype.createAll = function create(model, dataArray, options, callback) {
+		const returnArr = [];
+		eachSeries(dataArray, (data, cb) => {
+			this._createSync(model, data, (err, id) => {
+				if (err) return process.nextTick(function() {
+					cb(err);
+				});
+				const returnData = Object.assign({}, data);
+				this.setIdValue(model, returnData, id);
+				returnArr.push(returnData);
+				this.saveToFile(id, cb);
+			});
+		}).then(function() {
+			callback(null, returnArr);
+		}, function(err) {
+			callback(err, returnArr);
+		});
+	};
+	Memory.prototype.updateOrCreate = function(model, data, options, callback) {
+		const self = this;
+		this.exists(model, self.getIdValue(model, data), options, function(err, exists) {
+			if (exists) self.save(model, data, options, function(err, data) {
+				callback(err, data, { isNewInstance: false });
+			});
+			else self.create(model, data, options, function(err, id) {
+				self.setIdValue(model, data, id);
+				callback(err, data, { isNewInstance: true });
+			});
+		});
+	};
+	Memory.prototype.patchOrCreateWithWhere = Memory.prototype.upsertWithWhere = function(model, where, data, options, callback) {
+		const self = this;
+		const primaryKey = this.idName(model);
+		const filter = { where };
+		const nodes = self._findAllSkippingIncludes(model, filter);
+		if (nodes.length === 0) return self._createSync(model, data, function(err, id) {
+			if (err) return process.nextTick(function() {
+				callback(err);
+			});
+			self.saveToFile(id, function(err, id) {
+				self.setIdValue(model, data, id);
+				callback(err, self.fromDb(model, data), { isNewInstance: true });
+			});
+		});
+		if (nodes.length === 1) {
+			const primaryKeyValue = nodes[0][primaryKey];
+			self.updateAttributes(model, primaryKeyValue, data, options, function(err, data) {
+				callback(err, data, { isNewInstance: false });
+			});
+		} else process.nextTick(function() {
+			const error = /* @__PURE__ */ new Error("There are multiple instances found.Upsert Operation will not be performed!");
+			error.statusCode = 400;
+			callback(error);
+		});
+	};
+	Memory.prototype.findOrCreate = function(model, filter, data, options, callback) {
+		const self = this;
+		const nodes = self._findAllSkippingIncludes(model, filter);
+		const found = nodes[0];
+		if (!found) return self._createSync(model, data, function(err, id) {
+			if (err) return callback(err);
+			self.saveToFile(id, function(err, id) {
+				self.setIdValue(model, data, id);
+				callback(err, data, true);
+			});
+		});
+		if (!filter || !filter.include) return process.nextTick(function() {
+			callback(null, found, false);
+		});
+		self._models[model].model.include(nodes[0], filter.include, options, function(err, nodes) {
+			process.nextTick(function() {
+				if (err) return callback(err);
+				callback(null, nodes[0], false);
+			});
+		});
+	};
+	Memory.prototype.save = function save(model, data, options, callback) {
+		const self = this;
+		const id = this.getIdValue(model, data);
+		let modelData = this.collection(model) && this.collection(model)[id];
+		modelData = modelData && deserialize(modelData);
+		if (modelData) data = merge(modelData, data);
+		this.collection(model)[id] = serialize(data);
+		this.saveToFile(data, function(err) {
+			callback(err, self.fromDb(model, data), { isNewInstance: !modelData });
+		});
+	};
+	Memory.prototype.exists = function exists(model, id, options, callback) {
+		process.nextTick(function() {
+			callback(null, this.collection(model) && this.collection(model).hasOwnProperty(id));
+		}.bind(this));
+	};
+	Memory.prototype.find = function find(model, id, options, callback) {
+		process.nextTick(function() {
+			callback(null, id in this.collection(model) && this.fromDb(model, this.collection(model)[id]));
+		}.bind(this));
+	};
+	Memory.prototype.destroy = function destroy(model, id, options, callback) {
+		const exists = this.collection(model)[id];
+		delete this.collection(model)[id];
+		this.saveToFile({ count: exists ? 1 : 0 }, callback);
+	};
+	Memory.prototype.fromDb = function(model, data) {
+		if (!data) return null;
+		data = deserialize(data);
+		const props = this._models[model].properties;
+		for (const key in data) {
+			let val = data[key];
+			if (val === void 0 || val === null) continue;
+			if (props[key]) switch (props[key].type.name) {
+				case "Date":
+					val = new Date(val.toString().replace(/GMT.*$/, "GMT"));
+					break;
+				case "Boolean":
+					val = Boolean(val);
+					break;
+				case "Number":
+					val = Number(val);
+					break;
+			}
+			data[key] = val;
+		}
+		return data;
+	};
+	function getValue(obj, path, keys) {
+		if (obj == null) return;
+		if (!keys) return obj[path];
+		let val = obj;
+		for (let i = 0, n = keys.length; i < n; i++) {
+			val = val[keys[i]];
+			if (val == null) return val;
+		}
+		return val;
+	}
+	function normalizeSortOrders(order) {
+		const rawOrders = typeof order === "string" ? [order] : order;
+		const orders = new Array(rawOrders.length);
+		for (let i = 0; i < rawOrders.length; i++) {
+			let key = rawOrders[i];
+			let reverse = 1;
+			const match = key.match(/\s+(A|DE)SC$/i);
+			if (match) {
+				key = key.replace(/\s+(A|DE)SC/i, "");
+				if (match[1].toLowerCase() === "de") reverse = -1;
+			}
+			orders[i] = {
+				key,
+				keys: key.indexOf(".") === -1 ? null : key.split("."),
+				reverse
+			};
+		}
+		return orders;
+	}
+	function createSorter(orders) {
+		return function sorting(a, b) {
+			let undefinedA;
+			let undefinedB;
+			for (let i = 0, l = orders.length; i < l; i++) {
+				const order = orders[i];
+				const aVal = getValue(a, order.key, order.keys);
+				const bVal = getValue(b, order.key, order.keys);
+				undefinedB = bVal === void 0 && aVal !== void 0;
+				undefinedA = aVal === void 0 && bVal !== void 0;
+				if (undefinedB || aVal > bVal) return order.reverse;
+				else if (undefinedA || aVal < bVal) return -order.reverse;
+			}
+			return 0;
+		};
+	}
+	Memory.prototype._findAllSkippingIncludes = function(model, filter) {
+		const collection = this.collection(model);
+		let nodes = [];
+		for (const key in collection) if (hasOwnProperty.call(collection, key)) nodes.push(this.fromDb(model, collection[key]));
+		if (filter) {
+			let order = filter.order;
+			if (!order) {
+				const idNames = this.idNames(model);
+				if (idNames && idNames.length) order = idNames;
+			}
+			if (order) nodes = nodes.sort(createSorter(normalizeSortOrders(order)));
+			const nearFilter = geo.nearFilter(filter.where);
+			if (nearFilter) nodes = geo.filter(nodes, nearFilter);
+			if (filter.where && nodes.length > 0) {
+				const predicate = applyFilter(filter);
+				const filteredNodes = [];
+				for (let i = 0; i < nodes.length; i++) if (predicate(nodes[i])) filteredNodes.push(nodes[i]);
+				nodes = filteredNodes;
+			}
+			if (filter.fields) {
+				const selectFields = utils.selectFields(filter.fields);
+				const selectedNodes = new Array(nodes.length);
+				for (let i = 0; i < nodes.length; i++) selectedNodes[i] = selectFields(nodes[i]);
+				nodes = selectedNodes;
+			}
+			const skip = filter.skip || filter.offset || 0;
+			const limit = filter.limit || nodes.length;
+			if (skip !== 0 || limit < nodes.length) nodes = nodes.slice(skip, skip + limit);
+		}
+		return nodes;
+	};
+	Memory.prototype.all = function all(model, filter, options, callback) {
+		const self = this;
+		const nodes = self._findAllSkippingIncludes(model, filter);
+		process.nextTick(function() {
+			if (filter && filter.include) self._models[model].model.include(nodes, filter.include, options, callback);
+			else callback(null, nodes);
+		});
+	};
+	function applyFilter(filter) {
+		const where = filter.where;
+		if (typeof where === "function") return where;
+		return createWherePredicate(where);
+	}
+	function createWherePredicate(where) {
+		const keys = Object.keys(where);
+		const predicates = new Array(keys.length);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			const value = where[key];
+			if ((key === "and" || key === "or") && Array.isArray(value)) {
+				const nestedPredicates = new Array(value.length);
+				for (let j = 0; j < value.length; j++) nestedPredicates[j] = createWherePredicate(value[j]);
+				predicates[i] = key === "and" ? function(obj) {
+					for (let j = 0; j < nestedPredicates.length; j++) if (!nestedPredicates[j](obj)) return false;
+					return true;
+				} : function(obj) {
+					for (let j = 0; j < nestedPredicates.length; j++) if (nestedPredicates[j](obj)) return true;
+					return false;
+				};
+				continue;
+			}
+			predicates[i] = createPropertyPredicate(key, value);
+		}
+		if (predicates.length === 1) return predicates[0];
+		return function(obj) {
+			for (let i = 0; i < predicates.length; i++) if (!predicates[i](obj)) return false;
+			return true;
+		};
+	}
+	function createPropertyPredicate(key, matcher) {
+		const dotIndex = key.indexOf(".");
+		const keyPath = dotIndex === -1 ? null : key.split(".");
+		const matchValue = createValueMatcher(matcher);
+		let subPredicate;
+		let subKey;
+		if (dotIndex !== -1) {
+			subKey = key.substring(0, dotIndex);
+			const nestedWhere = {};
+			nestedWhere[key.substring(dotIndex + 1)] = matcher;
+			subPredicate = createWherePredicate(nestedWhere);
+		}
+		return function(obj) {
+			const value = getValue(obj, key, keyPath);
+			if (Array.isArray(value)) {
+				if (matcher && typeof matcher === "object" && matcher !== null && matcher.neq !== void 0) {
+					if (value.length <= 0) return true;
+				}
+				for (let i = 0; i < value.length; i++) if (matchValue(value[i])) return true;
+				return false;
+			}
+			if (matchValue(value)) return true;
+			if (!subPredicate) return false;
+			const subValue = obj[subKey];
+			if (Array.isArray(subValue)) {
+				for (let i = 0; i < subValue.length; i++) if (subPredicate(subValue[i])) return true;
+				return false;
+			}
+			if (typeof subValue === "object" && subValue !== null) return subPredicate(subValue);
+			return false;
+		};
+	}
+	function likeToRegExp(pattern) {
+		if (pattern instanceof RegExp) return pattern;
+		let regex = "";
+		pattern = pattern.replace(/([.*+?^=!:${}()|[\]/\\])/g, "\\$1");
+		for (let i = 0, n = pattern.length; i < n; i++) {
+			const char = pattern.charAt(i);
+			if (char === "\\") {
+				i++;
+				if (i < n) regex += pattern.charAt(i);
+				continue;
+			} else if (char === "%") regex += ".*";
+			else if (char === "_") regex += ".";
+			else if (char === ".") regex += "\\.";
+			else if (char === "*") regex += "\\*";
+			else regex += char;
+		}
+		return regex;
+	}
+	function createValueMatcher(example) {
+		if (example instanceof RegExp) return function(value) {
+			return typeof value === "string" ? value.match(example) : false;
+		};
+		if (example == null) return function(value) {
+			return value == null;
+		};
+		if (typeof example === "object" && example !== null) {
+			if (example.regexp) {
+				const regexp = example.regexp;
+				return function(value) {
+					return value ? value.match(regexp) : false;
+				};
+			}
+			if (example.near) return function() {
+				return true;
+			};
+			if (example.inq) {
+				const inq = example.inq;
+				return function(value) {
+					for (let i = 0; i < inq.length; i++) if (inq[i] == value) return true;
+					return false;
+				};
+			}
+			if (example.nin) {
+				const nin = example.nin;
+				return function(value) {
+					for (let i = 0; i < nin.length; i++) if (nin[i] == value) return false;
+					return true;
+				};
+			}
+			if ("neq" in example) {
+				const neq = example.neq;
+				return function(value) {
+					return compare(neq, value) !== 0;
+				};
+			}
+			if ("between" in example) {
+				const lower = example.between[0];
+				const upper = example.between[1];
+				return function(value) {
+					return compare(value, lower) >= 0 && compare(value, upper) <= 0;
+				};
+			}
+			if (example.like || example.nlike || example.ilike || example.nilike) {
+				let like = example.like || example.nlike || example.ilike || example.nilike;
+				if (typeof like === "string") like = likeToRegExp(like);
+				const regexp = example.ilike || example.nilike ? new RegExp(like, "i") : new RegExp(like);
+				const negate = !!(example.nlike || example.nilike);
+				return function(value) {
+					regexp.lastIndex = 0;
+					const matches = regexp.test(value);
+					return negate ? !matches : matches;
+				};
+			}
+			const inequalityMatcher = createInequalityMatcher(example);
+			if (inequalityMatcher) return inequalityMatcher;
+		}
+		if (example instanceof Date) return function(value) {
+			if (value instanceof Date) return example.getTime() === value.getTime();
+			return example == value;
+		};
+		return function(value) {
+			return example == value;
+		};
+	}
+	function createInequalityMatcher(example) {
+		if ("gt" in example) {
+			const gt = example.gt;
+			return function(value) {
+				return compare(value, gt) > 0;
+			};
+		}
+		if ("gte" in example) {
+			const gte = example.gte;
+			return function(value) {
+				return compare(value, gte) >= 0;
+			};
+		}
+		if ("lt" in example) {
+			const lt = example.lt;
+			return function(value) {
+				return compare(value, lt) < 0;
+			};
+		}
+		if ("lte" in example) {
+			const lte = example.lte;
+			return function(value) {
+				return compare(value, lte) <= 0;
+			};
+		}
+		return null;
+	}
+	function compare(val1, val2) {
+		if (val1 == null || val2 == null) return val1 == val2 ? 0 : NaN;
+		if (typeof val1 === "number") return val1 - val2;
+		if (typeof val1 === "string") return val1 > val2 ? 1 : val1 < val2 ? -1 : val1 == val2 ? 0 : NaN;
+		if (typeof val1 === "boolean") return val1 - val2;
+		if (val1 instanceof Date) return val1 - val2;
+		return val1 == val2 ? 0 : NaN;
+	}
+	Memory.prototype.destroyAll = function destroyAll(model, where, options, callback) {
+		const cache = this.collection(model);
+		let count = 0;
+		if (where) {
+			const filter = applyFilter({ where });
+			for (const id in cache) if (hasOwnProperty.call(cache, id) && filter(this.fromDb(model, cache[id]))) {
+				count++;
+				delete cache[id];
+			}
+		} else {
+			for (const id in cache) if (hasOwnProperty.call(cache, id)) count++;
+			this.collection(model, {});
+		}
+		this.saveToFile({ count }, callback);
+	};
+	Memory.prototype.count = function count(model, where, options, callback) {
+		const cache = this.collection(model);
+		let count = 0;
+		if (where) {
+			const filter = applyFilter({ where });
+			for (const id in cache) if (hasOwnProperty.call(cache, id) && filter(this.fromDb(model, cache[id]))) count++;
+		} else for (const id in cache) if (hasOwnProperty.call(cache, id)) count++;
+		process.nextTick(function() {
+			callback(null, count);
+		});
+	};
+	Memory.prototype.update = Memory.prototype.updateAll = function updateAll(model, where, data, options, cb) {
+		const self = this;
+		const cache = this.collection(model);
+		let filter = null;
+		where = where || {};
+		filter = applyFilter({ where });
+		const ids = Object.keys(cache);
+		let count = 0;
+		eachParallel(ids, function(id, done) {
+			const inst = self.fromDb(model, cache[id]);
+			if (!filter || filter(inst)) {
+				count++;
+				id = self.getIdValue(model, inst);
+				self.updateAttributes(model, id, data, options, done);
+			} else process.nextTick(done);
+		}).then(function() {
+			self.saveToFile({ count }, cb);
+		}, function(err) {
+			if (err) return cb(err);
+		});
+	};
+	Memory.prototype.updateAttributes = function updateAttributes(model, id, data, options, cb) {
+		if (!id) {
+			const err = new Error(g.f("You must provide an {{id}} when updating attributes!"));
+			if (cb) return cb(err);
+			else throw err;
+		}
+		data = Object.create(data);
+		this.setIdValue(model, data, id);
+		if (this.collection(model) && this.collection(model)[id]) this.save(model, data, options, cb);
+		else {
+			const msg = g.f("Could not update attributes. {{Object}} with {{id}} %s does not exist!", id);
+			const error = new Error(msg);
+			error.statusCode = error.status = 404;
+			cb(error);
+		}
+	};
+	Memory.prototype.replaceById = function(model, id, data, options, cb) {
+		const self = this;
+		if (!id) {
+			const err = new Error(g.f("You must provide an {{id}} when replacing!"));
+			return process.nextTick(function() {
+				cb(err);
+			});
+		}
+		data = Object.create(data);
+		this.setIdValue(model, data, id);
+		if (!(this.collection(model) && this.collection(model)[id])) {
+			const msg = "Could not replace. Object with id " + id + " does not exist!";
+			const error = new Error(msg);
+			error.statusCode = error.status = 404;
+			return process.nextTick(function() {
+				cb(error);
+			});
+		}
+		const newModelData = {};
+		for (const key in data) {
+			const val = data[key];
+			if (typeof val === "function") continue;
+			newModelData[key] = val;
+		}
+		this.collection(model)[id] = serialize(newModelData);
+		this.saveToFile(newModelData, function(err) {
+			cb(err, self.fromDb(model, newModelData));
+		});
+	};
+	Memory.prototype.replaceOrCreate = function(model, data, options, callback) {
+		const self = this;
+		const idName = self.idNames(model)[0];
+		const idValue = self.getIdValue(model, data);
+		const filter = { where: {} };
+		filter.where[idName] = idValue;
+		if (!self._findAllSkippingIncludes(model, filter)[0]) return self._createSync(model, data, function(err, id) {
+			if (err) return process.nextTick(function() {
+				callback(err);
+			});
+			self.saveToFile(id, function(err, id) {
+				self.setIdValue(model, data, id);
+				callback(err, self.fromDb(model, data), { isNewInstance: true });
+			});
+		});
+		const id = self.getIdValue(model, data);
+		self.collection(model)[id] = serialize(data);
+		self.saveToFile(data, function(err) {
+			callback(err, self.fromDb(model, data), { isNewInstance: false });
+		});
+	};
+	Memory.prototype.transaction = function() {
+		return new Memory(this);
+	};
+	Memory.prototype.exec = function(callback) {
+		this.onTransactionExec();
+		setTimeout(callback, 50);
+	};
+	Memory.prototype.buildNearFilter = function(_filter) {};
+	Memory.prototype.automigrate = function(models, cb) {
+		const self = this;
+		if (!cb && "function" === typeof models) {
+			cb = models;
+			models = void 0;
+		}
+		if ("string" === typeof models) models = [models];
+		models = models || Object.keys(self._models);
+		if (models.length === 0) return process.nextTick(cb);
+		const invalidModels = models.filter(function(m) {
+			return !(m in self._models);
+		});
+		if (invalidModels.length) return process.nextTick(function() {
+			cb(new Error(g.f("Cannot migrate models not attached to this datasource: %s", invalidModels.join(" "))));
+		});
+		models.forEach(function(m) {
+			self.initCollection(m);
+		});
+		if (cb) process.nextTick(cb);
+	};
+	function merge(base, update) {
+		if (!base) return update;
+		for (const key in update) {
+			const val = update[key];
+			if (typeof val === "function") continue;
+			base[key] = val;
+		}
+		return base;
+	}
+}));
+//#endregion
+module.exports = require_memory();