@vsaas/loopback-datasource-juggler 10.0.0

package/dist/lib/model-definition.js

@@ -0,0 +1,231 @@
+"use strict";
+const require_runtime = require("../_virtual/_rolldown/runtime.js");
+const require_lib_types = require("./types.js");
+const require_lib_model = require("./model.js");
+const require_lib_model_builder = require("./model-builder.js");
+//#region src/lib/model-definition.ts
+var require_model_definition = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const assert = require("assert");
+	const util = require("util");
+	const EventEmitter = require("events").EventEmitter;
+	const traverse = require("neotraverse/legacy");
+	const ModelBaseClass = require_lib_model;
+	const ModelBuilder = require_lib_model_builder;
+	/**
+	* Model definition
+	*/
+	module.exports = ModelDefinition;
+	/**
+	* Constructor for ModelDefinition
+	* @param {ModelBuilder} modelBuilder A model builder instance
+	* @param {String|Object} name The model name or the schema object
+	* @param {Object} properties The model properties, optional
+	* @param {Object} settings The model settings, optional
+	* @returns {ModelDefinition}
+	* @constructor
+	*
+	*/
+	function ModelDefinition(modelBuilder, name, properties, settings) {
+		if (!(this instanceof ModelDefinition)) return new ModelDefinition(modelBuilder, name, properties, settings);
+		this.modelBuilder = modelBuilder || ModelBuilder.defaultInstance;
+		assert(name, "name is missing");
+		if (arguments.length === 2 && typeof name === "object") {
+			const schema = name;
+			this.name = schema.name;
+			this.rawProperties = schema.properties || {};
+			this.settings = schema.settings || {};
+		} else {
+			assert(typeof name === "string", "name must be a string");
+			this.name = name;
+			this.rawProperties = properties || {};
+			this.settings = settings || {};
+		}
+		this.relations = [];
+		this.properties = null;
+		this.build();
+	}
+	util.inherits(ModelDefinition, EventEmitter);
+	require_lib_types(ModelDefinition);
+	/**
+	* Return table name for specified `modelName`
+	* @param {String} connectorType The connector type, such as 'oracle' or 'mongodb'
+	*/
+	ModelDefinition.prototype.tableName = function(connectorType) {
+		const settings = this.settings;
+		if (settings[connectorType]) return settings[connectorType].table || settings[connectorType].tableName || this.name;
+		else return this.name;
+	};
+	/**
+	* Return column name for specified modelName and propertyName
+	* @param {String} connectorType The connector type, such as 'oracle' or 'mongodb'
+	* @param propertyName The property name
+	* @returns {String} columnName
+	*/
+	ModelDefinition.prototype.columnName = function(connectorType, propertyName) {
+		if (!propertyName) return propertyName;
+		this.build();
+		const property = this.properties[propertyName];
+		if (property && property[connectorType]) return property[connectorType].column || property[connectorType].columnName || propertyName;
+		else return propertyName;
+	};
+	/**
+	* Return column metadata for specified modelName and propertyName
+	* @param {String} connectorType The connector type, such as 'oracle' or 'mongodb'
+	* @param propertyName The property name
+	* @returns {Object} column metadata
+	*/
+	ModelDefinition.prototype.columnMetadata = function(connectorType, propertyName) {
+		if (!propertyName) return propertyName;
+		this.build();
+		const property = this.properties[propertyName];
+		if (property && property[connectorType]) return property[connectorType];
+		else return null;
+	};
+	/**
+	* Return column names for specified modelName
+	* @param {String} connectorType The connector type, such as 'oracle' or 'mongodb'
+	* @returns {String[]} column names
+	*/
+	ModelDefinition.prototype.columnNames = function(connectorType) {
+		this.build();
+		const props = this.properties;
+		const cols = [];
+		for (const p in props) if (props[p][connectorType]) cols.push(props[p][connectorType].column || props[p][connectorType].columnName || p);
+		else cols.push(p);
+		return cols;
+	};
+	/**
+	* Find the ID properties sorted by the index
+	* @returns {Object[]} property name/index for IDs
+	*/
+	ModelDefinition.prototype.ids = function() {
+		if (this._ids) return this._ids;
+		const ids = [];
+		this.build();
+		const props = this.properties;
+		for (const key in props) {
+			let id = props[key].id;
+			if (!id) continue;
+			if (typeof id !== "number") id = 1;
+			ids.push({
+				name: key,
+				id,
+				property: props[key]
+			});
+		}
+		ids.sort(function(a, b) {
+			return a.id - b.id;
+		});
+		this._ids = ids;
+		return ids;
+	};
+	/**
+	* Find the ID column name
+	* @param {String} modelName The model name
+	* @returns {String} columnName for ID
+	*/
+	ModelDefinition.prototype.idColumnName = function(connectorType) {
+		return this.columnName(connectorType, this.idName());
+	};
+	/**
+	* Find the ID property name
+	* @returns {String} property name for ID
+	*/
+	ModelDefinition.prototype.idName = function() {
+		const id = this.ids()[0];
+		if (this.properties.id && this.properties.id.id) return "id";
+		else return id && id.name;
+	};
+	/**
+	* Find the ID property names sorted by the index
+	* @returns {String[]} property names for IDs
+	*/
+	ModelDefinition.prototype.idNames = function() {
+		return this.ids().map(function(id) {
+			return id.name;
+		});
+	};
+	/**
+	*
+	* @returns {{}}
+	*/
+	ModelDefinition.prototype.indexes = function() {
+		this.build();
+		const indexes = {};
+		if (this.settings.indexes) for (const i in this.settings.indexes) indexes[i] = this.settings.indexes[i];
+		for (const p in this.properties) if (this.properties[p].index) indexes[p + "_index"] = this.properties[p].index;
+		return indexes;
+	};
+	/**
+	* Build a model definition
+	* @param {Boolean} force Forcing rebuild
+	*/
+	ModelDefinition.prototype.build = function(forceRebuild) {
+		if (forceRebuild) {
+			this.properties = null;
+			this.relations = [];
+			this._ids = null;
+			this.json = null;
+		}
+		if (this.properties) return this.properties;
+		this.properties = {};
+		for (const p in this.rawProperties) {
+			const prop = this.rawProperties[p];
+			const type = this.modelBuilder.resolveType(prop);
+			if (typeof type === "string") this.relations.push({
+				source: this.name,
+				target: type,
+				type: Array.isArray(prop) ? "hasMany" : "belongsTo",
+				as: p
+			});
+			else {
+				const typeDef = { type };
+				if (typeof prop === "object" && prop !== null) {
+					for (const a in prop) if (a !== "type") typeDef[a] = prop[a];
+				}
+				this.properties[p] = typeDef;
+			}
+		}
+		return this.properties;
+	};
+	/**
+	* Define a property
+	* @param {String} propertyName The property name
+	* @param {Object} propertyDefinition The property definition
+	*/
+	ModelDefinition.prototype.defineProperty = function(propertyName, propertyDefinition) {
+		this.rawProperties[propertyName] = propertyDefinition;
+		this.build(true);
+	};
+	function isModelClass(cls) {
+		if (!cls) return false;
+		return cls.prototype instanceof ModelBaseClass;
+	}
+	ModelDefinition.prototype.toJSON = function(forceRebuild) {
+		if (forceRebuild) this.json = null;
+		if (this.json) return this.json;
+		const json = {
+			name: this.name,
+			properties: {},
+			settings: this.settings
+		};
+		this.build(forceRebuild);
+		const mapper = function(val) {
+			if (val === void 0 || val === null) return val;
+			if ("function" === typeof val.toJSON) return val.toJSON();
+			if ("function" === typeof val) {
+				if (isModelClass(val)) if (val.settings && val.settings.anonymous) return val.definition && val.definition.toJSON().properties;
+				else return val.modelName;
+				return val.name;
+			} else return val;
+		};
+		for (const p in this.properties) json.properties[p] = traverse(this.properties[p]).map(mapper);
+		this.json = json;
+		return json;
+	};
+	ModelDefinition.prototype.hasPK = function() {
+		return this.ids().length > 0;
+	};
+}));
+//#endregion
+module.exports = require_model_definition();

package/dist/lib/model-utils.js

@@ -0,0 +1,368 @@
+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");
+require("./model.js");
+//#region src/lib/model-utils.ts
+var require_model_utils = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	module.exports = ModelUtils;
+	/*!
+	* Module dependencies
+	*/
+	const g = require_lib_globalize();
+	const geo = require_lib_geo;
+	const { fieldsToArray, sanitizeQuery: sanitizeQueryOrData, isPlainObject, isClass, toRegExp } = require_lib_utils;
+	/**
+	* A mixin to contain utility methods for DataAccessObject
+	*/
+	function ModelUtils() {}
+	/**
+	* Verify if allowExtendedOperators is enabled
+	* @options {Object} [options] Optional options to use.
+	* @property {Boolean} allowExtendedOperators.
+	* @returns {Boolean} Returns `true` if allowExtendedOperators is enabled, else `false`.
+	*/
+	ModelUtils._allowExtendedOperators = function(options) {
+		const flag = this._getSetting("allowExtendedOperators", options);
+		if (flag != null) return !!flag;
+		return false;
+	};
+	/**
+	* Get settings via hierarchical determination
+	* - method level options
+	* - model level settings
+	* - data source level settings
+	*
+	* @param {String} key The setting key
+	*/
+	ModelUtils._getSetting = function(key, options) {
+		let val = options && options[key];
+		if (val !== void 0) return val;
+		const m = this.definition;
+		if (m && m.settings) {
+			val = m.settings[key];
+			if (val !== void 0) return m.settings[key];
+		}
+		const ds = this.getDataSource();
+		if (ds && ds.settings) return ds.settings[key];
+	};
+	const operators = {
+		eq: "=",
+		gt: ">",
+		gte: ">=",
+		lt: "<",
+		lte: "<=",
+		between: "BETWEEN",
+		inq: "IN",
+		nin: "NOT IN",
+		neq: "!=",
+		like: "LIKE",
+		nlike: "NOT LIKE",
+		ilike: "ILIKE",
+		nilike: "NOT ILIKE",
+		regexp: "REGEXP"
+	};
+	ModelUtils._normalize = function(filter, options) {
+		if (!filter) return;
+		let err = null;
+		if (typeof filter !== "object" || Array.isArray(filter)) {
+			err = new Error(g.f("The query filter %j is not an {{object}}", filter));
+			err.statusCode = 400;
+			throw err;
+		}
+		if (filter.limit || filter.skip || filter.offset) {
+			const limit = Number(filter.limit || 100);
+			const offset = Number(filter.skip || filter.offset || 0);
+			if (isNaN(limit) || limit <= 0 || Math.ceil(limit) !== limit) {
+				err = new Error(g.f("The {{limit}} parameter %j is not valid", filter.limit));
+				err.statusCode = 400;
+				throw err;
+			}
+			if (isNaN(offset) || offset < 0 || Math.ceil(offset) !== offset) {
+				err = new Error(g.f("The {{offset/skip}} parameter %j is not valid", filter.skip || filter.offset));
+				err.statusCode = 400;
+				throw err;
+			}
+			filter.limit = limit;
+			filter.offset = offset;
+			filter.skip = offset;
+		}
+		if (filter.order) {
+			let order = filter.order;
+			if (!Array.isArray(order)) order = [order];
+			const fields = [];
+			for (let i = 0, m = order.length; i < m; i++) if (typeof order[i] === "string") {
+				const tokens = order[i].split(/(?:\s*,\s*)+/);
+				for (let t = 0, n = tokens.length; t < n; t++) {
+					let token = tokens[t];
+					if (token.length === 0) continue;
+					const parts = token.split(/\s+/);
+					if (parts.length >= 2) {
+						const dir = parts[1].toUpperCase();
+						if (dir === "ASC" || dir === "DESC") token = parts[0] + " " + dir;
+						else {
+							err = new Error(g.f("The {{order}} %j has invalid direction", token));
+							err.statusCode = 400;
+							throw err;
+						}
+					}
+					fields.push(token);
+				}
+			} else {
+				err = new Error(g.f("The order %j is not valid", order[i]));
+				err.statusCode = 400;
+				throw err;
+			}
+			if (fields.length === 1 && typeof filter.order === "string") filter.order = fields[0];
+			else filter.order = fields;
+		}
+		if (filter.fields) filter.fields = fieldsToArray(filter.fields, Object.keys(this.definition.properties), this.settings.strict);
+		filter = this._sanitizeQuery(filter, options);
+		this._coerce(filter.where, options);
+		return filter;
+	};
+	function DateType(arg) {
+		const d = new Date(arg);
+		if (isNaN(d.getTime())) throw new Error(g.f("Invalid date: %s", arg));
+		return d;
+	}
+	function BooleanType(arg) {
+		if (typeof arg === "string") switch (arg) {
+			case "true":
+			case "1": return true;
+			case "false":
+			case "0": return false;
+		}
+		if (arg == null) return null;
+		return Boolean(arg);
+	}
+	function NumberType(val) {
+		const num = Number(val);
+		return !isNaN(num) ? num : val;
+	}
+	function coerceArray(val) {
+		if (Array.isArray(val)) return val;
+		if (!isPlainObject(val)) throw new Error(g.f("Value is not an {{array}} or {{object}} with sequential numeric indices"));
+		const props = Object.keys(val);
+		if (props.length === 0) throw new Error(g.f("Value is an empty {{object}}"));
+		const arrayVal = Array.from({ length: props.length });
+		for (let i = 0; i < arrayVal.length; ++i) {
+			if (!val.hasOwnProperty(i)) throw new Error(g.f("Value is not an {{array}} or {{object}} with sequential numeric indices"));
+			arrayVal[i] = val[i];
+		}
+		return arrayVal;
+	}
+	function _normalizeAsArray(result) {
+		if (typeof result === "string") result = [result];
+		if (Array.isArray(result)) return result;
+		else {
+			const keys = [];
+			for (const k in result) if (result[k]) keys.push(k);
+			return keys;
+		}
+	}
+	/**
+	* Get an array of hidden property names
+	*/
+	ModelUtils._getHiddenProperties = function() {
+		const settings = this.definition.settings || {};
+		return _normalizeAsArray(settings.hiddenProperties || settings.hidden || []);
+	};
+	/**
+	* Get an array of protected property names
+	*/
+	ModelUtils._getProtectedProperties = function() {
+		const settings = this.definition.settings || {};
+		return _normalizeAsArray(settings.protectedProperties || settings.protected || []);
+	};
+	/**
+	* Get the maximum depth of a query object
+	*/
+	ModelUtils._getMaxDepthOfQuery = function(options, defaultValue) {
+		options = options || {};
+		let maxDepth = this._getSetting("maxDepthOfQuery", options);
+		if (maxDepth == null) maxDepth = defaultValue || 32;
+		return +maxDepth;
+	};
+	/**
+	* Get the maximum depth of a data object
+	*/
+	ModelUtils._getMaxDepthOfData = function(options, defaultValue) {
+		options = options || {};
+		let maxDepth = this._getSetting("maxDepthOfData", options);
+		if (maxDepth == null) maxDepth = defaultValue || 64;
+		return +maxDepth;
+	};
+	/**
+	* Get the prohibitHiddenPropertiesInQuery flag
+	*/
+	ModelUtils._getProhibitHiddenPropertiesInQuery = function(options, defaultValue) {
+		const flag = this._getSetting("prohibitHiddenPropertiesInQuery", options);
+		if (flag == null) return !!defaultValue;
+		return !!flag;
+	};
+	/**
+	* Sanitize the query object
+	*/
+	ModelUtils._sanitizeQuery = function(query, options) {
+		options = options || {};
+		const normalizeUndefinedInQuery = this._getSetting("normalizeUndefinedInQuery", options);
+		const prohibitHiddenPropertiesInQuery = this._getProhibitHiddenPropertiesInQuery(options);
+		const maxDepthOfQuery = this._getMaxDepthOfQuery(options);
+		let prohibitedKeys = [];
+		if (prohibitHiddenPropertiesInQuery) {
+			prohibitedKeys = this._getHiddenProperties();
+			if (options.prohibitProtectedPropertiesInQuery) prohibitedKeys = prohibitedKeys.concat(this._getProtectedProperties());
+		}
+		return sanitizeQueryOrData(query, Object.assign({
+			maxDepth: maxDepthOfQuery,
+			prohibitedKeys,
+			normalizeUndefinedInQuery
+		}, options));
+	};
+	/**
+	* Sanitize the data object
+	*/
+	ModelUtils._sanitizeData = function(data, options) {
+		options = options || {};
+		return sanitizeQueryOrData(data, Object.assign({ maxDepth: this._getMaxDepthOfData(options) }, options));
+	};
+	ModelUtils._coerce = function(where, options, modelDef) {
+		const self = this;
+		if (where == null) return where;
+		options = options || {};
+		let err;
+		if (typeof where !== "object" || Array.isArray(where)) {
+			err = new Error(g.f("The where clause %j is not an {{object}}", where));
+			err.statusCode = 400;
+			throw err;
+		}
+		let props;
+		if (modelDef && modelDef.properties) props = modelDef.properties;
+		else props = self.definition.properties;
+		for (const p in where) {
+			if (p === "and" || p === "or" || p === "nor") {
+				let clauses = where[p];
+				try {
+					clauses = coerceArray(clauses);
+				} catch (e) {
+					err = new Error(g.f("The %s operator has invalid clauses %j: %s", p, clauses, e.message));
+					err.statusCode = 400;
+					throw err;
+				}
+				for (let k = 0; k < clauses.length; k++) self._coerce(clauses[k], options);
+				where[p] = clauses;
+				continue;
+			}
+			let DataType = props[p] && props[p].type;
+			if (!DataType) continue;
+			if ((Array.isArray(DataType) || DataType === Array) && !isNestedModel(DataType)) DataType = DataType[0];
+			if (DataType === Date) DataType = DateType;
+			else if (DataType === Boolean) DataType = BooleanType;
+			else if (DataType === Number) DataType = NumberType;
+			if (!DataType) continue;
+			if (DataType === geo.GeoPoint) continue;
+			let val = where[p];
+			if (val === null || val === void 0) continue;
+			let operator = null;
+			const exp = val;
+			if (val.constructor === Object) {
+				for (const op in operators) if (op in val) {
+					val = val[op];
+					operator = op;
+					switch (operator) {
+						case "inq":
+						case "nin":
+						case "between":
+							try {
+								val = coerceArray(val);
+							} catch (e) {
+								err = new Error(g.f("The %s property has invalid clause %j: %s", p, where[p], e));
+								err.statusCode = 400;
+								throw err;
+							}
+							if (operator === "between" && val.length !== 2) {
+								err = new Error(g.f("The %s property has invalid clause %j: Expected precisely 2 values, received %d", p, where[p], val.length));
+								err.statusCode = 400;
+								throw err;
+							}
+							break;
+						case "like":
+						case "nlike":
+						case "ilike":
+						case "nilike":
+							if (!(typeof val === "string" || val instanceof RegExp)) {
+								err = new Error(g.f("The %s property has invalid clause %j: Expected a string or RegExp", p, where[p]));
+								err.statusCode = 400;
+								throw err;
+							}
+							break;
+						case "regexp":
+							val = toRegExp(val);
+							if (val instanceof Error) {
+								val.statusCode = 400;
+								throw val;
+							}
+							break;
+					}
+					break;
+				}
+			}
+			try {
+				val = coerceArray(val);
+			} catch {}
+			const allowExtendedOperators = self._allowExtendedOperators(options);
+			if (Array.isArray(val) && !isNestedModel(DataType)) {
+				for (let i = 0; i < val.length; i++) if (val[i] !== null && val[i] !== void 0) {
+					if (!(val[i] instanceof RegExp)) val[i] = isClass(DataType) ? new DataType(val[i]) : DataType(val[i]);
+				}
+			} else if (val != null) if (operator === null && val instanceof RegExp) operator = "regexp";
+			else if (operator === "regexp" && val instanceof RegExp) {} else if ((operator === "like" || operator === "nlike" || operator === "ilike" || operator === "nilike") && val instanceof RegExp) {} else if (allowExtendedOperators && typeof val === "object") {} else {
+				if (!allowExtendedOperators) {
+					const extendedOperators = Object.keys(val).filter(function(k) {
+						return k[0] === "$";
+					});
+					if (extendedOperators.length) {
+						const msg = g.f("Operators \"" + extendedOperators.join(", ") + "\" are not allowed in query");
+						const err = new Error(msg);
+						err.code = "OPERATOR_NOT_ALLOWED_IN_QUERY";
+						err.statusCode = 400;
+						err.details = {
+							operators: extendedOperators,
+							where
+						};
+						throw err;
+					}
+				}
+				if (isNestedModel(DataType)) {
+					if (Array.isArray(DataType) && Array.isArray(val)) {
+						if (val === null || val === void 0) continue;
+						for (const it of val) self._coerce(it, options, DataType[0].definition);
+					} else self._coerce(val, options, DataType.definition);
+					continue;
+				} else val = isClass(DataType) ? new DataType(val) : DataType(val);
+			}
+			if (operator && operator !== "eq") {
+				const value = {};
+				value[operator] = val;
+				if (exp.options) value.options = exp.options;
+				val = value;
+			}
+			where[p] = val;
+		}
+		return where;
+	};
+	/**
+	* A utility function which checks for nested property definitions
+	*
+	* @param {*} propType Property type metadata
+	*
+	*/
+	function isNestedModel(propType) {
+		if (!propType) return false;
+		if (Array.isArray(propType)) return isNestedModel(propType[0]);
+		return propType.hasOwnProperty("definition") && propType.definition.hasOwnProperty("properties");
+	}
+}));
+//#endregion
+module.exports = require_model_utils();