@nxtedition/deepstream.io-client-js 23.4.3 → 23.4.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/deepstream.io-client-js",
-  "version": "23.4.3",
+  "version": "23.4.5",
   "description": "the javascript client for deepstream.io",
   "homepage": "http://deepstream.io",
   "bugs": {
@@ -19,8 +19,7 @@
   "scripts": {
     "_postinstall": "husky install",
     "prepublishOnly": "pinst --disable",
-    "postpublish": "pinst --enable",
-    "test": "jest --bail --watchAll"
+    "postpublish": "pinst --enable"
   },
   "lint-staged": {
     "*.{js,jsx,md,ts}": [
@@ -59,27 +58,27 @@
     "/__tests__"
   ],
   "dependencies": {
+    "@nxtedition/json-path": "^1.0.3",
     "bufferutil": "^4.0.7",
     "component-emitter2": "^1.3.5",
     "invariant": "^2.2.4",
-    "utf-8-validate": "^5.0.10",
-    "ws": "^8.11.0",
-    "xuid": "^4.1.0",
+    "utf-8-validate": "^6.0.3",
+    "ws": "^8.13.0",
+    "xuid": "^4.1.2",
     "xxhash-wasm": "^1.0.2"
   },
   "devDependencies": {
-    "eslint": "^8.27.0",
-    "eslint-config-prettier": "^8.5.0",
+    "eslint": "^8.38.0",
+    "eslint-config-prettier": "^8.8.0",
     "eslint-config-standard": "^17.0.0",
-    "eslint-plugin-import": "^2.26.0",
-    "eslint-plugin-n": "^15.5.0",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-n": "^15.7.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-promise": "^6.1.1",
-    "husky": "^8.0.2",
-    "jest": "^29.3.0",
-    "lint-staged": "^13.0.3",
+    "husky": "^8.0.3",
+    "lint-staged": "^13.2.1",
     "pinst": "^3.0.0",
-    "prettier": "^2.7.1"
+    "prettier": "^2.8.7"
   },
   "peerDependencies": {
     "rxjs": ">=6.x"

package/src/record/record-handler.js

@@ -5,10 +5,11 @@ const C = require('../constants/constants')
 const rxjs = require('rxjs')
 const invariant = require('invariant')
 const EventEmitter = require('component-emitter2')
-const jsonPath = require('./json-path')
+const jsonPath = require('@nxtedition/json-path')
 const utils = require('../utils/utils')
 const rx = require('rxjs/operators')
 const xuid = require('xuid')
+const timers = require('../utils/timers')
 
 const kEmpty = Symbol('kEmpty')
 
@@ -180,7 +181,7 @@ class RecordHandler {
         signal?.removeEventListener('abort', onAbort)
 
         if (timeoutHandle) {
-          clearTimeout(timeoutHandle)
+          timers.clearTimeout(timeoutHandle)
           timeoutHandle = null
         }
 
@@ -207,8 +208,7 @@ class RecordHandler {
       const onTimeout = () => {
         const elapsed = Date.now() - this._connected
         if (elapsed < timeoutValue) {
-          timeoutHandle = setTimeout(onTimeout, timeoutValue - elapsed)
-          timeoutHandle.unref?.()
+          timeoutHandle = timers.setTimeout(onTimeout, timeoutValue - elapsed)
         } else {
           for (const rec of records.filter((rec) => !rec.isReady)) {
             this._client._$onError(C.TOPIC.RECORD, C.EVENT.TIMEOUT, 'record timeout', [
@@ -230,8 +230,7 @@ class RecordHandler {
       }
 
       if (timeoutValue) {
-        timeoutHandle = setTimeout(onTimeout, timeoutValue)
-        timeoutHandle.unref?.()
+        timeoutHandle = timers.setTimeout(onTimeout, timeoutValue)
       }
 
       signal?.addEventListener('abort', onAbort)
@@ -373,7 +372,7 @@ class RecordHandler {
         }
 
         if (timeoutHandle) {
-          clearTimeout(timeoutHandle)
+          timers.clearTimeout(timeoutHandle)
           timeoutHandle = null
         }
 
@@ -397,7 +396,7 @@ class RecordHandler {
       const record = this.getRecord(name).subscribe(onUpdate)
 
       if (timeoutValue && state && record.state < state) {
-        timeoutHandle = setTimeout(() => {
+        timeoutHandle = timers.setTimeout(() => {
           const expected = C.RECORD_STATE_NAME[state]
           const current = C.RECORD_STATE_NAME[record.state]
           o.error(
@@ -407,7 +406,6 @@ class RecordHandler {
             )
           )
         }, timeoutValue)
-        timeoutHandle.unref?.()
       }
 
       if (record.version) {

package/src/record/record.js

@@ -1,4 +1,4 @@
-const jsonPath = require('./json-path')
+const jsonPath = require('@nxtedition/json-path')
 const utils = require('../utils/utils')
 const C = require('../constants/constants')
 const messageParser = require('../message/message-parser')

package/src/utils/timers.js

@@ -0,0 +1,97 @@
+// undici timers
+
+'use strict'
+
+let fastNow = Date.now()
+let fastNowTimeout
+
+const fastTimers = []
+
+function onTimeout() {
+  fastNow = Date.now()
+
+  let len = fastTimers.length
+  let idx = 0
+  while (idx < len) {
+    const timer = fastTimers[idx]
+
+    if (timer.state === 0) {
+      timer.state = fastNow + timer.delay
+    } else if (timer.state > 0 && fastNow >= timer.state) {
+      timer.state = -1
+      timer.callback(timer.opaque)
+    }
+
+    if (timer.state === -1) {
+      timer.state = -2
+      if (idx !== len - 1) {
+        fastTimers[idx] = fastTimers.pop()
+      } else {
+        fastTimers.pop()
+      }
+      len -= 1
+    } else {
+      idx += 1
+    }
+  }
+
+  if (fastTimers.length > 0) {
+    refreshTimeout()
+  }
+}
+
+function refreshTimeout() {
+  if (fastNowTimeout && fastNowTimeout.refresh) {
+    fastNowTimeout.refresh()
+  } else {
+    clearTimeout(fastNowTimeout)
+    fastNowTimeout = setTimeout(onTimeout, 1e3)
+    if (fastNowTimeout.unref) {
+      fastNowTimeout.unref()
+    }
+  }
+}
+
+class Timeout {
+  constructor(callback, delay, opaque) {
+    this.callback = callback
+    this.delay = delay
+    this.opaque = opaque
+
+    //  -2 not in timer list
+    //  -1 in timer list but inactive
+    //   0 in timer list waiting for time
+    // > 0 in timer list waiting for time to expire
+    this.state = -2
+
+    this.refresh()
+  }
+
+  refresh() {
+    if (this.state === -2) {
+      fastTimers.push(this)
+      if (!fastNowTimeout || fastTimers.length === 1) {
+        refreshTimeout()
+      }
+    }
+
+    this.state = 0
+  }
+
+  clear() {
+    this.state = -1
+  }
+}
+
+module.exports = {
+  setTimeout(callback, delay, opaque) {
+    return delay < 1e3 ? setTimeout(callback, delay, opaque) : new Timeout(callback, delay, opaque)
+  },
+  clearTimeout(timeout) {
+    if (timeout instanceof Timeout) {
+      timeout.clear()
+    } else {
+      clearTimeout(timeout)
+    }
+  },
+}

package/__tests__/json-path.test.js

@@ -1,353 +0,0 @@
-const jsonPath = require('../src/record/json-path')
-
-describe('equality', () => {
-  it('deep equal', () => {
-    const obj = { asd: 123 }
-    const res = jsonPath.set(
-      {
-        obj,
-        foo: 'true',
-      },
-      null,
-      {
-        obj,
-      }
-    )
-
-    expect(res.obj).toBe(obj)
-    expect(res).toEqual({ obj })
-  })
-
-  it('returns old value', () => {
-    const obj = {
-      asd: true,
-    }
-    const res = jsonPath.set(obj, undefined, {
-      asd: true,
-    })
-
-    expect(res).toBe(obj)
-  })
-})
-
-describe('json clone', () => {
-  it('types', () => {
-    expect(jsonPath.jsonClone('ASD')).toEqual('ASD')
-    expect(jsonPath.jsonClone(null)).toEqual(null)
-    expect(jsonPath.jsonClone(undefined)).toEqual(undefined)
-    expect(jsonPath.jsonClone(1)).toEqual(1)
-    expect(jsonPath.jsonClone(NaN)).toEqual(null)
-    expect(jsonPath.jsonClone(1.1)).toEqual(1.1)
-
-    const date = new Date()
-    expect(jsonPath.jsonClone(date)).toEqual(date.toISOString())
-  })
-})
-
-describe('set', () => {
-  it('set through null', () => {
-    const res = jsonPath.set(
-      {
-        asd: null,
-      },
-      'asd.foo.bar',
-      true
-    )
-    expect(res).toEqual({
-      asd: { foo: { bar: true } },
-    })
-  })
-
-  it('set empty', () => {
-    const obj = {
-      asd: null,
-    }
-    const res = jsonPath.set(obj, null, {})
-    expect(res).toEqual({})
-  })
-
-  it('set on null', () => {
-    const res = jsonPath.set(null, null, { sad: true })
-    expect(res).toEqual({ sad: true })
-  })
-
-  it('set string', () => {
-    const res = jsonPath.set({ foo: 'ASD' }, null, { sad: 'ASD' })
-    expect(res).toEqual({ sad: 'ASD' })
-  })
-
-  it('set array on object', () => {
-    const res = jsonPath.set({}, null, [])
-    expect(res).toEqual([])
-  })
-
-  it('set array on object plainJSON', () => {
-    const res = jsonPath.set({}, null, [], true)
-    expect(res).toEqual([])
-  })
-})
-
-describe('order', () => {
-  it('updates order', () => {
-    const obj = {
-      foo: 1,
-      bar: 1,
-    }
-    const res = jsonPath.set(obj, undefined, {
-      bar: 1,
-      foo: 2,
-    })
-
-    expect(res).not.toBe(obj)
-    expect(res).toEqual({ bar: 1, foo: 2 })
-  })
-
-  it('keeps order', () => {
-    const obj = {
-      foo: 1,
-      bar: 1,
-    }
-    const res = jsonPath.set(obj, undefined, {
-      foo: 1,
-      bar: 1,
-    })
-
-    expect(res).toBe(obj)
-  })
-})
-
-describe('paths are tokenized and retrieved correctly', () => {
-  const testRecord = {
-    _$data: {
-      firstname: 'Wolfram',
-      lastname: 'Hempel',
-      address: {
-        street: 'currentStreet',
-      },
-      pastAddresses: [
-        { street: 'firststreet', postCode: 1001 },
-        { street: 'secondstreet', postCode: 2002 },
-      ],
-      1234: 'integer index',
-    },
-  }
-
-  it('retrieves simple paths', () => {
-    expect(jsonPath.get(testRecord._$data, 'firstname')).toBe('Wolfram')
-  })
-
-  it('retrieves nested paths', () => {
-    expect(jsonPath.get(testRecord._$data, 'address.street')).toBe('currentStreet')
-  })
-
-  it('retrieves array entries', () => {
-    expect(jsonPath.get(testRecord._$data, 'pastAddresses[1]')).toEqual({
-      street: 'secondstreet',
-      postCode: 2002,
-    })
-  })
-
-  it('retrieves other array entries', () => {
-    expect(jsonPath.get(testRecord._$data, 'pastAddresses[0]')).toEqual({
-      street: 'firststreet',
-      postCode: 1001,
-    })
-  })
-
-  it('retrieves values from objects within arrays', () => {
-    expect(jsonPath.get(testRecord._$data, 'pastAddresses[0].postCode')).toBe(1001)
-  })
-
-  it('handles whitespace', () => {
-    expect(jsonPath.get(testRecord._$data, ' pastAddresses[ 1 ].postCode ')).toBe(2002)
-  })
-
-  it('handles integers', () => {
-    expect(jsonPath.get(testRecord._$data, 1234)).toBe('integer index')
-  })
-
-  it('returns undefined for non existing keys', () => {
-    expect(jsonPath.get(testRecord._$data, 'doesNotExist')).toBe(undefined)
-  })
-
-  it('returns undefined for non existing nested keys', () => {
-    expect(jsonPath.get(testRecord._$data, 'address.number')).toBe(undefined)
-  })
-
-  it('returns undefined for existing array indices', () => {
-    expect(jsonPath.get(testRecord._$data, 'pastAddresses[3]')).toBe(undefined)
-  })
-
-  it('returns undefined for negative array indices', () => {
-    expect(jsonPath.get(testRecord._$data, 'pastAddresses[-1]')).toBe(undefined)
-  })
-
-  it('detects changes', () => {
-    expect(jsonPath.get(testRecord._$data, 'firstname')).toBe('Wolfram')
-    testRecord._$data.firstname = 'Egon'
-    expect(jsonPath.get(testRecord._$data, 'firstname')).toBe('Egon')
-  })
-
-  it('detects changes to arrays', () => {
-    expect(jsonPath.get(testRecord._$data, 'pastAddresses[1].street')).toBe('secondstreet')
-    testRecord._$data.pastAddresses.pop()
-    expect(jsonPath.get(testRecord._$data, 'pastAddresses[1].street')).toBe(undefined)
-  })
-})
-
-describe('objects are created from paths and their value is set correctly', () => {
-  it('sets simple values', () => {
-    const record = { _$data: {} }
-    record._$data = jsonPath.set(record._$data, 'firstname', 'Wolfram')
-    expect(jsonPath.get(record._$data, 'firstname')).toBe('Wolfram')
-    expect(record._$data).toEqual({ firstname: 'Wolfram' })
-  })
-
-  it('sets values for nested objects', () => {
-    const record = { _$data: {} }
-    record._$data = jsonPath.set(record._$data, 'adress.street', 'someStreet')
-    expect(jsonPath.get(record._$data, 'adress.street')).toBe('someStreet')
-    expect(record._$data).toEqual({
-      adress: {
-        street: 'someStreet',
-      },
-    })
-  })
-
-  it('sets values for arrays', () => {
-    const record = { _$data: {} }
-    record._$data = jsonPath.set(record._$data, 'pastAddresses[1].street', 'someStreet')
-    expect(jsonPath.get(record._$data, 'pastAddresses[1].street')).toBe('someStreet')
-    expect(record._$data).toEqual({
-      pastAddresses: [
-        undefined,
-        {
-          street: 'someStreet',
-        },
-      ],
-    })
-  })
-
-  it('sets values for null values', () => {
-    const record = {
-      _$data: {
-        job: null,
-        joinedAt: 1480020987915,
-      },
-    }
-    const jobId = { id: 88 }
-    record._$data = jsonPath.set(record._$data, 'job', jobId, true)
-    expect(jsonPath.get(record._$data, 'job.id')).toBe(88)
-    expect(record._$data).toEqual({
-      job: { id: 88 },
-      joinedAt: 1480020987915,
-    })
-  })
-
-  it('extends existing objects', () => {
-    const record = { _$data: { firstname: 'Wolfram' } }
-    record._$data = jsonPath.set(record._$data, 'lastname', 'Hempel')
-    expect(jsonPath.get(record._$data, 'lastname')).toBe('Hempel')
-    expect(record._$data).toEqual({
-      firstname: 'Wolfram',
-      lastname: 'Hempel',
-    })
-  })
-
-  it('even when the path is not NaNish and could be interpreted as a base 16 number', () => {
-    let record = {}
-    const pathName = '0x02335'
-    record = jsonPath.set(record, pathName, 'value')
-    expect(record[0]).toBe(undefined)
-    expect(record[pathName]).toBe('value')
-    expect(jsonPath.get(record, pathName)).toBe('value')
-    expect(record[pathName]).toBe('value')
-  })
-
-  it('extends existing arrays', () => {
-    const record = {
-      _$data: {
-        firstname: 'Wolfram',
-        animals: ['Bear', 'Cow', 'Ostrich'],
-      },
-    }
-    record._$data = jsonPath.set(record._$data, 'animals[ 1 ]', 'Emu')
-    expect(jsonPath.get(record._$data, 'animals[ 1 ]')).toBe('Emu')
-    expect(record._$data).toEqual({
-      firstname: 'Wolfram',
-      animals: ['Bear', 'Emu', 'Ostrich'],
-    })
-  })
-})
-
-describe('plain JSON', () => {
-  it('converts into plain JSON', () => {
-    const time = new Date()
-    const x = {
-      a: time,
-      b: undefined,
-      c: [undefined],
-      d: NaN,
-      e: Infinity,
-      g: {
-        a: time,
-      },
-    }
-    const res = jsonPath.set({ a: 1 }, null, x)
-    expect(res).toEqual({
-      a: time.toISOString(),
-      c: [null],
-      d: null,
-      e: null,
-      g: {
-        a: time.toISOString(),
-      },
-    })
-    expect(res.hasOwnProperty('b')).toEqual(false)
-  })
-
-  it('undefined is removed from src', () => {
-    const y = jsonPath.EMPTY
-    const res = jsonPath.set(y, null, {
-      b: undefined,
-    })
-    expect(Object.keys(res).length).toEqual(0)
-    expect(res).toBe(y)
-  })
-
-  it('empty is EMPTY', () => {
-    const y = {
-      b: 1,
-    }
-    const res = jsonPath.set(y, null, {
-      b: undefined,
-    })
-    expect(Object.keys(res).length).toEqual(0)
-    expect(res).toBe(jsonPath.EMPTY)
-    expect(res).toEqual({})
-  })
-
-  it('stringify date', () => {
-    const y = {
-      time: {},
-    }
-    const date = new Date()
-    const res = jsonPath.set(
-      y,
-      null,
-      {
-        date,
-      },
-      false
-    )
-    expect(res.date).toEqual(date.toISOString())
-  })
-
-  it('remove property on undefined', () => {
-    const y = {
-      time: {},
-    }
-    const res = jsonPath.set(y, 'time', undefined)
-    expect(Object.keys(res)).toEqual([])
-  })
-})

package/src/record/json-path.js

@@ -1,199 +0,0 @@
-const utils = require('../utils/utils')
-const PARTS_REG_EXP = /([^.[\]\s]+)/g
-
-const cache = new Map()
-const EMPTY = utils.deepFreeze({})
-
-const EMPTY_OBJ = EMPTY
-const EMPTY_ARR = utils.deepFreeze([])
-
-function get(data, path) {
-  data = data || EMPTY
-
-  if (!path) {
-    return data
-  }
-
-  const tokens = tokenize(path)
-
-  for (let i = 0; i < tokens.length; i++) {
-    if (data == null || typeof data !== 'object') {
-      return undefined
-    }
-    data = data[tokens[i]]
-  }
-
-  return data
-}
-
-function parse(value) {
-  if (value === '{}') {
-    return EMPTY_OBJ
-  } else if (value === '[]') {
-    return EMPTY_ARR
-  } else {
-    return JSON.parse(value)
-  }
-}
-
-function stringify(value) {
-  if (value === EMPTY_OBJ) {
-    return '{}'
-  } else if (value === EMPTY_ARR) {
-    return '[]'
-  } else {
-    return JSON.stringify(value)
-  }
-}
-
-function set(data, path, value, isPlainJSON = false) {
-  data = data || EMPTY
-
-  if (!path) {
-    return patch(data, value, isPlainJSON)
-  }
-
-  const oldValue = get(data, path)
-  const newValue = patch(oldValue, value, isPlainJSON)
-
-  if (newValue === oldValue) {
-    return data
-  }
-
-  const result = data ? utils.shallowCopy(data) : {}
-
-  const tokens = tokenize(path)
-
-  let node = result
-  for (let i = 0; i < tokens.length; i++) {
-    const token = tokens[i]
-    if (i === tokens.length - 1) {
-      if (newValue !== undefined) {
-        node[token] = newValue
-      } else {
-        delete node[token]
-      }
-    } else if (node[token] != null && typeof node[token] === 'object') {
-      node = node[token] = utils.shallowCopy(node[token])
-    } else if (tokens[i + 1] && !isNaN(tokens[i + 1])) {
-      node = node[token] = []
-    } else {
-      node = node[token] = {}
-    }
-  }
-
-  return result
-}
-
-function jsonClone(o) {
-  if (o == null || typeof o === 'string') {
-    return o
-  }
-
-  if (Array.isArray(o) && o.length === 0) {
-    return EMPTY_ARR
-  } else if (utils.isPlainObject(o) && Object.keys(o).length === 0) {
-    return EMPTY_OBJ
-  }
-
-  return JSON.parse(JSON.stringify(o))
-}
-
-function patch(oldValue, newValue, isPlainJSON) {
-  if (oldValue === newValue) {
-    return oldValue
-  } else if (oldValue === null || newValue === null) {
-    return isPlainJSON ? newValue : jsonClone(newValue)
-  } else if (Array.isArray(oldValue) && Array.isArray(newValue)) {
-    if (newValue.length === 0) {
-      return EMPTY_ARR
-    }
-
-    let arr = newValue.length === oldValue.length ? null : []
-    for (let i = 0; i < newValue.length; i++) {
-      const value = patch(oldValue[i], newValue[i], isPlainJSON)
-
-      if (!arr) {
-        if (value === oldValue[i]) {
-          continue
-        }
-        arr = []
-        for (let j = 0; j < i; ++j) {
-          arr[j] = oldValue[j]
-        }
-      }
-      // JSON: compat, undefined in array is null
-      arr[i] = value === undefined ? null : value
-    }
-
-    return arr || oldValue
-  } else if (utils.isPlainObject(oldValue, true) && utils.isPlainObject(newValue, isPlainJSON)) {
-    const newKeys = Object.keys(newValue).filter((key) => newValue[key] !== undefined)
-    const oldKeys = Object.keys(oldValue)
-
-    if (newKeys.length === 0) {
-      return oldKeys.length === 0 ? oldValue : EMPTY
-    }
-
-    let obj = newKeys.length === oldKeys.length ? null : {}
-    for (let i = 0; i < newKeys.length; ++i) {
-      const key = newKeys[i]
-      const val = patch(oldValue[key], newValue[key], isPlainJSON)
-
-      if (!obj) {
-        if (val === oldValue[key] && key === oldKeys[i]) {
-          continue
-        }
-        obj = {}
-        for (let j = 0; j < i; j++) {
-          obj[newKeys[j]] = oldValue[newKeys[j]]
-        }
-      }
-
-      if (val !== undefined) {
-        obj[key] = val
-      }
-    }
-
-    return obj || oldValue
-  } else {
-    return isPlainJSON ? newValue : jsonClone(newValue)
-  }
-}
-
-function tokenize(path) {
-  if (!path) {
-    return []
-  }
-
-  if (Array.isArray(path)) {
-    return path
-  }
-
-  let parts = cache.get(path)
-
-  if (parts) {
-    return parts
-  }
-
-  parts = path && String(path) !== 'undefined' ? String(path).match(PARTS_REG_EXP) : []
-
-  if (!parts) {
-    throw new Error('invalid path ' + path)
-  }
-
-  cache.set(path, parts)
-
-  return parts
-}
-
-module.exports = {
-  EMPTY,
-  EMPTY_OBJ,
-  EMPTY_ARR,
-  parse,
-  stringify,
-  get,
-  set,
-  jsonClone,
-}