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

package/src/PubSub.ts

@@ -7,16 +7,10 @@ import {
   SerializedEntityData,
   classNamesToEntityConstructors,
 } from '@nymphjs/nymph';
-import {
-  request,
-  client as WebSocketClient,
-  server as WebSocketServer,
-  connection,
-  Message,
-} from 'websocket';
-import { difference } from 'lodash';
-
-import { Config, ConfigDefaults as defaults } from './conf';
+import ws from 'websocket';
+import { difference } from 'lodash-es';
+
+import { Config, ConfigDefaults as defaults } from './conf/index.js';
 import type {
   QuerySubscriptionData,
   AuthenticateMessageData,
@@ -28,7 +22,7 @@ import type {
   PublishMessageData,
   MessageData,
   MessageOptions,
-} from './PubSub.types';
+} from './PubSub.types.js';
 
 /**
  * A publish/subscribe server for Nymph.
@@ -53,207 +47,289 @@ export default class PubSub {
   /**
    * The WebSocket server.
    */
-  public server: WebSocketServer;
+  public server: ws.server;
 
-  private sessions = new Map<connection, string>();
+  private sessions = new Map<
+    ws.connection,
+    { authToken: string; switchToken?: string }
+  >();
   protected querySubs: {
     [etype: string]: {
-      [query: string]: Map<connection, QuerySubscriptionData>;
+      [query: string]: Map<ws.connection, QuerySubscriptionData>;
     };
   } = {};
   protected uidSubs: {
-    [uidName: string]: Map<connection, { count: boolean }>;
+    [uidName: string]: Map<ws.connection, { count: boolean }>;
   } = {};
+  protected static transactionPublishes: {
+    nymph: Nymph;
+    payload: string;
+    config: Config;
+  }[] = [];
 
   public static initPublisher(config: Partial<Config>, nymph: Nymph) {
     const configWithDefaults: Config = { ...defaults, ...config };
+    const unsubscribers: (() => boolean)[] = [];
 
-    nymph.on(
-      'beforeSaveEntity',
-      async (nymph: Nymph, entity: EntityInterface) => {
+    unsubscribers.push(
+      nymph.on('beforeSaveEntity', async (enymph, entity) => {
         const guid = entity.guid;
-        const etype = (entity.constructor as EntityConstructor).ETYPE;
+        const EntityClass = entity.constructor as EntityConstructor;
+        const etype = EntityClass.ETYPE;
 
-        const off = nymph.on(
-          'afterSaveEntity',
-          async (_nymph: Nymph, result: Promise<boolean>) => {
-            off();
-            if (!(await result)) {
-              return;
-            }
-            this.publish(
-              JSON.stringify({
-                action: 'publish',
-                event: guid == null ? 'create' : 'update',
-                guid: entity.guid,
-                entity: entity.toJSON(),
-                etype: etype,
-              }),
-              configWithDefaults
-            );
+        if (!EntityClass.pubSubEnabled) {
+          return;
+        }
+
+        const off = enymph.on('afterSaveEntity', async (curNymph, result) => {
+          off();
+          off2();
+          if (!(await result)) {
+            return;
           }
-        );
-      }
+          const payload = JSON.stringify({
+            action: 'publish',
+            event: guid == null ? 'create' : 'update',
+            guid: entity.guid,
+            entity: entity.toJSON(),
+            etype: etype,
+          });
+          this.transactionPublishes.push({
+            nymph: curNymph,
+            payload,
+            config: configWithDefaults,
+          });
+          await this.publishTransactionPublishes(curNymph);
+        });
+        const off2 = enymph.on('failedSaveEntity', async () => {
+          off();
+          off2();
+        });
+      }),
     );
 
-    nymph.on(
-      'beforeDeleteEntity',
-      async (nymph: Nymph, entity: EntityInterface) => {
+    unsubscribers.push(
+      nymph.on('beforeDeleteEntity', async (enymph, entity) => {
         const guid = entity.guid;
-        const etype = (entity.constructor as EntityConstructor).ETYPE;
+        const EntityClass = entity.constructor as EntityConstructor;
+        const etype = EntityClass.ETYPE;
 
-        const off = nymph.on(
-          'afterDeleteEntity',
-          async (_nymph: Nymph, result: Promise<boolean>) => {
-            off();
-            if (!(await result)) {
-              return;
-            }
-            this.publish(
-              JSON.stringify({
-                action: 'publish',
-                event: 'delete',
-                guid: guid,
-                etype: etype,
-              }),
-              configWithDefaults
-            );
+        if (!EntityClass.pubSubEnabled) {
+          return;
+        }
+
+        const off = enymph.on('afterDeleteEntity', async (curNymph, result) => {
+          off();
+          off2();
+          if (!(await result)) {
+            return;
           }
-        );
-      }
+          const payload = JSON.stringify({
+            action: 'publish',
+            event: 'delete',
+            guid: guid,
+            etype: etype,
+          });
+          this.transactionPublishes.push({
+            nymph: curNymph,
+            payload,
+            config: configWithDefaults,
+          });
+          await this.publishTransactionPublishes(curNymph);
+        });
+        const off2 = enymph.on('failedDeleteEntity', async () => {
+          off();
+          off2();
+        });
+      }),
     );
 
-    nymph.on(
-      'beforeDeleteEntityByID',
-      async (nymph: Nymph, guid: string, className?: string) => {
+    unsubscribers.push(
+      nymph.on('beforeDeleteEntityByID', async (enymph, guid, className) => {
         try {
-          const etype = nymph.getEntityClass(className ?? 'Entity').ETYPE;
+          const EntityClass = enymph.getEntityClass(className ?? 'Entity');
+          const etype = EntityClass.ETYPE;
 
-          const off = nymph.on(
+          if (!EntityClass.pubSubEnabled) {
+            return;
+          }
+
+          const off = enymph.on(
             'afterDeleteEntityByID',
-            async (_nymph: Nymph, result: Promise<boolean>) => {
+            async (curNymph, result) => {
               off();
+              off2();
               if (!(await result)) {
                 return;
               }
-              this.publish(
-                JSON.stringify({
-                  action: 'publish',
-                  event: 'delete',
-                  guid: guid,
-                  etype: etype,
-                }),
-                configWithDefaults
-              );
-            }
+              const payload = JSON.stringify({
+                action: 'publish',
+                event: 'delete',
+                guid: guid,
+                etype: etype,
+              });
+              this.transactionPublishes.push({
+                nymph: curNymph,
+                payload,
+                config: configWithDefaults,
+              });
+              await this.publishTransactionPublishes(curNymph);
+            },
           );
+          const off2 = enymph.on('failedDeleteEntityByID', async () => {
+            off();
+            off2();
+          });
         } catch (e: any) {
           return;
         }
-      }
+      }),
     );
 
-    nymph.on('beforeNewUID', async (nymph: Nymph, name: string) => {
-      const off = nymph.on(
-        'afterNewUID',
-        async (_nymph: Nymph, result: Promise<number | null>) => {
+    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({
-              action: 'publish',
-              event: 'newUID',
-              name: name,
-              value: value,
-            }),
-            configWithDefaults
-          );
-        }
-      );
-    });
+          const payload = JSON.stringify({
+            action: 'publish',
+            event: 'newUID',
+            name: name,
+            value: value,
+          });
+          this.transactionPublishes.push({
+            nymph: curNymph,
+            payload,
+            config: configWithDefaults,
+          });
+          await this.publishTransactionPublishes(curNymph);
+        });
+        const off2 = enymph.on('failedNewUID', async () => {
+          off();
+          off2();
+        });
+      }),
+    );
 
-    nymph.on(
-      'beforeSetUID',
-      async (nymph: Nymph, name: string, value: number) => {
-        const off = nymph.on(
-          'afterSetUID',
-          async (_nymph: Nymph, result: Promise<boolean>) => {
-            off();
-            if (!(await result)) {
-              return;
-            }
-            this.publish(
-              JSON.stringify({
-                action: 'publish',
-                event: 'setUID',
-                name: name,
-                value: value,
-              }),
-              configWithDefaults
-            );
+    unsubscribers.push(
+      nymph.on('beforeSetUID', async (enymph, name, value) => {
+        const off = enymph.on('afterSetUID', async (curNymph, result) => {
+          off();
+          off2();
+          if (!(await result)) {
+            return;
           }
-        );
-      }
+          const payload = JSON.stringify({
+            action: 'publish',
+            event: 'setUID',
+            name: name,
+            value: value,
+          });
+          this.transactionPublishes.push({
+            nymph: curNymph,
+            payload,
+            config: configWithDefaults,
+          });
+          await this.publishTransactionPublishes(curNymph);
+        });
+        const off2 = enymph.on('failedSetUID', async () => {
+          off();
+          off2();
+        });
+      }),
     );
 
-    nymph.on(
-      'beforeRenameUID',
-      async (nymph: Nymph, oldName: string, newName: string) => {
-        const off = nymph.on(
-          'afterRenameUID',
-          async (_nymph: Nymph, result: Promise<boolean>) => {
-            off();
-            if (!(await result)) {
-              return;
-            }
-            this.publish(
-              JSON.stringify({
-                action: 'publish',
-                event: 'renameUID',
-                oldName: oldName,
-                newName: newName,
-              }),
-              configWithDefaults
-            );
+    unsubscribers.push(
+      nymph.on('beforeRenameUID', async (enymph, oldName, newName) => {
+        const off = enymph.on('afterRenameUID', async (curNymph, result) => {
+          off();
+          off2();
+          if (!(await result)) {
+            return;
           }
-        );
-      }
+          const payload = JSON.stringify({
+            action: 'publish',
+            event: 'renameUID',
+            oldName: oldName,
+            newName: newName,
+          });
+          this.transactionPublishes.push({
+            nymph: curNymph,
+            payload,
+            config: configWithDefaults,
+          });
+          await this.publishTransactionPublishes(curNymph);
+        });
+        const off2 = enymph.on('failedRenameUID', async () => {
+          off();
+          off2();
+        });
+      }),
     );
 
-    nymph.on('beforeDeleteUID', async (nymph: Nymph, name: string) => {
-      const off = nymph.on(
-        'afterDeleteUID',
-        async (_nymph: Nymph, result: Promise<boolean>) => {
+    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({
-              action: 'publish',
-              event: 'deleteUID',
-              name: name,
-            }),
-            configWithDefaults
-          );
+          const payload = JSON.stringify({
+            action: 'publish',
+            event: 'deleteUID',
+            name: name,
+          });
+          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 = [];
+    };
   }
 
   private static publish(message: string, config: Config) {
     for (let host of config.entries ?? []) {
-      const client = new WebSocketClient();
+      const client = new ws.client();
 
       client.on('connectFailed', (error) => {
         if (config.logger) {
           config.logger(
             'error',
             new Date().toISOString(),
-            `Publish connection failed. (${error.toString()}, ${host})`
+            `Publish connection failed. (${error.toString()}, ${host})`,
           );
         }
       });
@@ -264,7 +340,7 @@ export default class PubSub {
             config.logger(
               'error',
               new Date().toISOString(),
-              `Publish connect error. (${error.toString()}, ${host})`
+              `Publish connect error. (${error.toString()}, ${host})`,
             );
           }
         });
@@ -280,16 +356,60 @@ export default class PubSub {
     }
   }
 
+  private static isOrIsDescendant(parent: Nymph, child: Nymph) {
+    let check: Nymph | null = child;
+    while (check) {
+      if (check === parent) {
+        return true;
+      }
+      check = check.parent;
+    }
+    return false;
+  }
+
+  private static async publishTransactionPublishes(nymph: 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) as {
+      nymph: Nymph;
+      payload: string;
+      config: Config;
+    }[];
+  }
+
+  private static removeTransactionPublishes(nymph: 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.
    */
-  public constructor(
-    config: Partial<Config>,
-    nymph: Nymph,
-    server: WebSocketServer
-  ) {
+  public constructor(config: Partial<Config>, nymph: Nymph, server: ws.server) {
     this.nymph = nymph;
     this.config = { ...defaults, ...config };
     this.server = server;
@@ -301,14 +421,14 @@ export default class PubSub {
     this.server.shutDown();
   }
 
-  public handleRequest(request: request) {
+  public handleRequest(request: ws.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.'
+        'Client from origin ' + request.origin + ' was kicked by the bouncer.',
       );
       return;
     }
@@ -317,7 +437,7 @@ export default class PubSub {
     this.config.logger(
       'log',
       new Date().toISOString(),
-      `Client joined the party! (${connection.remoteAddress}).`
+      `Client joined the party! (${connection.remoteAddress}).`,
     );
 
     connection.on('error', (err) => {
@@ -336,7 +456,7 @@ export default class PubSub {
   /**
    * Handle a message from a client.
    */
-  public async onMessage(from: connection, msg: Message) {
+  public async onMessage(from: ws.connection, msg: ws.Message) {
     if (msg.type !== 'utf8') {
       throw new Error("This server doesn't accept binary messages.");
     }
@@ -344,7 +464,7 @@ export default class PubSub {
     if (
       !data.action ||
       ['authenticate', 'subscribe', 'unsubscribe', 'publish'].indexOf(
-        data.action
+        data.action,
       ) === -1
     ) {
       return;
@@ -366,11 +486,11 @@ export default class PubSub {
   /**
    * Clean up after users who leave.
    */
-  public onClose(conn: connection, description: string) {
+  public onClose(conn: ws.connection, description: string) {
     this.config.logger(
       'log',
       new Date().toISOString(),
-      `Client skedaddled. (${description}, ${conn.remoteAddress})`
+      `Client skedaddled. (${description}, ${conn.remoteAddress})`,
     );
 
     let mess = 0;
@@ -398,7 +518,7 @@ export default class PubSub {
                     JSON.stringify({
                       query: curData.query,
                       count,
-                    })
+                    }),
                   );
                 }
               }
@@ -428,7 +548,7 @@ export default class PubSub {
                   JSON.stringify({
                     uid: curUID,
                     count,
-                  })
+                  }),
                 );
               }
             }
@@ -447,16 +567,16 @@ export default class PubSub {
       this.config.logger(
         'log',
         new Date().toISOString(),
-        `Cleaned up client's mess. (${mess}, ${conn.remoteAddress})`
+        `Cleaned up client's mess. (${mess}, ${conn.remoteAddress})`,
       );
     }
   }
 
-  public onError(conn: connection, e: Error) {
+  public onError(conn: ws.connection, e: Error) {
     this.config.logger(
       'error',
       new Date().toISOString(),
-      `An error occured. (${e.message}, ${conn.remoteAddress})`
+      `An error occured. (${e.message}, ${conn.remoteAddress})`,
     );
   }
 
@@ -464,13 +584,14 @@ export default class PubSub {
    * Handle an authentication from a client.
    */
   private handleAuthentication(
-    from: connection,
-    data: AuthenticateMessageData
+    from: ws.connection,
+    data: AuthenticateMessageData,
   ) {
     // Save the user's auth token in session storage.
-    const token = data.token;
-    if (token != null) {
-      this.sessions.set(from, token);
+    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);
     }
@@ -480,21 +601,31 @@ export default class PubSub {
    * Handle a subscribe or unsubscribe from a client.
    */
   private async handleSubscription(
-    from: connection,
-    data: SubscribeMessageData
+    from: ws.connection,
+    data: SubscribeMessageData,
   ) {
-    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);
+    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);
+      }
+    } catch (e: any) {
+      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 }));
+      }
     }
   }
 
@@ -502,33 +633,39 @@ export default class PubSub {
    * Handle a subscribe or unsubscribe for a query from a client.
    */
   private async handleSubscriptionQuery(
-    from: connection,
+    from: ws.connection,
     data: QuerySubscribeMessageData,
     qrefParent?: {
       etype: string;
       query: string;
-    }
+    },
   ) {
-    let args: [MessageOptions, ...Selector[]];
-    let EntityClass: EntityConstructor;
-    try {
-      args = JSON.parse(data.query);
-      EntityClass = this.nymph.getEntityClass(args[0].class);
-    } catch (e: any) {
-      return;
+    let args: [MessageOptions, ...Selector[]] = 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);
     const [clientOptions, ...selectors] = args;
-    const options: Options & { return: 'guid' } = {
+    const options: Options & { return: 'entity' } = {
       ...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.
 
@@ -543,7 +680,7 @@ export default class PubSub {
           {
             etype,
             query: serialArgs,
-          }
+          },
         );
       }
 
@@ -554,18 +691,33 @@ export default class PubSub {
       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) {
-          // Log in the user for access controls.
-          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: EntityInterface[] = [];
+      let sendEntities = false;
       const existingSub = this.querySubs[etype][serialArgs].get(from);
       if (existingSub) {
         if (qrefParent) {
@@ -577,23 +729,49 @@ export default 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 as string),
           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})`
+        `Client subscribed to a query! (${serialArgs}, ${from.remoteAddress})`,
       );
 
       if (this.config.broadcastCounts) {
@@ -606,7 +784,7 @@ export default class PubSub {
               JSON.stringify({
                 query: curData.query,
                 count,
-              })
+              }),
             );
           }
         }
@@ -627,7 +805,7 @@ export default class PubSub {
           {
             etype,
             query: serialArgs,
-          }
+          },
         );
       }
 
@@ -649,7 +827,7 @@ export default class PubSub {
               !(
                 qrefParent.etype === parent.etype &&
                 qrefParent.query === parent.query
-              )
+              ),
           );
         }
         if (!qrefParent) {
@@ -662,7 +840,7 @@ export default class PubSub {
       this.config.logger(
         'log',
         new Date().toISOString(),
-        `Client unsubscribed from a query! (${serialArgs}, ${from.remoteAddress})`
+        `Client unsubscribed from a query! (${serialArgs}, ${from.remoteAddress})`,
       );
 
       const count = this.querySubs[etype][serialArgs].size;
@@ -685,7 +863,7 @@ export default class PubSub {
               JSON.stringify({
                 query: curData.query,
                 count,
-              })
+              }),
             );
           }
         }
@@ -697,8 +875,8 @@ export default class PubSub {
    * Handle a subscribe or unsubscribe for a UID from a client.
    */
   private async handleSubscriptionUid(
-    from: connection,
-    data: UidSubscribeMessageData
+    from: ws.connection,
+    data: UidSubscribeMessageData,
   ) {
     if (data.action === 'subscribe') {
       // Client is subscribing to a UID.
@@ -708,10 +886,49 @@ export default class PubSub {
       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})`
+        `Client subscribed to a UID! (${data.uid}, ${from.remoteAddress})`,
       );
 
       if (this.config.broadcastCounts) {
@@ -724,7 +941,7 @@ export default class PubSub {
               JSON.stringify({
                 uid: data.uid,
                 count,
-              })
+              }),
             );
           }
         }
@@ -743,7 +960,7 @@ export default class PubSub {
       this.config.logger(
         'log',
         new Date().toISOString(),
-        `Client unsubscribed from a UID! (${data.uid}, ${from.remoteAddress})`
+        `Client unsubscribed from a UID! (${data.uid}, ${from.remoteAddress})`,
       );
 
       const count = this.uidSubs[data.uid].size;
@@ -763,7 +980,7 @@ export default class PubSub {
               JSON.stringify({
                 uid: data.uid,
                 count,
-              })
+              }),
             );
           }
         }
@@ -775,9 +992,9 @@ export default class PubSub {
    * Handle a publish from a client.
    */
   private async handlePublish(
-    from: connection,
-    msg: Message,
-    data: PublishMessageData
+    from: ws.connection,
+    msg: ws.Message,
+    data: PublishMessageData,
   ) {
     if (
       'guid' in data &&
@@ -817,13 +1034,13 @@ export default class PubSub {
    * Handle an entity publish from a client.
    */
   private async handlePublishEntity(
-    from: connection,
-    data: PublishEntityMessageData
+    from: ws.connection,
+    data: PublishEntityMessageData,
   ) {
     this.config.logger(
       'log',
       new Date().toISOString(),
-      `Received an entity publish! (${data.guid}, ${data.event}, ${from.remoteAddress})`
+      `Received an entity publish! (${data.guid}, ${data.event}, ${from.remoteAddress})`,
     );
 
     const etype = data.etype;
@@ -834,7 +1051,7 @@ export default class PubSub {
 
     for (let curQuery in this.querySubs[etype]) {
       const curClients = this.querySubs[etype][curQuery];
-      const updatedClients = new Set<connection>();
+      const updatedClients = new Set<ws.connection>();
 
       if (data.event === 'delete' || data.event === 'update') {
         // Check if it is in any client's currents.
@@ -853,7 +1070,7 @@ export default class PubSub {
           this.config.logger(
             'error',
             new Date().toISOString(),
-            `Error checking for client updates! (${e?.message})`
+            `Error checking for client updates! (${e?.message})`,
           );
         }
       }
@@ -870,7 +1087,7 @@ export default class PubSub {
           const entitySData: SerializedEntityData = {};
           if (typeof data.entity.class !== 'string') {
             throw new Error(
-              `Received entity data class is not valid: ${data.entity.class}`
+              `Received entity data class is not valid: ${data.entity.class}`,
             );
           }
           const DataEntityClass = this.nymph.getEntityClass(data.entity.class);
@@ -879,11 +1096,12 @@ export default class PubSub {
             EntityClass.ETYPE === DataEntityClass.ETYPE &&
             (qrefQueries.length ||
               this.nymph.driver.checkData(
+                EntityClass.ETYPE,
                 entityData,
                 entitySData,
                 selectors,
                 data.guid,
-                data.entity?.tags ?? []
+                data.entity?.tags ?? [],
               ))
           ) {
             // It either matches the query, or there are qref queries.
@@ -903,15 +1121,16 @@ export default class PubSub {
               if (qrefQueries.length) {
                 const translatedSelectors = this.translateQRefSelectors(
                   curClient,
-                  selectors
+                  selectors,
                 );
                 if (
                   !this.nymph.driver.checkData(
+                    EntityClass.ETYPE,
                     entityData,
                     entitySData,
                     translatedSelectors,
                     data.guid,
-                    data.entity?.tags ?? []
+                    data.entity?.tags ?? [],
                   )
                 ) {
                   // The query doesn't match when the qref queries are filled.
@@ -926,7 +1145,7 @@ export default class PubSub {
           this.config.logger(
             'error',
             new Date().toISOString(),
-            `Error checking for client updates! (${e?.message})`
+            `Error checking for client updates! (${e?.message})`,
           );
         }
       }
@@ -934,13 +1153,14 @@ export default class PubSub {
   }
 
   private async updateClient(
-    curClient: connection,
+    curClient: ws.connection,
     curData: QuerySubscriptionData,
-    data: PublishEntityMessageData
+    data: PublishEntityMessageData,
   ) {
     // Update currents list.
     let current: EntityInterface[];
-    let token: string | undefined;
+    let authToken: string | undefined;
+    let switchToken: string | undefined;
     const nymph = this.nymph.clone();
     try {
       const [clientOptions, ...clientSelectors] = JSON.parse(curData.query);
@@ -951,15 +1171,29 @@ export default class PubSub {
         source: 'client',
         skipAc: false,
       };
-      const selectors = 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) {
-          // Log in the user for access controls.
-          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);
@@ -967,13 +1201,13 @@ export default class PubSub {
       this.config.logger(
         'error',
         new Date().toISOString(),
-        `Error updating client! (${e?.message}, ${curClient.remoteAddress})`
+        `Error updating client! (${e?.message}, ${curClient.remoteAddress})`,
       );
       return;
     }
 
     const entityMap = Object.fromEntries(
-      current.map((entity) => [entity.guid, entity])
+      current.map((entity) => [entity.guid, entity]),
     );
     const currentGuids = current.map((entity) => entity.guid ?? '');
     const removed = difference(curData.current, currentGuids);
@@ -985,13 +1219,13 @@ export default class PubSub {
         this.config.logger(
           'log',
           new Date().toISOString(),
-          `Notifying client of removal! (${curClient.remoteAddress})`
+          `Notifying client of removal! (${curClient.remoteAddress})`,
         );
         curClient.sendUTF(
           JSON.stringify({
             query: curData.query,
             removed: guid,
-          })
+          }),
         );
       }
 
@@ -1001,7 +1235,7 @@ export default class PubSub {
         this.config.logger(
           'log',
           new Date().toISOString(),
-          `Notifying client of new match! (${curClient.remoteAddress})`
+          `Notifying client of new match! (${curClient.remoteAddress})`,
         );
         if (typeof entity.updateDataProtection === 'function') {
           entity.updateDataProtection();
@@ -1011,7 +1245,7 @@ export default class PubSub {
             query: curData.query,
             added: guid,
             data: entity,
-          })
+          }),
         );
       }
 
@@ -1021,7 +1255,7 @@ export default class PubSub {
         this.config.logger(
           'log',
           new Date().toISOString(),
-          `Notifying client of update! (${curClient.remoteAddress})`
+          `Notifying client of update! (${curClient.remoteAddress})`,
         );
         if (typeof entity.updateDataProtection === 'function') {
           entity.updateDataProtection();
@@ -1031,7 +1265,7 @@ export default class PubSub {
             query: curData.query,
             updated: data.guid,
             data: entity,
-          })
+          }),
         );
       }
     }
@@ -1039,7 +1273,7 @@ export default 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();
     }
@@ -1060,19 +1294,19 @@ export default class PubSub {
    * Handle a UID publish from a client.
    */
   private async handlePublishUid(
-    from: connection,
-    data: PublishUidMessageData
+    from: ws.connection,
+    data: PublishUidMessageData,
   ) {
     this.config.logger(
       'log',
       new Date().toISOString(),
       `Received a UID publish! (${
         'name' in data ? data.name : `${data.oldName} => ${data.newName}`
-      }, ${data.event}, ${from.remoteAddress})`
+      }, ${data.event}, ${from.remoteAddress})`,
     );
 
     const names = [data.name, data.oldName].filter(
-      (name) => name != null
+      (name) => name != null,
     ) as string[];
     let value = data.value;
     if (data.event === 'renameUID' && data.newName) {
@@ -1087,7 +1321,7 @@ export default class PubSub {
         this.config.logger(
           'log',
           new Date().toISOString(),
-          `Notifying client of ${data.event}! (${name}, ${curClient.remoteAddress})`
+          `Notifying client of ${data.event}! (${name}, ${curClient.remoteAddress})`,
         );
         const payload: {
           uid: string;
@@ -1113,14 +1347,14 @@ export default class PubSub {
         this.config.logger(
           'log',
           new Date().toISOString(),
-          `Notifying client of new value after rename! (${data.newName}, ${curClient.remoteAddress})`
+          `Notifying client of new value after rename! (${data.newName}, ${curClient.remoteAddress})`,
         );
         curClient.sendUTF(
           JSON.stringify({
             uid: data.newName,
             event: 'setUID',
             value,
-          })
+          }),
         );
       }
     }
@@ -1129,24 +1363,24 @@ export default class PubSub {
   /**
    * Relay publish data to other servers.
    */
-  private relay(message: Message) {
+  private relay(message: ws.Message) {
     if (message.type !== 'utf8') {
       this.config.logger(
         'error',
         new Date().toISOString(),
-        `Can't relay non UTF8 message.`
+        `Can't relay non UTF8 message.`,
       );
       return;
     }
 
     for (let host of this.config.relays) {
-      const client = new WebSocketClient();
+      const client = new ws.client();
 
       client.on('connectFailed', (error) => {
         this.config.logger(
           'error',
           new Date().toISOString(),
-          `Relay connection failed. (${error.toString()}, ${host})`
+          `Relay connection failed. (${error.toString()}, ${host})`,
         );
       });
 
@@ -1155,7 +1389,7 @@ export default class PubSub {
           this.config.logger(
             'error',
             new Date().toISOString(),
-            `Relay connect error. (${error.toString()}, ${host})`
+            `Relay connect error. (${error.toString()}, ${host})`,
           );
         });
 
@@ -1170,8 +1404,8 @@ export default class PubSub {
     }
   }
 
-  private findQRefQueries(options: Options, ...selectors: Selector[]) {
-    const qrefQueries: [Options, ...Selector[]][] = [];
+  private findQRefQueries(options: MessageOptions, ...selectors: Selector[]) {
+    const qrefQueries: [MessageOptions, ...Selector[]][] = [];
 
     for (const curSelector of selectors) {
       for (const k in curSelector) {
@@ -1191,7 +1425,7 @@ export default class PubSub {
             Array.isArray(((value as Selector['qref']) ?? [])[0])
               ? value
               : [value]
-          ) as [string, [Options, ...Selector[]]][];
+          ) as [string, [MessageOptions, ...Selector[]]][];
           for (let i = 0; i < tmpArr.length; i++) {
             qrefQueries.push(tmpArr[i][1]);
           }
@@ -1209,7 +1443,7 @@ export default class PubSub {
    * This translates qref selectors into ref selectors using the "current" GUID
    * list in the existing subscriptions.
    */
-  private translateQRefSelectors(client: connection, selectors: Selector[]) {
+  private translateQRefSelectors(client: ws.connection, selectors: Selector[]) {
     const newSelectors: Selector[] = [];
 
     for (const curSelector of selectors) {
@@ -1238,28 +1472,56 @@ export default 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'
-                ? this.nymph.getEntityClass(qrefOptions.class)
-                : qrefOptions.class ?? this.nymph.getEntityClass('Entity');
+            const QrefEntityClass = qrefOptions.class
+              ? this.nymph.getEntityClass(qrefOptions.class)
+              : this.nymph.getEntityClass('Entity');
             const data =
               this.querySubs[QrefEntityClass.ETYPE][query].get(client);
             if (data) {
               const guids = data.current;
-              let newValue: [string, string | EntityInterface][];
-              const oldValue = newSelector[newKey];
-              if (!oldValue) {
-                newValue = [];
-              } else if (oldValue.length && !Array.isArray(oldValue[0])) {
-                newValue = [oldValue] as [string, string | EntityInterface][];
+              if (newKey === '!ref') {
+                // Insert the qref results as a not ref clause.
+                let newValue: [string, string | EntityInterface][];
+                const oldValue = newSelector[newKey];
+                if (
+                  oldValue == null ||
+                  (Array.isArray(oldValue) && !oldValue.length)
+                ) {
+                  newValue = [];
+                } else if (
+                  Array.isArray(oldValue) &&
+                  !Array.isArray(oldValue[0])
+                ) {
+                  newValue = [oldValue] as [string, string | EntityInterface][];
+                } else {
+                  newValue = oldValue as [string, string | EntityInterface][];
+                }
+                newValue.push(
+                  ...(guids.map((guid) => [name, guid]) as [string, string][]),
+                );
+                newSelector[newKey] = newValue;
               } else {
-                newValue = oldValue as [string, string | EntityInterface][];
+                // Insert the qref results as an "or" selector clause with a ref
+                // selector.
+                let newValue: Selector[];
+                const oldValue = newSelector['selector'];
+                delete newSelector[key];
+                if (
+                  oldValue == null ||
+                  (Array.isArray(oldValue) && !oldValue.length)
+                ) {
+                  newValue = [];
+                } else if (!Array.isArray(oldValue)) {
+                  newValue = [oldValue] as Selector[];
+                } else {
+                  newValue = oldValue as Selector[];
+                }
+                newValue.push({
+                  type: '|',
+                  ref: guids.map((guid) => [name, guid]) as [string, string][],
+                });
+                newSelector['selector'] = newValue;
               }
-              newValue.push(
-                ...(guids.map((guid) => [name, guid]) as [string, string][])
-              );
-              // Insert the qref results as a ref clause.
-              newSelector[newKey] = newValue;
             } else {
               // Can't translate, so put the original back in.
               if (!newSelector[key]) {
@@ -1285,7 +1547,7 @@ export default class PubSub {
             newSelector[key] = [];
           }
           (newSelector[key] as [string, string | EntityInterface][]).push(
-            ...tmpArr
+            ...tmpArr,
           );
         } else {
           // @ts-ignore: ts doesn't know what value is here.