@akinon/next 1.93.0-snapshot-ZERO-3574-20250813140510 → 1.93.0

package/data/server/product.ts

@@ -35,84 +35,57 @@ const getProductDataHandler = ({
           .join('&');
     }
 
-    let data: ProductResult;
-
-    try {
-      data = await appFetch<ProductResult>({
-        url,
-        locale,
-        currency,
-        init: {
-          headers: {
-            Accept: 'application/json',
-            'Content-Type': 'application/json',
-            ...(headers ?? {})
-          }
+    const data = await appFetch<ProductResult>({
+      url,
+      locale,
+      currency,
+      init: {
+        headers: {
+          Accept: 'application/json',
+          'Content-Type': 'application/json',
+          ...(headers ?? {})
         }
-      });
-    } catch (error) {
-      logger.error('Failed to fetch product data', {
-        handler: 'getProductDataHandler',
-        pk,
-        error: error.message,
-        url
-      });
-      return null;
-    }
+      }
+    });
 
     const categoryUrl = product.categoryUrl(data.product.pk);
 
-    let productCategoryData: ProductCategoryResult;
-    let breadcrumbData: { menu?: unknown } = {};
-
-    try {
-      productCategoryData = await appFetch<ProductCategoryResult>({
-        url: categoryUrl,
-        locale,
-        currency,
-        init: {
-          headers: {
-            Accept: 'application/json',
-            'Content-Type': 'application/json'
-          }
+    const productCategoryData = await appFetch<ProductCategoryResult>({
+      url: categoryUrl,
+      locale,
+      currency,
+      init: {
+        headers: {
+          Accept: 'application/json',
+          'Content-Type': 'application/json'
         }
-      });
-
-      const menuItemModel = productCategoryData?.results[0]?.menuitemmodel;
-
-      if (!menuItemModel) {
-        logger.warn(
-          'menuItemModel is undefined, skipping breadcrumbData fetch',
-          {
-            handler: 'getProductDataHandler',
-            pk
-          }
-        );
-        return { data, breadcrumbData: undefined };
       }
+    });
 
-      const breadcrumbUrl = product.breadcrumbUrl(menuItemModel);
+    const menuItemModel = productCategoryData?.results[0]?.menuitemmodel;
 
-      breadcrumbData = await appFetch<{ menu?: unknown }>({
-        url: breadcrumbUrl,
-        locale,
-        currency,
-        init: {
-          headers: {
-            Accept: 'application/json',
-            'Content-Type': 'application/json'
-          }
-        }
-      });
-    } catch (error) {
-      logger.warn('Failed to fetch breadcrumb data', {
+    if (!menuItemModel) {
+      logger.warn('menuItemModel is undefined, skipping breadcrumbData fetch', {
         handler: 'getProductDataHandler',
-        pk,
-        error: error.message
+        pk
       });
-      // Continue without breadcrumb data
+      return { data, breadcrumbData: undefined };
     }
 
+    const breadcrumbUrl = product.breadcrumbUrl(menuItemModel);
+
+    const breadcrumbData = await appFetch<any>({
+      url: breadcrumbUrl,
+      locale,
+      currency,
+      init: {
+        headers: {
+          Accept: 'application/json',
+          'Content-Type': 'application/json'
+        }
+      }
+    });
+
     return {
       data,
       breadcrumbData: breadcrumbData?.menu

package/data/server/special-page.ts

@@ -15,24 +15,20 @@ const getSpecialPageDataHandler = (
   return async function () {
     const params = generateCommerceSearchParams(searchParams);
 
-    try {
-      const data: GetCategoryResponse = await appFetch({
-        url: `${category.getSpecialPageByPk(pk)}${params}`,
-        locale,
-        currency,
-        init: {
-          headers: {
-            Accept: 'application/json',
-            'Content-Type': 'application/json',
-            ...(headers ?? {})
-          }
+    const data: GetCategoryResponse = await appFetch({
+      url: `${category.getSpecialPageByPk(pk)}${params}`,
+      locale,
+      currency,
+      init: {
+        headers: {
+          Accept: 'application/json',
+          'Content-Type': 'application/json',
+          ...(headers ?? {})
         }
-      });
+      }
+    });
 
-      return data;
-    } catch (error) {
-      return null;
-    }
+    return data;
   };
 };
 

package/data/urls.ts

@@ -142,8 +142,7 @@ export const checkout = {
   setOrderSelectionPage: '/orders/checkout/?page=OrderSelectionPage',
   loyaltyCardPage: '/orders/checkout/?page=LoyaltyCardPage',
   sendSmsPage: '/orders/checkout/?page=SendSmsPage',
-  verifySmsPage: '/orders/checkout/?page=VerifySmsPage',
-  saveSampleProducts: '/orders/checkout/?page=SampleProductPage'
+  verifySmsPage: '/orders/checkout/?page=VerifySmsPage'
 };
 
 export const flatpage = {
@@ -183,11 +182,7 @@ export const product = {
   breadcrumbUrl: (menuitemmodel: string) =>
     `/menus/generate_breadcrumb/?item=${menuitemmodel}&generator_name=menu_item`,
   bundleProduct: (productPk: string, queryString: string) =>
-    `/bundle-product/${productPk}/?${queryString}`,
-  similarProducts: (params?: string) =>
-    `/similar-products${params ? `?${params}` : ''}`,
-  similarProductsList: (params?: string) =>
-    `/similar-product-list${params ? `?${params}` : ''}`
+    `/bundle-product/${productPk}/?${queryString}`
 };
 
 export const wishlist = {

package/hocs/server/with-segment-defaults.tsx

@@ -72,13 +72,10 @@ const addRootLayoutProps = async (componentProps: RootLayoutProps) => {
 const checkRedisVariables = () => {
   const requiredVariableValues = [
     process.env.CACHE_HOST,
-    process.env.CACHE_PORT
+    process.env.CACHE_PORT,
+    process.env.CACHE_SECRET
   ];
 
-  if (!settings.usePrettyUrlRoute) {
-    requiredVariableValues.push(process.env.CACHE_SECRET);
-  }
-
   if (
     !requiredVariableValues.every((v) => v) &&
     process.env.NODE_ENV === 'production'

package/hooks/use-localization.ts

@@ -4,6 +4,7 @@ import { LocalizationContext } from '../localization/provider';
 import { useContext } from 'react';
 import { setCookie, urlLocaleMatcherRegex } from '../utils';
 import { LocaleUrlStrategy } from '../localization';
+import { useRouter } from 'next/navigation';
 
 export const useLocalization = () => {
   const {
@@ -17,6 +18,8 @@ export const useLocalization = () => {
     localeUrlStrategy
   } = useContext(LocalizationContext);
 
+  const router = useRouter();
+
   /**
    * Sets the locale in the URL.
    * @param locale Locale value defined in the settings.
@@ -27,8 +30,6 @@ export const useLocalization = () => {
 
     let targetUrl;
 
-    setCookie('pz-locale', locale);
-
     if (localeUrlStrategy === LocaleUrlStrategy.Subdomain) {
       const hostParts = hostname.split('.');
       const subDomain = hostParts[0];

package/instrumentation/node.ts

@@ -4,19 +4,17 @@ import { Resource } from '@opentelemetry/resources';
 import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
 import { SimpleSpanProcessor } from '@opentelemetry/sdk-trace-node';
 
-if (process.env.NODE_ENV === 'development') {
-  const sdk = new NodeSDK({
-    resource: new Resource({
-      [SemanticResourceAttributes.SERVICE_NAME]: 'pz-next-app'
-    }),
-    spanProcessor: new SimpleSpanProcessor(
-      new OTLPTraceExporter({
-        url: `${
-          process.env.PZ_DASHBOARD_URL ?? 'http://localhost:3005'
-        }/api/traces`
-      })
-    )
-  });
+const sdk = new NodeSDK({
+  resource: new Resource({
+    [SemanticResourceAttributes.SERVICE_NAME]: 'pz-next-app'
+  }),
+  spanProcessor: new SimpleSpanProcessor(
+    new OTLPTraceExporter({
+      url: `${
+        process.env.PZ_DASHBOARD_URL ?? 'http://localhost:3005'
+      }/api/traces`
+    })
+  )
+});
 
-  sdk.start();
-}
+sdk.start();

package/jest.config.js

@@ -1,19 +1,13 @@
 const path = require('path');
-const findBaseDir = require('./utils/find-base-dir');
-
-const baseDir = findBaseDir();
 
 module.exports = {
   preset: 'ts-jest',
   testEnvironment: 'node',
   rootDir: path.resolve(__dirname),
+  roots: [],
   testMatch: ['**/*.test.ts'],
   testPathIgnorePatterns: [],
-  roots: [path.resolve(__dirname)],
   transformIgnorePatterns: [],
-  moduleNameMapper: {
-    '^settings$': path.resolve(baseDir, 'src/settings.js')
-  },
   transform: {
     '^.+\\.(tsx?|jsx?|mjs?)$': [
       'ts-jest',

package/lib/cache-handler.mjs

@@ -2,7 +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 logger from '../utils/log';
 
 // Cache configuration
 const CACHE_CONFIG = {
@@ -32,10 +31,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) {
-    logger.trace('Reusing existing Redis connection');
+    console_log('Reusing existing Redis connection');
     return globalForRedis.redisClient;
   }
 
@@ -53,7 +64,7 @@ async function getRedisClient() {
     const redisUrl = `redis://${CACHE_CONFIG.host}:${CACHE_CONFIG.port}/${CACHE_CONFIG.bucket}`;
 
     if (globalForRedis.connectionAttempts === 1) {
-      logger.debug('Creating Redis connection', { url: redisUrl });
+      console_log('Creating Redis connection:', redisUrl);
     }
 
     const redisClient = createClient({
@@ -62,8 +73,8 @@ async function getRedisClient() {
         reconnectStrategy: (retries) => {
           if (retries > CACHE_CONFIG.redis.reconnectStrategy.maxRetries) {
             if (!globalForRedis.hasLoggedConnectionError) {
-              logger.debug(
-                'Redis is not available, falling back to local cache only'
+              console.warn(
+                '[Cache Handler] Redis is not available, falling back to local cache only'
               );
               globalForRedis.hasLoggedConnectionError = true;
             }
@@ -79,23 +90,23 @@ async function getRedisClient() {
       // 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.'
+          console.warn(
+            '[Cache Handler] Redis connection refused. Is Redis running? Falling back to local cache.'
           );
         } else {
-          logger.warn('Redis client error', { error: error.message });
+          console.error('[Cache Handler] Redis client error:', error.message);
         }
         globalForRedis.hasLoggedConnectionError = true;
       }
     });
 
     redisClient.on('connect', () => {
-      logger.debug('Redis connected');
+      console_log('Redis connected');
       globalForRedis.hasLoggedConnectionError = false;
     });
 
     redisClient.on('ready', () => {
-      logger.debug('Redis ready');
+      console_log('Redis ready');
       globalForRedis.hasLoggedConnectionError = false;
     });
 
@@ -105,9 +116,14 @@ async function getRedisClient() {
   } catch (error) {
     if (!globalForRedis.hasLoggedConnectionError) {
       if (error.code === 'ECONNREFUSED') {
-        logger.debug('Could not connect to Redis - using local cache only');
+        console.warn(
+          '[Cache Handler] Could not connect to Redis - using local cache only'
+        );
       } else {
-        logger.error('Failed to connect to Redis', { error: error.message });
+        console.error(
+          '[Cache Handler] Failed to connect to Redis:',
+          error.message
+        );
       }
       globalForRedis.hasLoggedConnectionError = true;
     }
@@ -119,7 +135,7 @@ async function getRedisClient() {
 }
 
 CacheHandler.onCreation(async () => {
-  logger.debug('Initializing cache handlers...');
+  console_log('Initializing cache handlers...');
 
   let client;
   try {
@@ -163,68 +179,69 @@ CacheHandler.onCreation(async () => {
     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
-      });
+      console_log(
+        'GET called for key:',
+        typeof vKey === 'string' ? vKey : vKey?.key
+      );
 
       // Check local cache first
-      logger.trace('Checking local cache...');
+      console_log('Checking local cache...');
       const localResult = await localHandler.get(vKey, context);
 
       if (localResult) {
-        logger.trace('Found in local cache');
+        console_log('Found in local cache');
         return localResult;
       }
 
-      logger.trace('Not found in local, checking Redis...');
+      console_log('Not found in local, checking Redis...');
       try {
         const redisResult = await redisHandler.get(vKey, context);
 
         if (redisResult) {
-          logger.trace('Found in Redis');
+          console_log('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');
+            console_log('Synced to local cache');
           } catch (error) {
-            logger.debug('Failed to sync to local', { error: error.message });
+            console_log('Failed to sync to local:', error.message);
           }
           return redisResult;
         }
       } catch (error) {
-        logger.warn('Redis GET operation failed', { error: error.message });
+        console_log('Redis error:', error.message);
       }
 
-      logger.trace('Not found in any cache');
+      console_log('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
-      });
+      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) =>
-            logger.warn('Redis SET operation failed', { error: error.message })
-          )
+          .catch((error) => console_log('Redis SET error:', error.message))
       ]);
     },
     delete: async (key, context) => {
       const vKey = versionKey(key);
-      logger.trace('DELETE called for key', {
-        key: typeof vKey === 'string' ? vKey : vKey?.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) => {
-      logger.debug('REVALIDATE_TAG called for tags', { tags });
+      console_log('REVALIDATE_TAG called for tags:', tags);
       await Promise.allSettled([
         localHandler.revalidateTag?.(tags, context),
         redisHandler.revalidateTag?.(tags, context)
@@ -232,7 +249,7 @@ CacheHandler.onCreation(async () => {
     }
   };
 
-  logger.info('Cache handlers initialized successfully');
+  console_log('[Cache Handler] Handlers initialized successfully');
 
   return {
     handlers: [customHandler]

package/lib/cache.ts

@@ -31,8 +31,6 @@ 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') ? '' : url.origin
+            location.startsWith('http') ? '' : process.env.NEXT_PUBLIC_URL
           );
 
           redirectUrl.pathname = getUrlPathWithLocale(

package/middlewares/complete-gpay.ts

@@ -34,7 +34,6 @@ 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);
@@ -46,9 +45,7 @@ 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,
-      'Accept-Language':
-        currentLocale ?? req.cookies.get('pz-locale')?.value ?? ''
+      'x-forwarded-for': ip
     };
 
     try {
@@ -148,8 +145,7 @@ const withCompleteGpay =
       logger.info('Redirecting to order success page', {
         middleware: 'complete-gpay',
         redirectUrlWithLocale,
-        ip,
-        setCookie: request.headers.get('set-cookie')
+        ip
       });
 
       // Using POST method while redirecting causes an error,

package/middlewares/complete-masterpass.ts

@@ -4,7 +4,6 @@ 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) {
@@ -35,7 +34,6 @@ 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);
@@ -47,9 +45,7 @@ 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,
-      'Accept-Language':
-        currentLocale ?? req.cookies.get('pz-locale')?.value ?? ''
+      'x-forwarded-for': ip
     };
 
     try {
@@ -149,8 +145,7 @@ const withCompleteMasterpass =
       logger.info('Redirecting to order success page', {
         middleware: 'complete-masterpass',
         redirectUrlWithLocale,
-        ip,
-        setCookie: request.headers.get('set-cookie')
+        ip
       });
 
       // Using POST method while redirecting causes an error,