@nxtedition/deepstream.io-client-js 32.0.11 → 32.0.13

package/package.json

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

package/src/client.d.ts

@@ -7,10 +7,21 @@ import type { EventStats } from './event/event-handler.js'
 import type RpcHandler from './rpc/rpc-handler.js'
 import type { RpcStats, RpcMethodDef } from './rpc/rpc-handler.js'
 
+export interface DeepstreamClientOptions {
+  reconnectIntervalIncrement?: number
+  maxReconnectInterval?: number
+  maxReconnectAttempts?: number
+  maxPacketSize?: number
+  batchSize?: number
+  schedule?: ((fn: () => void) => void) | null
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  logger?: any
+}
+
 export default function <
   Records extends Record<string, unknown> = Record<string, unknown>,
   Methods extends Record<string, RpcMethodDef> = Record<string, RpcMethodDef>,
->(url: string, options?: unknown): DeepstreamClient<Records, Methods>
+>(url: string, options?: DeepstreamClientOptions): DeepstreamClient<Records, Methods>
 
 export type {
   DsRecord,
@@ -22,6 +33,8 @@ export type {
   SyncOptions,
   Paths,
   Get,
+  ConnectionStateName,
+  DeepstreamErrorEventName,
 }
 
 type RecordStateConstants = Readonly<{
@@ -77,6 +90,36 @@ type EventConstants = Readonly<{
 }>
 type EventKey = keyof EventConstants
 type EventName = EventConstants[EventKey]
+type DeepstreamErrorEventName = Exclude<
+  EventName,
+  'connectionStateChanged' | 'connected' | 'MAX_RECONNECTION_ATTEMPTS_REACHED'
+>
+
+export interface DeepstreamError extends Error {
+  topic?: string
+  event?: EventName | null
+  data?: unknown
+}
+
+export interface DeepstreamMessage {
+  raw: string | null
+  topic: string | null
+  action: string | null
+  data: string[]
+}
+
+export interface DeepstreamClientEventMap {
+  connectionStateChanged: (state: ConnectionStateName) => void
+  connected: (connected: boolean) => void
+  MAX_RECONNECTION_ATTEMPTS_REACHED: (attempt: number) => void
+  error: (error: DeepstreamError) => void
+  recv: (message: DeepstreamMessage) => void
+  send: (message: DeepstreamMessage) => void
+}
+
+type DeepstreamErrorEventMap = {
+  [K in DeepstreamErrorEventName]: (error: DeepstreamError) => void
+}
 
 export interface DeepstreamClient<
   Records extends Record<string, unknown> = Record<string, unknown>,
@@ -87,12 +130,21 @@ export interface DeepstreamClient<
   rpc: RpcHandler<Methods>
   record: RecordHandler<Records>
   user: string | null
-  on: (evt: EventName | 'error', callback: (...args: unknown[]) => void) => this
-  off: (evt: EventName | 'error', callback: (...args: unknown[]) => void) => this
+  on<K extends keyof (DeepstreamClientEventMap & DeepstreamErrorEventMap)>(
+    evt: K,
+    callback: (DeepstreamClientEventMap & DeepstreamErrorEventMap)[K],
+  ): this
+  off<K extends keyof (DeepstreamClientEventMap & DeepstreamErrorEventMap)>(
+    evt: K,
+    callback: (DeepstreamClientEventMap & DeepstreamErrorEventMap)[K],
+  ): this
   getConnectionState: () => ConnectionStateName
   close: () => void
   login(callback: (success: boolean, authData: unknown) => void): this
-  login(authParams: object, callback: (success: boolean, authData: unknown) => void): this
+  login(
+    authParams: Record<string, unknown>,
+    callback: (success: boolean, authData: unknown) => void,
+  ): this
   stats: {
     record: RecordStats
     rpc: RpcStats

package/src/client.test-d.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import make, { type DeepstreamClient } from './client.js'
+import make, { type DeepstreamClient, type DeepstreamError } from './client.js'
 import { expectAssignable, expectError, expectType } from 'tsd'
 import type { Observable } from 'rxjs'
 import type { EmptyObject } from 'type-fest'
@@ -287,3 +287,34 @@ expectAssignable<(() => void) | void>(ds.event.provide('pattern*', () => {}, {})
 ds.on('error', (err) => {})
 ds.off('error', (err) => {})
 expectError(ds.on('unknownEvent', () => {}))
+
+// client.on: callback arg types per event
+ds.on('error', (err) => {
+  expectType<DeepstreamError>(err)
+})
+ds.on('connectionError', (err) => {
+  expectType<DeepstreamError>(err)
+})
+ds.on('connectionStateChanged', (state) => {
+  expectType<
+    | 'CLOSED'
+    | 'AWAITING_CONNECTION'
+    | 'CHALLENGING'
+    | 'AWAITING_AUTHENTICATION'
+    | 'AUTHENTICATING'
+    | 'OPEN'
+    | 'ERROR'
+    | 'RECONNECTING'
+  >(state)
+})
+ds.on('connected', (connected) => {
+  expectType<boolean>(connected)
+})
+ds.on('MAX_RECONNECTION_ATTEMPTS_REACHED', (attempt) => {
+  expectType<number>(attempt)
+})
+
+// client.on: wrong callback arg types are errors
+expectError(ds.on('connectionStateChanged', (state: number) => {}))
+expectError(ds.on('connected', (connected: string) => {}))
+expectError(ds.on('MAX_RECONNECTION_ATTEMPTS_REACHED', (attempt: string) => {}))

package/src/event/event-handler.js

@@ -78,7 +78,7 @@ EventHandler.on = function (name, callback) {
 
 EventHandler.once = function (name, callback) {
   const fn = (...args) => {
-    this.unsubscribe(fn)
+    this.unsubscribe(name, fn)
     callback(...args)
   }
   this.subscribe(name, fn)

package/src/record/record.js

@@ -249,7 +249,7 @@ class Record {
   when(stateOrNil, optionsOrNil) {
     invariant(this._refs > 0, 'missing refs')
 
-    if (stateOrNil != null && stateOrNil === 'object') {
+    if (stateOrNil != null && typeof stateOrNil === 'object') {
       optionsOrNil = stateOrNil
       stateOrNil = optionsOrNil?.state
     }

package/src/utils/utils.js

@@ -85,7 +85,7 @@ export function setTimeout(callback, timeoutDuration) {
 
 export function setInterval(callback, intervalDuration) {
   if (intervalDuration !== null) {
-    return setInterval(callback, intervalDuration)
+    return globalThis.setInterval(callback, intervalDuration)
   } else {
     return -1
   }

package/.claude/settings.local.json

@@ -1,9 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(npm run test:types:*)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}