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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/deepstream.io-client-js",
-  "version": "28.1.5",
+  "version": "28.1.7",
   "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/event/event-handler.d.ts

@@ -9,7 +9,7 @@ export default class EventHandler {
   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
+  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,5 +1,5 @@
 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
@@ -12,15 +12,14 @@ export default class RecordHandler<Records> {
   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: number,
-    ): Observable<Data>
+    ): 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,9 +117,9 @@ 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:
@@ -127,9 +128,9 @@ export default class RecordHandler<Records> {
       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

@@ -1,4 +1,11 @@
 import make from './client.js'
+import {
+  EmptyObject,
+  GettablePossibleEmpty,
+  PossiblyEmptyData,
+  SettablePossibleEmpty,
+} from './record/record.js'
+import { assertNonEmpty } from './record/record-handler.js'
 
 interface Records {
   test: {
@@ -8,6 +15,9 @@ interface Records {
   foo: {
     bar: number
   }
+  tjena: {
+    optional?: string
+  }
   num: number
   str: string
 }
@@ -18,6 +28,93 @@ interface Methods {
 
 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', {
@@ -25,6 +122,8 @@ ds.record.set('test', {
 })
 
 ds.record.set('foo', { value: 'namn' })
+ds.record.set('foo', { bar: 22 })
+ds.record.set('foo', {})
 
 ds.record.set('test', 'name', '23')
 
@@ -55,6 +154,8 @@ 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')
@@ -66,8 +167,7 @@ const s = Object.freeze({})
 
 ds.record.JSON.EMPTY
 
-ds.event.provide('test', (what) => {
-}, {})
+ds.event.provide('test', (what) => {}, {})
 
 const a = ds.rpc.provide('test', (args, response) => {
   console.log(args.name)
@@ -75,4 +175,3 @@ const a = ds.rpc.provide('test', (args, response) => {
 })
 
 a()
-