@akinon/next 1.0.0

package/hooks/use-router.ts

@@ -0,0 +1,45 @@
+'use client';
+
+import { useRouter as _useRouter } from 'next/navigation';
+import { urlLocaleMatcherRegex } from '../utils';
+import { useLocalization } from './use-localization';
+import { LocaleUrlStrategy } from '../localization';
+
+export const useRouter = () => {
+  const { locale, locales, localeUrlStrategy, defaultLocaleValue } =
+    useLocalization();
+  const defaultLocale = locales.find((l) => l.value === defaultLocaleValue);
+  const router = _useRouter();
+
+  const pushOrReplace = (
+    fn: (href: string, options?) => void,
+    href: string,
+    options?
+  ) => {
+    if (href.startsWith('http')) {
+      return fn(href, options);
+    }
+
+    const url = new URL(href, window.location.origin);
+    const pathnameWithoutLocale = url.pathname.replace(
+      urlLocaleMatcherRegex,
+      ''
+    );
+
+    url.pathname = `${
+      locale === defaultLocale?.value &&
+      localeUrlStrategy === LocaleUrlStrategy.HideDefaultLocale
+        ? ''
+        : `/${locale}`
+    }${pathnameWithoutLocale}`;
+
+    return fn(url.href, options);
+  };
+
+  return {
+    ...router,
+    push: (href: string, options?) => pushOrReplace(router.push, href, options),
+    replace: (href: string, options?) =>
+      pushOrReplace(router.replace, href, options)
+  } as typeof router;
+};

package/hooks/use-translation.ts

@@ -0,0 +1,14 @@
+import { LocalizationContext } from '../localization/provider';
+import { useContext } from 'react';
+
+/**
+ * @deprecated Use useLocalization instead.
+ */
+export const useTranslation = (namespace?: string) => {
+  const { translate, locale } = useContext(LocalizationContext);
+
+  return {
+    t: (path: string) => translate(namespace ? `${namespace}.${path}` : path),
+    locale
+  };
+};

package/lib/cache.ts

@@ -0,0 +1,185 @@
+import { RedisClientType } from 'redis';
+import Settings from 'settings';
+import { CacheOptions } from '../types';
+import logger from '../utils/log';
+import { ServerVariables } from '../utils/server-variables';
+
+export const CacheKey = {
+  List: (searchParams: URLSearchParams) =>
+    `list_${encodeURIComponent(JSON.stringify(searchParams))}`,
+  Category: (pk: number, searchParams?: URLSearchParams) =>
+    `category_${pk}_${encodeURIComponent(JSON.stringify(searchParams))}`,
+  CategorySlug: (slug: string) => `category_${slug}`,
+  SpecialPage: (pk: number, searchParams: URLSearchParams) =>
+    `special_page_${pk}_${encodeURIComponent(JSON.stringify(searchParams))}`,
+  Product: (pk: number, searchParams: URLSearchParams) =>
+    `product_${pk}_${encodeURIComponent(JSON.stringify(searchParams))}`,
+  GroupProduct: (pk: number, searchParams: URLSearchParams) =>
+    `group_product_${pk}_${encodeURIComponent(JSON.stringify(searchParams))}`,
+  FlatPage: (pk: number) => `flat_page_${pk}`,
+  Widget: (slug: string) => `widget_${slug}`,
+  PrettyUrl: (pathname: string) => `pretty_url_${pathname}`,
+  Menu: (depth: number, parent?: string) =>
+    `menu_${depth}${parent ? `_${parent}` : ''}`,
+  Seo: (url: string) => `seo_${url}`,
+  RootSeo: 'root_seo'
+};
+
+export class Cache {
+  static PROXY_URL = `${process.env.NEXT_PUBLIC_URL}/api/cache`;
+
+  static formatKey(key: string) {
+    return encodeURIComponent(
+      `${Settings.commerceUrl}_${ServerVariables.locale}_${key}`
+    );
+  }
+
+  static async getClient() {
+    const { createClient } = await import('redis');
+    const redisUrl = `redis://${process.env.CACHE_HOST}:${
+      process.env.CACHE_PORT
+    }/${process.env.CACHE_BUCKET ?? '0'}`;
+
+    const client: RedisClientType = createClient({
+      url: redisUrl
+    });
+
+    client.on('error', (error) => {
+      logger.error('Redis client error', { redisUrl, error });
+    });
+
+    return client;
+  }
+
+  static async get(key: string) {
+    let value;
+    let client;
+
+    try {
+      client = await Cache.getClient();
+      await client.connect();
+      value = JSON.parse(await client.get(key));
+
+      logger.debug('Redis get success', { key });
+      logger.trace('Redis get success', { key, value });
+    } catch (error) {
+      logger.error('Redis get error', { key, error });
+    } finally {
+      await client?.disconnect();
+    }
+
+    return value;
+  }
+
+  static async set(key: string, value: string, expire?: number) {
+    let success = false;
+    let client;
+
+    try {
+      client = await Cache.getClient();
+      await client.connect();
+      await client.set(key, value, {
+        EX: expire
+      });
+
+      success = true;
+
+      logger.debug('Redis set success', { key });
+      logger.trace('Redis set success', { key, value });
+    } catch (error) {
+      logger.error('Redis set error', { key, error });
+    } finally {
+      await client?.disconnect();
+    }
+
+    return success;
+  }
+
+  static async wrap<T = any>(
+    key: string,
+    handler: () => Promise<T>,
+    options?: CacheOptions
+  ): Promise<T> {
+    const requiredVariables = [
+      process.env.CACHE_HOST,
+      process.env.CACHE_PORT,
+      process.env.CACHE_SECRET
+    ];
+
+    if (!requiredVariables.every((v) => v)) {
+      return await handler();
+    }
+
+    const defaultOptions: CacheOptions = {
+      cache: true,
+      expire: Settings.redis.defaultExpirationTime
+    };
+
+    const _options = Object.assign(defaultOptions, options);
+    const formattedKey = Cache.formatKey(key);
+
+    logger.debug('Cache wrap', { key, formattedKey, _options });
+
+    if (_options.cache) {
+      let cachedValue;
+
+      if (_options.useProxy) {
+        const body = new URLSearchParams();
+
+        body.append('key', formattedKey);
+
+        cachedValue = await Cache.proxyRequest('POST', body);
+        logger.debug('Cache proxy request success', { key });
+        logger.trace('Cache proxy request', { key, cachedValue });
+      } else {
+        cachedValue = await Cache.get(formattedKey);
+      }
+
+      if (cachedValue) {
+        return cachedValue;
+      }
+    }
+
+    logger.info('Redis cache miss. Setting new value...', { key });
+
+    const data = await handler();
+
+    if (data && _options.cache) {
+      if (_options.useProxy) {
+        try {
+          const body = new URLSearchParams();
+
+          body.append('key', formattedKey);
+          body.append('value', JSON.stringify(data));
+          body.append(
+            'expire',
+            String(_options?.expire ?? Settings.redis.defaultExpirationTime)
+          );
+          await Cache.proxyRequest('PUT', body);
+
+          logger.debug('Cache proxy request', { key, body: body.toString() });
+        } catch (error) {
+          logger.error('Cache proxy error', error);
+        }
+      } else {
+        await Cache.set(formattedKey, JSON.stringify(data), _options?.expire);
+      }
+    }
+
+    return data;
+  }
+
+  static async proxyRequest(method: 'POST' | 'PUT', body: URLSearchParams) {
+    const response = await (
+      await fetch(Cache.PROXY_URL, {
+        method,
+        headers: {
+          authorization: process.env.CACHE_SECRET
+        },
+        body
+      })
+    ).json();
+
+    return response;
+  }
+}

package/localization/index.ts

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

package/localization/provider.tsx

@@ -0,0 +1,58 @@
+'use client';
+
+import React, { createContext } from 'react';
+import { getTranslateFn } from '../utils';
+import { useParams } from 'next/navigation';
+import { Currency, Locale } from '../types';
+import settings from 'settings';
+
+export const LocalizationContext = createContext(
+  {} as {
+    translate: (path: string) => string;
+    locale: string;
+    currency: string;
+    locales: Locale[];
+    currencies: Currency[];
+    defaultLocaleValue: string;
+    defaultCurrencyCode: string;
+    localeUrlStrategy?: string;
+  }
+);
+
+export default function LocalizationProvider({
+  children,
+  translations
+}: {
+  children: React.ReactNode;
+  translations: any;
+}) {
+  const {
+    locales,
+    currencies,
+    defaultLocaleValue,
+    defaultCurrencyCode,
+    localeUrlStrategy
+  } = settings.localization;
+
+  const { locale, currency } = useParams() as {
+    locale: string;
+    currency: string;
+  };
+
+  return (
+    <LocalizationContext.Provider
+      value={{
+        translate: (path: string) => getTranslateFn(path, translations),
+        locale,
+        currency,
+        locales,
+        currencies,
+        defaultLocaleValue,
+        defaultCurrencyCode,
+        localeUrlStrategy
+      }}
+    >
+      {children}
+    </LocalizationContext.Provider>
+  );
+}

package/middlewares/currency.ts

@@ -0,0 +1,55 @@
+import { NextFetchEvent, NextMiddleware } from 'next/server';
+import { ROUTES } from 'routes';
+import settings from 'settings';
+import { PzNextRequest } from '.';
+import logger from '../utils/log';
+
+const withCurrency =
+  (middleware: NextMiddleware) =>
+  async (req: PzNextRequest, event: NextFetchEvent) => {
+    try {
+      const { currencies, defaultCurrencyCode, defaultLocaleValue } =
+        settings.localization;
+      const locale = req.middlewareParams.rewrites.locale ?? defaultLocaleValue;
+
+      if (!defaultCurrencyCode) {
+        logger.error('Default currency code is not defined in settings.');
+        throw new Error(
+          'Default currency code is not defined. Use `defaultCurrencyCode` property in `localization` object in `settings.js` file.'
+        );
+      }
+
+      const getActiveCurrencyCode =
+        settings.localization.getActiveCurrencyCode ??
+        (({ req }) => {
+          return (
+            req.cookies.get('pz-currency')?.value ??
+            settings.localization.defaultCurrencyCode
+          );
+        });
+
+      let activeCurrency = getActiveCurrencyCode({
+        req,
+        locale,
+        defaultCurrencyCode
+      });
+
+      if (
+        !activeCurrency ||
+        !currencies.find((c) => c.code === activeCurrency)
+      ) {
+        logger.warn(
+          `Currency ${activeCurrency} is not defined in settings. Using default currency ${defaultCurrencyCode} instead.`
+        );
+        activeCurrency = defaultCurrencyCode;
+      }
+
+      req.middlewareParams.rewrites.currency = activeCurrency;
+    } catch (error) {
+      logger.error('withCurrency error', error);
+    }
+
+    return middleware(req, event);
+  };
+
+export default withCurrency;

package/middlewares/default.ts

@@ -0,0 +1,224 @@
+import { NextFetchEvent, NextMiddleware, NextResponse } from 'next/server';
+import Settings from 'settings';
+import {
+  PzNextRequest,
+  withOauthLogin,
+  withPrettyUrl,
+  withRedirectionPayment,
+  withThreeDRedirection,
+  withUrlRedirection
+} from '.';
+import { urlLocaleMatcherRegex } from '../utils';
+import withCurrency from './currency';
+import withLocale from './locale';
+import logger from '../utils/log';
+import { user } from '../data/urls';
+
+const withPzDefault =
+  (middleware: NextMiddleware) =>
+  async (req: PzNextRequest, event: NextFetchEvent) => {
+    const url = req.nextUrl.clone();
+    const commerceUrl = encodeURIComponent(decodeURI(Settings.commerceUrl)); // encodeURI doesn't work as expected in middleware
+    const searchParams = new URLSearchParams(url.search);
+
+    logger.debug('withPzDefault', {
+      url: url.href,
+      middlewareParams: req.middlewareParams
+    });
+
+    // Support legacy ?format=json query param
+    if (searchParams.has('json') || searchParams.get('format') === 'json') {
+      try {
+        searchParams.set('format', 'json');
+
+        const request = await fetch(
+          `${encodeURI(Settings.commerceUrl)}${url.pathname.replace(
+            urlLocaleMatcherRegex,
+            ''
+          )}?${searchParams.toString()}`,
+          {
+            next: {
+              revalidate: 0
+            },
+            headers: {
+              Cookie: req.headers.get('cookie') || '',
+              Accept: 'application/json',
+              'X-Requested-With': 'XMLHttpRequest'
+            }
+          }
+        );
+
+        return NextResponse.json(await request.json());
+      } catch (error) {
+        logger.error('?format=json error', error);
+        return NextResponse.next();
+      }
+    }
+
+    if (url.pathname === '/healthz') {
+      return NextResponse.json({ status: 'ok' });
+    }
+
+    if (req.nextUrl.pathname.startsWith('/.well-known')) {
+      const url = new URL(`${Settings.commerceUrl}${req.nextUrl.pathname}`);
+      const req_ = await fetch(url.toString());
+
+      if (req_.ok) {
+        return NextResponse.rewrite(url);
+      } else {
+        return NextResponse.next();
+      }
+    }
+
+    if (req.nextUrl.pathname.includes('/orders/hooks/')) {
+      return NextResponse.rewrite(
+        new URL(
+          `${Settings.commerceUrl}${req.nextUrl.pathname.replace(
+            urlLocaleMatcherRegex,
+            ''
+          )}`
+        )
+      );
+    }
+
+    if (req.nextUrl.pathname.startsWith('/orders/redirection/')) {
+      return NextResponse.rewrite(
+        new URL(`${encodeURI(Settings.commerceUrl)}/orders/redirection/`)
+      );
+    }
+
+    req.middlewareParams = {
+      commerceUrl,
+      rewrites: {}
+    };
+
+    return withOauthLogin(
+      withLocale(
+        withCurrency(
+          withPrettyUrl(
+            withRedirectionPayment(
+              withThreeDRedirection(
+                withUrlRedirection(
+                  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,
+                        ''
+                      );
+
+                      url.basePath = `/${commerceUrl}`;
+                      url.pathname = `/${
+                        locale.length ? `${locale}/` : ''
+                      }${currency}${prettyUrl ?? pathnameWithoutLocale}`;
+
+                      Settings.rewrites.forEach((rewrite) => {
+                        url.pathname = url.pathname.replace(
+                          rewrite.source,
+                          rewrite.destination
+                        );
+                      });
+
+                      middlewareResult = (await middleware(
+                        req,
+                        event
+                      )) as NextResponse | void;
+
+                      if (middlewareResult instanceof NextResponse) {
+                        middlewareResult.headers.set(
+                          'x-middleware-rewrite',
+                          url.href
+                        );
+                      } else {
+                        middlewareResult = NextResponse.rewrite(url);
+                      }
+
+                      if (!url.pathname.startsWith(`/${currency}/orders`)) {
+                        middlewareResult.cookies.set(
+                          'pz-locale',
+                          locale?.length > 0 ? locale : defaultLocaleValue,
+                          {
+                            sameSite: 'none',
+                            secure: true
+                          }
+                        );
+                      }
+                      middlewareResult.cookies.set('pz-currency', currency, {
+                        sameSite: 'none',
+                        secure: true
+                      });
+
+                      if (
+                        req.cookies.get('pz-currency') &&
+                        req.cookies.get('pz-currency').value !== currency
+                      ) {
+                        logger.debug('Currency changed', {
+                          currency,
+                          oldCurrency: req.cookies.get('pz-currency')?.value
+                        });
+
+                        middlewareResult.cookies.set('pz-reset-basket', 'true');
+                      }
+
+                      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
+                        });
+
+                        middlewareResult.cookies.set(
+                          'pz-reset-client-cache',
+                          'true'
+                        );
+                      }
+
+                      middlewareResult.headers.set(
+                        'pz-url',
+                        req.nextUrl.toString()
+                      );
+
+                      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);
+                      }
+                    } catch (error) {
+                      logger.error('withPzDefault Error', error);
+                    }
+
+                    return middlewareResult;
+                  }
+                )
+              )
+            )
+          )
+        )
+      )
+    )(req, event);
+  };
+
+export default withPzDefault;

package/middlewares/index.ts

@@ -0,0 +1,29 @@
+import withPzDefault from './default';
+import withPrettyUrl from './pretty-url';
+import withThreeDRedirection from './three-d-redirection';
+import withRedirectionPayment from './redirection-payment';
+import withLocale from './locale';
+import withOauthLogin from './oauth-login';
+import withUrlRedirection from './url-redirection';
+import { NextRequest } from 'next/server';
+
+export {
+  withPzDefault,
+  withPrettyUrl,
+  withThreeDRedirection,
+  withRedirectionPayment,
+  withLocale,
+  withOauthLogin,
+  withUrlRedirection
+};
+
+export interface PzNextRequest extends NextRequest {
+  middlewareParams: {
+    commerceUrl: string;
+    rewrites: {
+      locale?: string;
+      prettyUrl?: string;
+      currency?: string;
+    };
+  };
+}

package/middlewares/locale.ts

@@ -0,0 +1,61 @@
+import { NextFetchEvent, NextMiddleware, NextResponse } from 'next/server';
+import settings from 'settings';
+import { PzNextRequest } from '.';
+import { LocaleUrlStrategy } from '../localization';
+import { urlLocaleMatcherRegex } from '../utils';
+import logger from '../utils/log';
+
+const getMatchedLocale = (pathname: string) => {
+  let matchedLocale = pathname.match(urlLocaleMatcherRegex)?.[0] ?? '';
+  matchedLocale = matchedLocale.replace('/', '');
+
+  if (!matchedLocale.length) {
+    if (
+      settings.localization.localeUrlStrategy !==
+      LocaleUrlStrategy.ShowAllLocales
+    ) {
+      matchedLocale = settings.localization.defaultLocaleValue;
+    }
+  }
+
+  return matchedLocale;
+};
+
+const withLocale =
+  (middleware: NextMiddleware) =>
+  async (req: PzNextRequest, event: NextFetchEvent) => {
+    try {
+      const url = req.nextUrl.clone();
+      const matchedLocale = getMatchedLocale(url.pathname);
+      let { localeUrlStrategy, defaultLocaleValue, redirectToDefaultLocale } =
+        settings.localization;
+
+      localeUrlStrategy =
+        localeUrlStrategy ?? LocaleUrlStrategy.HideDefaultLocale;
+
+      if (!defaultLocaleValue) {
+        logger.error('Default locale value is not defined in settings.');
+        throw new Error(
+          'Default locale value is not defined. Use `defaultLocaleValue` property in `localization` object in `settings.js` file.'
+        );
+      }
+
+      if (
+        !matchedLocale?.length &&
+        localeUrlStrategy === LocaleUrlStrategy.ShowAllLocales &&
+        redirectToDefaultLocale &&
+        req.method === 'GET'
+      ) {
+        url.pathname = `/${defaultLocaleValue}${url.pathname}`;
+        return NextResponse.redirect(url);
+      }
+
+      req.middlewareParams.rewrites.locale = matchedLocale;
+    } catch (error) {
+      logger.error('withLocale error', error);
+    }
+
+    return middleware(req, event);
+  };
+
+export default withLocale;