insite-users-server 1.0.334

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Eugene Nesvetaev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,13 @@
+# inSite users server side
+
+## Installation
+
+```sh
+$ npm install insite-users-server
+```
+
+Or
+
+```sh
+$ yarn add insite-users-server
+```

package/lib/abilities/Abilities.js

@@ -0,0 +1,145 @@
+import { basisTree } from "./tree";
+
+
+function mergeTrees(target, source) {
+	for (const sourceItem of source) {
+		const targetItem = target.find(({ _id }) => _id === sourceItem._id);
+		if (targetItem) {
+			for (const key in sourceItem)
+				if (key !== "_id") {
+					const sourceItemField = sourceItem[key];
+					if (Array.isArray(sourceItemField))
+						mergeTrees(targetItem[key] ??= [], sourceItemField);
+					else
+						targetItem[key] = sourceItemField;
+				}
+		} else
+			target.push(sourceItem);
+	}
+	
+	return target;
+}
+
+
+export class Abilities extends Map {
+	constructor(options = {}) {
+		super();
+		
+		const {
+			tree: customTree,
+			basis = true
+		} = options;
+		
+		this.tree =
+			customTree ?
+				basis ?
+					mergeTrees(basisTree, customTree) :
+					customTree :
+				basisTree;
+		
+		this.#parse(this.tree);
+		
+	}
+	
+	#parse(list) {
+		for (const ability of list) {
+			this.set(ability._id, ability);
+			if (ability.subAbilities)
+				this.#parse(ability.subAbilities);
+		}
+		
+	}
+	
+	merge(target, source) {
+		for (const [ abilityId, ability ] of Object.entries(source)) {
+			const schema = this.get(abilityId);
+			if (schema) {
+				if (schema.isInheritable !== false && ability)
+					if (!target[abilityId])
+						target[abilityId] = Object.deepClone(ability);
+					else if (schema.params)
+						for (const param of schema.params)
+							if (param.isInheritable !== false && ability[param._id] !== undefined)
+								if (!target[abilityId][param._id])
+									target[abilityId][param._id] = Object.deepClone(ability[param._id]);
+								else
+									if (param.type === "number") {
+										if (target[abilityId][param._id] < ability[param._id])
+											target[abilityId][param._id] = ability[param._id];
+									} else if (param.type === "items") {
+										const targetItems = target[abilityId][param._id];
+										for (const itemId of ability[param._id])
+											if (!targetItems.includes(itemId))
+												targetItems.push(itemId);
+									}
+				
+				
+			} else
+				delete source[abilityId];
+		}
+		
+		return target;
+	}
+	
+	getMinimumOf(_id) {
+		const schema = this.get(_id);
+		if (schema.params) {
+			const ability = {};
+			for (const param of schema.params)
+				if (param.type === "number")
+					ability[param._id] = param.min ?? 0;
+				else if (param.type === "items")
+					ability[param._id] = [];
+			
+			return ability;
+		}
+		
+		return true;
+	}
+	
+	getMaximum() {
+		return [ ...this.values() ].reduce((abilities, schema) => {
+			if (schema.params) {
+				const ability = {};
+				for (const param of schema.params)
+					if (param.type === "number")
+						ability[param._id] = param.max ?? 0;
+					else if (param.type === "items")
+						ability[param._id] = param.items.ids();
+				
+				abilities[schema._id] = ability;
+			} else
+				abilities[schema._id] = true;
+			
+			return abilities;
+		}, {});
+	}
+	
+	getSchemeFor(user) {
+		return (function resolve(abilities) {
+			for (let i = 0; i < abilities.length; i++) {
+				const schema = abilities[i];
+				const userAbility = user.abilities[schema._id];
+				if (userAbility) {
+					if (schema.params)
+						for (const param of schema.params) {
+							const userParam = userAbility[param._id];
+							if (param.type === "number") {
+								if (param.max !== undefined)
+									param.max = userParam;
+							} else if (param.type === "items")
+								for (let j = 0; j < param.items.length; j++)
+									if (!userParam.includes(param.items[j]._id))
+										param.items.splice(j--, 1);
+						}
+					if (schema.subAbilities)
+						resolve(schema.subAbilities);
+				} else
+					abilities.splice(i--, 1);
+			}
+			
+			return abilities;
+		})(Object.deepClone(this.tree));
+	}
+	
+}

package/lib/abilities/index.js

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

package/lib/abilities/tree.js

@@ -0,0 +1,26 @@
+export const basisTree = [
+	{
+		_id: "login",
+		title: "Вход в систему",
+		params: [
+			{
+				_id: "sessionsLimit",
+				title: "Лимит активных сессий",
+				type: "number",
+				min: 1,
+				max: 128
+			},
+			{
+				_id: "sections",
+				title: "Доступные разделы",
+				type: "items",
+				items: [
+					{
+						_id: "users",
+						title: "Пользователи"
+					}
+				]
+			}
+		]
+	}
+];

package/lib/index.js

@@ -0,0 +1,4 @@
+import "@nesvet/deprecated-extensions";
+
+
+export * from "./users";

package/lib/lib/index.js

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

package/lib/lib/regexps.js

@@ -0,0 +1,11 @@
+export const regexps = {
+	_id: /^[a-fA-F\d]{24}$/,
+	email: /^[^\s@]{1,63}@[^\s@]{1,63}\.[^\s@]{1,63}$/,
+	argon2: /^\$argon2(?:i|d|id)\$v=\d+\$m=\d+,t=\d+,p=\d+\$[a-zA-Z\d+/]+\$[a-zA-Z\d+/]+$/,
+	sessionId: /^[a-fA-F\d]{16,32}\$[a-fA-F\d]{16,32}$/,
+	role: /^[a-z\d\-_]{1,64}$/,
+	ip: /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/
+};
+
+for (const key in regexps)
+	regexps[key].pattern = regexps[key].toString().slice(1, -1);

package/lib/orgs/Org.js

@@ -0,0 +1,70 @@
+const snapshots = new Map();
+
+
+export class Org {
+	constructor(orgs, orgDoc) {
+		this.#orgs = orgs;
+		
+		this._id = orgDoc._id;
+		orgs.set(this._id, this);
+		
+		this.update(orgDoc);
+		
+	}
+	
+	#orgs;
+	
+	isOrg = true;
+	
+	ownerOrgs = new Set();
+	ownerUsers = new Set();
+	
+	users = new Set();
+	
+	slaveOrgs = new Set();
+	
+	update({ _id, title, owners: ownerIds, ...restProps }, next) {
+		
+		const orgs = this.#orgs;
+		
+		Object.assign(this, restProps);
+		
+		if (title !== undefined) {
+			this.title = title;
+			this.initials = title?.[0]?.toUpperCase() ?? "";
+			this.displayLabel = title;
+		}
+		
+		if (ownerIds) {
+			this.ownerIds = ownerIds;
+			
+			
+			const snapshot = this.ownerIds.join(",");
+			
+			if (snapshot !== snapshots.get(this._id)) {
+				snapshots.set(this._id, snapshot);
+				
+				if (orgs.users.isInited)
+					orgs.updateDebounced();
+				
+				orgs.users.emit("orgs-org-update", this, next);
+			}
+		}
+		
+	}
+	
+	delete() {
+		
+		const orgs = this.#orgs;
+		
+		orgs.delete(this._id);
+		
+		snapshots.delete(this._id);
+		
+		orgs.replace(this._id);
+		
+		orgs.updateDebounced();
+		
+	}
+	
+}

package/lib/orgs/Orgs.js

@@ -0,0 +1,232 @@
+import { debounce } from "@nesvet/n";
+import { ObjectId } from "insite-db";
+import { Org } from "./Org";
+import { basisSchema } from "./schema";
+
+
+const indexes = [
+	[ { owners: 1 } ]
+];
+
+function sortOrgs(a, b) {
+	return (
+		(b.slaveOrgs.size - a.slaveOrgs.size) || (
+			a.title > b.title ?
+				1 :
+				a.title < b.title ?
+					-1 :
+					0
+		)
+	);
+}
+
+function preventDirectDelete() {
+	throw new Error("Direct usage of orgs collection.deleteOne or .deleteMany is forbidden. Use orgs.collectionDelete instead.");
+}
+
+
+export class Orgs extends Map {
+	constructor(users, options = {}) {
+		super();
+		
+		const {
+			schema: customSchema,
+			indexes: customIndexes,
+			null: nullProps
+		} = 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("orgs", { jsonSchema });
+			
+			this.collection.ensureIndexes([ ...indexes, ...customIndexes ?? [] ]);
+			
+			this.collection.deleteOne =
+				this.collection.deleteMany =
+					preventDirectDelete;
+			
+			this.null = new Org(this, {
+				...nullProps,
+				_id: null,
+				title: "",
+				displayLabel: "",
+				note: "",
+				owners: [],
+				createdAt: Date.now()
+			});
+			
+			this.null.ownerIds = new Array.Empty();
+			this.null.ownerOrgs = new Set.Empty();
+			this.null.ownerUsers = new Set.Empty();
+			this.null.slaveOrgs = new Set.Empty();
+			
+			return this;
+		})();
+	}
+	
+	load(orgDoc) {
+		new Org(this, orgDoc);
+		
+	}
+	
+	static resolve(org, slaveOrgs) {
+		slaveOrgs = [ org, ...slaveOrgs ];
+		
+		for (const ownerOrg of org.ownerOrgs) {
+			Orgs.resolve(ownerOrg, slaveOrgs);
+			ownerOrg.slaveOrgs.addAll(slaveOrgs);
+		}
+		
+	}
+	
+	sorted = [];
+	
+	async update() {
+		
+		const array = [ ...this.values() ];
+		const sorted = [];
+		
+		for (const org of array) {
+			org.ownerOrgs.clear();
+			org.ownerUsers.clear();
+			org.slaveOrgs.clear();
+			
+			for (const ownerId of org.ownerIds) {
+				const ownerOrg = this.get(ownerId);
+				if (ownerOrg)
+					org.ownerOrgs.add(ownerOrg);
+				else {
+					const ownerUser = this.users.get(ownerId);
+					if (ownerUser)
+						org.ownerUsers.add(ownerUser);
+				}
+			}
+			
+			if (!org.ownerOrgs.size && org._id)
+				sorted.push(org);
+		}
+		
+		for (const org of array)
+			if (!array.some(anotherOrg => anotherOrg.ownerOrgs.has(org)))
+				Orgs.resolve(org, []);
+		
+		sorted.sort(sortOrgs);
+		for (const org of array)
+			org.slaveOrgs.sort(sortOrgs);
+		
+		for (let i = 0; i < sorted.length; i++) {
+			const org = sorted[i];
+			for (const slaveOrg of [ ...org.slaveOrgs ].reverse())
+				if (slaveOrg.ownerOrgs.has(org)) {
+					const slaveOrgIndex = sorted.indexOf(slaveOrg);
+					if (~slaveOrgIndex) {
+						sorted.splice(slaveOrgIndex, 1);
+						i--;
+					}
+					sorted.splice(i + 1, 0, slaveOrg);
+				}
+		}
+		for (let o = 0, { length } = sorted; o < length;)
+			sorted[o]._o = o++;
+		
+		this.sorted = sorted;
+		
+		this.users.emit("orgs-update");
+		
+		if (this.users.isInited) {
+			this.users.updateDebounced.clear();
+			this.users.update();
+		}
+		
+	}
+	
+	updateDebounced = debounce(this.update, 250);
+	
+	initialLoad = async () => {
+		
+		for (const orgDoc of await this.collection.find().toArray())
+			this.load(orgDoc);
+		
+		delete this.initialLoad;
+		
+	};
+	
+	init = async () => {
+		
+		await this.update();
+		
+		this.collection.changeListeners.add(next => {
+			switch (next.operationType) {
+				case "insert": {
+					const org = new Org(this, next.fullDocument);
+					this.users.emit("orgs-org-update", org, 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("orgs-org-update", null, next);
+			}
+			
+		});
+		
+		delete this.init;
+		
+	};
+	
+	new({ title, note, ...restProps }, ownerId) {
+		return this.collection.insertOne({
+			_id: (new ObjectId()).toString(),
+			title,
+			note: note || "",
+			owners: ownerId ? [ ownerId ] : [],
+			...Object.delete(restProps, "_id", "owners"),
+			createdAt: Date.now()
+		});
+	}
+	
+	collectionDelete(org) {
+		const _id = typeof org == "string" ? org : org._id;
+		
+		return this.collection.bulkWrite([
+			{ updateMany: { filter: { owners: _id }, update: { $pullAll: { owners: [ _id ] } } } },
+			{ deleteOne: { filter: { _id } } }
+		]);
+	}
+	
+	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/orgs/index.js

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

package/lib/orgs/schema.js

@@ -0,0 +1,39 @@
+import { regexps } from "../lib";
+
+
+export const basisSchema = {
+	required: [
+		"_id",
+		"title",
+		"note",
+		"owners",
+		"createdAt"
+	],
+	properties: {
+		_id: {
+			bsonType: "string",
+			pattern: regexps._id.pattern
+		},
+		title: {
+			bsonType: "string",
+			maxLength: 512
+		},
+		note: {
+			bsonType: "string",
+			maxLength: 131072
+		},
+		owners: {
+			bsonType: "array",
+			uniqueItems: true,
+			items: {
+				bsonType: "string",
+				pattern: regexps._id.pattern
+			},
+			additionalItems: false
+		},
+		createdAt: {
+			bsonType: "number"
+		}
+	},
+	additionalProperties: false
+};

package/lib/roles/Role.js

@@ -0,0 +1,70 @@
+const snapshots = new Map();
+
+
+export class Role {
+	constructor(roles, roleDoc) {
+		this.#roles = roles;
+		
+		this._id = roleDoc._id;
+		roles.set(this._id, this);
+		
+		this.update(roleDoc);
+		
+	}
+	
+	#roles;
+	
+	ownInvolves = [];
+	involves = new Set();
+	abilities = {};
+	inheritedAbilities = {};
+	
+	update({ _id, involves: ownInvolveIds, abilities: ownAbilities, title, ...restProps }, next) {
+		
+		const roles = this.#roles;
+		
+		Object.assign(this, restProps);
+		
+		if (ownInvolveIds)
+			this.ownInvolveIds = ownInvolveIds;
+		
+		if (ownAbilities)
+			this.ownAbilities = ownAbilities;
+		
+		if (title !== undefined) {
+			this.title = title;
+			this.displayTitle = title || this._id;
+		}
+		
+		
+		if (ownInvolveIds || ownAbilities) {
+			const snapshot = [
+				this.ownInvolveIds.join(","),
+				JSON.stringify(this.ownAbilities)
+			].join("\n");
+			
+			if (snapshot != snapshots.get(this._id)) {
+				snapshots.set(this._id, snapshot);
+				
+				if (roles.users.isInited)
+					roles.updateDebounced();
+				
+				roles.users.emit("roles-role-update", next);
+			}
+		}
+		
+	}
+	
+	delete() {
+		
+		const roles = this.#roles;
+		
+		roles.delete(this._id);
+		
+		snapshots.delete(this._id);
+		
+		roles.updateDebounced();
+		
+	}
+	
+}