@akinon/next 1.0.0

package/middlewares/oauth-login.ts

@@ -0,0 +1,78 @@
+import {
+  NextFetchEvent,
+  NextMiddleware,
+  NextRequest,
+  NextResponse
+} from 'next/server';
+import Settings from 'settings';
+import { getUrlPathWithLocale } from '../utils/localization';
+
+const withOauthLogin =
+  (middleware: NextMiddleware) =>
+  async (req: NextRequest, event: NextFetchEvent) => {
+    const url = req.nextUrl.clone();
+    const loginUrlMatcherRegex = new RegExp(/^\/(\w+)\/login\/?$/);
+    const loginCallbackUrlMatcherRegex = new RegExp(
+      /^\/(\w+)\/login\/callback\/?$/
+    );
+
+    const headers = {
+      'x-forwarded-host':
+        req.headers.get('x-forwarded-host') || req.headers.get('host') || ''
+    };
+
+    if (loginUrlMatcherRegex.test(url.pathname)) {
+      const provider = url.pathname.match(loginUrlMatcherRegex)[1];
+      const response = NextResponse.rewrite(
+        `${Settings.commerceUrl}/${provider}/login/`,
+        {
+          headers
+        }
+      );
+
+      if (req.headers.get('referer')) {
+        response.cookies.set(
+          'pz-oauth-callback-url',
+          req.headers.get('referer')
+        );
+      }
+
+      return response;
+    }
+
+    if (loginCallbackUrlMatcherRegex.test(url.pathname)) {
+      const provider = url.pathname.match(loginCallbackUrlMatcherRegex)[1];
+
+      return NextResponse.rewrite(
+        `${Settings.commerceUrl}/${provider}/login/callback/${url.search}`,
+        {
+          headers
+        }
+      );
+    }
+
+    if (!url.pathname.startsWith('/baskets/basket')) {
+      return middleware(req, event);
+    }
+
+    if (req.cookies.get('messages')?.value.includes('Successfully signed in')) {
+      let redirectUrlWithLocale = `${url.origin}${getUrlPathWithLocale(
+        '/auth/oauth-login',
+        req.cookies.get('pz-locale')?.value
+      )}`;
+      let callbackUrl = req.cookies.get('pz-oauth-callback-url')?.value ?? '';
+
+      if (callbackUrl.length) {
+        redirectUrlWithLocale += `?next=${encodeURIComponent(callbackUrl)}`;
+      }
+
+      const response = NextResponse.redirect(redirectUrlWithLocale);
+      response.cookies.delete('messages');
+      response.cookies.delete('pz-oauth-callback-url');
+      return response;
+    }
+
+    return middleware(req, event);
+  };
+
+export default withOauthLogin;

package/middlewares/pretty-url.ts

@@ -0,0 +1,94 @@
+import { Cache, CacheKey } from '../lib/cache';
+import { NextFetchEvent, NextMiddleware, NextRequest } from 'next/server';
+import { ROUTES } from 'routes';
+import { URLS } from '../data/urls';
+import Settings from 'settings';
+import { urlLocaleMatcherRegex } from '../utils';
+import { PzNextRequest } from '.';
+import logger from '../utils/log';
+
+type PrettyUrlResult = {
+  matched: boolean;
+  path?: string;
+};
+
+const resolvePrettyUrlHandler = (pathname: string) => async () => {
+  let results = <{ old_path: string }[]>[];
+  let prettyUrlResult: PrettyUrlResult = {
+    matched: false
+  };
+
+  try {
+    const requestUrl = URLS.misc.prettyUrls(pathname);
+
+    logger.debug(`Resolving pretty url`, { pathname, requestUrl });
+
+    const apiResponse = await fetch(requestUrl);
+    const data = await apiResponse.json();
+    ({ results } = data);
+
+    const matched = results.length > 0;
+    const [{ old_path: path } = { old_path: '' }] = results;
+    prettyUrlResult = {
+      matched,
+      path
+    };
+
+    logger.trace('Pretty url result', prettyUrlResult);
+  } catch (error) {
+    logger.error('Error resolving pretty url', { error, pathname });
+  }
+
+  return prettyUrlResult;
+};
+
+const resolvePrettyUrl = async (pathname: string) => {
+  return Cache.wrap(
+    CacheKey.PrettyUrl(pathname),
+    resolvePrettyUrlHandler(pathname),
+    {
+      useProxy: true
+    }
+  );
+};
+
+const withPrettyUrl =
+  (middleware: NextMiddleware) =>
+  async (req: PzNextRequest, event: NextFetchEvent) => {
+    const url = req.nextUrl.clone();
+    const matchedLanguagePrefix = url.pathname.match(
+      urlLocaleMatcherRegex
+    )?.[0];
+    const prettyUrlPathname = url.pathname.replace(matchedLanguagePrefix, '');
+    const isValidPrettyUrlPath = (pathname: string) => {
+      return (
+        new RegExp(/^\/[a-zA-Z0-9/]+(?:-[a-zA-Z0-9/]+)*$/).test(pathname) &&
+        !Object.entries(ROUTES).find(([, value]) =>
+          new RegExp(`^${value}$`).test(pathname)
+        )
+      );
+    };
+
+    if (
+      !isValidPrettyUrlPath(prettyUrlPathname) ||
+      Settings.commerceUrl === 'default'
+    ) {
+      return middleware(req, event);
+    }
+
+    const prettyUrlResult = await resolvePrettyUrl(prettyUrlPathname);
+
+    if (prettyUrlResult.matched) {
+      req.middlewareParams.rewrites.prettyUrl = prettyUrlResult.path;
+      logger.debug('Resolved pretty url', {
+        source: prettyUrlPathname,
+        dest: prettyUrlResult.path
+      });
+
+      return middleware(req, event);
+    }
+
+    return middleware(req, event);
+  };
+
+export default withPrettyUrl;

package/middlewares/redirection-payment.ts

@@ -0,0 +1,117 @@
+import { Buffer } from 'buffer';
+import { NextFetchEvent, NextMiddleware, NextResponse } from 'next/server';
+import Settings from 'settings';
+import logger from '../utils/log';
+import { PzNextRequest } from '.';
+import { getUrlPathWithLocale } from '../utils/localization';
+import { urlLocaleMatcherRegex } from '../utils';
+
+const streamToString = async (stream: ReadableStream<Uint8Array> | null) => {
+  if (stream) {
+    const chunks = [];
+    let result = '';
+
+    try {
+      for await (const chunk of stream as any) {
+        chunks.push(Buffer.from(chunk));
+      }
+
+      result = Buffer.concat(chunks).toString('utf-8');
+    } catch (error) {
+      logger.error('Error while reading body stream', {
+        middleware: 'redirection-payment',
+        error
+      });
+    }
+
+    return result;
+  }
+  return null;
+};
+
+const withRedirectionPayment =
+  (middleware: NextMiddleware) =>
+  async (req: PzNextRequest, event: NextFetchEvent) => {
+    const url = req.nextUrl.clone();
+    const pathnameWithoutLocale = url.pathname.replace(
+      urlLocaleMatcherRegex,
+      ''
+    );
+    const searchParams = new URLSearchParams(url.search);
+
+    if (
+      !pathnameWithoutLocale.startsWith('/orders') ||
+      searchParams.get('page') !== 'RedirectionPageCompletePage' ||
+      req.method !== 'POST'
+    ) {
+      return middleware(req, event);
+    }
+
+    const body = await streamToString(req.body);
+    const requestUrl = `${Settings.commerceUrl}/orders/checkout/${url.search}`;
+
+    const request = await fetch(requestUrl, {
+      method: 'POST',
+      headers: {
+        'X-Requested-With': 'XMLHttpRequest',
+        'Content-Type': 'application/x-www-form-urlencoded',
+        Cookie: req.headers.get('cookie') ?? ''
+      },
+      body
+    });
+
+    logger.info('Complete redirection payment request', {
+      requestUrl,
+      status: request.status
+    });
+
+    const response = await request.json();
+
+    const { context_list: contextList } = response;
+    const redirectionContext = contextList?.find(
+      (context) => context.page_context?.redirect_url
+    );
+    const redirectUrl = redirectionContext?.page_context?.redirect_url;
+
+    if (!redirectUrl) {
+      logger.info('Order success page context list', {
+        middleware: 'redirection-payment',
+        contextList
+      });
+
+      logger.warn(
+        'No redirection url for order success page found in page_context',
+        { middleware: 'redirection-payment' }
+      );
+      return NextResponse.redirect(
+        `${url.origin}${getUrlPathWithLocale(
+          `/orders/checkout?${searchParams.toString()}`,
+          req.cookies.get('pz-locale')?.value
+        )}`,
+        303
+      );
+    }
+
+    const redirectUrlWithLocale = `${url.origin}${getUrlPathWithLocale(
+      redirectUrl,
+      req.cookies.get('pz-locale')?.value
+    )}`;
+
+    logger.info('Redirecting to order success page', {
+      middleware: 'redirection-payment',
+      redirectUrlWithLocale
+    });
+
+    // Using POST method while redirecting causes an error,
+    // 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') ?? ''
+    );
+
+    return nextResponse;
+  };
+
+export default withRedirectionPayment;

package/middlewares/three-d-redirection.ts

@@ -0,0 +1,122 @@
+import { NextFetchEvent, NextMiddleware, NextResponse } from 'next/server';
+import Settings from 'settings';
+import { Buffer } from 'buffer';
+import logger from '../utils/log';
+import { getUrlPathWithLocale } from '../utils/localization';
+import { PzNextRequest } from '.';
+
+const streamToString = async (stream: ReadableStream<Uint8Array> | null) => {
+  if (stream) {
+    const chunks = [];
+    let result = '';
+
+    try {
+      for await (const chunk of stream as any) {
+        chunks.push(Buffer.from(chunk));
+      }
+
+      result = Buffer.concat(chunks).toString('utf-8');
+    } catch (error) {
+      logger.error('Error while reading body stream', {
+        middleware: 'three-d-redirection',
+        error
+      });
+    }
+
+    return result;
+  }
+  return null;
+};
+
+const withThreeDRedirection =
+  (middleware: NextMiddleware) =>
+  async (req: PzNextRequest, event: NextFetchEvent) => {
+    const url = req.nextUrl.clone();
+
+    if (url.search.indexOf('CreditCardThreeDSecurePage') === -1) {
+      return middleware(req, event);
+    }
+
+    const body = await streamToString(req.body);
+    const params = body.split('&');
+    const encodedPzParams = decodeURIComponent(
+      params.find((param) => param.startsWith('pzparams'))?.split('=')[1] ?? ''
+    );
+
+    logger.debug('Encoded 3D form extra params', encodedPzParams);
+
+    if (!encodedPzParams.length) {
+      logger.warn('No pzparams found in 3D form params');
+      return middleware(req, event);
+    }
+
+    const pzParams = JSON.parse(decodeURIComponent(encodedPzParams)) as {
+      session: string;
+      locale: string;
+    };
+
+    logger.debug('3D form extra params', pzParams);
+
+    const requestUrl = `${Settings.commerceUrl}/orders/checkout/${url.search}`;
+
+    const request = await fetch(requestUrl, {
+      method: 'POST',
+      headers: {
+        'X-Requested-With': 'XMLHttpRequest',
+        'Content-Type': 'application/x-www-form-urlencoded',
+        Cookie: `osessionid=${pzParams.session}`
+      },
+      body
+    });
+
+    logger.info('Complete 3D payment request', {
+      requestUrl,
+      status: request.status
+    });
+
+    const response = await request.json();
+
+    const { context_list: contextList } = response;
+    const redirectionContext = contextList?.find(
+      (context) => context.page_context?.redirect_url
+    );
+    const redirectUrl = redirectionContext?.page_context?.redirect_url;
+
+    logger.info('Order success page context list', {
+      middleware: 'three-d-redirection',
+      contextList
+    });
+
+    if (!redirectUrl) {
+      logger.warn(
+        'No redirection url for order success page found in page_context',
+        {
+          middleware: 'three-d-redirection'
+        }
+      );
+      return middleware(req, event);
+    }
+
+    const redirectUrlWithLocale = `${url.origin}${getUrlPathWithLocale(
+      redirectUrl,
+      req.cookies.get('pz-locale')?.value
+    )}`;
+
+    logger.info('Redirecting to order success page', {
+      middleware: 'three-d-redirection',
+      redirectUrlWithLocale
+    });
+
+    // Using POST method while redirecting causes an error,
+    // 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') ?? ''
+    );
+
+    return nextResponse;
+  };
+
+export default withThreeDRedirection;

package/middlewares/url-redirection.ts

@@ -0,0 +1,61 @@
+import { NextFetchEvent, NextMiddleware } from 'next/server';
+import settings from 'settings';
+import { PzNextRequest } from '.';
+import logger from '../utils/log';
+import { urlLocaleMatcherRegex } from '../utils';
+import { getUrlPathWithLocale } from '../utils/localization';
+import { ROUTES } from 'routes';
+
+// This middleware is used to handle url redirections set in Omnitron
+
+const withUrlRedirection =
+  (middleware: NextMiddleware) =>
+  async (req: PzNextRequest, event: NextFetchEvent) => {
+    const url = req.nextUrl.clone();
+    const pathnameWithoutLocale = url.pathname.replace(
+      urlLocaleMatcherRegex,
+      ''
+    );
+
+    if (
+      Object.entries(ROUTES).find(([, value]) =>
+        new RegExp(`^${value}$`).test(pathnameWithoutLocale)
+      ) ||
+      pathnameWithoutLocale.startsWith('/orders')
+    ) {
+      return middleware(req, event);
+    }
+
+    try {
+      const request = await fetch(
+        `${settings.commerceUrl}${pathnameWithoutLocale}${url.search}`,
+        {
+          redirect: 'manual',
+          next: {
+            revalidate: 0
+          }
+        }
+      );
+
+      if (request.headers.get('location')) {
+        const location = request.headers.get('location');
+        const redirectUrl = new URL(
+          request.headers.get('location'),
+          location.startsWith('http') ? '' : process.env.NEXT_PUBLIC_URL
+        );
+
+        redirectUrl.pathname = getUrlPathWithLocale(
+          redirectUrl.pathname,
+          req.middlewareParams.rewrites.locale
+        );
+
+        return Response.redirect(redirectUrl.toString(), request.status);
+      }
+    } catch (error) {
+      logger.error('withUrlRedirection error', error);
+    }
+
+    return middleware(req, event);
+  };
+
+export default withUrlRedirection;

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@akinon/next",
+  "description": "Core package for Project Zero Next",
+  "version": "1.0.0",
+  "private": false,
+  "license": "MIT",
+  "bin": {
+    "pz-install-plugins": "bin/pz-install-plugins.js"
+  },
+  "dependencies": {
+    "@reduxjs/toolkit": "1.9.2",
+    "cross-spawn": "7.0.3",
+    "react-redux": "8.0.5",
+    "react-string-replace": "1.1.1",
+    "redis": "4.5.1"
+  },
+  "devDependencies": {
+    "@types/react-redux": "7.1.23"
+  }
+}

package/plugins.js

@@ -0,0 +1,7 @@
+module.exports = [
+  'pz-basket-gift-pack',
+  'pz-click-collect',
+  'pz-one-click-checkout',
+  'pz-pay-on-delivery',
+  'pz-checkout-gift-pack',
+];

package/redux/hooks.ts

@@ -0,0 +1,7 @@
+'use client';
+
+import { TypedUseSelectorHook, useDispatch, useSelector } from 'react-redux';
+import type { RootState, TypedDispatch } from 'redux/store';
+
+export const useAppDispatch = () => useDispatch<TypedDispatch>();
+export const useAppSelector: TypedUseSelectorHook<RootState> = useSelector;