@vsaas/loopback-datasource-juggler 10.0.0

package/dist/lib/utils.js

@@ -0,0 +1,625 @@
+"use strict";
+const require_runtime = require("../_virtual/_rolldown/runtime.js");
+const require_lib_globalize = require("./globalize.js");
+//#region src/lib/utils.ts
+var require_utils = /* @__PURE__ */ require_runtime.__commonJSMin(((exports) => {
+	exports.safeRequire = safeRequire;
+	exports.fieldsToArray = fieldsToArray;
+	exports.selectFields = selectFields;
+	exports.sanitizeQuery = sanitizeQuery;
+	exports.parseSettings = parseSettings;
+	exports.mergeSettings = exports.deepMerge = deepMerge;
+	exports.deepMergeProperty = deepMergeProperty;
+	exports.isPlainObject = isPlainObject;
+	exports.defineCachedRelations = defineCachedRelations;
+	exports.sortObjectsByIds = sortObjectsByIds;
+	exports.setScopeValuesFromWhere = setScopeValuesFromWhere;
+	exports.mergeQuery = mergeQuery;
+	exports.mergeIncludes = mergeIncludes;
+	exports.createPromiseCallback = createPromiseCallback;
+	exports.uniq = uniq;
+	exports.toRegExp = toRegExp;
+	exports.hasRegExpFlags = hasRegExpFlags;
+	exports.idEquals = idEquals;
+	exports.findIndexOf = findIndexOf;
+	exports.collectTargetIds = collectTargetIds;
+	exports.idName = idName;
+	exports.rankArrayElements = rankArrayElements;
+	exports.idsHaveDuplicates = idsHaveDuplicates;
+	exports.isClass = isClass;
+	exports.escapeRegExp = escapeRegExp;
+	exports.applyParentProperty = applyParentProperty;
+	const g = require_lib_globalize();
+	const traverse = require("neotraverse/legacy");
+	const assert = require("assert");
+	const debug = require("debug")("loopback:juggler:utils");
+	/**
+	* The name of the property in modelBuilder settings that will enable the child parent reference functionality
+	* @type {string}
+	*/
+	const BUILDER_PARENT_SETTING = "parentRef";
+	/**
+	* The property name that should be defined on each child instance if parent feature flag enabled
+	* @type {string}
+	*/
+	const PARENT_PROPERTY_NAME = "__parent";
+	const REGEXP_OPERATORS = new Set([
+		"like",
+		"nlike",
+		"ilike",
+		"nilike",
+		"regexp"
+	]);
+	function safeRequire(module$1) {
+		try {
+			return require(module$1);
+		} catch {
+			g.log("Run \"{{npm install loopback-datasource-juggler}} %s\" command ", "to use {{loopback-datasource-juggler}} using %s database engine", module$1, module$1);
+			process.exit(1);
+		}
+	}
+	function setScopeValuesFromWhere(data, where, targetModel) {
+		for (const i in where) {
+			if (i === "and") {
+				for (let w = 0, n = where[i].length; w < n; w++) setScopeValuesFromWhere(data, where[i][w], targetModel);
+				continue;
+			}
+			const prop = targetModel.definition.properties[i];
+			if (prop) {
+				const val = where[i];
+				if (typeof val !== "object" || val instanceof prop.type || prop.type.name === "ObjectID" || prop.type.name === "uuidFromString") data[i] = where[i];
+			}
+		}
+	}
+	/**
+	* Merge include options of default scope with runtime include option.
+	* exhibits the _.extend behaviour. Property value of source overrides
+	* property value of destination if property name collision occurs
+	* @param {String|Array|Object} destination The default value of `include` option
+	* @param {String|Array|Object} source The runtime value of `include` option
+	* @returns {Object}
+	*/
+	function mergeIncludes(destination, source) {
+		const destArray = convertToArray(destination);
+		const sourceArray = convertToArray(source);
+		if (destArray.length === 0) return sourceArray;
+		if (sourceArray.length === 0) return destArray;
+		const relationNames = [];
+		const resultArray = [];
+		for (const j in sourceArray) {
+			const sourceEntry = sourceArray[j];
+			const sourceEntryRelationName = typeof (sourceEntry.rel || sourceEntry.relation) === "string" ? sourceEntry.relation : Object.keys(sourceEntry)[0];
+			relationNames.push(sourceEntryRelationName);
+			resultArray.push(sourceEntry);
+		}
+		for (const i in destArray) {
+			const destEntry = destArray[i];
+			const destEntryRelationName = typeof (destEntry.rel || destEntry.relation) === "string" ? destEntry.relation : Object.keys(destEntry)[0];
+			if (relationNames.indexOf(destEntryRelationName) === -1) resultArray.push(destEntry);
+		}
+		return resultArray;
+	}
+	/**
+	* Converts input parameter into array of objects which wraps the value.
+	* "someValue" is converted to [{"someValue":true}]
+	* ["someValue"] is converted to [{"someValue":true}]
+	* {"someValue":true} is converted to [{"someValue":true}]
+	* @param {String|Array|Object} param - Input parameter to be converted
+	* @returns {Array}
+	*/
+	function convertToArray(include) {
+		if (typeof include === "string") {
+			const obj = {};
+			obj[include] = true;
+			return [obj];
+		} else if (isPlainObject(include)) {
+			if (include.rel || include.relation) return [include];
+			const newInclude = [];
+			for (const key in include) {
+				const obj = {};
+				obj[key] = include[key];
+				newInclude.push(obj);
+			}
+			return newInclude;
+		} else if (Array.isArray(include)) {
+			const normalized = [];
+			for (const i in include) {
+				const includeEntry = include[i];
+				if (typeof includeEntry === "string") {
+					const obj = {};
+					obj[includeEntry] = true;
+					normalized.push(obj);
+				} else normalized.push(includeEntry);
+			}
+			return normalized;
+		}
+		return [];
+	}
+	/*!
+	* Merge query parameters
+	* @param {Object} base The base object to contain the merged results
+	* @param {Object} update The object containing updates to be merged
+	* @param {Object} spec Optionally specifies parameters to exclude (set to false)
+	* @returns {*|Object} The base object
+	* @private
+	*/
+	function mergeQuery(base, update, spec) {
+		if (!update) return;
+		spec = spec || {};
+		base = base || {};
+		if (update.where && Object.keys(update.where).length > 0) if (base.where && Object.keys(base.where).length > 0) base.where = { and: [base.where, update.where] };
+		else base.where = update.where;
+		if (spec.include !== false && update.include) if (!base.include) base.include = update.include;
+		else if (spec.nestedInclude === true) {
+			const saved = base.include;
+			base.include = {};
+			base.include[update.include] = saved;
+		} else base.include = mergeIncludes(base.include, update.include);
+		if (spec.collect !== false && update.collect) base.collect = update.collect;
+		if (spec.fields !== false && update.fields !== void 0) base.fields = update.fields;
+		else if (update.fields !== void 0) base.fields = [].concat(base.fields).concat(update.fields);
+		if ((!base.order || spec.order === false) && update.order) base.order = update.order;
+		if (spec.limit !== false && update.limit !== void 0) base.limit = update.limit;
+		const skip = spec.skip !== false && spec.offset !== false;
+		if (skip && update.skip !== void 0) base.skip = update.skip;
+		if (skip && update.offset !== void 0) base.offset = update.offset;
+		return base;
+	}
+	/**
+	* Normalize fields to an array of included properties
+	* @param {String|String[]|Object} fields Fields filter
+	* @param {String[]} properties Property names
+	* @param {Boolean} excludeUnknown To exclude fields that are unknown properties
+	* @returns {String[]} An array of included property names
+	*/
+	function fieldsToArray(fields, properties, excludeUnknown) {
+		if (!fields) return;
+		let result = properties;
+		let i, n;
+		if (typeof fields === "string") result = [fields];
+		else if (Array.isArray(fields) && fields.length > 0) result = fields;
+		else if ("object" === typeof fields) {
+			const included = [];
+			const excluded = [];
+			const keys = Object.keys(fields);
+			if (!keys.length) return;
+			for (i = 0, n = keys.length; i < n; i++) {
+				const k = keys[i];
+				if (fields[k]) included.push(k);
+				else if (k in fields && !fields[k]) excluded.push(k);
+			}
+			if (included.length > 0) result = included;
+			else if (excluded.length > 0) for (i = 0, n = excluded.length; i < n; i++) {
+				const index = result.indexOf(excluded[i]);
+				if (index !== -1) result.splice(index, 1);
+			}
+		}
+		let fieldArray = [];
+		if (excludeUnknown) {
+			for (i = 0, n = result.length; i < n; i++) if (properties.indexOf(result[i]) !== -1) fieldArray.push(result[i]);
+		} else fieldArray = result;
+		return fieldArray;
+	}
+	function selectFields(fields) {
+		return function(obj) {
+			const result = {};
+			let key;
+			for (let i = 0; i < fields.length; i++) {
+				key = fields[i];
+				result[key] = obj[key];
+			}
+			return result;
+		};
+	}
+	function isProhibited(key, prohibitedKeys) {
+		if (!prohibitedKeys || !prohibitedKeys.length) return false;
+		if (typeof key !== "string") return false;
+		const keySegments = key.indexOf(".") === -1 ? null : key.split(".");
+		for (const k of prohibitedKeys) {
+			if (k === key) return true;
+			if (keySegments && keySegments.indexOf(k) !== -1) return true;
+		}
+		return false;
+	}
+	/**
+	* Accept an operator key and return whether it is used for a regular expression query or not
+	* @param {string} operator
+	* @returns {boolean}
+	*/
+	function isRegExpOperator(operator) {
+		return REGEXP_OPERATORS.has(operator);
+	}
+	/**
+	* Accept a RegExp string and make sure that any special characters for RegExp are escaped in case they
+	* create an invalid Regexp
+	* @param {string} str
+	* @returns {string}
+	*/
+	function escapeRegExp(str) {
+		assert.strictEqual(typeof str, "string", "String required for regexp escaping");
+		try {
+			new RegExp(str);
+			return str;
+		} catch {
+			console.warn("Auto-escaping invalid RegExp value %j supplied by the caller. Please note this behavior may change in the future.", str);
+			return str.replace(/[-[\]/{}()+?.\\^$|]/g, "\\$&");
+		}
+	}
+	/**
+	* Sanitize the query object
+	* @param query {object} The query object
+	* @param options
+	* @property normalizeUndefinedInQuery {String} either "nullify", "throw" or "ignore" (default: "ignore")
+	* @property prohibitedKeys {String[]} An array of prohibited keys to be removed
+	* @returns {*}
+	*/
+	function sanitizeQuery(query, options) {
+		debug("Sanitizing query object: %j", query);
+		if (typeof query !== "object" || query === null) return query;
+		options = options || {};
+		if (typeof options === "string") options = { normalizeUndefinedInQuery: options };
+		const prohibitedKeys = options.prohibitedKeys;
+		const offendingKeys = [];
+		const normalizeUndefinedInQuery = options.normalizeUndefinedInQuery;
+		const maxDepth = options.maxDepth || Number.MAX_SAFE_INTEGER;
+		const result = traverse(query).forEach(function(x) {
+			/**
+			* Security risk if the client passes in a very deep where object
+			*/
+			if (this.circular) {
+				const msg = g.f("The query object is circular");
+				const err = new Error(msg);
+				err.statusCode = 400;
+				err.code = "QUERY_OBJECT_IS_CIRCULAR";
+				throw err;
+			}
+			if (this.level > maxDepth) {
+				const msg = g.f("The query object exceeds maximum depth %d", maxDepth);
+				const err = new Error(msg);
+				err.statusCode = 400;
+				err.code = "QUERY_OBJECT_TOO_DEEP";
+				throw err;
+			}
+			/**
+			* Make sure prohibited keys are removed from the query to prevent
+			* sensitive values from being guessed
+			*/
+			if (isProhibited(this.key, prohibitedKeys)) {
+				offendingKeys.push(this.key);
+				this.remove();
+				return;
+			}
+			/**
+			* Handle undefined values
+			*/
+			if (x === void 0) switch (normalizeUndefinedInQuery) {
+				case "nullify":
+					this.update(null);
+					break;
+				case "throw": throw new Error(g.f("Unexpected `undefined` in query"));
+				default: this.remove();
+			}
+			if (!Array.isArray(x) && typeof x === "object" && x !== null && x.constructor !== Object) {
+				this.update(x, true);
+				return x;
+			}
+			if (isRegExpOperator(this.key) && typeof x === "string") return escapeRegExp(x);
+			return x;
+		});
+		if (offendingKeys.length) console.error(g.f("Potential security alert: hidden/protected properties %j are used in query.", offendingKeys));
+		return result;
+	}
+	const url = require("url");
+	const qs = require("qs");
+	/**
+	* Parse a URL into a settings object
+	* @param {String} urlStr The URL for connector settings
+	* @returns {Object} The settings object
+	*/
+	function parseSettings(urlStr) {
+		if (!urlStr) return {};
+		const uri = url.parse(urlStr, false);
+		const settings = {};
+		settings.connector = uri.protocol && uri.protocol.split(":")[0];
+		settings.host = settings.hostname = uri.hostname;
+		settings.port = uri.port && Number(uri.port);
+		settings.user = settings.username = uri.auth && uri.auth.split(":")[0];
+		settings.password = uri.auth && uri.auth.split(":")[1];
+		settings.database = uri.pathname && uri.pathname.split("/")[1];
+		settings.url = urlStr;
+		if (uri.query) {
+			const params = qs.parse(uri.query);
+			for (const p in params) settings[p] = params[p];
+		}
+		return settings;
+	}
+	/**
+	* Objects deep merge
+	*
+	* Forked from https://github.com/nrf110/deepmerge/blob/master/index.js
+	*
+	* The original function tries to merge array items if they are objects, this
+	* was changed to always push new items in arrays, independently of their type.
+	*
+	* NOTE: The function operates as a deep clone when called with a single object
+	* argument.
+	*
+	* @param {Object} base The base object
+	* @param {Object} extras The object to merge with base
+	* @returns {Object} The merged object
+	*/
+	function deepMerge(base, extras) {
+		const array = Array.isArray(base) && (Array.isArray(extras) || !extras);
+		let dst = array && [] || {};
+		if (array) {
+			extras = extras || [];
+			dst = base.slice();
+			const seen = new Set(dst);
+			for (let i = 0; i < extras.length; i++) {
+				const extraItem = extras[i];
+				if (seen.has(extraItem)) continue;
+				seen.add(extraItem);
+				dst.push(extraItem);
+			}
+		} else {
+			if (base != null && typeof base === "object") {
+				const baseKeys = Object.keys(base);
+				for (let i = 0; i < baseKeys.length; i++) {
+					const key = baseKeys[i];
+					if (base[key] && typeof base[key] === "object") dst[key] = deepMerge(base[key]);
+					else dst[key] = base[key];
+				}
+			}
+			if (extras != null && typeof extras === "object") {
+				const extraKeys = Object.keys(extras);
+				for (let i = 0; i < extraKeys.length; i++) {
+					const key = extraKeys[i];
+					const extra = extras[key];
+					if (extra == null || typeof extra !== "object") dst[key] = extra;
+					else if (base == null || typeof base !== "object" || base[key] == null) dst[key] = extra;
+					else dst[key] = deepMerge(base[key], extra);
+				}
+			}
+		}
+		return dst;
+	}
+	/**
+	* Properties deep merge
+	* Similar as deepMerge but also works on single properties of any type
+	*
+	* @param {Object} base The base property
+	* @param {Object} extras The property to merge with base
+	* @returns {Object} The merged property
+	*/
+	function deepMergeProperty(base, extras) {
+		return deepMerge({ key: base }, { key: extras }).key;
+	}
+	const numberIsFinite = Number.isFinite || function(value) {
+		return typeof value === "number" && isFinite(value);
+	};
+	/**
+	* Adds a property __rank to array elements of type object {}
+	* If an inner element already has the __rank property it is not altered
+	* NOTE: the function mutates the provided array
+	*
+	* @param array The original array
+	* @param rank The rank to apply to array elements
+	* @return rankedArray The original array with newly ranked elements
+	*/
+	function rankArrayElements(array, rank) {
+		if (!Array.isArray(array) || !numberIsFinite(rank)) return array;
+		for (let i = 0, n = array.length; i < n; i++) {
+			const el = array[i];
+			if (!el || typeof el != "object" || Array.isArray(el)) continue;
+			if (el.__rank) continue;
+			Object.defineProperty(el, "__rank", {
+				writable: false,
+				enumerable: false,
+				configurable: false,
+				value: rank
+			});
+		}
+		return array;
+	}
+	/**
+	* Define an non-enumerable __cachedRelations property
+	* @param {Object} obj The obj to receive the __cachedRelations
+	*/
+	function defineCachedRelations(obj) {
+		if (!obj.__cachedRelations) Object.defineProperty(obj, "__cachedRelations", {
+			writable: true,
+			enumerable: false,
+			configurable: true,
+			value: {}
+		});
+	}
+	/**
+	* Check if the argument is plain object
+	* @param {*} obj The obj value
+	* @returns {boolean}
+	*/
+	function isPlainObject(obj) {
+		return typeof obj === "object" && obj !== null && obj.constructor === Object;
+	}
+	function sortObjectsByIds(idName, ids, objects, strict) {
+		ids = ids.map(function(id) {
+			return typeof id === "object" ? String(id) : id;
+		});
+		const ranks = /* @__PURE__ */ new Map();
+		for (let i = 0; i < ids.length; i++) if (!ranks.has(ids[i])) ranks.set(ids[i], i);
+		const heading = [];
+		const tailing = [];
+		objects.forEach(function(x) {
+			if (typeof x === "object") {
+				const id = typeof x[idName] === "object" ? String(x[idName]) : x[idName];
+				const idx = ranks.has(id) ? ranks.get(id) : -1;
+				if (strict && idx === -1) return;
+				if (idx === -1) tailing.push(x);
+				else heading.push({
+					idx,
+					value: x
+				});
+			}
+		});
+		heading.sort(function(x, y) {
+			return x.idx - y.idx;
+		});
+		const sorted = Array.from({ length: heading.length + tailing.length });
+		for (let i = 0; i < heading.length; i++) sorted[i] = heading[i].value;
+		for (let i = 0; i < tailing.length; i++) sorted[heading.length + i] = tailing[i];
+		return sorted;
+	}
+	function createPromiseCallback() {
+		let cb;
+		const promise = new Promise(function(resolve, reject) {
+			cb = function(err, data) {
+				if (err) return reject(err);
+				return resolve(data);
+			};
+		});
+		cb.promise = promise;
+		return cb;
+	}
+	function isBsonType(value) {
+		return value.hasOwnProperty("_bsontype") || value.constructor.prototype.hasOwnProperty("_bsontype");
+	}
+	/**
+	* Dedupe an array
+	* @param {Array} an array
+	* @returns {Array} an array with unique items
+	*/
+	function uniq(a) {
+		const uniqArray = [];
+		if (!a) return uniqArray;
+		assert(Array.isArray(a), "array argument is required");
+		const seen = /* @__PURE__ */ new Set();
+		for (let i = 0, n = a.length; i < n; i++) {
+			const item = a[i];
+			const comparable = isBsonType(item) ? item.toString() : item;
+			if (seen.has(comparable)) continue;
+			seen.add(comparable);
+			uniqArray.push(item);
+		}
+		return uniqArray;
+	}
+	/**
+	* Converts a string, regex literal, or a RegExp object to a RegExp object.
+	* @param {String|Object} The string, regex literal, or RegExp object to convert
+	* @returns {Object} A RegExp object
+	*/
+	function toRegExp(regex) {
+		const isString = typeof regex === "string";
+		const isRegExp = regex instanceof RegExp;
+		if (!(isString || isRegExp)) return new Error(g.f("Invalid argument, must be a string, {{regex}} literal, or {{RegExp}} object"));
+		if (isRegExp) return regex;
+		if (!hasRegExpFlags(regex)) return new RegExp(regex);
+		const flags = regex.split("/").pop().split("");
+		const validFlags = [
+			"i",
+			"g",
+			"m"
+		];
+		const invalidFlags = [];
+		flags.forEach(function(flag) {
+			if (validFlags.indexOf(flag) === -1) invalidFlags.push(flag);
+		});
+		if (invalidFlags.length > 0) return new Error(g.f("Invalid {{regex}} flags: %s", invalidFlags));
+		const expression = regex.substr(1, regex.lastIndexOf("/") - 1);
+		return new RegExp(expression, flags.join(""));
+	}
+	function hasRegExpFlags(regex) {
+		return regex instanceof RegExp ? regex.toString().split("/").pop() : !!regex.match(/.*\/.+$/);
+	}
+	function idEquals(id1, id2) {
+		if (id1 === id2) return true;
+		if (typeof id1 === "number" && typeof id2 === "string" || typeof id1 === "string" && typeof id2 === "number") return id1 == id2;
+		id1 = JSON.stringify(id1);
+		id2 = JSON.stringify(id2);
+		if (id1 === id2) return true;
+		return false;
+	}
+	function findIndexOf(arr, target, isEqual) {
+		if (!isEqual) return arr.indexOf(target);
+		for (let i = 0; i < arr.length; i++) if (isEqual(arr[i], target)) return i;
+		return -1;
+	}
+	/**
+	* Returns an object that queries targetIds.
+	* @param {Array} The array of targetData
+	* @param {String} The Id property name of target model
+	* @returns {Object} The object that queries targetIds
+	*/
+	function collectTargetIds(targetData, idPropertyName) {
+		const targetIds = [];
+		for (let i = 0; i < targetData.length; i++) {
+			const targetId = targetData[i][idPropertyName];
+			targetIds.push(targetId);
+		}
+		return { inq: uniq(targetIds) };
+	}
+	/**
+	* Find the idKey of a Model.
+	* @param {ModelConstructor} m - Model Constructor
+	* @returns {String}
+	*/
+	function idName(m) {
+		return m.definition.idName() || "id";
+	}
+	/**
+	* Check a list of IDs to see if there are any duplicates.
+	*
+	* @param {Array} The array of IDs to check
+	* @returns {boolean} If any duplicates were found
+	*/
+	function idsHaveDuplicates(ids) {
+		let hasDuplicates = void 0;
+		let i, j;
+		if (typeof Set === "function") {
+			const uniqueIds = /* @__PURE__ */ new Set();
+			for (i = 0; i < ids.length; ++i) {
+				const idType = typeof ids[i];
+				if (idType === "string" || idType === "number") if (uniqueIds.has(ids[i])) {
+					hasDuplicates = true;
+					break;
+				} else uniqueIds.add(ids[i]);
+				else break;
+			}
+			if (hasDuplicates === void 0 && uniqueIds.size === ids.length) hasDuplicates = false;
+		}
+		if (hasDuplicates === void 0) {
+			for (i = 0; i < ids.length && hasDuplicates === void 0; ++i) for (j = 0; j < i; ++j) if (idEquals(ids[i], ids[j])) {
+				hasDuplicates = true;
+				break;
+			}
+		}
+		return hasDuplicates === true;
+	}
+	function isClass(fn) {
+		return fn && fn.toString().startsWith("class ");
+	}
+	/**
+	* Accept an element, and attach the __parent property to it, unless no object given, while also
+	* making sure to check for already created properties
+	*
+	* @param {object} element
+	* @param {Model} parent
+	*/
+	function applyParentProperty(element, parent) {
+		assert.strictEqual(typeof element, "object", "Non object element given to assign parent");
+		const { constructor: { modelBuilder: { settings: builderSettings } = {} } = {} } = element;
+		if (!builderSettings || !builderSettings[BUILDER_PARENT_SETTING]) return;
+		if (element.hasOwnProperty(PARENT_PROPERTY_NAME)) {
+			const existingParent = element[PARENT_PROPERTY_NAME];
+			if (existingParent && existingParent !== parent) g.warn(`Re-assigning child model instance to another parent than the original!
+Although supported, this is not a recommended practice: ${element.constructor.name} -> ${parent.constructor.name}\nYou should create an independent copy of the child model using \`new Model(CHILD)\` OR \`new Model(CHILD.toJSON())\` and assign to new parent`);
+			element[PARENT_PROPERTY_NAME] = parent;
+		} else Object.defineProperty(element, PARENT_PROPERTY_NAME, {
+			value: parent,
+			writable: true,
+			enumerable: false,
+			configurable: false
+		});
+	}
+}));
+//#endregion
+module.exports = require_utils();