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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/deepstream.io-client-js",
-  "version": "32.0.11",
+  "version": "32.0.12",
   "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,
@@ -77,6 +88,16 @@ 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 DeepstreamClient<
   Records extends Record<string, unknown> = Record<string, unknown>,
@@ -87,8 +108,14 @@ 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(evt: 'connectionStateChanged', callback: (state: ConnectionStateName) => void): this
+  on(evt: 'connected', callback: (connected: boolean) => void): this
+  on(evt: 'MAX_RECONNECTION_ATTEMPTS_REACHED', callback: (attempt: number) => void): this
+  on(evt: 'error' | DeepstreamErrorEventName, callback: (error: DeepstreamError) => void): this
+  off(evt: 'connectionStateChanged', callback: (state: ConnectionStateName) => void): this
+  off(evt: 'connected', callback: (connected: boolean) => void): this
+  off(evt: 'MAX_RECONNECTION_ATTEMPTS_REACHED', callback: (attempt: number) => void): this
+  off(evt: 'error' | DeepstreamErrorEventName, callback: (error: DeepstreamError) => void): this
   getConnectionState: () => ConnectionStateName
   close: () => void
   login(callback: (success: boolean, authData: unknown) => void): this

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) => {}))