@nymphjs/pubsub 1.0.0-beta.11 → 1.0.0-beta.111

package/dist/PubSub.js

@@ -1,125 +1,252 @@
-"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@gmail.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 = {};
+    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 +266,48 @@ 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;
+        }
+        this.transactionPublishes = (await Promise.all(this.transactionPublishes.map(async (publish) => {
+            // Check that this instance is a parent and the instance is not in a
+            // transaction.
+            if (!this.isOrIsDescendant(nymph, publish.nymph) ||
+                (await publish.nymph.inTransaction())) {
+                return publish;
+            }
+            this.publish(publish.payload, publish.config);
+            return null;
+        }))).filter((value) => value != null);
+    }
+    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 +316,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,6 +333,9 @@ 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.");
@@ -191,6 +358,9 @@ class PubSub {
                 break;
         }
     }
+    /**
+     * 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 +379,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 +405,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 +431,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 +488,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 +513,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 +557,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 +606,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 +617,7 @@ class PubSub {
                     query: serialArgs,
                 });
             }
+            // Now unsubscribe from this query.
             if (!(etype in this.querySubs)) {
                 return;
             }
@@ -398,6 +643,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 +651,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 +664,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 +726,7 @@ class PubSub {
             }
         }
         if (data.action === 'unsubscribe') {
+            // Client is unsubscribing from a UID.
             if (!(data.uid in this.uidSubs)) {
                 return;
             }
@@ -450,10 +737,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,6 +755,9 @@ class PubSub {
             }
         }
     }
+    /**
+     * Handle a publish from a client.
+     */
     async handlePublish(from, msg, data) {
         if ('guid' in data &&
             typeof data.guid === 'string' &&
@@ -474,7 +766,9 @@ class PubSub {
                 ((data.event === 'create' || data.event === 'update') &&
                     'entity' in data &&
                     data.entity != null))) {
+            // Publish is an entity.
             await this.handlePublishEntity(from, data);
+            // Relay the publish to other servers.
             this.relay(msg);
         }
         if ((('name' in data && typeof data.name === 'string') ||
@@ -483,10 +777,15 @@ 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);
+            // Relay the publish to other servers.
             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 +796,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);
@@ -514,6 +814,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,18 +829,23 @@ 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;
                                 }
                             }
@@ -554,8 +860,10 @@ class PubSub {
         }
     }
     async updateClient(curClient, curData, data) {
+        // Update currents list.
         let current;
-        let token;
+        let authToken;
+        let switchToken;
         const nymph = this.nymph.clone();
         try {
             const [clientOptions, ...clientSelectors] = JSON.parse(curData.query);
@@ -566,14 +874,26 @@ class PubSub {
                 source: 'client',
                 skipAc: false,
             };
-            const selectors = (0, nymph_1.classNamesToEntityConstructors)(nymph, clientSelectors);
+            const selectors = classNamesToEntityConstructors(nymph, clientSelectors, true);
             if (this.sessions.has(curClient)) {
-                token = this.sessions.get(curClient);
+                const session = this.sessions.get(curClient);
+                authToken = session?.authToken;
+                switchToken = session?.switchToken;
             }
-            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);
+                    }
                 }
             }
             current = await nymph.getEntities(options, ...selectors);
@@ -584,10 +904,11 @@ class PubSub {
         }
         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);
+        const removed = difference(curData.current, currentGuids);
+        const added = difference(currentGuids, curData.current);
         if (curData.direct) {
             for (let guid of removed) {
+                // Notify subscriber.
                 this.config.logger('log', new Date().toISOString(), `Notifying client of removal! (${curClient.remoteAddress})`);
                 curClient.sendUTF(JSON.stringify({
                     query: curData.query,
@@ -596,6 +917,7 @@ class PubSub {
             }
             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();
@@ -608,6 +930,7 @@ class PubSub {
             }
             if (data.event === 'update' && data.guid in entityMap) {
                 const entity = entityMap[data.guid];
+                // Notify subscriber.
                 this.config.logger('log', new Date().toISOString(), `Notifying client of update! (${curClient.remoteAddress})`);
                 if (typeof entity.updateDataProtection === 'function') {
                     entity.updateDataProtection();
@@ -619,11 +942,14 @@ class PubSub {
                 }));
             }
         }
+        // Update curData.
         curData.current = currentGuids;
-        if (nymph.tilmeld != null && token != null) {
+        if (nymph.tilmeld != null && authToken != null) {
+            // Clear the user that was temporarily logged in.
             nymph.tilmeld.clearSession();
         }
         if ((removed.length || added.length) && curData.qrefParents.length) {
+            // All qref parents need to be rerun.
             for (const qrefParent of curData.qrefParents) {
                 const subData = this.querySubs[qrefParent.etype][qrefParent.query].get(curClient);
                 if (subData) {
@@ -632,6 +958,9 @@ class PubSub {
             }
         }
     }
+    /**
+     * 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 +997,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})`);
             });
@@ -718,6 +1050,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 +1076,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 +1149,7 @@ class PubSub {
                     newSelector[key].push(...tmpArr);
                 }
                 else {
+                    // @ts-ignore: ts doesn't know what value is here.
                     newSelector[key] = value;
                 }
             }
@@ -793,5 +1158,4 @@ class PubSub {
         return newSelectors;
     }
 }
-exports.default = PubSub;
 //# sourceMappingURL=PubSub.js.map