@vsaas/loopback-datasource-juggler 10.0.0

package/dist/lib/date-string.js

@@ -0,0 +1,87 @@
+"use strict";
+//#region src/lib/date-string.ts
+var require_date_string = /* @__PURE__ */ require("../_virtual/_rolldown/runtime.js").__commonJSMin(((exports, module) => {
+	const inspect = require("util").inspect;
+	module.exports = DateString;
+	/**
+	* A String whose value is a valid representation of a Date.
+	* Use this type if you need to preserve the format of the value and still
+	* check if it's valid.
+	* Example:
+	* ```js
+	* var loopback = require('loopback');
+	* var dt = new loopback.DateString('2001-01-01');
+	*
+	* dt.toString();
+	* // '2001-01-01'
+	* dt._date.toISOString();
+	* // '2001-01-01T00:00:00.000Z'
+	* ```
+	*
+	* You can use this definition on your models as well:
+	* ```json
+	* {
+	*   "name": "Person",
+	*   "base": "PersistedModel",
+	*   "properties": {
+	*     "name": {
+	*       "type": "string"
+	*     },
+	*     "dob": {
+	*       "type": "DateString",
+	*       "required": true
+	*     },
+	*   },
+	*   "validations": [],
+	*   "relations": {},
+	*   "acls": [],
+	*   "methods": {}
+	* }
+	* ```
+	* @class DateString
+	* @param {String} value
+	* @constructor
+	*/
+	function DateString(value) {
+		if (!(this instanceof DateString)) return new DateString(value);
+		if (value instanceof DateString) value = value.when;
+		if (typeof value !== "string") throw new Error("Input must be a string");
+		Object.defineProperty(this, "when", {
+			get: () => {
+				return this._when;
+			},
+			set: (val) => {
+				const d = new Date(val);
+				if (isNaN(d.getTime())) throw new Error("Invalid date");
+				else {
+					this._when = val;
+					this._date = d;
+				}
+			}
+		});
+		this.when = value;
+	}
+	/**
+	* Returns the value of DateString in its original form.
+	* @returns {String} The Date as a String.
+	*/
+	DateString.prototype.toString = function() {
+		return this.when;
+	};
+	/**
+	* Returns the JSON representation of the DateString object.
+	* @returns {String} A JSON string.
+	*/
+	DateString.prototype.toJSON = function() {
+		return JSON.stringify({ when: this.when });
+	};
+	DateString.prototype.inspect = function(_depth, _options) {
+		return "DateString " + inspect({
+			when: this.when,
+			_date: this._date
+		});
+	};
+	if (inspect.custom) DateString.prototype[inspect.custom] = DateString.prototype.inspect;
+}));
+//#endregion
+module.exports = require_date_string();

package/dist/lib/geo.js

@@ -0,0 +1,244 @@
+"use strict";
+//#region src/lib/geo.ts
+var require_geo = /* @__PURE__ */ require("../_virtual/_rolldown/runtime.js").__commonJSMin(((exports) => {
+	const assert = require("assert");
+	/*!
+	* Get a near filter from a given where object. For connector use only.
+	*/
+	exports.nearFilter = function nearFilter(where) {
+		const nearResults = [];
+		nearSearch(where);
+		return !nearResults.length ? false : nearResults;
+		function nearSearch(clause, parentKeys) {
+			if (typeof clause !== "object") return false;
+			parentKeys = parentKeys || [];
+			Object.keys(clause).forEach(function(clauseKey) {
+				if (typeof clause[clauseKey] !== "object" || !clause[clauseKey]) return;
+				if (Array.isArray(clause[clauseKey])) clause[clauseKey].forEach(function(el, index) {
+					const ret = nearSearch(el, parentKeys.concat(clauseKey).concat(index));
+					if (ret) return ret;
+				});
+				else if (clause[clauseKey].hasOwnProperty("near")) {
+					const result = clause[clauseKey];
+					nearResults.push({
+						near: result.near,
+						maxDistance: result.maxDistance,
+						minDistance: result.minDistance,
+						unit: result.unit,
+						mongoKey: parentKeys.length ? parentKeys.concat(clauseKey) : clauseKey,
+						key: clauseKey
+					});
+				}
+			});
+		}
+	};
+	/*!
+	* Filter a set of results using the given filters returned by `nearFilter()`.
+	* Can support multiple locations, but will include results from all of them.
+	*
+	* WARNING: "or" operator with GeoPoint does not work as expected, eg:
+	* {where: {or: [{location: {near: (29,-90)}},{name:'Sean'}]}}
+	* Will actually work as if you had used "and".  This is because geo filtering
+	* takes place outside of the SQL query, so the result set of "name = Sean" is
+	* returned by the database, and then the location filtering happens in the app
+	* logic.  So the "near" operator is always an "and" of the SQL filters, and "or"
+	* of other GeoPoint filters.
+	*
+	* Additionally, since this step occurs after the SQL result set is returned,
+	* if using GeoPoints with pagination the result set may be smaller than the
+	* page size.  The page size is enforced at the DB level, and then we may
+	* remove results at the Geo-app level.  If we "limit: 25", but 4 of those results
+	* do not have a matching geopoint field, the request will only return 21 results.
+	* This may make it erroneously look like a given page is the end of the result set.
+	*/
+	exports.filter = function(rawResults, filters) {
+		const distances = {};
+		const results = [];
+		filters.forEach(function(filter) {
+			const origin = filter.near;
+			const max = filter.maxDistance > 0 ? filter.maxDistance : false;
+			const min = filter.minDistance > 0 ? filter.minDistance : false;
+			const unit = filter.unit;
+			const key = filter.key;
+			rawResults.forEach(function(result) {
+				let loc = result[key];
+				if (!loc) return;
+				if (!(loc instanceof GeoPoint)) loc = GeoPoint(loc);
+				if (typeof loc.lat !== "number") return;
+				if (typeof loc.lng !== "number") return;
+				const d = GeoPoint.distanceBetween(origin, loc, { type: unit });
+				if (min && d < min || max && d > max) return;
+				distances[result.id] = d;
+				results.push(result);
+			});
+			results.sort(function(resA, resB) {
+				const a = resA[key];
+				const b = resB[key];
+				if (a && b) {
+					const da = distances[resA.id];
+					const db = distances[resB.id];
+					if (db === da) return 0;
+					return da > db ? 1 : -1;
+				} else return 0;
+			});
+		});
+		return results;
+	};
+	exports.GeoPoint = GeoPoint;
+	/**
+	* The GeoPoint object represents a physical location.
+	*
+	* For example:
+	*
+	* ```js
+	* var loopback = require(‘loopback’);
+	* var here = new loopback.GeoPoint({lat: 10.32424, lng: 5.84978});
+	* ```
+	*
+	* Embed a latitude / longitude point in a model.
+	*
+	* ```js
+	* var CoffeeShop = loopback.createModel('coffee-shop', {
+	*   location: 'GeoPoint'
+	* });
+	* ```
+	*
+	* You can query LoopBack models with a GeoPoint property and an attached data source using geo-spatial filters and
+	* sorting. For example, the following code finds the three nearest coffee shops.
+	*
+	* ```js
+	* CoffeeShop.attachTo(oracle);
+	* var here = new GeoPoint({lat: 10.32424, lng: 5.84978});
+	* CoffeeShop.find( {where: {location: {near: here}}, limit:3}, function(err, nearbyShops) {
+	*   console.info(nearbyShops); // [CoffeeShop, ...]
+	* });
+	* ```
+	* @class GeoPoint
+	* @property {Number} lat The latitude in degrees.
+	* @property {Number} lng The longitude in degrees.
+	*
+	* @options {Object} Options Object with two Number properties: lat and long.
+	* @property {Number} lat The latitude point in degrees. Range: -90 to 90.
+	* @property {Number} lng The longitude point in degrees. Range: -180 to 180.
+	*
+	* @options {Array} Options Array with two Number entries: [lat,long].
+	* @property {Number} lat The latitude point in degrees. Range: -90 to 90.
+	* @property {Number} lng The longitude point in degrees. Range: -180 to 180.
+	*/
+	function GeoPoint(data) {
+		if (!(this instanceof GeoPoint)) return new GeoPoint(data);
+		if (arguments.length === 2) data = {
+			lat: arguments[0],
+			lng: arguments[1]
+		};
+		assert(Array.isArray(data) || typeof data === "object" || typeof data === "string", "must provide valid geo-coordinates array [lat, lng] or object or a \"lat, lng\" string");
+		if (typeof data === "string") try {
+			data = JSON.parse(data);
+		} catch {
+			data = data.split(/,\s*/);
+			assert(data.length === 2, "must provide a string \"lat,lng\" creating a GeoPoint with a string");
+		}
+		if (Array.isArray(data)) data = {
+			lat: Number(data[0]),
+			lng: Number(data[1])
+		};
+		else {
+			data.lng = Number(data.lng);
+			data.lat = Number(data.lat);
+		}
+		assert(typeof data === "object", "must provide a lat and lng object when creating a GeoPoint");
+		assert(typeof data.lat === "number" && !isNaN(data.lat), "lat must be a number when creating a GeoPoint");
+		assert(typeof data.lng === "number" && !isNaN(data.lng), "lng must be a number when creating a GeoPoint");
+		assert(data.lng <= 180, "lng must be <= 180");
+		assert(data.lng >= -180, "lng must be >= -180");
+		assert(data.lat <= 90, "lat must be <= 90");
+		assert(data.lat >= -90, "lat must be >= -90");
+		this.lat = data.lat;
+		this.lng = data.lng;
+	}
+	/**
+	* Determine the spherical distance between two GeoPoints.
+	*
+	* @param  {GeoPoint} pointA Point A
+	* @param  {GeoPoint} pointB Point B
+	* @options  {Object} options Options object with one key, 'type'.  See below.
+	* @property {String} type Unit of measurement, one of:
+	*
+	* - `miles` (default)
+	* - `radians`
+	* - `kilometers`
+	* - `meters`
+	* - `miles`
+	* - `feet`
+	* - `degrees`
+	*/
+	GeoPoint.distanceBetween = function distanceBetween(a, b, options) {
+		if (!(a instanceof GeoPoint)) a = GeoPoint(a);
+		if (!(b instanceof GeoPoint)) b = GeoPoint(b);
+		const x1 = a.lat;
+		const y1 = a.lng;
+		const x2 = b.lat;
+		const y2 = b.lng;
+		return geoDistance(x1, y1, x2, y2, options);
+	};
+	/**
+	* Determine the spherical distance to the given point.
+	* Example:
+	* ```js
+	* var loopback = require(‘loopback’);
+	*
+	* var here = new loopback.GeoPoint({lat: 10, lng: 10});
+	* var there = new loopback.GeoPoint({lat: 5, lng: 5});
+	*
+	* loopback.GeoPoint.distanceBetween(here, there, {type: 'miles'}) // 438
+	* ```
+	* @param {Object} point GeoPoint object to which to measure distance.
+	* @options  {Object} options Options object with one key, 'type'.  See below.
+	* @property {String} type Unit of measurement, one of:
+	*
+	* - `miles` (default)
+	* - `radians`
+	* - `kilometers`
+	* - `meters`
+	* - `miles`
+	* - `feet`
+	* - `degrees`
+	*/
+	GeoPoint.prototype.distanceTo = function(point, options) {
+		return GeoPoint.distanceBetween(this, point, options);
+	};
+	/**
+	* Simple serialization.
+	*/
+	GeoPoint.prototype.toString = function() {
+		return this.lat + "," + this.lng;
+	};
+	/**
+	* @property {Number} DEG2RAD - Factor to convert degrees to radians.
+	* @property {Number} RAD2DEG - Factor to convert radians to degrees.
+	* @property {Object} EARTH_RADIUS - Radius of the earth.
+	*/
+	const DEG2RAD = .01745329252;
+	const EARTH_RADIUS = {
+		kilometers: 6370.99056,
+		meters: 6370990.56,
+		miles: 3958.75,
+		feet: 20902200,
+		radians: 1,
+		degrees: 57.29577951308
+	};
+	function geoDistance(x1, y1, x2, y2, options) {
+		const type = options && options.type || "miles";
+		x1 = x1 * DEG2RAD;
+		y1 = y1 * DEG2RAD;
+		x2 = x2 * DEG2RAD;
+		y2 = y2 * DEG2RAD;
+		const haversine = function(a) {
+			return Math.pow(Math.sin(a / 2), 2);
+		};
+		const f = Math.sqrt(haversine(x2 - x1) + Math.cos(x2) * Math.cos(x1) * haversine(y2 - y1));
+		return 2 * Math.asin(f) * EARTH_RADIUS[type];
+	}
+}));
+//#endregion
+module.exports = require_geo();

package/dist/lib/globalize.js

@@ -0,0 +1,33 @@
+"use strict";
+//#region src/lib/globalize.ts
+var require_globalize = /* @__PURE__ */ require("../_virtual/_rolldown/runtime.js").__commonJSMin(((exports, module) => {
+	const util = require("util");
+	function normalizeTemplate(message) {
+		return String(message).replace(/\{\{([^}]+)\}\}/g, "$1");
+	}
+	function formatMessage(message, args) {
+		return util.format(normalizeTemplate(message), ...args);
+	}
+	function StrongGlobalize() {}
+	StrongGlobalize.prototype.f = function(message, ...args) {
+		return formatMessage(message, args);
+	};
+	StrongGlobalize.prototype.log = function(message, ...args) {
+		console.log(formatMessage(message, args));
+	};
+	StrongGlobalize.prototype.warn = function(message, ...args) {
+		console.warn(formatMessage(message, args));
+	};
+	StrongGlobalize.prototype.error = function(message, ...args) {
+		console.error(formatMessage(message, args));
+	};
+	const sharedGlobalize = new StrongGlobalize();
+	function createGlobalize() {
+		return sharedGlobalize;
+	}
+	createGlobalize.StrongGlobalize = StrongGlobalize;
+	createGlobalize.SetRootDir = function() {};
+	module.exports = createGlobalize;
+}));
+//#endregion
+module.exports = require_globalize();

package/dist/lib/hooks.js

@@ -0,0 +1,79 @@
+"use strict";
+const require_runtime = require("../_virtual/_rolldown/runtime.js");
+const require_lib_globalize = require("./globalize.js");
+//#region src/lib/hooks.ts
+var require_hooks = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const deprecated = require("depd")("loopback-datasource-juggler");
+	const g = require_lib_globalize();
+	/*!
+	* Module exports
+	*/
+	module.exports = Hookable;
+	function Hookable() {}
+	/**
+	* List of hooks available
+	*/
+	Hookable.afterInitialize = null;
+	Hookable.beforeValidate = null;
+	Hookable.afterValidate = null;
+	Hookable.beforeSave = null;
+	Hookable.afterSave = null;
+	Hookable.beforeCreate = null;
+	Hookable.afterCreate = null;
+	Hookable.beforeUpdate = null;
+	Hookable.afterUpdate = null;
+	Hookable.beforeDestroy = null;
+	Hookable.afterDestroy = null;
+	/**
+	* @deprecated
+	* Setup a Model-based hook to trigger when the specified action occurs.
+	* The trigger is broken up into three segments: `beforeHook`, `work` and
+	* `afterHook`.
+	* @param {string} actionName The name of the action that triggers the hook.
+	* @param {Function} work The 2nd phase of the trigger.
+	* @param {*} data The value(s) to provide to the 1st phase (`beforeHook`) call.
+	* @callback
+	* @param {Function} callback
+	*/
+	Hookable.prototype.trigger = function trigger(actionName, work, data, callback) {
+		const capitalizedName = capitalize(actionName);
+		let beforeHook = this.constructor["before" + capitalizedName] || this.constructor["pre" + capitalizedName];
+		let afterHook = this.constructor["after" + capitalizedName] || this.constructor["post" + capitalizedName];
+		if (actionName === "validate") {
+			beforeHook = beforeHook || this.constructor.beforeValidation;
+			afterHook = afterHook || this.constructor.afterValidation;
+		}
+		const inst = this;
+		if (actionName !== "initialize") {
+			if (beforeHook) deprecateHook(inst.constructor, ["before", "pre"], capitalizedName);
+			if (afterHook) deprecateHook(inst.constructor, ["after", "post"], capitalizedName);
+		}
+		if (work) if (beforeHook) beforeHook.call(inst, function() {
+			if (arguments.length) return callback && callback.apply(null, arguments);
+			work.call(inst, next);
+		}, data);
+		else work.call(inst, next);
+		else next();
+		function next(done) {
+			if (afterHook) afterHook.call(inst, done);
+			else if (done) done.call(this);
+		}
+	};
+	function capitalize(string) {
+		return string.charAt(0).toUpperCase() + string.slice(1);
+	}
+	function deprecateHook(ctor, prefixes, capitalizedName) {
+		const candidateNames = prefixes.map(function(p) {
+			return p + capitalizedName;
+		});
+		if (capitalizedName === "Validate") candidateNames.push(prefixes[0] + "Validation");
+		let hookName = candidateNames.filter(function(hook) {
+			return !!ctor[hook];
+		})[0];
+		if (!hookName) return;
+		if (ctor.modelName) hookName = ctor.modelName + "." + hookName;
+		deprecated(g.f("Model hook \"%s\" is deprecated, use Operation hooks instead. {{http://docs.strongloop.com/display/LB/Operation+hooks}}", hookName));
+	}
+}));
+//#endregion
+module.exports = require_hooks();

package/dist/lib/id-utils.js

@@ -0,0 +1,66 @@
+"use strict";
+//#region src/lib/id-utils.ts
+var require_id_utils = /* @__PURE__ */ require("../_virtual/_rolldown/runtime.js").__commonJSMin(((exports, module) => {
+	const { randomBytes } = require("crypto");
+	const NANOID_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz-";
+	const UUID_EPOCH_OFFSET = 12219292800000n;
+	const nodeId = Buffer.from(randomBytes(6));
+	const clockSeqSeed = randomBytes(2);
+	nodeId[0] |= 1;
+	let clockSeq = (clockSeqSeed[0] << 8 | clockSeqSeed[1]) & 16383;
+	let lastMSecs = 0;
+	let lastNSecs = 0;
+	function nanoid(size = 21) {
+		const bytes = randomBytes(size);
+		let id = "";
+		for (let i = 0; i < size; i++) id += NANOID_ALPHABET[bytes[i] % 64];
+		return id;
+	}
+	function uuidV4() {
+		const bytes = Buffer.from(randomBytes(16));
+		bytes[6] = bytes[6] & 15 | 64;
+		bytes[8] = bytes[8] & 63 | 128;
+		return stringifyUuid(bytes);
+	}
+	function uuidV1() {
+		let msecs = Date.now();
+		let nsecs = lastNSecs + 1;
+		const dt = msecs - lastMSecs + (nsecs - lastNSecs) / 1e4;
+		if (dt < 0) clockSeq = clockSeq + 1 & 16383;
+		if (dt < 0 || msecs > lastMSecs) nsecs = 0;
+		if (nsecs >= 1e4) {
+			msecs += 1;
+			nsecs = 0;
+		}
+		lastMSecs = msecs;
+		lastNSecs = nsecs;
+		const time = (BigInt(msecs) + UUID_EPOCH_OFFSET) * 10000n + BigInt(nsecs);
+		const bytes = Buffer.allocUnsafe(16);
+		const timeLow = Number(time & 4294967295n);
+		const timeMid = Number(time >> 32n & 65535n);
+		const timeHigh = Number(time >> 48n & 4095n);
+		bytes[0] = timeLow >>> 24 & 255;
+		bytes[1] = timeLow >>> 16 & 255;
+		bytes[2] = timeLow >>> 8 & 255;
+		bytes[3] = timeLow & 255;
+		bytes[4] = timeMid >>> 8 & 255;
+		bytes[5] = timeMid & 255;
+		bytes[6] = timeHigh >>> 8 & 15 | 16;
+		bytes[7] = timeHigh & 255;
+		bytes[8] = clockSeq >>> 8 & 63 | 128;
+		bytes[9] = clockSeq & 255;
+		nodeId.copy(bytes, 10);
+		return stringifyUuid(bytes);
+	}
+	function stringifyUuid(bytes) {
+		const hex = bytes.toString("hex");
+		return hex.slice(0, 8) + "-" + hex.slice(8, 12) + "-" + hex.slice(12, 16) + "-" + hex.slice(16, 20) + "-" + hex.slice(20, 32);
+	}
+	module.exports = {
+		nanoid,
+		uuidV1,
+		uuidV4
+	};
+}));
+//#endregion
+module.exports = require_id_utils();