@nxtedition/deepstream.io-client-js 28.1.4 → 28.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/deepstream.io-client-js",
-  "version": "28.1.4",
+  "version": "28.1.6",
   "description": "the javascript client for deepstream.io",
   "homepage": "http://deepstream.io",
   "type": "module",
@@ -60,6 +60,7 @@
     "pinst": "^3.0.0",
     "prettier": "^3.3.3",
     "rxjs": "^7.8.1",
+    "type-fest": "^4.33.0",
     "typescript": "^5.6.3",
     "typescript-eslint": "^8.12.2"
   },

package/src/client.d.ts

@@ -1,7 +1,7 @@
-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'
+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,

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

@@ -1,26 +1,25 @@
 import type { Observable } from 'rxjs'
-import Record from './record.js'
+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: RecordStateConstants['VOID']
-  CLIENT: RecordStateConstants['CLIENT']
-  PROVIDER: RecordStateConstants['PROVIDER']
-  SERVER: RecordStateConstants['SERVER']
-  STALE: RecordStateConstants['STALE']
+  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: 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>
@@ -35,7 +34,7 @@ export default class RecordHandler<Records> {
 
   set: {
     // without path:
-    <Name extends keyof Records>(name: Name, data: Records[Name]): void
+    <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>>(
@@ -49,39 +48,41 @@ export default class RecordHandler<Records> {
     // without path:
     <Name extends keyof Records, Data extends Records[Name]>(
       name: Name,
-      updater: (data: Data) => Data,
+      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: Get<Data, Path>) => Get<Data, 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<Data>
+    <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>>
+    ): Observable<Get<Data, Path> | undefined>
 
     // with state:
     <Name extends keyof Records, Data extends Records[Name]>(
       name: Name,
-      state: RecordStateConstants,
-    ): Observable<Data>
+      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>>
+    ): Observable<Get<Data, Path> | undefined>
   }
 
   get: {
@@ -89,14 +90,14 @@ export default class RecordHandler<Records> {
     <Name extends keyof Records, Data extends Records[Name]>(
       name: Name,
       state?: number,
-    ): Promise<Data>
+    ): 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>>
+    ): Promise<Get<Data, Path> | undefined>
   }
 
   observe2: {
@@ -107,7 +108,7 @@ export default class RecordHandler<Records> {
       name: Name
       version: string
       state: number
-      data: Data
+      data: GettablePossibleEmpty<Data>
     }>
 
     // with path:
@@ -116,20 +117,20 @@ export default class RecordHandler<Records> {
       path: Path,
     ): Observable<{
       name: Name
-      version: Get<Data, Path>
+      version: string
       state: number
-      data: Data
+      data: Get<Data, Path> | undefined
     }>
 
     // with state:
     <Name extends keyof Records, Data extends Records[Name]>(
       name: Name,
-      state: RecordStateConstants,
+      state: number,
     ): Observable<{
       name: Name
-      version: Get<Data, Path>
+      version: string
       state: number
-      data: Data
+      data: GettablePossibleEmpty<Data>
     }>
 
     // with path and state:
@@ -139,9 +140,9 @@ export default class RecordHandler<Records> {
       state: number,
     ): Observable<{
       name: Name
-      version: Get<Data, Path>
+      version: string
       state: number
-      data: Get<Data, Path>
+      data: Get<Data, Path> | undefined
     }>
   }
 }

package/src/record/record.d.ts

@@ -1,10 +1,42 @@
-import RecordHandler from './record-handler.js'
+import type RecordHandler from './record-handler.js'
+import type { EmptyObject, SingleKeyObject } from 'type-fest'
 
 type Paths<T> = keyof T
 type Get<Data, Path extends string> = Path extends keyof Data ? Data[Path] : unknown
 
+export type { EmptyObject } from 'type-fest'
+
+// 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 {
-  state?: number
   timeout?: number
   signal?: AbortSignal
 }
@@ -18,7 +50,7 @@ export default class Record<Data> {
 
   readonly name: string
   readonly version: string
-  readonly data: Data
+  readonly data: GettablePossibleEmpty<Data>
   readonly state: number
   readonly refs: number
 
@@ -31,13 +63,13 @@ export default class Record<Data> {
     // with path
     <Path extends Paths<Data>, DataAtPath extends Get<Data, Path> = Get<Data, Path>>(
       path: Path,
-    ): DataAtPath
+    ): DataAtPath | undefined
     // without path
-    (): Data
+    (): GettablePossibleEmpty<Data>
     // implementation
     <Path extends Paths<Data>, DataAtPath extends Get<Data, Path> = Get<Data, Path>>(
       path?: Path,
-    ): Path extends undefined ? Data : DataAtPath
+    ): Path extends undefined ? GettablePossibleEmpty<Data> : DataAtPath | undefined
   }
 
   set: {
@@ -47,10 +79,10 @@ export default class Record<Data> {
       dataAtPath: DataAtPath,
     ): void
     // without path
-    (data: Data): void
+    (data: SettablePossibleEmpty<Data>): void
     // implementation
     <Path extends Paths<Data>, DataAtPath extends Get<Data, Path>>(
-      ...args: [pathOrData: Path | Data, value?: DataAtPath]
+      ...args: [pathOrData: Path | SettablePossibleEmpty<Data>, value?: DataAtPath]
     ): void
   }
 
@@ -61,11 +93,16 @@ export default class Record<Data> {
     (state: number, options: WhenOptions): Promise<Record<Data>>
   }
 
-  update<Path extends Paths<Data>, PathOrUpdater extends Path | ((data: Data) => Data)>(
+  update<
+    Path extends Paths<Data>,
+    PathOrUpdater extends
+      | Path
+      | ((data: Readonly<GettablePossibleEmpty<Data>>) => SettablePossibleEmpty<Data>),
+  >(
     ...args: PathOrUpdater extends Path
       ? [
           path: Path,
-          updater: (dataAtPath: Get<Data, Path>) => Get<Data, Path>,
+          updater: (dataAtPath: Readonly<Get<Data, Path>> | undefined) => Get<Data, Path>,
           options?: UpdateOptions,
         ]
       : [updater: PathOrUpdater, options?: UpdateOptions]

package/src/test.ts

@@ -0,0 +1,177 @@
+import make from './client.js'
+import {
+  EmptyObject,
+  GettablePossibleEmpty,
+  PossiblyEmptyData,
+  SettablePossibleEmpty,
+} from './record/record.js'
+import { assertNonEmpty } from './record/record-handler.js'
+
+interface Records {
+  test: {
+    name: string
+    age: number
+  }
+  foo: {
+    bar: number
+  }
+  tjena: {
+    optional?: string
+  }
+  num: number
+  str: string
+}
+
+interface Methods {
+  test: [{ name: string }, { age: number }]
+}
+
+const ds = make<Records, Methods>('http://localhost:3000')
+
+const y = await ds.record.get('test')
+if ('age' in y) {
+  console.log(y.name)
+}
+
+const q: PossiblyEmptyData<{ test: number }> = {}
+console.log(q.test)
+if ('test' in q) {
+  console.log(q.test)
+}
+
+const w: PossiblyEmptyData<{ test: number; haj: number }> = { test: 22, haj: 22 }
+
+function test<D>(cb: (data: GettablePossibleEmpty<D>) => SettablePossibleEmpty<D>) {
+  // cb({})
+}
+
+test<{ foo: number; bar: number }>((data) => {
+  return data
+})
+
+test<{ foo?: number; bar: number }>(() => {
+  return {
+    foo: 22,
+  }
+})
+
+test<{ foo?: number; bar: number }>((data) => {
+  // return data
+  const a= {
+    ...data,
+    foo: 22,
+  }
+  return a
+})
+
+test<{ foo?: number; bar?: number }>((data) => {
+  return {
+    ...data,
+    foo: 22,
+  }
+})
+
+const y = await ds.record.get('test')
+if ('age' in y) {
+  console.log(y.name)
+
+test<{ foo?: number }>((data) => {
+  return data
+})
+
+test<{ foo: number }>((data) => {
+  return {
+    ...data,
+    foo: 22,
+  }
+})
+
+if ('test' in w) {
+  console.log(w.haj)
+}
+console.log(w.test)
+console.log(w.test)
+
+const m: PossiblyEmptyData<{ test?: number }> = {}
+console.log(m.test)
+
+assertNonEmpty(q)
+q.test
+// q.test
+
+// q
+
+ds.record.set('test', ds.record.JSON.EMPTY_OBJ)
+
+ds.record.update('test', (data) => {
+  const a = {
+    // ...data,
+    age: 22,
+  }
+  console.log(data.name)
+  return {
+    ...data,
+    age: 22,
+  }
+})
+
+ds.record.provide('test', () => {})
+
+ds.record.set('test', {
+  name: 23,
+})
+
+ds.record.set('foo', { value: 'namn' })
+ds.record.set('foo', { bar: 22 })
+ds.record.set('foo', {})
+
+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)
+
+ds.record.set('test', {})
+
+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()