insite-subscriptions-server 1.0.216

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 subscriptions server side
+
+## Installation
+
+```sh
+$ npm install insite-subscriptions-server
+```
+
+Or
+
+```sh
+$ yarn add insite-subscriptions-server
+```

package/lib/CollectionMapPublication.js

@@ -0,0 +1,163 @@
+import sift from "sift";
+import { Publication } from "./Publication";
+
+
+function projectDocument(document, projection, isInclusive = true, isTop = true) {
+	if (projection)
+		if (isInclusive) {
+			const projected = {};
+			for (const key in projection) {
+				const subprojection = projection[key];
+				projected[key] =
+					typeof subprojection == "object" ?
+						Array.isArray(document[key]) ?
+							document[key].map(item => projectDocument(item, subprojection, true, false)) :
+							projectDocument(document[key], subprojection, true, false) :
+						document[key];
+			}
+			if (isTop && projection._id === 0)
+				delete projected._id;
+			
+			return projected;
+		} else {
+			const projected = { ...document };
+			for (const key in projection) {
+				const subprojection = projection[key];
+				if (typeof subprojection == "object")
+					projected[key] =
+						Array.isArray(document[key]) ?
+							document[key].map(item => projectDocument(item, subprojection, false, false)) :
+							projectDocument(document[key], subprojection, false, false);
+				 else
+					delete projected[key];
+			}
+			
+			return projected;
+		}
+	
+	return document;
+}
+
+
+export class CollectionMapPublication extends Publication {
+	constructor(name, collection, queryProps, transform) {
+		super(name, { collection, queryProps, transform });
+		
+	}
+	
+	type = "map";
+	
+	skipSymbol = Symbol("skip");
+	
+	skip(next) {
+		next[this.skipSymbol] = true;
+		
+	}
+	
+	makeQueryProps(args) {
+		const { query = null, projection = null, sort = null, triggers } = (typeof this.queryProps == "function" ? this.queryProps(...args) : this.queryProps) || {};
+		
+		let isProjectionInclusive = null;
+		let fields = null;
+		if (projection) {
+			for (const key in projection) {
+				isProjectionInclusive = !!projection[key];
+				if (key !== "_id")
+					break;
+			}
+			if (isProjectionInclusive) {
+				fields = new Set([ ...Object.keys(query), ...Object.keys(projection), ...triggers ?? [] ]);
+				fields.delete("_id");
+				if (projection._id !== 0)
+					projection._id = 1;
+			}
+		}
+		
+		return { query, projection, isProjectionInclusive, fields, sort, args };
+	}
+	
+	async fetchSubscription(subscription, next) {
+		if (subscription.query) {
+			if (next) {
+				const { _id } = next.documentKey;
+				
+				if (next.operationType === "insert" || (next.operationType != "delete" && subscription.match(next.fullDocument))) {
+					const doc = projectDocument(next.fullDocument, subscription.projection, subscription.isProjectionInclusive);
+					this.transform?.(doc, subscription.args);
+					if (subscription.ids.has(_id))
+						return [ "u"/* update */, doc, next.updateDescription && Object.keys(next.updateDescription.updatedFields) ];
+					
+					subscription.ids.add(_id);
+					
+					return [ "c"/* create */, doc ];
+					
+				}
+				subscription.ids.delete(_id);
+				
+				return [ "d"/* delete */, _id ];
+				
+			}
+			const cursor = this.collection.find(subscription.query);
+			
+			if (subscription.projection)
+				cursor.project(subscription.projection);
+			
+			if (subscription.sort)
+				cursor.sort(subscription.sort);
+			
+			const array = await cursor.toArray();
+			
+			if (subscription.ids) {
+				subscription.ids.clear();
+				if (this.transform)
+					for (const item of array) {
+						subscription.ids.add(item._id);
+						this.transform(item, subscription.args);
+					}
+				else
+					for (const item of array)
+						subscription.ids.add(item._id);
+			} else if (this.transform)
+				for (const item of array)
+					this.transform(item, subscription.args);
+			
+			return [ "i"/* initial */, array, subscription.sort ];
+			
+		}
+		
+		return null;
+	}
+	
+	async fetch(...args) {
+		return [ await this.fetchSubscription(this.makeQueryProps(args), null) ];
+	}
+	
+	changed(changed) {
+		return Promise.all(this.subscriptions.map(subscription => subscription.changed(changed)));
+	}
+	
+	onSubscribe(subscription) {
+		Object.assign(subscription, this.makeQueryProps(subscription.args));
+		
+		if (subscription.query) {
+			subscription.match = sift(subscription.query);
+			this.collection.changeListeners.add(subscription.collectionChangeListener);
+		}
+		
+	}
+	
+	flushInitial() {
+		return Promise.all(this.subscriptions.map(async subscription => {
+			subscription.handler([ await this.fetchSubscription(subscription) ]);
+			subscription.updates = [];
+			
+		}));
+	}
+	
+	onUnsubscribe(subscription) {
+		if (subscription.query)
+			this.collection.changeListeners.delete(subscription.collectionChangeListener);
+		
+	}
+	
+}

package/lib/CollectionMapSubscriptionHandle.js

@@ -0,0 +1,60 @@
+import { SubscriptionHandle } from "./SubscriptionHandle";
+
+
+export class CollectionMapSubscriptionHandle extends SubscriptionHandle {
+	constructor(publicationName, args, handler, immediately) {
+		super(publicationName, args, handler, immediately, true);
+		
+		if (this.publication) {
+			this.publication.subscribe(this);
+			
+			this.skipSymbol = this.publication.skipSymbol;
+			
+			if (immediately)
+				this.changed(null);
+		}
+		
+	}
+	
+	ids = new Set();
+	
+	async changed(next) {
+		this.handler([ await this.publication.fetchSubscription(this, next) ]);
+		
+	}
+	
+	updates = [];
+	flushTimeout = null;
+	
+	handleUpdatedFieldsSome = field => this.fields.has(field);
+	
+	flushUpdates = () => {
+		
+		if (this.updates.length) {
+			this.handler(this.updates);
+			this.updates = [];
+		}
+		
+	};
+	
+	collectionChangeListener = async next => {
+		
+		if (
+			!next[this.skipSymbol] &&
+			(this.ids.has(next.documentKey._id) ? (
+				next.operationType !== "update" ||
+				!this.fields ||
+				Object.keys(next.updateDescription.updatedFields).some(this.handleUpdatedFieldsSome)
+			) : this.match(next.fullDocument))
+		) {
+			clearTimeout(this.flushTimeout);
+			
+			this.updates.push(await this.publication.fetchSubscription(this, next));
+			
+			this.flushTimeout = setTimeout(this.flushUpdates, 1);
+		}
+		
+	};
+	
+	
+}

package/lib/Publication.js

@@ -0,0 +1,42 @@
+export const publications = new Map();
+
+
+export class Publication {
+	constructor(name, props) {
+		this.name = name;
+		Object.assign(this, props);
+		
+		publications.set(name, this);
+		
+	}
+	
+	type = "object";
+	
+	subscriptions = new Set();
+	
+	// eslint-disable-next-line @typescript-eslint/no-empty-function
+	fetch() {}
+	
+	fetchSubscription(subscription) {
+		return this.fetch(...subscription.args);
+	}
+	
+	subscribe(subscription) {
+		this.subscriptions.add(subscription);
+		this.onSubscribe?.(subscription);
+		
+	}
+	
+	changed(changed) {
+		for (const subscription of this.subscriptions)
+			subscription.changed(changed);
+		
+	}
+	
+	unsubscribe(subscription) {
+		this.onUnsubscribe?.(subscription);
+		this.subscriptions.delete(subscription);
+		
+	}
+	
+}

package/lib/SubscriptionHandle.js

@@ -0,0 +1,44 @@
+import { publications } from "./Publication";
+
+
+export class SubscriptionHandle {
+	constructor(publicationName, args, handler, immediately, prevent) {
+		this.publication = publications.get(publicationName);
+		
+		if (this.publication) {
+			this.args = args;
+			this.handler = handler;
+			
+			if (!prevent) {
+				this.publication.subscribe(this);
+				
+				if (immediately)
+					this.changed(null);
+			}
+			
+		} else if (process.env.NODE_ENV === "development")
+			console.error("Unknown publication", publicationName);
+		
+	}
+	
+	async changed(changed) {
+		this.handler(await this.publication.fetchSubscription(this, changed), changed);
+		
+	}
+	
+	cancel() {
+		
+		this.publication?.unsubscribe(this);
+		
+	}
+	
+	renew() {
+		
+		this.publication?.unsubscribe(this);
+		
+		this.publication?.subscribe(this);
+		
+		return this.changed(null);
+	}
+	
+}

package/lib/index.js

@@ -0,0 +1,3 @@
+export * from "./CollectionMapPublication";
+export * from "./Publication";
+export * from "./SubscriptionHandle";

package/lib/ws/SubscriptionHandler.js

@@ -0,0 +1,70 @@
+import { CollectionMapSubscriptionHandle } from "../CollectionMapSubscriptionHandle";
+import { publications } from "../Publication";
+import { SubscriptionHandle } from "../SubscriptionHandle";
+import { Subscriptions } from "./Subscriptions";
+
+
+const handlesByType = {
+	object: SubscriptionHandle,
+	map: CollectionMapSubscriptionHandle
+};
+
+
+export class SubscriptionHandler {
+	constructor(wss, options = {}) {
+		
+		const {
+			users
+		} = options;
+		
+		if (users)
+			users.on("user-permissions-change", SubscriptionHandler.handleUserPermissionsChange);
+		
+		wss.on("client-connect", SubscriptionHandler.handleClientConnect);
+		wss.on("client-session", SubscriptionHandler.handleClientSession);
+		wss.on("client-message:s-s"/* subscription subscribe */, SubscriptionHandler.handleClientSubscribe);
+		wss.on("client-message:s-u"/* subscription unsubscribe */, SubscriptionHandler.handleClientUnsubscribe);
+		wss.on("client-close", SubscriptionHandler.handleClientClose);
+		
+	}
+	
+	
+	static handleUserPermissionsChange(user) {
+		if (user.webSockets)
+			for (const ws of user.webSockets)
+				ws.subscriptions.renew();
+		
+	}
+	
+	static handleClientConnect(ws) {
+		ws.subscriptions = new Subscriptions();
+		
+	}
+	
+	static handleClientSession(ws) {
+		ws.subscriptions.renew();
+		
+	}
+	
+	static handleClientSubscribe(ws, subscriptionType, publicationName, i, args, immediately) {
+		const Handle = handlesByType[subscriptionType];
+		
+		if (Handle && publications.get(publicationName)?.type === subscriptionType) {
+			const handler = data => ws.sendMessage("s-c"/* subscription changed */, i, data);
+			ws.subscriptions.subscribe(i, new Handle(publicationName, [ ws, ...args ], handler, immediately));
+		}
+		
+	}
+	
+	static handleClientUnsubscribe(ws, i) {
+		ws.subscriptions.cancel(i);
+		
+	}
+	
+	static handleClientClose(ws) {
+		for (const subscription of ws.subscriptions.values())
+			subscription.cancel();
+		
+	}
+	
+}

package/lib/ws/Subscriptions.js

@@ -0,0 +1,15 @@
+export class Subscriptions extends Map {
+	
+	subscribe = this.set;
+	
+	renew() {
+		return Promise.all(this.mapValues(subscription => subscription.renew()));
+	}
+	
+	cancel(key) {
+		this.get(key)?.cancel();
+		this.delete(key);
+		
+	}
+	
+}

package/lib/ws/index.js

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

package/package.json

@@ -0,0 +1,34 @@
+{
+	"name": "insite-subscriptions-server",
+	"version": "1.0.216",
+	"description": "inSite subscriptions 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-subscriptions-server.git"
+	},
+	"keywords": [
+		"insite",
+		"subscriptions",
+		"server"
+	],
+	"author": "Eugene Nesvetaev <dev@nesvet.dev> (https://nesvet.dev/)",
+	"license": "MIT",
+	"dependencies": {
+		"insite-ws": "^1",
+		"sift": "^16"
+	},
+	"devDependencies": {
+		"@nesvet/eslint-config": "^1"
+	}
+}