@nxtedition/deepstream.io-client-js 30.0.1 → 31.0.1

package/src/record/record-handler.js

@@ -10,10 +10,44 @@ import * as utils from '../utils/utils.js'
 import xuid from 'xuid'
 import * as timers from '../utils/timers.js'
 
+function noop() {}
+
 const kEmpty = Symbol('kEmpty')
 
+const OBSERVE_DEFAULTS = {
+  timeout: 2 * 60e3,
+  state: C.RECORD_STATE.SERVER,
+  dataOnly: true,
+}
+const OBSERVE2_DEFAULTS = {
+  timeout: 2 * 60e3,
+}
+const GET_DEFAULTS = {
+  timeout: 2 * 60e3,
+  first: true,
+  sync: true,
+  dataOnly: true,
+}
+const GET2_DEFAULTS = {
+  timeout: 2 * 60e3,
+  first: true,
+}
+
+function onSync(subscription) {
+  subscription.synced = true
+  onUpdate(null, subscription)
+}
+
 function onUpdate(record, subscription) {
-  if (subscription.state && record.state < subscription.state) {
+  if (!subscription.record) {
+    return
+  }
+
+  if (!subscription.synced) {
+    return
+  }
+
+  if (subscription.state && subscription.record.state < subscription.state) {
     return
   }
 
@@ -22,7 +56,9 @@ function onUpdate(record, subscription) {
     subscription.timeout = null
   }
 
-  const data = subscription.path ? record.get(subscription.path) : record.data
+  const data = subscription.path
+    ? subscription.record.get(subscription.path)
+    : subscription.record.data
 
   if (subscription.dataOnly) {
     if (data !== subscription.data) {
@@ -31,12 +67,17 @@ function onUpdate(record, subscription) {
     }
   } else {
     subscription.subscriber.next({
-      name: record.name,
-      version: record.version,
-      state: record.state,
+      name: subscription.record.name,
+      version: subscription.record.version,
+      state: subscription.record.state,
       data,
     })
   }
+
+  if (subscription.first) {
+    subscription.subscriber.complete?.()
+    subscription.unsubscribe()
+  }
 }
 
 function onTimeout(subscription) {
@@ -53,39 +94,6 @@ function onTimeout(subscription) {
   )
 }
 
-function onUpdateFast(rec, opaque) {
-  const { timeout, resolve, synced, state } = opaque
-
-  if (rec.state >= state && synced) {
-    timers.clearTimeout(timeout)
-    rec.unsubscribe(onUpdateFast, opaque)
-    rec.unref()
-    resolve(rec.data)
-  }
-}
-
-function onSyncFast(opaque) {
-  opaque.synced = true
-  onUpdateFast(opaque.rec, opaque)
-}
-
-function onTimeoutFast(opaque) {
-  const { rec, synced, resolve } = opaque
-  rec.unsubscribe(onUpdateFast, opaque)
-  rec.unref()
-
-  let err
-  if (rec.state < opaque.state) {
-    err = new Error(`timeout state: ${opaque.rec.name} [${opaque.rec.state}<${opaque.state}]`)
-  } else if (!synced) {
-    err = new Error(`timeout sync: ${opaque.rec.name} `)
-  } else {
-    err = new Error('timeout')
-  }
-
-  resolve(Promise.reject(Object.assign(err, { code: 'ETIMEDOUT' })))
-}
-
 class RecordHandler {
   constructor(options, connection, client) {
     this.JSON = jsonPath
@@ -95,12 +103,12 @@ class RecordHandler {
     this._options = options
     this._connection = connection
     this._client = client
-    this._recordsByName = new Map()
-    this._recordsByKey = new Map()
+    this._records = new Map()
     this._listeners = new Map()
     this._pruning = new Set()
     this._patching = new Map()
     this._updating = new Map()
+    this._putting = new Map()
 
     this._connected = 0
     this._stats = {
@@ -133,7 +141,7 @@ class RecordHandler {
 
       for (const rec of pruning) {
         rec._$dispose()
-        this._recordsByName.delete(rec.name)
+        this._records.delete(rec.name)
       }
 
       this._stats.pruning -= pruning.size
@@ -161,13 +169,16 @@ class RecordHandler {
   }
 
   _onUpdating(rec, value) {
+    const callbacks = this._updating.get(rec)
+
     if (value) {
+      invariant(!callbacks, 'updating callbacks must not exist')
       this._stats.updating += 1
       this._updating.set(rec, [])
     } else {
-      this._stats.updating -= 1
+      invariant(callbacks, 'updating callbacks must exist')
 
-      const callbacks = this._updating.get(rec)
+      this._stats.updating -= 1
       this._updating.delete(rec)
       for (const callback of callbacks) {
         callback()
@@ -216,14 +227,13 @@ class RecordHandler {
       `invalid name ${name}`,
     )
 
-    let record = this._recordsByName.get(name)
+    let record = this._records.get(name)
 
     if (!record) {
       record = new Record(name, this)
       this._stats.records += 1
       this._stats.created += 1
-      this._recordsByName.set(record.name, record)
-      this._recordsByKey.set(record.name, record)
+      this._records.set(name, record)
     }
 
     return record.ref()
@@ -256,139 +266,148 @@ class RecordHandler {
     this._stats.listeners += 1
     this._listeners.set(pattern, listener)
 
-    return () => {
+    const disposer = () => {
       listener._$destroy()
 
       this._stats.listeners -= 1
       this._listeners.delete(pattern)
     }
+    disposer[Symbol.dispose] = disposer
+
+    return disposer
   }
 
   async sync(opts) {
     // TODO (fix): Sync pending? What about VOID state?
-
-    let onAbort
+    // TODO (perf): Slow implementation...
 
     const signal = opts?.signal
     const timeout = opts?.timeout
 
-    const signalPromise = signal
-      ? new Promise((resolve, reject) => {
-          onAbort = () => {
-            reject(signal.reason ?? new utils.AbortError())
-          }
-          signal.addEventListener('abort', onAbort)
-        })
-      : null
-    signalPromise?.catch(() => {})
-
+    let disposers
     try {
+      const signalPromise = signal
+        ? new Promise((resolve, reject) => {
+            const onAbort = () => reject(signal.reason ?? new utils.AbortError())
+            signal.addEventListener('abort', onAbort)
+            disposers ??= []
+            disposers.push(() => signal.removeEventListener('abort', onAbort))
+          })
+        : null
+
+      signalPromise?.catch(noop)
+
       if (this._patching.size) {
-        let patchingTimeout
-        const patching = [...this._patching.values()]
-        await Promise.race([
-          Promise.all(
-            patching.map((callbacks) => new Promise((resolve) => callbacks.push(resolve))),
-          ),
-          new Promise((resolve) => {
-            patchingTimeout = timers.setTimeout(
-              () => {
+        let promises
+
+        {
+          const patchingPromises = []
+          for (const callbacks of this._patching.values()) {
+            patchingPromises.push(new Promise((resolve) => callbacks.push(resolve)))
+          }
+          promises ??= []
+          promises.push(Promise.all(patchingPromises))
+        }
+
+        if (timeout) {
+          promises.push(
+            new Promise((resolve) => {
+              const patchingTimeout = timers.setTimeout(() => {
                 this._client._$onError(
                   C.TOPIC.RECORD,
                   C.EVENT.TIMEOUT,
-                  Object.assign(new Error('sync patching timeout'), {
-                    data: { patching, timeout },
-                  }),
+                  new Error('sync patching timeout'),
                 )
                 resolve(null)
-              },
-              timeout ?? 2 * 60e3,
-            )
-          }),
-          signalPromise,
-        ]).finally(() => {
-          timers.clearTimeout(patchingTimeout)
-        })
+              }, timeout)
+              disposers ??= []
+              disposers.push(() => timers.clearTimeout(patchingTimeout))
+            }),
+          )
+        }
+
+        if (signalPromise) {
+          promises ??= []
+          promises.push(signalPromise)
+        }
+
+        if (promises) {
+          await Promise.race(promises)
+        }
       }
 
       if (this._updating.size) {
-        let updatingTimeout
-        const updating = [...this._updating.values()]
-        await Promise.race([
-          Promise.all(
-            updating.map((callbacks) => new Promise((resolve) => callbacks.push(resolve))),
-          ),
-          new Promise((resolve) => {
-            updatingTimeout = timers.setTimeout(
-              () => {
+        let promises
+
+        {
+          const updatingPromises = []
+          for (const callbacks of this._updating.values()) {
+            updatingPromises.push(new Promise((resolve) => callbacks.push(resolve)))
+          }
+          promises ??= []
+          promises.push(Promise.all(updatingPromises))
+        }
+
+        if (timeout) {
+          promises ??= []
+          promises.push(
+            new Promise((resolve) => {
+              const updatingTimeout = timers.setTimeout(() => {
                 this._client._$onError(
                   C.TOPIC.RECORD,
                   C.EVENT.TIMEOUT,
-                  Object.assign(new Error('sync updating timeout'), {
-                    data: { updating, timeout },
-                  }),
+                  new Error('sync updating timeout'),
                 )
                 resolve(null)
-              },
-              timeout ?? 2 * 60e3,
-            )
-          }),
-          signalPromise,
-        ]).finally(() => {
-          timers.clearTimeout(updatingTimeout)
-        })
-      }
-
-      let serverTimeout
-      const token = xuid()
-      return await Promise.race([
-        await new Promise((resolve) => {
-          this._syncEmitter.once(token, resolve)
-          this._connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.SYNC, [token])
-        }),
-        new Promise((resolve) => {
-          serverTimeout = timers.setTimeout(
-            () => {
-              this._client._$onError(
-                C.TOPIC.RECORD,
-                C.EVENT.TIMEOUT,
-                Object.assign(new Error('sync server timeout'), { data: { token, timeout } }),
-              )
-              resolve(null)
-            },
-            timeout ?? 2 * 60e3,
+              }, timeout)
+              disposers ??= []
+              disposers.push(() => timers.clearTimeout(updatingTimeout))
+            }),
           )
-        }),
-        signalPromise,
-      ]).finally(() => {
-        timers.clearTimeout(serverTimeout)
-      })
-    } finally {
-      if (onAbort) {
-        signal?.removeEventListener('abort', onAbort)
+        }
+
+        if (promises) {
+          await Promise.race(promises)
+        }
       }
-    }
-  }
 
-  _sync(callback, opaque) {
-    this._syncQueue.push(callback, opaque)
+      {
+        const syncPromise = new Promise((resolve) => this._sync(resolve))
+
+        let promises
+
+        if (timeout) {
+          promises ??= []
+          promises.push(
+            new Promise((resolve, reject) => {
+              const serverTimeout = timers.setTimeout(() => {
+                reject(new Error('sync server timeout'))
+              }, timeout)
+              disposers ??= []
+              disposers.push(() => timers.clearTimeout(serverTimeout))
+            }),
+          )
+        }
 
-    if (this._syncQueue.length > 2) {
-      return
-    }
+        if (signalPromise) {
+          promises ??= []
+          promises.push(signalPromise)
+        }
 
-    setTimeout(() => {
-      // Token must be universally unique until deepstream properly separates
-      // sync requests from different sockets.
-      const token = xuid()
-      const queue = this._syncQueue.splice(0)
-      this._syncEmitter.once(token, () => {
-        for (let n = 0; n < queue.length; n += 2) {
-          queue[n](queue[n + 1])
+        if (promises) {
+          promises.push(syncPromise)
+          await Promise.race(promises)
+        } else {
+          await syncPromise
         }
-      })
-      this._connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.SYNC, [token, 'WEAK'])
-    }, 1)
+      }
+    } finally {
+      if (disposers) {
+        for (const disposer of disposers) {
+          disposer()
+        }
+      }
+    }
   }
 
   set(name, ...args) {
@@ -400,6 +419,35 @@ class RecordHandler {
     }
   }
 
+  put(name, version, data, parent) {
+    if (typeof name !== 'string' || name.startsWith('_')) {
+      throw new Error('invalid argument: name')
+    }
+
+    if (typeof version !== 'string' || !/^\d+-/.test(version)) {
+      throw new Error('invalid argument: verison')
+    }
+
+    if (typeof data !== 'object' && data != null) {
+      throw new Error('invalid argument: data')
+    }
+
+    if (parent != null && (typeof version !== 'string' || !/^\d+-/.test(version))) {
+      throw new Error('invalid argument: parent')
+    }
+
+    const update = [name, version, jsonPath.stringify(data)]
+
+    if (parent) {
+      update.push(parent)
+    }
+
+    this._connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.PUT, update)
+
+    this._putting.set(update, [])
+    this._sync((update) => this._putting.delete(update), 'WEAK', update)
+  }
+
   /**
    *
    * @param {*} name
@@ -424,14 +472,7 @@ class RecordHandler {
    * @returns {rxjs.Observable}
    */
   observe(...args) {
-    return this._observe(
-      {
-        state: C.RECORD_STATE.SERVER,
-        timeout: 2 * 60e3,
-        dataOnly: true,
-      },
-      ...args,
-    )
+    return this._observe(OBSERVE_DEFAULTS, ...args)
   }
 
   /**
@@ -439,47 +480,9 @@ class RecordHandler {
    * @returns {Promise}
    */
   get(...args) {
-    if (args.length === 1 || (args.length === 2 && typeof args[1] === 'number')) {
-      return new Promise((resolve) => {
-        const rec = this.getRecord(args[0])
-        const state = args.length === 2 ? args[1] : C.RECORD_STATE.SERVER
-        // TODO (perf): We could also skip sync if state is less than SERVER. However,
-        // there is a potential race where we receive an UPDATE for a previous SUBSCRIBE.
-        // Unsure how to avoid that. Keep it simple for now and always sync regardless of
-        // current state.
-        const synced = state < C.RECORD_STATE.SERVER
-
-        if (rec.state >= state && synced) {
-          rec.unref()
-          resolve(rec.data)
-        } else {
-          const opaque = {
-            rec,
-            state,
-            resolve,
-            timeout: null,
-            synced,
-          }
-          opaque.timeout = timers.setTimeout(onTimeoutFast, 2 * 60e3, opaque)
-          rec.subscribe(onUpdateFast, opaque)
-
-          if (!opaque.synced) {
-            this._sync(onSyncFast, opaque)
-          }
-        }
-      })
-    } else {
-      // Slow path...
-      // TODO (fix): Missing sync..
-      return new Promise((resolve, reject) => {
-        this.observe(...args)
-          .pipe(rxjs.first())
-          .subscribe({
-            next: resolve,
-            error: reject,
-          })
-      })
-    }
+    return new Promise((resolve, reject) => {
+      this._subscribe({ next: resolve, error: reject }, GET_DEFAULTS, ...args)
+    })
   }
 
   /**
@@ -488,12 +491,7 @@ class RecordHandler {
    */
   get2(...args) {
     return new Promise((resolve, reject) => {
-      this.observe2(...args)
-        .pipe(rxjs.first())
-        .subscribe({
-          next: resolve,
-          error: reject,
-        })
+      this._subscribe({ next: resolve, error: reject }, GET2_DEFAULTS, ...args)
     })
   }
 
@@ -502,24 +500,29 @@ class RecordHandler {
    * @returns {rxjs.Observable<{ name: string, version: string, state: Number, data: any}>}
    */
   observe2(...args) {
-    return this._observe(
-      {
-        timeout: 2 * 60e3,
-      },
-      ...args,
-    )
+    return this._observe(OBSERVE2_DEFAULTS, ...args)
   }
 
   /**
    * @returns {rxjs.Observable}
    */
-  // TODO (perf): Avoid rest parameters.
   _observe(defaults, name, ...args) {
+    return new rxjs.Observable((subscriber) => {
+      this._subscribe(subscriber, defaults, name, ...args)
+    })
+  }
+
+  /**
+   * @returns {{ unsubscribe: Function }}
+   */
+  _subscribe(subscriber, defaults, name, ...args) {
     let path
-    let state = defaults ? defaults.state : undefined
+    let state = defaults?.state
     let signal
-    let timeout = defaults ? defaults.timeout : undefined
-    let dataOnly = defaults ? defaults.dataOnly : undefined
+    let timeout = defaults?.timeout
+    let dataOnly = defaults?.dataOnly
+    let sync = defaults?.sync
+    let first = defaults?.first
 
     let idx = 0
 
@@ -559,71 +562,90 @@ class RecordHandler {
       if (options.dataOnly !== undefined) {
         dataOnly = options.dataOnly
       }
+
+      if (options.sync !== undefined) {
+        sync = options.sync
+      }
+
+      if (options.first !== undefined) {
+        first = options.first
+      }
     }
 
     if (typeof state === 'string') {
       state = C.RECORD_STATE[state.toUpperCase()]
     }
 
-    // TODO (perf): Avoid subscribe closure allocation.
-    return new rxjs.Observable((subscriber) => {
-      const subscription = {
-        subscriber,
-        path,
-        state,
-        signal,
-        dataOnly,
-        data: kEmpty,
-        timeout: null,
-        /** @type {Record?} */ record: null,
-        /** @type {Function?} */ abort: null,
-        unsubscribe() {
-          if (this.timeout) {
-            timers.clearTimeout(this.timeout)
-            this.timeout = null
-          }
+    // TODO (perf): Make a class
+    const subscription = {
+      subscriber,
+      first,
+      path,
+      state,
+      synced: false,
+      signal,
+      dataOnly,
+      data: kEmpty,
+      /** @type {NodeJS.Timeout|Timeout|null} */
+      timeout: null,
+      /** @type {Record?} */
+      record: null,
+      /** @type {Function?} */
+      abort: null,
+      unsubscribe() {
+        if (this.timeout) {
+          timers.clearTimeout(this.timeout)
+          this.timeout = null
+        }
 
-          if (this.signal) {
-            utils.removeAbortListener(this.signal, this.abort)
-            this.signal = null
-            this.abort = null
-          }
+        if (this.signal) {
+          utils.removeAbortListener(this.signal, this.abort)
+          this.signal = null
+          this.abort = null
+        }
 
-          if (this.record) {
-            this.record.unsubscribe(onUpdate, this)
-            this.record.unref()
-            this.record = null
-          }
-        },
-      }
+        if (this.record) {
+          this.record.unsubscribe(onUpdate, this)
+          this.record.unref()
+          this.record = null
+        }
+      },
+    }
 
-      const record = (subscription.record = this.getRecord(name).subscribe(onUpdate, subscription))
+    subscription.record = this.getRecord(name).subscribe(onUpdate, subscription)
 
-      if (timeout > 0 && state && record.state < state) {
-        // TODO (perf): Avoid Timer allocation.
-        subscription.timeout = timers.setTimeout(onTimeout, timeout, subscription)
-      }
+    const record = subscription.record
 
-      if (record.version) {
-        onUpdate(record, subscription)
-      }
+    if (sync && record.state >= C.RECORD_STATE.SERVER) {
+      this._sync(onSync, sync === true ? 'WEAK' : sync, subscription)
+    } else {
+      subscription.synced = true
+    }
 
-      if (signal) {
-        // TODO (perf): Avoid abort closure allocation.
-        subscription.abort = () => subscriber.error(new utils.AbortError())
-        utils.addAbortListener(signal, subscription.abort)
-      }
+    if (timeout > 0 && state && record.state < state) {
+      // TODO (perf): Avoid Timer allocation.
+      subscription.timeout = timers.setTimeout(onTimeout, timeout, subscription)
+    }
 
-      return subscription
-    })
+    if (signal) {
+      // TODO (perf): Avoid abort closure allocation.
+      subscription.abort = () => subscriber.error(new utils.AbortError())
+      utils.addAbortListener(signal, subscription.abort)
+    }
+
+    if (record.version) {
+      onUpdate(null, subscription)
+    }
+
+    return subscription
   }
 
   _$handle(message) {
-    let key
+    let name
     if (message.action === C.ACTIONS.ERROR) {
-      key = message.data[1]
+      name = message.data[1]
     } else {
-      key = message.data[0]
+      name = message.data[0]
     }
 
     if (message.action === C.ACTIONS.SYNC) {
@@ -631,12 +653,12 @@ class RecordHandler {
       return true
     }
 
-    const listener = this._listeners.get(key)
+    const listener = this._listeners.get(name)
     if (listener && listener._$onMessage(message)) {
       return true
     }
 
-    const record = this._recordsByKey.get(key)
+    const record = this._records.get(name)
     if (record && record._$onMessage(message)) {
       return true
     }
@@ -649,12 +671,17 @@ class RecordHandler {
       listener._$onConnectionStateChange(connected)
     }
 
-    for (const record of this._recordsByName.values()) {
+    for (const record of this._records.values()) {
       record._$onConnectionStateChange(connected)
     }
 
     if (connected) {
       this._connected = Date.now()
+
+      for (const update of this._putting.keys()) {
+        this._connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.PUT, update)
+      }
+
       for (const token of this._syncEmitter.eventNames()) {
         this._connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.SYNC, [token])
       }
@@ -662,6 +689,35 @@ class RecordHandler {
       this._connected = 0
     }
   }
+
+  _sync(callback, type, opaque) {
+    this._syncQueue.push(callback, opaque)
+
+    if (this._syncQueue.length > 2) {
+      return
+    }
+
+    if (type == null) {
+      type = null
+    } else if (type === true) {
+      type = 'WEAK'
+    } else if (type !== 'WEAK' && type !== 'STRONG') {
+      throw new Error(`invalid sync type: ${type}`)
+    }
+
+    setTimeout(() => {
+      // Token must be universally unique until deepstream properly separates
+      // sync requests from different sockets.
+      const token = xuid()
+      const queue = this._syncQueue.splice(0)
+      this._syncEmitter.once(token, () => {
+        for (let n = 0; n < queue.length; n += 2) {
+          queue[n](queue[n + 1])
+        }
+      })
+      this._connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.SYNC, type ? [token, type] : [token])
+    }, 1)
+  }
 }
 
 export default RecordHandler