@akinon/next 1.93.0-snapshot-ZERO-3586-20250828143733 → 1.94.0

package/lib/cache-handler.mjs

@@ -2,445 +2,6 @@ import { CacheHandler } from '@neshca/cache-handler';
 import createLruHandler from '@neshca/cache-handler/local-lru';
 import createRedisHandler from '@neshca/cache-handler/redis-strings';
 import { createClient } from 'redis';
-import * as zstdWasm from '@bokuweb/zstd-wasm';
-
-// Color utilities for logs
-const colors = {
-  red: '\x1b[31m',
-  green: '\x1b[32m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-  magenta: '\x1b[35m',
-  cyan: '\x1b[36m',
-  white: '\x1b[37m',
-  reset: '\x1b[0m',
-  bright: '\x1b[1m'
-};
-
-const colorLog = (color, prefix, ...args) => {
-  // Always show compression-related logs regardless of debug flag
-  // eslint-disable-next-line no-console
-  console.log(`${colors.bright}${color}${prefix}${colors.reset}`, ...args);
-};
-
-// Initialize ZSTD immediately with IIFE (to avoid top-level await)
-let zstd;
-
-// Initialize immediately using IIFE
-(async () => {
-  try {
-    await zstdWasm.init();
-    zstd = zstdWasm;
-    colorLog(
-      colors.green,
-      '[Cache Handler] 🚀 ',
-      'ZSTD compression initialized successfully at module load'
-    );
-  } catch (error) {
-    colorLog(
-      colors.yellow,
-      '[Cache Handler] ⚠️ ',
-      'ZSTD compression failed to initialize:',
-      error.message
-    );
-    zstd = false;
-  }
-})();
-
-const getZstd = () => {
-  return zstd;
-};
-
-// Only ZSTD compression is used now - gzip/deflate removed for simplicity
-
-// Compression/decompression functions for cache values
-const compressValue = async (value) => {
-  try {
-    console_log(
-      '🔍 Compressing value type:',
-      typeof value,
-      'keys:',
-      value && typeof value === 'object' ? Object.keys(value) : 'N/A'
-    );
-
-    // For Next.js cache entries, we need to preserve the entire structure
-    // and only compress the nested 'value' field if it exists
-    if (value && typeof value === 'object' && value.value !== undefined) {
-      console_log('📦 Next.js cache entry detected, preserving structure');
-
-      // Debug original lifespan values
-      console_log('🔍 Original lifespan values:', {
-        expireAge: value.lifespan?.expireAge,
-        expireAt: value.lifespan?.expireAt,
-        revalidate: value.lifespan?.revalidate,
-        staleAge: value.lifespan?.staleAge,
-        currentTime: Math.floor(Date.now() / 1000)
-      });
-
-      const nestedValue = value.value;
-      const serializedNestedValue =
-        typeof nestedValue === 'string'
-          ? nestedValue
-          : JSON.stringify(nestedValue);
-      const originalSize = Buffer.byteLength(serializedNestedValue, 'utf8');
-
-      // Only compress the nested value if larger than 1KB
-      if (originalSize < 1024) {
-        colorLog(
-          colors.blue,
-          '[Cache Handler] ⚡ ',
-          `Skipping compression for small value (${originalSize} bytes)`
-        );
-        // Ensure tags is always an array even for small values
-        const result = {
-          ...value,
-          tags: Array.isArray(value.tags) ? value.tags : []
-        };
-        return result; // Return original structure with guaranteed array tags
-      }
-
-      const zstdLib = getZstd();
-      let compressed;
-
-      if (zstdLib && zstdLib !== false) {
-        compressed = zstdLib.compress(
-          Buffer.from(serializedNestedValue, 'utf8'),
-          3
-        );
-        colorLog(colors.cyan, '[Cache Handler] 🔵 ', `Using ZSTD compression`);
-      } else {
-        // No fallback compression - if ZSTD fails, don't compress
-        colorLog(
-          colors.yellow,
-          '[Cache Handler] ⚠️ ',
-          `ZSTD not available, storing uncompressed`
-        );
-        return {
-          ...value,
-          tags: Array.isArray(value.tags) ? value.tags : []
-        };
-      }
-
-      const compressedBase64 = Buffer.from(compressed).toString('base64');
-      const compressionRatio =
-        ((originalSize - compressed.length) / originalSize) * 100;
-
-      colorLog(
-        colors.cyan,
-        '[Cache Handler] 🔵 ',
-        `Compressed nested value ${originalSize} → ${
-          compressed.length
-        } bytes (${compressionRatio.toFixed(1)}% reduction, method: zstd)`
-      );
-
-      // Return the cache entry with compressed nested value but preserved structure
-      // Ensure tags is always an array for Redis handler compatibility
-      // Fix expireAge to match project's revalidate value (300) instead of Next.js calculated value (450)
-      const result = {
-        ...value, // Preserve all metadata (lastModified, expiresAt, tags, etc.)
-        tags: Array.isArray(value.tags) ? value.tags : [], // Ensure tags is always an array
-        lifespan: {
-          ...value.lifespan,
-          // Use revalidate value for expireAge to match project configuration
-          expireAge: value.lifespan?.revalidate || value.lifespan?.expireAge,
-          // Recalculate expireAt based on lastModifiedAt + revalidate
-          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
-        }
-      };
-
-      // Debug final lifespan values to see if they changed
-      console_log('🔍 Final lifespan values after compression and fix:', {
-        expireAge: result.lifespan?.expireAge,
-        expireAt: result.lifespan?.expireAt,
-        revalidate: result.lifespan?.revalidate,
-        staleAge: result.lifespan?.staleAge,
-        originalExpireAge: value.lifespan?.expireAge,
-        fixedToMatchRevalidate:
-          result.lifespan?.expireAge === result.lifespan?.revalidate,
-        changed: result.lifespan?.expireAge !== value.lifespan?.expireAge
-      });
-
-      // Additional validation for Redis handler requirements
-      console_log('🔍 Compressed cache entry validation:', {
-        hasLastModified: result.lastModified !== undefined,
-        hasLifespan: result.lifespan !== undefined,
-        lifespanExpireAtType: typeof result.lifespan?.expireAt,
-        lifespanExpireAtValue: result.lifespan?.expireAt,
-        tagsIsArray: Array.isArray(result.tags),
-        tagsLength: result.tags?.length,
-        isValidForRedis:
-          result.lastModified !== undefined &&
-          result.lifespan?.expireAt !== undefined &&
-          typeof result.lifespan.expireAt === 'number' &&
-          Array.isArray(result.tags)
-      });
-
-      return result;
-    }
-
-    // For primitive values or non-cache-entry objects, compress directly
-    const serializedValue =
-      typeof value === 'string' ? value : JSON.stringify(value);
-    const originalSize = Buffer.byteLength(serializedValue, 'utf8');
-
-    if (originalSize < 1024) {
-      colorLog(
-        colors.blue,
-        '[Cache Handler] ⚡ ',
-        `Skipping compression for small value (${originalSize} bytes)`
-      );
-      // For non-Next.js cache entries, ensure they have required Redis fields if they're objects
-      // But NEVER modify Next.js cache entries (they have lastModified, lifespan, tags, value)
-      if (
-        value &&
-        typeof value === 'object' &&
-        value.lastModified === undefined &&
-        value.lifespan === undefined &&
-        value.value === undefined
-      ) {
-        // This is a primitive object, not a Next.js cache entry
-        return {
-          ...value,
-          tags: value.tags || [], // Preserve existing tags or add empty array
-          lastModified: Date.now(),
-          lifespan: {
-            expireAt: Math.floor(Date.now() / 1000) + 3600
-          }
-        };
-      }
-      // Fix expireAge for Next.js cache entries to match project's revalidate value
-      if (
-        value &&
-        typeof value === 'object' &&
-        value.lifespan &&
-        value.lifespan.revalidate
-      ) {
-        return {
-          ...value,
-          lifespan: {
-            ...value.lifespan,
-            // Use revalidate value for expireAge to match project configuration
-            expireAge: value.lifespan.revalidate,
-            // Recalculate expireAt based on lastModifiedAt + revalidate
-            expireAt:
-              value.lifespan.lastModifiedAt && value.lifespan.revalidate
-                ? value.lifespan.lastModifiedAt + value.lifespan.revalidate
-                : value.lifespan.expireAt
-          }
-        };
-      }
-      // Return other values unchanged
-      return value;
-    }
-
-    const zstdLib = getZstd();
-    let compressed;
-
-    if (zstdLib && zstdLib !== false) {
-      compressed = zstdLib.compress(Buffer.from(serializedValue, 'utf8'), 3);
-      colorLog(colors.cyan, '[Cache Handler] 🔵 ', `Using ZSTD compression`);
-    } else {
-      // No fallback compression - if ZSTD fails, don't compress
-      colorLog(
-        colors.yellow,
-        '[Cache Handler] ⚠️ ',
-        `ZSTD not available, storing uncompressed`
-      );
-      // For non-Next.js cache entries, ensure they have required Redis fields if they're objects
-      // But NEVER modify Next.js cache entries (they have lastModified, lifespan, tags, value)
-      if (
-        value &&
-        typeof value === 'object' &&
-        value.lastModified === undefined &&
-        value.lifespan === undefined &&
-        value.value === undefined
-      ) {
-        // This is a primitive object, not a Next.js cache entry
-        return {
-          ...value,
-          tags: value.tags || [], // Preserve existing tags or add empty array
-          lastModified: Date.now(),
-          lifespan: {
-            expireAt: Math.floor(Date.now() / 1000) + 3600
-          }
-        };
-      }
-      // Return Next.js cache entries and other values unchanged
-      return value;
-    }
-
-    const compressedBase64 = Buffer.from(compressed).toString('base64');
-    const compressionRatio =
-      ((originalSize - compressed.length) / originalSize) * 100;
-
-    colorLog(
-      colors.cyan,
-      '[Cache Handler] 🔵 ',
-      `Compressed ${originalSize} → ${
-        compressed.length
-      } bytes (${compressionRatio.toFixed(1)}% reduction, method: zstd)`
-    );
-
-    // For compressed non-Next.js entries, ensure Redis compatibility
-    const compressedResult = {
-      __compressed: true,
-      __method: 'zstd',
-      __originalSize: originalSize,
-      __compressedSize: compressed.length,
-      __data: compressedBase64,
-      // Add required Redis fields only for truly primitive values (not cache entries)
-      tags: [], // Required array for Redis handler
-      lastModified: Date.now(),
-      lifespan: { expireAt: Math.floor(Date.now() / 1000) + 3600 } // Default 1 hour for primitive values only
-    };
-
-    console_log('🔍 Non-Next.js compressed entry validation:', {
-      hasRequiredFields:
-        Array.isArray(compressedResult.tags) &&
-        compressedResult.lastModified !== undefined &&
-        compressedResult.lifespan?.expireAt !== undefined &&
-        typeof compressedResult.lifespan.expireAt === 'number'
-    });
-
-    return compressedResult;
-  } catch (error) {
-    console.warn(
-      '[Cache Handler] Compression failed, storing uncompressed:',
-      error.message
-    );
-    return value; // Return original value on error
-  }
-};
-
-const decompressValue = async (compressedData) => {
-  try {
-    console_log(
-      '🔍 Decompressing value type:',
-      typeof compressedData,
-      'keys:',
-      compressedData && typeof compressedData === 'object'
-        ? Object.keys(compressedData)
-        : 'N/A'
-    );
-
-    // Check if this is a Next.js cache entry with compressed nested value
-    if (
-      compressedData &&
-      typeof compressedData === 'object' &&
-      compressedData.value &&
-      typeof compressedData.value === 'object' &&
-      compressedData.value.__compressed
-    ) {
-      console_log(
-        '📦 Next.js cache entry with compressed nested value detected'
-      );
-
-      const compressedNestedValue = compressedData.value;
-      const compressedBuffer = Buffer.from(
-        compressedNestedValue.__data,
-        'base64'
-      );
-      let decompressed;
-
-      if (compressedNestedValue.__method === 'zstd') {
-        const zstdLib = getZstd();
-        if (zstdLib && zstdLib !== false) {
-          decompressed = zstdLib.decompress(compressedBuffer).toString('utf8');
-          colorLog(
-            colors.cyan,
-            '[Cache Handler] 🔵 ',
-            'Using ZSTD decompression for nested value'
-          );
-        } else {
-          throw new Error('zstd not available for decompression');
-        }
-      } else {
-        // Legacy support for gzip compressed data, but warn about it
-        colorLog(
-          colors.yellow,
-          '[Cache Handler] ⚠️ ',
-          'Found legacy gzip compressed data, consider cache invalidation'
-        );
-        throw new Error(
-          'gzip decompression no longer supported - please invalidate cache'
-        );
-      }
-
-      colorLog(
-        colors.cyan,
-        '[Cache Handler] 🔵 ',
-        `Decompressed nested value ${compressedNestedValue.__compressedSize} → ${decompressed.length} bytes (method: zstd)`
-      );
-
-      // Restore the original cache entry structure with decompressed nested value
-      return {
-        ...compressedData, // Preserve all metadata (lastModified, expiresAt, tags, etc.)
-        value: JSON.parse(decompressed) // Restore original nested value
-      };
-    }
-
-    // Check if this is a directly compressed value
-    if (
-      compressedData &&
-      typeof compressedData === 'object' &&
-      compressedData.__compressed
-    ) {
-      console_log('📄 Directly compressed value detected');
-
-      const compressedBuffer = Buffer.from(compressedData.__data, 'base64');
-      let decompressed;
-
-      if (compressedData.__method === 'zstd') {
-        const zstdLib = getZstd();
-        if (zstdLib && zstdLib !== false) {
-          decompressed = zstdLib.decompress(compressedBuffer).toString('utf8');
-          colorLog(
-            colors.cyan,
-            '[Cache Handler] 🔵 ',
-            'Using ZSTD decompression'
-          );
-        } else {
-          throw new Error('zstd not available for decompression');
-        }
-      } else {
-        // Legacy support for gzip compressed data, but warn about it
-        colorLog(
-          colors.yellow,
-          '[Cache Handler] ⚠️ ',
-          'Found legacy gzip compressed data, consider cache invalidation'
-        );
-        throw new Error(
-          'gzip decompression no longer supported - please invalidate cache'
-        );
-      }
-
-      colorLog(
-        colors.cyan,
-        '[Cache Handler] 🔵 ',
-        `Decompressed ${compressedData.__compressedSize} → ${decompressed.length} bytes (method: zstd)`
-      );
-
-      return JSON.parse(decompressed);
-    }
-
-    // No compression detected, return as-is
-    console_log('✨ No compression detected, returning value as-is');
-    return compressedData;
-  } catch (error) {
-    console.warn('[Cache Handler] Decompression failed:', error.message);
-    return compressedData; // Return original data on error
-  }
-};
 
 // Cache configuration
 const CACHE_CONFIG = {
@@ -575,53 +136,12 @@ async function getRedisClient() {
 
 CacheHandler.onCreation(async () => {
   console_log('Initializing cache handlers...');
-  colorLog(
-    colors.blue,
-    '[Cache Handler] 🔧 ',
-    'Starting cache handler initialization...'
-  );
-
-  // Force log to appear even if debug is off
-  colorLog(
-    colors.green,
-    '[Cache Handler] 🚀 ',
-    'CACHE HANDLER INITIALIZATION STARTING'
-  );
-  colorLog(colors.blue, '[Cache Handler] 🔧 ', 'Environment check:');
-  colorLog(
-    colors.blue,
-    '[Cache Handler] 🔧 ',
-    '- CACHE_HOST:',
-    process.env.CACHE_HOST
-  );
-  colorLog(
-    colors.blue,
-    '[Cache Handler] 🔧 ',
-    '- CACHE_PORT:',
-    process.env.CACHE_PORT
-  );
-  colorLog(
-    colors.blue,
-    '[Cache Handler] 🔧 ',
-    '- NODE_ENV:',
-    process.env.NODE_ENV
-  );
 
   let client;
   try {
     client = await getRedisClient();
-    colorLog(
-      colors.green,
-      '[Cache Handler] ✅ ',
-      'Redis client connected successfully'
-    );
   } catch (error) {
     // Error already logged in getRedisClient, just return local handler
-    colorLog(
-      colors.red,
-      '[Cache Handler] ❌ ',
-      'Redis connection failed, using local cache only'
-    );
     return {
       handlers: [createLruHandler(CACHE_CONFIG.lru)]
     };
@@ -630,20 +150,22 @@ CacheHandler.onCreation(async () => {
   const redisHandler = createRedisHandler({
     client,
     timeoutMs: CACHE_CONFIG.redis.timeoutMs,
-    keyExpirationStrategy: 'EXPIREAT' // Use EXPIREAT for Redis 6.0.x compatibility
+    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}:` : '';
 
   // Create optimized functions for each scenario
-  const versionKeyString = (key) => `${versionPrefix}${key}`;
-  const versionKeyObject = (key) => ({
-    ...key,
-    key: `${versionPrefix}${key.key}`
-  });
+  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) => {
@@ -657,24 +179,10 @@ CacheHandler.onCreation(async () => {
     name: 'custom-local-then-redis',
     get: async (key, context) => {
       const vKey = versionKey(key);
-      const keyStr = typeof vKey === 'string' ? vKey : vKey?.key;
-
-      // Force log GET calls to see if handler is being used
-      colorLog(colors.white, '[Cache Handler] 🔍 ', `CACHE GET: ${keyStr}`);
-      console_log('GET called for key:', keyStr);
-
-      // Extract and log URL information for better debugging
-      if (keyStr) {
-        const urlMatch = keyStr.match(/https?%3A%2F%2F[^_]+|\/[^_]*$/);
-        const extractedUrl = urlMatch
-          ? decodeURIComponent(urlMatch[0])
-          : 'unknown';
-        colorLog(
-          colors.white,
-          '[Cache Handler] 🌐 ',
-          `Cache GET for URL: ${extractedUrl}`
-        );
-      }
+      console_log(
+        'GET called for key:',
+        typeof vKey === 'string' ? vKey : vKey?.key
+      );
 
       // Check local cache first
       console_log('Checking local cache...');
@@ -682,38 +190,6 @@ CacheHandler.onCreation(async () => {
 
       if (localResult) {
         console_log('Found in local cache');
-        // Check if it's compressed data (new format or legacy format)
-        if (
-          localResult &&
-          typeof localResult === 'object' &&
-          (localResult.__compressed ||
-            (localResult.value && localResult.value.__compressed) ||
-            localResult.compressed !== undefined)
-        ) {
-          try {
-            const decompressed = await decompressValue(localResult);
-            // If it's a string, parse it; otherwise return as-is (it's already parsed)
-            return typeof decompressed === 'string'
-              ? JSON.parse(decompressed)
-              : decompressed;
-          } catch (error) {
-            console.warn(
-              '[Cache Handler] Failed to decompress local cache value:',
-              error.message
-            );
-            return localResult;
-          }
-        }
-
-        // Debug info for non-compressed values
-        console_log('🔍 Local result type:', typeof localResult);
-        if (
-          localResult &&
-          typeof localResult === 'object' &&
-          localResult.constructor === Object
-        ) {
-          console_log('🔍 Local result keys:', Object.keys(localResult));
-        }
         return localResult;
       }
 
@@ -723,66 +199,14 @@ CacheHandler.onCreation(async () => {
 
         if (redisResult) {
           console_log('Found in Redis');
-
-          let finalResult = redisResult;
-
-          // Parse JSON if it's a string (Redis stores as JSON)
-          if (typeof redisResult === 'string') {
-            try {
-              finalResult = JSON.parse(redisResult);
-              console_log('🔄 Parsed JSON from Redis');
-            } catch (parseError) {
-              console.warn(
-                '⚠️ Failed to parse Redis JSON, using raw string:',
-                parseError.message
-              );
-              finalResult = redisResult;
-            }
-          }
-
-          // Check if it's compressed data and decompress (new format or legacy format)
-          if (
-            finalResult &&
-            typeof finalResult === 'object' &&
-            (finalResult.__compressed ||
-              (finalResult.value && finalResult.value.__compressed) ||
-              finalResult.compressed !== undefined)
-          ) {
-            try {
-              const decompressed = await decompressValue(finalResult);
-              // If it's a string, parse it; otherwise return as-is (it's already parsed)
-              finalResult =
-                typeof decompressed === 'string'
-                  ? JSON.parse(decompressed)
-                  : decompressed;
-            } catch (error) {
-              console.warn(
-                '[Cache Handler] Failed to decompress Redis cache value:',
-                error.message
-              );
-              // finalResult stays as is
-            }
-          }
-
-          // Debug Redis result
-          console_log('🔍 Redis result type:', typeof redisResult);
-          console_log('🔍 Final result type:', typeof finalResult);
-          if (
-            finalResult &&
-            typeof finalResult === 'object' &&
-            finalResult.constructor === Object
-          ) {
-            console_log('🔍 Final result keys:', Object.keys(finalResult));
-          }
-
           // Sync back to local cache for faster future access
           try {
-            await localHandler.set(vKey, finalResult, context);
+            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 (error) {
         console_log('Redis error:', error.message);
@@ -793,260 +217,17 @@ CacheHandler.onCreation(async () => {
     },
     set: async (key, value, context) => {
       const vKey = versionKey(key);
-      const keyStr = typeof vKey === 'string' ? vKey : vKey?.key;
-
-      // Force log SET calls to see if handler is being used
-      colorLog(colors.white, '[Cache Handler] 💾 ', `CACHE SET: ${keyStr}`);
-      console_log('SET called for key:', keyStr);
-
-      // Extract and log URL information for better debugging
-      if (keyStr) {
-        const urlMatch = keyStr.match(/https?%3A%2F%2F[^_]+|\/[^_]*$/);
-        const extractedUrl = urlMatch
-          ? decodeURIComponent(urlMatch[0])
-          : 'unknown';
-        colorLog(
-          colors.white,
-          '[Cache Handler] 🌐 ',
-          `Cache SET for URL: ${extractedUrl}`
-        );
-      }
-
-      // Log context and value information for debugging
-      console_log('SET Debug Info:', {
-        contextKeys: context ? Object.keys(context) : 'no context',
-        valueKeys:
-          value && typeof value === 'object'
-            ? Object.keys(value)
-            : 'primitive value',
-        valueType: typeof value,
-        contextRevalidatedAt: context?.revalidatedAt,
-        contextExpiresAt: context?.expiresAt,
-        contextLifespan: context?.lifespan,
-        valueTags: value?.tags,
-        valueLastModified: value?.lastModified,
-        valueExpiresAt: value?.expiresAt,
-        valueLifespan: value?.lifespan,
-        lifespanExpireAt: value?.lifespan?.expireAt,
-        currentTime: Math.floor(Date.now() / 1000),
-        ttlRemaining: value?.lifespan?.expireAt
-          ? value.lifespan.expireAt - Math.floor(Date.now() / 1000)
-          : 'unknown'
-      });
-
-      // Debug original value TTL before any processing
-      colorLog(
-        colors.yellow,
-        '[Cache Handler] 🔍 ',
-        'ORIGINAL VALUE TTL DEBUG:',
-        {
-          originalExpireAt: value?.lifespan?.expireAt,
-          originalExpireAge: value?.lifespan?.expireAge,
-          originalRevalidate: value?.lifespan?.revalidate,
-          currentTime: Math.floor(Date.now() / 1000),
-          ttlRemaining: value?.lifespan?.expireAt
-            ? value.lifespan.expireAt - Math.floor(Date.now() / 1000)
-            : 'N/A'
-        }
+      console_log(
+        'SET called for key:',
+        typeof vKey === 'string' ? vKey : vKey?.key
       );
-
-      // Try to compress the value first
-      let compressedValue;
-      let shouldUseCompressed = false;
-
-      try {
-        colorLog(
-          colors.blue,
-          '[Cache Handler] 🧪 ',
-          `Attempting compression for ${keyStr}`
-        );
-        compressedValue = await compressValue(value);
-
-        // Debug compressed value TTL after compression
-        colorLog(
-          colors.yellow,
-          '[Cache Handler] 🔍 ',
-          'COMPRESSED VALUE TTL DEBUG:',
-          {
-            compressedExpireAt: compressedValue?.lifespan?.expireAt,
-            compressedExpireAge: compressedValue?.lifespan?.expireAge,
-            compressedRevalidate: compressedValue?.lifespan?.revalidate,
-            ttlChanged:
-              value?.lifespan?.expireAt !== compressedValue?.lifespan?.expireAt,
-            originalTTL: value?.lifespan?.expireAt,
-            compressedTTL: compressedValue?.lifespan?.expireAt
-          }
-        );
-
-        // Check if compression actually happened (compressValue returns original if no compression)
-        shouldUseCompressed =
-          compressedValue !== value &&
-          (compressedValue?.__compressed ||
-            compressedValue?.value?.__compressed);
-        colorLog(
-          colors.green,
-          '[Cache Handler] ✅ ',
-          `Compression ${
-            shouldUseCompressed ? 'SUCCESS' : 'SKIPPED'
-          } for ${keyStr}`
-        );
-      } catch (error) {
-        colorLog(
-          colors.red,
-          '[Cache Handler] ❌ ',
-          `Compression failed for ${keyStr}:`,
-          error.message
-        );
-        console.warn(
-          '[Cache Handler] Compression failed, using original value:',
-          error.message
-        );
-        compressedValue = value;
-        shouldUseCompressed = false;
-      }
-
-      // Set to both caches - local gets original, Redis gets compressed (if successful)
-      // IMPORTANT: Both calls must use the same context to preserve TTL
-
-      // Try Redis with compressed value first, fallback to original on error
-      let redisSetResult;
-
-      if (shouldUseCompressed) {
-        // Log before attempting Redis SET with compression
-        colorLog(
-          colors.blue,
-          '[Cache Handler] 💾 ',
-          `Attempting Redis SET with compression for: ${keyStr}`
-        );
-
-        try {
-          // Debug what we're sending to Redis
-          colorLog(
-            colors.yellow,
-            '[Cache Handler] 🔍 ',
-            'SENDING TO REDIS (COMPRESSED):',
-            {
-              keyStr,
-              hasLifespan: compressedValue?.lifespan !== undefined,
-              expireAt: compressedValue?.lifespan?.expireAt,
-              expireAge: compressedValue?.lifespan?.expireAge,
-              contextExpireAt: context?.expiresAt,
-              contextLifespan: context?.lifespan
-            }
-          );
-
-          await redisHandler.set(vKey, compressedValue, context);
-          colorLog(
-            colors.green,
-            '[Cache Handler] ✅ ',
-            `Redis SET with compression successful for: ${keyStr}`
-          );
-          redisSetResult = { status: 'fulfilled' };
-        } catch (compressionError) {
-          colorLog(
-            colors.yellow,
-            '[Cache Handler] ⚠️ ',
-            `Redis SET with compression failed for ${keyStr}, trying uncompressed fallback:`,
-            compressionError.message
-          );
-
-          // Fallback to original uncompressed value
-          try {
-            // Debug what we're sending to Redis as fallback
-            colorLog(
-              colors.yellow,
-              '[Cache Handler] 🔍 ',
-              'SENDING TO REDIS (FALLBACK UNCOMPRESSED):',
-              {
-                keyStr,
-                hasLifespan: value?.lifespan !== undefined,
-                expireAt: value?.lifespan?.expireAt,
-                expireAge: value?.lifespan?.expireAge,
-                contextExpireAt: context?.expiresAt,
-                contextLifespan: context?.lifespan
-              }
-            );
-
-            await redisHandler.set(vKey, value, context);
-            colorLog(
-              colors.green,
-              '[Cache Handler] ✅ ',
-              `Redis SET fallback (uncompressed) successful for: ${keyStr}`
-            );
-            redisSetResult = { status: 'fulfilled' };
-          } catch (fallbackError) {
-            colorLog(
-              colors.red,
-              '[Cache Handler] ❌ ',
-              `Redis SET fallback also failed for: ${keyStr}`,
-              fallbackError.message
-            );
-            redisSetResult = { status: 'rejected', reason: fallbackError };
-          }
-        }
-      } else {
-        // No compression, use original value directly
-        colorLog(
-          colors.blue,
-          '[Cache Handler] 💾 ',
-          `Attempting Redis SET (uncompressed) for: ${keyStr}`
-        );
-
-        try {
-          // Debug what we're sending to Redis (no compression)
-          colorLog(
-            colors.yellow,
-            '[Cache Handler] 🔍 ',
-            'SENDING TO REDIS (NO COMPRESSION):',
-            {
-              keyStr,
-              hasLifespan: value?.lifespan !== undefined,
-              expireAt: value?.lifespan?.expireAt,
-              expireAge: value?.lifespan?.expireAge,
-              contextExpireAt: context?.expiresAt,
-              contextLifespan: context?.lifespan
-            }
-          );
-
-          await redisHandler.set(vKey, value, context);
-          colorLog(
-            colors.green,
-            '[Cache Handler] ✅ ',
-            `Redis SET (uncompressed) successful for: ${keyStr}`
-          );
-          redisSetResult = { status: 'fulfilled' };
-        } catch (error) {
-          colorLog(
-            colors.red,
-            '[Cache Handler] ❌ ',
-            `Redis SET (uncompressed) failed for: ${keyStr}`,
-            error.message
-          );
-          redisSetResult = { status: 'rejected', reason: error };
-        }
-      }
-
-      // Always set to local cache with original value
-      let localSetResult;
-      try {
-        await localHandler.set(vKey, value, context);
-        localSetResult = { status: 'fulfilled' };
-      } catch (error) {
-        localSetResult = { status: 'rejected', reason: error };
-      }
-
-      const results = [localSetResult, redisSetResult];
-
-      // Log results
-      console_log('SET Results:', {
-        local: results[0].status,
-        redis: results[1].status,
-        localError:
-          results[0].status === 'rejected' ? results[0].reason?.message : null,
-        redisError:
-          results[1].status === 'rejected' ? results[1].reason?.message : null,
-        compressionUsed: shouldUseCompressed
-      });
+      // 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);
@@ -1069,11 +250,6 @@ CacheHandler.onCreation(async () => {
   };
 
   console_log('[Cache Handler] Handlers initialized successfully');
-  colorLog(
-    colors.green,
-    '[Cache Handler] 🎉 ',
-    'Cache handlers ready with Redis + Local LRU + Compression'
-  );
 
   return {
     handlers: [customHandler]