@nxtedition/deepstream.io-client-js 32.0.21 → 32.0.22

package/package.json

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

package/src/client.d.ts

@@ -3,25 +3,14 @@ import type { Paths, Get } from './record/record.js'
 import type RecordHandler from './record/record-handler.js'
 import type { RecordStats, ProvideOptions, SyncOptions } from './record/record-handler.js'
 import type EventHandler from './event/event-handler.js'
-import type { EventStats, EventProvideOptions } from './event/event-handler.js'
+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?: DeepstreamClientOptions): DeepstreamClient<Records, Methods>
+>(url: string, options?: unknown): DeepstreamClient<Records, Methods>
 
 export type {
   DsRecord,
@@ -30,12 +19,9 @@ export type {
   RpcHandler,
   RpcMethodDef,
   ProvideOptions,
-  EventProvideOptions,
   SyncOptions,
   Paths,
   Get,
-  ConnectionStateName,
-  DeepstreamErrorEventName,
 }
 
 type RecordStateConstants = Readonly<{
@@ -91,36 +77,6 @@ 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 DeepstreamMessage {
-  raw: string | null
-  topic: string | null
-  action: string | null
-  data: string[]
-}
-
-export interface DeepstreamClientEventMap {
-  connectionStateChanged: (state: ConnectionStateName) => void
-  connected: (connected: boolean) => void
-  MAX_RECONNECTION_ATTEMPTS_REACHED: (attempt: number) => void
-  error: (error: DeepstreamError) => void
-  recv: (message: DeepstreamMessage) => void
-  send: (message: DeepstreamMessage) => void
-}
-
-type DeepstreamErrorEventMap = {
-  [K in DeepstreamErrorEventName]: (error: DeepstreamError) => void
-}
 
 export interface DeepstreamClient<
   Records extends Record<string, unknown> = Record<string, unknown>,
@@ -131,21 +87,11 @@ export interface DeepstreamClient<
   rpc: RpcHandler<Methods>
   record: RecordHandler<Records>
   user: string | null
-  on<K extends keyof (DeepstreamClientEventMap & DeepstreamErrorEventMap)>(
-    evt: K,
-    callback: (DeepstreamClientEventMap & DeepstreamErrorEventMap)[K],
-  ): this
-  off<K extends keyof (DeepstreamClientEventMap & DeepstreamErrorEventMap)>(
-    evt: K,
-    callback: (DeepstreamClientEventMap & DeepstreamErrorEventMap)[K],
-  ): this
+  on: (evt: EventName, callback: (...args: unknown[]) => void) => void
+  off: (evt: EventName, callback: (...args: unknown[]) => void) => void
   getConnectionState: () => ConnectionStateName
   close: () => void
-  login(callback: (success: boolean, authData: unknown) => void): this
-  login(
-    authParams: Record<string, unknown>,
-    callback: (success: boolean, authData: unknown) => void,
-  ): this
+  login: unknown
   stats: {
     record: RecordStats
     rpc: RpcStats

package/src/client.test-d.ts

@@ -1,8 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import make, { type DeepstreamClient, type DeepstreamError } from './client.js'
+import make, { type DeepstreamClient } from './client.js'
 import { expectAssignable, expectError, expectType } from 'tsd'
 import type { Observable } from 'rxjs'
-import type { EmptyObject } from 'type-fest'
 
 interface Records extends Record<string, unknown> {
   o: {
@@ -23,11 +22,6 @@ interface Records extends Record<string, unknown> {
       }
     }
   }
-  possiblyEmpty:
-    | {
-        pe1: string
-      }
-    | EmptyObject
   c: Circular
   m: {
     m1: string
@@ -68,7 +62,7 @@ expectAssignable<{ n0?: { n1: { n2: { n3: string } } } } | undefined>(await ds.r
 expectAssignable<{ n1: { n2: { n3: string } } } | undefined>(await ds.record.get('n', 'n0'))
 
 // set withouth path
-ds.record.set('possiblyEmpty', {}) // empty should always work
+ds.record.set('n', {}) // empty should always work
 ds.record.set('n', { n0: { n1: { n2: { n3: 'test' } } } })
 expectError(ds.record.set('n', { n0: {} })) // nested props are required
 
@@ -102,14 +96,10 @@ 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<{ name: string; version: string; state: number; data: string }>(
-  await ds.record.get2('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'))
-expectAssignable<string | undefined>(await ds.record.get('possiblyEmpty', 'pe1'))
 
 // observe with options
 expectAssignable<Observable<{ p1: string; p2?: string; p3: { p4: string } }>>(
@@ -189,16 +179,6 @@ 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'))
 
@@ -230,19 +210,6 @@ 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 }))
@@ -253,68 +220,7 @@ 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', () => {}))
-
-// 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) => {}))

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

@@ -4,22 +4,13 @@ export default class EventHandler {
   connected: boolean
   stats: EventStats
   subscribe: (name: string, callback: (data: unknown) => void) => void
-  unsubscribe: (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: EventProvideOptions,
-  ) => (() => void) | void
-}
-
-export interface EventProvideOptions {
-  mode?: 'unicast' | (string & {})
-  stringify?: ((input: unknown) => string) | null
+  provide: (pattern: string, callback: (name: string) => void, options: unknown) => () => void
 }
 
 export interface EventStats {

package/src/event/event-handler.js

@@ -71,21 +71,21 @@ EventHandler.prototype.unsubscribe = function (name, callback) {
   }
 }
 
-EventHandler.prototype.on = function (name, callback) {
+EventHandler.on = function (name, callback) {
   this.subscribe(name, callback)
   return this
 }
 
-EventHandler.prototype.once = function (name, callback) {
+EventHandler.once = function (name, callback) {
   const fn = (...args) => {
-    this.unsubscribe(name, fn)
+    this.unsubscribe(fn)
     callback(...args)
   }
   this.subscribe(name, fn)
   return this
 }
 
-EventHandler.prototype.off = function (name, callback) {
+EventHandler.off = function (name, callback) {
   this.unsubscribe(name, callback)
   return this
 }

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

@@ -1,6 +1,12 @@
 import type { Observable } from 'rxjs'
 import type DsRecord from './record.js'
-import type { Get, UpdateOptions, ObserveOptions, ObserveOptionsWithPath } from './record.js'
+import type {
+  EmptyObject,
+  Get,
+  UpdateOptions,
+  ObserveOptions,
+  ObserveOptionsWithPath,
+} from './record.js'
 
 type Lookup<Table, Name> = Name extends keyof Table ? Table[Name] : unknown
 
@@ -26,8 +32,8 @@ export default class RecordHandler<Records = Record<string, unknown>> {
   }
 
   JSON: {
-    EMPTY: Record<string, unknown>
-    EMPTY_OBJ: Record<string, unknown>
+    EMPTY: EmptyObject
+    EMPTY_OBJ: EmptyObject
     EMPTY_ARR: []
   }
 
@@ -40,44 +46,13 @@ export default class RecordHandler<Records = Record<string, unknown>> {
     pattern: string,
     callback: (key: string) => unknown,
     optionsOrRecursive?: ProvideOptions | boolean,
-  ) => Disposer | void
-
-  put: (
-    name: string,
-    version: string,
-    data: Record<string, unknown> | null,
-    parent?: string,
-  ) => void
-
-  getAsync: {
-    <Name extends string>(
-      name: Name,
-      options: ObserveOptions,
-    ):
-      | { value: Lookup<Records, Name>; async: false }
-      | { value: Promise<Lookup<Records, Name>>; async: true }
-
-    <Name extends string, Path extends string | string[]>(
-      name: Name,
-      path: Path,
-      options?: ObserveOptions,
-    ):
-      | { value: Get<Lookup<Records, Name>, Path>; async: false }
-      | { value: Promise<Get<Lookup<Records, Name>, Path>>; async: true }
-
-    <Name extends string>(
-      name: Name,
-      state?: number,
-    ):
-      | { value: Lookup<Records, Name>; async: false }
-      | { value: Promise<Lookup<Records, Name>>; async: true }
-  }
+  ) => Disposer
 
   sync: (options?: SyncOptions) => Promise<void>
 
   set: {
     // without path:
-    <Name extends string>(name: Name, data: Lookup<Records, Name>): void
+    <Name extends string>(name: Name, data: Lookup<Records, Name> | EmptyObject): void
 
     // with path:
     <Name extends string, Path extends string | string[]>(
@@ -92,17 +67,14 @@ export default class RecordHandler<Records = Record<string, unknown>> {
   update: {
     <Name extends string>(
       name: Name,
-      updater: (data: Lookup<Records, Name>, version: string) => Lookup<Records, Name>,
+      updater: (data: Lookup<Records, Name>) => Lookup<Records, Name> | EmptyObject,
       options?: UpdateOptions,
     ): Promise<void>
 
     <Name extends string, Path extends string | string[]>(
       name: Name,
       path: Path,
-      updater: (
-        data: Get<Lookup<Records, Name>, Path>,
-        version: string,
-      ) => Get<Lookup<Records, Name>, Path>,
+      updater: (data: Get<Lookup<Records, Name>, Path>) => Get<Lookup<Records, Name>, Path>,
       options?: UpdateOptions,
     ): Promise<void>
   }
@@ -141,73 +113,6 @@ export default class RecordHandler<Records = Record<string, unknown>> {
     ): Observable<Get<Lookup<Records, Name>, Path>>
   }
 
-  observe2: {
-    <Name extends string>(
-      name: Name,
-      options: ObserveOptions,
-    ): Observable<{
-      name: string
-      version: string
-      state: number
-      data: Lookup<Records, Name>
-    }>
-
-    <Name extends string, Path extends string | string[]>(
-      name: Name,
-      options: ObserveOptionsWithPath<Path>,
-    ): Observable<{
-      name: string
-      version: string
-      state: number
-      data: Get<Lookup<Records, Name>, Path>
-    }>
-
-    <Name extends string>(
-      name: Name,
-      state?: number,
-      options?: ObserveOptions,
-    ): Observable<{
-      name: string
-      version: string
-      state: number
-      data: Lookup<Records, Name>
-    }>
-
-    <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,
-      options?: ObserveOptionsWithPath<Path>,
-    ): Observable<{
-      name: string
-      version: string
-      state: number
-      data: Get<Lookup<Records, Name>, Path>
-    }>
-  }
-
   get: {
     <Name extends string>(name: Name, options: ObserveOptions): Promise<Lookup<Records, Name>>
 
@@ -242,11 +147,11 @@ export default class RecordHandler<Records = Record<string, unknown>> {
     ): Promise<Get<Lookup<Records, Name>, Path>>
   }
 
-  get2: {
+  observe2: {
     <Name extends string>(
       name: Name,
       options: ObserveOptions,
-    ): Promise<{
+    ): Observable<{
       name: string
       version: string
       state: number
@@ -256,7 +161,7 @@ export default class RecordHandler<Records = Record<string, unknown>> {
     <Name extends string, Path extends string | string[]>(
       name: Name,
       options: ObserveOptionsWithPath<Path>,
-    ): Promise<{
+    ): Observable<{
       name: string
       version: string
       state: number
@@ -267,7 +172,7 @@ export default class RecordHandler<Records = Record<string, unknown>> {
       name: Name,
       state?: number,
       options?: ObserveOptions,
-    ): Promise<{
+    ): Observable<{
       name: string
       version: string
       state: number
@@ -278,7 +183,7 @@ export default class RecordHandler<Records = Record<string, unknown>> {
       name: Name,
       state?: number,
       options?: ObserveOptionsWithPath<Path>,
-    ): Promise<{
+    ): Observable<{
       name: string
       version: string
       state: number
@@ -289,7 +194,7 @@ export default class RecordHandler<Records = Record<string, unknown>> {
       name: Name,
       path: Path,
       options?: ObserveOptionsWithPath<Path>,
-    ): Promise<{
+    ): Observable<{
       name: string
       version: string
       state: number
@@ -301,7 +206,7 @@ export default class RecordHandler<Records = Record<string, unknown>> {
       path: Path,
       state?: number,
       options?: ObserveOptionsWithPath<Path>,
-    ): Promise<{
+    ): Observable<{
       name: string
       version: string
       state: number
@@ -318,13 +223,12 @@ export interface RecordStats {
   pruning: number
   patching: number
   subscriptions: number
-  listeners: number
 }
 
 export interface ProvideOptions {
   recursive?: boolean
   stringify?: ((input: unknown) => string) | null
-  mode?: null | 'unicast' | (string & {})
+  mode: undefined | null | 'unicast'
 }
 
 export interface SyncOptions {

package/src/record/record.d.ts

@@ -1,15 +1,36 @@
 import type RecordHandler from './record-handler.js'
-import type { Get as _Get, AllUnionFields } from 'type-fest'
-export type { Paths } from 'type-fest'
+import type { Get, EmptyObject, SingleKeyObject } from 'type-fest'
+export type { Get, Paths, EmptyObject } from 'type-fest'
 
-// HACK: Wrap type-fest's Get to get rid of EmptyObject from union
-type RemoveSymbolKeys<T> = {
-  [K in keyof T as K extends symbol ? never : K]: T[K]
-}
-export type Get<BaseType, Path extends string | readonly string[]> = _Get<
-  RemoveSymbolKeys<AllUnionFields<BaseType>>,
-  Path
->
+// When getting, for convenience, we say the data might be partial under some
+// circumstances.
+//
+// When you e.g. do record.get or record.update, there is always a possibility
+// that the data object is empty. The naive correct type for that would be
+// `Data | EmptyObject`. However, that forces the user to always type guard
+// against the empty object case. This type tries to allow the user to skip
+// that check in some cases, where it should be safe to do so.
+export type GettablePossibleEmpty<Data> = keyof Data extends never
+  ? EmptyObject // If there are no keys at all
+  : Partial<Data> extends Data
+    ? // All properties in Data are already optional, so we can safely return it
+      // as is. The user just need to check the properties themselves instead.
+      Data
+    : SingleKeyObject<Data> extends never
+      ? // There are more than one property in Data, and some of them are
+          // required. That means that the user must always check for the empty
+          // object case.
+          Data | EmptyObject
+      : // There is exactly one property in Data, and it is required. In this
+        // particular case, we can safely use Data as the "empty" type, but
+        // with the single property turned optional.
+        {
+          [K in keyof Data]+?: Data[K]
+        }
+
+// When setting the data must fully adhere to the Data type, or exactly an
+// empty object.
+export type SettablePossibleEmpty<Data> = Data | EmptyObject
 
 export interface WhenOptions {
   signal?: AbortSignal
@@ -24,7 +45,6 @@ export interface UpdateOptions {
 }
 
 export interface ObserveOptions {
-  key?: string
   signal?: AbortSignal
   timeout?: number
   state?: number
@@ -47,21 +67,12 @@ export default class Record<Data = unknown> {
 
   ref(): Record<Data>
   unref(): 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>
+  subscribe(callback: (record: Record<Data>) => void, opaque?: unknown): Record<Data>
+  unsubscribe(callback: (record: Record<Data>) => void, opaque?: unknown): Record<Data>
 
   get: {
     // with path
     <P extends string | string[]>(path: P): Get<Data, P>
-    // with function mapper
-    <R>(fn: (data: Data) => R): R
     // without path
     (): Data
     (path: undefined | string | string[]): unknown
@@ -74,7 +85,7 @@ export default class Record<Data = unknown> {
       dataAtPath: unknown extends Get<Data, P> ? never : Get<Data, P>,
     ): void
     // without path
-    (data: Data): void
+    (data: SettablePossibleEmpty<Data>): void
   }
 
   when: {
@@ -86,13 +97,13 @@ export default class Record<Data = unknown> {
   update: {
     // without path
     (
-      updater: (data: Readonly<Data>, version: string) => Data,
+      updater: (data: Readonly<Data>) => SettablePossibleEmpty<Data>,
       options?: UpdateOptions,
     ): Promise<void>
     // with path
     <P extends string | string[]>(
       path: P,
-      updater: (dataAtPath: Readonly<Get<Data, P>>, version: string) => Get<Data, P>,
+      updater: (dataAtPath: Readonly<Get<Data, P>>) => Get<Data, P>,
       options?: UpdateOptions,
     ): Promise<void>
   }

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

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

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

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

package/src/utils/utils.js

@@ -83,6 +83,14 @@ export function setTimeout(callback, timeoutDuration) {
   }
 }
 
+export function setInterval(callback, intervalDuration) {
+  if (intervalDuration !== null) {
+    return setInterval(callback, intervalDuration)
+  } else {
+    return -1
+  }
+}
+
 export function compareRev(a, b) {
   if (!a) {
     return b ? -1 : 0

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

@@ -1,40 +0,0 @@
-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/utils/multicast-listener.js

@@ -1,252 +0,0 @@
-import * as rxjs from 'rxjs'
-import * as C from '../constants/constants.js'
-import { h64ToString, findBigIntPaths } from '../utils/utils.js'
-
-export default class Listener {
-  constructor(topic, pattern, callback, handler, { recursive = false, stringify = null } = {}) {
-    this._topic = topic
-    this._pattern = pattern
-    this._callback = callback
-    this._handler = handler
-    this._client = this._handler._client
-    this._connection = this._handler._connection
-    this._subscriptions = new Map()
-    this._recursive = recursive
-    this._stringify = stringify || JSON.stringify
-
-    this._$onConnectionStateChange()
-  }
-
-  get connected() {
-    return this._connection.connected
-  }
-
-  get stats() {
-    return {
-      subscriptions: this._subscriptions.size,
-    }
-  }
-
-  _$destroy() {
-    this._reset()
-
-    if (this.connected) {
-      this._connection.sendMsg(this._topic, C.ACTIONS.UNLISTEN, [this._pattern])
-    }
-  }
-
-  _$onMessage(message) {
-    if (!this.connected) {
-      this._client._$onError(
-        C.TOPIC.RECORD,
-        C.EVENT.NOT_CONNECTED,
-        new Error('received message while not connected'),
-        message,
-      )
-      return
-    }
-
-    const name = message.data[1]
-
-    if (message.action === C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_FOUND) {
-      if (this._subscriptions.has(name)) {
-        this._error(name, 'invalid add: listener exists')
-        return
-      }
-
-      // TODO (refactor): Move to class
-      const provider = {
-        name,
-        value$: null,
-        sending: false,
-        accepted: false,
-        version: null,
-        timeout: null,
-        patternSubscription: null,
-        valueSubscription: null,
-      }
-      provider.stop = () => {
-        if (this.connected && provider.accepted) {
-          this._connection.sendMsg(this._topic, C.ACTIONS.LISTEN_REJECT, [
-            this._pattern,
-            provider.name,
-          ])
-        }
-
-        provider.value$ = null
-        provider.version = null
-        provider.accepted = false
-        provider.sending = false
-
-        clearTimeout(provider.timeout)
-        provider.timeout = null
-
-        provider.patternSubscription?.unsubscribe()
-        provider.patternSubscription = null
-
-        provider.valueSubscription?.unsubscribe()
-        provider.valueSubscription = null
-      }
-      provider.send = () => {
-        provider.sending = false
-
-        if (!provider.patternSubscription) {
-          return
-        }
-
-        const accepted = Boolean(provider.value$)
-        if (provider.accepted === accepted) {
-          return
-        }
-
-        this._connection.sendMsg(
-          this._topic,
-          accepted ? C.ACTIONS.LISTEN_ACCEPT : C.ACTIONS.LISTEN_REJECT,
-          [this._pattern, provider.name],
-        )
-
-        provider.version = null
-        provider.accepted = accepted
-      }
-      provider.next = (value$) => {
-        if (!value$) {
-          value$ = null
-        } else if (typeof value$.subscribe !== 'function') {
-          value$ = rxjs.of(value$) // Compat for recursive with value
-        }
-
-        if (Boolean(provider.value$) !== Boolean(value$) && !provider.sending) {
-          provider.sending = true
-          queueMicrotask(provider.send)
-        }
-
-        provider.value$ = value$
-
-        if (provider.valueSubscription) {
-          provider.valueSubscription.unsubscribe()
-          provider.valueSubscription = provider.value$?.subscribe(provider.observer)
-        }
-      }
-      provider.error = (err) => {
-        provider.stop()
-        // TODO (feat): backoff retryCount * delay?
-        // TODO (feat): backoff option?
-        provider.timeout = setTimeout(() => {
-          provider.start()
-        }, 10e3)
-        this._error(provider.name, err)
-      }
-      provider.observer = {
-        next: (value) => {
-          if (value == null) {
-            provider.next(null) // TODO (fix): This is weird...
-            return
-          }
-
-          if (this._topic === C.TOPIC.EVENT) {
-            this._handler.emit(provider.name, value)
-          } else if (this._topic === C.TOPIC.RECORD) {
-            if (typeof value !== 'object' && typeof value !== 'string') {
-              this._error(provider.name, 'invalid value')
-              return
-            }
-
-            if (typeof value !== 'string') {
-              try {
-                value = this._stringify(value)
-              } catch (err) {
-                const bigIntPaths = /BigInt/.test(err.message) ? findBigIntPaths(value) : undefined
-                this._error(
-                  Object.assign(new Error(`invalid value: ${value}`), {
-                    cause: err,
-                    data: { name: provider.name, bigIntPaths },
-                  }),
-                )
-                return
-              }
-            }
-
-            const body = value
-            const hash = h64ToString(body)
-            const version = `INF-${hash}`
-
-            if (provider.version !== version) {
-              provider.version = version
-              this._connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.UPDATE, [
-                provider.name,
-                version,
-                body,
-              ])
-            }
-          }
-        },
-        error: provider.error,
-      }
-      provider.start = () => {
-        try {
-          const ret$ = this._callback(name)
-          if (this._recursive && typeof ret$?.subscribe === 'function') {
-            provider.patternSubscription = ret$.subscribe(provider)
-          } else {
-            provider.patternSubscription = rxjs.of(ret$).subscribe(provider)
-          }
-        } catch (err) {
-          this._error(provider.name, err)
-        }
-      }
-
-      provider.start()
-
-      this._subscriptions.set(provider.name, provider)
-    } else if (message.action === C.ACTIONS.LISTEN_ACCEPT) {
-      const provider = this._subscriptions.get(name)
-      if (!provider?.value$) {
-        return
-      }
-
-      if (provider.valueSubscription) {
-        this._error(
-          name,
-          'invalid accept: listener started (pattern:' + this._pattern + ' name:' + name + ')',
-        )
-      } else {
-        // TODO (fix): provider.version = message.data[2]
-        provider.valueSubscription = provider.value$.subscribe(provider.observer)
-      }
-    } else if (message.action === C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_REMOVED) {
-      const provider = this._subscriptions.get(name)
-
-      if (!provider) {
-        this._error(
-          name,
-          'invalid remove: listener missing (pattern:' + this._pattern + ' name:' + name + ')',
-        )
-      } else {
-        provider.stop()
-        this._subscriptions.delete(provider.name)
-      }
-    } else {
-      return false
-    }
-    return true
-  }
-
-  _$onConnectionStateChange() {
-    if (this.connected) {
-      this._connection.sendMsg(this._topic, C.ACTIONS.LISTEN, [this._pattern])
-    } else {
-      this._reset()
-    }
-  }
-
-  _error(name, err) {
-    this._client._$onError(this._topic, C.EVENT.LISTENER_ERROR, err, [this._pattern, name])
-  }
-
-  _reset() {
-    for (const provider of this._subscriptions.values()) {
-      provider.stop()
-    }
-    this._subscriptions.clear()
-  }
-}