@akinon/next 1.96.0-rc.57 → 1.96.0-snapshot-ZERO-35861-20250908151109

package/lib/cache-handler.mjs

@@ -3,7 +3,261 @@ import createLruHandler from '@neshca/cache-handler/local-lru';
 import createRedisHandler from '@neshca/cache-handler/redis-strings';
 import { createClient } from 'redis';
 
-// Cache configuration
+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;
+  }
+};
+
 const CACHE_CONFIG = {
   lru: {
     maxItemCount: 2000
@@ -22,7 +276,6 @@ 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;
@@ -31,42 +284,22 @@ 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: {
@@ -87,7 +320,6 @@ 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(
@@ -101,12 +333,10 @@ async function getRedisClient() {
     });
 
     redisClient.on('connect', () => {
-      console_log('Redis connected');
       globalForRedis.hasLoggedConnectionError = false;
     });
 
     redisClient.on('ready', () => {
-      console_log('Redis ready');
       globalForRedis.hasLoggedConnectionError = false;
     });
 
@@ -115,16 +345,6 @@ 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;
@@ -135,13 +355,10 @@ 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)]
     };
@@ -150,98 +367,161 @@ CacheHandler.onCreation(async () => {
   const redisHandler = createRedisHandler({
     client,
     timeoutMs: CACHE_CONFIG.redis.timeoutMs,
-    keyExpirationStrategy: 'EXAT'
+    keyExpirationStrategy: 'EXPIREAT'
   });
 
   const localHandler = createLruHandler(CACHE_CONFIG.lru);
 
-  // Pre-compute version prefix if exists
-  const versionPrefix = CACHE_CONFIG.version ? `${CACHE_CONFIG.version}:` : '';
-
-  // Create optimized functions for each scenario
-  const versionKeyString = versionPrefix
-    ? (key) => `${versionPrefix}${key}`
-    : (key) => key;
+  const CACHE_VERSION = 'v2';
+  const versionPrefix = `${CACHE_VERSION}_`;
 
-  const versionKeyObject = versionPrefix
-    ? (key) => ({ ...key, key: `${versionPrefix}${key.key}` })
-    : (key) => key;
+  const versionKeyString = (key) => `${versionPrefix}${key}`;
+  const versionKeyObject = (key) => ({
+    ...key,
+    key: `${versionPrefix}${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) {
-        console_log('Found in local cache');
+        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;
+          }
+        }
+
         return localResult;
       }
 
-      console_log('Not found in local, checking Redis...');
       try {
         const redisResult = await redisHandler.get(vKey, context);
 
         if (redisResult) {
-          console_log('Found in Redis');
-          // Sync back to local cache for faster future access
+          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;
+            }
+          }
+
           try {
-            await localHandler.set(vKey, redisResult, context);
-            console_log('Synced to local cache');
-          } catch (error) {
-            console_log('Failed to sync to local:', error.message);
+            await localHandler.set(vKey, finalResult, context);
+          } catch (_) {
+            return finalResult;
           }
-          return redisResult;
+          return finalResult;
         }
-      } catch (error) {
-        console_log('Redis error:', error.message);
+      } catch (_) {
+        return undefined;
       }
 
-      console_log('Not found in any cache');
       return undefined;
     },
     set: async (key, value, context) => {
       const vKey = versionKey(key);
-      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))
-      ]);
+
+      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;
+      }
     },
     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)
@@ -249,8 +529,6 @@ CacheHandler.onCreation(async () => {
     }
   };
 
-  console_log('[Cache Handler] Handlers initialized successfully');
-
   return {
     handlers: [customHandler]
   };