@akinon/next 2.0.0-beta.9 → 2.0.0

package/middlewares/default.ts

@@ -11,14 +11,23 @@ import {
   withRedirectionPayment,
   withSavedCardRedirection,
   withThreeDRedirection,
-  withUrlRedirection
+  withUrlRedirection,
+  withCompleteWallet,
+  withWalletCompleteRedirection,
+  withMasterpassRestCallback,
+  withBfcacheHeaders
 } from '.';
 import { urlLocaleMatcherRegex } from '../utils';
+import { getPzSegmentsConfig, encodePzValue, isLegacyMode } from '../utils/pz-segments';
 import withCurrency from './currency';
 import withLocale from './locale';
 import logger from '../utils/log';
 import { user } from '../data/urls';
 import { getUrlPathWithLocale } from '../utils/localization';
+import getRootHostname from '../utils/get-root-hostname';
+import { LocaleUrlStrategy } from '../localization';
+
+const POST_CHECKOUT_COOKIE_MAX_AGE_MS = 1000 * 60 * 30; // 30 minutes
 
 const withPzDefault =
   (middleware: NextMiddleware) =>
@@ -96,6 +105,7 @@ const withPzDefault =
     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/')
     ) {
@@ -123,8 +133,13 @@ const withPzDefault =
     }
 
     if (req.nextUrl.pathname.startsWith('/orders/redirection/')) {
+      const queryString = searchParams.toString();
       return NextResponse.rewrite(
-        new URL(`${encodeURI(Settings.commerceUrl)}/orders/redirection/`)
+        new URL(
+          `${encodeURI(Settings.commerceUrl)}/orders/redirection/${
+            queryString ? `?${queryString}` : ''
+          }`
+        )
       );
     }
 
@@ -142,21 +157,35 @@ const withPzDefault =
       );
     }
 
-    // If commerce redirects to /orders/checkout/ without locale
+    // If commerce redirects to /orders/checkout/ or /orders/post-checkout/ without locale
+    const isPostCheckout = !!req.nextUrl.pathname.match(
+      new RegExp('^/orders/post-checkout/$')
+    );
+    const checkoutLocalePath = getUrlPathWithLocale(
+      '/orders/checkout/',
+      req.cookies.get('pz-locale')?.value
+    );
     if (
-      req.nextUrl.pathname.match(new RegExp('^/orders/checkout/$')) &&
-      req.nextUrl.searchParams.size === 0 &&
-      getUrlPathWithLocale(
-        '/orders/checkout/',
-        req.cookies.get('pz-locale')?.value
-      ) !== req.nextUrl.pathname
+      (isPostCheckout && req.nextUrl.searchParams.size === 0) ||
+      (req.nextUrl.pathname.match(new RegExp('^/orders/checkout/$')) &&
+        req.nextUrl.searchParams.size === 0 &&
+        checkoutLocalePath !== req.nextUrl.pathname)
     ) {
-      const redirectUrlWithLocale = `${url.origin}${getUrlPathWithLocale(
-        '/orders/checkout/',
-        req.cookies.get('pz-locale')?.value
-      )}`;
+      const response = NextResponse.redirect(
+        `${url.origin}${checkoutLocalePath}`,
+        303
+      );
+
+      if (isPostCheckout) {
+        response.cookies.set('pz-post-checkout-flow', 'true', {
+          path: '/',
+          sameSite: 'none',
+          secure: true,
+          expires: new Date(Date.now() + POST_CHECKOUT_COOKIE_MAX_AGE_MS)
+        });
+      }
 
-      return NextResponse.redirect(redirectUrlWithLocale, 303);
+      return response;
     }
 
     // Dynamically handle any payment gateway without specifying names
@@ -211,7 +240,6 @@ const withPzDefault =
 
     req.middlewareParams = {
       commerceUrl,
-      found: true,
       rewrites: {}
     };
 
@@ -226,195 +254,321 @@ const withPzDefault =
                     withCompleteGpay(
                       withCompleteMasterpass(
                         withSavedCardRedirection(
-                          async (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 = '';
-
-                              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 originalUrl = new URL(req.url);
-                                customRewriteUrlDiff =
-                                  rewriteUrl.pathname.replace(
-                                    originalUrl.pathname,
-                                    ''
-                                  );
-                              }
-
-                              url.basePath = `/${commerceUrl}`;
-                              url.pathname = `/${
-                                locale.length ? `${locale}/` : ''
-                              }${currency}/${customRewriteUrlDiff}${
-                                prettyUrl ?? pathnameWithoutLocale
-                              }`.replace(/\/+/g, '/');
-
-                              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 (
-                                  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);
-                              }
-
-                              if (
-                                !url.pathname.startsWith(`/${currency}/orders`)
-                              ) {
-                                middlewareResult.cookies.set(
-                                  'pz-locale',
-                                  locale?.length > 0
-                                    ? locale
-                                    : defaultLocaleValue,
-                                  {
-                                    sameSite: 'none',
-                                    secure: true,
-                                    expires: new Date(
-                                      Date.now() + 1000 * 60 * 60 * 24 * 7
-                                    ) // 7 days
+                          withCompleteWallet(
+                            withWalletCompleteRedirection(
+                              withMasterpassRestCallback(
+                                withBfcacheHeaders(
+                                  async (
+                                    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 = '';
+
+                                    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 originalUrl = new URL(req.url);
+                                      customRewriteUrlDiff =
+                                        rewriteUrl.pathname.replace(
+                                          originalUrl.pathname,
+                                          ''
+                                        );
+                                    }
+
+                                    let ordersPrefix: string;
+
+                                    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) => [
+                                              seg.name,
+                                              req.middlewareParams.rewrites[
+                                                seg.name
+                                              ] ??
+                                                (seg.resolve
+                                                  ? seg.resolve(resolveContext)
+                                                  : '')
+                                            ])
+                                        )
+                                      };
+
+                                      const pzValue = encodePzValue(
+                                        segmentValues,
+                                        pzConfig
+                                      );
+
+                                      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 (
+                                        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);
+                                    }
+
+                                    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.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()
+                                    );
+
+                                    if (req.cookies.get('pz-set-currency')) {
+                                      middlewareResult.cookies.delete(
+                                        'pz-set-currency'
+                                      );
+                                    }
+
+                                    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
+                                      );
+                                    }
+
+                                    // 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,
+                                          {
+                                            domain: rootHostname
+                                          }
+                                        );
+                                      }
+                                    } catch (error) {
+                                      logger.error('CSRF Error', {
+                                        error,
+                                        ip
+                                      });
+                                    }
+                                  } catch (error) {
+                                    logger.error('withPzDefault Error', {
+                                      error,
+                                      ip
+                                    });
                                   }
-                                );
-                              }
-                              middlewareResult.cookies.set(
-                                'pz-currency',
-                                currency,
-                                {
-                                  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()
-                              );
-
-                              if (req.cookies.get('pz-set-currency')) {
-                                middlewareResult.cookies.delete(
-                                  'pz-set-currency'
-                                );
-                              }
-
-                              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}`;
-
-                                if (!req.cookies.get('csrftoken')) {
-                                  const { csrf_token } = await (
-                                    await fetch(url)
-                                  ).json();
-                                  middlewareResult.cookies.set(
-                                    'csrftoken',
-                                    csrf_token
-                                  );
-                                }
-                              } catch (error) {
-                                logger.error('CSRF Error', {
-                                  error,
-                                  ip
-                                });
-                              }
-                            } catch (error) {
-                              logger.error('withPzDefault Error', {
-                                error,
-                                ip
-                              });
-                            }
-
-                            return middlewareResult;
-                          }
+
+                                  return middlewareResult;
+                                })
+                              )
+                            )
+                          )
                         )
                       )
                     )

package/middlewares/index.ts

@@ -9,6 +9,10 @@ import withCompleteGpay from './complete-gpay';
 import withCompleteMasterpass from './complete-masterpass';
 import withCheckoutProvider from './checkout-provider';
 import withSavedCardRedirection from './saved-card-redirection';
+import withCompleteWallet from './complete-wallet';
+import withWalletCompleteRedirection from './wallet-complete-redirection';
+import withMasterpassRestCallback from './masterpass-rest-callback';
+import withBfcacheHeaders from './bfcache-headers';
 import { NextRequest } from 'next/server';
 
 export {
@@ -22,17 +26,21 @@ export {
   withCompleteGpay,
   withCompleteMasterpass,
   withCheckoutProvider,
-  withSavedCardRedirection
+  withSavedCardRedirection,
+  withCompleteWallet,
+  withWalletCompleteRedirection,
+  withMasterpassRestCallback,
+  withBfcacheHeaders
 };
 
 export interface PzNextRequest extends NextRequest {
   middlewareParams: {
     commerceUrl: string;
-    found: boolean;
     rewrites: {
       locale?: string;
       prettyUrl?: string;
       currency?: string;
+      [key: string]: string | undefined;
     };
   };
 }