insite-users-server 1.0.334

package/lib/ws/UsersServer.js

@@ -0,0 +1,212 @@
+import {
+	AbilitiesPublication,
+	RolesPublication,
+	UserPublication,
+	UsersPublication,
+	UsersExtendedPublication,
+	OrgsPublication,
+	OrgsExtendedPublication
+} from "./publications";
+
+
+export class UsersServer {
+	constructor(wss, options = {}) {
+		wss.usersServer = this;
+		
+		const {
+			users,
+			publication: publicationOptions,
+			extendedPublication: extendedPublicationOptions,
+			userPublication: userPublicationOptions,
+			roles = {},
+			orgs = {},
+			getSessionProps
+		} = options;
+		
+		const {
+			publication: rolesPublicationOptions
+		} = roles;
+		
+		const {
+			publication: orgsPublicationOptions,
+			extendedPublication: orgsExtendedPublicationOptions
+		} = orgs;
+		
+		this.users = users;
+		this.getSessionProps = getSessionProps;
+		
+		for (const user of users.values())
+			UsersServer.handleUserCreate(user);
+		
+		users.abilities.publication = new AbilitiesPublication(users.abilities);
+		
+		users.roles.publication = new RolesPublication(users.roles, rolesPublicationOptions);
+		users.on("roles-update", UsersServer.handleRolesUpdate);
+		users.on("roles-role-update", UsersServer.handleRolesRoleUpdate);
+		
+		users.publication = new UsersPublication(users, publicationOptions);
+		users.extendedPublication = new UsersExtendedPublication(users, extendedPublicationOptions);
+		users.userPublication = new UserPublication(users, userPublicationOptions);
+		users.on("user-create", UsersServer.handleUserCreate);
+		users.on("user-is-online", UsersServer.handleUserIsOnline);
+		
+		users.on("session-delete", this.#handleSessionDelete);
+		
+		users.orgs.publication = new OrgsPublication(users.orgs, orgsPublicationOptions);
+		users.orgs.extendedPublication = new OrgsExtendedPublication(users.orgs, orgsExtendedPublicationOptions);
+		users.on("orgs-update", UsersServer.handleOrgsUpdate);
+		users.on("orgs-org-update", UsersServer.handleOrgsOrgUpdate);
+		
+		wss.options.WebSocket.prototype.login = UsersServer.login;
+		wss.options.WebSocket.prototype.logout = UsersServer.logout;
+		wss.options.WebSocket.prototype.setSession = UsersServer.setSession;
+		
+		wss.on("client-connect", UsersServer.handleClientConnect);
+		
+		if (wss.requestListener) {
+			wss.on("client-request:login", UsersServer.handleClientRequestLogin);
+			wss.on("client-request:logout", UsersServer.handleClientRequestLogout);
+		}
+		
+		wss.on("client-closed", UsersServer.handleClientClosed);
+		
+	}
+	
+	wsBySessions = new Map();
+	
+	getDefaultSessionProps({ userAgent, remoteAddress }) {
+		return {
+			userAgent,
+			remoteAddress
+		};
+	}
+	
+	
+	static handleUserCreate(user) {
+		user.webSockets = new Set();
+		
+	}
+	
+	static handleUserIsOnline({ _id, isOnline }) {
+		const updates = { _id, isOnline };
+		
+		for (const usersSubscription of this.publication.subscriptions) {
+			const [ ws ] = usersSubscription.args;
+			if (ws.user && ws.user._id != _id)
+				usersSubscription.handler([ [ "u"/* update */, updates, true ] ]);
+		}
+		
+	}
+	
+	#handleSessionDelete = session => this.wsBySessions.get(session)?.setSession(null);
+	
+	static handleRolesUpdate() {
+		this.roles.publication.flushInitial();
+		
+	}
+	
+	static handleRolesRoleUpdate(_, next) {
+		if (next)
+			this.roles.publication.skip(next);
+		
+	}
+	
+	static handleOrgsUpdate() {
+		
+		this.orgs.publication.flushInitial();
+		this.orgs.extendedPublication.flushInitial();
+		
+	}
+	
+	static handleOrgsOrgUpdate(_, next) {
+		if (next) {
+			this.orgs.publication.skip(next);
+			this.orgs.extendedPublication.skip(next);
+		}
+		
+	}
+	
+	
+	static handleClientConnect(ws) {
+		ws.session = null;
+		
+	}
+	
+	static handleClientRequestLogin(ws, email, password) {
+		return ws.login(email, password);
+	}
+	
+	static handleClientRequestLogout(ws) {
+		return ws.logout();
+	}
+	
+	static handleClientClosed(ws) {
+		ws.session?.offline();
+		ws.setSession(null);
+		
+	}
+	
+	
+	static async login(email, password) {
+		
+		const { usersServer } = this.wss;
+		
+		const session = await usersServer.users.login(email, password, {
+			...usersServer.getDefaultSessionProps(this),
+			...usersServer.getSessionProps?.(this),
+			isOnline: true
+		});
+		
+		if (session)
+			this.setSession(session);
+		
+	}
+	
+	static logout() {
+		if (this.session) {
+			this.wss.usersServer.users.logout(this.session);
+			this.setSession(null);
+		}
+		
+	}
+	
+	
+	static setSession(session, shouldProlong) {
+		
+		const { usersServer } = this.wss;
+		
+		if (typeof session == "string")
+			session = usersServer.users.sessions.get(session) ?? null;
+		
+		if (this.session != session) {
+			if (this.session)
+				usersServer.wsBySessions.delete(this.session);
+			
+			if (session) {
+				this.session = session;
+				this.user = session.user;
+				this.lastUserId = this.user._id;
+				
+				this.user.webSockets.add(this);
+				usersServer.wsBySessions.set(session, this);
+				
+				if (shouldProlong)
+					session.prolong({
+						...usersServer.getDefaultSessionProps(this),
+						...usersServer.getSessionProps?.(this),
+						isOnline: true
+					});
+				
+			} else {
+				this.user.webSockets.delete(this);
+				
+				this.session = null;
+				delete this.user;
+			}
+			
+			this.wss.emit("client-session", this, shouldProlong);
+		}
+		
+	}
+	
+}

package/lib/ws/index.js

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

package/lib/ws/publications.js

@@ -0,0 +1,258 @@
+import { Publication, CollectionMapPublication } from "insite-subscriptions-server";
+
+
+export class AbilitiesPublication extends Publication {
+	constructor(abilities) {
+		super("abilities", {
+
+			fetch({ user }) {
+				if (user?.abilities.login?.sections?.includes("users"))
+					return { abilities: abilities.getSchemeFor(user) };
+			}
+
+		});
+	}
+}
+
+
+export class RolesPublication extends CollectionMapPublication {
+	constructor(roles, options = {}) {
+
+		const {
+			projection = { title: 1, description: 1 },
+			sort = { _o: 1 },
+			transform
+		} = options;
+
+		Object.assign(projection, { involves: 1, abilities: 1 });
+
+		super("roles", roles.collection, ws => ws.user?.abilities.login?.sections?.includes("users") && {
+			query: { _id: { $in: ws.user.slaveRoleIds } },
+			projection,
+			sort
+		}, roleDoc => {
+			const { involves, abilities, inheritedAbilities, displayTitle, _o } = roles.get(roleDoc._id);
+
+			if (roleDoc.involves) {
+				roleDoc.ownInvolves = roleDoc.involves;
+				roleDoc.involves = involves.ids();
+				roleDoc.abilities = abilities;
+				roleDoc.inheritedAbilities = inheritedAbilities;
+			}
+
+			if (projection.title)
+				roleDoc.displayTitle = displayTitle;
+
+			roleDoc._o = _o;
+
+			transform?.(roleDoc);
+
+		});
+
+	}
+
+}
+
+
+export class UserPublication extends Publication {
+	constructor(users, options = {}) {
+
+		const {
+			fieldsToUpdate = [],
+			projection,
+			transform
+		} = options;
+
+		for (const key of [
+			"email",
+			"name",
+			"name.first",
+			"name.middle",
+			"name.last",
+			"org",
+			"job",
+			"avatar"
+		])
+			if (!projection || projection[key] !== 0)
+				fieldsToUpdate.push(key);
+
+		super("user", {
+
+			onSubscribe(subscription) {
+				const [ { user } ] = subscription.args;
+
+				if (user) {
+					const { _id } = user;
+
+					subscription.changeListener = next => {
+						if (next.documentKey._id == _id)
+							switch (next.operationType) {
+								case "update":
+									if (!Object.keys(next.updateDescription.updatedFields).includesAny(fieldsToUpdate))
+										break;
+
+								case "replace":
+								case "delete":
+									subscription.changed(next);
+							}
+
+					};
+
+					users.collection.changeListeners.add(subscription.changeListener);
+				}
+
+			},
+
+			fetch({ user, session }, isSessionIdRequired) {
+				if (user) {
+					const userDoc = Object.pick(user, "_id", "email", "name", "initials", "displayLabel", "job", "avatarUrl", "abilities", "slaveIds");
+
+					userDoc.orgId = user.org._id;
+					userDoc.sessionId = isSessionIdRequired ? session._id : undefined;
+					userDoc.isOnline = true;
+
+					if (projection)
+						for (const key in projection)
+							if (projection[key])
+								userDoc[key] = user[key];
+							else
+								delete userDoc[key];
+
+					transform?.(userDoc);
+
+					return userDoc;
+				}
+			},
+
+			onUnsubscribe(subscription) {
+				if (subscription.changeListener)
+					users.collection.changeListeners.delete(subscription.changeListener);
+
+			}
+
+		});
+
+	}
+}
+
+export class UsersPublication extends CollectionMapPublication {
+	constructor(users, options = {}) {
+
+		const {
+			projection = { email: 1, name: 1, org: 1, job: 1, avatar: 1 },
+			sort = { "name.last": 1 },
+			transform
+		} = options;
+
+		super("users", users.collection, ws => ws.user?.abilities.login && {
+			query: {},
+			projection,
+			sort
+		}, userDoc => {
+			({
+				initials: userDoc.initials,
+				displayLabel: userDoc.displayLabel,
+				avatarUrl: userDoc.avatarUrl,
+				isOnline: userDoc.isOnline
+			} = users.get(userDoc._id));
+			
+			userDoc.orgId = userDoc.org;
+			
+			delete userDoc.org;
+			delete userDoc.avatar;
+			
+			transform?.(userDoc);
+			
+		});
+
+	}
+}
+
+export class UsersExtendedPublication extends CollectionMapPublication {
+	constructor(users, options = {}) {
+
+		const {
+			projection = { _id: 1 },
+			sort,
+			triggers = [],
+			transform
+		} = options;
+
+		if (!triggers.includes("roles"))
+			triggers.push("roles");
+
+		super("users.extended", users.collection, ws => ws.user?.abilities.login?.sections?.includes("users") && {
+			query: { _id: { $in: ws.user.slaveIds } },
+			projection,
+			sort,
+			triggers
+		}, (userDoc, [ ws ]) => {
+			userDoc.roleIds = users.get(userDoc._id).ownRoleIds.intersection(ws.user.slaveRoleIds);
+
+			transform?.(userDoc);
+
+		});
+
+	}
+}
+
+
+export class OrgsPublication extends CollectionMapPublication {
+	constructor(orgs, options = {}) {
+
+		const {
+			projection = { title: 1 },
+			sort = { title: 1 },
+			transform
+		} = options;
+
+		super("orgs", orgs.collection, ws => ws.user?.abilities.login && {
+			query: {},
+			projection,
+			sort
+		}, orgDoc => {
+			({
+				initials: orgDoc.initials,
+				displayLabel: orgDoc.displayLabel
+			} = orgs.get(orgDoc._id));
+			
+			transform?.(orgDoc);
+			
+		});
+
+	}
+
+}
+
+export class OrgsExtendedPublication extends CollectionMapPublication {
+	constructor(orgs, options = {}) {
+
+		const {
+			projection = { note: 1 },
+			sort = { _o: 1 },
+			triggers = [],
+			transform
+		} = options;
+
+		if (!triggers.includes("owners"))
+			triggers.push("owners");
+
+		super("orgs.extended", orgs.collection, ws => ws.user?.abilities.login?.sections?.includes("users") && {
+			query: { _id: { $in: ws.user.slaveIds } },
+			projection,
+			sort,
+			triggers
+		}, (orgDoc, [ ws ]) => {
+			const { ownerIds, slaveOrgs, _o } = orgs.get(orgDoc._id);
+
+			orgDoc.owners = ownerIds.intersection(ws.user.slaveIds);
+			orgDoc.slaveOrgs = slaveOrgs.intersection(ws.user.slaveOrgs).ids();
+			orgDoc._o = _o;
+
+			transform?.(orgDoc);
+
+		});
+
+	}
+
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+	"name": "insite-users-server",
+	"version": "1.0.334",
+	"description": "inSite users server side",
+	"type": "module",
+	"main": "./lib/index.js",
+	"module": "./lib/index.js",
+	"exports": {
+		".": "./lib/index.js",
+		"./ws": "./lib/ws/index.js"
+	},
+	"packageManager": "yarn@1.22.22",
+	"scripts": {
+		"test": "echo \"Error: no test specified\" && exit 1"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/nesvet/insite-users-server.git"
+	},
+	"keywords": [
+		"insite",
+		"users",
+		"server"
+	],
+	"author": "Eugene Nesvetaev <dev@nesvet.dev> (https://nesvet.dev/)",
+	"license": "MIT",
+	"dependencies": {
+		"@nesvet/n": "^1",
+		"@nesvet/deprecated-extensions": "^1",
+		"insite-db": "^1",
+		"insite-subscriptions-server": "^1",
+		"argon2": "^0",
+		"eventemitter3": "^5"
+	},
+	"devDependencies": {
+		"@nesvet/eslint-config": "^1"
+	}
+}