Remove redundant memory KV calls, allow disable memory KV for testing

Author: Nathan Booker

core/lib/kv/adapters/upstash.ts

@@ -2,23 +2,14 @@ import { Redis } from '@upstash/redis';
 
 import { KvAdapter, SetCommandOptions } from '../types';
 
-import { MemoryKvAdapter } from './memory';
-
-const memoryKv = new MemoryKvAdapter();
-
 export class UpstashKvAdapter implements KvAdapter {
   private upstashKv = Redis.fromEnv();
-  private memoryKv = memoryKv;
 
   async mget<Data>(...keys: string[]) {
-    const memoryValues = await this.memoryKv.mget<Data>(...keys);
-
-    return memoryValues.length ? memoryValues : this.upstashKv.mget<Data[]>(keys);
+    return this.upstashKv.mget<Data[]>(keys);
   }
 
   async set<Data>(key: string, value: Data, opts?: SetCommandOptions) {
-    await this.memoryKv.set(key, value, opts);
-
     const response = await this.upstashKv.set(key, value, opts);
 
     if (response === 'OK') {

core/lib/kv/adapters/vercel-runtime-cache.ts

@@ -1,109 +1,60 @@
-import { KvAdapter, SetCommandOptions } from '../types';
-
-import { MemoryKvAdapter } from './memory';
+import { getCache } from '@vercel/functions';
 
-const memoryKv = new MemoryKvAdapter();
+import { KvAdapter, SetCommandOptions } from '../types';
 
 export class RuntimeCacheAdapter implements KvAdapter {
-  private memoryKv = memoryKv;
+  private cache = getCache();
 
   async mget<Data>(...keys: string[]): Promise<Array<Data | null>> {
-    // First check memory cache for immediate reads
-    const memoryValues = await this.memoryKv.mget<Data>(...keys);
-
-    // Check if all values are found in memory cache
-    const allFoundInMemory = memoryValues.every((value) => value !== null);
-
-    if (allFoundInMemory) {
-      this.logger(
-        `MGET - Keys: ${keys.toString()} - Source: MEMORY - Values found: ${memoryValues.length}`,
-      );
-
-      return memoryValues;
-    }
-
-    // Otherwise, fetch missing values from runtime cache
     this.logger(
-      `MGET - Keys: ${keys.toString()} - Source: RUNTIME_CACHE - Memory hits: ${memoryValues.filter((v) => v !== null).length}/${keys.length}`,
+      `MGET - Keys: ${keys.toString()} - Source: RUNTIME_CACHE - Fetching ${keys.length} keys`,
     );
 
     try {
-      // Use dynamic import to load the getCache function only when needed
-      const { getCache } = await import('@vercel/functions');
-      const cache = getCache();
-
       const values = await Promise.all(
-        keys.map(async (key, index) => {
-          // Use memory value if available, otherwise fetch from runtime cache
-          if (memoryValues[index] !== null && memoryValues[index] !== undefined) {
-            return memoryValues[index];
-          }
-
+        keys.map(async (key) => {
           try {
             // Use the Runtime Cache API
-            const cachedValue = await cache.get(key);
+            const cachedValue = await this.cache.get(key);
 
             if (cachedValue !== null) {
               this.logger(`RUNTIME_CACHE GET - Key: ${key} - Found: true`);
-
               return cachedValue;
             }
 
             this.logger(`RUNTIME_CACHE GET - Key: ${key} - Found: false`);
-
             return null;
           } catch (error) {
             this.logger(
               `RUNTIME_CACHE GET ERROR - Key: ${key} - Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
             );
-
             return null;
           }
         }),
       );
 
-      // Store the runtime cache values in memory cache for future reads
-      await Promise.all(
-        values.map(async (value, index) => {
-          const key = keys[index];
-
-          if (!key || value === null || memoryValues[index] !== null) {
-            return;
-          }
-
-          await this.memoryKv.set(key, value);
-          this.logger(`MEMORY SET - Key: ${key} - Cached from runtime`);
-        }),
-      );
-
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       return values as Array<Data | null>;
     } catch (error) {
       this.logger(
-        `RUNTIME_CACHE ACCESS ERROR - Falling back to memory only: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        `RUNTIME_CACHE ACCESS ERROR - Returning null values: ${error instanceof Error ? error.message : 'Unknown error'}`,
       );
 
-      return memoryValues;
+      // Return null for all keys if Runtime Cache is unavailable
+      return keys.map(() => null);
     }
   }
 
-  async set<Data>(key: string, value: Data, opts?: SetCommandOptions): Promise<Data | null> {
-    this.logger(`SET - Key: ${key} - Setting in both memory and runtime cache`);
-
-    // Set in memory cache immediately for fast subsequent reads
-    await this.memoryKv.set(key, value, opts);
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async set<Data>(key: string, value: Data, _opts?: SetCommandOptions): Promise<Data | null> {
+    this.logger(`SET - Key: ${key} - Setting in runtime cache`);
 
-    // Set in runtime cache for persistence across requests
     try {
-      // Use dynamic import to load the getCache function only when needed
-      const { getCache } = await import('@vercel/functions');
-      const cache = getCache();
-
-      await cache.set(key, value);
+      await this.cache.set(key, value);
       this.logger(`RUNTIME_CACHE SET - Key: ${key} - Success`);
     } catch (error) {
       this.logger(
-        `RUNTIME_CACHE SET ERROR - Key: ${key} - Error: ${error instanceof Error ? error.message : 'Unknown error'} - Value still cached in memory`,
+        `RUNTIME_CACHE SET ERROR - Key: ${key} - Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
       );
     }
 

core/lib/kv/index.ts

@@ -3,6 +3,7 @@ import { KvAdapter, SetCommandOptions } from './types';
 
 interface Config {
   logger?: boolean;
+  disableMemory?: boolean;
 }
 
 const memoryKv = new MemoryKvAdapter();
@@ -25,6 +26,19 @@ class KV<Adapter extends KvAdapter> implements KvAdapter {
   async mget<Data>(...keys: string[]) {
     const kv = await this.getKv();
 
+    // Skip memory cache if disabled (useful for testing)
+    if (this.config.disableMemory) {
+      this.logger(`MGET - Keys: ${keys.toString()} - MEMORY DISABLED - Direct adapter access`);
+
+      const directValues = await kv.mget<Data>(...keys);
+
+      this.logger(
+        `MGET - Keys: ${keys.toString()} - Value: ${JSON.stringify(directValues, null, 2)}`,
+      );
+
+      return directValues;
+    }
+
     const memoryValues = (await this.memoryKv.mget<Data>(...keys)).filter(Boolean);
 
     if (memoryValues.length === keys.length) {
@@ -60,6 +74,13 @@ class KV<Adapter extends KvAdapter> implements KvAdapter {
 
     this.logger(`SET - Key: ${key} - Value: ${JSON.stringify(value, null, 2)}`);
 
+    // Skip memory cache if disabled (useful for testing)
+    if (this.config.disableMemory) {
+      this.logger(`SET - Key: ${key} - MEMORY DISABLED - Direct adapter only`);
+
+      return kv.set(key, value, opts);
+    }
+
     await Promise.all([this.memoryKv.set(key, value, opts), kv.set(key, value, opts)]);
 
     return value;
@@ -102,6 +123,7 @@ const adapterInstance = new KV(createKVAdapter, {
   logger:
     (process.env.NODE_ENV !== 'production' && process.env.KV_LOGGER !== 'false') ||
     process.env.KV_LOGGER === 'true',
+  disableMemory: process.env.KV_DISABLE_MEMORY === 'true',
 });
 
 export { adapterInstance as kv };