@nxtedition/deepstream.io-client-js 26.0.18 → 26.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/deepstream.io-client-js",
-  "version": "26.0.18",
+  "version": "26.0.21",
   "description": "the javascript client for deepstream.io",
   "homepage": "http://deepstream.io",
   "type": "module",

package/src/message/connection.js

@@ -2,7 +2,6 @@ import * as utils from '../utils/utils.js'
 import * as messageParser from './message-parser.js'
 import * as messageBuilder from './message-builder.js'
 import * as C from '../constants/constants.js'
-import xxhash from 'xxhash-wasm'
 import FixedQueue from '../utils/fixed-queue.js'
 import Emitter from 'component-emitter2'
 
@@ -38,12 +37,6 @@ export default function Connection(client, url, options) {
   this._url = new URL(url)
 
   this._state = C.CONNECTION_STATE.CLOSED
-
-  this.hasher = null
-  xxhash().then((hasher) => {
-    this.hasher = hasher
-    this._createEndpoint()
-  })
 }
 
 Emitter(Connection.prototype)

package/src/message/message-builder.js

@@ -1,25 +1,104 @@
 import * as C from '../constants/constants.js'
+import * as utils from '../utils/utils.js'
+import varint from 'varint'
 
-const SEP = C.MESSAGE_PART_SEPERATOR
+const poolEncoder = new globalThis.TextEncoder()
+
+// TODO (fix): Don't assume maxMesageSize is 1MB
+const maxMessageSize = 1024 * 1024
+const poolSize = maxMessageSize * 4
+
+let poolBuffer
+let poolView
+let poolOffset
+
+function reallocPool() {
+  poolBuffer = utils.isNode
+    ? globalThis.Buffer.allocUnsafe(poolSize)
+    : new Uint8Array(new ArrayBuffer(poolSize))
+  poolView = new DataView(poolBuffer.buffer)
+  poolOffset = 0
+}
+
+function alignPool() {
+  // Ensure aligned slices
+  if (poolOffset & 0x7) {
+    poolOffset |= 0x7
+    poolOffset++
+  }
+}
+
+function writeString(dst, str, offset) {
+  if (utils.isNode) {
+    return dst.write(str, offset)
+  } else {
+    const res = poolEncoder.encodeInto(str, new Uint8Array(dst.buffer, offset))
+    return res.written
+  }
+}
 
 export function getMsg(topic, action, data) {
   if (data && !(data instanceof Array)) {
     throw new Error('data must be an array')
   }
 
-  const sendData = [topic, action]
+  if (!poolBuffer || poolOffset + maxMessageSize > poolSize) {
+    reallocPool()
+  } else {
+    alignPool()
+  }
+
+  const start = poolOffset
+
+  const headerSize = 8
+  for (let n = 0; n < headerSize; n++) {
+    poolBuffer[poolOffset++] = 0
+  }
+
+  let headerPos = start
+  poolBuffer[headerPos++] = 128 + headerSize
+
+  poolBuffer[poolOffset++] = topic.charCodeAt(0)
+  poolBuffer[poolOffset++] = 31
+  for (let n = 0; n < action.length; n++) {
+    poolBuffer[poolOffset++] = action.charCodeAt(n)
+  }
 
   if (data) {
     for (let i = 0; i < data.length; i++) {
-      if (typeof data[i] === 'object') {
-        sendData.push(JSON.stringify(data[i]))
+      const type = typeof data[i]
+      let len
+      if (data[i] == null) {
+        poolBuffer[poolOffset++] = 31
+        len = 0
+      } else if (type === 'object') {
+        poolBuffer[poolOffset++] = 31
+        len = writeString(poolBuffer, JSON.stringify(data[i]), poolOffset)
+      } else if (type === 'bigint') {
+        poolBuffer[poolOffset++] = 31
+        poolView.setBigUint64(poolOffset, data[i], false)
+        len = 8
+      } else if (type === 'string') {
+        poolBuffer[poolOffset++] = 31
+        len = writeString(poolBuffer, data[i], poolOffset)
       } else {
-        sendData.push(data[i])
+        throw new Error('invalid data')
+      }
+      poolOffset += len
+
+      varint.encode(len + 1, poolBuffer, headerPos)
+      headerPos += varint.encode.bytes
+      if (headerPos - start >= headerSize) {
+        throw new Error('header too large')
+      }
+
+      if (poolOffset >= poolSize) {
+        throw new Error('message too large')
       }
     }
   }
 
-  return sendData.join(SEP)
+  return new Uint8Array(poolBuffer.buffer, start, poolOffset - start)
 }
 
 export function typed(value) {

package/src/record/record-handler.js

@@ -97,11 +97,19 @@ class RecordHandler {
     this._connection = connection
     this._client = client
     this._records = new Map()
+    this._cache = new Map()
     this._listeners = new Map()
     this._pruning = new Set()
     this._patching = new Map()
     this._updating = new Map()
 
+    this._registry = new FinalizationRegistry((name) => {
+      const entry = this._cache.get(name)
+      if (entry && entry.deref && entry.deref() === undefined) {
+        this._cache.delete(name)
+      }
+    })
+
     this._connected = 0
     this._stats = {
       updating: 0,
@@ -134,6 +142,11 @@ class RecordHandler {
       for (const rec of pruning) {
         rec._$dispose()
         this._records.delete(rec.name)
+
+        if (!this._cache.has(rec.name)) {
+          this._cache.set(rec.name, new WeakRef(rec))
+          this._registry.register(rec, rec.name)
+        }
       }
 
       this._stats.pruning -= pruning.size
@@ -219,7 +232,7 @@ class RecordHandler {
     let record = this._records.get(name)
 
     if (!record) {
-      record = new Record(name, this)
+      record = this._cache.get(name)?.deref() ?? new Record(name, this)
       this._stats.records += 1
       this._stats.created += 1
       this._records.set(name, record)

package/src/utils/multicast-listener.js

@@ -1,5 +1,6 @@
+import * as rxjs from 'rxjs'
 import * as C from '../constants/constants.js'
-import rxjs from 'rxjs'
+import { h64ToString } from '../utils/utils.js'
 
 export default class Listener {
   constructor(topic, pattern, callback, handler, { recursive = false, stringify = null } = {}) {
@@ -151,7 +152,7 @@ export default class Listener {
             }
 
             const body = typeof value !== 'string' ? this._stringify(value) : value
-            const hash = this._connection.hasher.h64ToString(body)
+            const hash = h64ToString(body)
             const version = `INF-${hash}`
 
             if (provider.version !== version) {

package/src/utils/unicast-listener.js

@@ -1,9 +1,9 @@
+import * as rxjs from 'rxjs'
 import * as C from '../constants/constants.js'
-import rx from 'rxjs/operators'
-import rxjs from 'rxjs'
+import { h64ToString } from '../utils/utils.js'
 
-const PIPE = rxjs.pipe(
-  rx.map((value) => {
+const valuePipe = rxjs.pipe(
+  rxjs.map((value) => {
     let data
     if (value && typeof value === 'string') {
       if (value.charAt(0) !== '{' && value.charAt(0) !== '[') {
@@ -18,7 +18,7 @@ const PIPE = rxjs.pipe(
 
     return data
   }),
-  rx.distinctUntilChanged(),
+  rxjs.distinctUntilChanged(),
 )
 
 export default class Listener {
@@ -69,14 +69,14 @@ export default class Listener {
       }
 
       if (value$) {
-        const subscription = value$.pipe(PIPE).subscribe({
+        const subscription = value$.pipe(valuePipe).subscribe({
           next: (data) => {
             if (data == null) {
               this._connection.sendMsg(this._topic, C.ACTIONS.LISTEN_REJECT, [this._pattern, name])
               this._subscriptions.delete(name)
               subscription.unsubscribe()
             } else {
-              const version = `INF-${this._connection.hasher.h64ToString(data)}`
+              const version = `INF-${h64ToString(data)}`
               this._connection.sendMsg(this._topic, C.ACTIONS.UPDATE, [name, version, data])
             }
           },

package/src/utils/utils.js

@@ -1,3 +1,5 @@
+import xxhash from 'xxhash-wasm'
+
 const NODE_ENV = typeof process !== 'undefined' && process.env && process.env.NODE_ENV
 export const isNode = typeof process !== 'undefined' && process.toString() === '[object process]'
 export const isProduction = NODE_ENV === 'production'
@@ -174,3 +176,17 @@ export function removeAbortListener(signal, handler) {
     }
   }
 }
+
+const HASHER = await xxhash()
+
+export function h64(str) {
+  return HASHER.h64(str)
+}
+
+export function h64ToString(str) {
+  return HASHER.h64ToString(str)
+}
+
+export function h64Raw(str) {
+  return HASHER.h64Raw(str)
+}