@akinon/next 1.59.0 → 1.60.0-rc.6

package/middlewares/default.ts

@@ -9,6 +9,7 @@ import {
   withOauthLogin,
   withPrettyUrl,
   withRedirectionPayment,
+  withSavedCardRedirection,
   withThreeDRedirection,
   withUrlRedirection
 } from '.';
@@ -88,14 +89,44 @@ const withPzDefault =
       req.nextUrl.pathname.includes('/orders/hooks/') ||
       req.nextUrl.pathname.includes('/orders/checkout-with-token/')
     ) {
-      return NextResponse.rewrite(
+      const segment = url.searchParams.get('segment');
+      const currency = url.searchParams.get('currency')?.toLowerCase();
+
+      const headers = {};
+
+      if (segment) {
+        headers['X-Segment-Id'] = segment;
+      }
+
+      if (currency) {
+        headers['x-currency'] = currency;
+      }
+
+      const response = NextResponse.rewrite(
         new URL(
           `${Settings.commerceUrl}${req.nextUrl.pathname.replace(
             urlLocaleMatcherRegex,
             ''
           )}`
-        )
+        ),
+        {
+          headers
+        }
       );
+
+      if (segment) {
+        response.cookies.set('pz-segment', segment);
+      }
+
+      if (currency) {
+        response.cookies.set('pz-currency', currency, {
+          sameSite: 'none',
+          secure: true,
+          expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7) // 7 days
+        });
+      }
+
+      return response;
     }
 
     if (req.nextUrl.pathname.startsWith('/orders/redirection/')) {
@@ -110,6 +141,14 @@ const withPzDefault =
       );
     }
 
+    if (req.nextUrl.pathname.includes('/orders/saved-card-redirect')) {
+      return NextResponse.rewrite(
+        new URL(
+          `${encodeURI(Settings.commerceUrl)}/orders/saved-card-redirect/`
+        )
+      );
+    }
+
     // If commerce redirects to /orders/checkout/ without locale
     if (
       req.nextUrl.pathname.match(new RegExp('^/orders/checkout/$')) &&
@@ -127,6 +166,25 @@ const withPzDefault =
       return NextResponse.redirect(redirectUrlWithLocale, 303);
     }
 
+    // Dynamically handle any payment gateway without specifying names
+    const paymentGatewayRegex = new RegExp('^/payment-gateway/([^/]+)/$');
+    const gatewayMatch = req.nextUrl.pathname.match(paymentGatewayRegex);
+
+    if (
+      gatewayMatch && // Check if the URL matches the /payment-gateway/<gateway> pattern
+      getUrlPathWithLocale(
+        `/payment-gateway/${gatewayMatch[1]}/`,
+        req.cookies.get('pz-locale')?.value
+      ) !== req.nextUrl.pathname
+    ) {
+      const redirectUrlWithLocale = `${url.origin}${getUrlPathWithLocale(
+        `/payment-gateway/${gatewayMatch[1]}/`,
+        req.cookies.get('pz-locale')?.value
+      )}?${req.nextUrl.searchParams.toString()}`;
+
+      return NextResponse.redirect(redirectUrlWithLocale);
+    }
+
     if (req.nextUrl.pathname.startsWith('/orders/checkout-provider/')) {
       try {
         const data = await req.json();
@@ -174,114 +232,141 @@ const withPzDefault =
                   withUrlRedirection(
                     withCompleteGpay(
                       withCompleteMasterpass(
-                        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,
-                                  ''
-                                );
-                            }
+                        withSavedCardRedirection(
+                          async (req: PzNextRequest, event: NextFetchEvent) => {
+                            let middlewareResult: NextResponse | void =
+                              NextResponse.next();
 
-                            url.basePath = `/${commerceUrl}`;
-                            url.pathname = `/${
-                              locale.length ? `${locale}/` : ''
-                            }${currency}/${customRewriteUrlDiff}${
-                              prettyUrl ?? pathnameWithoutLocale
-                            }`.replace(/\/+/g, '/');
-
-                            if (
-                              !req.middlewareParams.found &&
-                              Settings.customNotFoundEnabled
-                            ) {
-                              let pathname = url.pathname
-                                .replace(/\/+$/, '')
-                                .split('/');
-                              url.pathname = url.pathname.replace(
-                                pathname.pop(),
-                                'pz-not-found'
+                            try {
+                              const { locale, prettyUrl, currency } =
+                                req.middlewareParams.rewrites;
+                              const { defaultLocaleValue } =
+                                Settings.localization;
+                              const url = req.nextUrl.clone();
+                              const pathnameWithoutLocale = url.pathname.replace(
+                                urlLocaleMatcherRegex,
+                                ''
                               );
-                            }
 
-                            Settings.rewrites.forEach((rewrite) => {
-                              url.pathname = url.pathname.replace(
-                                rewrite.source,
-                                rewrite.destination
-                              );
-                            });
+                              middlewareResult = (await middleware(
+                                req,
+                                event
+                              )) as NextResponse | void;
+
+                              let customRewriteUrlDiff = '';
 
-                            // 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 instanceof NextResponse &&
                                 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'
+                                  'x-middleware-rewrite'
+                                )
                               ) {
-                                middlewareResult = NextResponse.rewrite(url);
+                                const rewriteUrl = new URL(
+                                  middlewareResult.headers.get(
+                                    'x-middleware-rewrite'
+                                  )
+                                );
+                                const originalUrl = new URL(req.url);
+                                customRewriteUrlDiff =
+                                  rewriteUrl.pathname.replace(
+                                    originalUrl.pathname,
+                                    ''
+                                  );
                               }
-                            } else {
-                              // if middleware.ts doesn't have a return value.
-                              // e.g. NextResponse.next() doesn't exist in middleware.ts
 
-                              middlewareResult = NextResponse.rewrite(url);
-                            }
+                              url.basePath = `/${commerceUrl}`;
+                              url.pathname = `/${
+                                locale.length ? `${locale}/` : ''
+                              }${currency}/${customRewriteUrlDiff}${
+                                prettyUrl ?? pathnameWithoutLocale
+                              }`.replace(/\/+/g, '/');
+
+                              if (
+                                !req.middlewareParams.found &&
+                                Settings.customNotFoundEnabled
+                              ) {
+                                let pathname = url.pathname
+                                  .replace(/\/+$/, '')
+                                  .split('/');
+                                url.pathname = url.pathname.replace(
+                                  pathname.pop(),
+                                  'pz-not-found'
+                                );
+                              }
+
+                              if (
+                                Settings.usePrettyUrlRoute &&
+                                url.searchParams.toString().length > 0 &&
+                                !Object.entries(ROUTES).find(([, value]) =>
+                                  new RegExp(`^${value}/?$`).test(
+                                    pathnameWithoutLocale
+                                  )
+                                )
+                              ) {
+                                url.pathname =
+                                  url.pathname +
+                                  `searchparams|${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
 
-                            if (
-                              !url.pathname.startsWith(`/${currency}/orders`)
-                            ) {
+                                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
+                                  }
+                                );
+                              }
                               middlewareResult.cookies.set(
-                                'pz-locale',
-                                locale?.length > 0
-                                  ? locale
-                                  : defaultLocaleValue,
+                                'pz-currency',
+                                currency,
                                 {
                                   sameSite: 'none',
                                   secure: true,
@@ -290,76 +375,65 @@ const withPzDefault =
                                   ) // 7 days
                                 }
                               );
-                            }
-                            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 (
+                                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
+                                });
+                              }
 
-                            if (process.env.ACC_APP_VERSION) {
                               middlewareResult.headers.set(
-                                'acc-app-version',
-                                process.env.ACC_APP_VERSION
+                                'pz-url',
+                                req.nextUrl.toString()
                               );
-                            }
 
-                            // Set CSRF token if not set
-                            try {
-                              const url = `${Settings.commerceUrl}${user.csrfToken}`;
+                              if (req.cookies.get('pz-set-currency')) {
+                                middlewareResult.cookies.delete(
+                                  'pz-set-currency'
+                                );
+                              }
 
-                              if (!req.cookies.get('csrftoken')) {
-                                const { csrf_token } = await (
-                                  await fetch(url)
-                                ).json();
-                                middlewareResult.cookies.set(
-                                  'csrftoken',
-                                  csrf_token
+                              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('CSRF Error', {
+                              logger.error('withPzDefault Error', {
                                 error,
                                 ip
                               });
                             }
-                          } catch (error) {
-                            logger.error('withPzDefault Error', {
-                              error,
-                              ip
-                            });
-                          }
 
-                          return middlewareResult;
-                        }
+                            return middlewareResult;
+                          }
+                        )
                       )
                     )
                   )

package/middlewares/index.ts

@@ -8,6 +8,7 @@ import withUrlRedirection from './url-redirection';
 import withCompleteGpay from './complete-gpay';
 import withCompleteMasterpass from './complete-masterpass';
 import withCheckoutProvider from './checkout-provider';
+import withSavedCardRedirection from './saved-card-redirection';
 import { NextRequest } from 'next/server';
 
 export {
@@ -20,7 +21,8 @@ export {
   withUrlRedirection,
   withCompleteGpay,
   withCompleteMasterpass,
-  withCheckoutProvider
+  withCheckoutProvider,
+  withSavedCardRedirection
 };
 
 export interface PzNextRequest extends NextRequest {

package/middlewares/oauth-login.ts

@@ -58,7 +58,9 @@ const withOauthLogin =
       return middleware(req, event);
     }
 
-    if (req.cookies.get('messages')?.value.includes('Successfully signed in')) {
+    const currentSessionId = req.cookies.get('osessionid');
+
+    if (req.cookies.get('messages')?.value.includes('Successfully signed in') || currentSessionId) {
       let redirectUrlWithLocale = `${url.origin}${getUrlPathWithLocale(
         '/auth/oauth-login',
         req.cookies.get('pz-locale')?.value

package/middlewares/pretty-url.ts

@@ -43,9 +43,14 @@ const resolvePrettyUrlHandler =
     return prettyUrlResult;
   };
 
-const resolvePrettyUrl = async (pathname: string, ip: string | null) => {
+const resolvePrettyUrl = async (
+  pathname: string,
+  locale: string,
+  ip: string | null
+) => {
   return Cache.wrap(
     CacheKey.PrettyUrl(pathname),
+    locale,
     resolvePrettyUrlHandler(pathname, ip),
     {
       useProxy: true
@@ -56,6 +61,10 @@ const resolvePrettyUrl = async (pathname: string, ip: string | null) => {
 const withPrettyUrl =
   (middleware: NextMiddleware) =>
   async (req: PzNextRequest, event: NextFetchEvent) => {
+    if (Settings.usePrettyUrlRoute) {
+      return middleware(req, event);
+    }
+
     const url = req.nextUrl.clone();
     const matchedLanguagePrefix = url.pathname.match(
       urlLocaleMatcherRegex
@@ -84,6 +93,7 @@ const withPrettyUrl =
       )
         ? url.pathname
         : prettyUrlPathname,
+      matchedLanguagePrefix,
       ip
     );