@vsaas/loopback 10.0.0

package/dist/common/models/user2.cjs

@@ -0,0 +1,118 @@
+//#region common/models/user.json
+var require_user = /* @__PURE__ */ require("../../_virtual/_rolldown/runtime.cjs").__commonJSMin(((exports, module) => {
+	module.exports = {
+		"name": "User",
+		"properties": {
+			"realm": { "type": "string" },
+			"username": { "type": "string" },
+			"password": {
+				"type": "string",
+				"required": true
+			},
+			"email": {
+				"type": "string",
+				"required": true
+			},
+			"emailVerified": "boolean",
+			"verificationToken": "string"
+		},
+		"options": { "caseSensitiveEmail": true },
+		"hidden": ["password", "verificationToken"],
+		"acls": [
+			{
+				"principalType": "ROLE",
+				"principalId": "$everyone",
+				"permission": "DENY"
+			},
+			{
+				"principalType": "ROLE",
+				"principalId": "$everyone",
+				"permission": "ALLOW",
+				"property": "create"
+			},
+			{
+				"principalType": "ROLE",
+				"principalId": "$owner",
+				"permission": "ALLOW",
+				"property": "deleteById"
+			},
+			{
+				"principalType": "ROLE",
+				"principalId": "$everyone",
+				"permission": "ALLOW",
+				"property": "login"
+			},
+			{
+				"principalType": "ROLE",
+				"principalId": "$everyone",
+				"permission": "ALLOW",
+				"property": "logout"
+			},
+			{
+				"principalType": "ROLE",
+				"principalId": "$owner",
+				"permission": "ALLOW",
+				"property": "findById"
+			},
+			{
+				"principalType": "ROLE",
+				"principalId": "$owner",
+				"permission": "ALLOW",
+				"property": "patchAttributes"
+			},
+			{
+				"principalType": "ROLE",
+				"principalId": "$owner",
+				"permission": "ALLOW",
+				"property": "replaceById"
+			},
+			{
+				"principalType": "ROLE",
+				"principalId": "$everyone",
+				"permission": "ALLOW",
+				"property": "verify",
+				"accessType": "EXECUTE"
+			},
+			{
+				"principalType": "ROLE",
+				"principalId": "$everyone",
+				"permission": "ALLOW",
+				"property": "confirm"
+			},
+			{
+				"principalType": "ROLE",
+				"principalId": "$everyone",
+				"permission": "ALLOW",
+				"property": "resetPassword",
+				"accessType": "EXECUTE"
+			},
+			{
+				"principalType": "ROLE",
+				"principalId": "$authenticated",
+				"permission": "ALLOW",
+				"property": "changePassword",
+				"accessType": "EXECUTE"
+			},
+			{
+				"principalType": "ROLE",
+				"principalId": "$authenticated",
+				"permission": "ALLOW",
+				"property": "setPassword",
+				"accessType": "EXECUTE"
+			}
+		],
+		"relations": { "accessTokens": {
+			"type": "hasMany",
+			"model": "AccessToken",
+			"foreignKey": "userId",
+			"options": { "disableInclude": true }
+		} }
+	};
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_user();
+	}
+});

package/dist/index.cjs

@@ -0,0 +1,16 @@
+const require_lib_loopback = require("./lib/loopback.cjs");
+const require_lib_connectors_base_connector = require("./lib/connectors/base-connector.cjs");
+const require_lib_connectors_memory = require("./lib/connectors/memory.cjs");
+const require_lib_connectors_mail = require("./lib/connectors/mail.cjs");
+//#region src/index.ts
+const loopback = require_lib_loopback;
+require("@vsaas/loopback-datasource-juggler");
+loopback.Connector = require_lib_connectors_base_connector;
+loopback.Memory = require_lib_connectors_memory;
+loopback.Mail = require_lib_connectors_mail;
+loopback.Remote = require("@vsaas/loopback-connector-remote");
+loopback.GeoPoint = require("@vsaas/loopback-datasource-juggler/geo").GeoPoint;
+loopback.DateString = require("@vsaas/loopback-datasource-juggler/date-string");
+loopback.ValidationError = loopback.Model.ValidationError;
+module.exports = loopback;
+//#endregion

package/dist/lib/access-context.cjs

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime$1 = require("../_virtual/_rolldown/runtime.cjs");
+const require_lib_runtime = require("./runtime.cjs");
+//#region src/lib/access-context.ts
+var access_context_exports = /* @__PURE__ */ require_runtime$1.__exportAll({
+	AccessContext: () => AccessContext,
+	AccessRequest: () => AccessRequest,
+	DEFAULT_SCOPES: () => DEFAULT_SCOPES,
+	Principal: () => Principal
+});
+function AccessContext(context) {
+	if (!(this instanceof AccessContext)) return new AccessContext(context);
+	context = context || {};
+	assert(context.registry, "Application registry is mandatory in AccessContext but missing in provided context");
+	this.registry = context.registry;
+	this.principals = context.principals || [];
+	let model = context.model;
+	model = typeof model === "string" ? this.registry.getModel(model) : model;
+	this.model = model;
+	this.modelName = model && model.modelName;
+	this.modelId = context.id || context.modelId;
+	this.property = context.property || AccessContext.ALL;
+	this.method = context.method;
+	this.sharedMethod = context.sharedMethod;
+	this.sharedClass = this.sharedMethod && this.sharedMethod.sharedClass;
+	if (this.sharedMethod) this.methodNames = this.sharedMethod.aliases.concat([this.sharedMethod.name]);
+	else this.methodNames = [];
+	if (this.sharedMethod) this.accessType = this.model._getAccessTypeForMethod(this.sharedMethod);
+	this.accessType = context.accessType || AccessContext.ALL;
+	const loopback = runtime.loopback;
+	assert(loopback.AccessToken, "AccessToken model must be defined before AccessContext model");
+	this.accessToken = context.accessToken || loopback.AccessToken.ANONYMOUS;
+	const principalType = context.principalType || Principal.USER;
+	const principalId = context.principalId || void 0;
+	const principalName = context.principalName || void 0;
+	if (principalId != null) this.addPrincipal(principalType, principalId, principalName);
+	const token = this.accessToken;
+	if (token.userId != null) this.addPrincipal(token.principalType || Principal.USER, token.userId);
+	if (token.appId != null) this.addPrincipal(Principal.APPLICATION, token.appId);
+	this.remotingContext = context.remotingContext;
+}
+function Principal(type, id, name) {
+	if (!(this instanceof Principal)) return new Principal(type, id, name);
+	this.type = type;
+	this.id = id;
+	this.name = name;
+}
+function AccessRequest(model, property, accessType, permission, methodNames, registry) {
+	if (!(this instanceof AccessRequest)) return new AccessRequest(model, property, accessType, permission, methodNames, registry);
+	if (arguments.length === 1 && typeof model === "object") {
+		const obj = model || {};
+		this.model = obj.model || AccessContext.ALL;
+		this.property = obj.property || AccessContext.ALL;
+		this.accessType = obj.accessType || AccessContext.ALL;
+		this.permission = obj.permission || AccessContext.DEFAULT;
+		this.methodNames = obj.methodNames || [];
+		this.registry = obj.registry;
+	} else {
+		this.model = model || AccessContext.ALL;
+		this.property = property || AccessContext.ALL;
+		this.accessType = accessType || AccessContext.ALL;
+		this.permission = permission || AccessContext.DEFAULT;
+		this.methodNames = methodNames || [];
+		this.registry = registry;
+	}
+	assert(this.registry, "Application registry is mandatory in AccessRequest but missing in provided argument(s)");
+}
+var assert, runtime, debug, DEFAULT_SCOPES;
+var init_access_context = require_runtime$1.__esmMin((() => {
+	assert = require("assert");
+	runtime = require_lib_runtime;
+	debug = require("debug")("loopback:security:access-context");
+	DEFAULT_SCOPES = ["DEFAULT"];
+	AccessContext.ALL = "*";
+	AccessContext.READ = "READ";
+	AccessContext.REPLICATE = "REPLICATE";
+	AccessContext.WRITE = "WRITE";
+	AccessContext.EXECUTE = "EXECUTE";
+	AccessContext.DEFAULT = "DEFAULT";
+	AccessContext.ALLOW = "ALLOW";
+	AccessContext.ALARM = "ALARM";
+	AccessContext.AUDIT = "AUDIT";
+	AccessContext.DENY = "DENY";
+	AccessContext.permissionOrder = {
+		DEFAULT: 0,
+		ALLOW: 1,
+		ALARM: 2,
+		AUDIT: 3,
+		DENY: 4
+	};
+	AccessContext.prototype.addPrincipal = function(principalType, principalId, principalName) {
+		const principal = new Principal(principalType, principalId, principalName);
+		for (let i = 0; i < this.principals.length; i++) if (this.principals[i].equals(principal)) return false;
+		this.principals.push(principal);
+		return true;
+	};
+	AccessContext.prototype.getUserId = function() {
+		const user = this.getUser();
+		return user && user.id;
+	};
+	AccessContext.prototype.getUser = function() {
+		const BaseUser = this.registry.getModel("User");
+		for (let i = 0; i < this.principals.length; i++) {
+			const p = this.principals[i];
+			if (p.type === Principal.APP || p.type === Principal.ROLE || p.type == Principal.SCOPE) continue;
+			if (p.type === Principal.USER) return {
+				id: p.id,
+				principalType: p.type
+			};
+			const userModel = this.registry.findModel(p.type);
+			if (!userModel) continue;
+			if (userModel.prototype instanceof BaseUser) return {
+				id: p.id,
+				principalType: p.type
+			};
+		}
+	};
+	AccessContext.prototype.getAppId = function() {
+		for (let i = 0; i < this.principals.length; i++) {
+			const p = this.principals[i];
+			if (p.type === Principal.APPLICATION) return p.id;
+		}
+		return null;
+	};
+	AccessContext.prototype.isAuthenticated = function() {
+		return this.getUserId() != null || this.getAppId() != null;
+	};
+	AccessContext.prototype.getScopes = function() {
+		if (!this.sharedMethod) return DEFAULT_SCOPES;
+		const methodLevel = this.sharedMethod.accessScopes || DEFAULT_SCOPES;
+		debug("--Context scopes of %s()--", this.sharedMethod.stringName);
+		debug("  method-level: %j", methodLevel);
+		return methodLevel;
+	};
+	AccessContext.prototype.isScopeAllowed = function() {
+		if (!this.accessToken) return false;
+		const tokenScopes = this.accessToken.scopes || DEFAULT_SCOPES;
+		const resourceScopes = this.getScopes();
+		return Array.isArray(tokenScopes) && Array.isArray(resourceScopes) && resourceScopes.some((scope) => tokenScopes.indexOf(scope) !== -1);
+	};
+	AccessContext.prototype.debug = function() {
+		if (debug.enabled) {
+			debug("---AccessContext---");
+			if (this.principals && this.principals.length) {
+				debug("principals:");
+				this.principals.forEach(function(principal) {
+					debug("principal: %j", principal);
+				});
+			} else debug("principals: %j", this.principals);
+			debug("modelName %s", this.modelName);
+			debug("modelId %s", this.modelId);
+			debug("property %s", this.property);
+			debug("method %s", this.method);
+			debug("accessType %s", this.accessType);
+			debug("accessScopes %j", this.getScopes());
+			if (this.accessToken) {
+				debug("accessToken:");
+				debug("  id %j", this.accessToken.id);
+				debug("  ttl %j", this.accessToken.ttl);
+				debug("  scopes %j", this.accessToken.scopes || DEFAULT_SCOPES);
+			}
+			debug("getUserId() %s", this.getUserId());
+			debug("isAuthenticated() %s", this.isAuthenticated());
+		}
+	};
+	Principal.USER = "USER";
+	Principal.APP = Principal.APPLICATION = "APP";
+	Principal.ROLE = "ROLE";
+	Principal.SCOPE = "SCOPE";
+	Principal.prototype.equals = function(p) {
+		const other = p;
+		if (other instanceof Principal) return this.type === other.type && String(this.id) === String(other.id);
+		return false;
+	};
+	AccessRequest.prototype.isWildcard = function() {
+		return this.model === AccessContext.ALL || this.property === AccessContext.ALL || this.accessType === AccessContext.ALL;
+	};
+	AccessRequest.prototype.exactlyMatches = function(acl) {
+		const matchesModel = acl.model === this.model;
+		const matchesProperty = acl.property === this.property;
+		const matchesMethodName = this.methodNames.indexOf(acl.property) !== -1;
+		const matchesAccessType = acl.accessType === this.accessType;
+		if (matchesModel && matchesAccessType) return matchesProperty || matchesMethodName;
+		return false;
+	};
+	AccessRequest.prototype.settleDefaultPermission = function(defaultPermission) {
+		if (this.permission !== "DEFAULT") return;
+		const modelName = this.model;
+		if (!defaultPermission) {
+			const modelClass = this.registry.findModel(modelName);
+			defaultPermission = modelClass && modelClass.settings.defaultPermission;
+		}
+		this.permission = defaultPermission || "ALLOW";
+	};
+	AccessRequest.prototype.isAllowed = function() {
+		return this.permission !== this.registry.getModel("ACL").DENY;
+	};
+	AccessRequest.prototype.debug = function() {
+		if (debug.enabled) {
+			debug("---AccessRequest---");
+			debug(" model %s", this.model);
+			debug(" property %s", this.property);
+			debug(" accessType %s", this.accessType);
+			debug(" permission %s", this.permission);
+			debug(" isWildcard() %s", this.isWildcard());
+			debug(" isAllowed() %s", this.isAllowed());
+		}
+	};
+}));
+//#endregion
+init_access_context();
+exports.AccessContext = AccessContext;
+exports.AccessRequest = AccessRequest;
+exports.DEFAULT_SCOPES = DEFAULT_SCOPES;
+exports.Principal = Principal;
+Object.defineProperty(exports, "access_context_exports", {
+	enumerable: true,
+	get: function() {
+		return access_context_exports;
+	}
+});
+Object.defineProperty(exports, "init_access_context", {
+	enumerable: true,
+	get: function() {
+		return init_access_context;
+	}
+});