insite-users-server 1.0.334

package/lib/roles/Roles.js

@@ -0,0 +1,224 @@
+import { debounce } from "@nesvet/n";
+import { Role } from "./Role";
+import { basisSchema } from "./schema";
+
+
+const indexes = [
+	[ { involves: 1 } ]
+];
+
+function preventDirectDelete() {
+	throw new Error("Direct usage of roles collection.deleteOne or .deleteMany is forbidden. Use roles.collectionDelete instead.");
+}
+
+function sortRoles(a, b) {
+	return (
+		(b.involves.size - a.involves.size) || (
+			(a.title && b.title) ?
+				a.title > b.title ? 1 : a.title < b.title ? -1 : 0 :
+				a.title ?
+					-1 :
+					b.title ?
+						1 :
+						a._id > b._id ?
+							1 :
+							a._id < b._id ?
+								-1 :
+								0
+			
+		)
+	);
+}
+
+
+export class Roles extends Map {
+	constructor(users, options = {}) {
+		super();
+		
+		const {
+			schema: customSchema,
+			indexes: customIndexes,
+			root: rootProps
+		} = options;
+		
+		this.users = users;
+		this.collections = users.collections;
+		this.abilities = users.abilities;
+		
+		this.root = new Role(this, {
+			...rootProps,
+			_id: "root",
+			involves: [],
+			abilities: this.abilities.getMaximum(),
+			title: "Root",
+			description: "Root",
+			createdAt: Date.now()
+		});
+		
+		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("roles", { jsonSchema });
+			
+			this.collection.ensureIndexes([ ...indexes, ...customIndexes ?? [] ]);
+			
+			this.collection.deleteOne =
+				this.collection.deleteMany =
+					preventDirectDelete;
+			
+			return this;
+		})();
+	}
+	
+	load(roleDoc) {
+		new Role(this, roleDoc);
+		
+	}
+	
+	resolve(role, involvedBy) {
+		involvedBy = [ role, ...involvedBy ];
+		
+		for (const involvedRoleId of role.ownInvolveIds) {
+			const involvedRole = this.get(involvedRoleId);
+			if (involvedRole) {
+				for (const involvedByRole of involvedBy) {
+					involvedByRole.involves.reAdd(involvedRole);
+					this.abilities.merge(involvedByRole.inheritedAbilities, involvedRole.abilities);
+				}
+				if (involvedRole !== role)
+					this.resolve(involvedRole, involvedBy);
+			}
+		}
+		
+	}
+	
+	sorted = [];
+	
+	async update() {
+		
+		const array = [ ...this.values() ];
+		
+		this.root.ownInvolveIds = [];
+		for (const role of array) {
+			if (role !== this.root && !array.some(anotherRole => anotherRole.ownInvolveIds.includes(role._id)))
+				this.root.ownInvolveIds.push(role._id);
+			role.involves.clear();
+			role.abilities = Object.deepClone(role.ownAbilities);
+			role.inheritedAbilities = {};
+		}
+		
+		this.root.involves.add(this.root);
+		this.resolve(this.root, []);
+		
+		for (const role of array)
+			role.ownInvolves = this.getAll(role.ownInvolveIds).sort(sortRoles).reverse();
+		
+		const sorted = [ this.root ];
+		
+		for (let i = 0; i < sorted.length; i++) {
+			const role = sorted[i];
+			for (const involvedRole of role.ownInvolves) {
+				const involvedRoleIndex = sorted.indexOf(involvedRole);
+				if (~involvedRoleIndex) {
+					sorted.splice(involvedRoleIndex, 1);
+					i--;
+				}
+				sorted.splice(i + 1, 0, involvedRole);
+			}
+		}
+		
+		let _o = 0;
+		for (const role of sorted) {
+			this.abilities.merge(role.abilities, role.inheritedAbilities);
+			role._o = _o++;
+		}
+		
+		this.sorted = sorted;
+		
+		this.users.emit("roles-update");
+		
+		if (this.users.isInited) {
+			this.users.updateDebounced.clear();
+			this.users.update(true);
+		}
+		
+	}
+	
+	updateDebounced = debounce(this.update, 250);
+	
+	init = async () => {
+		
+		for (const roleDoc of await this.collection.find().toArray())
+			this.load(roleDoc);
+		
+		await this.update();
+		
+		this.collection.changeListeners.add(next => {
+			switch (next.operationType) {
+				case "insert":
+					const role = new Role(this, next.fullDocument);
+					this.users.emit("roles-role-update", role, next);
+					break;
+				
+				case "update":
+				case "replace":
+					this.get(next.documentKey._id).update(next.updateDescription?.updatedFields || next.fullDocument, next);
+					break;
+				
+				case "delete":
+					this.get(next.documentKey._id).delete();
+					this.users.emit("roles-role-update", null, next);
+			}
+			
+		});
+		
+		delete this.init;
+		
+	};
+	
+	new({ _id, involves, title, description, ...restProps }) {
+		return this.collection.insertOne({
+			_id,
+			involves: involves || [],
+			abilities: {},
+			title: title ?? "",
+			description: description ?? "",
+			...Object.delete(restProps, "abilities"),
+			createdAt: Date.now()
+		});
+	}
+	
+	collectionDelete(role) {
+		const _id = typeof role == "string" ? role : role._id;
+		
+		return this.collection.bulkWrite([
+			{ updateMany: { filter: { involves: _id }, update: { $pullAll: { involves: [ _id ] } } } },
+			{ deleteOne: { filter: { _id } } }
+		]);
+	}
+	
+	cleanUpIds(ids) {
+		const roles = this.sorted.intersection(this.getAll(ids));
+		
+		const cleanedUpIds = [];
+		
+		for (const role of roles)
+			if (roles.every(anotherRole => anotherRole === role || !anotherRole.involves.has(role)))
+				cleanedUpIds.push(role._id);
+		
+		return cleanedUpIds;
+	}
+	
+}

package/lib/roles/index.js

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

package/lib/roles/schema.js

@@ -0,0 +1,45 @@
+import { regexps } from "../lib";
+
+
+export const basisSchema = {
+	required: [
+		"_id",
+		"involves",
+		"abilities",
+		"title",
+		"description",
+		"createdAt"
+	],
+	properties: {
+		_id: {
+			bsonType: "string",
+			pattern: regexps.role.pattern,
+			not: { enum: [ "root" ] }
+		},
+		involves: {
+			bsonType: "array",
+			uniqueItems: true,
+			items: {
+				bsonType: "string",
+				pattern: regexps.role.pattern,
+				not: { enum: [ "root" ] }
+			},
+			additionalItems: false
+		},
+		abilities: {
+			bsonType: "object"
+		},
+		title: {
+			bsonType: "string",
+			maxLength: 256
+		},
+		description: {
+			bsonType: "string",
+			maxLength: 10240
+		},
+		createdAt: {
+			bsonType: "number"
+		}
+	},
+	additionalProperties: false
+};

package/lib/sessions/Session.js

@@ -0,0 +1,72 @@
+export class Session {
+	constructor(sessions, sessionDoc) {
+		this.#sessions = sessions;
+		
+		this._id = sessionDoc._id;
+		sessions.set(this._id, this);
+		
+		this.user = sessions.users.get(sessionDoc.user);
+		this.user.sessions.add(this);
+		
+		sessions.users.bySessionId.set(this._id, this.user);
+		
+		this.update(sessionDoc);
+		
+	}
+	
+	#sessions;
+	
+	update({ _id, user, isOnline, ...restProps }) {
+		
+		const sessions = this.#sessions;
+		
+		if (isOnline !== undefined && this.isOnline != isOnline) {
+			this.isOnline = isOnline;
+			
+			if (sessions.isInited && this.user.isOnline != this.isOnline)
+				this.user.updateIsOnline();
+		}
+		
+		Object.assign(this, restProps);
+		
+	}
+	
+	prolong({ _id, user, ...updates }) {
+		
+		const sessions = this.#sessions;
+		
+		const ts = Date.now();
+		
+		updates.prolongedAt = ts;
+		updates.expiresAt = new Date(ts + (sessions.collection.expireAfterSeconds * 1000));
+		
+		this.update(updates);
+		
+		return sessions.collection.updateOne({ _id: this._id }, { $set: updates });
+	}
+	
+	offline() {
+		
+		const updates = { isOnline: false };
+		
+		this.update(updates);
+		
+		return this.#sessions.collection.updateOne({ _id: this._id }, { $set: updates });
+	}
+	
+	delete() {
+		
+		const sessions = this.#sessions;
+		
+		sessions.delete(this._id);
+		this.user.sessions.delete(this);
+		sessions.users.bySessionId.delete(this._id);
+		
+		sessions.users.emit("session-delete", this);
+		
+		if (this.isOnline)
+			this.user.updateIsOnline();
+		
+	}
+	
+}

package/lib/sessions/Sessions.js

@@ -0,0 +1,118 @@
+import crypto from "node:crypto";
+import { random } from "@nesvet/n";
+import { basisSchema } from "./schema";
+import { Session } from "./Session";
+
+
+const expireAfterSeconds = 3600 * 24 * 7;
+
+const indexes = [
+	[ { user: 1 } ],
+	[ { expiresAt: 1 }, { expireAfterSeconds } ]
+];
+
+
+export class Sessions extends Map {
+	constructor(users, options = {}) {
+		super();
+		
+		const {
+			schema: customSchema,
+			indexes: customIndexes
+		} = options;
+		
+		this.users = users;
+		this.collections = users.collections;
+		
+		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("sessions", { jsonSchema });
+			
+			this.collection.expireAfterSeconds = expireAfterSeconds;
+			
+			this.collection.ensureIndexes([ ...indexes, ...customIndexes ?? [] ]);
+			
+			await this.collection.updateMany({ isOnline: true }, { $set: { isOnline: false } });
+			
+			return this;
+		})();
+	}
+	
+	isInited = false;
+	
+	makeId() {
+		return `${crypto.randomBytes(random(8, 16)).toString("hex")}$${crypto.randomBytes(random(8, 16)).toString("hex")}`;
+	}
+	
+	load(sessionDoc) {
+		new Session(this, sessionDoc);
+		
+	}
+	
+	init = async () => {
+		
+		for (const sessionDoc of await this.collection.find().toArray())
+			this.load(sessionDoc);
+		
+		this.collection.changeListeners.add(next => {
+			switch (next.operationType) {
+				case "insert":
+					if (!this.has(next.documentKey._id))
+						new Session(this, next.fullDocument);
+					
+					this.users.get(next.fullDocument.user)?.trimSessions();
+					
+					break;
+				
+				case "update":
+				case "replace":
+					this.get(next.documentKey._id)?.update(next.updateDescription?.updatedFields || next.fullDocument);
+					break;
+				
+				case "delete":
+					this.get(next.documentKey._id)?.delete();
+			}
+			
+		});
+		
+		this.isInited = true;
+		
+		delete this.init;
+		
+	};
+	
+	async new(user, props) {
+		
+		const ts = Date.now();
+		
+		const sessionDoc = {
+			...props,
+			_id: this.uid(),
+			user: user._id,
+			createdAt: ts,
+			prolongedAt: ts,
+			expiresAt: new Date(ts + (expireAfterSeconds * 1000))
+		};
+		
+		/* new Session(…) before await insertOne(…) for avoid changeStream insert event to come earlier and create the session duplicate */
+		const session = new Session(this, sessionDoc);
+		
+		await this.collection.insertOne(sessionDoc);
+		
+		return session;
+	}
+	
+}

package/lib/sessions/index.js

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

package/lib/sessions/schema.js

@@ -0,0 +1,45 @@
+import { regexps } from "../lib";
+
+
+export const basisSchema = {
+	required: [
+		"_id",
+		"user",
+		"remoteAddress",
+		"isOnline",
+		"createdAt",
+		"prolongedAt",
+		"expiresAt"
+	],
+	properties: {
+		_id: {
+			bsonType: "string",
+			pattern: regexps.sessionId.pattern
+		},
+		user: {
+			bsonType: "string",
+			pattern: regexps._id.pattern
+		},
+		userAgent: {
+			bsonType: "string",
+			maxLength: 4096
+		},
+		remoteAddress: {
+			bsonType: "string",
+			pattern: regexps.ip.pattern
+		},
+		isOnline: {
+			bsonType: "bool"
+		},
+		createdAt: {
+			bsonType: "number"
+		},
+		prolongedAt: {
+			bsonType: "number"
+		},
+		expiresAt: {
+			bsonType: "date"
+		}
+	},
+	additionalProperties: false
+};