@nxtedition/deepstream.io-client-js 26.0.2 → 26.0.4

package/package.json

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

package/src/client.js

@@ -36,13 +36,13 @@ const Client = function (url, options) {
 Emitter(Client.prototype)
 
 Object.defineProperty(Client.prototype, 'stats', {
-  get: function stats() {
+  get: function stats () {
     return {
       record: this.record.stats,
       rpc: this.rpc.stats,
-      event: this.event.stats,
+      event: this.event.stats
     }
-  },
+  }
 })
 
 Client.prototype.login = function (authParamsOrCallback, callback) {
@@ -127,7 +127,7 @@ Client.prototype._getOptions = function (options) {
   return mergedOptions
 }
 
-function createDeepstream(url, options) {
+function createDeepstream (url, options) {
   return new Client(url, options)
 }
 

package/src/default-options.js

@@ -5,5 +5,5 @@ export default {
   maxPacketSize: 1024 * 1024,
   batchSize: 4096,
   schedule: null,
-  logger: null,
+  logger: null
 }

package/src/event/event-handler.js

@@ -1,6 +1,6 @@
 import * as C from '../constants/constants.js'
 import * as messageBuilder from '../message/message-builder.js'
-import { convertTyped } from '../message/message-parser.js'
+import messageParser from '../message/message-parser.js'
 import MulticastListener from '../utils/multicast-listener.js'
 import UnicastListener from '../utils/unicast-listener.js'
 import EventEmitter from 'component-emitter2'
@@ -13,7 +13,7 @@ const EventHandler = function (options, connection, client) {
   this._emitter = new EventEmitter()
   this._listeners = new Map()
   this._stats = {
-    emitted: 0,
+    emitted: 0
   }
 
   this.subscribe = this.subscribe.bind(this)
@@ -26,19 +26,19 @@ const EventHandler = function (options, connection, client) {
 }
 
 Object.defineProperty(EventHandler.prototype, 'connected', {
-  get: function connected() {
+  get: function connected () {
     return this._client.getConnectionState() === C.CONNECTION_STATE.OPEN
-  },
+  }
 })
 
 Object.defineProperty(EventHandler.prototype, 'stats', {
-  get: function stats() {
+  get: function stats () {
     return {
       ...this._stats,
       listeners: this._listeners.size,
-      events: this._emitter.eventNames().length,
+      events: this._emitter.eventNames().length
     }
-  },
+  }
 })
 
 EventHandler.prototype.subscribe = function (name, callback) {
@@ -143,7 +143,7 @@ EventHandler.prototype._$handle = function (message) {
 
   if (message.action === C.ACTIONS.EVENT) {
     if (message.data && message.data.length === 2) {
-      this._emitter.emit(name, convertTyped(data, this._client))
+      this._emitter.emit(name, messageParser.convertTyped(data, this._client))
     } else {
       this._emitter.emit(name)
     }

package/src/message/connection.js

@@ -1,11 +1,10 @@
 import * as utils from '../utils/utils.js'
-import { convertTyped } from './message-parser.js'
+import 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'
-import varint from 'varint'
 
 const BrowserWebSocket = globalThis.WebSocket || globalThis.MozWebSocket
 const NodeWebSocket = utils.isNode ? await import('ws').then((x) => x.default) : null
@@ -24,8 +23,12 @@ const Connection = function (client, url, options) {
   this._tooManyAuthAttempts = false
   this._connectionAuthenticationTimeout = false
   this._challengeDenied = false
-  this._decoder = new TextDecoder()
-  this._encoder = new TextEncoder()
+  this._message = {
+    raw: null,
+    topic: null,
+    action: null,
+    data: null
+  }
   this._recvQueue = new FixedQueue()
   this._reconnectTimeout = null
   this._reconnectionAttempt = 0
@@ -46,9 +49,9 @@ Emitter(Connection.prototype)
 
 // TODO (fix): Remove
 Object.defineProperty(Connection.prototype, 'connected', {
-  get: function connected() {
+  get: function connected () {
     return this._state === C.CONNECTION_STATE.OPEN
-  },
+  }
 })
 
 Connection.prototype.getState = function () {
@@ -91,7 +94,7 @@ Connection.prototype.close = function () {
 Connection.prototype._createEndpoint = function () {
   if (utils.isNode) {
     this._endpoint = new NodeWebSocket(this._url, {
-      generateMask() {},
+      generateMask () {}
     })
   } else {
     this._endpoint = new BrowserWebSocket(this._url)
@@ -103,8 +106,9 @@ Connection.prototype._createEndpoint = function () {
   this._endpoint.onerror = this._onError.bind(this)
   this._endpoint.onclose = this._onClose.bind(this)
 
+  const decoder = new TextDecoder()
   this._endpoint.onmessage = ({ data }) => {
-    this._onMessage(data)
+    this._onMessage(typeof data === 'string' ? data : decoder.decode(data))
   }
 }
 
@@ -113,7 +117,12 @@ Connection.prototype.send = function (message) {
 
   if (message.length > maxPacketSize) {
     const err = new Error(`Packet to big: ${message.length} > ${maxPacketSize}`)
-    this._client._$onError(C.TOPIC.CONNECTION, C.EVENT.CONNECTION_ERROR, err, message)
+    this._client._$onError(
+      C.TOPIC.CONNECTION,
+      C.EVENT.CONNECTION_ERROR,
+      err,
+      message.split(C.MESSAGE_PART_SEPERATOR).map((x) => x.slice(0, 256))
+    )
     return false
   }
 
@@ -161,10 +170,10 @@ Connection.prototype._sendAuthParams = function () {
   this._setState(C.CONNECTION_STATE.AUTHENTICATING)
   const authMessage = messageBuilder.getMsg(C.TOPIC.AUTH, C.ACTIONS.REQUEST, [
     this._authParams,
-    '26.0.0', // TODO (fix): How to read from package.json?
+    '24.3.1', // TODO (fix): How to read from package.json?
     utils.isNode
       ? `Node/${process.version}`
-      : globalThis.navigator && globalThis.navigator.userAgent,
+      : globalThis.navigator && globalThis.navigator.userAgent
   ])
   this._submit(authMessage)
 }
@@ -206,60 +215,13 @@ Connection.prototype._onClose = function () {
   }
 }
 
-Connection.prototype._onMessage = function (raw) {
-  if (typeof raw === 'string') {
-    raw = this._encoder.encode(raw)
-  } else if (!utils.isNode) {
-    raw = new Uint8Array(raw)
-  }
-
-  const len = raw.byteLength
-
-  const start = 0
-
-  let pos = start
-
-  let headerSize = 0
-  if (raw[pos] >= 128) {
-    headerSize = raw[pos] - 128
-    pos += headerSize
-  }
-
-  // TODO (perf): Use numbers instead of string..
-  const topic = String.fromCharCode(raw[pos++])
-  pos++
-
-  let action = ''
-  while (pos < len && raw[pos] !== 31) {
-    // TODO (perf): Use numbers instead of string..
-    action += String.fromCharCode(raw[pos++])
-  }
-  pos++
-
-  // TODO (fix): Validate topic and action
-
-  let data
-
-  // TODO (fix): Don't stringify binary data...
-
-  if (headerSize > 0) {
-    data = []
-    let headerPos = start + 1
-    while (headerPos < headerSize) {
-      const len = varint.decode(raw, headerPos)
-      headerPos += varint.decode.bytes
-      if (len === 0) {
-        break
-      }
-      data.push(this._decoder.decode(raw.subarray(pos, pos + len - 1)))
-      pos += len
-    }
-  } else {
-    data =
-      pos < len ? this._decoder.decode(raw.subarray(pos, len)).split(C.MESSAGE_PART_SEPERATOR) : []
+Connection.prototype._onMessage = function (data) {
+  // Remove MESSAGE_SEPERATOR if exists.
+  if (data.charCodeAt(data.length - 1) === 30) {
+    data = data.slice(0, -1)
   }
 
-  this._recvQueue.push({ topic, action, data })
+  this._recvQueue.push(data)
   if (!this._processingRecv) {
     this._processingRecv = true
     this._schedule(this._recvMessages)
@@ -283,19 +245,20 @@ Connection.prototype._recvMessages = function (deadline) {
       continue
     }
 
-    if (message === C.TOPIC.ERROR) {
-      this._client._$onError(C.TOPIC.ERROR, message.action, new Error('Message error'), message)
-      continue
+    if (this._logger) {
+      this._logger.trace(message, 'receive')
     }
 
-    this.emit('recv', message)
+    messageParser.parseMessage(message, this._client, this._message)
+
+    this.emit('recv', this._message)
 
-    if (message.topic === C.TOPIC.CONNECTION) {
-      this._handleConnectionResponse(message)
-    } else if (message.topic === C.TOPIC.AUTH) {
-      this._handleAuthResponse(message)
+    if (this._message.topic === C.TOPIC.CONNECTION) {
+      this._handleConnectionResponse(this._message)
+    } else if (this._message.topic === C.TOPIC.AUTH) {
+      this._handleAuthResponse(this._message)
     } else {
-      this._client._$onMessage(message)
+      this._client._$onMessage(this._message)
     }
   }
 
@@ -313,7 +276,7 @@ Connection.prototype._handleConnectionResponse = function (message) {
   } else if (message.action === C.ACTIONS.CHALLENGE) {
     this._setState(C.CONNECTION_STATE.CHALLENGING)
     this._submit(
-      messageBuilder.getMsg(C.TOPIC.CONNECTION, C.ACTIONS.CHALLENGE_RESPONSE, [this._url]),
+      messageBuilder.getMsg(C.TOPIC.CONNECTION, C.ACTIONS.CHALLENGE_RESPONSE, [this._url])
     )
   } else if (message.action === C.ACTIONS.REJECTION) {
     this._challengeDenied = true
@@ -352,7 +315,7 @@ Connection.prototype._getAuthData = function (data) {
   if (data === undefined) {
     return null
   } else {
-    return convertTyped(data, this._client)
+    return messageParser.convertTyped(data, this._client)
   }
 }
 
@@ -388,8 +351,8 @@ Connection.prototype._tryReconnect = function () {
       },
       Math.min(
         this._options.maxReconnectInterval,
-        this._options.reconnectIntervalIncrement * this._reconnectionAttempt,
-      ),
+        this._options.reconnectIntervalIncrement * this._reconnectionAttempt
+      )
     )
     this._reconnectionAttempt++
   } else {

package/src/message/message-builder.js

@@ -9,7 +9,7 @@ let poolBuffer
 let poolView
 let poolOffset
 
-function allocPool(size) {
+function allocPool (size) {
   poolSize = size || poolSize || 1024 * 1024
   poolBuffer = utils.isNode
     ? globalThis.Buffer.allocUnsafe(poolSize)
@@ -18,7 +18,7 @@ function allocPool(size) {
   poolOffset = 0
 }
 
-function alignPool() {
+function alignPool () {
   // Ensure aligned slices
   if (poolOffset & 0x7) {
     poolOffset |= 0x7
@@ -26,7 +26,7 @@ function alignPool() {
   }
 }
 
-function writeString(dst, str, offset) {
+function writeString (dst, str, offset) {
   if (utils.isNode) {
     return dst.write(str, offset)
   } else {
@@ -35,7 +35,7 @@ function writeString(dst, str, offset) {
   }
 }
 
-export function getMsg(topic, action, data) {
+export function getMsg (topic, action, data) {
   if (data && !(data instanceof Array)) {
     throw new Error('data must be an array')
   }
@@ -79,6 +79,7 @@ export function getMsg(topic, action, data) {
       } else {
         throw new Error('invalid data')
       }
+
       poolOffset += len
 
       varint.encode(len + 1, poolBuffer, headerPos)
@@ -97,7 +98,7 @@ export function getMsg(topic, action, data) {
   return new Uint8Array(poolBuffer.buffer, start, poolOffset - start)
 }
 
-export function typed(value) {
+export function typed (value) {
   const type = typeof value
 
   if (type === 'string') {

package/src/message/message-parser.js

@@ -1,6 +1,10 @@
 import * as C from '../constants/constants.js'
 
-export function convertTyped(value, client) {
+const MessageParser = function () {
+  this._actions = this._getActions()
+}
+
+MessageParser.prototype.convertTyped = function (value, client) {
   const type = value.charAt(0)
 
   if (type === C.TYPES.STRING) {
@@ -40,3 +44,48 @@ export function convertTyped(value, client) {
 
   return undefined
 }
+
+MessageParser.prototype._getActions = function () {
+  const actions = {}
+
+  for (const key in C.ACTIONS) {
+    actions[C.ACTIONS[key]] = key
+  }
+
+  return actions
+}
+
+MessageParser.prototype.parseMessage = function (message, client, result) {
+  const parts = message.split(C.MESSAGE_PART_SEPERATOR)
+
+  if (parts.length < 2) {
+    client._$onError(
+      C.TOPIC.ERROR,
+      C.EVENT.MESSAGE_PARSE_ERROR,
+      new Error('Insufficiant message parts')
+    )
+    return null
+  }
+
+  if (parts[0] === C.TOPIC.ERROR) {
+    client._$onError(C.TOPIC.ERROR, parts[1], new Error('Message error'), message)
+    return null
+  }
+
+  if (this._actions[parts[1]] === undefined) {
+    client._$onError(
+      C.TOPIC.ERROR,
+      C.EVENT.MESSAGE_PARSE_ERROR,
+      new Error('Unknown action'),
+      message
+    )
+    return null
+  }
+
+  result.raw = message
+  result.topic = parts[0]
+  result.action = parts[1]
+  result.data = parts.splice(2)
+}
+
+export default new MessageParser()