@nxtedition/deepstream.io-client-js 30.0.1 → 31.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/deepstream.io-client-js",
-  "version": "30.0.1",
+  "version": "31.0.0",
   "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
   },
@@ -39,27 +40,29 @@
     "component-emitter2": "^1.3.5",
     "invariant": "^2.2.4",
     "lodash.clonedeep": "^4.5.0",
-    "utf-8-validate": "^6.0.4",
+    "utf-8-validate": "^6.0.5",
     "ws": "^8.18.0",
     "xuid": "^4.1.3",
     "xxhash-wasm": "^1.0.2"
   },
   "devDependencies": {
-    "eslint": "^9.9.0",
+    "@types/node": "^22.10.3",
+    "eslint": "^9.14.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-config-standard": "^17.1.0",
-    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-n": "^17.10.2",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-n": "^17.12.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-promise": "^7.1.0",
-    "husky": "^9.1.4",
-    "lint-staged": "^15.2.8",
-    "mitata": "^0.1.11",
+    "husky": "^9.1.6",
+    "lint-staged": "^15.2.10",
+    "mitata": "^1.0.10",
     "pinst": "^3.0.0",
     "prettier": "^3.3.3",
     "rxjs": "^7.8.1",
-    "typescript": "^5.5.4",
-    "typescript-eslint": "^8.0.1"
+    "type-fest": "^4.33.0",
+    "typescript": "^5.6.3",
+    "typescript-eslint": "^8.12.2"
   },
   "peerDependencies": {
     "rxjs": ">=6.x"

package/src/client.d.ts

@@ -0,0 +1,104 @@
+import type Record from './record/record.js'
+import type RecordHandler, { RecordStats } from './record/record-handler.js'
+import type EventHandler, { EventStats } from './event/event-handler.js'
+import type 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/constants/constants.js

@@ -81,6 +81,7 @@ ACTIONS.CHALLENGE = 'CH'
 ACTIONS.CHALLENGE_RESPONSE = 'CHR'
 ACTIONS.READ = 'R'
 ACTIONS.UPDATE = 'U'
+ACTIONS.PUT = 'P'
 ACTIONS.SUBSCRIBE = 'S'
 ACTIONS.SYNC = 'SY'
 ACTIONS.UNSUBSCRIBE = 'US'

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/message/connection.js

@@ -199,7 +199,7 @@ Connection.prototype._onError = function (err) {
   }
 
   if (err.code === 'ECONNRESET' || err.code === 'ECONNREFUSED') {
-    err.message = "Can't t! Deepstream server unreachable on " + this._url
+    err.message = "Can't connect! Deepstream server unreachable on " + this._url
   }
 
   this._client._$onError(C.TOPIC.CONNECTION, C.EVENT.CONNECTION_ERROR, err)

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

@@ -0,0 +1,158 @@
+import type { Observable } from 'rxjs'
+import type Record, { EmptyObject, GettablePossibleEmpty, SettablePossibleEmpty } 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: {
+    EMPTY: EmptyObject
+    EMPTY_OBJ: EmptyObject
+    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: SettablePossibleEmpty<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: Readonly<GettablePossibleEmpty<Data>>) => SettablePossibleEmpty<Data>,
+    ): Promise<void>
+
+    // with path:
+    <Name extends keyof Records, Data extends Records[Name], Path extends Paths<Data>>(
+      name: Name,
+      path: Path,
+      updater: (data: Readonly<Get<Data, Path>> | undefined) => Get<Data, Path>,
+    ): Promise<void>
+  }
+
+  observe: {
+    // without path:
+    <Name extends keyof Records, Data extends Records[Name]>(
+      name: Name,
+    ): Observable<GettablePossibleEmpty<Data>>
+
+    // with path:
+    <Name extends keyof Records, Data extends Records[Name], Path extends Paths<Data> & string>(
+      name: Name,
+      path: Path,
+    ): Observable<Get<Data, Path> | undefined>
+
+    // with state:
+    <Name extends keyof Records, Data extends Records[Name]>(
+      name: Name,
+      state: number,
+    ): Observable<GettablePossibleEmpty<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> | undefined>
+  }
+
+  get: {
+    // without path:
+    <Name extends keyof Records, Data extends Records[Name]>(
+      name: Name,
+      state?: number,
+    ): Promise<GettablePossibleEmpty<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> | undefined>
+  }
+
+  observe2: {
+    // without path:
+    <Name extends keyof Records, Data extends Records[Name]>(
+      name: Name,
+    ): Observable<{
+      name: Name
+      version: string
+      state: number
+      data: GettablePossibleEmpty<Data>
+    }>
+
+    // with path:
+    <Name extends keyof Records, Data extends Records[Name], Path extends Paths<Data> & string>(
+      name: Name,
+      path: Path,
+    ): Observable<{
+      name: Name
+      version: string
+      state: number
+      data: Get<Data, Path> | undefined
+    }>
+
+    // with state:
+    <Name extends keyof Records, Data extends Records[Name]>(
+      name: Name,
+      state: number,
+    ): Observable<{
+      name: Name
+      version: string
+      state: number
+      data: GettablePossibleEmpty<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: string
+      state: number
+      data: Get<Data, Path> | undefined
+    }>
+  }
+}
+
+export interface RecordStats {
+  updating: number
+  created: number
+  destroyed: number
+  records: number
+  pruning: number
+  patching: number
+  subscriptions: number
+}