@akinon/next 2.0.0-beta.12 → 2.0.0-beta.13

package/lib/cache-handler.mjs

@@ -1,32 +1,544 @@
 import { CacheHandler } from '@neshca/cache-handler';
 import createLruHandler from '@neshca/cache-handler/local-lru';
-import createRedisHandler from '@neshca/cache-handler/redis-stack';
+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;
+  }
+};
+
+const CACHE_CONFIG = {
+  lru: {
+    maxItemCount: 2000
+  },
+  redis: {
+    timeoutMs: 5000,
+    reconnectStrategy: {
+      maxRetries: 3,
+      retryDelay: (retries) => Math.min(retries * 100, 3000)
+    },
+    connectTimeout: 500
+  },
+  host: process.env.CACHE_HOST || 'localhost',
+  port: process.env.CACHE_PORT || '6379',
+  bucket: process.env.CACHE_BUCKET ?? '0',
+  version: process.env.ACC_APP_VERSION || ''
+};
+
+const globalForRedis = global;
+if (!globalForRedis.redisClient) {
+  globalForRedis.redisClient = null;
+  globalForRedis.isConnecting = false;
+  globalForRedis.hasLoggedConnectionError = false;
+  globalForRedis.connectionAttempts = 0;
+}
+
+async function getRedisClient() {
+  if (globalForRedis.redisClient?.isReady) {
+    return globalForRedis.redisClient;
+  }
+
+  if (globalForRedis.isConnecting) {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    return getRedisClient();
+  }
+
+  globalForRedis.isConnecting = true;
+  globalForRedis.connectionAttempts++;
+
+  try {
+    const redisUrl = `redis://${CACHE_CONFIG.host}:${CACHE_CONFIG.port}/${CACHE_CONFIG.bucket}`;
+
+    const redisClient = createClient({
+      url: redisUrl,
+      socket: {
+        reconnectStrategy: (retries) => {
+          if (retries > CACHE_CONFIG.redis.reconnectStrategy.maxRetries) {
+            if (!globalForRedis.hasLoggedConnectionError) {
+              console.warn(
+                '[Cache Handler] Redis is not available, falling back to local cache only'
+              );
+              globalForRedis.hasLoggedConnectionError = true;
+            }
+            return false;
+          }
+          return CACHE_CONFIG.redis.reconnectStrategy.retryDelay(retries);
+        },
+        connectTimeout: CACHE_CONFIG.redis.connectTimeout
+      }
+    });
+
+    redisClient.on('error', (error) => {
+      if (!globalForRedis.hasLoggedConnectionError) {
+        if (error.code === 'ECONNREFUSED') {
+          console.warn(
+            '[Cache Handler] Redis connection refused. Is Redis running? Falling back to local cache.'
+          );
+        } else {
+          console.error('[Cache Handler] Redis client error:', error.message);
+        }
+        globalForRedis.hasLoggedConnectionError = true;
+      }
+    });
+
+    redisClient.on('connect', () => {
+      globalForRedis.hasLoggedConnectionError = false;
+    });
+
+    redisClient.on('ready', () => {
+      globalForRedis.hasLoggedConnectionError = false;
+    });
+
+    await redisClient.connect();
+    globalForRedis.redisClient = redisClient;
+    return redisClient;
+  } catch (error) {
+    if (!globalForRedis.hasLoggedConnectionError) {
+      globalForRedis.hasLoggedConnectionError = true;
+    }
+    globalForRedis.redisClient = null;
+    throw error;
+  } finally {
+    globalForRedis.isConnecting = false;
+  }
+}
+
 CacheHandler.onCreation(async () => {
-  const redisUrl = `redis://${process.env.CACHE_HOST}:${
-    process.env.CACHE_PORT
-  }/${process.env.CACHE_BUCKET ?? '0'}`;
+  let client;
+  try {
+    client = await getRedisClient();
+  } catch (error) {
+    return {
+      handlers: [createLruHandler(CACHE_CONFIG.lru)]
+    };
+  }
 
-  const client = createClient({
-    url: redisUrl
+  const redisHandler = createRedisHandler({
+    client,
+    timeoutMs: CACHE_CONFIG.redis.timeoutMs,
+    keyExpirationStrategy: 'EXPIREAT'
   });
 
-  client.on('error', (error) => {
-    console.error('Redis client error', { redisUrl, error });
-  });
+  const localHandler = createLruHandler(CACHE_CONFIG.lru);
 
-  await client.connect();
+  const CACHE_VERSION = 'v2';
+  const versionPrefix = `${CACHE_VERSION}_`;
 
-  const redisHandler = await createRedisHandler({
-    client,
-    timeoutMs: 5000
+  const versionKeyString = (key) => `${versionPrefix}${key}`;
+  const versionKeyObject = (key) => ({
+    ...key,
+    key: `${versionPrefix}${key.key}`
   });
 
-  // const localHandler = createLruHandler();
+  const versionKey = (key) => {
+    return typeof key === 'string'
+      ? versionKeyString(key)
+      : versionKeyObject(key);
+  };
+
+  const customHandler = {
+    name: 'custom-local-then-redis',
+    get: async (key, context) => {
+      const vKey = versionKey(key);
+
+      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;
+          }
+        }
+
+        return localResult;
+      }
+
+      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;
+            }
+          }
+
+          try {
+            await localHandler.set(vKey, finalResult, context);
+          } catch (_) {
+            return finalResult;
+          }
+          return finalResult;
+        }
+      } catch (_) {
+        return undefined;
+      }
+
+      return undefined;
+    },
+    set: async (key, value, context) => {
+      const vKey = versionKey(key);
+
+      const stripTags = (val) => {
+        if (val && typeof val === 'object') {
+          const { tags, ...rest } = val;
+          return { ...rest, tags: [] };
+        }
+        return val;
+      };
+
+      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, stripTags(compressedValue), context);
+
+          redisSetResult = { status: 'fulfilled' };
+        } catch (compressionError) {
+          try {
+            await redisHandler.set(vKey, stripTags(value), context);
+
+            redisSetResult = { status: 'fulfilled' };
+          } catch (fallbackError) {
+            redisSetResult = { status: 'rejected', reason: fallbackError };
+          }
+        }
+      } else {
+        try {
+          await redisHandler.set(vKey, stripTags(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);
+
+      await Promise.allSettled([
+        localHandler.delete?.(vKey, context),
+        redisHandler.delete?.(vKey, context)
+      ]);
+    },
+    revalidateTag: async (tags, context) => {
+      await Promise.allSettled([
+        localHandler.revalidateTag?.(tags, context),
+        redisHandler.revalidateTag?.(tags, context)
+      ]);
+    }
+  };
 
   return {
-    handlers: [redisHandler]
+    handlers: [customHandler]
   };
 });