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

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,14 +22,14 @@ import type {
   PublishMessageData,
   MessageData,
   MessageOptions,
-} from './PubSub.types';
+} from './PubSub.types.js';
 
 /**
  * A publish/subscribe server for Nymph.
  *
  * Written by Hunter Perrin for SciActive.
  *
- * @author Hunter Perrin <hperrin@gmail.com>
+ * @author Hunter Perrin <hperrin@port87.com>
  * @copyright SciActive Inc
  * @see http://nymph.io/
  */
@@ -53,207 +47,294 @@ 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 outgoingClientMessages = new Map<
+    ws.connection,
+    { subscription: QuerySubscriptionData; publish: PublishEntityMessageData }[]
+  >();
+  protected outgoingClientMessagesTimeout: NodeJS.Immediate | null = null;
+  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 +345,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 +361,81 @@ 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;
+    }
+
+    let notReadyTransactionPublishes: typeof this.transactionPublishes = [];
+    let readyTransactionPublishes: typeof this.transactionPublishes = [];
+
+    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<Config, string[]>();
+
+    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,
+        );
+      }
+    }
+  }
+
+  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 +447,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 +463,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,41 +482,65 @@ 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.");
     }
     const data: MessageData = 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: MessageData, 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.
    */
-  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 +568,7 @@ export default class PubSub {
                     JSON.stringify({
                       query: curData.query,
                       count,
-                    })
+                    }),
                   );
                 }
               }
@@ -428,7 +598,7 @@ export default class PubSub {
                   JSON.stringify({
                     uid: curUID,
                     count,
-                  })
+                  }),
                 );
               }
             }
@@ -447,16 +617,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 +634,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 +651,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 +683,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 +730,7 @@ export default class PubSub {
           {
             etype,
             query: serialArgs,
-          }
+          },
         );
       }
 
@@ -554,18 +741,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 +779,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 (nymph.tilmeld != null && token != null) {
+
+      if (sendEntities) {
+        // Notify the client of the current value.
+        from.sendUTF(
+          JSON.stringify({
+            query: data.query,
+            set: true,
+            data: entities,
+          }),
+        );
+      }
+
+      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 +834,7 @@ export default class PubSub {
               JSON.stringify({
                 query: curData.query,
                 count,
-              })
+              }),
             );
           }
         }
@@ -627,7 +855,7 @@ export default class PubSub {
           {
             etype,
             query: serialArgs,
-          }
+          },
         );
       }
 
@@ -649,7 +877,7 @@ export default class PubSub {
               !(
                 qrefParent.etype === parent.etype &&
                 qrefParent.query === parent.query
-              )
+              ),
           );
         }
         if (!qrefParent) {
@@ -662,7 +890,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 +913,7 @@ export default class PubSub {
               JSON.stringify({
                 query: curData.query,
                 count,
-              })
+              }),
             );
           }
         }
@@ -697,8 +925,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 +936,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 +991,7 @@ export default class PubSub {
               JSON.stringify({
                 uid: data.uid,
                 count,
-              })
+              }),
             );
           }
         }
@@ -743,7 +1010,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 +1030,7 @@ export default class PubSub {
               JSON.stringify({
                 uid: data.uid,
                 count,
-              })
+              }),
             );
           }
         }
@@ -774,11 +1041,7 @@ export default class PubSub {
   /**
    * Handle a publish from a client.
    */
-  private async handlePublish(
-    from: connection,
-    msg: Message,
-    data: PublishMessageData
-  ) {
+  private async handlePublish(from: ws.connection, data: PublishMessageData) {
     if (
       'guid' in data &&
       typeof data.guid === 'string' &&
@@ -791,9 +1054,6 @@ export default class PubSub {
       // Publish is an entity.
 
       await this.handlePublishEntity(from, data);
-
-      // Relay the publish to other servers.
-      this.relay(msg);
     }
 
     if (
@@ -807,9 +1067,6 @@ export default class PubSub {
       // Publish is a UID.
 
       await this.handlePublishUid(from, data);
-
-      // Relay the publish to other servers.
-      this.relay(msg);
     }
   }
 
@@ -817,13 +1074,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 +1091,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.
@@ -845,7 +1102,7 @@ export default class PubSub {
               continue;
             }
             if (curData.current.indexOf(data.guid) !== -1) {
-              await this.updateClient(curClient, curData, data);
+              this.addOutgoingClientMessage(curClient, curData, data);
               updatedClients.add(curClient);
             }
           }
@@ -853,7 +1110,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 +1127,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 +1136,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 +1161,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.
@@ -919,138 +1178,201 @@ export default class PubSub {
                 }
               }
 
-              await this.updateClient(curClient, curData, data);
+              this.addOutgoingClientMessage(curClient, curData, data);
             }
           }
         } catch (e: any) {
           this.config.logger(
             'error',
             new Date().toISOString(),
-            `Error checking for client updates! (${e?.message})`
+            `Error checking for client updates! (${e?.message})`,
           );
         }
       }
     }
   }
 
-  private async updateClient(
-    curClient: connection,
+  private addOutgoingClientMessage(
+    curClient: ws.connection,
     curData: QuerySubscriptionData,
-    data: PublishEntityMessageData
+    data: PublishEntityMessageData,
   ) {
-    // Update currents list.
-    let current: EntityInterface[];
-    let token: string | undefined;
-    const nymph = this.nymph.clone();
-    try {
-      const [clientOptions, ...clientSelectors] = JSON.parse(curData.query);
-      const options: Options = {
-        ...clientOptions,
-        class: nymph.getEntityClass(clientOptions.class),
-        return: 'entity',
-        source: 'client',
-        skipAc: false,
-      };
-      const selectors = 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) {
-          // Log in the user for access controls.
-          nymph.tilmeld.fillSession(user);
-        }
-      }
-      current = await nymph.getEntities(options, ...selectors);
-    } catch (e: any) {
-      this.config.logger(
-        'error',
-        new Date().toISOString(),
-        `Error updating client! (${e?.message}, ${curClient.remoteAddress})`
-      );
-      return;
+    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 = difference(curData.current, currentGuids);
-    const added = difference(currentGuids, curData.current);
+    this.outgoingClientMessagesTimeout = setImmediate(async () => {
+      await this.updateClients();
+    });
+  }
 
-    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,
-            removed: guid,
-          })
-        );
-      }
+  private async updateClients() {
+    const outgoingClientMessages = [...this.outgoingClientMessages.entries()];
+    this.outgoingClientMessages.clear();
 
-      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();
-        }
-        curClient.sendUTF(
-          JSON.stringify({
-            query: curData.query,
-            added: guid,
-            data: entity,
-          })
-        );
+    for (let [curClient, entries] of outgoingClientMessages) {
+      const queryMap: { [k: string]: typeof entries } = {};
+      for (let entry of entries) {
+        const arr = queryMap[entry.subscription.query] || [];
+        arr.push(entry);
+        queryMap[entry.subscription.query] = arr;
       }
 
-      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();
+      for (let [query, queryEntries] of Object.entries(queryMap)) {
+        // Update currents list.
+        let current: EntityInterface[];
+        let authToken: string | undefined;
+        let switchToken: string | undefined;
+        const nymph = this.nymph.clone();
+        try {
+          const [clientOptions, ...clientSelectors] = JSON.parse(query);
+          const options: 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);
+        } catch (e: any) {
+          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,
-          })
+
+        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: {
+          query: string;
+          removed?: string;
+          added?: string;
+          updated?: string;
+          data?: any;
+        }[] = [];
+
+        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,
+              });
+            }
 
-    // Update curData.
-    curData.current = currentGuids;
+            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 (nymph.tilmeld != null && token != null) {
-      // Clear the user that was temporarily logged in.
-      nymph.tilmeld.clearSession();
-    }
+            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) && 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) {
-          this.updateClient(curClient, subData, data);
+          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 }),
+          );
         }
       }
     }
@@ -1060,19 +1382,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 +1409,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 +1435,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 +1451,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 +1477,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 +1492,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,9 +1513,9 @@ export default class PubSub {
             Array.isArray(((value as Selector['qref']) ?? [])[0])
               ? value
               : [value]
-          ) as [string, [Options, ...Selector[]]][];
-          for (let i = 0; i < tmpArr.length; i++) {
-            qrefQueries.push(tmpArr[i][1]);
+          ) as [string, [MessageOptions, ...Selector[]]][];
+          for (let [_name, qRefQuery] of tmpArr) {
+            qrefQueries.push(qRefQuery);
           }
         } else if (key === 'selector' || key === '!selector') {
           const tmpArr = (Array.isArray(value) ? value : [value]) as Selector[];
@@ -1209,7 +1531,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 +1560,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 +1635,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.