@akinon/next 1.92.0 → 1.93.0-rc.47

package/lib/cache-handler.mjs

@@ -1,32 +1,241 @@
 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';
+import logger from '../utils/log';
 
-CacheHandler.onCreation(async () => {
-  const redisUrl = `redis://${process.env.CACHE_HOST}:${
-    process.env.CACHE_PORT
-  }/${process.env.CACHE_BUCKET ?? '0'}`;
+// Cache configuration
+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 client = createClient({
-    url: redisUrl
-  });
+// Use global to persist across module reloads in development
+const globalForRedis = global;
+if (!globalForRedis.redisClient) {
+  globalForRedis.redisClient = null;
+  globalForRedis.isConnecting = false;
+  globalForRedis.hasLoggedConnectionError = false;
+  globalForRedis.connectionAttempts = 0;
+}
 
-  client.on('error', (error) => {
-    console.error('Redis client error', { redisUrl, error });
-  });
+async function getRedisClient() {
+  // If client exists and is ready, return it
+  if (globalForRedis.redisClient?.isReady) {
+    logger.trace('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) {
+      logger.debug('Creating Redis connection', { url: redisUrl });
+    }
+
+    const redisClient = createClient({
+      url: redisUrl,
+      socket: {
+        reconnectStrategy: (retries) => {
+          if (retries > CACHE_CONFIG.redis.reconnectStrategy.maxRetries) {
+            if (!globalForRedis.hasLoggedConnectionError) {
+              logger.debug(
+                '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) => {
+      // Only log the first connection error to avoid spam
+      if (!globalForRedis.hasLoggedConnectionError) {
+        if (error.code === 'ECONNREFUSED') {
+          logger.debug(
+            'Redis connection refused. Is Redis running? Falling back to local cache.'
+          );
+        } else {
+          logger.warn('Redis client error', { error: error.message });
+        }
+        globalForRedis.hasLoggedConnectionError = true;
+      }
+    });
+
+    redisClient.on('connect', () => {
+      logger.debug('Redis connected');
+      globalForRedis.hasLoggedConnectionError = false;
+    });
+
+    redisClient.on('ready', () => {
+      logger.debug('Redis ready');
+      globalForRedis.hasLoggedConnectionError = false;
+    });
+
+    await redisClient.connect();
+    globalForRedis.redisClient = redisClient;
+    return redisClient;
+  } catch (error) {
+    if (!globalForRedis.hasLoggedConnectionError) {
+      if (error.code === 'ECONNREFUSED') {
+        logger.debug('Could not connect to Redis - using local cache only');
+      } else {
+        logger.error('Failed to connect to Redis', { error: error.message });
+      }
+      globalForRedis.hasLoggedConnectionError = true;
+    }
+    globalForRedis.redisClient = null;
+    throw error;
+  } finally {
+    globalForRedis.isConnecting = false;
+  }
+}
+
+CacheHandler.onCreation(async () => {
+  logger.debug('Initializing cache handlers...');
 
-  await client.connect();
+  let client;
+  try {
+    client = await getRedisClient();
+  } catch (error) {
+    // Error already logged in getRedisClient, just return local handler
+    return {
+      handlers: [createLruHandler(CACHE_CONFIG.lru)]
+    };
+  }
 
-  const redisHandler = await createRedisHandler({
+  const redisHandler = createRedisHandler({
     client,
-    timeoutMs: 5000
+    timeoutMs: CACHE_CONFIG.redis.timeoutMs,
+    keyExpirationStrategy: 'EXAT'
   });
 
-  // const localHandler = createLruHandler();
+  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 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);
+      logger.trace('GET called for key', {
+        key: typeof vKey === 'string' ? vKey : vKey?.key
+      });
+
+      // Check local cache first
+      logger.trace('Checking local cache...');
+      const localResult = await localHandler.get(vKey, context);
+
+      if (localResult) {
+        logger.trace('Found in local cache');
+        return localResult;
+      }
+
+      logger.trace('Not found in local, checking Redis...');
+      try {
+        const redisResult = await redisHandler.get(vKey, context);
+
+        if (redisResult) {
+          logger.trace('Found in Redis');
+          // Sync back to local cache for faster future access
+          try {
+            await localHandler.set(vKey, redisResult, context);
+            logger.trace('Synced to local cache');
+          } catch (error) {
+            logger.debug('Failed to sync to local', { error: error.message });
+          }
+          return redisResult;
+        }
+      } catch (error) {
+        logger.warn('Redis GET operation failed', { error: error.message });
+      }
+
+      logger.trace('Not found in any cache');
+      return undefined;
+    },
+    set: async (key, value, context) => {
+      const vKey = versionKey(key);
+      logger.trace('SET called for key', {
+        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) =>
+            logger.warn('Redis SET operation failed', { error: error.message })
+          )
+      ]);
+    },
+    delete: async (key, context) => {
+      const vKey = versionKey(key);
+      logger.trace('DELETE called for key', {
+        key: typeof vKey === 'string' ? vKey : vKey?.key
+      });
+      await Promise.allSettled([
+        localHandler.delete?.(vKey, context),
+        redisHandler.delete?.(vKey, context)
+      ]);
+    },
+    revalidateTag: async (tags, context) => {
+      logger.debug('REVALIDATE_TAG called for tags', { tags });
+      await Promise.allSettled([
+        localHandler.revalidateTag?.(tags, context),
+        redisHandler.revalidateTag?.(tags, context)
+      ]);
+    }
+  };
+
+  logger.info('Cache handlers initialized successfully');
 
   return {
-    handlers: [redisHandler]
+    handlers: [customHandler]
   };
 });
 

package/lib/cache.ts

@@ -31,6 +31,8 @@ export const CacheKey = {
     `category_${pk}_${encodeURIComponent(
       JSON.stringify(searchParams)
     )}${hashCacheKey(headers)}`,
+  Basket: (namespace?: string) => `basket${namespace ? `_${namespace}` : ''}`,
+  AllBaskets: () => 'all_baskets',
   CategorySlug: (slug: string) => `category_${slug}`,
   SpecialPage: (
     pk: number,

package/middlewares/checkout-provider.ts

@@ -64,7 +64,7 @@ const withCheckoutProvider =
           const location = request.headers.get('location');
           const redirectUrl = new URL(
             request.headers.get('location'),
-            location.startsWith('http') ? '' : process.env.NEXT_PUBLIC_URL
+            location.startsWith('http') ? '' : url.origin
           );
 
           redirectUrl.pathname = getUrlPathWithLocale(

package/middlewares/complete-gpay.ts

@@ -34,6 +34,7 @@ const withCompleteGpay =
     const url = req.nextUrl.clone();
     const ip = req.headers.get('x-forwarded-for') ?? '';
     const sessionId = req.cookies.get('osessionid');
+    const currentLocale = req.middlewareParams?.rewrites?.locale;
 
     if (url.search.indexOf('GPayCompletePage') === -1) {
       return middleware(req, event);
@@ -45,7 +46,9 @@ const withCompleteGpay =
       'Content-Type': 'application/x-www-form-urlencoded',
       Cookie: req.headers.get('cookie') ?? '',
       'x-currency': req.cookies.get('pz-currency')?.value ?? '',
-      'x-forwarded-for': ip
+      'x-forwarded-for': ip,
+      'Accept-Language':
+        currentLocale ?? req.cookies.get('pz-locale')?.value ?? ''
     };
 
     try {
@@ -145,7 +148,8 @@ const withCompleteGpay =
       logger.info('Redirecting to order success page', {
         middleware: 'complete-gpay',
         redirectUrlWithLocale,
-        ip
+        ip,
+        setCookie: request.headers.get('set-cookie')
       });
 
       // Using POST method while redirecting causes an error,

package/middlewares/complete-masterpass.ts

@@ -4,6 +4,7 @@ import { Buffer } from 'buffer';
 import logger from '../utils/log';
 import { getUrlPathWithLocale } from '../utils/localization';
 import { PzNextRequest } from '.';
+import { ServerVariables } from '../utils/server-variables';
 
 const streamToString = async (stream: ReadableStream<Uint8Array> | null) => {
   if (stream) {
@@ -34,6 +35,7 @@ const withCompleteMasterpass =
     const url = req.nextUrl.clone();
     const ip = req.headers.get('x-forwarded-for') ?? '';
     const sessionId = req.cookies.get('osessionid');
+    const currentLocale = req.middlewareParams?.rewrites?.locale;
 
     if (url.search.indexOf('MasterpassCompletePage') === -1) {
       return middleware(req, event);
@@ -45,7 +47,9 @@ const withCompleteMasterpass =
       'Content-Type': 'application/x-www-form-urlencoded',
       Cookie: req.headers.get('cookie') ?? '',
       'x-currency': req.cookies.get('pz-currency')?.value ?? '',
-      'x-forwarded-for': ip
+      'x-forwarded-for': ip,
+      'Accept-Language':
+        currentLocale ?? req.cookies.get('pz-locale')?.value ?? ''
     };
 
     try {
@@ -145,7 +149,8 @@ const withCompleteMasterpass =
       logger.info('Redirecting to order success page', {
         middleware: 'complete-masterpass',
         redirectUrlWithLocale,
-        ip
+        ip,
+        setCookie: request.headers.get('set-cookie')
       });
 
       // Using POST method while redirecting causes an error,