fix(rpc): cache falsy RPC results (presence check, not truthiness)

Author: antfubot

packages/devframe/src/client/rpc.ts

@@ -316,14 +316,11 @@ export async function getDevframeRpcClient(
           async onRequest(req, next, resolve) {
             await rpcOptions.onRequest?.call(this, req, next, resolve)
             if (cacheOptions && cacheManager?.validate(req.m)) {
-              const cached = cacheManager.cached(req.m, req.a)
-              if (cached) {
-                return resolve(cached)
-              }
-              else {
-                const res = await next(req)
-                cacheManager?.apply(req, res)
+              if (cacheManager.has(req.m, req.a)) {
+                return resolve(cacheManager.cached(req.m, req.a))
               }
+              const res = await next(req)
+              cacheManager.apply(req, res)
             }
             else {
               await next(req)

packages/devframe/src/rpc/cache.test.ts

@@ -19,3 +19,46 @@ it('cache', async () => {
   cache.clear()
   expect(cache.cached<number>('fn2', [3, 4])).toBeUndefined()
 })
+
+it('serves falsy cached values via `has` (presence, not truthiness)', () => {
+  const cache = new RpcCacheManager({ functions: ['fn'] })
+
+  // absent key: `has` reports false, distinct from a stored falsy value
+  expect(cache.has('fn', ['zero'])).toBe(false)
+
+  cache.apply({ m: 'fn', a: ['zero'] }, 0)
+  cache.apply({ m: 'fn', a: ['false'] }, false)
+  cache.apply({ m: 'fn', a: ['empty'] }, '')
+  cache.apply({ m: 'fn', a: ['null'] }, null)
+
+  expect(cache.has('fn', ['zero'])).toBe(true)
+  expect(cache.has('fn', ['false'])).toBe(true)
+  expect(cache.has('fn', ['empty'])).toBe(true)
+  expect(cache.has('fn', ['null'])).toBe(true)
+
+  expect(cache.cached('fn', ['zero'])).toBe(0)
+  expect(cache.cached('fn', ['false'])).toBe(false)
+  expect(cache.cached('fn', ['empty'])).toBe('')
+  expect(cache.cached('fn', ['null'])).toBe(null)
+})
+
+it('the client cache path (has-then-cached) serves a falsy value without a second fetch', async () => {
+  const cache = new RpcCacheManager({ functions: ['fn'] })
+  let nextCalls = 0
+  const next = async (req: { m: string, a: unknown[] }) => {
+    nextCalls++
+    cache.apply(req, 0)
+    return 0
+  }
+
+  // mirrors the onRequest cache path in client/rpc.ts
+  async function callThroughCache(req: { m: string, a: unknown[] }) {
+    if (cache.has(req.m, req.a))
+      return cache.cached(req.m, req.a)
+    return next(req)
+  }
+
+  expect(await callThroughCache({ m: 'fn', a: [] })).toBe(0)
+  expect(await callThroughCache({ m: 'fn', a: [] })).toBe(0)
+  expect(nextCalls).toBe(1) // second call served from cache, not re-fetched
+})

packages/devframe/src/rpc/cache.ts

@@ -33,6 +33,10 @@ export class RpcCacheManager {
     return undefined
   }
 
+  has(m: string, a: unknown[]): boolean {
+    return this.cacheMap.get(m)?.has(this.keySerializer(a)) ?? false
+  }
+
   apply(req: { m: string, a: unknown[] }, res: unknown): void {
     const methodCache = this.cacheMap.get(req.m) || new Map<string, unknown>()
     methodCache.set(this.keySerializer(req.a), res)