@nymphjs/client 1.0.0-beta.7 → 1.0.0-beta.70

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 type { NymphOptions, Options, Selector } from './Nymph.types';
+import type { EntityInstanceType } from './Entity';
+import type {
+  EntityConstructor,
+  EntityInterface,
+  EntityJson,
+} from './Entity.types';
+import type {
   PubSubCallbacks,
   PubSubConnectCallback,
   PubSubCountCallback,
@@ -9,15 +14,17 @@ import {
   PubSubEventType,
   PubSubRejectCallback,
   PubSubResolveCallback,
+  PubSubErrorCallback,
   PubSubSubscribable,
   PubSubUpdate,
 } from './PubSub.types';
 import { entityConstructorsToClassNames } from './utils';
-
-let authToken: string | null = null;
+import { ClientError } from './HttpRequester';
 
 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 pubsubUrl: string | undefined;
@@ -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,8 +215,8 @@ 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;
         }
@@ -242,31 +260,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 +300,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 +312,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 +364,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 +389,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 +428,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 +449,7 @@ export default class PubSub {
       }
     }
     if (
-      e.code !== 4200 &&
+      e.code !== 1000 &&
       (typeof navigator === 'undefined' || navigator.onLine)
     ) {
       if (this.connection) {
@@ -412,6 +472,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,71 +620,59 @@ 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);
+        for (let i = 0; i < current.length; i++) {
+          if (current[i] != null && current[i].guid === update.removed) {
+            current.splice(i, 1);
             return;
           }
         }
@@ -623,9 +682,9 @@ export default class PubSub {
       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);
+        for (let i = 0; i < current.length; i++) {
+          if (current[i] != null && current[i].guid === update.added) {
+            entity = current.splice(i, 1)[0].$init(update.data);
           }
         }
         if (entity == null) {
@@ -635,9 +694,9 @@ export default class PubSub {
       }
       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);
+        for (let i = 0; i < current.length; i++) {
+          if (current[i] != null && current[i].guid === update.updated) {
+            entity = current.splice(i, 1)[0].$init(update.data);
           }
         }
       }
@@ -645,8 +704,7 @@ export default class PubSub {
       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 sort = 'sort' in query[0] ? (query[0].sort as string) : 'cdate';
         const reverse = query[0].hasOwnProperty('reverse')
           ? query[0].reverse
           : false;
@@ -655,20 +713,20 @@ export default class PubSub {
         if (reverse) {
           for (
             i = 0;
-            ((oldArr[i] ?? {})[sort] ?? 0) >= (entity[sort] ?? 0) &&
-            i < oldArr.length;
+            ((current[i] ?? {})[sort] ?? 0) >= (entity[sort] ?? 0) &&
+            i < current.length;
             i++
           );
         } else {
           for (
             i = 0;
-            ((oldArr[i] ?? {})[sort] ?? 0) < (entity[sort] ?? 0) &&
-            i < oldArr.length;
+            ((current[i] ?? {})[sort] ?? 0) < (entity[sort] ?? 0) &&
+            i < current.length;
             i++
           );
         }
 
-        oldArr.splice(i, 0, entity);
+        current.splice(i, 0, entity);
       }
     }
   }
@@ -679,16 +737,21 @@ export default class PubSub {
       ? PubSubConnectCallback
       : T extends 'disconnect'
       ? PubSubDisconnectCallback
-      : never
+      : T extends 'error'
+      ? PubSubErrorCallback
+      : never,
   ) {
     const prop = (event + 'Callbacks') as T extends 'connect'
       ? 'connectCallbacks'
       : T extends 'disconnect'
       ? '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);
   }
@@ -699,16 +762,21 @@ export default class PubSub {
       ? PubSubConnectCallback
       : T extends 'disconnect'
       ? PubSubDisconnectCallback
-      : never
+      : T extends 'error'
+      ? PubSubErrorCallback
+      : never,
   ) {
     const prop = (event + 'Callbacks') as T extends 'connect'
       ? 'connectCallbacks'
       : T extends 'disconnect'
       ? '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 +784,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 +808,7 @@ export class PubSubSubscription<T> {
   constructor(
     query: string,
     callbacks: PubSubCallbacks<T>,
-    unsubscribe: () => void
+    unsubscribe: () => void,
   ) {
     this.query = query;
     this.callbacks = callbacks;

package/src/PubSub.types.ts

@@ -7,11 +7,16 @@ export type PubSubCountCallback = (count: number) => void;
 export type PubSubCallbacks<T> = [
   PubSubResolveCallback<T> | undefined,
   PubSubRejectCallback | undefined,
-  PubSubCountCallback | undefined
+  PubSubCountCallback | undefined,
 ];
-export type PubSubEventType = 'connect' | 'disconnect';
+export type PubSubEventType = 'connect' | 'disconnect' | 'error';
 export type PubSubConnectCallback = () => void;
 export type PubSubDisconnectCallback = () => void;
+/**
+ * The error event is for unknown errors. Query errors fire their own reject
+ * callbacks.
+ */
+export type PubSubErrorCallback = (err: any) => void;
 export type PubSubUpdate<T> =
   | T
   | {
@@ -31,5 +36,5 @@ export type PubSubUpdate<T> =
 export type PubSubSubscribable<T> = (
   resolve?: PubSubResolveCallback<T> | undefined,
   reject?: PubSubRejectCallback | undefined,
-  count?: PubSubCountCallback | undefined
+  count?: PubSubCountCallback | undefined,
 ) => PubSubSubscription<T>;