@nxtedition/deepstream.io-client-js 31.2.1 → 31.2.3

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": "31.2.1",
+  "version": "31.2.3",
   "description": "the javascript client for deepstream.io",
   "homepage": "http://deepstream.io",
   "type": "module",

package/src/client.d.ts

@@ -8,7 +8,7 @@ import type RpcHandler from './rpc/rpc-handler.js'
 import type { RpcStats, RpcMethodDef } from './rpc/rpc-handler.js'
 
 export default function <
-  Records,
+  Records extends Record<string, unknown> = Record<string, unknown>,
   Methods extends Record<string, RpcMethodDef> = Record<string, RpcMethodDef>,
 >(url: string, options?: unknown): DeepstreamClient<Records, Methods>
 
@@ -79,7 +79,7 @@ type EventKey = keyof EventConstants
 type EventName = EventConstants[EventKey]
 
 export interface DeepstreamClient<
-  Records,
+  Records extends Record<string, unknown> = Record<string, unknown>,
   Methods extends Record<string, RpcMethodDef> = Record<string, RpcMethodDef>,
 > {
   nuid: () => string

package/src/client.test-d.ts

@@ -1,5 +1,7 @@
-import make from './client.js'
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import make, { type DeepstreamClient } from './client.js'
 import { expectAssignable, expectError } from 'tsd'
+import type { Observable } from 'rxjs'
 
 interface Records extends Record<string, unknown> {
   o: {
@@ -48,6 +50,14 @@ interface Circular {
 
 const ds = make<Records>('')
 
+// Test that make() returns DeepstreamClient with appropriate generics
+expectAssignable<DeepstreamClient>(make(''))
+// When you want to accept "any client" regardless of Records type, use DeepstreamClient<any>
+expectAssignable<DeepstreamClient<any>>(make<Records>(''))
+expectAssignable<DeepstreamClient<any, any>>(make<Records>(''))
+expectAssignable<DeepstreamClient<any>>(ds)
+expectAssignable<DeepstreamClient<any, any>>(ds)
+
 expectAssignable<{ n0?: { n1: { n2: { n3: string } } } } | undefined>(await ds.record.get('n'))
 expectAssignable<{ n1: { n2: { n3: string } } } | undefined>(await ds.record.get('n', 'n0'))
 
@@ -86,9 +96,89 @@ expectError(ds.record.set('n', 'n1.x2', {}))
 expectError(ds.record.set('n', 'n1.n2.n3', { n4: 22 }))
 
 expectAssignable<string>(await ds.record.get('p', 'p1'))
+expectAssignable<string>(await ds.record.get('p', 'p1', { signal: new AbortController().signal }))
+expectAssignable<string>(await ds.record.get('p', { path: 'p1' }))
 expectAssignable<string | undefined>(await ds.record.get('p', 'p2'))
 expectAssignable<unknown>(await ds.record.get('p', 'x1'))
 
+// observe with options
+expectAssignable<Observable<{ p1: string; p2?: string; p3: { p4: string } }>>(
+  ds.record.observe('p', { signal: new AbortController().signal }),
+)
+expectAssignable<Observable<{ p1: string; p2?: string; p3: { p4: string } }>>(
+  ds.record.observe('p', { timeout: 5000 }),
+)
+expectAssignable<Observable<string>>(
+  ds.record.observe('p', 'p1', { signal: new AbortController().signal }),
+)
+expectAssignable<Observable<string>>(ds.record.observe('p', { path: 'p1', timeout: 5000 }))
+expectAssignable<Observable<string>>(
+  ds.record.observe('p', 'p1', 2, { signal: new AbortController().signal }),
+)
+expectAssignable<Observable<{ p1: string; p2?: string; p3: { p4: string } }>>(
+  ds.record.observe('p', 2, { timeout: 5000 }),
+)
+
+// observe2 with options
+expectAssignable<
+  Observable<{
+    name: string
+    version: string
+    state: number
+    data: { p1: string; p2?: string; p3: { p4: string } }
+  }>
+>(ds.record.observe2('p', { signal: new AbortController().signal }))
+expectAssignable<
+  Observable<{
+    name: string
+    version: string
+    state: number
+    data: { p1: string; p2?: string; p3: { p4: string } }
+  }>
+>(ds.record.observe2('p', { timeout: 5000 }))
+expectAssignable<
+  Observable<{
+    name: string
+    version: string
+    state: number
+    data: string
+  }>
+>(ds.record.observe2('p', 'p1', { signal: new AbortController().signal }))
+expectAssignable<
+  Observable<{
+    name: string
+    version: string
+    state: number
+    data: string
+  }>
+>(ds.record.observe2('p', { path: 'p1', timeout: 5000 }))
+expectAssignable<
+  Observable<{
+    name: string
+    version: string
+    state: number
+    data: string
+  }>
+>(ds.record.observe2('p', 'p1', 2, { signal: new AbortController().signal }))
+expectAssignable<
+  Observable<{
+    name: string
+    version: string
+    state: number
+    data: { p1: string; p2?: string; p3: { p4: string } }
+  }>
+>(ds.record.observe2('p', 2, { timeout: 5000 }))
+
+// update with options
+expectAssignable<Promise<void>>(
+  ds.record.update('p', (data) => data, { signal: new AbortController().signal }),
+)
+expectAssignable<Promise<void>>(ds.record.update('p', (data) => data, { timeout: 5000 }))
+expectAssignable<Promise<void>>(
+  ds.record.update('p', 'p1', (data) => data, { signal: new AbortController().signal }),
+)
+expectAssignable<Promise<void>>(ds.record.update('p', 'p1', (data) => data, { timeout: 5000 }))
+
 // Circular
 expectAssignable<string | undefined>(await ds.record.get('c', 'a.b1'))
 
@@ -96,11 +186,31 @@ expectAssignable<string | undefined>(await ds.record.get('c', 'a.b1'))
 //
 
 // getRecord
-const daRec = ds.record.getRecord('o')
-daRec.set({ o0: {} })
-
-daRec.update('o0', (x) => ({ ...x, o1: {} }))
-expectError(daRec.set('o0.x1', {}))
-daRec.set('o0.o1', {})
-expectError(daRec.update((x) => 'x'))
-expectError(daRec.update('o0', (x) => ({ ...x, o1: '22' })))
+const rec = ds.record.getRecord('o')
+rec.set({ o0: {} })
+
+rec.update('o0', (x) => ({ ...x, o1: {} }))
+expectError(rec.set('o0.x1', {}))
+rec.set('o0.o1', {})
+expectError(rec.update((x) => 'x'))
+expectError(rec.update('o0', (x) => ({ ...x, o1: '22' })))
+
+// when with options
+expectAssignable<Promise<typeof rec>>(rec.when())
+expectAssignable<Promise<typeof rec>>(rec.when(2))
+expectAssignable<Promise<typeof rec>>(rec.when({ timeout: 5000 }))
+expectAssignable<Promise<typeof rec>>(rec.when({ signal: new AbortController().signal }))
+expectAssignable<Promise<typeof rec>>(rec.when({ state: 2 }))
+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.update with options
+expectAssignable<Promise<void>>(rec.update((x) => x, { signal: new AbortController().signal }))
+expectAssignable<Promise<void>>(rec.update((x) => x, { timeout: 5000 }))
+expectAssignable<Promise<void>>(rec.update((x) => x, { state: 2 }))
+expectAssignable<Promise<void>>(
+  rec.update('o0', (x) => x, { signal: new AbortController().signal }),
+)
+expectAssignable<Promise<void>>(rec.update('o0', (x) => x, { timeout: 5000 }))
+expectAssignable<Promise<void>>(rec.update('o0', (x) => x, { state: 2 }))

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

@@ -3,11 +3,11 @@ import { Observable } from 'rxjs'
 export default class EventHandler {
   connected: boolean
   stats: EventStats
-  subscribe: (name: string, callback: () => void) => void
-  unsubscribe: (name: string, callback: () => void) => void
-  on: (name: string, callback: () => void) => this
-  once: (name: string, callback: () => void) => this
-  off: (name: string, callback: () => void) => this
+  subscribe: (name: string, callback: (data: unknown) => void) => void
+  unsubscribe: (name: string, callback: (data: unknown) => void) => void
+  on: (name: string, callback: (data: unknown) => void) => this
+  once: (name: string, callback: (data: unknown) => void) => this
+  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

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

@@ -1,6 +1,12 @@
 import type { Observable } from 'rxjs'
 import type DsRecord from './record.js'
-import type { EmptyObject, Get } from './record.js'
+import type {
+  EmptyObject,
+  Get,
+  UpdateOptions,
+  ObserveOptions,
+  ObserveOptionsWithPath,
+} from './record.js'
 
 type Lookup<Table, Name> = Name extends keyof Table ? Table[Name] : unknown
 
@@ -45,57 +51,92 @@ export default class RecordHandler<Records = Record<string, unknown>> {
   }
 
   update: {
-    // without path:
     <Name extends string>(
       name: Name,
       updater: (data: Lookup<Records, Name>) => Lookup<Records, Name> | EmptyObject,
+      options?: UpdateOptions,
     ): Promise<void>
 
-    // with path:
     <Name extends string, Path extends string | string[]>(
       name: Name,
       path: Path,
       updater: (data: Get<Lookup<Records, Name>, Path>) => Get<Lookup<Records, Name>, Path>,
+      options?: UpdateOptions,
     ): Promise<void>
   }
 
   observe: {
-    // without path:
-    <Name extends string>(name: Name): Observable<Lookup<Records, Name>>
+    <Name extends string>(name: Name, options: ObserveOptions): Observable<Lookup<Records, Name>>
 
-    // with path:
     <Name extends string, Path extends string | string[]>(
       name: Name,
-      path: Path,
+      options: ObserveOptionsWithPath<Path>,
+    ): Observable<Get<Lookup<Records, Name>, Path>>
+
+    <Name extends string>(
+      name: Name,
+      state?: number,
+      options?: ObserveOptions,
+    ): Observable<Lookup<Records, Name>>
+
+    <Name extends string, Path extends string | string[]>(
+      name: Name,
+      state?: number,
+      options?: ObserveOptionsWithPath<Path>,
     ): Observable<Get<Lookup<Records, Name>, Path>>
 
-    // with state:
-    <Name extends string>(name: Name, state: number): Observable<Lookup<Records, Name>>
+    <Name extends string, Path extends string | string[]>(
+      name: Name,
+      path: Path,
+      options?: ObserveOptionsWithPath<Path>,
+    ): Observable<Get<Lookup<Records, Name>, Path>>
 
-    // with path and state:
     <Name extends string, Path extends string | string[]>(
       name: Name,
       path: Path,
-      state: number,
+      state?: number,
+      options?: ObserveOptionsWithPath<Path>,
     ): Observable<Get<Lookup<Records, Name>, Path>>
   }
 
   get: {
-    // without path:
-    <Name extends string>(name: Name, state?: number): Promise<Lookup<Records, Name>>
+    <Name extends string>(name: Name, options: ObserveOptions): Promise<Lookup<Records, Name>>
+
+    <Name extends string, Path extends string | string[]>(
+      name: Name,
+      options: ObserveOptionsWithPath<Path>,
+    ): Promise<Get<Lookup<Records, Name>, Path>>
+
+    <Name extends string>(
+      name: Name,
+      state?: number,
+      options?: ObserveOptions,
+    ): Promise<Lookup<Records, Name>>
+
+    <Name extends string, Path extends string | string[]>(
+      name: Name,
+      state?: number,
+      options?: ObserveOptionsWithPath<Path>,
+    ): Promise<Get<Lookup<Records, Name>, Path>>
+
+    <Name extends string, Path extends string | string[]>(
+      name: Name,
+      path: Path,
+      options?: ObserveOptionsWithPath<Path>,
+    ): Promise<Get<Lookup<Records, Name>, Path>>
 
-    // with path:
     <Name extends string, Path extends string | string[]>(
       name: Name,
       path: Path,
       state?: number,
+      options?: ObserveOptionsWithPath<Path>,
     ): Promise<Get<Lookup<Records, Name>, Path>>
   }
 
   observe2: {
-    // without path:
     <Name extends string>(
       name: Name,
+      options: ObserveOptions,
     ): Observable<{
       name: string
       version: string
@@ -103,10 +144,9 @@ export default class RecordHandler<Records = Record<string, unknown>> {
       data: Lookup<Records, Name>
     }>
 
-    // with path:
     <Name extends string, Path extends string | string[]>(
       name: Name,
-      path: Path,
+      options: ObserveOptionsWithPath<Path>,
     ): Observable<{
       name: string
       version: string
@@ -114,10 +154,10 @@ export default class RecordHandler<Records = Record<string, unknown>> {
       data: Get<Lookup<Records, Name>, Path>
     }>
 
-    // with state:
     <Name extends string>(
       name: Name,
-      state: number,
+      state?: number,
+      options?: ObserveOptions,
     ): Observable<{
       name: string
       version: string
@@ -125,11 +165,33 @@ export default class RecordHandler<Records = Record<string, unknown>> {
       data: Lookup<Records, Name>
     }>
 
-    // with path and state:
+    <Name extends string, Path extends string | string[]>(
+      name: Name,
+      state?: number,
+      options?: ObserveOptionsWithPath<Path>,
+    ): Observable<{
+      name: string
+      version: string
+      state: number
+      data: Get<Lookup<Records, Name>, Path>
+    }>
+
+    <Name extends string, Path extends string | string[]>(
+      name: Name,
+      path: Path,
+      options?: ObserveOptionsWithPath<Path>,
+    ): Observable<{
+      name: string
+      version: string
+      state: number
+      data: Get<Lookup<Records, Name>, Path>
+    }>
+
     <Name extends string, Path extends string | string[]>(
       name: Name,
       path: Path,
-      state: number,
+      state?: number,
+      options?: ObserveOptionsWithPath<Path>,
     ): Observable<{
       name: string
       version: string

package/src/record/record.d.ts

@@ -33,12 +33,27 @@ export type GettablePossibleEmpty<Data> = keyof Data extends never
 export type SettablePossibleEmpty<Data> = Data | EmptyObject
 
 export interface WhenOptions {
-  timeout?: number
   signal?: AbortSignal
+  timeout?: number
+  state?: number
 }
 
 export interface UpdateOptions {
   signal?: AbortSignal
+  timeout?: number
+  state?: number
+}
+
+export interface ObserveOptions {
+  signal?: AbortSignal
+  timeout?: number
+  state?: number
+  dataOnly?: boolean
+  sync?: boolean
+}
+
+export interface ObserveOptionsWithPath<Path extends string | string[]> extends ObserveOptions {
+  path?: Path
 }
 
 export default class Record<Data = unknown> {
@@ -74,9 +89,8 @@ export default class Record<Data = unknown> {
 
   when: {
     (): Promise<Record<Data>>
-    (state: number): Promise<Record<Data>>
     (options: WhenOptions): Promise<Record<Data>>
-    (state: number, options: WhenOptions): Promise<Record<Data>>
+    (state: number, options?: WhenOptions): Promise<Record<Data>>
   }
 
   update: {