@nxtedition/deepstream.io-client-js 23.4.4 → 23.4.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/deepstream.io-client-js",
-  "version": "23.4.4",
+  "version": "23.4.6",
   "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,7 +5,7 @@ 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')

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/unicast-listener.js

@@ -1,5 +1,4 @@
 const C = require('../constants/constants')
-const rx = require('rxjs/operators')
 const rxjs = require('rxjs')
 
 class Listener {
@@ -12,26 +11,7 @@ class Listener {
     this._connection = this._handler._connection
     this._subscriptions = new Map()
     this._stringify = stringify || JSON.stringify
-    this._pipe = rxjs.pipe(
-      rx.map((value) => {
-        let data
-        if (value && typeof value === 'string') {
-          if (value.charAt(0) !== '{' && value.charAt(0) !== '[') {
-            throw new Error(`invalid value: ${value}`)
-          }
-          data = value
-        } else if (value && typeof value === 'object') {
-          data = this._stringify(value)
-        } else {
-          throw new Error(`invalid value: ${value}`)
-        }
-
-        const hash = this._connection.hasher.h64ToString(data)
-
-        return { data, hash }
-      }),
-      rx.distinctUntilKeyChanged('hash')
-    )
+    this._value = null
 
     this._$onConnectionStateChange()
 
@@ -79,9 +59,30 @@ class Listener {
       }
 
       if (value$) {
-        const subscription = value$.pipe(this._pipe).subscribe({
-          next: ({ data, hash }) => {
-            this._connection.sendMsg(this._topic, C.ACTIONS.UPDATE, [name, `INF-${hash}`, data])
+        const subscription = value$.subscribe({
+          next: (value) => {
+            let data
+            if (value && typeof value === 'string') {
+              if (value.charAt(0) !== '{' && value.charAt(0) !== '[') {
+                throw new Error(`invalid value: ${value}`)
+              }
+              data = value
+            } else if (value && typeof value === 'object') {
+              data = this._stringify(value)
+            } else {
+              throw new Error(`invalid value: ${value}`)
+            }
+
+            if (value === this._value) {
+              return
+            }
+
+            this._value = value
+            this._connection.sendMsg(this._topic, C.ACTIONS.UPDATE, [
+              name,
+              `INF-${this._connection.hasher.h64ToString(data)}`,
+              data,
+            ])
           },
           error: (err) => {
             this._error(name, err)

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,
-}