@akinon/next 2.0.0-beta.2 → 2.0.0-beta.20

package/lib/cache.ts

@@ -1,8 +1,67 @@
 import { createPool, Pool } from 'generic-pool';
 import { RedisClientType } from 'redis';
 import Settings from 'settings';
-import { CacheOptions } from '../types';
+import { CacheOptions, SearchParams } from '../types';
 import logger from '../utils/log';
+const CACHE_VERSION = 'v2';
+
+const compressData = async (data: string): Promise<Uint8Array> => {
+  const stream = new CompressionStream('gzip');
+  const writer = stream.writable.getWriter();
+  const reader = stream.readable.getReader();
+
+  writer.write(new TextEncoder().encode(data));
+  writer.close();
+
+  const chunks: Uint8Array[] = [];
+  let done = false;
+
+  while (!done) {
+    const { value, done: readerDone } = await reader.read();
+    done = readerDone;
+    if (value) chunks.push(value);
+  }
+
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+
+  return result;
+};
+
+const decompressData = async (compressed: Uint8Array): Promise<string> => {
+  const stream = new DecompressionStream('gzip');
+  const writer = stream.writable.getWriter();
+  const reader = stream.readable.getReader();
+
+  writer.write(compressed as any);
+  writer.close();
+
+  const chunks: Uint8Array[] = [];
+  let done = false;
+
+  while (!done) {
+    const { value, done: readerDone } = await reader.read();
+    done = readerDone;
+    if (value) chunks.push(value);
+  }
+
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+
+  return new TextDecoder().decode(result);
+};
 
 const hashCacheKey = (object?: Record<string, string>) => {
   if (!object) {
@@ -19,34 +78,37 @@ const hashCacheKey = (object?: Record<string, string>) => {
   return `_${encodeURIComponent(cacheKey)}`;
 };
 export const CacheKey = {
-  List: (searchParams: URLSearchParams, headers?: Record<string, string>) =>
+  List: (searchParams: SearchParams, headers?: Record<string, string>) =>
     `list_${encodeURIComponent(JSON.stringify(searchParams))}${hashCacheKey(
       headers
     )}`,
   Category: (
     pk: number,
-    searchParams?: URLSearchParams,
+    searchParams?: SearchParams,
     headers?: Record<string, string>
   ) =>
     `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,
-    searchParams: URLSearchParams,
+    searchParams: SearchParams,
     headers?: Record<string, string>
   ) =>
     `special_page_${pk}_${encodeURIComponent(
       JSON.stringify(searchParams)
     )}${hashCacheKey(headers)}`,
-  Product: (pk: number, searchParams: URLSearchParams) =>
+  Product: (pk: number, searchParams: SearchParams) =>
     `product_${pk}_${encodeURIComponent(JSON.stringify(searchParams))}`,
-  GroupProduct: (pk: number, searchParams: URLSearchParams) =>
+  GroupProduct: (pk: number, searchParams: SearchParams) =>
     `group_product_${pk}_${encodeURIComponent(JSON.stringify(searchParams))}`,
   FlatPage: (pk: number) => `flat_page_${pk}`,
   LandingPage: (pk: number) => `landing_page_${pk}`,
   Widget: (slug: string) => `widget_${slug}`,
+  WidgetSchema: (widgetSlug: string) => `widget_schema_${widgetSlug}`,
   PrettyUrl: (pathname: string) => `pretty_url_${pathname}`,
   Menu: (depth: number, parent?: string) =>
     `menu_${depth}${parent ? `_${parent}` : ''}`,
@@ -58,8 +120,32 @@ export const CacheKey = {
 export class Cache {
   static PROXY_URL = `${process.env.NEXT_PUBLIC_URL}/api/cache`;
 
+  private static serializeValue(value: any): string {
+    return typeof value === 'object' ? JSON.stringify(value) : String(value);
+  }
+
+  private static validateKey(key: string): boolean {
+    return !(!key || key.trim() === '');
+  }
+
+  private static validateKeyValuePairs(keyValuePairs: Record<string, any>): {
+    isValid: boolean;
+    invalidKeys: string[];
+  } {
+    if (!keyValuePairs || Object.keys(keyValuePairs).length === 0) {
+      return { isValid: false, invalidKeys: [] };
+    }
+
+    const invalidKeys = Object.keys(keyValuePairs).filter(
+      (key) => !this.validateKey(key)
+    );
+    return { isValid: invalidKeys.length === 0, invalidKeys };
+  }
+
   static formatKey(key: string, locale: string) {
-    return encodeURIComponent(`${Settings.commerceUrl}_${locale}_${key}`);
+    return encodeURIComponent(
+      `${CACHE_VERSION}_${Settings.commerceUrl}_${locale}_${key}`
+    );
   }
 
   static clientPool: Pool<RedisClientType> = createPool(
@@ -70,9 +156,14 @@ export class Cache {
           process.env.CACHE_PORT
         }/${process.env.CACHE_BUCKET ?? '0'}`;
 
-        const client: RedisClientType = createClient({
-          url: redisUrl
-        });
+        const options = {
+          url: redisUrl,
+          ...(process.env.CACHE_PASSWORD && {
+            password: process.env.CACHE_PASSWORD
+          })
+        };
+
+        const client: RedisClientType = createClient(options);
 
         client.on('error', (error) => {
           logger.error('Redis client error', { redisUrl, error });
@@ -96,9 +187,9 @@ export class Cache {
     return await Cache.clientPool.acquire();
   }
 
-  static async get(key: string) {
-    let value;
-    let client;
+  static async get(key: string): Promise<any> {
+    let value: any;
+    let client: RedisClientType | undefined;
 
     try {
       client = await Cache.getClient();
@@ -108,9 +199,7 @@ export class Cache {
       } else {
         value = null;
       }
-      logger.debug('Redis get success', { key, value });
     } catch (error) {
-      logger.error('Redis get error', { key, error });
       value = null;
     } finally {
       if (client) {
@@ -121,14 +210,13 @@ export class Cache {
     return value;
   }
 
-  static async set(key: string, value: any, expire?: number) {
+  static async set(key: string, value: any, expire?: number): Promise<boolean> {
     let success = false;
-    let client;
+    let client: RedisClientType | undefined;
 
     try {
       client = await Cache.getClient();
-      const serializedValue =
-        typeof value === 'object' ? JSON.stringify(value) : value;
+      const serializedValue = Cache.serializeValue(value);
 
       if (expire) {
         await client.set(key, serializedValue, { EX: expire });
@@ -137,9 +225,7 @@ export class Cache {
       }
 
       success = true;
-      logger.debug('Redis set success', { key, value });
     } catch (error) {
-      logger.error('Redis set error', { key, error });
       success = false;
     } finally {
       if (client) {
@@ -156,10 +242,6 @@ export class Cache {
     handler: () => Promise<T>,
     options?: CacheOptions
   ): Promise<T> {
-    if (Settings.usePrettyUrlRoute) {
-      return await handler();
-    }
-
     const requiredVariables = [
       process.env.CACHE_HOST,
       process.env.CACHE_PORT,
@@ -172,27 +254,33 @@ export class Cache {
 
     const defaultOptions: CacheOptions = {
       cache: true,
-      expire: Settings.redis.defaultExpirationTime
+      expire: Settings.redis.defaultExpirationTime,
+      compressed: process.env.CACHE_COMPRESSION_ENABLED !== 'false'
     };
 
     const _options = Object.assign(defaultOptions, options);
     const formattedKey = Cache.formatKey(key, locale);
 
-    logger.debug('Cache wrap', { key, formattedKey, _options });
+    if (Settings.usePrettyUrlRoute) {
+      _options.expire = 120;
+    }
 
     if (_options.cache) {
-      let cachedValue;
+      let cachedValue: any;
 
       if (_options.useProxy) {
         const body = new URLSearchParams();
 
         body.append('key', formattedKey);
+        if (_options.compressed) {
+          body.append('compressed', 'true');
+        }
 
         cachedValue = await Cache.proxyRequest('POST', body);
-        logger.debug('Cache proxy request success', { key });
-        logger.trace('Cache proxy request', { key, cachedValue });
       } else {
-        cachedValue = await Cache.get(formattedKey);
+        cachedValue = _options.compressed
+          ? await Cache.getCompressed(formattedKey)
+          : await Cache.get(formattedKey);
       }
 
       if (cachedValue) {
@@ -200,8 +288,6 @@ export class Cache {
       }
     }
 
-    logger.debug('Redis cache miss. Setting new value...', { key });
-
     const data = await handler();
 
     if (data && _options.cache) {
@@ -215,14 +301,19 @@ export class Cache {
             'expire',
             String(_options?.expire ?? Settings.redis.defaultExpirationTime)
           );
+          if (_options.compressed) {
+            body.append('compressed', 'true');
+          }
           await Cache.proxyRequest('PUT', body);
-
-          logger.debug('Cache proxy request', { key, body: body.toString() });
         } catch (error) {
           logger.error('Cache proxy error', error);
         }
       } else {
-        await Cache.set(formattedKey, JSON.stringify(data), _options?.expire);
+        if (_options.compressed) {
+          await Cache.setCompressed(formattedKey, data, _options?.expire);
+        } else {
+          await Cache.set(formattedKey, JSON.stringify(data), _options?.expire);
+        }
       }
     }
 
@@ -234,7 +325,7 @@ export class Cache {
       await fetch(Cache.PROXY_URL, {
         method,
         headers: {
-          authorization: process.env.CACHE_SECRET
+          authorization: process.env.CACHE_SECRET || ''
         },
         body
       })
@@ -242,4 +333,148 @@ export class Cache {
 
     return response;
   }
+
+  static async mset(
+    keyValuePairs: Record<string, any>,
+    expire?: number
+  ): Promise<boolean> {
+    const validation = Cache.validateKeyValuePairs(keyValuePairs);
+    if (!validation.isValid) {
+      if (validation.invalidKeys.length > 0) {
+        logger.error('Invalid keys in mset', {
+          invalidKeys: validation.invalidKeys
+        });
+      } else {
+        logger.warn('mset called with empty keyValuePairs');
+      }
+      return false;
+    }
+
+    let success = false;
+    let client: RedisClientType | undefined;
+
+    try {
+      client = await Cache.getClient();
+      const pipeline = client.multi();
+
+      Object.entries(keyValuePairs).forEach(([key, value]) => {
+        const serializedValue = Cache.serializeValue(value);
+        if (expire) {
+          pipeline.set(key, serializedValue, { EX: expire });
+        } else {
+          pipeline.set(key, serializedValue);
+        }
+      });
+
+      const results = await pipeline.exec();
+
+      const failures =
+        results?.filter((result) => result instanceof Error) || [];
+
+      if (failures.length > 0) {
+        success = false;
+      } else {
+        success = true;
+      }
+    } catch (error) {
+      success = false;
+    } finally {
+      if (client) {
+        await Cache.clientPool.release(client);
+      }
+    }
+
+    return success;
+  }
+
+  static async setCompressed(
+    key: string,
+    value: any,
+    expire?: number
+  ): Promise<boolean> {
+    if (!Cache.validateKey(key)) {
+      return false;
+    }
+
+    let success = false;
+    let client: RedisClientType | undefined;
+
+    try {
+      client = await Cache.getClient();
+      const serializedValue = Cache.serializeValue(value);
+
+      try {
+        const compressed = await compressData(serializedValue);
+        const compressedBase64 = Buffer.from(compressed).toString('base64');
+
+        if (expire) {
+          await client.set(key, compressedBase64, { EX: expire });
+        } else {
+          await client.set(key, compressedBase64);
+        }
+
+        success = true;
+      } catch (compressionError) {
+        if (expire) {
+          await client.set(key, serializedValue, { EX: expire });
+        } else {
+          await client.set(key, serializedValue);
+        }
+
+        success = true;
+      }
+    } catch (error) {
+      success = false;
+    } finally {
+      if (client) {
+        await Cache.clientPool.release(client);
+      }
+    }
+
+    return success;
+  }
+
+  static async getCompressed(key: string): Promise<unknown> {
+    if (!Cache.validateKey(key)) {
+      return null;
+    }
+
+    let value: unknown;
+    let client: RedisClientType | undefined;
+
+    try {
+      client = await Cache.getClient();
+      const compressed = await client.get(key);
+
+      if (compressed) {
+        const compressedBuffer = Buffer.from(compressed, 'base64');
+
+        try {
+          const decompressedString = await decompressData(
+            new Uint8Array(compressedBuffer)
+          );
+          value = JSON.parse(decompressedString);
+          return value;
+        } catch (decompressionError) {
+          try {
+            const rawString = compressed;
+            const parsedData = JSON.parse(rawString);
+            return parsedData;
+          } catch (jsonError) {
+            return null;
+          }
+        }
+      } else {
+        value = null;
+      }
+    } catch (error) {
+      value = null;
+    } finally {
+      if (client) {
+        await Cache.clientPool.release(client);
+      }
+    }
+
+    return value;
+  }
 }

package/localization/index.ts

@@ -1,5 +1,6 @@
 export enum LocaleUrlStrategy {
   HideAllLocales = 'hide-all-locales',
   HideDefaultLocale = 'hide-default-locale',
-  ShowAllLocales = 'show-all-locales'
+  ShowAllLocales = 'show-all-locales',
+  Subdomain = 'subdomain'
 }

package/localization/provider.tsx

@@ -2,7 +2,7 @@
 
 import React, { createContext } from 'react';
 import { getTranslateFn } from '../utils';
-import { useParams } from 'next/navigation';
+import { usePzParams } from '../hooks/use-pz-params';
 import { Currency, Locale } from '../types';
 import settings from 'settings';
 
@@ -34,10 +34,7 @@ export default function LocalizationProvider({
     localeUrlStrategy
   } = settings.localization;
 
-  const { locale, currency } = useParams() as {
-    locale: string;
-    currency: string;
-  };
+  const { locale, currency } = usePzParams();
 
   return (
     <LocalizationContext.Provider

package/middlewares/bfcache-headers.ts

@@ -0,0 +1,18 @@
+import { NextMiddleware } from 'next/server';
+
+const withBfcacheHeaders = (middleware: NextMiddleware): NextMiddleware => {
+  return async (req, event) => {
+    const response = await middleware(req, event);
+
+    if (process.env.BF_CACHE === 'true' && response) {
+      response.headers.set(
+        'Cache-Control',
+        'private, no-cache, max-age=0, must-revalidate'
+      );
+    }
+
+    return response;
+  };
+};
+
+export default withBfcacheHeaders;

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

@@ -4,6 +4,7 @@ import { Buffer } from 'buffer';
 import logger from '../utils/log';
 import { getUrlPathWithLocale } from '../utils/localization';
 import { PzNextRequest } from '.';
+import { getCheckoutPath } from '../utils';
 
 const streamToString = async (stream: ReadableStream<Uint8Array> | null) => {
   if (stream) {
@@ -34,18 +35,22 @@ 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);
     }
 
-    const requestUrl = `${Settings.commerceUrl}/orders/checkout/${url.search}`;
+    const isPostCheckout = req.cookies.get('pz-post-checkout-flow')?.value === 'true';
+    const requestUrl = `${Settings.commerceUrl}${getCheckoutPath(isPostCheckout)}${url.search}`;
     const requestHeaders = {
       'X-Requested-With': 'XMLHttpRequest',
       '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 {
@@ -59,17 +64,9 @@ const withCompleteGpay =
             ip
           }
         );
-
-        return NextResponse.redirect(
-          `${url.origin}${getUrlPathWithLocale(
-            '/orders/checkout/',
-            req.cookies.get('pz-locale')?.value
-          )}`,
-          303
-        );
       }
 
-      const request = await fetch(requestUrl, {
+      const fetchResponse = await fetch(requestUrl, {
         method: 'POST',
         headers: requestHeaders,
         body
@@ -77,14 +74,14 @@ const withCompleteGpay =
 
       logger.info('Complete GPay payment request', {
         requestUrl,
-        status: request.status,
+        status: fetchResponse.status,
         requestHeaders,
         ip
       });
 
-      const response = await request.json();
+      const responseData = await fetchResponse.json();
 
-      const { context_list: contextList, errors } = response;
+      const { context_list: contextList, errors } = responseData;
       const redirectionContext = contextList?.find(
         (context) => context.page_context?.redirect_url
       );
@@ -98,18 +95,26 @@ const withCompleteGpay =
           ip
         });
 
-        return NextResponse.redirect(
+        const errorResponse = NextResponse.redirect(
           `${url.origin}${getUrlPathWithLocale(
             '/orders/checkout/',
             req.cookies.get('pz-locale')?.value
           )}`,
-          {
-            status: 303,
-            headers: {
-              'Set-Cookie': `pz-pos-error=${JSON.stringify(errors)}; path=/;`
-            }
-          }
+          303
         );
+
+        // Forward set-cookie headers from the upstream response
+        const setCookies = fetchResponse.headers.getSetCookie?.() ?? [];
+        setCookies.forEach((cookie) => {
+          errorResponse.headers.append('Set-Cookie', cookie);
+        });
+
+        // Add error cookie
+        errorResponse.cookies.set('pz-pos-error', JSON.stringify(errors), {
+          path: '/'
+        });
+
+        return errorResponse;
       }
 
       logger.info('Order success page context list', {
@@ -124,7 +129,7 @@ const withCompleteGpay =
           {
             middleware: 'complete-gpay',
             requestHeaders,
-            response: JSON.stringify(response),
+            response: JSON.stringify(responseData),
             ip
           }
         );
@@ -152,10 +157,11 @@ const withCompleteGpay =
       // So we use 303 status code to change the method to GET
       const nextResponse = NextResponse.redirect(redirectUrlWithLocale, 303);
 
-      nextResponse.headers.set(
-        'Set-Cookie',
-        request.headers.get('set-cookie') ?? ''
-      );
+      // Forward all set-cookie headers from the upstream response
+      const setCookies = fetchResponse.headers.getSetCookie?.() ?? [];
+      setCookies.forEach((cookie) => {
+        nextResponse.headers.append('Set-Cookie', cookie);
+      });
 
       return nextResponse;
     } catch (error) {