@nymphjs/client 1.0.0-beta.12 → 1.0.0-beta.120

package/src/PubSub.ts

@@ -1,7 +1,12 @@
-import Nymph, { InvalidRequestError } from './Nymph';
-import { NymphOptions, Options, Selector } from './Nymph.types';
-import { EntityConstructor, EntityInterface } from './Entity.types';
-import {
+import Nymph, { InvalidRequestError } from './Nymph.js';
+import type { NymphOptions, Options, Selector } from './Nymph.types.js';
+import type { EntityInstanceType } from './Entity.js';
+import type {
+  EntityConstructor,
+  EntityInterface,
+  EntityJson,
+} from './Entity.types.js';
+import type {
   PubSubCallbacks,
   PubSubConnectCallback,
   PubSubCountCallback,
@@ -9,17 +14,19 @@ import {
   PubSubEventType,
   PubSubRejectCallback,
   PubSubResolveCallback,
+  PubSubErrorCallback,
   PubSubSubscribable,
   PubSubUpdate,
-} from './PubSub.types';
-import { entityConstructorsToClassNames } from './utils';
-
-let authToken: string | null = null;
+} from './PubSub.types.js';
+import { entityConstructorsToClassNames } from './utils.js';
+import { ClientError } from './HttpRequester.js';
 
 export default class PubSub {
   private nymph: Nymph;
+  private authToken: string | null = null;
+  private switchToken: string | null = null;
   private connection: WebSocket | undefined;
-  private waitForConnectionTimeout: NodeJS.Timeout | undefined;
+  private waitForConnectionTimeout: number | undefined;
   private pubsubUrl: string | undefined;
   private WebSocket: typeof WebSocket;
   private subscriptions: {
@@ -35,6 +42,7 @@ export default class PubSub {
   };
   private connectCallbacks: PubSubConnectCallback[] = [];
   private disconnectCallbacks: PubSubDisconnectCallback[] = [];
+  private errorCallbacks: PubSubErrorCallback[] = [];
   private noConsole = false;
 
   public constructor(nymphOptions: NymphOptions, nymph: Nymph) {
@@ -51,11 +59,16 @@ export default class PubSub {
     if (typeof addEventListener !== 'undefined') {
       addEventListener('online', () => this.connect());
     }
-    if (typeof navigator === 'undefined' || navigator.onLine) {
+    if (
+      !nymphOptions.noAutoconnect &&
+      (typeof navigator === 'undefined' || navigator.onLine)
+    ) {
       this.connect();
     }
   }
 
+  // TODO: return: 'guid' doesn't work here because the server always returns
+  // entities.
   public subscribeEntities<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'guid' },
     ...selectors: Selector[]
@@ -63,14 +76,13 @@ export default class PubSub {
   public subscribeEntities<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
     ...selectors: Selector[]
-  ): PubSubSubscribable<PubSubUpdate<ReturnType<T['factorySync']>[]>>;
+  ): PubSubSubscribable<PubSubUpdate<EntityInstanceType<T>[]>>;
   public subscribeEntities<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
     ...selectors: Selector[]
-  ): PubSubSubscribable<
-    PubSubUpdate<ReturnType<T['factorySync']>[]> | PubSubUpdate<string[]>
-  > {
-    const promise = this.nymph.getEntities(options, ...selectors);
+  ):
+    | PubSubSubscribable<PubSubUpdate<EntityInstanceType<T>[]>>
+    | PubSubSubscribable<PubSubUpdate<string[]>> {
     const query = [
       entityConstructorsToClassNames(options),
       ...entityConstructorsToClassNames(selectors),
@@ -79,18 +91,20 @@ export default class PubSub {
     const subscribe = (
       resolve?:
         | PubSubResolveCallback<
-            | PubSubUpdate<ReturnType<T['factorySync']>[]>
-            | PubSubUpdate<string[]>
+            PubSubUpdate<EntityInstanceType<T>[]> | PubSubUpdate<string[]>
           >
         | undefined,
       reject?: PubSubRejectCallback | undefined,
-      count?: PubSubCountCallback | undefined
+      count?: PubSubCountCallback | undefined,
     ) => {
       const callbacks: PubSubCallbacks<
-        PubSubUpdate<ReturnType<T['factorySync']>[]> | PubSubUpdate<string[]>
+        PubSubUpdate<EntityInstanceType<T>[]> | PubSubUpdate<string[]>
       > = [resolve, reject, count];
 
-      promise.then(resolve, reject);
+      if (!this.isConnection()) {
+        // Fall back to a regular query if we're not connected.
+        this.nymph.getEntities(options, ...selectors).then(resolve, reject);
+      }
 
       this._subscribeQuery(jsonQuery, callbacks);
       return new PubSubSubscription(jsonQuery, callbacks, () => {
@@ -100,6 +114,8 @@ export default class PubSub {
     return subscribe;
   }
 
+  // TODO: return: 'guid' doesn't work here because the server always returns
+  // entities.
   public subscribeEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T> & { return: 'guid' },
     ...selectors: Selector[]
@@ -107,15 +123,13 @@ export default class PubSub {
   public subscribeEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
     ...selectors: Selector[]
-  ): PubSubSubscribable<PubSubUpdate<ReturnType<T['factorySync']> | null>>;
+  ): PubSubSubscribable<PubSubUpdate<EntityInstanceType<T> | null>>;
   public subscribeEntity<T extends EntityConstructor = EntityConstructor>(
     options: Options<T>,
     ...selectors: Selector[]
-  ): PubSubSubscribable<
-    | PubSubUpdate<ReturnType<T['factorySync']> | null>
-    | PubSubUpdate<string | null>
-  > {
-    const promise = this.nymph.getEntity(options, ...selectors);
+  ):
+    | PubSubSubscribable<PubSubUpdate<EntityInstanceType<T> | null>>
+    | PubSubSubscribable<PubSubUpdate<string | null>> {
     const query = [
       { ...entityConstructorsToClassNames(options), limit: 1 },
       ...entityConstructorsToClassNames(selectors),
@@ -124,12 +138,12 @@ export default class PubSub {
     const subscribe = (
       resolve?:
         | PubSubResolveCallback<
-            | PubSubUpdate<ReturnType<T['factorySync']> | null>
+            | PubSubUpdate<EntityInstanceType<T> | null>
             | PubSubUpdate<string | null>
           >
         | undefined,
       reject?: PubSubRejectCallback | undefined,
-      count?: PubSubCountCallback | undefined
+      count?: PubSubCountCallback | undefined,
     ) => {
       const newResolve = (args: any) => {
         if (!args.length) {
@@ -143,11 +157,13 @@ export default class PubSub {
         }
       };
       const callbacks: PubSubCallbacks<
-        | PubSubUpdate<ReturnType<T['factorySync']> | null>
-        | PubSubUpdate<string | null>
+        PubSubUpdate<EntityInstanceType<T> | null> | PubSubUpdate<string | null>
       > = [newResolve, reject, count];
 
-      promise.then(resolve, reject);
+      if (!this.isConnection()) {
+        // Fall back to a regular query if we're not connected.
+        this.nymph.getEntity(options, ...selectors).then(resolve, reject);
+      }
 
       this._subscribeQuery(jsonQuery, callbacks);
       return new PubSubSubscription(jsonQuery, callbacks, () => {
@@ -158,15 +174,17 @@ export default class PubSub {
   }
 
   public subscribeUID(name: string) {
-    const promise = this.nymph.getUID(name);
     const subscribe = (
       resolve?: PubSubResolveCallback<number> | undefined,
       reject?: PubSubRejectCallback | undefined,
-      count?: PubSubCountCallback | undefined
+      count?: PubSubCountCallback | undefined,
     ) => {
       const callbacks: PubSubCallbacks<number> = [resolve, reject, count];
 
-      promise.then(resolve, reject);
+      if (!this.isConnection()) {
+        // Fall back to a regular query if we're not connected.
+        this.nymph.getUID(name).then(resolve, reject);
+      }
 
       this._subscribeUID(name, callbacks);
       return {
@@ -182,11 +200,11 @@ export default class PubSub {
     entity: T,
     resolve?: PubSubResolveCallback<T> | undefined,
     reject?: PubSubRejectCallback | undefined,
-    count?: PubSubCountCallback | undefined
+    count?: PubSubCountCallback | undefined,
   ) {
     if (!entity.guid) {
       throw new InvalidRequestError(
-        "You can't subscribe to an entity with no GUID."
+        "You can't subscribe to an entity with no GUID.",
       );
     }
     const query = [
@@ -197,15 +215,21 @@ export default class PubSub {
 
     const newResolve = (args: any) => {
       if (Array.isArray(args)) {
-        if (args[0].length) {
-          entity.$init(args[0]);
+        if (args.length) {
+          entity.$init(args[0].toJSON());
         } else {
           entity.guid = null;
         }
-      } else if ('removed' in args) {
-        entity.guid = null;
       } else {
-        entity.$init(args.data);
+        let update = args;
+        if ('multiple' in args && args.multiple) {
+          update = args.messages.pop();
+        }
+        if ('removed' in update) {
+          entity.guid = null;
+        } else {
+          entity.$init(update.data);
+        }
       }
 
       if (resolve) {
@@ -242,31 +266,31 @@ export default class PubSub {
       return;
     }
 
-    this.connection.close(4200, 'Closure requested by application.');
+    this.connection.close(1000, 'Closure requested by application.');
   }
 
-  private _waitForConnection(attempts = 0) {
-    // Wait 5 seconds, then check and attempt connection again if
-    // unsuccessful. Keep repeating until successful.
-    this.waitForConnectionTimeout = setTimeout(() => {
-      if (
-        this.connection &&
-        this.connection.readyState !== this.WebSocket.OPEN
-      ) {
-        if (
-          this.connection.readyState !== this.WebSocket.CONNECTING ||
-          attempts >= 5
-        ) {
-          this.connection.close();
-          this._waitForConnection();
-          this._attemptConnect();
+  private _waitForConnection(attempts = 1) {
+    // Wait 5 seconds, then check and attempt connection again if unsuccessful.
+    // Keep repeating, adding attempts^2*5 seconds each time to a max of ten
+    // minutes, until successful.
+    this.waitForConnectionTimeout = setTimeout(
+      () => {
+        if (this.connection) {
+          if (this.connection.readyState !== this.WebSocket.OPEN) {
+            if (this.connection.readyState !== this.WebSocket.CONNECTING) {
+              this.connection.close();
+              this._waitForConnection(attempts + 1);
+              this._attemptConnect();
+            } else {
+              this._waitForConnection(attempts + 1);
+            }
+          }
         } else {
-          this._waitForConnection(attempts + 1);
+          this._attemptConnect();
         }
-      } else {
-        this._attemptConnect();
-      }
-    }, 5000);
+      },
+      Math.max(Math.pow(attempts, 2) * 5000, 1000 * 60 * 10),
+    );
   }
 
   private _attemptConnect() {
@@ -282,6 +306,11 @@ export default class PubSub {
     if (typeof console !== 'undefined' && !this.noConsole) {
       console.log('Nymph-PubSub connection established!');
     }
+
+    if (this.waitForConnectionTimeout) {
+      clearTimeout(this.waitForConnectionTimeout);
+    }
+
     for (let i = 0; i < this.connectCallbacks.length; i++) {
       const callback = this.connectCallbacks[i];
       if (callback) {
@@ -289,10 +318,11 @@ export default class PubSub {
       }
     }
 
-    if (authToken != null) {
+    if (this.authToken != null) {
       this._send({
         action: 'authenticate',
-        token: authToken,
+        authToken: this.authToken,
+        switchToken: this.switchToken,
       });
     }
 
@@ -340,17 +370,23 @@ export default class PubSub {
   private _onmessage(e: WebSocketEventMap['message']) {
     let data = JSON.parse(e.data);
     let subs: PubSubCallbacks<any>[] = [];
+    let set = 'set' in data && data.set;
     let count = 'count' in data;
+    let error = 'error' in data;
     if (
       data.hasOwnProperty('query') &&
       this.subscriptions.queries.hasOwnProperty(data.query)
     ) {
       subs = [...this.subscriptions.queries[data.query]];
-      if (!count) {
+      if (!count && !error) {
         for (let i = 0; i < subs.length; i++) {
           const callback = subs[i][0];
           if (typeof callback === 'function') {
-            callback(data);
+            callback(
+              set
+                ? data.data.map((e: EntityJson) => this.nymph.initEntity(e))
+                : data,
+            );
           }
         }
       }
@@ -359,14 +395,36 @@ export default class PubSub {
       this.subscriptions.uids.hasOwnProperty(data.uid)
     ) {
       subs = [...this.subscriptions.uids[data.uid]];
-      if (!count) {
+      if (!count && !error) {
         for (let i = 0; i < subs.length; i++) {
           const callback = subs[i][0];
-          if (typeof callback === 'function') {
-            callback(data.value ?? null, data.event);
+          const errCallback = subs[i][1];
+          if (set && data.data == null) {
+            if (typeof errCallback === 'function') {
+              errCallback(
+                new ClientError(
+                  { status: 404, statusText: 'Not Found' } as Response,
+                  { textStatus: 'Not Found' },
+                ),
+              );
+            }
+          } else if (typeof callback === 'function') {
+            if (set) {
+              callback(data.data);
+            } else {
+              callback(data.value ?? null, data.event);
+            }
           }
         }
       }
+    } else if (error) {
+      for (let i = 0; i < this.errorCallbacks.length; i++) {
+        const callback = this.errorCallbacks[i];
+        if (callback) {
+          callback(data.error);
+        }
+      }
+      return;
     }
     if (count) {
       for (let i = 0; i < subs.length; i++) {
@@ -376,6 +434,14 @@ export default class PubSub {
         }
       }
     }
+    if (error) {
+      for (let i = 0; i < subs.length; i++) {
+        const callback = subs[i][1];
+        if (typeof callback === 'function') {
+          callback(data.error);
+        }
+      }
+    }
   }
 
   private _onclose(e: WebSocketEventMap['close']) {
@@ -389,7 +455,7 @@ export default class PubSub {
       }
     }
     if (
-      e.code !== 4200 &&
+      e.code !== 1000 &&
       (typeof navigator === 'undefined' || navigator.onLine)
     ) {
       if (this.connection) {
@@ -412,6 +478,17 @@ export default class PubSub {
     );
   }
 
+  public isConnectionConnecting() {
+    return !!(
+      this.connection &&
+      this.connection.readyState === this.WebSocket.CONNECTING
+    );
+  }
+
+  public isConnection() {
+    return this.isConnectionOpen() || this.isConnectionConnecting();
+  }
+
   private _subscribeQuery(query: string, callbacks: PubSubCallbacks<any>) {
     let isNewSubscription = false;
     if (!this.subscriptions.queries.hasOwnProperty(query)) {
@@ -549,126 +626,117 @@ export default class PubSub {
   }
 
   public updateArray(
-    oldArr: EntityInterface[],
-    update: PubSubUpdate<EntityInterface[]>
+    current: EntityInterface[],
+    update: PubSubUpdate<EntityInterface[]>,
   ) {
     if (Array.isArray(update)) {
       const newArr = [...update];
 
-      if (oldArr.length === 0) {
+      if (current.length === 0) {
         // This will happen on the first update from a subscribe.
-        oldArr.splice(0, 0, ...newArr);
+        current.splice(0, 0, ...newArr);
         return;
       }
 
-      const idMap: { [k: string]: number } = {};
-      const Entity = this.nymph.getEntityClass('Entity');
+      const idMap: { [k: string]: EntityInterface } = {};
+      const newEntities: EntityInterface[] = [];
+      while (current.length) {
+        const first = current.shift();
+        if (!first) {
+          continue;
+        }
+        const guid = first.guid;
+        if (!guid) {
+          newEntities.push(first);
+          continue;
+        }
+        idMap[guid] = first;
+      }
+
       for (let i = 0; i < newArr.length; i++) {
         const entity = newArr[i];
-        if (entity instanceof Entity && entity.guid != null) {
-          idMap[entity.guid] = i;
+        const guid = entity.guid;
+        if (guid == null) {
+          continue;
         }
-      }
-      const remove: number[] = [];
-      for (let k in oldArr) {
-        if (
-          // This handles sparse arrays.
-          typeof k === 'number' &&
-          k <= 4294967294 &&
-          /^0$|^[1-9]\d*$/.test(k) &&
-          oldArr.hasOwnProperty(k)
-        ) {
-          const guid = oldArr[k].guid;
-          if (guid != null) {
-            if (!idMap.hasOwnProperty(guid)) {
-              // It was deleted.
-              remove.push(k);
-            } else if (newArr[idMap[guid]].mdate !== oldArr[k].mdate) {
-              // It was modified.
-              oldArr[k].$init(newArr[idMap[guid]].toJSON());
-              delete idMap[guid];
-            } else {
-              // Item wasn't modified.
-              delete idMap[guid];
-            }
-          }
+
+        if (!idMap.hasOwnProperty(guid)) {
+          // It was added.
+          current.push(entity);
+        } else if (idMap[guid].mdate !== entity.mdate) {
+          // It was modified.
+          idMap[guid].$init(entity.toJSON());
+          current.push(idMap[guid]);
+        } else {
+          // Item wasn't modified.
+          current.push(idMap[guid]);
         }
       }
-      // Now we must remove the deleted ones.
-      remove.sort(function (a, b) {
-        // Sort backwards so we can remove in reverse order. (Preserves
-        // indices.)
-        if (a > b) return -1;
-        if (a < b) return 1;
-        return 0;
-      });
-      for (let n = 0; n < remove.length; n++) {
-        oldArr.splice(remove[n], 1);
-      }
-      // And add the new ones.
-      for (let value of Object.values(idMap)) {
-        oldArr.splice(oldArr.length, 0, newArr[value]);
-      }
+
+      current.splice(current.length, 0, ...newEntities);
     } else if (update != null && update.hasOwnProperty('query')) {
-      if ('removed' in update) {
-        for (let i = 0; i < oldArr.length; i++) {
-          if (oldArr[i] != null && oldArr[i].guid === update.removed) {
-            oldArr.splice(i, 1);
-            return;
+      const updates =
+        'multiple' in update && update.multiple ? update.messages : [update];
+      for (let curUpdate of updates) {
+        if ('removed' in curUpdate) {
+          for (let i = 0; i < current.length; i++) {
+            if (current[i] != null && current[i].guid === curUpdate.removed) {
+              current.splice(i, 1);
+              continue;
+            }
           }
         }
-      }
 
-      // Get the entity.
-      let entity: EntityInterface | null = null;
-      if ('added' in update) {
-        // Check for it in the array already.
-        for (let i = 0; i < oldArr.length; i++) {
-          if (oldArr[i] != null && oldArr[i].guid === update.added) {
-            entity = oldArr.splice(i, 1)[0].$init(update.data);
+        // Get the entity.
+        let entity: EntityInterface | null = null;
+        if ('added' in curUpdate) {
+          // Check for it in the array already.
+          for (let i = 0; i < current.length; i++) {
+            if (current[i] != null && current[i].guid === curUpdate.added) {
+              entity = current.splice(i, 1)[0].$init(curUpdate.data);
+            }
+          }
+          if (entity == null) {
+            // A new entity.
+            entity = this.nymph.initEntity(curUpdate.data);
           }
         }
-        if (entity == null) {
-          // A new entity.
-          entity = this.nymph.initEntity(update.data);
-        }
-      }
-      if ('updated' in update) {
-        // Extract it from the array.
-        for (let i = 0; i < oldArr.length; i++) {
-          if (oldArr[i] != null && oldArr[i].guid === update.updated) {
-            entity = oldArr.splice(i, 1)[0].$init(update.data);
+        if ('updated' in curUpdate) {
+          // Extract it from the array.
+          for (let i = 0; i < current.length; i++) {
+            if (current[i] != null && current[i].guid === curUpdate.updated) {
+              entity = current.splice(i, 1)[0].$init(curUpdate.data);
+            }
           }
         }
-      }
 
-      const query = JSON.parse(update.query);
-      if (entity != null) {
-        // Insert the entity in order.
-        const sort =
-          'sort' in query[0] ? (query[0].sort as 'cdate' | 'mdate') : 'cdate';
-        const reverse = query[0].hasOwnProperty('reverse')
-          ? query[0].reverse
-          : false;
-        let i;
-
-        if (reverse) {
-          for (
-            i = 0;
-            ((oldArr[i] ?? {})[sort] ?? 0) >= (entity[sort] ?? 0) &&
-            i < oldArr.length;
-            i++
-          );
-        } else {
-          for (
-            i = 0;
-            ((oldArr[i] ?? {})[sort] ?? 0) < (entity[sort] ?? 0) &&
-            i < oldArr.length;
-            i++
-          );
-        }
+        if (entity != null) {
+          const query = JSON.parse(curUpdate.query);
+          // Insert the entity in order.
+          const sort = 'sort' in query[0] ? (query[0].sort as string) : 'cdate';
+          const reverse = query[0].hasOwnProperty('reverse')
+            ? query[0].reverse
+            : false;
+          let i;
+
+          if (reverse) {
+            for (
+              i = 0;
+              ((current[i] ?? {})[sort] ?? 0) >= (entity[sort] ?? 0) &&
+              i < current.length;
+              i++
+            );
+          } else {
+            for (
+              i = 0;
+              ((current[i] ?? {})[sort] ?? 0) < (entity[sort] ?? 0) &&
+              i < current.length;
+              i++
+            );
+          }
 
-        oldArr.splice(i, 0, entity);
+          current.splice(i, 0, entity);
+        }
       }
     }
   }
@@ -678,17 +746,22 @@ export default class PubSub {
     callback: T extends 'connect'
       ? PubSubConnectCallback
       : T extends 'disconnect'
-      ? PubSubDisconnectCallback
-      : never
+        ? PubSubDisconnectCallback
+        : T extends 'error'
+          ? PubSubErrorCallback
+          : never,
   ) {
     const prop = (event + 'Callbacks') as T extends 'connect'
       ? 'connectCallbacks'
       : T extends 'disconnect'
-      ? 'disconnectCallbacks'
-      : never;
+        ? 'disconnectCallbacks'
+        : T extends 'error'
+          ? 'errorCallbacks'
+          : never;
     if (!(prop in this)) {
       throw new Error('Invalid event type.');
     }
+    // @ts-ignore: The callback should always be the right type here.
     this[prop].push(callback);
     return () => this.off(event, callback);
   }
@@ -698,17 +771,22 @@ export default class PubSub {
     callback: T extends 'connect'
       ? PubSubConnectCallback
       : T extends 'disconnect'
-      ? PubSubDisconnectCallback
-      : never
+        ? PubSubDisconnectCallback
+        : T extends 'error'
+          ? PubSubErrorCallback
+          : never,
   ) {
     const prop = (event + 'Callbacks') as T extends 'connect'
       ? 'connectCallbacks'
       : T extends 'disconnect'
-      ? 'disconnectCallbacks'
-      : never;
+        ? 'disconnectCallbacks'
+        : T extends 'error'
+          ? 'errorCallbacks'
+          : never;
     if (!(prop in this)) {
       return false;
     }
+    // @ts-ignore: The callback should always be the right type here.
     const i = this[prop].indexOf(callback);
     if (i > -1) {
       this[prop].splice(i, 1);
@@ -716,12 +794,17 @@ export default class PubSub {
     return true;
   }
 
-  public setToken(token: string | null) {
-    authToken = token;
+  public authenticate(
+    authToken: string | null,
+    switchToken: string | null = null,
+  ) {
+    this.authToken = authToken;
+    this.switchToken = switchToken;
     if (this.isConnectionOpen()) {
       this._send({
         action: 'authenticate',
-        token: authToken,
+        authToken: this.authToken,
+        switchToken: this.switchToken,
       });
     }
   }
@@ -735,7 +818,7 @@ export class PubSubSubscription<T> {
   constructor(
     query: string,
     callbacks: PubSubCallbacks<T>,
-    unsubscribe: () => void
+    unsubscribe: () => void,
   ) {
     this.query = query;
     this.callbacks = callbacks;