@nymphjs/pubsub 1.0.0-beta.12 → 1.0.0-beta.121

package/dist/PubSub.js

@@ -1,125 +1,254 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const nymph_1 = require("@nymphjs/nymph");
-const websocket_1 = require("websocket");
-const lodash_1 = require("lodash");
-const conf_1 = require("./conf");
-class PubSub {
+import { classNamesToEntityConstructors, } from '@nymphjs/nymph';
+import ws from 'websocket';
+import { difference } from 'lodash-es';
+import { ConfigDefaults as defaults } from './conf/index.js';
+/**
+ * A publish/subscribe server for Nymph.
+ *
+ * Written by Hunter Perrin for SciActive.
+ *
+ * @author Hunter Perrin <hperrin@port87.com>
+ * @copyright SciActive Inc
+ * @see http://nymph.io/
+ */
+export default class PubSub {
+    /**
+     * The Nymph instance.
+     */
+    nymph;
+    /**
+     * The PubSub config.
+     */
+    config;
+    /**
+     * The WebSocket server.
+     */
+    server;
+    sessions = new Map();
+    querySubs = {};
+    uidSubs = {};
+    outgoingClientMessages = new Map();
+    outgoingClientMessagesTimeout = null;
+    static transactionPublishes = [];
     static initPublisher(config, nymph) {
-        const configWithDefaults = { ...conf_1.ConfigDefaults, ...config };
-        nymph.on('beforeSaveEntity', async (nymph, entity) => {
+        const configWithDefaults = { ...defaults, ...config };
+        const unsubscribers = [];
+        unsubscribers.push(nymph.on('beforeSaveEntity', async (enymph, entity) => {
             const guid = entity.guid;
-            const etype = entity.constructor.ETYPE;
-            const off = nymph.on('afterSaveEntity', async (_nymph, result) => {
+            const EntityClass = entity.constructor;
+            const etype = EntityClass.ETYPE;
+            if (!EntityClass.pubSubEnabled) {
+                return;
+            }
+            const off = enymph.on('afterSaveEntity', async (curNymph, result) => {
                 off();
+                off2();
                 if (!(await result)) {
                     return;
                 }
-                this.publish(JSON.stringify({
+                const payload = JSON.stringify({
                     action: 'publish',
                     event: guid == null ? 'create' : 'update',
                     guid: entity.guid,
                     entity: entity.toJSON(),
                     etype: etype,
-                }), configWithDefaults);
+                });
+                this.transactionPublishes.push({
+                    nymph: curNymph,
+                    payload,
+                    config: configWithDefaults,
+                });
+                await this.publishTransactionPublishes(curNymph);
             });
-        });
-        nymph.on('beforeDeleteEntity', async (nymph, entity) => {
+            const off2 = enymph.on('failedSaveEntity', async () => {
+                off();
+                off2();
+            });
+        }));
+        unsubscribers.push(nymph.on('beforeDeleteEntity', async (enymph, entity) => {
             const guid = entity.guid;
-            const etype = entity.constructor.ETYPE;
-            const off = nymph.on('afterDeleteEntity', async (_nymph, result) => {
+            const EntityClass = entity.constructor;
+            const etype = EntityClass.ETYPE;
+            if (!EntityClass.pubSubEnabled) {
+                return;
+            }
+            const off = enymph.on('afterDeleteEntity', async (curNymph, result) => {
                 off();
+                off2();
                 if (!(await result)) {
                     return;
                 }
-                this.publish(JSON.stringify({
+                const payload = JSON.stringify({
                     action: 'publish',
                     event: 'delete',
                     guid: guid,
                     etype: etype,
-                }), configWithDefaults);
+                });
+                this.transactionPublishes.push({
+                    nymph: curNymph,
+                    payload,
+                    config: configWithDefaults,
+                });
+                await this.publishTransactionPublishes(curNymph);
             });
-        });
-        nymph.on('beforeDeleteEntityByID', async (nymph, guid, className) => {
+            const off2 = enymph.on('failedDeleteEntity', async () => {
+                off();
+                off2();
+            });
+        }));
+        unsubscribers.push(nymph.on('beforeDeleteEntityByID', async (enymph, guid, className) => {
             try {
-                const etype = nymph.getEntityClass(className ?? 'Entity').ETYPE;
-                const off = nymph.on('afterDeleteEntityByID', async (_nymph, result) => {
+                const EntityClass = enymph.getEntityClass(className ?? 'Entity');
+                const etype = EntityClass.ETYPE;
+                if (!EntityClass.pubSubEnabled) {
+                    return;
+                }
+                const off = enymph.on('afterDeleteEntityByID', async (curNymph, result) => {
                     off();
+                    off2();
                     if (!(await result)) {
                         return;
                     }
-                    this.publish(JSON.stringify({
+                    const payload = JSON.stringify({
                         action: 'publish',
                         event: 'delete',
                         guid: guid,
                         etype: etype,
-                    }), configWithDefaults);
+                    });
+                    this.transactionPublishes.push({
+                        nymph: curNymph,
+                        payload,
+                        config: configWithDefaults,
+                    });
+                    await this.publishTransactionPublishes(curNymph);
+                });
+                const off2 = enymph.on('failedDeleteEntityByID', async () => {
+                    off();
+                    off2();
                 });
             }
             catch (e) {
                 return;
             }
-        });
-        nymph.on('beforeNewUID', async (nymph, name) => {
-            const off = nymph.on('afterNewUID', async (_nymph, result) => {
+        }));
+        unsubscribers.push(nymph.on('beforeNewUID', async (enymph, name) => {
+            const off = enymph.on('afterNewUID', async (curNymph, result) => {
                 off();
+                off2();
                 const value = await result;
                 if (value == null) {
                     return;
                 }
-                this.publish(JSON.stringify({
+                const payload = JSON.stringify({
                     action: 'publish',
                     event: 'newUID',
                     name: name,
                     value: value,
-                }), configWithDefaults);
+                });
+                this.transactionPublishes.push({
+                    nymph: curNymph,
+                    payload,
+                    config: configWithDefaults,
+                });
+                await this.publishTransactionPublishes(curNymph);
             });
-        });
-        nymph.on('beforeSetUID', async (nymph, name, value) => {
-            const off = nymph.on('afterSetUID', async (_nymph, result) => {
+            const off2 = enymph.on('failedNewUID', async () => {
                 off();
+                off2();
+            });
+        }));
+        unsubscribers.push(nymph.on('beforeSetUID', async (enymph, name, value) => {
+            const off = enymph.on('afterSetUID', async (curNymph, result) => {
+                off();
+                off2();
                 if (!(await result)) {
                     return;
                 }
-                this.publish(JSON.stringify({
+                const payload = JSON.stringify({
                     action: 'publish',
                     event: 'setUID',
                     name: name,
                     value: value,
-                }), configWithDefaults);
+                });
+                this.transactionPublishes.push({
+                    nymph: curNymph,
+                    payload,
+                    config: configWithDefaults,
+                });
+                await this.publishTransactionPublishes(curNymph);
             });
-        });
-        nymph.on('beforeRenameUID', async (nymph, oldName, newName) => {
-            const off = nymph.on('afterRenameUID', async (_nymph, result) => {
+            const off2 = enymph.on('failedSetUID', async () => {
+                off();
+                off2();
+            });
+        }));
+        unsubscribers.push(nymph.on('beforeRenameUID', async (enymph, oldName, newName) => {
+            const off = enymph.on('afterRenameUID', async (curNymph, result) => {
                 off();
+                off2();
                 if (!(await result)) {
                     return;
                 }
-                this.publish(JSON.stringify({
+                const payload = JSON.stringify({
                     action: 'publish',
                     event: 'renameUID',
                     oldName: oldName,
                     newName: newName,
-                }), configWithDefaults);
+                });
+                this.transactionPublishes.push({
+                    nymph: curNymph,
+                    payload,
+                    config: configWithDefaults,
+                });
+                await this.publishTransactionPublishes(curNymph);
             });
-        });
-        nymph.on('beforeDeleteUID', async (nymph, name) => {
-            const off = nymph.on('afterDeleteUID', async (_nymph, result) => {
+            const off2 = enymph.on('failedRenameUID', async () => {
+                off();
+                off2();
+            });
+        }));
+        unsubscribers.push(nymph.on('beforeDeleteUID', async (enymph, name) => {
+            const off = enymph.on('afterDeleteUID', async (curNymph, result) => {
                 off();
+                off2();
                 if (!(await result)) {
                     return;
                 }
-                this.publish(JSON.stringify({
+                const payload = JSON.stringify({
                     action: 'publish',
                     event: 'deleteUID',
                     name: name,
-                }), configWithDefaults);
+                });
+                this.transactionPublishes.push({
+                    nymph: curNymph,
+                    payload,
+                    config: configWithDefaults,
+                });
+                await this.publishTransactionPublishes(curNymph);
             });
-        });
+            const off2 = enymph.on('failedDeleteUID', async () => {
+                off();
+                off2();
+            });
+        }));
+        unsubscribers.push(nymph.on('afterCommitTransaction', async (enymph, _name, result) => {
+            if (result) {
+                await this.publishTransactionPublishes(enymph);
+            }
+        }));
+        unsubscribers.push(nymph.on('afterRollbackTransaction', async (enymph) => {
+            this.removeTransactionPublishes(enymph);
+        }));
+        return () => {
+            for (let unsubscribe of unsubscribers) {
+                unsubscribe();
+            }
+            this.transactionPublishes = [];
+        };
     }
     static publish(message, config) {
         for (let host of config.entries ?? []) {
-            const client = new websocket_1.client();
+            const client = new ws.client();
             client.on('connectFailed', (error) => {
                 if (config.logger) {
                     config.logger('error', new Date().toISOString(), `Publish connection failed. (${error.toString()}, ${host})`);
@@ -139,12 +268,70 @@ class PubSub {
             client.connect(host, 'nymph');
         }
     }
+    static isOrIsDescendant(parent, child) {
+        let check = child;
+        while (check) {
+            if (check === parent) {
+                return true;
+            }
+            check = check.parent;
+        }
+        return false;
+    }
+    static async publishTransactionPublishes(nymph) {
+        if (await nymph.inTransaction()) {
+            // This instance is still in a transaction, so nothing gets published yet.
+            return;
+        }
+        let notReadyTransactionPublishes = [];
+        let readyTransactionPublishes = [];
+        for (let publish of this.transactionPublishes) {
+            if (!this.isOrIsDescendant(nymph, publish.nymph) ||
+                (await publish.nymph.inTransaction())) {
+                notReadyTransactionPublishes.push(publish);
+            }
+            else {
+                readyTransactionPublishes.push(publish);
+            }
+        }
+        if (!readyTransactionPublishes.length) {
+            return;
+        }
+        this.transactionPublishes = notReadyTransactionPublishes;
+        let configMap = new Map();
+        for (let publish of readyTransactionPublishes) {
+            const arr = configMap.get(publish.config) || [];
+            arr.push(publish.payload);
+            configMap.set(publish.config, arr);
+        }
+        for (let [config, payloads] of configMap.entries()) {
+            if (payloads.length === 1) {
+                this.publish(payloads[0], config);
+            }
+            else {
+                this.publish(JSON.stringify({
+                    action: 'multiple',
+                    messages: payloads.map((payload) => JSON.parse(payload)),
+                }), config);
+            }
+        }
+    }
+    static removeTransactionPublishes(nymph) {
+        this.transactionPublishes = this.transactionPublishes.filter((publish) => {
+            if (this.isOrIsDescendant(nymph, publish.nymph)) {
+                return false;
+            }
+            return true;
+        });
+    }
+    /**
+     * Initialize Nymph PubSub.
+     *
+     * @param config The PubSub configuration.
+     */
     constructor(config, nymph, server) {
-        this.sessions = new Map();
-        this.querySubs = {};
-        this.uidSubs = {};
         this.nymph = nymph;
-        this.config = { ...conf_1.ConfigDefaults, ...config };
+        this.config = { ...defaults, ...config };
         this.server = server;
         this.server.on('request', this.handleRequest.bind(this));
     }
@@ -153,6 +340,7 @@ class PubSub {
     }
     handleRequest(request) {
         if (!this.config.originIsAllowed(request.origin)) {
+            // Make sure we only accept requests from an allowed origin
             request.reject();
             this.config.logger('log', new Date().toISOString(), 'Client from origin ' + request.origin + ' was kicked by the bouncer.');
             return;
@@ -169,28 +357,58 @@ class PubSub {
             this.onClose(connection, description);
         });
     }
+    /**
+     * Handle a message from a client.
+     */
     async onMessage(from, msg) {
         if (msg.type !== 'utf8') {
             throw new Error("This server doesn't accept binary messages.");
         }
         const data = JSON.parse(msg.utf8Data);
         if (!data.action ||
-            ['authenticate', 'subscribe', 'unsubscribe', 'publish'].indexOf(data.action) === -1) {
+            [
+                'authenticate',
+                'subscribe',
+                'unsubscribe',
+                'publish',
+                'multiple',
+            ].indexOf(data.action) === -1) {
             return;
         }
-        switch (data.action) {
-            case 'authenticate':
-                this.handleAuthentication(from, data);
-                break;
-            case 'subscribe':
-            case 'unsubscribe':
-                await this.handleSubscription(from, data);
-                break;
-            case 'publish':
-                await this.handlePublish(from, msg, data);
-                break;
-        }
+        const handleMessageData = async (data, dontRelay = false) => {
+            switch (data.action) {
+                case 'authenticate':
+                    this.handleAuthentication(from, data);
+                    break;
+                case 'subscribe':
+                case 'unsubscribe':
+                    await this.handleSubscription(from, data);
+                    break;
+                case 'publish':
+                    await this.handlePublish(from, data);
+                    if (!dontRelay) {
+                        // Relay the publish to other servers.
+                        this.relay(msg);
+                    }
+                    break;
+                case 'multiple':
+                    for (let individual of data.messages) {
+                        await handleMessageData(individual, 
+                        // These will be published with the multiple payload.
+                        individual.action === 'publish');
+                    }
+                    if (data.messages.find((msg) => msg.action === 'publish') != null) {
+                        // Relay the publish to other servers.
+                        this.relay(msg);
+                    }
+                    break;
+            }
+        };
+        await handleMessageData(data);
     }
+    /**
+     * Clean up after users who leave.
+     */
     onClose(conn, description) {
         this.config.logger('log', new Date().toISOString(), `Client skedaddled. (${description}, ${conn.remoteAddress})`);
         let mess = 0;
@@ -209,6 +427,7 @@ class PubSub {
                     }
                     else {
                         if (this.config.broadcastCounts) {
+                            // Notify clients of the subscription count.
                             for (let key of curClients.keys()) {
                                 const curData = curClients.get(key);
                                 if (curData && curData.count) {
@@ -234,6 +453,7 @@ class PubSub {
                 }
                 else {
                     if (this.config.broadcastCounts) {
+                        // Notify clients of the subscription count.
                         for (const key of curClients.keys()) {
                             const curData = curClients.get(key);
                             if (curData && curData.count) {
@@ -259,34 +479,56 @@ class PubSub {
     onError(conn, e) {
         this.config.logger('error', new Date().toISOString(), `An error occured. (${e.message}, ${conn.remoteAddress})`);
     }
+    /**
+     * Handle an authentication from a client.
+     */
     handleAuthentication(from, data) {
-        const token = data.token;
-        if (token != null) {
-            this.sessions.set(from, token);
+        // Save the user's auth token in session storage.
+        const authToken = data.authToken;
+        const switchToken = data.switchToken;
+        if (authToken != null) {
+            this.sessions.set(from, { authToken, switchToken });
         }
         else if (this.sessions.has(from)) {
             this.sessions.delete(from);
         }
     }
+    /**
+     * Handle a subscribe or unsubscribe from a client.
+     */
     async handleSubscription(from, data) {
-        if ('query' in data && data.query != null) {
-            await this.handleSubscriptionQuery(from, data);
+        try {
+            if ('query' in data && data.query != null) {
+                // Request is for a query.
+                await this.handleSubscriptionQuery(from, data);
+            }
+            else if ('uid' in data &&
+                data.uid != null &&
+                typeof data.uid == 'string') {
+                // Request is for a UID.
+                await this.handleSubscriptionUid(from, data);
+            }
         }
-        else if ('uid' in data &&
-            data.uid != null &&
-            typeof data.uid == 'string') {
-            await this.handleSubscriptionUid(from, data);
+        catch (e) {
+            if ('query' in data && data.query != null) {
+                from.sendUTF(JSON.stringify({ query: data.query, error: e.message }));
+            }
+            else if ('uid' in data && data.uid != null) {
+                from.sendUTF(JSON.stringify({ uid: data.uid, error: e.message }));
+            }
+            else {
+                from.sendUTF(JSON.stringify({ error: e.message }));
+            }
         }
     }
+    /**
+     * Handle a subscribe or unsubscribe for a query from a client.
+     */
     async handleSubscriptionQuery(from, data, qrefParent) {
-        let args;
-        let EntityClass;
-        try {
-            args = JSON.parse(data.query);
-            EntityClass = this.nymph.getEntityClass(args[0].class);
-        }
-        catch (e) {
-            return;
+        let args = JSON.parse(data.query);
+        let EntityClass = this.nymph.getEntityClass(args[0].class);
+        if (!EntityClass.restEnabled) {
+            throw new Error('Not accessible.');
         }
         const etype = EntityClass.ETYPE;
         const serialArgs = JSON.stringify(args);
@@ -294,11 +536,22 @@ class PubSub {
         const options = {
             ...clientOptions,
             class: EntityClass,
-            return: 'guid',
+            return: 'entity',
             source: 'client',
         };
+        // Find qref queries.
         const qrefQueries = this.findQRefQueries(clientOptions, ...selectors);
+        // Check that all qref queries are accessible classes.
+        for (const qrefQuery of qrefQueries) {
+            const args = qrefQuery;
+            const EntityClass = this.nymph.getEntityClass(args[0].class);
+            if (!EntityClass.restEnabled) {
+                throw new Error('Not accessible.');
+            }
+        }
         if (data.action === 'subscribe') {
+            // Client is subscribing to a query.
+            // First subscribe to qrefQueries, giving this one as a reference.
             for (const qrefQuery of qrefQueries) {
                 await this.handleSubscriptionQuery(from, {
                     action: 'subscribe',
@@ -308,23 +561,39 @@ class PubSub {
                     query: serialArgs,
                 });
             }
+            // Now subscribe to this query.
             if (!(etype in this.querySubs)) {
                 this.querySubs[etype] = {};
             }
             if (!(serialArgs in this.querySubs[etype])) {
                 this.querySubs[etype][serialArgs] = new Map();
             }
-            let token = null;
+            let authToken = null;
+            let switchToken = null;
             if (this.sessions.has(from)) {
-                token = this.sessions.get(from);
+                const session = this.sessions.get(from);
+                authToken = session?.authToken;
+                switchToken = session?.switchToken;
             }
             const nymph = this.nymph.clone();
-            if (nymph.tilmeld != null && token != null) {
-                const user = await nymph.tilmeld.extractToken(token);
-                if (user) {
-                    nymph.tilmeld.fillSession(user);
+            if (nymph.tilmeld != null && authToken != null) {
+                const user = await nymph.tilmeld.extractToken(authToken);
+                if (user && user.enabled) {
+                    if (switchToken != null) {
+                        const switchUser = await nymph.tilmeld.extractToken(switchToken);
+                        if (switchUser) {
+                            // Log in the switchUser for access controls.
+                            await nymph.tilmeld.fillSession(switchUser);
+                        }
+                    }
+                    else {
+                        // Log in the user for access controls.
+                        await nymph.tilmeld.fillSession(user);
+                    }
                 }
             }
+            let entities = [];
+            let sendEntities = false;
             const existingSub = this.querySubs[etype][serialArgs].get(from);
             if (existingSub) {
                 if (qrefParent) {
@@ -336,21 +605,42 @@ class PubSub {
                 if (data.count && !existingSub.count) {
                     existingSub.count = true;
                 }
+                sendEntities = existingSub.direct;
+                if (sendEntities) {
+                    entities = existingSub.current.length
+                        ? await nymph.getEntities({
+                            class: EntityClass,
+                            source: 'client',
+                        }, { type: '|', guid: existingSub.current })
+                        : [];
+                }
             }
             else {
+                entities = await nymph.getEntities(options, ...selectors);
                 this.querySubs[etype][serialArgs].set(from, {
-                    current: await nymph.getEntities(options, ...selectors),
+                    current: entities.map((e) => e.guid),
                     query: data.query,
                     qrefParents: qrefParent ? [qrefParent] : [],
                     direct: !qrefParent,
                     count: !!data.count,
                 });
+                sendEntities = !qrefParent;
+            }
+            if (sendEntities) {
+                // Notify the client of the current value.
+                from.sendUTF(JSON.stringify({
+                    query: data.query,
+                    set: true,
+                    data: entities,
+                }));
             }
-            if (nymph.tilmeld != null && token != null) {
+            if (nymph.tilmeld != null && authToken != null) {
+                // Clear the user that was temporarily logged in.
                 nymph.tilmeld.clearSession();
             }
             this.config.logger('log', new Date().toISOString(), `Client subscribed to a query! (${serialArgs}, ${from.remoteAddress})`);
             if (this.config.broadcastCounts) {
+                // Notify clients of the subscription count.
                 const count = this.querySubs[etype][serialArgs].size;
                 for (let key of this.querySubs[etype][serialArgs].keys()) {
                     const curData = this.querySubs[etype][serialArgs].get(key);
@@ -364,6 +654,8 @@ class PubSub {
             }
         }
         if (data.action === 'unsubscribe') {
+            // Client is unsubscribing from a query.
+            // First unsubscribe from qrefQueries.
             for (const qrefQuery of qrefQueries) {
                 await this.handleSubscriptionQuery(from, {
                     action: 'unsubscribe',
@@ -373,6 +665,7 @@ class PubSub {
                     query: serialArgs,
                 });
             }
+            // Now unsubscribe from this query.
             if (!(etype in this.querySubs)) {
                 return;
             }
@@ -398,6 +691,7 @@ class PubSub {
             this.config.logger('log', new Date().toISOString(), `Client unsubscribed from a query! (${serialArgs}, ${from.remoteAddress})`);
             const count = this.querySubs[etype][serialArgs].size;
             if (count === 0) {
+                // No more subscribed clients.
                 delete this.querySubs[etype][serialArgs];
                 if (Object.keys(this.querySubs[etype]).length === 0) {
                     delete this.querySubs[etype];
@@ -405,6 +699,7 @@ class PubSub {
                 return;
             }
             if (this.config.broadcastCounts) {
+                // Notify clients of the subscription count.
                 for (let key of this.querySubs[etype][serialArgs].keys()) {
                     const curData = this.querySubs[etype][serialArgs].get(key);
                     if (curData && curData.count) {
@@ -417,16 +712,55 @@ class PubSub {
             }
         }
     }
+    /**
+     * Handle a subscribe or unsubscribe for a UID from a client.
+     */
     async handleSubscriptionUid(from, data) {
         if (data.action === 'subscribe') {
+            // Client is subscribing to a UID.
             if (!(data.uid in this.uidSubs)) {
                 this.uidSubs[data.uid] = new Map();
             }
             this.uidSubs[data['uid']].set(from, {
                 count: !!data.count,
             });
+            let authToken = null;
+            let switchToken = null;
+            if (this.sessions.has(from)) {
+                const session = this.sessions.get(from);
+                authToken = session?.authToken;
+                switchToken = session?.switchToken;
+            }
+            const nymph = this.nymph.clone();
+            if (nymph.tilmeld != null && authToken != null) {
+                const user = await nymph.tilmeld.extractToken(authToken);
+                if (user && user.enabled) {
+                    if (switchToken != null) {
+                        const switchUser = await nymph.tilmeld.extractToken(switchToken);
+                        if (switchUser) {
+                            // Log in the switchUser for access controls.
+                            await nymph.tilmeld.fillSession(switchUser);
+                        }
+                    }
+                    else {
+                        // Log in the user for access controls.
+                        await nymph.tilmeld.fillSession(user);
+                    }
+                }
+            }
+            // Notify the client of the current value.
+            from.sendUTF(JSON.stringify({
+                uid: data.uid,
+                set: true,
+                data: await this.nymph.getUID(data.uid),
+            }));
+            if (nymph.tilmeld != null && authToken != null) {
+                // Clear the user that was temporarily logged in.
+                nymph.tilmeld.clearSession();
+            }
             this.config.logger('log', new Date().toISOString(), `Client subscribed to a UID! (${data.uid}, ${from.remoteAddress})`);
             if (this.config.broadcastCounts) {
+                // Notify clients of the subscription count.
                 const count = this.uidSubs[data.uid].size;
                 for (let key of this.uidSubs[data.uid].keys()) {
                     const curData = this.uidSubs[data.uid].get(key);
@@ -440,6 +774,7 @@ class PubSub {
             }
         }
         if (data.action === 'unsubscribe') {
+            // Client is unsubscribing from a UID.
             if (!(data.uid in this.uidSubs)) {
                 return;
             }
@@ -450,10 +785,12 @@ class PubSub {
             this.config.logger('log', new Date().toISOString(), `Client unsubscribed from a UID! (${data.uid}, ${from.remoteAddress})`);
             const count = this.uidSubs[data.uid].size;
             if (count === 0) {
+                // No more subscribed clients.
                 delete this.uidSubs[data.uid];
                 return;
             }
             if (this.config.broadcastCounts) {
+                // Notify clients of the subscription count.
                 for (let key of this.uidSubs[data.uid].keys()) {
                     const curData = this.uidSubs[data.uid].get(key);
                     if (curData && curData.count) {
@@ -466,7 +803,10 @@ class PubSub {
             }
         }
     }
-    async handlePublish(from, msg, data) {
+    /**
+     * Handle a publish from a client.
+     */
+    async handlePublish(from, data) {
         if ('guid' in data &&
             typeof data.guid === 'string' &&
             data.guid.match(/^[0-9a-f]{24}$/) &&
@@ -474,8 +814,8 @@ class PubSub {
                 ((data.event === 'create' || data.event === 'update') &&
                     'entity' in data &&
                     data.entity != null))) {
+            // Publish is an entity.
             await this.handlePublishEntity(from, data);
-            this.relay(msg);
         }
         if ((('name' in data && typeof data.name === 'string') ||
             ('oldName' in data &&
@@ -483,10 +823,13 @@ class PubSub {
                 'newName' in data &&
                 typeof data.newName === 'string')) &&
             ['newUID', 'setUID', 'renameUID', 'deleteUID'].indexOf(data.event) !== -1) {
+            // Publish is a UID.
             await this.handlePublishUid(from, data);
-            this.relay(msg);
         }
     }
+    /**
+     * Handle an entity publish from a client.
+     */
     async handlePublishEntity(from, data) {
         this.config.logger('log', new Date().toISOString(), `Received an entity publish! (${data.guid}, ${data.event}, ${from.remoteAddress})`);
         const etype = data.etype;
@@ -497,6 +840,7 @@ class PubSub {
             const curClients = this.querySubs[etype][curQuery];
             const updatedClients = new Set();
             if (data.event === 'delete' || data.event === 'update') {
+                // Check if it is in any client's currents.
                 try {
                     for (const curClient of curClients.keys()) {
                         const curData = curClients.get(curClient);
@@ -504,7 +848,7 @@ class PubSub {
                             continue;
                         }
                         if (curData.current.indexOf(data.guid) !== -1) {
-                            await this.updateClient(curClient, curData, data);
+                            this.addOutgoingClientMessage(curClient, curData, data);
                             updatedClients.add(curClient);
                         }
                     }
@@ -514,6 +858,7 @@ class PubSub {
                 }
             }
             if ((data.event === 'create' || data.event === 'update') && data.entity) {
+                // Check if it matches the query.
                 try {
                     const [clientOptions, ...selectors] = JSON.parse(curQuery);
                     const qrefQueries = this.findQRefQueries(clientOptions, ...selectors);
@@ -528,22 +873,27 @@ class PubSub {
                     const DataEntityClass = this.nymph.getEntityClass(data.entity.class);
                     if (EntityClass.ETYPE === DataEntityClass.ETYPE &&
                         (qrefQueries.length ||
-                            this.nymph.driver.checkData(entityData, entitySData, selectors, data.guid, data.entity?.tags ?? []))) {
+                            this.nymph.driver.checkData(EntityClass.ETYPE, entityData, entitySData, selectors, data.guid, data.entity?.tags ?? []))) {
+                        // It either matches the query, or there are qref queries.
                         for (let curClient of curClients.keys()) {
                             if (updatedClients.has(curClient)) {
+                                // The user was already notified. (Of an update.)
                                 continue;
                             }
                             const curData = curClients.get(curClient);
                             if (!curData) {
                                 continue;
                             }
+                            // If there are qref queries, we need to dive into the user's
+                            // current data and translate them before running checkData.
                             if (qrefQueries.length) {
                                 const translatedSelectors = this.translateQRefSelectors(curClient, selectors);
-                                if (!this.nymph.driver.checkData(entityData, entitySData, translatedSelectors, data.guid, data.entity?.tags ?? [])) {
+                                if (!this.nymph.driver.checkData(EntityClass.ETYPE, entityData, entitySData, translatedSelectors, data.guid, data.entity?.tags ?? [])) {
+                                    // The query doesn't match when the qref queries are filled.
                                     continue;
                                 }
                             }
-                            await this.updateClient(curClient, curData, data);
+                            this.addOutgoingClientMessage(curClient, curData, data);
                         }
                     }
                 }
@@ -553,85 +903,142 @@ class PubSub {
             }
         }
     }
-    async updateClient(curClient, curData, data) {
-        let current;
-        let token;
-        const nymph = this.nymph.clone();
-        try {
-            const [clientOptions, ...clientSelectors] = JSON.parse(curData.query);
-            const options = {
-                ...clientOptions,
-                class: nymph.getEntityClass(clientOptions.class),
-                return: 'entity',
-                source: 'client',
-                skipAc: false,
-            };
-            const selectors = (0, nymph_1.classNamesToEntityConstructors)(nymph, clientSelectors);
-            if (this.sessions.has(curClient)) {
-                token = this.sessions.get(curClient);
-            }
-            if (nymph.tilmeld != null && token != null) {
-                const user = await nymph.tilmeld.extractToken(token);
-                if (user) {
-                    nymph.tilmeld.fillSession(user);
-                }
-            }
-            current = await nymph.getEntities(options, ...selectors);
-        }
-        catch (e) {
-            this.config.logger('error', new Date().toISOString(), `Error updating client! (${e?.message}, ${curClient.remoteAddress})`);
-            return;
+    addOutgoingClientMessage(curClient, curData, data) {
+        const arr = this.outgoingClientMessages.get(curClient) || [];
+        arr.push({ subscription: curData, publish: data });
+        this.outgoingClientMessages.set(curClient, arr);
+        if (this.outgoingClientMessagesTimeout) {
+            clearImmediate(this.outgoingClientMessagesTimeout);
         }
-        const entityMap = Object.fromEntries(current.map((entity) => [entity.guid, entity]));
-        const currentGuids = current.map((entity) => entity.guid ?? '');
-        const removed = (0, lodash_1.difference)(curData.current, currentGuids);
-        const added = (0, lodash_1.difference)(currentGuids, curData.current);
-        if (curData.direct) {
-            for (let guid of removed) {
-                this.config.logger('log', new Date().toISOString(), `Notifying client of removal! (${curClient.remoteAddress})`);
-                curClient.sendUTF(JSON.stringify({
-                    query: curData.query,
-                    removed: guid,
-                }));
+        this.outgoingClientMessagesTimeout = setImmediate(async () => {
+            await this.updateClients();
+        });
+    }
+    async updateClients() {
+        const outgoingClientMessages = [...this.outgoingClientMessages.entries()];
+        this.outgoingClientMessages.clear();
+        for (let [curClient, entries] of outgoingClientMessages) {
+            const queryMap = {};
+            for (let entry of entries) {
+                const arr = queryMap[entry.subscription.query] || [];
+                arr.push(entry);
+                queryMap[entry.subscription.query] = arr;
             }
-            for (let guid of added) {
-                const entity = entityMap[guid];
-                this.config.logger('log', new Date().toISOString(), `Notifying client of new match! (${curClient.remoteAddress})`);
-                if (typeof entity.updateDataProtection === 'function') {
-                    entity.updateDataProtection();
+            for (let [query, queryEntries] of Object.entries(queryMap)) {
+                // Update currents list.
+                let current;
+                let authToken;
+                let switchToken;
+                const nymph = this.nymph.clone();
+                try {
+                    const [clientOptions, ...clientSelectors] = JSON.parse(query);
+                    const options = {
+                        ...clientOptions,
+                        class: nymph.getEntityClass(clientOptions.class),
+                        return: 'entity',
+                        source: 'client',
+                        skipAc: false,
+                    };
+                    const selectors = classNamesToEntityConstructors(nymph, clientSelectors, true);
+                    if (this.sessions.has(curClient)) {
+                        const session = this.sessions.get(curClient);
+                        authToken = session?.authToken;
+                        switchToken = session?.switchToken;
+                    }
+                    if (nymph.tilmeld != null && authToken != null) {
+                        const user = await nymph.tilmeld.extractToken(authToken);
+                        if (user && user.enabled) {
+                            if (switchToken != null) {
+                                const switchUser = await nymph.tilmeld.extractToken(switchToken);
+                                if (switchUser) {
+                                    // Log in the switchUser for access controls.
+                                    await nymph.tilmeld.fillSession(switchUser);
+                                }
+                            }
+                            else {
+                                // Log in the user for access controls.
+                                await nymph.tilmeld.fillSession(user);
+                            }
+                        }
+                    }
+                    current = await nymph.getEntities(options, ...selectors);
                 }
-                curClient.sendUTF(JSON.stringify({
-                    query: curData.query,
-                    added: guid,
-                    data: entity,
-                }));
-            }
-            if (data.event === 'update' && data.guid in entityMap) {
-                const entity = entityMap[data.guid];
-                this.config.logger('log', new Date().toISOString(), `Notifying client of update! (${curClient.remoteAddress})`);
-                if (typeof entity.updateDataProtection === 'function') {
-                    entity.updateDataProtection();
+                catch (e) {
+                    this.config.logger('error', new Date().toISOString(), `Error updating client! (${e?.message}, ${curClient.remoteAddress})`);
+                    return;
                 }
-                curClient.sendUTF(JSON.stringify({
-                    query: curData.query,
-                    updated: data.guid,
-                    data: entity,
-                }));
-            }
-        }
-        curData.current = currentGuids;
-        if (nymph.tilmeld != null && token != null) {
-            nymph.tilmeld.clearSession();
-        }
-        if ((removed.length || added.length) && curData.qrefParents.length) {
-            for (const qrefParent of curData.qrefParents) {
-                const subData = this.querySubs[qrefParent.etype][qrefParent.query].get(curClient);
-                if (subData) {
-                    this.updateClient(curClient, subData, data);
+                const entityMap = Object.fromEntries(current.map((entity) => [entity.guid, entity]));
+                // These are the current GUIDs for this set of subscriptions/publishes.
+                const currentGuids = current.map((entity) => entity.guid ?? '');
+                const clientUpdates = [];
+                for (let { subscription, publish } of queryEntries) {
+                    const removed = difference(subscription.current, currentGuids);
+                    const added = difference(currentGuids, subscription.current);
+                    if (subscription.direct) {
+                        for (let guid of removed) {
+                            // Notify subscriber.
+                            this.config.logger('log', new Date().toISOString(), `Notifying client of removal! (${curClient.remoteAddress})`);
+                            clientUpdates.push({
+                                query: subscription.query,
+                                removed: guid,
+                            });
+                        }
+                        for (let guid of added) {
+                            const entity = entityMap[guid];
+                            // Notify client.
+                            this.config.logger('log', new Date().toISOString(), `Notifying client of new match! (${curClient.remoteAddress})`);
+                            if (typeof entity.updateDataProtection === 'function') {
+                                entity.updateDataProtection();
+                            }
+                            clientUpdates.push({
+                                query: subscription.query,
+                                added: guid,
+                                data: entity.toJSON(),
+                            });
+                        }
+                        if (publish.event === 'update' && publish.guid in entityMap) {
+                            const entity = entityMap[publish.guid];
+                            // Notify subscriber.
+                            this.config.logger('log', new Date().toISOString(), `Notifying client of update! (${curClient.remoteAddress})`);
+                            if (typeof entity.updateDataProtection === 'function') {
+                                entity.updateDataProtection();
+                            }
+                            clientUpdates.push({
+                                query: subscription.query,
+                                updated: publish.guid,
+                                data: entity.toJSON(),
+                            });
+                        }
+                    }
+                    // Update subscription.
+                    subscription.current = currentGuids;
+                    if (nymph.tilmeld != null && authToken != null) {
+                        // Clear the user that was temporarily logged in.
+                        nymph.tilmeld.clearSession();
+                    }
+                    if ((removed.length || added.length) &&
+                        subscription.qrefParents.length) {
+                        // All qref parents need to be rerun.
+                        for (const qrefParent of subscription.qrefParents) {
+                            const subData = this.querySubs[qrefParent.etype][qrefParent.query].get(curClient);
+                            if (subData) {
+                                this.addOutgoingClientMessage(curClient, subData, publish);
+                            }
+                        }
+                    }
+                }
+                if (clientUpdates.length === 1) {
+                    curClient.sendUTF(JSON.stringify(clientUpdates[0]));
+                }
+                else if (clientUpdates.length > 1) {
+                    curClient.sendUTF(JSON.stringify({ query, multiple: true, messages: clientUpdates }));
                 }
             }
         }
     }
+    /**
+     * Handle a UID publish from a client.
+     */
     async handlePublishUid(from, data) {
         this.config.logger('log', new Date().toISOString(), `Received a UID publish! (${'name' in data ? data.name : `${data.oldName} => ${data.newName}`}, ${data.event}, ${from.remoteAddress})`);
         const names = [data.name, data.oldName].filter((name) => name != null);
@@ -668,13 +1075,16 @@ class PubSub {
             }
         }
     }
+    /**
+     * Relay publish data to other servers.
+     */
     relay(message) {
         if (message.type !== 'utf8') {
             this.config.logger('error', new Date().toISOString(), `Can't relay non UTF8 message.`);
             return;
         }
         for (let host of this.config.relays) {
-            const client = new websocket_1.client();
+            const client = new ws.client();
             client.on('connectFailed', (error) => {
                 this.config.logger('error', new Date().toISOString(), `Relay connection failed. (${error.toString()}, ${host})`);
             });
@@ -706,8 +1116,8 @@ class PubSub {
                     const tmpArr = (Array.isArray((value ?? [])[0])
                         ? value
                         : [value]);
-                    for (let i = 0; i < tmpArr.length; i++) {
-                        qrefQueries.push(tmpArr[i][1]);
+                    for (let [_name, qRefQuery] of tmpArr) {
+                        qrefQueries.push(qRefQuery);
                     }
                 }
                 else if (key === 'selector' || key === '!selector') {
@@ -718,6 +1128,10 @@ class PubSub {
         }
         return qrefQueries;
     }
+    /**
+     * This translates qref selectors into ref selectors using the "current" GUID
+     * list in the existing subscriptions.
+     */
     translateQRefSelectors(client, selectors) {
         const newSelectors = [];
         for (const curSelector of selectors) {
@@ -740,27 +1154,55 @@ class PubSub {
                         const name = tmpArr[i][0];
                         const [qrefOptions, ...qrefSelectors] = tmpArr[i][1];
                         const query = JSON.stringify(tmpArr[i][1]);
-                        const QrefEntityClass = typeof qrefOptions.class === 'string'
+                        const QrefEntityClass = qrefOptions.class
                             ? this.nymph.getEntityClass(qrefOptions.class)
-                            : qrefOptions.class ?? this.nymph.getEntityClass('Entity');
+                            : this.nymph.getEntityClass('Entity');
                         const data = this.querySubs[QrefEntityClass.ETYPE][query].get(client);
                         if (data) {
                             const guids = data.current;
-                            let newValue;
-                            const oldValue = newSelector[newKey];
-                            if (!oldValue) {
-                                newValue = [];
-                            }
-                            else if (oldValue.length && !Array.isArray(oldValue[0])) {
-                                newValue = [oldValue];
+                            if (newKey === '!ref') {
+                                // Insert the qref results as a not ref clause.
+                                let newValue;
+                                const oldValue = newSelector[newKey];
+                                if (oldValue == null ||
+                                    (Array.isArray(oldValue) && !oldValue.length)) {
+                                    newValue = [];
+                                }
+                                else if (Array.isArray(oldValue) &&
+                                    !Array.isArray(oldValue[0])) {
+                                    newValue = [oldValue];
+                                }
+                                else {
+                                    newValue = oldValue;
+                                }
+                                newValue.push(...guids.map((guid) => [name, guid]));
+                                newSelector[newKey] = newValue;
                             }
                             else {
-                                newValue = oldValue;
+                                // Insert the qref results as an "or" selector clause with a ref
+                                // selector.
+                                let newValue;
+                                const oldValue = newSelector['selector'];
+                                delete newSelector[key];
+                                if (oldValue == null ||
+                                    (Array.isArray(oldValue) && !oldValue.length)) {
+                                    newValue = [];
+                                }
+                                else if (!Array.isArray(oldValue)) {
+                                    newValue = [oldValue];
+                                }
+                                else {
+                                    newValue = oldValue;
+                                }
+                                newValue.push({
+                                    type: '|',
+                                    ref: guids.map((guid) => [name, guid]),
+                                });
+                                newSelector['selector'] = newValue;
                             }
-                            newValue.push(...guids.map((guid) => [name, guid]));
-                            newSelector[newKey] = newValue;
                         }
                         else {
+                            // Can't translate, so put the original back in.
                             if (!newSelector[key]) {
                                 newSelector[key] = [];
                             }
@@ -785,6 +1227,7 @@ class PubSub {
                     newSelector[key].push(...tmpArr);
                 }
                 else {
+                    // @ts-ignore: ts doesn't know what value is here.
                     newSelector[key] = value;
                 }
             }
@@ -793,5 +1236,4 @@ class PubSub {
         return newSelectors;
     }
 }
-exports.default = PubSub;
 //# sourceMappingURL=PubSub.js.map