@akinon/next 2.0.32-rc.0 → 2.0.33-beta.0

package/middlewares/default.ts

@@ -18,11 +18,7 @@ import {
   withBfcacheHeaders
 } from '.';
 import { getCsrfCookieFlags, urlLocaleMatcherRegex } from '../utils';
-import {
-  getPzSegmentsConfig,
-  encodePzValue,
-  isLegacyMode
-} from '../utils/pz-segments';
+import { getPzSegmentsConfig, encodePzValue, isLegacyMode } from '../utils/pz-segments';
 import withCurrency from './currency';
 import withLocale from './locale';
 import logger from '../utils/log';
@@ -106,9 +102,79 @@ const withPzDefault =
       }
     }
 
+    if (req.nextUrl.pathname.includes('/orders/checkout-with-token/')) {
+      const queryString = searchParams.toString();
+      const currency = searchParams.get('currency')?.toLowerCase();
+      const commercePath = req.nextUrl.pathname.replace(
+        urlLocaleMatcherRegex,
+        ''
+      );
+      const targetUrl = `${Settings.commerceUrl}${commercePath}${
+        queryString ? `?${queryString}` : ''
+      }`;
+
+      try {
+        const commerceResponse = await fetch(targetUrl, {
+          redirect: 'manual',
+          headers: {
+            cookie: req.headers.get('cookie') || ''
+          }
+        });
+
+        const location = commerceResponse.headers.get('location');
+
+        if (location) {
+          const locationUrl = new URL(location, Settings.commerceUrl);
+          locationUrl.searchParams.set('source', 'instore');
+          const redirectTarget = `${req.nextUrl.origin}${locationUrl.pathname}${locationUrl.search}`;
+          const response = NextResponse.redirect(redirectTarget);
+
+          // Set pz-currency FIRST via cookies API — NextResponse.cookies.set()
+          // overwrites manually appended Set-Cookie headers, so it must run
+          // before headers.append('Set-Cookie', ...) calls.
+          if (currency) {
+            response.cookies.set('pz-currency', currency, {
+              sameSite: 'none',
+              secure: true,
+              expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7)
+            });
+          }
+
+          // Forward set-cookie headers from the upstream response
+          const setCookies =
+            commerceResponse.headers.getSetCookie?.() ?? [];
+          setCookies.forEach((cookie) => {
+            response.headers.append('Set-Cookie', cookie);
+          });
+
+          return response;
+        }
+
+        logger.warn('checkout-with-token: no redirect from commerce', {
+          ip,
+          url: targetUrl
+        });
+      } catch {
+        logger.warn(
+          'checkout-with-token: fetch failed, falling back to rewrite',
+          { ip, url: targetUrl }
+        );
+      }
+      const response = NextResponse.rewrite(new URL(targetUrl));
+
+      if (currency) {
+        response.cookies.set('pz-currency', currency, {
+          sameSite: 'none',
+          secure: true,
+          expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7)
+        });
+      }
+
+      return response;
+    }
+
     if (
       req.nextUrl.pathname.includes('/orders/hooks/') ||
-      req.nextUrl.pathname.includes('/orders/checkout-with-token/') ||
       req.nextUrl.pathname.includes('/orders/post-checkout-redirect/') ||
       req.nextUrl.pathname.includes('/hooks/cash_register/complete/') ||
       req.nextUrl.pathname.includes('/hooks/cash_register/pre_order/')
@@ -266,98 +332,98 @@ const withPzDefault =
                                     req: PzNextRequest,
                                     event: NextFetchEvent
                                   ) => {
-                                    let middlewareResult: NextResponse | void =
-                                      NextResponse.next();
-
-                                    try {
-                                      const { locale, prettyUrl, currency } =
-                                        req.middlewareParams.rewrites;
-                                      const { defaultLocaleValue } =
-                                        Settings.localization;
-                                      const url = req.nextUrl.clone();
-                                      const pathnameWithoutLocale =
-                                        url.pathname.replace(
-                                          urlLocaleMatcherRegex,
-                                          ''
-                                        );
-
-                                      middlewareResult = (await middleware(
-                                        req,
-                                        event
-                                      )) as NextResponse | void;
-
-                                      let customRewriteUrlDiff = '';
+                                  let middlewareResult: NextResponse | void =
+                                    NextResponse.next();
+
+                                  try {
+                                    const { locale, prettyUrl, currency } =
+                                      req.middlewareParams.rewrites;
+                                    const { defaultLocaleValue } =
+                                      Settings.localization;
+                                    const url = req.nextUrl.clone();
+                                    const pathnameWithoutLocale =
+                                      url.pathname.replace(
+                                        urlLocaleMatcherRegex,
+                                        ''
+                                      );
 
-                                      if (
-                                        middlewareResult instanceof
-                                          NextResponse &&
-                                        middlewareResult.headers.get(
-                                          'pz-override-response'
-                                        ) &&
+                                    middlewareResult = (await middleware(
+                                      req,
+                                      event
+                                    )) as NextResponse | void;
+
+                                    let customRewriteUrlDiff = '';
+
+                                    if (
+                                      middlewareResult instanceof
+                                        NextResponse &&
+                                      middlewareResult.headers.get(
+                                        'pz-override-response'
+                                      ) &&
+                                      middlewareResult.headers.get(
+                                        'x-middleware-rewrite'
+                                      )
+                                    ) {
+                                      const rewriteUrl = new URL(
                                         middlewareResult.headers.get(
                                           'x-middleware-rewrite'
                                         )
-                                      ) {
-                                        const rewriteUrl = new URL(
-                                          middlewareResult.headers.get(
-                                            'x-middleware-rewrite'
-                                          )
+                                      );
+                                      const originalUrl = new URL(req.url);
+                                      customRewriteUrlDiff =
+                                        rewriteUrl.pathname.replace(
+                                          originalUrl.pathname,
+                                          ''
                                         );
-                                        const originalUrl = new URL(req.url);
-                                        customRewriteUrlDiff =
-                                          rewriteUrl.pathname.replace(
-                                            originalUrl.pathname,
-                                            ''
-                                          );
-                                      }
+                                    }
 
-                                      let ordersPrefix: string;
+                                    let ordersPrefix: string;
 
-                                      if (isLegacyMode(Settings)) {
-                                        url.basePath = `/${commerceUrl}`;
-                                        url.pathname = `/${
-                                          locale.length ? `${locale}/` : ''
-                                        }${currency}/${customRewriteUrlDiff}${
+                                    if (isLegacyMode(Settings)) {
+                                      url.basePath = `/${commerceUrl}`;
+                                      url.pathname =
+                                        `/${locale.length ? `${locale}/` : ''}${currency}/${customRewriteUrlDiff}${
                                           prettyUrl ?? pathnameWithoutLocale
                                         }`.replace(/\/+/g, '/');
-                                        ordersPrefix = `/${currency}/orders`;
-                                      } else {
-                                        const pzConfig =
-                                          getPzSegmentsConfig(Settings);
-                                        const fullUrlPath =
-                                          `${customRewriteUrlDiff}${
-                                            prettyUrl ?? pathnameWithoutLocale
-                                          }`.replace(/\/+/g, '/');
-                                        const fullUrl = `${req.nextUrl.origin}${fullUrlPath}`;
-                                        const resolvedLocale =
-                                          locale?.length > 0
-                                            ? locale
-                                            : Settings.localization
-                                                .defaultLocaleValue;
-                                        const resolveContext = {
-                                          req,
-                                          event,
-                                          url,
-                                          locale: resolvedLocale,
-                                          currency,
-                                          pathname: pathnameWithoutLocale
-                                        };
-                                        const customSegments =
-                                          pzConfig.segments.filter(
-                                            (seg) =>
-                                              seg.name !== 'locale' &&
-                                              seg.name !== 'currency' &&
-                                              seg.name !== 'url'
-                                          );
-                                        const segmentValues: Record<
-                                          string,
-                                          string
-                                        > = {
-                                          locale: resolvedLocale,
-                                          currency,
-                                          url: encodeURIComponent(fullUrl),
-                                          ...Object.fromEntries(
-                                            customSegments.map((seg) => [
+                                      ordersPrefix = `/${currency}/orders`;
+                                    } else {
+                                      const pzConfig =
+                                        getPzSegmentsConfig(Settings);
+                                      const fullUrlPath =
+                                        `${customRewriteUrlDiff}${
+                                          prettyUrl ?? pathnameWithoutLocale
+                                        }`.replace(/\/+/g, '/');
+                                      const fullUrl = `${req.nextUrl.origin}${fullUrlPath}`;
+                                      const resolvedLocale =
+                                        locale?.length > 0
+                                          ? locale
+                                          : Settings.localization
+                                              .defaultLocaleValue;
+                                      const resolveContext = {
+                                        req,
+                                        event,
+                                        url,
+                                        locale: resolvedLocale,
+                                        currency,
+                                        pathname: pathnameWithoutLocale
+                                      };
+                                      const customSegments = pzConfig.segments
+                                        .filter(
+                                          (seg) =>
+                                            seg.name !== 'locale' &&
+                                            seg.name !== 'currency' &&
+                                            seg.name !== 'url'
+                                        );
+                                      const segmentValues: Record<
+                                        string,
+                                        string
+                                      > = {
+                                        locale: resolvedLocale,
+                                        currency,
+                                        url: encodeURIComponent(fullUrl),
+                                        ...Object.fromEntries(
+                                          customSegments
+                                            .map((seg) => [
                                               seg.name,
                                               req.middlewareParams.rewrites[
                                                 seg.name
@@ -366,121 +432,105 @@ const withPzDefault =
                                                   ? seg.resolve(resolveContext)
                                                   : '')
                                             ])
-                                          )
-                                        };
+                                        )
+                                      };
 
-                                        const pzValue = encodePzValue(
-                                          segmentValues,
-                                          pzConfig
+                                      const pzValue = encodePzValue(
+                                        segmentValues,
+                                        pzConfig
+                                      );
+
+                                      url.pathname =
+                                        `/${pzValue}/${fullUrlPath}`.replace(
+                                          /\/+/g,
+                                          '/'
                                         );
+                                      ordersPrefix = `/${pzValue}/orders`;
+                                    }
 
-                                        url.pathname =
-                                          `/${pzValue}/${fullUrlPath}`.replace(
-                                            /\/+/g,
-                                            '/'
-                                          );
-                                        ordersPrefix = `/${pzValue}/orders`;
-                                      }
+                                    if (
+                                      Settings.usePrettyUrlRoute &&
+                                      url.searchParams.toString().length > 0 &&
+                                      !Object.entries(ROUTES).find(
+                                        ([, value]) =>
+                                          new RegExp(`^${value}/?$`).test(
+                                            pathnameWithoutLocale
+                                          )
+                                      )
+                                    ) {
+                                      url.pathname =
+                                        url.pathname +
+                                        (/\/$/.test(url.pathname) ? '' : '/') +
+                                        `searchparams|${encodeURIComponent(
+                                          url.searchParams.toString()
+                                        )}`;
+                                    }
+
+                                    Settings.rewrites.forEach((rewrite) => {
+                                      url.pathname = url.pathname.replace(
+                                        rewrite.source,
+                                        rewrite.destination
+                                      );
+                                    });
 
+                                    // if middleware.ts has a return value for current url
+                                    if (
+                                      middlewareResult instanceof NextResponse
+                                    ) {
+                                      // pz-override-response header is used to prevent 404 page for custom responses.
                                       if (
-                                        Settings.usePrettyUrlRoute &&
-                                        url.searchParams.toString().length >
-                                          0 &&
-                                        !Object.entries(ROUTES).find(
-                                          ([, value]) =>
-                                            new RegExp(`^${value}/?$`).test(
-                                              pathnameWithoutLocale
-                                            )
-                                        )
+                                        middlewareResult.headers.get(
+                                          'pz-override-response'
+                                        ) !== 'true'
                                       ) {
-                                        url.pathname =
-                                          url.pathname +
-                                          (/\/$/.test(url.pathname)
-                                            ? ''
-                                            : '/') +
-                                          `searchparams|${encodeURIComponent(
-                                            url.searchParams.toString()
-                                          )}`;
-                                      }
-
-                                      Settings.rewrites.forEach((rewrite) => {
-                                        url.pathname = url.pathname.replace(
-                                          rewrite.source,
-                                          rewrite.destination
+                                        middlewareResult.headers.set(
+                                          'x-middleware-rewrite',
+                                          url.href
                                         );
-                                      });
-
-                                      // if middleware.ts has a return value for current url
-                                      if (
-                                        middlewareResult instanceof NextResponse
+                                      } else if (
+                                        middlewareResult.headers.get(
+                                          'x-middleware-rewrite'
+                                        ) &&
+                                        middlewareResult.headers.get(
+                                          'pz-override-response'
+                                        ) === 'true'
                                       ) {
-                                        // pz-override-response header is used to prevent 404 page for custom responses.
-                                        if (
-                                          middlewareResult.headers.get(
-                                            'pz-override-response'
-                                          ) !== 'true'
-                                        ) {
-                                          middlewareResult.headers.set(
-                                            'x-middleware-rewrite',
-                                            url.href
-                                          );
-                                        } else if (
-                                          middlewareResult.headers.get(
-                                            'x-middleware-rewrite'
-                                          ) &&
-                                          middlewareResult.headers.get(
-                                            'pz-override-response'
-                                          ) === 'true'
-                                        ) {
-                                          middlewareResult =
-                                            NextResponse.rewrite(url);
-                                        }
-                                      } else {
-                                        // if middleware.ts doesn't have a return value.
-                                        // e.g. NextResponse.next() doesn't exist in middleware.ts
-
                                         middlewareResult =
                                           NextResponse.rewrite(url);
                                       }
+                                    } else {
+                                      // if middleware.ts doesn't have a return value.
+                                      // e.g. NextResponse.next() doesn't exist in middleware.ts
 
-                                      const { localeUrlStrategy } =
-                                        Settings.localization;
-
-                                      const fallbackHost =
-                                        req.headers.get('x-forwarded-host') ||
-                                        req.headers.get('host');
-                                      const hostname =
-                                        process.env.NEXT_PUBLIC_URL ||
-                                        `https://${fallbackHost}`;
-                                      const rootHostname =
-                                        localeUrlStrategy ===
-                                        LocaleUrlStrategy.Subdomain
-                                          ? getRootHostname(hostname)
-                                          : null;
-
-                                      if (
-                                        !url.pathname.startsWith(ordersPrefix)
-                                      ) {
-                                        middlewareResult.cookies.set(
-                                          'pz-locale',
-                                          locale?.length > 0
-                                            ? locale
-                                            : defaultLocaleValue,
-                                          {
-                                            domain: rootHostname,
-                                            sameSite: 'none',
-                                            secure: true,
-                                            expires: new Date(
-                                              Date.now() +
-                                                1000 * 60 * 60 * 24 * 7
-                                            ) // 7 days
-                                          }
-                                        );
-                                      }
+                                      middlewareResult =
+                                        NextResponse.rewrite(url);
+                                    }
 
+                                    const { localeUrlStrategy } =
+                                      Settings.localization;
+
+                                    const fallbackHost =
+                                      req.headers.get('x-forwarded-host') ||
+                                      req.headers.get('host');
+                                    const hostname =
+                                      process.env.NEXT_PUBLIC_URL ||
+                                      `https://${fallbackHost}`;
+                                    const rootHostname =
+                                      localeUrlStrategy ===
+                                      LocaleUrlStrategy.Subdomain
+                                        ? getRootHostname(hostname)
+                                        : null;
+
+                                    if (
+                                      !url.pathname.startsWith(
+                                        ordersPrefix
+                                      )
+                                    ) {
                                       middlewareResult.cookies.set(
-                                        'pz-currency',
-                                        currency,
+                                        'pz-locale',
+                                        locale?.length > 0
+                                          ? locale
+                                          : defaultLocaleValue,
                                         {
                                           domain: rootHostname,
                                           sameSite: 'none',
@@ -490,89 +540,102 @@ const withPzDefault =
                                           ) // 7 days
                                         }
                                       );
+                                    }
 
-                                      if (
-                                        req.cookies.get('pz-locale') &&
-                                        req.cookies.get('pz-locale').value !==
-                                          locale
-                                      ) {
-                                        logger.debug('Locale changed', {
-                                          locale,
-                                          oldLocale:
-                                            req.cookies.get('pz-locale')?.value,
-                                          ip
-                                        });
+                                    middlewareResult.cookies.set(
+                                      'pz-currency',
+                                      currency,
+                                      {
+                                        domain: rootHostname,
+                                        sameSite: 'none',
+                                        secure: true,
+                                        expires: new Date(
+                                          Date.now() + 1000 * 60 * 60 * 24 * 7
+                                        ) // 7 days
                                       }
+                                    );
+
+                                    if (
+                                      req.cookies.get('pz-locale') &&
+                                      req.cookies.get('pz-locale').value !==
+                                        locale
+                                    ) {
+                                      logger.debug('Locale changed', {
+                                        locale,
+                                        oldLocale:
+                                          req.cookies.get('pz-locale')?.value,
+                                        ip
+                                      });
+                                    }
 
-                                      middlewareResult.headers.set(
-                                        'pz-url',
-                                        req.nextUrl.toString()
+                                    middlewareResult.headers.set(
+                                      'pz-url',
+                                      req.nextUrl.toString()
+                                    );
+
+                                    if (req.cookies.get('pz-set-currency')) {
+                                      middlewareResult.cookies.delete(
+                                        'pz-set-currency'
                                       );
+                                    }
 
-                                      if (req.cookies.get('pz-set-currency')) {
+                                    if (
+                                      req.cookies.get('pz-post-checkout-flow')
+                                    ) {
+                                      if (
+                                        pathnameWithoutLocale.startsWith(
+                                          '/orders/completed/'
+                                        ) ||
+                                        pathnameWithoutLocale.startsWith(
+                                          '/basket'
+                                        )
+                                      ) {
                                         middlewareResult.cookies.delete(
-                                          'pz-set-currency'
+                                          'pz-post-checkout-flow'
                                         );
                                       }
+                                    }
 
-                                      if (
-                                        req.cookies.get('pz-post-checkout-flow')
-                                      ) {
-                                        if (
-                                          pathnameWithoutLocale.startsWith(
-                                            '/orders/completed/'
-                                          ) ||
-                                          pathnameWithoutLocale.startsWith(
-                                            '/basket'
-                                          )
-                                        ) {
-                                          middlewareResult.cookies.delete(
-                                            'pz-post-checkout-flow'
-                                          );
-                                        }
-                                      }
+                                    if (process.env.ACC_APP_VERSION) {
+                                      middlewareResult.headers.set(
+                                        'acc-app-version',
+                                        process.env.ACC_APP_VERSION
+                                      );
+                                    }
 
-                                      if (process.env.ACC_APP_VERSION) {
-                                        middlewareResult.headers.set(
-                                          'acc-app-version',
-                                          process.env.ACC_APP_VERSION
-                                        );
-                                      }
+                                    // Set CSRF token if not set
+                                    try {
+                                      const url = `${Settings.commerceUrl}${user.csrfToken}`;
 
-                                      // Set CSRF token if not set
-                                      try {
-                                        const url = `${Settings.commerceUrl}${user.csrfToken}`;
-
-                                        if (!req.cookies.get('csrftoken')) {
-                                          const { csrf_token } = await (
-                                            await fetch(url)
-                                          ).json();
-                                          middlewareResult.cookies.set(
-                                            'csrftoken',
-                                            csrf_token,
-                                            {
-                                              path: '/',
-                                              domain: rootHostname,
-                                              ...getCsrfCookieFlags()
-                                            }
-                                          );
-                                        }
-                                      } catch (error) {
-                                        logger.error('CSRF Error', {
-                                          error,
-                                          ip
-                                        });
+                                      if (!req.cookies.get('csrftoken')) {
+                                        const { csrf_token } = await (
+                                          await fetch(url)
+                                        ).json();
+                                        middlewareResult.cookies.set(
+                                          'csrftoken',
+                                          csrf_token,
+                                          {
+                                            path: '/',
+                                            domain: rootHostname,
+                                            ...getCsrfCookieFlags()
+                                          }
+                                        );
                                       }
                                     } catch (error) {
-                                      logger.error('withPzDefault Error', {
+                                      logger.error('CSRF Error', {
                                         error,
                                         ip
                                       });
                                     }
-
-                                    return middlewareResult;
+                                  } catch (error) {
+                                    logger.error('withPzDefault Error', {
+                                      error,
+                                      ip
+                                    });
                                   }
-                                )
+
+                                  return middlewareResult;
+                                })
                               )
                             )
                           )