@vsaas/loopback 10.0.0

package/dist/lib/application.cjs

@@ -0,0 +1,450 @@
+"use strict";
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_lib_globalize = require("./globalize.cjs");
+const require_lib_utils = require("./utils.cjs");
+require("./registry.cjs");
+//#region src/lib/application.ts
+/*!
+* Module dependencies.
+*/
+var require_application = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const path = require("path");
+	const g = require_lib_globalize;
+	const DataSource = require("@vsaas/loopback-datasource-juggler").DataSource;
+	const assert = require("assert");
+	const fs = require("fs");
+	const RemoteObjects = require("@vsaas/remoting");
+	require("util");
+	const utils = require_lib_utils;
+	function camelize(name) {
+		return String(name).trim().replace(/[^A-Za-z0-9]+(.)?/g, function(match, chr) {
+			return chr ? chr.toUpperCase() : "";
+		});
+	}
+	function classify(name) {
+		const result = camelize(name);
+		if (!result) return result;
+		return result.charAt(0).toUpperCase() + result.slice(1);
+	}
+	/*!
+	* Export the app prototype.
+	*/
+	const app = module.exports = {};
+	/**
+	* Lazily load a set of [remote objects](http://apidocs.strongloop.com/strong-remoting/#remoteobjectsoptions).
+	*
+	* **NOTE:** Calling `app.remotes()` more than once returns only a single set of remote objects.
+	* @returns {RemoteObjects}
+	*/
+	app.remotes = function() {
+		if (this._remotes) return this._remotes;
+		else {
+			let options = {};
+			if (this.get) options = this.get("remoting");
+			return this._remotes = RemoteObjects.create(options);
+		}
+	};
+	/*!
+	* Remove a route by reference.
+	*/
+	app.disuse = function(route) {
+		if (this.stack) {
+			for (let i = 0; i < this.stack.length; i++) if (this.stack[i].route === route) this.stack.splice(i, 1);
+		}
+	};
+	/**
+	* Attach a model to the app. The `Model` will be available on the
+	* `app.models` object.
+	*
+	* Example - Attach an existing model:
+	```js
+	* var User = loopback.User;
+	* app.model(User);
+	*```
+	* Example - Attach an existing model, alter some aspects of the model:
+	* ```js
+	* var User = loopback.User;
+	* app.model(User, { dataSource: 'db' });
+	*```
+	*
+	* @param {Object} Model The model to attach.
+	* @options {Object} config The model's configuration.
+	* @property {String|DataSource} dataSource The `DataSource` to which to attach the model.
+	* @property {Boolean} [public] Whether the model should be exposed via REST API.
+	* @property {Object} [relations] Relations to add/update.
+	* @end
+	* @returns {ModelConstructor} the model class
+	*/
+	app.model = function(Model, config) {
+		let isPublic = true;
+		this.registry;
+		if (typeof Model === "string") throw new Error("app.model(modelName, settings) is no longer supported. Use app.registry.createModel(modelName, definition) and app.model(ModelCtor, config) instead.");
+		if (arguments.length > 1) {
+			config = config || {};
+			configureModel(Model, config, this);
+			isPublic = config.public !== false;
+		} else assert(Model.prototype instanceof Model.registry.getModel("Model"), Model.modelName + " must be a descendant of loopback.Model");
+		const modelName = Model.modelName;
+		this.models[modelName] = this.models[classify(modelName)] = this.models[camelize(modelName)] = Model;
+		this.models().push(Model);
+		if (isPublic && Model.sharedClass) {
+			this.remotes().defineObjectType(Model.modelName, function(data) {
+				return new Model(data);
+			});
+			this.remotes().addClass(Model.sharedClass);
+			if (Model.settings.trackChanges && Model.Change) this.remotes().addClass(Model.Change.sharedClass);
+			clearHandlerCache(this);
+			this.emit("modelRemoted", Model.sharedClass);
+		}
+		const self = this;
+		Model.on("remoteMethodDisabled", function(model, methodName) {
+			clearHandlerCache(self);
+			self.emit("remoteMethodDisabled", model, methodName);
+		});
+		Model.on("remoteMethodAdded", function(model) {
+			clearHandlerCache(self);
+			self.emit("remoteMethodAdded", model);
+		});
+		Model.shared = isPublic;
+		Model.app = this;
+		Model.emit("attached", this);
+		return Model;
+	};
+	/**
+	* Remove all references to a previously registered Model.
+	*
+	* The method emits "modelDeleted" event as a counter-part to "modelRemoted"
+	* event.
+	*
+	* @param {String} modelName The name of the model to remove.
+	*/
+	app.deleteModelByName = function(modelName) {
+		const ModelCtor = this.models[modelName];
+		delete this.models[modelName];
+		delete this.models[classify(modelName)];
+		delete this.models[camelize(modelName)];
+		if (ModelCtor) {
+			ModelCtor.removeAllListeners();
+			const ix = this._models.indexOf(ModelCtor);
+			if (ix > -1) this._models.splice(ix, 1);
+		}
+		const remotes = this.remotes();
+		remotes.deleteClassByName(modelName);
+		remotes.deleteTypeByName(modelName);
+		if (ModelCtor && ModelCtor.dataSource) ModelCtor.dataSource.deleteModelByName(modelName);
+		else this.registry.modelBuilder.deleteModelByName(modelName);
+		clearHandlerCache(this);
+		this.emit("modelDeleted", ModelCtor || modelName);
+	};
+	/**
+	* Get the models exported by the app. Returns only models defined using `app.model()`
+	*
+	* There are two ways to access models:
+	*
+	* 1.  Call `app.models()` to get a list of all models.
+	*
+	* ```js
+	* var models = app.models();
+	*
+	* models.forEach(function(Model) {
+	*  console.log(Model.modelName); // color
+	* });
+	* ```
+	*
+	* 2. Use `app.models` to access a model by name.
+	* `app.models` has properties for all defined models.
+	*
+	* The following example illustrates accessing the `Product` and `CustomerReceipt` models
+	* using the `models` object.
+	*
+	* ```js
+	* var loopback = require('loopback');
+	*  var app = loopback();
+	*  app.boot({
+	*   dataSources: {
+	*     db: {connector: 'memory'}
+	*   }
+	* });
+	*
+	* var productModel = app.registry.createModel('product');
+	* app.model(productModel, {dataSource: 'db'});
+	* var customerReceiptModel = app.registry.createModel('customer-receipt');
+	* app.model(customerReceiptModel, {dataSource: 'db'});
+	*
+	* // available based on the given name
+	* var Product = app.models.Product;
+	*
+	* // also available as camelCase
+	* var product = app.models.product;
+	*
+	* // multi-word models are avaiable as pascal cased
+	* var CustomerReceipt = app.models.CustomerReceipt;
+	*
+	* // also available as camelCase
+	* var customerReceipt = app.models.customerReceipt;
+	* ```
+	*
+	* @returns {Array} Array of model classes.
+	*/
+	app.models = function() {
+		return this._models || (this._models = []);
+	};
+	/**
+	* Define a DataSource.
+	*
+	* @param {String} name The data source name
+	* @param {Object} config The data source config
+	*/
+	app.dataSource = function(name, config) {
+		try {
+			const ds = dataSourcesFromConfig(name, config, this.connectors, this.registry);
+			this.dataSources[name] = this.dataSources[classify(name)] = this.dataSources[camelize(name)] = ds;
+			ds.app = this;
+			return ds;
+		} catch (err) {
+			if (err.message) err.message = g.f("Cannot create data source %s: %s", JSON.stringify(name), err.message);
+			throw err;
+		}
+	};
+	/**
+	* Register a connector.
+	*
+	* When a new data-source is being added via `app.dataSource`, the connector
+	* name is looked up in the registered connectors first.
+	*
+	* Connectors are required to be explicitly registered only for applications
+	* using browserify, because browserify does not support dynamic require,
+	* which is used by LoopBack to automatically load the connector module.
+	*
+	* @param {String} name Name of the connector, e.g. 'mysql'.
+	* @param {Object} connector Connector object as returned
+	*   by `require('loopback-connector-{name}')`.
+	*/
+	app.connector = function(name, connector) {
+		this.connectors[name] = this.connectors[classify(name)] = this.connectors[camelize(name)] = connector;
+	};
+	/**
+	* Get all remote objects.
+	* @returns {Object} [Remote objects](http://apidocs.strongloop.com/strong-remoting/#remoteobjectsoptions).
+	*/
+	app.remoteObjects = function() {
+		const result = {};
+		this.remotes().classes().forEach(function(sharedClass) {
+			result[sharedClass.name] = sharedClass.ctor;
+		});
+		return result;
+	};
+	/*!
+	* Get a handler of the specified type from the handler cache.
+	* @triggers `mounted` events on shared class constructors (models)
+	*/
+	app.handler = function(type, options) {
+		const handlers = this._handlers || (this._handlers = {});
+		if (handlers[type]) return handlers[type];
+		const remotes = this.remotes();
+		const handler = this._handlers[type] = remotes.handler(type, options);
+		remotes.classes().forEach(function(sharedClass) {
+			sharedClass.ctor.emit("mounted", app, sharedClass, remotes);
+		});
+		return handler;
+	};
+	/**
+	* An object to store dataSource instances.
+	*/
+	app.dataSources = app.datasources = {};
+	/**
+	* Enable app wide authentication.
+	*/
+	app.enableAuth = function(options) {
+		const AUTH_MODELS = [
+			"User",
+			"AccessToken",
+			"ACL",
+			"Role",
+			"RoleMapping"
+		];
+		const remotes = this.remotes();
+		const app = this;
+		if (options && options.dataSource) {
+			const appModels = app.registry.modelBuilder.models;
+			AUTH_MODELS.forEach(function(m) {
+				const Model = app.registry.findModel(m);
+				if (!Model) throw new Error(g.f("Authentication requires model %s to be defined.", m));
+				if (Model.dataSource || Model.app) return;
+				for (const name in appModels) {
+					const candidate = appModels[name];
+					const isSubclass = candidate.prototype instanceof Model;
+					const isAttached = !!candidate.dataSource || !!candidate.app;
+					if (isSubclass && isAttached) return;
+				}
+				app.model(Model, {
+					dataSource: options.dataSource,
+					public: m === "User"
+				});
+			});
+		}
+		remotes.authorization = function(ctx, next) {
+			const method = ctx.method;
+			const req = ctx.req;
+			const Model = method.ctor;
+			const modelInstance = ctx.instance;
+			const modelId = modelInstance && modelInstance.id || (req.params && req.params.id !== void 0 ? req.params.id : req.body && req.body.id !== void 0 ? req.body.id : req.query && req.query.id !== void 0 ? req.query.id : void 0);
+			const modelName = Model.modelName;
+			let errStatusCode = (Model.settings || {}).aclErrorStatus || app.get("aclErrorStatus") || 401;
+			if (!req.accessToken) errStatusCode = 401;
+			if (Model.checkAccess) utils.invokeWithCallback(Model.checkAccess, Model, [
+				req.accessToken,
+				modelId,
+				method,
+				ctx
+			]).then(function(allowed) {
+				if (allowed) return next();
+				const messages = {
+					403: {
+						message: g.f("Access Denied"),
+						code: "ACCESS_DENIED"
+					},
+					404: {
+						message: g.f("could not find %s with id %s", modelName, modelId),
+						code: "MODEL_NOT_FOUND"
+					},
+					401: {
+						message: g.f("Authorization Required"),
+						code: "AUTHORIZATION_REQUIRED"
+					}
+				};
+				const e = new Error(messages[errStatusCode].message || messages[403].message);
+				e.statusCode = errStatusCode;
+				e.code = messages[errStatusCode].code || messages[403].code;
+				next(e);
+			}, function(err) {
+				console.log(err);
+				next(err);
+			});
+			else next();
+		};
+		this._verifyAuthModelRelations();
+		this.isAuthEnabled = true;
+	};
+	app._verifyAuthModelRelations = function() {
+		if (this.get("_verifyAuthModelRelations") === false) return;
+		const AccessToken = this.registry.findModel("AccessToken");
+		const User = this.registry.findModel("User");
+		this.models().forEach((Model) => {
+			if (Model === AccessToken || Model.prototype instanceof AccessToken) scheduleVerification(Model, verifyAccessTokenRelations);
+			if (Model === User || Model.prototype instanceof User) scheduleVerification(Model, verifyUserRelations);
+		});
+		function scheduleVerification(Model, verifyFn) {
+			if (Model.dataSource) verifyFn(Model);
+			else Model.on("attached", () => verifyFn(Model));
+		}
+		function verifyAccessTokenRelations(Model) {
+			if (Model.relations && Model.relations.user) return;
+			const userName = ((Model.settings.relations || {}).user || {}).model;
+			if (userName) {
+				console.warn("The model %j configures \"belongsTo User-like models\" relation with target model %j. However, the model %j is not attached to the application and therefore cannot be used by this relation. This typically happens when the application has a custom custom User subclass, but does not fix AccessToken relations to use this new model.\nLearn more at http://ibm.biz/setup-loopback-auth", Model.modelName, userName, userName);
+				return;
+			}
+			console.warn("The model %j does not have \"belongsTo User-like model\" relation configured.\nLearn more at http://ibm.biz/setup-loopback-auth", Model.modelName);
+		}
+		function verifyUserRelations(Model) {
+			const hasManyTokens = Model.relations && Model.relations.accessTokens;
+			if (hasManyTokens) {
+				if (hasManyTokens.polymorphic) console.warn("The app configuration follows the multiple user models setup as described in http://ibm.biz/setup-loopback-auth", "The built-in role resolver $owner is not currently compatible with this configuration and should not be used in production.");
+				return;
+			}
+			const accessTokenName = ((Model.settings.relations || {}).accessTokens || {}).model;
+			if (accessTokenName) {
+				console.warn("The model %j configures \"hasMany AccessToken-like models\" relation with target model %j. However, the model %j is not attached to the application and therefore cannot be used by this relation. This typically happens when the application has a custom AccessToken subclass, but does not fix User relations to use this new model.\nLearn more at http://ibm.biz/setup-loopback-auth", Model.modelName, accessTokenName, accessTokenName);
+				return;
+			}
+			console.warn("The model %j does not have \"hasMany AccessToken-like models\" relation configured.\nLearn more at http://ibm.biz/setup-loopback-auth", Model.modelName);
+		}
+	};
+	app.boot = function(options) {
+		throw new Error(g.f("{{`app.boot`}} was removed, use the new module {{loopback-boot}} instead"));
+	};
+	function dataSourcesFromConfig(name, config, connectorRegistry, registry) {
+		let connectorPath;
+		assert(typeof config === "object", "can not create data source without config object");
+		if (typeof config.connector === "string") {
+			const connectorName = config.connector;
+			if (connectorRegistry[connectorName]) config.connector = connectorRegistry[connectorName];
+			else {
+				connectorPath = path.join(__dirname, "connectors", connectorName + ".cjs");
+				if (fs.existsSync(connectorPath)) config.connector = require(connectorPath);
+			}
+			if (config.connector && typeof config.connector === "object" && !config.connector.name) config.connector.name = connectorName;
+		}
+		return registry.createDataSource(name, config);
+	}
+	function configureModel(ModelCtor, config, app) {
+		assert(ModelCtor.prototype instanceof ModelCtor.registry.getModel("Model"), ModelCtor.modelName + " must be a descendant of loopback.Model");
+		let dataSource = config.dataSource;
+		if (dataSource) {
+			if (typeof dataSource === "string") dataSource = app.dataSources[dataSource];
+			assert(dataSource instanceof DataSource, ModelCtor.modelName + " is referencing a dataSource that does not exist: \"" + config.dataSource + "\"");
+		}
+		config = Object.assign({}, config);
+		config.dataSource = dataSource;
+		app.registry.configureModel(ModelCtor, config);
+	}
+	function clearHandlerCache(app) {
+		app._handlers = void 0;
+	}
+	/**
+	* Listen for connections and update the configured port.
+	*
+	* When there are no parameters or there is only one callback parameter,
+	* the server will listen on `app.get('host')` and `app.get('port')`.
+	*
+	* For example, to listen on host/port configured in app config:
+	* ```js
+	* app.listen();
+	* ```
+	*
+	* Otherwise all arguments are forwarded to `http.Server.listen`.
+	*
+	* For example, to listen on the specified port and all hosts, and ignore app config.
+	* ```js
+	* app.listen(80);
+	* ```
+	*
+	* The function also installs a `listening` callback that calls
+	* `app.set('port')` with the value returned by `server.address().port`.
+	* This way the port param contains always the real port number, even when
+	* listen was called with port number 0.
+	*
+	* @param {Function} [cb] If specified, the callback is added as a listener
+	*   for the server's "listening" event.
+	* @returns {http.Server} A node `http.Server` with this application configured
+	*   as the request handler.
+	*/
+	app.listen = function(cb) {
+		const self = this;
+		const server = require("http").createServer(this);
+		server.on("listening", function() {
+			self.set("port", this.address().port);
+			let listeningOnAll = false;
+			let host = self.get("host");
+			if (!host) {
+				listeningOnAll = true;
+				host = this.address().address;
+				self.set("host", host);
+			} else if (host === "0.0.0.0" || host === "::") listeningOnAll = true;
+			if (!self.get("url")) {
+				if (listeningOnAll) host = "localhost";
+				const url = "http://" + host + ":" + self.get("port") + "/";
+				self.set("url", url);
+			}
+		});
+		if (arguments.length === 0 || arguments.length == 1 && typeof arguments[0] == "function") {
+			let port = this.get("port");
+			if (port === void 0) port = 0;
+			server.listen(port, this.get("host"), cb);
+		} else server.listen.apply(server, arguments);
+		return server;
+	};
+}));
+//#endregion
+module.exports = require_application();

package/dist/lib/builtin-models.cjs

@@ -0,0 +1,60 @@
+"use strict";
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_key_value_model$2 = require("../common/models/key-value-model2.cjs");
+const require_common_models_key_value_model = require("../common/models/key-value-model.cjs");
+const require_email$2 = require("../common/models/email2.cjs");
+const require_common_models_email = require("../common/models/email.cjs");
+const require_application$2 = require("../common/models/application2.cjs");
+const require_common_models_application = require("../common/models/application.cjs");
+const require_access_token$2 = require("../common/models/access-token2.cjs");
+const require_common_models_access_token = require("../common/models/access-token.cjs");
+const require_user$2 = require("../common/models/user2.cjs");
+const require_common_models_user = require("../common/models/user.cjs");
+const require_role_mapping$2 = require("../common/models/role-mapping2.cjs");
+const require_common_models_role_mapping = require("../common/models/role-mapping.cjs");
+const require_role$2 = require("../common/models/role2.cjs");
+const require_common_models_role = require("../common/models/role.cjs");
+const require_acl$2 = require("../common/models/acl2.cjs");
+const require_common_models_acl = require("../common/models/acl.cjs");
+const require_scope$2 = require("../common/models/scope2.cjs");
+const require_common_models_scope = require("../common/models/scope.cjs");
+const require_change$2 = require("../common/models/change2.cjs");
+const require_common_models_change = require("../common/models/change.cjs");
+const require_checkpoint$2 = require("../common/models/checkpoint2.cjs");
+const require_common_models_checkpoint = require("../common/models/checkpoint.cjs");
+//#region src/lib/builtin-models.ts
+var require_builtin_models = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const assert = require("assert");
+	function defineBuiltinModels(registry) {
+		registry.KeyValueModel = createModel(registry, require_key_value_model$2.default, require_common_models_key_value_model);
+		registry.Email = createModel(registry, require_email$2.default, require_common_models_email);
+		registry.Application = createModel(registry, require_application$2.default, require_common_models_application);
+		registry.AccessToken = createModel(registry, require_access_token$2.default, require_common_models_access_token);
+		registry.User = createModel(registry, require_user$2.default, require_common_models_user);
+		registry.RoleMapping = createModel(registry, require_role_mapping$2.default, require_common_models_role_mapping);
+		registry.Role = createModel(registry, require_role$2.default, require_common_models_role);
+		registry.ACL = createModel(registry, require_acl$2.default, require_common_models_acl);
+		registry.Scope = createModel(registry, require_scope$2.default, require_common_models_scope);
+		registry.Change = createModel(registry, require_change$2.default, require_common_models_change);
+		registry.Checkpoint = createModel(registry, require_checkpoint$2.default, require_common_models_checkpoint);
+	}
+	function createModel(registry, definitionJson, customizeModel) {
+		const definition = cloneDeepJson(definitionJson);
+		const Model = registry.createModel(definition);
+		customizeModel(Model);
+		return Model;
+	}
+	function cloneDeepJson(obj) {
+		const result = Array.isArray(obj) ? [] : {};
+		assert.equal(Object.getPrototypeOf(result), Object.getPrototypeOf(obj));
+		for (const key in obj) {
+			const value = obj[key];
+			if (typeof value === "object") result[key] = cloneDeepJson(value);
+			else result[key] = value;
+		}
+		return result;
+	}
+	module.exports = defineBuiltinModels;
+}));
+//#endregion
+module.exports = require_builtin_models();

package/dist/lib/configure-shared-methods.cjs

@@ -0,0 +1,41 @@
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_lib_globalize = require("./globalize.cjs");
+//#region src/lib/configure-shared-methods.ts
+var require_configure_shared_methods = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const g = require_lib_globalize;
+	function configureSharedMethods(modelCtor, remotingConfig, modelConfig) {
+		const settings = {};
+		if (remotingConfig && remotingConfig.sharedMethods && typeof remotingConfig.sharedMethods === "object") Object.assign(settings, remotingConfig.sharedMethods);
+		const options = modelConfig.options;
+		if (options && options.remoting && options.remoting.sharedMethods && typeof options.remoting.sharedMethods === "object") Object.assign(settings, options.remoting.sharedMethods);
+		Object.keys(settings).forEach(function(setting) {
+			const settingValueType = typeof settings[setting];
+			if (settingValueType !== "boolean") throw new TypeError(g.f("Expected boolean, got %s", settingValueType));
+		});
+		const sharedMethods = modelCtor.sharedClass.methods({ includeDisabled: true });
+		const tests = Object.keys(settings).filter(function(setting) {
+			return Object.prototype.hasOwnProperty.call(settings, setting) && setting.indexOf("*") >= 0;
+		}).map(function(setting) {
+			const glob = escapeRegExp(setting).replace(/\*/g, "(.)*");
+			return {
+				regex: new RegExp(glob),
+				setting: settings[setting]
+			};
+		}) || [];
+		sharedMethods.forEach(function(sharedMethod) {
+			const methodName = sharedMethod.isStatic ? sharedMethod.name : "prototype." + sharedMethod.name;
+			if (Object.prototype.hasOwnProperty.call(settings, methodName)) if (settings[methodName] === false) sharedMethod.sharedClass.disableMethodByName(methodName);
+			else sharedMethod.shared = true;
+			else tests.forEach(function(glob) {
+				if (glob.regex.test(methodName)) if (glob.setting === false) sharedMethod.sharedClass.disableMethodByName(methodName);
+				else sharedMethod.shared = true;
+			});
+		});
+	}
+	function escapeRegExp(str) {
+		return str.replace(/[-/\\^$+?.()|[\]{}]/g, "\\$&");
+	}
+	module.exports = configureSharedMethods;
+}));
+//#endregion
+module.exports = require_configure_shared_methods();

package/dist/lib/connectors/base-connector.cjs

@@ -0,0 +1,23 @@
+"use strict";
+//#region src/lib/connectors/base-connector.ts
+/**
+* Expose `Connector`.
+*/
+var require_base_connector = /* @__PURE__ */ require("../../_virtual/_rolldown/runtime.cjs").__commonJSMin(((exports, module) => {
+	const EventEmitter = require("events").EventEmitter;
+	const debug = require("debug")("connector");
+	const inherits = require("util").inherits;
+	function Connector(options) {
+		EventEmitter.apply(this, arguments);
+		this.options = options;
+		debug("created with options", options);
+	}
+	inherits(Connector, EventEmitter);
+	Connector._createJDBAdapter = function(jdbModule) {
+		jdbModule.initialize({}, function() {});
+	};
+	Connector.prototype._addCrudOperationsFromJDBAdapter = function(connector) {};
+	module.exports = Connector;
+}));
+//#endregion
+module.exports = require_base_connector();