@vsaas/loopback-datasource-juggler 10.0.0

package/dist/lib/scope.js

@@ -0,0 +1,392 @@
+"use strict";
+const require_runtime = require("../_virtual/_rolldown/runtime.js");
+const require_lib_globalize = require("./globalize.js");
+const require_lib_utils = require("./utils.js");
+const require_lib_model = require("./model.js");
+//#region src/lib/scope.ts
+var require_scope = /* @__PURE__ */ require_runtime.__commonJSMin(((exports) => {
+	const i8n = require("inflection");
+	const g = require_lib_globalize();
+	const { isDeepStrictEqual } = require("util");
+	const utils = require_lib_utils;
+	const defineCachedRelations = utils.defineCachedRelations;
+	const setScopeValuesFromWhere = utils.setScopeValuesFromWhere;
+	const mergeQuery = utils.mergeQuery;
+	const DefaultModelBaseClass = require_lib_model;
+	const collectTargetIds = utils.collectTargetIds;
+	const idName = utils.idName;
+	const deprecated = require("depd")("loopback-datasource-juggler");
+	function isObject(value) {
+		return value !== null && typeof value === "object";
+	}
+	function isEmptyObject(value) {
+		return Object.keys(value).length === 0;
+	}
+	function omit(object, keyToOmit) {
+		const result = {};
+		const keys = Object.keys(object);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			if (key !== keyToOmit) result[key] = object[key];
+		}
+		return result;
+	}
+	function intersectionWith(left, right, comparator) {
+		const result = [];
+		for (let i = 0; i < left.length; i++) {
+			const leftValue = left[i];
+			for (let j = 0; j < right.length; j++) if (comparator(leftValue, right[j])) {
+				result.push(leftValue);
+				break;
+			}
+		}
+		return result;
+	}
+	function isEqual(left, right) {
+		return isDeepStrictEqual(left, right);
+	}
+	/**
+	* Module exports
+	*/
+	exports.defineScope = defineScope;
+	function ScopeDefinition(definition) {
+		this.isStatic = definition.isStatic;
+		this.modelFrom = definition.modelFrom;
+		this.modelTo = definition.modelTo || definition.modelFrom;
+		this.name = definition.name;
+		this.params = definition.params;
+		this.methods = definition.methods || {};
+		this.options = definition.options || {};
+	}
+	ScopeDefinition.prototype.targetModel = function(receiver) {
+		let modelTo;
+		if (typeof this.options.modelTo === "function") modelTo = this.options.modelTo.call(this, receiver) || this.modelTo;
+		else modelTo = this.modelTo;
+		if (!(modelTo.prototype instanceof DefaultModelBaseClass)) {
+			let msg = "Invalid target model for scope `";
+			msg += (this.isStatic ? this.modelFrom : this.modelFrom.constructor).modelName;
+			msg += this.isStatic ? "." : ".prototype.";
+			msg += this.name + "`.";
+			throw new Error(msg);
+		}
+		return modelTo;
+	};
+	/*!
+	* Find related model instances
+	* @param {*} receiver The target model class/prototype
+	* @param {Object|Function} scopeParams
+	* @param {Boolean|Object} [condOrRefresh] true for refresh or object as a filter
+	* @param {Object} [options]
+	* @param {Function} cb
+	* @returns {*}
+	*/
+	ScopeDefinition.prototype.related = function(receiver, scopeParams, condOrRefresh, options, cb) {
+		const name = this.name;
+		const self = receiver;
+		let actualCond = {};
+		let actualRefresh = false;
+		let saveOnCache = receiver instanceof DefaultModelBaseClass;
+		if (typeof condOrRefresh === "function" && options === void 0 && cb === void 0) {
+			cb = condOrRefresh;
+			options = {};
+			condOrRefresh = void 0;
+		} else if (typeof options === "function" && cb === void 0) {
+			cb = options;
+			options = {};
+		}
+		options = options || {};
+		if (condOrRefresh !== void 0) if (typeof condOrRefresh === "boolean") actualRefresh = condOrRefresh;
+		else {
+			actualCond = condOrRefresh;
+			actualRefresh = true;
+			saveOnCache = false;
+		}
+		cb = cb || utils.createPromiseCallback();
+		if (!self.__cachedRelations || self.__cachedRelations[name] === void 0 || actualRefresh) {
+			const params = mergeQuery(actualCond, scopeParams, { nestedInclude: true });
+			const targetModel = this.targetModel(receiver);
+			const scopeOnRelatedModel = params.collect && params.include.scope !== null && typeof params.include.scope === "object";
+			let filter, queryRelated;
+			if (scopeOnRelatedModel) {
+				filter = params.include;
+				queryRelated = filter.scope;
+				delete params.include.scope;
+			}
+			targetModel.find(params, options, function(err, data) {
+				if (!err && saveOnCache) {
+					defineCachedRelations(self);
+					self.__cachedRelations[name] = data;
+				}
+				if (scopeOnRelatedModel === true) {
+					const relatedModel = targetModel.relations[filter.relation].modelTo;
+					const IdKey = idName(relatedModel);
+					const smartMerge = function(idCollection, qWhere) {
+						if (!qWhere[IdKey]) return idCollection;
+						let merged = {};
+						const idsA = idCollection.inq;
+						const intersect = intersectionWith(idsA, qWhere[IdKey].inq ? qWhere[IdKey].inq : [qWhere[IdKey]], isEqual);
+						if (intersect.length === 1) merged = intersect[0];
+						if (intersect.length > 1) merged = { inq: intersect };
+						return merged;
+					};
+					if (queryRelated.where !== void 0) {
+						const IdKeyCondition = {};
+						IdKeyCondition[IdKey] = smartMerge(collectTargetIds(data, IdKey), queryRelated.where);
+						if (isObject(IdKeyCondition[IdKey]) && isEmptyObject(IdKeyCondition[IdKey])) return cb(null, []);
+						const mergedWhere = { and: [IdKeyCondition, omit(queryRelated.where, IdKey)] };
+						queryRelated.where = mergedWhere;
+					} else {
+						queryRelated.where = {};
+						queryRelated.where[IdKey] = collectTargetIds(data, IdKey);
+					}
+					relatedModel.find(queryRelated, options, cb);
+				} else cb(err, data);
+			});
+		} else cb(null, self.__cachedRelations[name]);
+		return cb.promise;
+	};
+	/**
+	* Define a scope method
+	* @param {String} name of the method
+	* @param {Function} function to define
+	*/
+	ScopeDefinition.prototype.defineMethod = function(name, fn) {
+		return this.methods[name] = fn;
+	};
+	/**
+	* Define a scope to the class
+	* @param {Model} cls The class where the scope method is added
+	* @param {Model} targetClass The class that a query to run against
+	* @param {String} name The name of the scope
+	* @param {Object|Function} params The parameters object for the query or a function
+	* to return the query object
+	* @param methods An object of methods keyed by the method name to be bound to the class
+	*/
+	function defineScope(cls, targetClass, name, params, methods, options) {
+		if (!cls._scopeMeta) cls._scopeMeta = {};
+		if (cls === targetClass) cls._scopeMeta[name] = params;
+		else if (targetClass) {
+			if (!targetClass._scopeMeta) targetClass._scopeMeta = {};
+		}
+		options = options || {};
+		const isStatic = typeof cls === "function" || options.isStatic || false;
+		const definition = new ScopeDefinition({
+			isStatic,
+			modelFrom: cls,
+			modelTo: targetClass,
+			name,
+			params,
+			methods,
+			options
+		});
+		if (isStatic) {
+			cls.scopes = cls.scopes || {};
+			cls.scopes[name] = definition;
+		} else {
+			cls.constructor.scopes = cls.constructor.scopes || {};
+			cls.constructor.scopes[name] = definition;
+		}
+		Object.defineProperty(cls, name, {
+			enumerable: false,
+			configurable: true,
+			get: function() {
+				const targetModel = definition.targetModel(this);
+				const self = this;
+				const f = function(condOrRefresh, options, cb) {
+					if (arguments.length === 0) {
+						if (typeof f.value === "function") return f.value(self);
+						else if (self.__cachedRelations) return self.__cachedRelations[name];
+					} else {
+						if (typeof condOrRefresh === "function" && options === void 0 && cb === void 0) {
+							cb = condOrRefresh;
+							options = {};
+							condOrRefresh = void 0;
+						} else if (typeof options === "function" && cb === void 0) {
+							cb = options;
+							options = {};
+						}
+						options = options || {};
+						if (f._scope.collect && condOrRefresh !== null && typeof condOrRefresh === "object") {
+							f._scope.include = {
+								relation: f._scope.collect,
+								scope: condOrRefresh
+							};
+							condOrRefresh = {};
+						}
+						return definition.related(self, f._scope, condOrRefresh, options, cb);
+					}
+				};
+				f._receiver = this;
+				f._scope = typeof definition.params === "function" ? definition.params.call(self) : definition.params;
+				f._targetClass = targetModel.modelName;
+				if (f._scope.collect) {
+					const rel = targetModel.relations[f._scope.collect];
+					f._targetClass = rel && rel.modelTo && rel.modelTo.modelName || i8n.camelize(f._scope.collect);
+				}
+				f.find = function(condOrRefresh, options, cb) {
+					if (typeof condOrRefresh === "function" && options === void 0 && cb === void 0) {
+						cb = condOrRefresh;
+						options = {};
+						condOrRefresh = {};
+					} else if (typeof options === "function" && cb === void 0) {
+						cb = options;
+						options = {};
+					}
+					options = options || {};
+					return definition.related(self, f._scope, condOrRefresh, options, cb);
+				};
+				f.getAsync = function() {
+					deprecated(g.f("Scope method \"getAsync()\" is deprecated, use \"find()\" instead."));
+					return this.find.apply(this, arguments);
+				};
+				f.build = build;
+				f.create = create;
+				f.updateAll = updateAll;
+				f.destroyAll = destroyAll;
+				f.findById = findById;
+				f.findOne = findOne;
+				f.count = count;
+				for (const i in definition.methods) f[i] = definition.methods[i].bind(self);
+				if (!targetClass) return f;
+				Object.keys(targetClass._scopeMeta).forEach(function(name) {
+					Object.defineProperty(f, name, {
+						enumerable: false,
+						get: function() {
+							mergeQuery(f._scope, targetModel._scopeMeta[name]);
+							return f;
+						}
+					});
+				}.bind(self));
+				return f;
+			}
+		});
+		const fn = function() {
+			this[name].apply(this[name], arguments);
+		};
+		cls["__get__" + name] = fn;
+		const fnCreate = function() {
+			this[name].create.apply(this[name], arguments);
+		};
+		cls["__create__" + name] = fnCreate;
+		const fnDelete = function() {
+			this[name].destroyAll.apply(this[name], arguments);
+		};
+		cls["__delete__" + name] = fnDelete;
+		const fnUpdate = function() {
+			this[name].updateAll.apply(this[name], arguments);
+		};
+		cls["__update__" + name] = fnUpdate;
+		const fnFindById = function(_cb) {
+			this[name].findById.apply(this[name], arguments);
+		};
+		cls["__findById__" + name] = fnFindById;
+		const fnFindOne = function(_cb) {
+			this[name].findOne.apply(this[name], arguments);
+		};
+		cls["__findOne__" + name] = fnFindOne;
+		const fnCount = function(_cb) {
+			this[name].count.apply(this[name], arguments);
+		};
+		cls["__count__" + name] = fnCount;
+		function build(data) {
+			data = data || {};
+			const targetModel = definition.targetModel(this._receiver);
+			const where = this._scope && this._scope.where || {};
+			setScopeValuesFromWhere(data, where, targetModel);
+			return new targetModel(data);
+		}
+		function create(data, options, cb) {
+			if (typeof data === "function" && options === void 0 && cb === void 0) {
+				cb = data;
+				data = {};
+			} else if (typeof options === "function" && cb === void 0) {
+				cb = options;
+				options = {};
+			}
+			options = options || {};
+			return this.build(data).save(options, cb);
+		}
+		function destroyAll(where, options, cb) {
+			if (typeof where === "function") {
+				cb = where;
+				where = {};
+			} else if (typeof options === "function" && cb === void 0) {
+				cb = options;
+				options = {};
+			}
+			options = options || {};
+			const targetModel = definition.targetModel(this._receiver);
+			const filter = mergeQuery({ where: this._scope && this._scope.where || {} }, { where: where || {} });
+			return targetModel.destroyAll(filter.where, options, cb);
+		}
+		function updateAll(where, data, options, cb) {
+			if (typeof data === "function" && options === void 0 && cb === void 0) {
+				cb = data;
+				data = where;
+				where = {};
+				options = {};
+			} else if (typeof options === "function" && cb === void 0) {
+				cb = options;
+				options = {};
+			}
+			options = options || {};
+			const targetModel = definition.targetModel(this._receiver);
+			const filter = mergeQuery({ where: this._scope && this._scope.where || {} }, { where: where || {} });
+			return targetModel.updateAll(filter.where, data, options, cb);
+		}
+		function findById(id, filter, options, cb) {
+			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 = {};
+					}
+				}
+			}
+			options = options || {};
+			filter = filter || {};
+			const idName = definition.targetModel(this._receiver).definition.idName();
+			let query = { where: {} };
+			query.where[idName] = id;
+			query = mergeQuery(query, filter);
+			return this.findOne(query, options, cb);
+		}
+		function findOne(filter, options, cb) {
+			if (typeof filter === "function") {
+				cb = filter;
+				filter = {};
+				options = {};
+			} else if (typeof options === "function" && cb === void 0) {
+				cb = options;
+				options = {};
+			}
+			options = options || {};
+			const targetModel = definition.targetModel(this._receiver);
+			filter = mergeQuery({ where: this._scope && this._scope.where || {} }, filter || {});
+			return targetModel.findOne(filter, options, cb);
+		}
+		function count(where, options, cb) {
+			if (typeof where === "function") {
+				cb = where;
+				where = {};
+			} else if (typeof options === "function" && cb === void 0) {
+				cb = options;
+				options = {};
+			}
+			options = options || {};
+			const targetModel = definition.targetModel(this._receiver);
+			const filter = mergeQuery({ where: this._scope && this._scope.where || {} }, { where: where || {} });
+			return targetModel.count(filter.where, options, cb);
+		}
+		return definition;
+	}
+}));
+//#endregion
+module.exports = require_scope();

package/dist/lib/transaction.js

@@ -0,0 +1,183 @@
+"use strict";
+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_utils = require("./utils.js");
+const require_lib_observer = require("./observer.js");
+const require_lib_id_utils = require("./id-utils.js");
+//#region src/lib/transaction.ts
+var require_transaction = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const g = require_lib_globalize();
+	const debug = require("debug")("loopback:connector:transaction");
+	const { uuidV1 } = require_lib_id_utils;
+	const utils = require_lib_utils;
+	const jutil = require_lib_jutil;
+	const ObserverMixin = require_lib_observer;
+	const Transaction = require("@vsaas/loopback-connector").Transaction;
+	module.exports = TransactionMixin;
+	/**
+	* TransactionMixin class.  Use to add transaction APIs to a model class.
+	*
+	* @class TransactionMixin
+	*/
+	function TransactionMixin() {}
+	/**
+	* Begin a new transaction.
+	*
+	* A transaction can be committed or rolled back. If timeout happens, the
+	* transaction will be rolled back. Please note a transaction is typically
+	* associated with a pooled connection. Committing or rolling back a transaction
+	* will release the connection back to the pool.
+	*
+	* Once the transaction is committed or rolled back, the connection property
+	* will be set to null to mark the transaction to be inactive. Trying to commit
+	* or rollback an inactive transaction will receive an error from the callback.
+	*
+	* Please also note that the transaction is only honored with the same data
+	* source/connector instance. CRUD methods will not join the current transaction
+	* if its model is not attached the same data source.
+	*
+	* Example:
+	*
+	* To pass the transaction context to one of the CRUD methods, use the `options`
+	* argument with `transaction` property, for example,
+	*
+	* ```js
+	* MyModel.beginTransaction('READ COMMITTED', function(err, tx) {
+	*   MyModel.create({x: 1, y: 'a'}, {transaction: tx}, function(err, inst) {
+	*     MyModel.find({x: 1}, {transaction: tx}, function(err, results) {
+	*       // ...
+	*       tx.commit(function(err) {...});
+	*     });
+	*   });
+	* });
+	* ```
+	*
+	* @param {Object|String} options Options to be passed upon transaction.
+	*
+	* Can be one of the forms:
+	*  - Object: {isolationLevel: '...', timeout: 1000}
+	*  - String: isolationLevel
+	*
+	* Valid values of `isolationLevel` are:
+	*
+	* - Transaction.READ_COMMITTED = 'READ COMMITTED'; // default
+	* - Transaction.READ_UNCOMMITTED = 'READ UNCOMMITTED';
+	* - Transaction.SERIALIZABLE = 'SERIALIZABLE';
+	* - Transaction.REPEATABLE_READ = 'REPEATABLE READ';
+	* @callback {Function} cb Callback function.
+	* @returns {Promise|undefined} Returns a callback promise.
+	*/
+	TransactionMixin.beginTransaction = function(options, cb) {
+		cb = cb || utils.createPromiseCallback();
+		if (Transaction) {
+			const connector = this.getConnector();
+			Transaction.begin(connector, options, function(err, transaction) {
+				if (err) return cb(err);
+				if (!transaction.id) transaction.id = uuidV1();
+				if (options.timeout && !transaction.timeout) transaction.timeout = setTimeout(function() {
+					const context = {
+						transaction,
+						operation: "timeout"
+					};
+					transaction.notifyObserversOf("timeout", context, function(err) {
+						if (!err) transaction.rollback(function() {
+							debug("Transaction %s is rolled back due to timeout", transaction.id);
+						});
+					});
+				}, options.timeout);
+				cb(err, transaction);
+			});
+		} else process.nextTick(function() {
+			const err = new Error(g.f("{{Transaction}} is not supported"));
+			cb(err);
+		});
+		return cb.promise;
+	};
+	if (Transaction) {
+		jutil.mixin(Transaction.prototype, ObserverMixin);
+		/**
+		* Commit a transaction and release it back to the pool.
+		*
+		* Example:
+		*
+		* ```js
+		* MyModel.beginTransaction('READ COMMITTED', function(err, tx) {
+		*   // some crud operation of your choice
+		*   tx.commit(function(err) {
+		*     // release the connection pool upon committing
+		*     tx.close(err);
+		*   });
+		* });
+		* ```
+		*
+		* @callback {Function} cb Callback function.
+		* @returns {Promise|undefined} Returns a callback promise.
+		*/
+		Transaction.prototype.commit = function(cb) {
+			cb = cb || utils.createPromiseCallback();
+			if (this.ensureActive(cb)) {
+				const context = {
+					transaction: this,
+					operation: "commit"
+				};
+				this.notifyObserversAround("commit", context, (done) => {
+					this.connector.commit(this.connection, done);
+				}, (err) => {
+					this.connection = null;
+					cb(err);
+				});
+			}
+			return cb.promise;
+		};
+		/**
+		* Rollback a transaction and release it back to the pool.
+		*
+		*  Example:
+		*
+		* ```js
+		* MyModel.beginTransaction('READ COMMITTED', function(err, tx) {
+		*   // some crud operation of your choice
+		*   tx.rollback(function(err) {
+		*     // release the connection pool upon committing
+		*     tx.close(err);
+		*   });
+		* });
+		* ```
+		*
+		* @callback {Function} cb Callback function.
+		* @returns {Promise|undefined} Returns a callback promise.
+		*/
+		Transaction.prototype.rollback = function(cb) {
+			cb = cb || utils.createPromiseCallback();
+			if (this.ensureActive(cb)) {
+				const context = {
+					transaction: this,
+					operation: "rollback"
+				};
+				this.notifyObserversAround("rollback", context, (done) => {
+					this.connector.rollback(this.connection, done);
+				}, (err) => {
+					this.connection = null;
+					cb(err);
+				});
+			}
+			return cb.promise;
+		};
+		Transaction.prototype.ensureActive = function(cb) {
+			if (!this.connection) process.nextTick(() => {
+				cb(new Error(g.f("The {{transaction}} is not active: %s", this.id)));
+			});
+			return !!this.connection;
+		};
+		Transaction.prototype.toJSON = function() {
+			return this.id;
+		};
+		Transaction.prototype.toString = function() {
+			return this.id;
+		};
+	}
+	TransactionMixin.Transaction = Transaction;
+}));
+//#endregion
+module.exports = require_transaction();

package/dist/lib/types.js

@@ -0,0 +1,58 @@
+"use strict";
+const require_runtime = require("../_virtual/_rolldown/runtime.js");
+const require_lib_date_string = require("./date-string.js");
+const require_lib_geo = require("./geo.js");
+//#region src/lib/types.ts
+var require_types = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const Types = {};
+	/**
+	* Schema types
+	*/
+	Types.Text = function Text(value) {
+		if (!(this instanceof Text)) return value;
+		this.value = value;
+	};
+	Types.Text.prototype.toObject = Types.Text.prototype.toJSON = function() {
+		return this.value;
+	};
+	Types.JSON = function JSON(value) {
+		if (!(this instanceof JSON)) return value;
+		this.value = value;
+	};
+	Types.JSON.prototype.toObject = Types.JSON.prototype.toJSON = function() {
+		return this.value;
+	};
+	Types.Any = function Any(value) {
+		if (!(this instanceof Any)) return value;
+		this.value = value;
+	};
+	Types.Any.prototype.toObject = Types.Any.prototype.toJSON = function() {
+		return this.value;
+	};
+	module.exports = function(modelTypes) {
+		const DateString = require_lib_date_string;
+		const GeoPoint = require_lib_geo.GeoPoint;
+		for (const t in Types) modelTypes[t] = Types[t];
+		modelTypes.schemaTypes = {};
+		modelTypes.registerType = function(type, names) {
+			names = names || [];
+			names = names.concat([type.name]);
+			for (let n = 0; n < names.length; n++) this.schemaTypes[names[n].toLowerCase()] = type;
+		};
+		modelTypes.registerType(Types.Text);
+		modelTypes.registerType(Types.JSON);
+		modelTypes.registerType(Types.Any);
+		modelTypes.registerType(String);
+		modelTypes.registerType(Number);
+		modelTypes.registerType(Boolean);
+		modelTypes.registerType(Date);
+		modelTypes.registerType(DateString);
+		modelTypes.registerType(Buffer, ["Binary"]);
+		modelTypes.registerType(Array);
+		modelTypes.registerType(GeoPoint);
+		modelTypes.registerType(Object);
+	};
+	module.exports.Types = Types;
+}));
+//#endregion
+module.exports = require_types();