insite-users-server 1.0.334

package/lib/users/User.js

@@ -0,0 +1,251 @@
+import { debounce } from "@nesvet/n";
+
+
+const rolesSnapshots = new Map();
+const permissionsSnapshots = new Map();
+
+const staticHost = process.env.STATIC_HOST ?? "localhost";
+
+
+export class User {
+	constructor(users, userDoc) {
+		this.#users = users;
+		
+		this._id = userDoc._id;
+		users.set(this._id, this);
+		
+		this.update(userDoc);
+		
+		if (users.isInited)
+			users.emit("user-create", this);
+		
+	}
+	
+	#users;
+	
+	isUser = true;
+	
+	roles = new Set();
+	slaveRoles = new Set();
+	slaveRoleIds = [];
+	abilities = {};
+	
+	slaveOrgs = new Set();
+	slaveUsers = new Set();
+	slaves = new Set();
+	
+	slaveIds = [];
+	permissiveIds = [];
+	
+	sessions = new Set();
+	
+	isOnline = false;
+	
+	update({ _id, name, email, roles: ownRoleIds, org: orgId, avatar, ...restProps }) {
+		
+		const users = this.#users;
+		
+		Object.assign(this, restProps);
+		
+		let isEmailUpdated;
+		if (email && this.email !== email) {
+			users.byEmail.delete(this.email);
+			this.email = email;
+			users.byEmail.set(email, this);
+			isEmailUpdated = true;
+		}
+		
+		let isNameUpdated;
+		let isLastNameUpdated;
+		if (name && (this.name?.first !== name.first || this.name.middle !== name.middle || this.name.last !== name.last)) {
+			isLastNameUpdated = this.name?.last !== name.last;
+			this.name = {
+				first: name.first,
+				middle: name.middle,
+				last: name.last
+			};
+			this.initials = (((name.first[0] || "") + (name.last[0] || "")) || this.email[0]).toUpperCase();
+			isNameUpdated = true;
+		}
+		
+		if (isEmailUpdated || isNameUpdated)
+			this.displayLabel = `${name.first} ${name.last}`.trim() || name.middle || this.email;
+		
+		let isRolesUpdated;
+		if (ownRoleIds) {
+			this.ownRoleIds = ownRoleIds;
+			
+			const snapshot = this.ownRoleIds.join(",");
+			
+			if (snapshot !== rolesSnapshots.get(this._id)) {
+				rolesSnapshots.set(this._id, snapshot);
+				this.updateRoles();
+				isRolesUpdated = true;
+			}
+		}
+		
+		let isOrgUpdated;
+		if (orgId !== undefined && this.org?._id !== orgId) {
+			this.org?.users.delete(this);
+			this.org = users.orgs.get(orgId) || users.orgs.null;
+			this.org.users.add(this);
+			isOrgUpdated = true;
+		}
+		
+		if (avatar !== undefined && this.avatar !== avatar) {
+			this.avatar = avatar;
+			this.avatarUrl = avatar && `https://${staticHost}/avatars/${this._id}-${avatar}.webp`;
+		}
+		
+		if (isRolesUpdated || isOrgUpdated) {
+			this.updatePermissions();
+			
+			if (isLastNameUpdated)
+				users.isSortRequired = true;
+			
+			if (users.isInited)
+				users.updateDebounced();
+			
+		} else if (isLastNameUpdated)
+			users.sortDebounced();
+		
+	}
+	
+	updateRoles() {
+		
+		const users = this.#users;
+		
+		if (users.isInited) {
+			this.ownRoles = [];
+			this.roles.clear();
+			this.slaveRoles.clear();
+			Object.clear(this.abilities);
+			
+			for (const roleId of this.ownRoleIds) {
+				const role = users.roles.get(roleId);
+				
+				this.ownRoles.push(role);
+				this.roles.add(role);
+				for (const involvedRole of role.involves) {
+					this.roles.add(involvedRole);
+					this.slaveRoles.add(involvedRole);
+				}
+				
+				this.slaveRoleIds = this.slaveRoles.ids();
+				
+				users.abilities.merge(this.abilities, role.abilities);
+			}
+			
+			if (this.roles.has(users.roles.root))
+				this.isRoot = true;
+			
+			this.trimSessions();
+		}
+		
+	}
+	
+	updatePermissions() {
+		
+		const users = this.#users;
+		
+		if (users.isInited) {
+			this.slaveOrgs.clear();
+			this.slaveUsers.clear();
+			this.slaves.clear();
+			const slaveIds = new Set();
+			
+			for (const org of users.orgs.sorted)
+				if ((org.ownerUsers.has(this) || this.isRoot) && !this.slaveOrgs.has(org)) {
+					this.slaveOrgs.add(org);
+					this.slaves.add(org);
+					slaveIds.add(org._id);
+					for (const slaveOrg of org.slaveOrgs) {
+						this.slaveOrgs.add(slaveOrg);
+						this.slaves.add(slaveOrg);
+						slaveIds.add(slaveOrg._id);
+					}
+				}
+			
+			for (const org of new Set([ this.org, ...this.slaveOrgs, users.orgs.null ]))
+				for (const user of org.users)
+					if (user !== this && (this.slaveRoles.hasAny(user.ownRoles) || !user.ownRoles.length)) {
+						this.slaveUsers.add(user);
+						this.slaves.add(user);
+						slaveIds.add(user._id);
+					}
+			
+			this.slaveIds = [ ...slaveIds ];
+			
+			const permissiveOrgIds = [];
+			if (this.org._id) {
+				permissiveOrgIds.push(this.org._id);
+				for (const slaveOrg of this.org.slaveOrgs)
+					if (!this.slaveOrgs.has(slaveOrg))
+						permissiveOrgIds.push(slaveOrg._id);
+			}
+			
+			this.permissiveIds = [ ...permissiveOrgIds, this._id, ...slaveIds ];
+			
+			
+			const snapshot = [
+				this.permissiveIds.join(","),
+				this.ownRoleIds.join(","),
+				JSON.stringify(this.abilities),
+				this.slaveRoleIds.join(",")
+			].join("\n");
+			
+			if (snapshot !== permissionsSnapshots.get(this._id)) {
+				permissionsSnapshots.set(this._id, snapshot);
+				
+				users.emit("user-permissions-change", this);
+			}
+		}
+		
+	}
+	
+	trimSessions() {
+		
+		const sessionsLimit = this.abilities.login?.sessionsLimit ?? 0;
+		
+		if (this.sessions.size > sessionsLimit)
+			return this.#users.sessions.collection.deleteMany({ _id: { $in: [ ...this.sessions ].sort((a, b) => a.expiresAt - b.expiresAt).slice(0, this.sessions.size - sessionsLimit).ids() } });
+		
+	}
+	
+	updateIsOnline = debounce(() => {
+		
+		let isOnline = false;
+		
+		for (const session of this.sessions)
+			if (session.isOnline) {
+				isOnline = true;
+				break;
+			}
+		
+		if (this.isOnline !== isOnline) {
+			this.isOnline = isOnline;
+			this.#users.emit("user-is-online", this);
+		}
+		
+	}, 500);
+	
+	delete() {
+		
+		const users = this.#users;
+		
+		this.org.users.delete(this);
+		
+		users.delete(this._id);
+		users.byEmail.delete(this.email);
+		users.sorted.remove(this);
+		
+		rolesSnapshots.delete(this._id);
+		permissionsSnapshots.delete(this._id);
+		
+		users.replace(this._id);
+		
+		users.updateDebounced();
+		
+	}
+	
+}

package/lib/users/Users.js

@@ -0,0 +1,265 @@
+import { ObjectId } from "insite-db";
+import { debounce } from "@nesvet/n";
+import argon2 from "argon2";
+import EventEmitter from "eventemitter3";
+import { Abilities } from "../abilities";
+import { Orgs } from "../orgs";
+import { Roles } from "../roles";
+import { Sessions } from "../sessions";
+import { Avatars } from "./avatars";
+import { basisSchema } from "./schema";
+import { User } from "./User";
+
+
+const indexes = [
+	[ { email: 1 }, { unique: true } ],
+	[ { org: 1 } ]
+];
+
+function sortUsersAndOrgs(a, b) {
+	return (
+		(a.isUser && b.isUser) ?
+			(a.name.last && b.name.last) ?
+				a.name.last > b.name.last ?
+					1 :
+					a.name.last < b.name.last ? -1 : 0 :
+			 (!a.name.last && !b.name.last) ?
+					a.displayLabel > b.displayLabel ?
+						1 :
+						a.displayLabel < b.displayLabel ? -1 : 0 :
+			 a.name.last ? -1 : 1 :
+		 (a.isOrg && b.isOrg) ?
+				a.title > b.title ?
+					1 :
+					a.title < b.title ? -1 : 0 :
+		 a.isOrg ? -1 : 1
+	);
+}
+
+
+export class Users extends Map {
+	constructor({
+		collections,
+		indexes: customIndexes,
+		schema: customSchema,
+		initialRoot: initialRootProps,
+		abilities: abilitiesOptions,
+		roles: rolesOptions,
+		orgs: orgsOptions,
+		sessions: sessionsOptions,
+		avatars: avatarsOptions
+	}) {
+		super();
+		
+		const eventEmitter = new EventEmitter();
+		for (const key in eventEmitter)
+			this[key] = eventEmitter[key];
+		
+		this.collections = collections;
+		
+		this.abilities = new Abilities(abilitiesOptions);
+		
+		if (customSchema) {
+			customSchema.required?.removeAll(basisSchema.required);
+			if (customSchema.properties)
+				Object.delete(customSchema, ...Object.keys(basisSchema.properties));
+		}
+		
+		const jsonSchema = {
+			...basisSchema,
+			...customSchema,
+			required: [ ...basisSchema.required, ...customSchema?.required ?? [] ],
+			properties: { ...basisSchema.properties, ...customSchema?.properties }
+		};
+		
+		return (async () => {
+			
+			this.collection = await this.collections.ensure("users", { jsonSchema });
+			
+			this.collection.ensureIndexes([ ...indexes, ...customIndexes ?? [] ]);
+			
+			if (!await this.collection.countDocuments({ roles: "root" }))
+				await this.new({
+					email: process.env.INSITE_ROOT_EMAIL ?? `root@${process.env.REMOTE_HOST || "insite.insite"}`,
+					password: process.env.INSITE_ROOT_PASSWORD ?? (process.env.MONGO_DBNAME || "insite"),
+					roles: [ "root" ],
+					name: { first: "Root" },
+					org: null,
+					job: "Root",
+					...Object.delete(initialRootProps, "roles", "org")
+				});
+			
+			this.roles = await new Roles(this, rolesOptions);
+			this.orgs = await new Orgs(this, orgsOptions);
+			this.sessions = await new Sessions(this, sessionsOptions);
+			this.avatars = await new Avatars(this, avatarsOptions);
+			
+			await this.roles.init();
+			
+			await this.orgs.initialLoad();
+			await this.initialLoad();
+			
+			await this.orgs.init();
+			await this.init();
+			
+			await this.sessions.init();
+			
+			return this;
+		})();
+	}
+	
+	isInited = false;
+	
+	byEmail = new Map();
+	bySessionId = new Map();
+	sorted = [];
+	
+	isSortRequired = false;
+	
+	load(userDoc) {
+		new User(this, userDoc);
+		
+	}
+	
+	sort() {
+		
+		this.isSortRequired = false;
+		
+		this.sorted = [ ...this.values() ].sort((a, b) => a.name.last > b.name.last ? 1 : a.name.last < b.name.last ? -1 : 0);
+		
+	}
+	
+	sortDebounced = debounce(this.sort, 250);
+	
+	update(shouldUpdateRoles) {
+		if (shouldUpdateRoles)
+			for (const user of this.values())
+				user.updateRoles();
+		
+		for (const user of this.values())
+			user.updatePermissions();
+		
+		if (this.isSortRequired)
+			this.sort();
+		
+	}
+	
+	updateDebounced = debounce(this.update, 250);
+	
+	initialLoad = async () => {
+		
+		for (const userDoc of await this.collection.find().toArray())
+			this.load(userDoc);
+		
+		delete this.initialLoad;
+		
+	};
+	
+	init = async () => {
+		
+		this.isInited = true;
+		
+		this.update(true);
+		
+		this.collection.changeListeners.add(next => {
+			switch (next.operationType) {
+				case "insert":
+					new User(this, next.fullDocument);
+					break;
+				
+				case "replace":
+					this.get(next.documentKey._id).update(next.fullDocument);
+					break;
+				
+				case "update":
+					this.get(next.documentKey._id).update(next.updateDescription.updatedFields);
+					break;
+				
+				case "delete":
+					this.get(next.documentKey._id).delete();
+			}
+			
+		});
+		
+		delete this.init;
+		
+	};
+	
+	async new({ email, password, roles, name, org, job, ...restProps }) {
+		if (this.byEmail.has(email))
+			throw new Error("User exists");
+		else
+			await this.collection.insertOne({
+				_id: (new ObjectId()).toString(),
+				email,
+				password: await argon2.hash(password),
+				roles: this.isInited ? this.roles.cleanUpIds(roles) : roles,
+				name: {
+					first: name.first ?? "",
+					middle: name.middle ?? "",
+					last: name.last ?? ""
+				},
+				org: org ?? null,
+				job: job ?? "",
+				...Object.delete(restProps, "_id"),
+				createdAt: Date.now()
+			});
+		
+		return true;
+	}
+	
+	async changePassword(_id, newPassword) {
+		if (!this.has(_id))
+			throw new Error("usernotfound");
+		else if (!newPassword)
+			throw new Error("emptypasswordisnotallowed");
+		else
+			await Promise.all([
+				this.collection.updateOne({ _id }, { $set: { password: await argon2.hash(newPassword) } }),
+				this.sessions.collection.deleteMany({ user: _id })
+			]);
+		
+	}
+	
+	async login(email, password, sessionProps) {
+		const user = this.byEmail.get(email);
+		
+		if (!user)
+			throw new Error("usernotfound");
+		else if (!await argon2.verify(user.password, password))
+			throw new Error("incorrectpassword");
+		else if (!user.abilities.login)
+			throw new Error("userisnotabletologin");
+		
+		return this.sessions.new(user, sessionProps);
+	}
+	
+	logout(session) {
+		session.delete();
+		
+		return this.sessions.collection.deleteOne({ _id: session._id });
+	}
+	
+	sortIds(ids) {
+		return ids
+			.map(_id => this.get(_id) || this.orgs.get(_id))
+			.filter(Boolean)
+			.sort(sortUsersAndOrgs)
+			.ids();
+	}
+	
+	replaceMap = new Map();
+	
+	replaceHandlers = new Set();
+	
+	async replace(fromId) {
+		const toId = this.replaceMap.get(fromId) ?? null;
+		if (toId)
+			this.replaceMap.delete(fromId);
+		
+		for (const handler of this.replaceHandlers)
+			await handler(fromId, toId);
+		
+	}
+	
+}

package/lib/users/avatars/Avatars.js

@@ -0,0 +1,16 @@
+import { schema as jsonSchema } from "./schema";
+
+
+export class Avatars {
+	constructor(users, options = {}) {
+		this.users = users;
+		this.collections = users.collections;
+		
+		return (async () => {
+			
+			this.collection = await this.collections.ensure("users.avatars", { jsonSchema });
+			
+			return this;
+		})();
+	}
+}

package/lib/users/avatars/index.js

@@ -0,0 +1 @@
+export { Avatars } from "./Avatars";

package/lib/users/avatars/schema.js

@@ -0,0 +1,33 @@
+import { regexps } from "../../lib";
+
+
+export const schema = {
+	required: [
+		"_id",
+		"type",
+		"size",
+		"ts",
+		"data"
+	],
+	properties: {
+		_id: {
+			bsonType: "string",
+			pattern: regexps._id.pattern
+		},
+		type: {
+			bsonType: "string",
+			maxLength: 256
+		},
+		size: {
+			bsonType: "number"
+		},
+		ts: {
+			bsonType: "string",
+			maxLength: 10
+		},
+		data: {
+			bsonType: "binData"
+		}
+	},
+	additionalProperties: false
+};

package/lib/users/index.js

@@ -0,0 +1 @@
+export * from "./Users";

package/lib/users/schema.js

@@ -0,0 +1,91 @@
+import { regexps } from "../lib";
+
+
+export const basisSchema = {
+	required: [
+		"_id",
+		"email",
+		"password",
+		"roles",
+		"name",
+		"org",
+		"job",
+		"createdAt"
+	],
+	properties: {
+		_id: {
+			bsonType: "string",
+			pattern: regexps._id.pattern
+		},
+		email: {
+			bsonType: "string",
+			pattern: regexps.email.pattern
+		},
+		password: {
+			bsonType: "string",
+			pattern: regexps.argon2.pattern
+		},
+		roles: {
+			bsonType: "array",
+			uniqueItems: true,
+			items: {
+				bsonType: "string",
+				pattern: regexps.role.pattern
+			},
+			additionalItems: false
+		},
+		name: {
+			bsonType: "object",
+			required: [
+				"first",
+				"middle",
+				"last"
+			],
+			properties: {
+				first: {
+					bsonType: "string",
+					maxLength: 512
+				},
+				middle: {
+					bsonType: "string",
+					maxLength: 512
+				},
+				last: {
+					bsonType: "string",
+					maxLength: 512
+				}
+			},
+			additionalProperties: false
+		},
+		org: {
+			oneOf: [
+				{
+					bsonType: "string",
+					pattern: regexps._id.pattern
+				},
+				{
+					bsonType: "null"
+				}
+			]
+		},
+		job: {
+			bsonType: "string",
+			maxLength: 512
+		},
+		avatar: {
+			oneOf: [
+				{
+					bsonType: "string",
+					maxLength: 10
+				},
+				{
+					bsonType: "null"
+				}
+			]
+		},
+		createdAt: {
+			bsonType: "number"
+		}
+	},
+	additionalProperties: false
+};