@akinon/next 1.96.0-snapshot-ZERO-35861-20250908151109 → 1.96.0-snapshot-ZERO-3620-20250915165755

package/lib/cache-handler.mjs

@@ -3,261 +3,7 @@ import createLruHandler from '@neshca/cache-handler/local-lru';
 import createRedisHandler from '@neshca/cache-handler/redis-strings';
 import { createClient } from 'redis';
 
-let zstd;
-
-(async () => {
-  try {
-    const { compress, decompress } = await import('@mongodb-js/zstd');
-    zstd = { compress, decompress, type: 'native' };
-  } catch (_) {
-    zstd = false;
-  }
-})();
-
-const getZstd = () => {
-  return zstd;
-};
-
-const compressValue = async (value) => {
-  try {
-    if (value && typeof value === 'object' && value.value !== undefined) {
-      const nestedValue = value.value;
-      const serializedNestedValue =
-        typeof nestedValue === 'string'
-          ? nestedValue
-          : JSON.stringify(nestedValue);
-      const originalSize = Buffer.byteLength(serializedNestedValue, 'utf8');
-
-      if (originalSize < 1024) {
-        const result = {
-          ...value,
-          tags: Array.isArray(value.tags) ? value.tags : []
-        };
-        return result;
-      }
-
-      const zstdLib = getZstd();
-      let compressed;
-
-      if (zstdLib && zstdLib !== false) {
-        const inputBuffer = Buffer.from(serializedNestedValue, 'utf8');
-
-        if (
-          typeof zstdLib.compress === 'function' &&
-          zstdLib.compress.constructor.name === 'AsyncFunction'
-        ) {
-          compressed = await zstdLib.compress(inputBuffer, 3);
-        } else {
-          compressed = zstdLib.compress(inputBuffer, 3);
-        }
-      } else {
-        return {
-          ...value,
-          tags: Array.isArray(value.tags) ? value.tags : []
-        };
-      }
-
-      const compressedBase64 = Buffer.from(compressed).toString('base64');
-
-      const result = {
-        ...value,
-        tags: Array.isArray(value.tags) ? value.tags : [],
-        lifespan: {
-          ...value.lifespan,
-          expireAge: value.lifespan?.revalidate || value.lifespan?.expireAge,
-          expireAt:
-            value.lifespan?.lastModifiedAt && value.lifespan?.revalidate
-              ? value.lifespan.lastModifiedAt + value.lifespan.revalidate
-              : value.lifespan?.expireAt
-        },
-        value: {
-          __compressed: true,
-          __method: 'zstd',
-          __originalSize: originalSize,
-          __compressedSize: compressed.length,
-          __data: compressedBase64
-        }
-      };
-
-      return result;
-    }
-
-    const serializedValue =
-      typeof value === 'string' ? value : JSON.stringify(value);
-    const originalSize = Buffer.byteLength(serializedValue, 'utf8');
-
-    if (originalSize < 1024) {
-      if (
-        value &&
-        typeof value === 'object' &&
-        value.lastModified === undefined &&
-        value.lifespan === undefined &&
-        value.value === undefined
-      ) {
-        return {
-          ...value,
-          tags: value.tags || [],
-          lastModified: Date.now(),
-          lifespan: {
-            expireAt: Math.floor(Date.now() / 1000) + 3600
-          }
-        };
-      }
-      if (
-        value &&
-        typeof value === 'object' &&
-        value.lifespan &&
-        value.lifespan.revalidate
-      ) {
-        return {
-          ...value,
-          lifespan: {
-            ...value.lifespan,
-            expireAge: value.lifespan.revalidate,
-            expireAt:
-              value.lifespan.lastModifiedAt && value.lifespan.revalidate
-                ? value.lifespan.lastModifiedAt + value.lifespan.revalidate
-                : value.lifespan.expireAt
-          }
-        };
-      }
-      return value;
-    }
-
-    const zstdLib = getZstd();
-    let compressed;
-
-    if (zstdLib && zstdLib !== false) {
-      const inputBuffer = Buffer.from(serializedValue, 'utf8');
-
-      if (
-        typeof zstdLib.compress === 'function' &&
-        zstdLib.compress.constructor.name === 'AsyncFunction'
-      ) {
-        compressed = await zstdLib.compress(inputBuffer, 3);
-      } else {
-        compressed = zstdLib.compress(inputBuffer, 3);
-      }
-    } else {
-      if (
-        value &&
-        typeof value === 'object' &&
-        value.lastModified === undefined &&
-        value.lifespan === undefined &&
-        value.value === undefined
-      ) {
-        return {
-          ...value,
-          tags: value.tags || [],
-          lastModified: Date.now(),
-          lifespan: {
-            expireAt: Math.floor(Date.now() / 1000) + 3600
-          }
-        };
-      }
-      return value;
-    }
-
-    const compressedBase64 = Buffer.from(compressed).toString('base64');
-
-    const compressedResult = {
-      __compressed: true,
-      __method: 'zstd',
-      __originalSize: originalSize,
-      __compressedSize: compressed.length,
-      __data: compressedBase64,
-      tags: [],
-      lastModified: Date.now(),
-      lifespan: { expireAt: Math.floor(Date.now() / 1000) + 3600 }
-    };
-
-    return compressedResult;
-  } catch (_) {
-    return value;
-  }
-};
-
-const decompressValue = async (compressedData) => {
-  try {
-    if (
-      compressedData &&
-      typeof compressedData === 'object' &&
-      compressedData.value &&
-      typeof compressedData.value === 'object' &&
-      compressedData.value.__compressed
-    ) {
-      const compressedNestedValue = compressedData.value;
-      const compressedBuffer = Buffer.from(
-        compressedNestedValue.__data,
-        'base64'
-      );
-      let decompressed;
-
-      if (compressedNestedValue.__method === 'zstd') {
-        const zstdLib = getZstd();
-        if (zstdLib && zstdLib !== false) {
-          if (
-            typeof zstdLib.decompress === 'function' &&
-            zstdLib.decompress.constructor.name === 'AsyncFunction'
-          ) {
-            const decompressedBuffer = await zstdLib.decompress(
-              compressedBuffer
-            );
-            decompressed = decompressedBuffer.toString('utf8');
-          } else {
-            decompressed = zstdLib
-              .decompress(compressedBuffer)
-              .toString('utf8');
-          }
-        } else {
-          throw new Error('zstd not available for decompression');
-        }
-      }
-
-      return {
-        ...compressedData,
-        value: JSON.parse(decompressed)
-      };
-    }
-
-    if (
-      compressedData &&
-      typeof compressedData === 'object' &&
-      compressedData.__compressed
-    ) {
-      const compressedBuffer = Buffer.from(compressedData.__data, 'base64');
-      let decompressed;
-
-      if (compressedData.__method === 'zstd') {
-        const zstdLib = getZstd();
-        if (zstdLib && zstdLib !== false) {
-          if (
-            typeof zstdLib.decompress === 'function' &&
-            zstdLib.decompress.constructor.name === 'AsyncFunction'
-          ) {
-            const decompressedBuffer = await zstdLib.decompress(
-              compressedBuffer
-            );
-            decompressed = decompressedBuffer.toString('utf8');
-          } else {
-            decompressed = zstdLib
-              .decompress(compressedBuffer)
-              .toString('utf8');
-          }
-        } else {
-          throw new Error('zstd not available for decompression');
-        }
-      }
-
-      return JSON.parse(decompressed);
-    }
-
-    return compressedData;
-  } catch (error) {
-    return compressedData;
-  }
-};
-
+// Cache configuration
 const CACHE_CONFIG = {
   lru: {
     maxItemCount: 2000
@@ -276,6 +22,7 @@ const CACHE_CONFIG = {
   version: process.env.ACC_APP_VERSION || ''
 };
 
+// Use global to persist across module reloads in development
 const globalForRedis = global;
 if (!globalForRedis.redisClient) {
   globalForRedis.redisClient = null;
@@ -284,22 +31,42 @@ if (!globalForRedis.redisClient) {
   globalForRedis.connectionAttempts = 0;
 }
 
+// Logging configuration
+const debugValue = process.env.NEXT_PRIVATE_DEBUG_CACHE;
+const debug = debugValue === 'true' || debugValue === '1';
+
+let console_log;
+if (debug) {
+  // eslint-disable-next-line no-console
+  console_log = (...args) => console.log('[Cache Handler]', ...args);
+} else {
+  console_log = () => {};
+}
+
 async function getRedisClient() {
+  // If client exists and is ready, return it
   if (globalForRedis.redisClient?.isReady) {
+    console_log('Reusing existing Redis connection');
     return globalForRedis.redisClient;
   }
 
+  // If we're already connecting, wait a bit and retry
   if (globalForRedis.isConnecting) {
     await new Promise((resolve) => setTimeout(resolve, 100));
     return getRedisClient();
   }
 
+  // Start new connection
   globalForRedis.isConnecting = true;
   globalForRedis.connectionAttempts++;
 
   try {
     const redisUrl = `redis://${CACHE_CONFIG.host}:${CACHE_CONFIG.port}/${CACHE_CONFIG.bucket}`;
 
+    if (globalForRedis.connectionAttempts === 1) {
+      console_log('Creating Redis connection:', redisUrl);
+    }
+
     const redisClient = createClient({
       url: redisUrl,
       socket: {
@@ -320,6 +87,7 @@ async function getRedisClient() {
     });
 
     redisClient.on('error', (error) => {
+      // Only log the first connection error to avoid spam
       if (!globalForRedis.hasLoggedConnectionError) {
         if (error.code === 'ECONNREFUSED') {
           console.warn(
@@ -333,10 +101,12 @@ async function getRedisClient() {
     });
 
     redisClient.on('connect', () => {
+      console_log('Redis connected');
       globalForRedis.hasLoggedConnectionError = false;
     });
 
     redisClient.on('ready', () => {
+      console_log('Redis ready');
       globalForRedis.hasLoggedConnectionError = false;
     });
 
@@ -345,6 +115,16 @@ async function getRedisClient() {
     return redisClient;
   } catch (error) {
     if (!globalForRedis.hasLoggedConnectionError) {
+      if (error.code === 'ECONNREFUSED') {
+        console.warn(
+          '[Cache Handler] Could not connect to Redis - using local cache only'
+        );
+      } else {
+        console.error(
+          '[Cache Handler] Failed to connect to Redis:',
+          error.message
+        );
+      }
       globalForRedis.hasLoggedConnectionError = true;
     }
     globalForRedis.redisClient = null;
@@ -355,10 +135,13 @@ async function getRedisClient() {
 }
 
 CacheHandler.onCreation(async () => {
+  console_log('Initializing cache handlers...');
+
   let client;
   try {
     client = await getRedisClient();
   } catch (error) {
+    // Error already logged in getRedisClient, just return local handler
     return {
       handlers: [createLruHandler(CACHE_CONFIG.lru)]
     };
@@ -367,161 +150,98 @@ CacheHandler.onCreation(async () => {
   const redisHandler = createRedisHandler({
     client,
     timeoutMs: CACHE_CONFIG.redis.timeoutMs,
-    keyExpirationStrategy: 'EXPIREAT'
+    keyExpirationStrategy: 'EXAT'
   });
 
   const localHandler = createLruHandler(CACHE_CONFIG.lru);
 
-  const CACHE_VERSION = 'v2';
-  const versionPrefix = `${CACHE_VERSION}_`;
+  // Pre-compute version prefix if exists
+  const versionPrefix = CACHE_CONFIG.version ? `${CACHE_CONFIG.version}:` : '';
 
-  const versionKeyString = (key) => `${versionPrefix}${key}`;
-  const versionKeyObject = (key) => ({
-    ...key,
-    key: `${versionPrefix}${key.key}`
-  });
+  // Create optimized functions for each scenario
+  const versionKeyString = versionPrefix
+    ? (key) => `${versionPrefix}${key}`
+    : (key) => key;
 
+  const versionKeyObject = versionPrefix
+    ? (key) => ({ ...key, key: `${versionPrefix}${key.key}` })
+    : (key) => key;
+
+  // Main version key function that routes to optimized paths
   const versionKey = (key) => {
     return typeof key === 'string'
       ? versionKeyString(key)
       : versionKeyObject(key);
   };
 
+  // Create a custom handler that checks local first, then Redis
   const customHandler = {
     name: 'custom-local-then-redis',
     get: async (key, context) => {
       const vKey = versionKey(key);
+      console_log(
+        'GET called for key:',
+        typeof vKey === 'string' ? vKey : vKey?.key
+      );
 
+      // Check local cache first
+      console_log('Checking local cache...');
       const localResult = await localHandler.get(vKey, context);
 
       if (localResult) {
-        if (
-          localResult &&
-          typeof localResult === 'object' &&
-          (localResult.__compressed ||
-            (localResult.value && localResult.value.__compressed) ||
-            localResult.compressed !== undefined)
-        ) {
-          try {
-            const decompressed = await decompressValue(localResult);
-            return typeof decompressed === 'string'
-              ? JSON.parse(decompressed)
-              : decompressed;
-          } catch (_) {
-            return localResult;
-          }
-        }
-
+        console_log('Found in local cache');
         return localResult;
       }
 
+      console_log('Not found in local, checking Redis...');
       try {
         const redisResult = await redisHandler.get(vKey, context);
 
         if (redisResult) {
-          let finalResult = redisResult;
-
-          if (typeof redisResult === 'string') {
-            try {
-              finalResult = JSON.parse(redisResult);
-            } catch (parseError) {
-              finalResult = redisResult;
-            }
-          }
-
-          if (
-            finalResult &&
-            typeof finalResult === 'object' &&
-            (finalResult.__compressed ||
-              (finalResult.value && finalResult.value.__compressed) ||
-              finalResult.compressed !== undefined)
-          ) {
-            try {
-              const decompressed = await decompressValue(finalResult);
-              finalResult =
-                typeof decompressed === 'string'
-                  ? JSON.parse(decompressed)
-                  : decompressed;
-            } catch (_) {
-              return finalResult;
-            }
-          }
-
+          console_log('Found in Redis');
+          // Sync back to local cache for faster future access
           try {
-            await localHandler.set(vKey, finalResult, context);
-          } catch (_) {
-            return finalResult;
+            await localHandler.set(vKey, redisResult, context);
+            console_log('Synced to local cache');
+          } catch (error) {
+            console_log('Failed to sync to local:', error.message);
           }
-          return finalResult;
+          return redisResult;
         }
-      } catch (_) {
-        return undefined;
+      } catch (error) {
+        console_log('Redis error:', error.message);
       }
 
+      console_log('Not found in any cache');
       return undefined;
     },
     set: async (key, value, context) => {
       const vKey = versionKey(key);
-
-      let compressedValue;
-      let shouldUseCompressed = false;
-
-      try {
-        compressedValue = await compressValue(value);
-
-        shouldUseCompressed =
-          compressedValue !== value &&
-          (compressedValue?.__compressed ||
-            compressedValue?.value?.__compressed);
-      } catch (error) {
-        compressedValue = value;
-        shouldUseCompressed = false;
-      }
-
-      let redisSetResult;
-
-      if (shouldUseCompressed) {
-        try {
-          await redisHandler.set(vKey, compressedValue, context);
-
-          redisSetResult = { status: 'fulfilled' };
-        } catch (compressionError) {
-          try {
-            await redisHandler.set(vKey, value, context);
-
-            redisSetResult = { status: 'fulfilled' };
-          } catch (fallbackError) {
-            redisSetResult = { status: 'rejected', reason: fallbackError };
-          }
-        }
-      } else {
-        try {
-          await redisHandler.set(vKey, value, context);
-          redisSetResult = { status: 'fulfilled' };
-        } catch (error) {
-          redisSetResult = { status: 'rejected', reason: error };
-          return redisSetResult;
-        }
-      }
-
-      let localSetResult;
-      try {
-        await localHandler.set(vKey, value, context);
-        localSetResult = { status: 'fulfilled' };
-      } catch (error) {
-        localSetResult = { status: 'rejected', reason: error };
-        return localSetResult;
-      }
+      console_log(
+        'SET called for key:',
+        typeof vKey === 'string' ? vKey : vKey?.key
+      );
+      // Set to both caches
+      await Promise.allSettled([
+        localHandler.set(vKey, value, context),
+        redisHandler
+          .set(vKey, value, context)
+          .catch((error) => console_log('Redis SET error:', error.message))
+      ]);
     },
     delete: async (key, context) => {
       const vKey = versionKey(key);
-
+      console_log(
+        'DELETE called for key:',
+        typeof vKey === 'string' ? vKey : vKey?.key
+      );
       await Promise.allSettled([
         localHandler.delete?.(vKey, context),
         redisHandler.delete?.(vKey, context)
       ]);
     },
     revalidateTag: async (tags, context) => {
+      console_log('REVALIDATE_TAG called for tags:', tags);
       await Promise.allSettled([
         localHandler.revalidateTag?.(tags, context),
         redisHandler.revalidateTag?.(tags, context)
@@ -529,6 +249,8 @@ CacheHandler.onCreation(async () => {
     }
   };
 
+  console_log('[Cache Handler] Handlers initialized successfully');
+
   return {
     handlers: [customHandler]
   };