@vsaas/loopback 10.0.0

package/dist/common/models/application.cjs

@@ -0,0 +1,100 @@
+"use strict";
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_lib_utils = require("../../lib/utils.cjs");
+//#region src/common/models/application.ts
+var require_application = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const assert = require("assert");
+	const utils = require_lib_utils;
+	/*!
+	* Application management functions
+	*/
+	const crypto = require("crypto");
+	function generateKey(hmacKey, algorithm, encoding) {
+		hmacKey = hmacKey || "loopback";
+		algorithm = algorithm || "sha1";
+		encoding = encoding || "hex";
+		const hmac = crypto.createHmac(algorithm, hmacKey);
+		const buf = crypto.randomBytes(32);
+		hmac.update(buf);
+		return hmac.digest(encoding);
+	}
+	function configureApplication(Application) {
+		Application.observe("before save", function(ctx, next) {
+			if (!ctx.instance) return next();
+			const app = ctx.instance;
+			app.created = app.modified = /* @__PURE__ */ new Date();
+			if (!app.id) app.id = generateKey("id", "md5");
+			app.clientKey = generateKey("client");
+			app.javaScriptKey = generateKey("javaScript");
+			app.restApiKey = generateKey("restApi");
+			app.windowsKey = generateKey("windows");
+			app.masterKey = generateKey("master");
+			next();
+		});
+		Application.register = function(owner, name, options, cb) {
+			assert(owner, "owner is required");
+			assert(name, "name is required");
+			if (typeof options === "function" && !cb) {
+				cb = options;
+				options = {};
+			}
+			cb = cb || utils.createPromiseCallback();
+			const props = {
+				owner,
+				name
+			};
+			for (const p in options) if (!(p in props)) props[p] = options[p];
+			this.create(props, cb);
+			return cb.promise;
+		};
+		Application.prototype.resetKeys = function(cb) {
+			this.clientKey = generateKey("client");
+			this.javaScriptKey = generateKey("javaScript");
+			this.restApiKey = generateKey("restApi");
+			this.windowsKey = generateKey("windows");
+			this.masterKey = generateKey("master");
+			this.modified = /* @__PURE__ */ new Date();
+			this.save(cb);
+		};
+		Application.resetKeys = function(appId, cb) {
+			cb = cb || utils.createPromiseCallback();
+			this.findById(appId, function(err, app) {
+				if (err) {
+					if (cb) cb(err, app);
+					return;
+				}
+				app.resetKeys(cb);
+			});
+			return cb.promise;
+		};
+		Application.authenticate = function(appId, key, cb) {
+			cb = cb || utils.createPromiseCallback();
+			this.findById(appId, function(err, app) {
+				if (err || !app) {
+					cb(err, null);
+					return cb.promise;
+				}
+				let result = null;
+				const keyNames = [
+					"clientKey",
+					"javaScriptKey",
+					"restApiKey",
+					"windowsKey",
+					"masterKey"
+				];
+				for (let i = 0; i < keyNames.length; i++) if (app[keyNames[i]] === key) {
+					result = {
+						application: app,
+						keyType: keyNames[i]
+					};
+					break;
+				}
+				cb(null, result);
+			});
+			return cb.promise;
+		};
+	}
+	module.exports = configureApplication;
+}));
+//#endregion
+module.exports = require_application();

package/dist/common/models/application2.cjs

@@ -0,0 +1,118 @@
+//#region common/models/application.json
+var require_application = /* @__PURE__ */ require("../../_virtual/_rolldown/runtime.cjs").__commonJSMin(((exports, module) => {
+	module.exports = {
+		"name": "Application",
+		"properties": {
+			"id": {
+				"type": "string",
+				"id": true
+			},
+			"realm": { "type": "string" },
+			"name": {
+				"type": "string",
+				"required": true
+			},
+			"description": "string",
+			"icon": {
+				"type": "string",
+				"description": "The icon image url"
+			},
+			"owner": {
+				"type": "string",
+				"description": "The user id of the developer who registers the application"
+			},
+			"collaborators": {
+				"type": ["string"],
+				"description": "A list of users ids who have permissions to work on this app"
+			},
+			"email": "string",
+			"emailVerified": "boolean",
+			"url": {
+				"type": "string",
+				"description": "The application URL for OAuth 2.0"
+			},
+			"callbackUrls": {
+				"type": ["string"],
+				"description": "OAuth 2.0 code/token callback URLs"
+			},
+			"permissions": {
+				"type": ["string"],
+				"description": "A list of permissions required by the application"
+			},
+			"clientKey": "string",
+			"javaScriptKey": "string",
+			"restApiKey": "string",
+			"windowsKey": "string",
+			"masterKey": "string",
+			"pushSettings": {
+				"apns": {
+					"production": {
+						"type": "boolean",
+						"description": [
+							"Production or development mode. It denotes what default APNS",
+							"servers to be used to send notifications.",
+							"See API documentation for more details."
+						]
+					},
+					"certData": {
+						"type": "string",
+						"description": "The certificate data loaded from the cert.pem file"
+					},
+					"keyData": {
+						"type": "string",
+						"description": "The key data loaded from the key.pem file"
+					},
+					"pushOptions": { "type": {
+						"gateway": "string",
+						"port": "number"
+					} },
+					"feedbackOptions": { "type": {
+						"gateway": "string",
+						"port": "number",
+						"batchFeedback": "boolean",
+						"interval": "number"
+					} }
+				},
+				"gcm": { "serverApiKey": "string" }
+			},
+			"authenticationEnabled": {
+				"type": "boolean",
+				"default": true
+			},
+			"anonymousAllowed": {
+				"type": "boolean",
+				"default": true
+			},
+			"authenticationSchemes": [{
+				"scheme": {
+					"type": "string",
+					"description": "See the API docs for the list of supported values."
+				},
+				"credential": {
+					"type": "object",
+					"description": "Scheme-specific credentials"
+				}
+			}],
+			"status": {
+				"type": "string",
+				"default": "sandbox",
+				"description": "Status of the application, production/sandbox/disabled"
+			},
+			"created": {
+				"type": "date",
+				"defaultFn": "now"
+			},
+			"modified": {
+				"type": "date",
+				"defaultFn": "now"
+			}
+		}
+	};
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_application();
+	}
+});

package/dist/common/models/change.cjs

@@ -0,0 +1,404 @@
+"use strict";
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_lib_globalize = require("../../lib/globalize.cjs");
+const require_lib_utils = require("../../lib/utils.cjs");
+//#region src/common/models/change.ts
+var require_change = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const g = require_lib_globalize;
+	const utils = require_lib_utils;
+	const crypto = require("crypto");
+	const assert = require("assert");
+	const debug = require("debug")("loopback:change");
+	function stableStringify(value) {
+		return JSON.stringify(sortForStableStringify(value));
+	}
+	function sortForStableStringify(value) {
+		if (value && typeof value.toJSON === "function") value = value.toJSON();
+		if (Array.isArray(value)) return value.map(sortForStableStringify);
+		if (value && typeof value === "object") {
+			const sorted = {};
+			Object.keys(value).sort().forEach(function(key) {
+				const sortedValue = sortForStableStringify(value[key]);
+				if (sortedValue !== void 0) sorted[key] = sortedValue;
+			});
+			return sorted;
+		}
+		return value;
+	}
+	module.exports = function(Change) {
+		Change.UPDATE = "update";
+		Change.CREATE = "create";
+		Change.DELETE = "delete";
+		Change.UNKNOWN = "unknown";
+		Change.Conflict = Conflict;
+		Change.setup = function() {
+			this.registry.getModel("PersistedModel").setup.call(this);
+			const Change = this;
+			Change.getter.id = function() {
+				if (!(this.modelName && this.modelId)) return null;
+				return Change.idForModel(this.modelName, this.modelId);
+			};
+		};
+		Change.setup();
+		Change.rectifyModelChanges = function(modelName, modelIds, callback) {
+			const Change = this;
+			const errors = [];
+			callback = callback || utils.createPromiseCallback();
+			const tasks = modelIds.map(function(id) {
+				return function(cb) {
+					Change.findOrCreateChange(modelName, id, function(err, change) {
+						if (err) return next(err);
+						change.rectify(next);
+					});
+					function next(err) {
+						if (err) {
+							err.modelName = modelName;
+							err.modelId = id;
+							errors.push(err);
+						}
+						cb();
+					}
+				};
+			});
+			Promise.all(tasks.map(function(task) {
+				return utils.invokeWithCallback(task, null, []);
+			})).then(function() {
+				if (errors.length) {
+					const desc = errors.map(function(e) {
+						return "#" + e.modelId + " - " + e.toString();
+					}).join("\n");
+					const err = new Error(g.f("Cannot rectify %s changes:\n%s", modelName, desc));
+					err.details = { errors };
+					return callback(err);
+				}
+				callback();
+			}, callback);
+			return callback.promise;
+		};
+		Change.idForModel = function(modelName, modelId) {
+			return this.hash([modelName, modelId].join("-"));
+		};
+		Change.findOrCreateChange = function(modelName, modelId, callback) {
+			assert(this.registry.findModel(modelName), modelName + " does not exist");
+			callback = callback || utils.createPromiseCallback();
+			const id = this.idForModel(modelName, modelId);
+			const Change = this;
+			this.findById(id, function(err, change) {
+				if (err) return callback(err);
+				if (change) callback(null, change);
+				else {
+					const ch = new Change({
+						id,
+						modelName,
+						modelId
+					});
+					ch.debug("creating change");
+					Change.updateOrCreate(ch, callback);
+				}
+			});
+			return callback.promise;
+		};
+		Change.prototype.rectify = function(cb) {
+			const change = this;
+			const currentRev = this.rev;
+			change.debug("rectify change");
+			cb = cb || utils.createPromiseCallback();
+			const model = this.getModelCtor();
+			const id = this.getModelId();
+			model.findById(id, function(err, inst) {
+				if (err) return cb(err);
+				if (inst) inst.fillCustomChangeProperties(change, function() {
+					prepareAndDoRectify(Change.revisionForInst(inst));
+				});
+				else prepareAndDoRectify(null);
+			});
+			return cb.promise;
+			function prepareAndDoRectify(rev) {
+				if (currentRev === rev) {
+					change.debug("rev and prev are equal (not updating anything)");
+					return cb(null, change);
+				}
+				change.constructor.getCheckpointModel().current(function(err, checkpoint) {
+					if (err) return cb(err);
+					doRectify(checkpoint, rev);
+				});
+			}
+			function doRectify(checkpoint, rev) {
+				if (rev) if (currentRev === rev) {
+					change.debug("ASSERTION FAILED: Change currentRev==rev should have been already handled");
+					return cb(null, change);
+				} else {
+					change.rev = rev;
+					change.debug("updated revision (was " + currentRev + ")");
+					if (change.checkpoint !== checkpoint) {
+						change.prev = currentRev;
+						change.debug("updated prev");
+					}
+				}
+				else {
+					change.rev = null;
+					change.debug("updated revision (was " + currentRev + ")");
+					if (change.checkpoint !== checkpoint) {
+						if (currentRev) change.prev = currentRev;
+						else if (!change.prev) {
+							change.debug("ERROR - could not determine prev");
+							change.prev = Change.UNKNOWN;
+						}
+						change.debug("updated prev");
+					}
+				}
+				if (change.checkpoint != checkpoint) {
+					debug("update checkpoint to", checkpoint);
+					change.checkpoint = checkpoint;
+				}
+				if (change.prev === Change.UNKNOWN) change.remove(cb);
+				else change.save(cb);
+			}
+		};
+		Change.prototype.currentRevision = function(cb) {
+			cb = cb || utils.createPromiseCallback();
+			const model = this.getModelCtor();
+			const id = this.getModelId();
+			model.findById(id, function(err, inst) {
+				if (err) return cb(err);
+				if (inst) cb(null, Change.revisionForInst(inst));
+				else cb(null, null);
+			});
+			return cb.promise;
+		};
+		Change.hash = function(str) {
+			return crypto.createHash(Change.settings.hashAlgorithm || "sha1").update(str).digest("hex");
+		};
+		Change.revisionForInst = function(inst) {
+			assert(inst, "Change.revisionForInst() requires an instance object.");
+			return this.hash(stableStringify(inst));
+		};
+		Change.prototype.type = function() {
+			if (this.rev && this.prev) return Change.UPDATE;
+			if (this.rev && !this.prev) return Change.CREATE;
+			if (!this.rev && this.prev) return Change.DELETE;
+			return Change.UNKNOWN;
+		};
+		Change.prototype.equals = function(change) {
+			if (!change) return false;
+			return (this.rev || null) === (change.rev || null);
+		};
+		Change.prototype.conflictsWith = function(change) {
+			if (!change) return false;
+			if (this.equals(change)) return false;
+			if (Change.bothDeleted(this, change)) return false;
+			if (this.isBasedOn(change)) return false;
+			return true;
+		};
+		Change.bothDeleted = function(a, b) {
+			return a.type() === Change.DELETE && b.type() === Change.DELETE;
+		};
+		Change.prototype.isBasedOn = function(change) {
+			return this.prev === change.rev;
+		};
+		Change.diff = function(modelName, since, remoteChanges, callback) {
+			callback = callback || utils.createPromiseCallback();
+			if (!Array.isArray(remoteChanges) || remoteChanges.length === 0) {
+				callback(null, {
+					deltas: [],
+					conflicts: []
+				});
+				return callback.promise;
+			}
+			const remoteChangeIndex = {};
+			const modelIds = [];
+			remoteChanges.forEach(function(ch) {
+				modelIds.push(ch.modelId);
+				remoteChangeIndex[ch.modelId] = new Change(ch);
+			});
+			since = Number(since) || 0;
+			this.find({ where: {
+				modelName,
+				modelId: { inq: modelIds }
+			} }, function(err, allLocalChanges) {
+				if (err) return callback(err);
+				const deltas = [];
+				const conflicts = [];
+				const localModelIds = [];
+				allLocalChanges.filter(function(c) {
+					return c.checkpoint >= since;
+				}).forEach(function(localChange) {
+					localChange = new Change(localChange);
+					localModelIds.push(localChange.modelId);
+					const remoteChange = remoteChangeIndex[localChange.modelId];
+					if (remoteChange && !localChange.equals(remoteChange)) if (remoteChange.conflictsWith(localChange)) {
+						remoteChange.debug("remote conflict");
+						localChange.debug("local conflict");
+						conflicts.push(localChange);
+					} else {
+						remoteChange.debug("remote delta");
+						deltas.push(remoteChange);
+					}
+				});
+				modelIds.forEach(function(id) {
+					if (localModelIds.indexOf(id) !== -1) return;
+					const d = remoteChangeIndex[id];
+					const oldChange = allLocalChanges.filter(function(c) {
+						return c.modelId === id;
+					})[0];
+					if (oldChange) d.prev = oldChange.rev;
+					else d.prev = null;
+					deltas.push(d);
+				});
+				callback(null, {
+					deltas,
+					conflicts
+				});
+			});
+			return callback.promise;
+		};
+		Change.rectifyAll = function(cb) {
+			debug("rectify all");
+			const Change = this;
+			cb = cb || utils.createPromiseCallback();
+			utils.invokeWithCallback(Change.find, Change, [{}]).then(async function(changes) {
+				for (const change of changes || []) await change.rectify();
+			}).then(function() {
+				cb();
+			}, cb);
+			return cb.promise;
+		};
+		Change.getCheckpointModel = function() {
+			let checkpointModel = this.Checkpoint;
+			if (checkpointModel) return checkpointModel;
+			this.Checkpoint = checkpointModel = this.registry.getModel("Checkpoint").extend("checkpoint");
+			assert(this.dataSource, "Cannot getCheckpointModel(): " + this.modelName + " is not attached to a dataSource");
+			checkpointModel.attachTo(this.dataSource);
+			return checkpointModel;
+		};
+		Change.prototype.debug = function() {
+			if (debug.enabled) {
+				const args = Array.prototype.slice.call(arguments);
+				args[0] = args[0] + " %s";
+				args.push(this.modelName);
+				debug.apply(this, args);
+				debug("	id", this.id);
+				debug("	rev", this.rev);
+				debug("	prev", this.prev);
+				debug("	checkpoint", this.checkpoint);
+				debug("	modelName", this.modelName);
+				debug("	modelId", this.modelId);
+				debug("	type", this.type());
+			}
+		};
+		Change.prototype.getModelCtor = function() {
+			return this.constructor.settings.trackModel;
+		};
+		Change.prototype.getModelId = function() {
+			const Model = this.getModelCtor();
+			const id = this.modelId;
+			const m = new Model();
+			m.setId(id);
+			return m.getId();
+		};
+		Change.prototype.getModel = function(callback) {
+			const Model = this.constructor.settings.trackModel;
+			const id = this.getModelId();
+			Model.findById(id, callback);
+		};
+		function Conflict(modelId, SourceModel, TargetModel) {
+			this.SourceModel = SourceModel;
+			this.TargetModel = TargetModel;
+			this.SourceChange = SourceModel.getChangeModel();
+			this.TargetChange = TargetModel.getChangeModel();
+			this.modelId = modelId;
+		}
+		Conflict.prototype.models = function(cb) {
+			const conflict = this;
+			const SourceModel = this.SourceModel;
+			const TargetModel = this.TargetModel;
+			const promise = Promise.all([utils.invokeWithCallback(SourceModel.findById, SourceModel, [conflict.modelId]), utils.invokeWithCallback(TargetModel.findById, TargetModel, [conflict.modelId])]);
+			if (typeof cb === "function") {
+				promise.then(function(results) {
+					cb(null, results[0], results[1]);
+				}, cb);
+				return;
+			}
+			return promise.then(function(results) {
+				return {
+					source: results[0],
+					target: results[1]
+				};
+			});
+		};
+		Conflict.prototype.changes = function(cb) {
+			const conflict = this;
+			const promise = Promise.all([utils.invokeWithCallback(conflict.SourceModel.findLastChange, conflict.SourceModel, [conflict.modelId]), utils.invokeWithCallback(conflict.TargetModel.findLastChange, conflict.TargetModel, [conflict.modelId])]);
+			if (typeof cb === "function") {
+				promise.then(function(results) {
+					cb(null, results[0], results[1]);
+				}, cb);
+				return;
+			}
+			return promise.then(function(results) {
+				return {
+					sourceChange: results[0],
+					targetChange: results[1]
+				};
+			});
+		};
+		Conflict.prototype.resolve = function(cb) {
+			const conflict = this;
+			cb = cb || utils.createPromiseCallback();
+			utils.invokeWithCallback(conflict.TargetModel.findLastChange, conflict.TargetModel, [this.modelId]).then(function(targetChange) {
+				return utils.invokeWithCallback(conflict.SourceModel.updateLastChange, conflict.SourceModel, [conflict.modelId, { prev: targetChange.rev }]);
+			}).then(function(result) {
+				cb(null, result);
+			}, cb);
+			return cb.promise;
+		};
+		Conflict.prototype.resolveUsingSource = function(cb) {
+			this.resolve(function(err) {
+				cb(err);
+			});
+		};
+		Conflict.prototype.resolveUsingTarget = function(cb) {
+			const conflict = this;
+			conflict.models(function(err, source, target) {
+				if (err) return done(err);
+				if (target === null) return conflict.SourceModel.deleteById(conflict.modelId, done);
+				new conflict.SourceModel(target.toObject(), { persisted: true }).save(done);
+			});
+			function done(err) {
+				cb(err);
+			}
+		};
+		Conflict.prototype.swapParties = function() {
+			const Ctor = this.constructor;
+			return new Ctor(this.modelId, this.TargetModel, this.SourceModel);
+		};
+		Conflict.prototype.resolveManually = function(data, cb) {
+			const conflict = this;
+			if (!data) return conflict.SourceModel.deleteById(conflict.modelId, done);
+			conflict.models(function(err, source, target) {
+				if (err) return done(err);
+				const inst = source || new conflict.SourceModel(target);
+				inst.setAttributes(data);
+				inst.save(function(err) {
+					if (err) return done(err);
+					conflict.resolve(done);
+				});
+			});
+			function done(err) {
+				cb(err);
+			}
+		};
+		Conflict.prototype.type = function(cb) {
+			this.changes(function(err, sourceChange, targetChange) {
+				if (err) return cb(err);
+				const sourceChangeType = sourceChange.type();
+				const targetChangeType = targetChange.type();
+				if (sourceChangeType === Change.UPDATE && targetChangeType === Change.UPDATE) return cb(null, Change.UPDATE);
+				if (sourceChangeType === Change.DELETE || targetChangeType === Change.DELETE) return cb(null, Change.DELETE);
+				return cb(null, Change.UNKNOWN);
+			});
+		};
+	};
+}));
+//#endregion
+module.exports = require_change();

package/dist/common/models/change2.cjs

@@ -0,0 +1,25 @@
+//#region common/models/change.json
+var require_change = /* @__PURE__ */ require("../../_virtual/_rolldown/runtime.cjs").__commonJSMin(((exports, module) => {
+	module.exports = {
+		"name": "Change",
+		"trackChanges": false,
+		"properties": {
+			"id": {
+				"type": "string",
+				"id": true
+			},
+			"rev": { "type": "string" },
+			"prev": { "type": "string" },
+			"checkpoint": { "type": "number" },
+			"modelName": { "type": "string" },
+			"modelId": { "type": "string" }
+		}
+	};
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_change();
+	}
+});

package/dist/common/models/checkpoint.cjs

@@ -0,0 +1,43 @@
+"use strict";
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_lib_utils = require("../../lib/utils.cjs");
+//#region src/common/models/checkpoint.ts
+var require_checkpoint = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const utils = require_lib_utils;
+	function configureCheckpoint(Checkpoint) {
+		Checkpoint.definition.rawProperties.time.default = Checkpoint.definition.properties.time.default = function() {
+			return /* @__PURE__ */ new Date();
+		};
+		Checkpoint.current = function(cb) {
+			cb = cb || utils.createPromiseCallback();
+			utils.invokeWithCallback(this._getSingleton, this, []).then(function(cp) {
+				cb(null, cp.seq);
+			}, cb);
+			return cb.promise;
+		};
+		Checkpoint._getSingleton = function(cb) {
+			cb = cb || utils.createPromiseCallback();
+			this.findOrCreate({ limit: 1 }, { seq: 1 }, cb);
+			return cb.promise;
+		};
+		Checkpoint.bumpLastSeq = function(cb) {
+			cb = cb || utils.createPromiseCallback();
+			(async function() {
+				const cp = await utils.invokeWithCallback(this._getSingleton, this, []);
+				const originalSeq = cp.seq;
+				cp.seq++;
+				await utils.invokeWithCallback(this.updateAll, this, [{
+					id: cp.id,
+					seq: originalSeq
+				}, { seq: cp.seq }]);
+				return cp;
+			}).call(this).then(function(cp) {
+				cb(null, cp);
+			}, cb);
+			return cb.promise;
+		};
+	}
+	module.exports = configureCheckpoint;
+}));
+//#endregion
+module.exports = require_checkpoint();