@greendrake/rpc 0.5.0 → 0.7.0

package/README.md

@@ -54,7 +54,7 @@ const user = await client.call('user.get', 'U1') // User
 await client.call('user.update', { id: 'U1', name: 'Ann' })
 ```
 
-`new RpcClient<M>(transport, locale?)` — `locale` is `() => string | undefined`, evaluated per call, so a language switch applies from the next call. `call(method, ...args)` is the one way to invoke a method, and every request it sends carries a nonce. `MethodMap` and `MethodMapConstraint<M>` are the constraint types; a plain interface qualifies.
+`new RpcClient<M>(transport, locale?)` — `locale` is `() => string | undefined`, evaluated per call, so a language switch applies from the next call. `call(method, ...args)` is the one way to invoke a method, and every request it sends carries a nonce. A method that takes no arguments is called with none, and its request carries no `arguments` field. `Caller<M>` is that `call`, which `RpcClient` and `@greendrake/vue-api`'s `ApiClient` both implement: the type for code handed either. `MethodMap` and `MethodMapConstraint<M>` are the constraint types; a plain interface qualifies.
 
 `Transport` is one method, `send(request: RpcRequest): Promise<unknown>`, resolving to the response `data` or rejecting with a mapped error. Anything implementing it plugs into the client.
 
@@ -211,7 +211,6 @@ cache.get('taxonomy.tree', [{ taxonomy: 'category' }]) // { hit: boolean; data?:
 cache.set('taxonomy.tree', [{ taxonomy: 'category' }], tree) // no-op for an unlisted method
 cache.invalidate('search.things') // every entry for the method
 cache.invalidate('search.things', { q: 'x' }) // that args-key only
-cache.prime('taxonomy.tree', [{ taxonomy: 'category' }], pushed) // seed from a server push
 cache.clear() // everything, e.g. when the session identity changes
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@greendrake/rpc",
-    "version": "0.5.0",
+    "version": "0.7.0",
     "description": "RPC client over JSON: typed method-map API, HTTP and reconnecting WebSocket transports, pluggable codec and headers, TTL response cache",
     "license": "MIT",
     "author": "Eugene Greendrake <eugene@greendrake.nz>",
@@ -34,10 +34,10 @@
     },
     "prettier": "@greendrake/dev-config/prettier",
     "dependencies": {
-        "@greendrake/util": "0.5.0"
+        "@greendrake/util": "0.7.0"
     },
     "devDependencies": {
-        "@greendrake/dev-config": "0.5.0",
+        "@greendrake/dev-config": "0.7.0",
         "typescript": "6.0.3"
     }
 }

package/src/ResponseCache.ts

@@ -85,12 +85,4 @@ export class ResponseCache {
     clear(): void {
         this.#entries.clear()
     }
-
-    // Seed the cache with a known-fresh response — a server push already
-    // carrying the full DTO a read would return — so the next read serves it
-    // without a round-trip. `args` must match the read's args so the same key
-    // is hit.
-    prime(method: string, args: unknown[], data: unknown): void {
-        this.set(method, args, data)
-    }
 }

package/src/RpcClient.ts

@@ -1,4 +1,4 @@
-import type { MethodMap, MethodMapConstraint, Transport } from './types'
+import type { Caller, MethodMap, MethodMapConstraint, Transport } from './types'
 import { packRequest } from './protocol'
 
 // Typed facade over a transport: methods come from the app's declared
@@ -6,7 +6,7 @@ import { packRequest } from './protocol'
 // proxies, no casts at call sites.
 //    const client = new RpcClient<Methods>(transport)
 //    const user = await client.call('user.get', id)
-export class RpcClient<M extends MethodMapConstraint<M> = MethodMap> {
+export class RpcClient<M extends MethodMapConstraint<M> = MethodMap> implements Caller<M> {
     readonly transport: Transport
     // Supplies the caller's UI language tag per request. Evaluated per call,
     // like HttpTransport's headers provider, so a locale switch takes effect on

package/src/main.ts

@@ -1,4 +1,4 @@
-export { identityCodec, type Codec, type HeadersProvider, type RpcRequest, type RpcResponse, type MethodMap, type MethodMapConstraint, type Transport } from './types'
+export { identityCodec, type Caller, type Codec, type HeadersProvider, type RpcRequest, type RpcResponse, type MethodMap, type MethodMapConstraint, type Transport } from './types'
 export { ApiError, NotFoundError, OneOutcomeError, WebSocketClosedError, codeOf } from './errors'
 export { makeError, packRequest, settleResponse } from './protocol'
 export { HttpTransport, type HttpTransportOptions } from './http'

package/src/types.ts

@@ -51,6 +51,12 @@ export type MethodMap = Record<string, (...args: never[]) => unknown>
 
 export type MethodMapConstraint<M> = Record<keyof M, (...args: never[]) => unknown>
 
+// What calls the methods of M: each with exactly its own arguments, and a method
+// that takes none with none at all.
+export interface Caller<M extends MethodMapConstraint<M>> {
+    call<K extends keyof M & string>(method: K, ...args: Parameters<M[K]>): Promise<Awaited<ReturnType<M[K]>>>
+}
+
 export interface Transport {
     send(request: RpcRequest): Promise<unknown>
 }