@nxtedition/deepstream.io-client-js 28.1.3 → 28.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/deepstream.io-client-js",
-  "version": "28.1.3",
+  "version": "28.1.5",
   "description": "the javascript client for deepstream.io",
   "homepage": "http://deepstream.io",
   "type": "module",
@@ -14,6 +14,7 @@
   "license": "Apache-2.0",
   "author": "deepstreamHub GmbH",
   "main": "src/client.js",
+  "types": "src/client.d.ts",
   "browser": {
     "ws": false
   },
@@ -45,6 +46,7 @@
     "xxhash-wasm": "^1.0.2"
   },
   "devDependencies": {
+    "@types/node": "^22.10.3",
     "eslint": "^9.14.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-config-standard": "^17.1.0",

package/src/client.d.ts

@@ -0,0 +1,104 @@
+import Record from './record/record.js'
+import RecordHandler, { RecordStats } from './record/record-handler.js'
+import EventHandler, { EventStats } from './event/event-handler.js'
+import RpcHandler, { RpcStats, RpcMethodDef } from './rpc/rpc-handler.js'
+
+export default function <Records, Methods>(
+  url: string,
+  options?: unknown,
+): DeepstreamClient<Records, Methods>
+
+export type { Record, RecordHandler, EventHandler, RpcHandler }
+
+type RecordStateConstants = Readonly<{
+  VOID: 0
+  CLIENT: 1
+  SERVER: 2
+  STALE: 3
+  PROVIDER: 4
+}>
+
+type ConnectionStateConstants = Readonly<{
+  CLOSED: 'CLOSED'
+  AWAITING_CONNECTION: 'AWAITING_CONNECTION'
+  CHALLENGING: 'CHALLENGING'
+  AWAITING_AUTHENTICATION: 'AWAITING_AUTHENTICATION'
+  AUTHENTICATING: 'AUTHENTICATING'
+  OPEN: 'OPEN'
+  ERROR: 'ERROR'
+  RECONNECTING: 'RECONNECTING'
+}>
+type ConnectionStateKey = keyof typeof ConnectionStateConstants
+type ConnectionStateName = (typeof ConnectionStateConstants)[ConnectionStateKey]
+
+type EventConstants = Readonly<{
+  CONNECTION_ERROR: 'connectionError'
+  CONNECTION_STATE_CHANGED: 'connectionStateChanged'
+  CONNECTED: 'connected'
+  MAX_RECONNECTION_ATTEMPTS_REACHED: 'MAX_RECONNECTION_ATTEMPTS_REACHED'
+  CONNECTION_AUTHENTICATION_TIMEOUT: 'CONNECTION_AUTHENTICATION_TIMEOUT'
+  NO_RPC_PROVIDER: 'NO_RPC_PROVIDER'
+  RPC_ERROR: 'RPC_ERROR'
+  TIMEOUT: 'TIMEOUT'
+  UNSOLICITED_MESSAGE: 'UNSOLICITED_MESSAGE'
+  MESSAGE_DENIED: 'MESSAGE_DENIED'
+  NOT_CONNECTED: 'NOT_CONNECTED'
+  MESSAGE_PARSE_ERROR: 'MESSAGE_PARSE_ERROR'
+  NOT_AUTHENTICATED: 'NOT_AUTHENTICATED'
+  MESSAGE_PERMISSION_ERROR: 'MESSAGE_PERMISSION_ERROR'
+  LISTENER_EXISTS: 'LISTENER_EXISTS'
+  PROVIDER_ERROR: 'PROVIDER_ERROR'
+  CACHE_ERROR: 'CACHE_ERROR'
+  UPDATE_ERROR: 'UPDATE_ERROR'
+  USER_ERROR: 'USER_ERROR'
+  REF_ERROR: 'REF_ERROR'
+  PROVIDER_EXISTS: 'PROVIDER_EXISTS'
+  NOT_LISTENING: 'NOT_LISTENING'
+  NOT_PROVIDING: 'NOT_PROVIDING'
+  LISTENER_ERROR: 'LISTENER_ERROR'
+  TOO_MANY_AUTH_ATTEMPTS: 'TOO_MANY_AUTH_ATTEMPTS'
+  IS_CLOSED: 'IS_CLOSED'
+  RECORD_NOT_FOUND: 'RECORD_NOT_FOUND'
+  NOT_SUBSCRIBED: 'NOT_SUBSCRIBED'
+}>
+type EventKey = keyof typeof EventConstants
+type EventName = (typeof EventConstants)[EventKey]
+
+export interface DeepstreamClient<
+  Records = Record<string, unknown>,
+  Methods = Record<string, RpcMethodDef>,
+> {
+  nuid: () => string
+  event: EventHandler
+  rpc: RpcHandler<Methods>
+  record: RecordHandler<Records>
+  user: string | null
+  on: (evt: EventName, callback: (...args: unknown[]) => void) => void
+  off: (evt: EventName, callback: (...args: unknown[]) => void) => void
+  getConnectionState: () => ConnectionStateName
+  close: () => void
+  login: unknown
+  stats: {
+    record: RecordStats
+    rpc: RpcStats
+    event: EventStats
+  }
+
+  isSameOrNewer(a: string, b: string): boolean
+
+  CONSTANTS: {
+    CONNECTION_STATE: ConnectionStateConstants
+    RECORD_STATE: RecordStateConstants
+    EVENT: EventConstants
+  }
+}
+
+export interface ProvideOptions {
+  recursive?: boolean
+  stringify?: ((input: unknown) => string) | null
+}
+
+export interface SyncOptions {
+  signal?: AbortSignal
+  timeout?: number
+}

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

@@ -0,0 +1,20 @@
+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
+  observe: <Data>(name: string) => Observable<Data>
+  emit: <Data>(name: string, data: Data) => void
+  provide: (pattern: string, callback: (name: string) => void, options: unknown) => () => void
+}
+
+export interface EventStats {
+  emitted: number
+  listeners: number
+  events: number
+}

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

@@ -0,0 +1,157 @@
+import type { Observable } from 'rxjs'
+import Record from './record.js'
+
+type Paths<T> = keyof T
+type Get<Data, Path extends string> = Path extends keyof Data ? Data[Path] : unknown
+
+export default class RecordHandler<Records> {
+  VOID: 0
+  CLIENT: 1
+  SERVER: 2
+  STALE: 3
+  PROVIDER: 4
+
+  JSON: {
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+    EMPTY: Readonly<{}>
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+    EMPTY_OBJ: Readonly<{}>
+    EMPTY_ARR: Readonly<unknown[]>
+  }
+
+  connected: boolean
+  stats: RecordStats
+  getRecord: <Name extends keyof Records, Data extends Records[Name] = Records[Name]>(
+    name: Name,
+  ) => Record<Data>
+
+  provide: <Data>(
+    pattern: string,
+    callback: (key: string) => Data,
+    optionsOrRecursive?: ProvideOptions | boolean,
+  ) => void | (() => void)
+
+  sync: (options?: SyncOptions) => Promise<void>
+
+  set: {
+    // without path:
+    <Name extends keyof Records>(name: Name, data: Records[Name]): void
+
+    // with path:
+    <Name extends keyof Records, Data extends Records[Name], Path extends Paths<Data>>(
+      name: Name,
+      path: Path,
+      data: Get<Data, Path>,
+    ): void
+  }
+
+  update: {
+    // without path:
+    <Name extends keyof Records, Data extends Records[Name]>(
+      name: Name,
+      updater: (data: Data) => Data,
+    ): Promise<void>
+
+    // with path:
+    <Name extends keyof Records, Data extends Records[Name], Path extends Paths<Data>>(
+      name: Name,
+      path: Path,
+      updater: (data: Get<Data, Path>) => Get<Data, Path>,
+    ): Promise<void>
+  }
+
+  observe: {
+    // without path:
+    <Name extends keyof Records, Data extends Records[Name]>(name: Name): Observable<Data>
+
+    // with path:
+    <Name extends keyof Records, Data extends Records[Name], Path extends Paths<Data> & string>(
+      name: Name,
+      path: Path,
+    ): Observable<Get<Data, Path>>
+
+    // with state:
+    <Name extends keyof Records, Data extends Records[Name]>(
+      name: Name,
+      state: number,
+    ): Observable<Data>
+
+    // with path and state:
+    <Name extends keyof Records, Data extends Records[Name], Path extends Paths<Data> & string>(
+      name: Name,
+      path: Path,
+      state: number,
+    ): Observable<Get<Data, Path>>
+  }
+
+  get: {
+    // without path:
+    <Name extends keyof Records, Data extends Records[Name]>(
+      name: Name,
+      state?: number,
+    ): Promise<Data>
+
+    // with path:
+    <Name extends keyof Records, Data extends Records[Name], Path extends Paths<Data> & string>(
+      name: Name,
+      path?: Path,
+      state?: number,
+    ): Promise<Get<Data, Path>>
+  }
+
+  observe2: {
+    // without path:
+    <Name extends keyof Records, Data extends Records[Name]>(
+      name: Name,
+    ): Observable<{
+      name: Name
+      version: string
+      state: number
+      data: Data
+    }>
+
+    // with path:
+    <Name extends keyof Records, Data extends Records[Name], Path extends Paths<Data> & string>(
+      name: Name,
+      path: Path,
+    ): Observable<{
+      name: Name
+      version: Get<Data, Path>
+      state: number
+      data: Data
+    }>
+
+    // with state:
+    <Name extends keyof Records, Data extends Records[Name]>(
+      name: Name,
+      state: number,
+    ): Observable<{
+      name: Name
+      version: Get<Data, Path>
+      state: number
+      data: Data
+    }>
+
+    // with path and state:
+    <Name extends keyof Records, Data extends Records[Name], Path extends Paths<Data> & string>(
+      name: Name,
+      path: Path,
+      state: number,
+    ): Observable<{
+      name: Name
+      version: Get<Data, Path>
+      state: number
+      data: Get<Data, Path>
+    }>
+  }
+}
+
+export interface RecordStats {
+  updating: number
+  created: number
+  destroyed: number
+  records: number
+  pruning: number
+  patching: number
+  subscriptions: number
+}

package/src/record/record.d.ts

@@ -0,0 +1,73 @@
+import RecordHandler from './record-handler.js'
+
+type Paths<T> = keyof T
+type Get<Data, Path extends string> = Path extends keyof Data ? Data[Path] : unknown
+
+export interface WhenOptions {
+  state?: number
+  timeout?: number
+  signal?: AbortSignal
+}
+
+export interface UpdateOptions {
+  signal?: AbortSignal
+}
+
+export default class Record<Data> {
+  constructor(name: string, handler: RecordHandler)
+
+  readonly name: string
+  readonly version: string
+  readonly data: Data
+  readonly state: number
+  readonly refs: number
+
+  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>
+
+  get: {
+    // with path
+    <Path extends Paths<Data>, DataAtPath extends Get<Data, Path> = Get<Data, Path>>(
+      path: Path,
+    ): DataAtPath
+    // without path
+    (): Data
+    // implementation
+    <Path extends Paths<Data>, DataAtPath extends Get<Data, Path> = Get<Data, Path>>(
+      path?: Path,
+    ): Path extends undefined ? Data : DataAtPath
+  }
+
+  set: {
+    // with path
+    <Path extends Paths<Data>, DataAtPath extends Get<Data, Path>>(
+      path: Path,
+      dataAtPath: DataAtPath,
+    ): void
+    // without path
+    (data: Data): void
+    // implementation
+    <Path extends Paths<Data>, DataAtPath extends Get<Data, Path>>(
+      ...args: [pathOrData: Path | Data, value?: DataAtPath]
+    ): void
+  }
+
+  when: {
+    (): Promise<Record<Data>>
+    (state: number): Promise<Record<Data>>
+    (options: WhenOptions): Promise<Record<Data>>
+    (state: number, options: WhenOptions): Promise<Record<Data>>
+  }
+
+  update<Path extends Paths<Data>, PathOrUpdater extends Path | ((data: Data) => Data)>(
+    ...args: PathOrUpdater extends Path
+      ? [
+          path: Path,
+          updater: (dataAtPath: Get<Data, Path>) => Get<Data, Path>,
+          options?: UpdateOptions,
+        ]
+      : [updater: PathOrUpdater, options?: UpdateOptions]
+  ): Promise<void>
+}

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

@@ -0,0 +1,31 @@
+import RpcResponse from './rpc-response.js'
+
+export type RpcMethodDef = [arguments: unknown, response: unknown]
+
+export default class RpcHandler<Methods extends Record<string, RpcMethodDef>> {
+  connected: boolean
+  stats: RpcStats
+
+  provide: <Name extends keyof Methods>(
+    name: Name,
+    callback: (args: Methods[Name][0], response: RpcResponse<Methods[Name][1]>) => void,
+  ) => UnprovideFn
+
+  unprovide: <Name extends keyof Methods>(name: Name) => void
+
+  make: {
+    <Name extends keyof Methods>(
+      name: Name,
+      args: Methods[Name][0],
+      callback: (error: unknown, response: Methods[Name][1]) => void,
+    ): void
+    <Name extends keyof Methods>(name: Name, args: Methods[Name][0]): Promise<Methods[Name][1]>
+  }
+}
+
+type UnprovideFn = () => void
+
+export interface RpcStats {
+  listeners: number
+  rpcs: number
+}

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

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

package/src/test.ts

@@ -0,0 +1,78 @@
+import make from './client.js'
+
+interface Records {
+  test: {
+    name: string
+    age: number
+  }
+  foo: {
+    bar: number
+  }
+  num: number
+  str: string
+}
+
+interface Methods {
+  test: [{ name: string }, { age: number }]
+}
+
+const ds = make<Records, Methods>('http://localhost:3000')
+
+ds.record.provide('test', () => {})
+
+ds.record.set('test', {
+  name: 23,
+})
+
+ds.record.set('foo', { value: 'namn' })
+
+ds.record.set('test', 'name', '23')
+
+ds.record.provide('test', () => {
+  return {
+    name: 23,
+  }
+})
+
+ds.record.update('test', 'name', (name) => {
+  return name
+})
+
+const r = ds.record.getRecord('test')
+//const name = r.get('bar')
+
+r.update('name', (name) => name + 'a2', { signal: new AbortSignal() })
+
+r.update((name) => ({ name: 'hej', age: 22 }))
+
+r.update('age', (age) => age + 1, { signal: new AbortSignal() })
+
+r.set({ age: 23, name: 'test' })
+r.set({ age: '23', name: 'test' })
+
+r.set('name', 22)
+r.set('name', 'name')
+r.set('age', true)
+r.set('age', 22)
+
+const a1 = r.get()
+const a2 = r.get('age')
+const a3 = r.get('name')
+const a4 = r.get('what')
+
+const name = r.get('age')
+
+const s = Object.freeze({})
+
+ds.record.JSON.EMPTY
+
+ds.event.provide('test', (what) => {
+}, {})
+
+const a = ds.rpc.provide('test', (args, response) => {
+  console.log(args.name)
+  response.send({ age: 22 })
+})
+
+a()
+

package/src/utils/unicast-listener.js

@@ -84,11 +84,11 @@ export default class Listener {
           },
         })
 
+        this._subscriptions.set(name, subscription)
+
         subscription.add(() => {
           this._subscriptions.delete(name)
         })
-
-        this._subscriptions.set(name, subscription)
       } else {
         this._connection.sendMsg(this._topic, C.ACTIONS.LISTEN_REJECT, [this._pattern, name])
       }