@nxtedition/deepstream.io-client-js 32.0.8 → 32.0.10

package/.claude/settings.local.json

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

package/package.json

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

package/src/client.d.ts

@@ -87,8 +87,8 @@ export interface DeepstreamClient<
   rpc: RpcHandler<Methods>
   record: RecordHandler<Records>
   user: string | null
-  on: (evt: EventName, callback: (...args: unknown[]) => void) => this
-  off: (evt: EventName, callback: (...args: unknown[]) => void) => this
+  on: (evt: EventName | 'error', callback: (...args: unknown[]) => void) => this
+  off: (evt: EventName | 'error', callback: (...args: unknown[]) => void) => this
   getConnectionState: () => ConnectionStateName
   close: () => void
   login(callback: (success: boolean, authData: unknown) => void): this

package/src/client.test-d.ts

@@ -188,6 +188,16 @@ expectAssignable<Promise<void>>(
 )
 expectAssignable<Promise<void>>(ds.record.update('p', 'p1', (data) => data, { timeout: 5000 }))
 
+// update: updater receives version as second argument
+ds.record.update('p', (data, version) => {
+  expectType<string>(version)
+  return data
+})
+ds.record.update('p', 'p1', (data, version) => {
+  expectType<string>(version)
+  return data
+})
+
 // Circular
 expectAssignable<string | undefined>(await ds.record.get('c', 'a.b1'))
 
@@ -219,6 +229,19 @@ expectAssignable<Promise<typeof rec>>(rec.when({ state: 2, timeout: 5000 }))
 expectAssignable<Promise<typeof rec>>(rec.when(2, { timeout: 5000 }))
 expectAssignable<Promise<typeof rec>>(rec.when(2, { signal: new AbortController().signal }))
 
+// Record.subscribe: callback receives (record, opaque)
+rec.subscribe((record, opaque) => {
+  expectType<typeof rec>(record)
+  expectType<unknown>(opaque)
+})
+rec.subscribe((record, opaque) => {}, 'my-opaque-token')
+
+// Record.unsubscribe: same callback signature
+rec.unsubscribe((record, opaque) => {
+  expectType<typeof rec>(record)
+  expectType<unknown>(opaque)
+})
+
 // Record.update with options
 expectAssignable<Promise<void>>(rec.update((x) => x, { signal: new AbortController().signal }))
 expectAssignable<Promise<void>>(rec.update((x) => x, { timeout: 5000 }))
@@ -229,7 +252,37 @@ expectAssignable<Promise<void>>(
 expectAssignable<Promise<void>>(rec.update('o0', (x) => x, { timeout: 5000 }))
 expectAssignable<Promise<void>>(rec.update('o0', (x) => x, { state: 2 }))
 
+// Record.update: updater receives version as second argument
+rec.update((x, version) => {
+  expectType<string>(version)
+  return x
+})
+rec.update('o0', (x, version) => {
+  expectType<string>(version)
+  return x
+})
+
 const state = 'VOID'
 expectType<0>(ds.record.STATE[state])
 const unknownState: string = 'VOID'
 expectType<number>(ds.record.STATE[unknownState])
+
+// record.getRecord: [Symbol.dispose] is present
+const recDispose = ds.record.getRecord('o')
+recDispose[Symbol.dispose]()
+
+// record.provide: returns Disposer | void
+expectAssignable<(() => void) | void>(ds.record.provide('pattern*', () => ({})))
+const recordDisposer = ds.record.provide('pattern*', () => ({}))
+if (recordDisposer) {
+  recordDisposer()
+  recordDisposer[Symbol.dispose]()
+}
+
+// event.provide: returns (() => void) | void
+expectAssignable<(() => void) | void>(ds.event.provide('pattern*', () => {}, {}))
+
+// client.on/off: 'error' is a valid event name
+ds.on('error', (err) => {})
+ds.off('error', (err) => {})
+expectError(ds.on('unknownEvent', () => {}))

package/src/event/event-handler.d.ts

@@ -10,7 +10,11 @@ export default class EventHandler {
   off: (name: string, callback: (data: unknown) => void) => this
   observe: <Data>(name: string) => Observable<Data>
   emit: <Data>(name: string, data?: Data) => void
-  provide: (pattern: string, callback: (name: string) => void, options: unknown) => () => void
+  provide: (
+    pattern: string,
+    callback: (name: string) => void,
+    options: unknown,
+  ) => (() => void) | void
 }
 
 export interface EventStats {

package/src/record/record-handler.d.ts

@@ -40,7 +40,7 @@ export default class RecordHandler<Records = Record<string, unknown>> {
     pattern: string,
     callback: (key: string) => unknown,
     optionsOrRecursive?: ProvideOptions | boolean,
-  ) => Disposer
+  ) => Disposer | void
 
   sync: (options?: SyncOptions) => Promise<void>
 
@@ -61,14 +61,17 @@ export default class RecordHandler<Records = Record<string, unknown>> {
   update: {
     <Name extends string>(
       name: Name,
-      updater: (data: Lookup<Records, Name>) => Lookup<Records, Name>,
+      updater: (data: Lookup<Records, Name>, version: string) => Lookup<Records, Name>,
       options?: UpdateOptions,
     ): Promise<void>
 
     <Name extends string, Path extends string | string[]>(
       name: Name,
       path: Path,
-      updater: (data: Get<Lookup<Records, Name>, Path>) => Get<Lookup<Records, Name>, Path>,
+      updater: (
+        data: Get<Lookup<Records, Name>, Path>,
+        version: string,
+      ) => Get<Lookup<Records, Name>, Path>,
       options?: UpdateOptions,
     ): Promise<void>
   }

package/src/record/record.d.ts

@@ -38,8 +38,15 @@ export default class Record<Data = unknown> {
 
   ref(): Record<Data>
   unref(): Record<Data>
-  subscribe(callback: (record: Record<Data>) => void, opaque?: unknown): Record<Data>
-  unsubscribe(callback: (record: Record<Data>) => void, opaque?: unknown): Record<Data>
+  [Symbol.dispose](): void
+  subscribe(
+    callback: (record: Record<Data>, opaque: unknown) => void,
+    opaque?: unknown,
+  ): Record<Data>
+  unsubscribe(
+    callback: (record: Record<Data>, opaque: unknown) => void,
+    opaque?: unknown,
+  ): Record<Data>
 
   get: {
     // with path
@@ -67,11 +74,14 @@ export default class Record<Data = unknown> {
 
   update: {
     // without path
-    (updater: (data: Readonly<Data>) => Data, options?: UpdateOptions): Promise<void>
+    (
+      updater: (data: Readonly<Data>, version: string) => Data,
+      options?: UpdateOptions,
+    ): Promise<void>
     // with path
     <P extends string | string[]>(
       path: P,
-      updater: (dataAtPath: Readonly<Get<Data, P>>) => Get<Data, P>,
+      updater: (dataAtPath: Readonly<Get<Data, P>>, version: string) => Get<Data, P>,
       options?: UpdateOptions,
     ): Promise<void>
   }

package/src/rpc/rpc-handler.d.ts

@@ -10,8 +10,11 @@ export default class RpcHandler<
 
   provide: <Name extends keyof Methods>(
     name: Name,
-    callback: (args: Methods[Name][0], response: RpcResponse<Methods[Name][1]>) => void,
-  ) => UnprovideFn
+    callback: (
+      args: Methods[Name][0],
+      response: RpcResponse<Methods[Name][1]>,
+    ) => Methods[Name][1] | Promise<Methods[Name][1]> | void,
+  ) => UnprovideFn | void
 
   unprovide: <Name extends keyof Methods>(name: Name) => void
 
@@ -22,7 +25,7 @@ export default class RpcHandler<
       ReturnValue extends Name extends keyof Methods ? Methods[Name][1] : unknown,
     >(
       name: Name,
-      args: Args,
+      args?: Args,
     ): Promise<ReturnValue>
     <
       Name extends keyof Methods | string,
@@ -30,7 +33,7 @@ export default class RpcHandler<
       ReturnValue extends Name extends keyof Methods ? Methods[Name][1] : unknown,
     >(
       name: Name,
-      args: Args,
+      args: Args | undefined,
       callback: (error: unknown, response: ReturnValue) => void,
     ): void
   }

package/src/rpc/rpc-handler.test-d.ts

@@ -0,0 +1,40 @@
+import make from '../client.js'
+import { expectAssignable, expectError, expectType } from 'tsd'
+
+interface Methods extends Record<string, [unknown, unknown]> {
+  greet: [{ name: string }, { message: string }]
+}
+
+const ds = make<Record<string, unknown>, Methods>('')
+
+// provide: callback may return void, a value, or a Promise — all valid
+ds.rpc.provide('greet', (_args, _response) => {})
+ds.rpc.provide('greet', (_args, _response) => ({ message: 'hello' }))
+ds.rpc.provide('greet', async (_args, _response) => ({ message: 'hello' }))
+// async callback that uses response.send() directly — returns Promise<void>
+ds.rpc.provide('greet', async (_args, response) => {
+  response.send({ message: 'hello' })
+})
+
+// provide: returning the wrong shape is an error
+expectError(ds.rpc.provide('greet', (_args, _response) => ({ notMessage: 'hello' })))
+
+// provide: response.completed is boolean
+ds.rpc.provide('greet', (_args, response) => {
+  expectType<boolean>(response.completed)
+})
+
+// provide: return type is UnprovideFn | void
+expectAssignable<(() => void) | void>(ds.rpc.provide('greet', () => {}))
+
+// make: args is optional (no args)
+expectAssignable<Promise<{ message: string }>>(ds.rpc.make('greet'))
+// make: args provided
+expectAssignable<Promise<{ message: string }>>(ds.rpc.make('greet', { name: 'world' }))
+// make: args explicitly undefined
+expectAssignable<Promise<{ message: string }>>(ds.rpc.make('greet', undefined))
+// make: callback form — args required positionally but can be undefined
+ds.rpc.make('greet', undefined, (err, res) => {
+  expectType<unknown>(err)
+  expectAssignable<{ message: string } | undefined>(res)
+})

package/src/rpc/rpc-response.d.ts

@@ -1,4 +1,5 @@
 export default class RpcResponse<Data> {
+  completed: boolean
   reject: () => void
   error: (error: Error | string) => void
   send: (data: Data) => void