@akinon/next 1.41.0 → 1.42.0-rc.0

package/hooks/use-message-listener.ts

@@ -0,0 +1,24 @@
+import { useEffect } from 'react';
+
+export const useMessageListener = () => {
+  useEffect(() => {
+    const handleMessage = (event: MessageEvent) => {
+      if (event.origin !== window.location.origin) {
+        return;
+      }
+
+      if (event.data && typeof event.data === 'string') {
+        const messageData = JSON.parse(event.data);
+        if (messageData?.url) {
+          window.location.href = messageData.url;
+        }
+      }
+    };
+
+    window.addEventListener('message', handleMessage);
+
+    return () => {
+      window.removeEventListener('message', handleMessage);
+    };
+  }, []);
+};

package/hooks/use-payment-options.ts

@@ -18,7 +18,8 @@ export const usePaymentOptions = () => {
     pay_on_delivery: 'pz-pay-on-delivery',
     bkm_express: 'pz-bkm',
     credit_payment: 'pz-credit-payment',
-    masterpass: 'pz-masterpass'
+    masterpass: 'pz-masterpass',
+    gpay: 'pz-gpay'
   };
 
   const isInitialTypeIncluded = (type: string) => initialTypes.has(type);

package/lib/cache-handler.mjs

@@ -0,0 +1,33 @@
+import { CacheHandler } from '@neshca/cache-handler';
+import createLruHandler from '@neshca/cache-handler/local-lru';
+import createRedisHandler from '@neshca/cache-handler/redis-stack';
+import { createClient } from 'redis';
+
+CacheHandler.onCreation(async () => {
+  const redisUrl = `redis://${process.env.CACHE_HOST}:${
+    process.env.CACHE_PORT
+  }/${process.env.CACHE_BUCKET ?? '0'}`;
+
+  const client = createClient({
+    url: redisUrl
+  });
+
+  client.on('error', (error) => {
+    console.error('Redis client error', { redisUrl, error });
+  });
+
+  await client.connect();
+
+  const redisHandler = await createRedisHandler({
+    client,
+    timeoutMs: 5000
+  });
+
+  const localHandler = createLruHandler();
+
+  return {
+    handlers: [redisHandler, localHandler]
+  };
+});
+
+export default CacheHandler;

package/lib/cache.ts

@@ -20,13 +20,16 @@ const hashCacheKey = (object?: Record<string, string>) => {
   return `_${encodeURIComponent(cacheKey)}`;
 };
 export const CacheKey = {
-  List: (searchParams: URLSearchParams, headers?: Record<string, string>) =>
+  List: (
+    searchParams: { [key: string]: string | string[] | undefined },
+    headers?: Record<string, string>
+  ) =>
     `list_${encodeURIComponent(JSON.stringify(searchParams))}${hashCacheKey(
       headers
     )}`,
   Category: (
     pk: number,
-    searchParams?: URLSearchParams,
+    searchParams?: { [key: string]: string | string[] | undefined },
     headers?: Record<string, string>
   ) =>
     `category_${pk}_${encodeURIComponent(
@@ -35,15 +38,20 @@ export const CacheKey = {
   CategorySlug: (slug: string) => `category_${slug}`,
   SpecialPage: (
     pk: number,
-    searchParams: URLSearchParams,
+    searchParams: { [key: string]: string | string[] | undefined },
     headers?: Record<string, string>
   ) =>
     `special_page_${pk}_${encodeURIComponent(
       JSON.stringify(searchParams)
     )}${hashCacheKey(headers)}`,
-  Product: (pk: number, searchParams: URLSearchParams) =>
-    `product_${pk}_${encodeURIComponent(JSON.stringify(searchParams))}`,
-  GroupProduct: (pk: number, searchParams: URLSearchParams) =>
+  Product: (
+    pk: number,
+    searchParams: { [key: string]: string | string[] | undefined }
+  ) => `product_${pk}_${encodeURIComponent(JSON.stringify(searchParams))}`,
+  GroupProduct: (
+    pk: number,
+    searchParams: { [key: string]: string | string[] | undefined }
+  ) =>
     `group_product_${pk}_${encodeURIComponent(JSON.stringify(searchParams))}`,
   FlatPage: (pk: number) => `flat_page_${pk}`,
   LandingPage: (pk: number) => `landing_page_${pk}`,
@@ -158,6 +166,10 @@ export class Cache {
     handler: () => Promise<T>,
     options?: CacheOptions
   ): Promise<T> {
+    if (Settings.usePrettyUrlRoute) {
+      return await handler();
+    }
+
     const requiredVariables = [
       process.env.CACHE_HOST,
       process.env.CACHE_PORT,

package/middlewares/default.ts

@@ -203,6 +203,15 @@ const withPzDefault =
                               );
                             }
 
+                            if (
+                              Settings.usePrettyUrlRoute &&
+                              url.searchParams.toString().length > 0
+                            ) {
+                              url.pathname =
+                                url.pathname +
+                                `searchparams|${url.searchParams.toString()}`;
+                            }
+
                             Settings.rewrites.forEach((rewrite) => {
                               url.pathname = url.pathname.replace(
                                 rewrite.source,

package/middlewares/pretty-url.ts

@@ -56,6 +56,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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@akinon/next",
   "description": "Core package for Project Zero Next",
-  "version": "1.41.0",
+  "version": "1.42.0-rc.0",
   "private": false,
   "license": "MIT",
   "bin": {
@@ -20,21 +20,22 @@
     "@opentelemetry/sdk-trace-node": "1.19.0",
     "@opentelemetry/semantic-conventions": "1.19.0",
     "@reduxjs/toolkit": "1.9.7",
+    "@neshca/cache-handler": "1.0.7",
     "cross-spawn": "7.0.3",
     "generic-pool": "3.9.0",
     "react-redux": "8.1.3",
     "react-string-replace": "1.1.1",
-    "redis": "4.5.1",
-    "semver": "7.5.4",
+    "redis": "4.6.13",
+    "semver": "7.6.2",
     "set-cookie-parser": "2.6.0"
   },
   "devDependencies": {
+    "@akinon/eslint-plugin-projectzero": "1.42.0-rc.0",
     "@types/react-redux": "7.1.30",
     "@types/set-cookie-parser": "2.4.7",
     "@typescript-eslint/eslint-plugin": "6.7.4",
     "@typescript-eslint/parser": "6.7.4",
     "eslint": "^8.14.0",
-    "@akinon/eslint-plugin-projectzero": "1.41.0",
     "eslint-config-prettier": "8.5.0"
   }
 }

package/plugins.d.ts

@@ -12,6 +12,7 @@ declare module '@akinon/pz-masterpass/src/utils' {
 declare module '@akinon/pz-masterpass/src/redux/reducer' {
   export const setError: any;
   export const setOtpModalVisible: any;
+  export const setCvcRequired: any;
 }
 
 declare module '@akinon/pz-otp' {

package/redux/middlewares/checkout.ts

@@ -16,6 +16,7 @@ import {
   setPreOrder,
   setRetailStores,
   setShippingOptions,
+  setDataSourceShippingOptions,
   setShippingStepCompleted,
   setCreditPaymentOptions
 } from '../../redux/reducers/checkout';
@@ -26,10 +27,11 @@ import { getCookie, setCookie } from '../../utils';
 import settings from 'settings';
 import { LocaleUrlStrategy } from '../../localization';
 import { showMobile3dIframe } from '../../utils/mobile-3d-iframe';
+import { showRedirectionIframe } from '../../utils/redirection-iframe';
 
 interface CheckoutResult {
   payload: {
-    errors?: any;
+    errors?: Record<string, string[]>;
     pre_order?: PreOrder;
     context_list?: CheckoutContext[];
   };
@@ -73,6 +75,7 @@ export const preOrderMiddleware: Middleware = ({
       deliveryOptions,
       addressList: addresses,
       shippingOptions,
+      dataSourceShippingOptions,
       paymentOptions,
       installmentOptions
     } = getState().checkout;
@@ -125,6 +128,22 @@ export const preOrderMiddleware: Middleware = ({
       dispatch(apiEndpoints.setShippingOption.initiate(shippingOptions[0].pk));
     }
 
+    if (
+      dataSourceShippingOptions.length > 0 &&
+      !preOrder.data_source_shipping_options
+    ) {
+      const selectedDataSourceShippingOptionsPks =
+        dataSourceShippingOptions.map(
+          (opt) => opt.data_source_shipping_options[0].pk
+        );
+
+      dispatch(
+        apiEndpoints.setDataSourceShippingOptions.initiate(
+          selectedDataSourceShippingOptionsPks
+        )
+      );
+    }
+
     if (!preOrder.payment_option && paymentOptions.length > 0) {
       dispatch(apiEndpoints.setPaymentOption.initiate(paymentOptions[0].pk));
     }
@@ -163,6 +182,7 @@ export const contextListMiddleware: Middleware = ({
     if (result?.payload?.context_list) {
       result.payload.context_list.forEach((context) => {
         const redirectUrl = context.page_context.redirect_url;
+        const isIframe = context.page_context.is_frame ?? false;
 
         if (redirectUrl) {
           const currentLocale = getCookie('pz-locale');
@@ -181,16 +201,19 @@ export const contextListMiddleware: Middleware = ({
           }
 
           const urlObj = new URL(url, window.location.origin);
-          urlObj.searchParams.set('t', new Date().getTime().toString());
-
-          if (
-            (isMobileApp ||
-              /iPad|iPhone|iPod|Android/i.test(navigator.userAgent)) &&
+          const isMobileDevice =
+            isMobileApp ||
+            /iPad|iPhone|iPod|Android/i.test(navigator.userAgent);
+          const isIframePaymentOptionExcluded =
             !settings.checkout?.iframeExcludedPaymentOptions?.includes(
               result.payload?.pre_order?.payment_option?.slug
-            )
-          ) {
+            );
+          urlObj.searchParams.set('t', new Date().getTime().toString());
+
+          if (isMobileDevice && !isIframePaymentOptionExcluded) {
             showMobile3dIframe(urlObj.toString());
+          } else if (isIframe && !isIframePaymentOptionExcluded) {
+            showRedirectionIframe(urlObj.toString());
           } else {
             window.location.href = urlObj.toString();
           }
@@ -220,12 +243,20 @@ export const contextListMiddleware: Middleware = ({
           dispatch(setShippingOptions(context.page_context.shipping_options));
         }
 
+        if (context.page_context.data_sources) {
+          dispatch(
+            setDataSourceShippingOptions(context.page_context.data_sources)
+          );
+        }
+
         if (context.page_context.payment_options) {
           dispatch(setPaymentOptions(context.page_context.payment_options));
         }
 
         if (context.page_context.credit_payment_options) {
-          dispatch(setCreditPaymentOptions(context.page_context.credit_payment_options));
+          dispatch(
+            setCreditPaymentOptions(context.page_context.credit_payment_options)
+          );
         }
 
         if (context.page_context.payment_choices) {

package/redux/reducers/checkout.ts

@@ -14,12 +14,12 @@ import {
   CheckoutCreditPaymentOption,
   PreOrder,
   RetailStore,
-  ShippingOption
+  ShippingOption,
+  DataSource
 } from '../../types';
 
 export interface CheckoutState {
-  // TODO: Add types
-  errors: any;
+  errors: Record<string, string[]>;
   hasGiftBox: boolean;
   canGuestPurchase: boolean;
   steps: {
@@ -37,6 +37,7 @@ export interface CheckoutState {
   addressList: Address[];
   deliveryOptions: DeliveryOption[];
   shippingOptions: ShippingOption[];
+  dataSourceShippingOptions: DataSource[];
   paymentOptions: PaymentOption[];
   creditPaymentOptions: CheckoutCreditPaymentOption[];
   selectedCreditPaymentPk: number;
@@ -68,6 +69,7 @@ const initialState: CheckoutState = {
   addressList: [],
   deliveryOptions: [],
   shippingOptions: [],
+  dataSourceShippingOptions: [],
   paymentOptions: [],
   creditPaymentOptions: [],
   selectedCreditPaymentPk: null,
@@ -122,6 +124,9 @@ const checkoutSlice = createSlice({
     setShippingOptions(state, { payload }) {
       state.shippingOptions = payload;
     },
+    setDataSourceShippingOptions(state, { payload }) {
+      state.dataSourceShippingOptions = payload;
+    },
     setPaymentOptions(state, { payload }) {
       state.paymentOptions = payload;
     },
@@ -169,6 +174,7 @@ export const {
   setAddressList,
   setDeliveryOptions,
   setShippingOptions,
+  setDataSourceShippingOptions,
   setPaymentOptions,
   setCreditPaymentOptions,
   setSelectedCreditPaymentPk,

package/redux/reducers/config.ts

@@ -6,6 +6,8 @@ import { Config } from '../../types';
 const initialState: Config = {
   user_phone_regex: '^(05)\\d{9}$',
   user_phone_format: '05999999999',
+  user_post_code_regex: '^\\d{5}$',
+  user_post_code_format: '99999',
   country: {
     pk: 1,
     name: 'Türkiye',

package/routes/pretty-url.tsx

@@ -0,0 +1,194 @@
+import { URLS } from '@akinon/next/data/urls';
+import { Metadata, PageProps } from '@akinon/next/types';
+import logger from '@akinon/next/utils/log';
+import { notFound } from 'next/navigation';
+
+type PrettyUrlResult = {
+  matched: boolean;
+  path?: string;
+  pk?: number;
+};
+
+const resolvePrettyUrlHandler =
+  (pathname: string, ip: string | null) => async () => {
+    let results = [] as { old_path: string }[];
+    let prettyUrlResult: PrettyUrlResult = {
+      matched: false
+    };
+
+    try {
+      const requestUrl = URLS.misc.prettyUrls(`/${pathname}/`);
+
+      logger.debug(`Resolving pretty url`, { pathname, requestUrl, ip });
+
+      const start = Date.now();
+      const apiResponse = await fetch(requestUrl, {
+        next: {
+          revalidate: 0
+        }
+      });
+      const data = await apiResponse.json();
+      ({ results } = data);
+      const end = Date.now();
+      console.warn('Pretty url response time', end - start, requestUrl);
+
+      const matched = results.length > 0;
+      const [{ old_path: path } = { old_path: '' }] = results;
+      let pk;
+
+      if (matched) {
+        const pkRegex = /\/(\d+)\/$/;
+        const match = path.match(pkRegex);
+        pk = match ? parseInt(match[1]) : undefined;
+      }
+
+      prettyUrlResult = {
+        matched,
+        path,
+        pk
+      };
+
+      logger.trace('Pretty url result', { prettyUrlResult, ip });
+    } catch (error) {
+      logger.error('Error resolving pretty url', { error, pathname, ip });
+    }
+
+    return prettyUrlResult;
+  };
+
+export async function generateMetadata({ params }: PageProps) {
+  let result: Metadata = {};
+  const { prettyurl } = params;
+  const pageSlug = prettyurl
+    .filter((x) => !x.startsWith('searchparams'))
+    .join('/');
+
+  const searchParams = Object.fromEntries(
+    new URLSearchParams(
+      decodeURIComponent(
+        prettyurl
+          .find((x) => x.startsWith('searchparams'))
+          ?.replace('searchparams%7C', '')
+      ) ?? {}
+    ).entries()
+  );
+
+  const prettyUrlResult = await resolvePrettyUrlHandler(pageSlug, null)();
+
+  if (!prettyUrlResult.matched) {
+    return notFound();
+  }
+
+  const commonProps = {
+    params: {
+      ...params,
+      pk: prettyUrlResult.pk
+    },
+    searchParams
+  };
+
+  try {
+    if (prettyUrlResult.path.startsWith('/product/')) {
+      await import('@product/[pk]/page').then(async (module) => {
+        result = await module['generateMetadata']?.(commonProps);
+      });
+    }
+
+    if (prettyUrlResult.path.startsWith('/group-product/')) {
+      await import('@group-product/[pk]/page').then(async (module) => {
+        result = await module['generateMetadata']?.(commonProps);
+      });
+    }
+
+    if (prettyUrlResult.path.startsWith('/category/')) {
+      await import('@category/[pk]/page').then(async (module) => {
+        result = await module['generateMetadata']?.(commonProps);
+      });
+    }
+
+    if (prettyUrlResult.path.startsWith('/special-page/')) {
+      await import('@special-page/[pk]/page').then(async (module) => {
+        result = await module['generateMetadata']?.(commonProps);
+      });
+    }
+
+    if (prettyUrlResult.path.startsWith('/flat-page/')) {
+      await import('@flat-page/[pk]/page').then(async (module) => {
+        result = await module['generateMetadata']?.(commonProps);
+      });
+    }
+    // eslint-disable-next-line no-empty
+  } catch (error) {}
+
+  return result;
+}
+
+export const dynamic = 'force-static';
+export const revalidate = 300;
+
+export default async function Page({ params }) {
+  const { prettyurl } = params;
+  const pageSlug = prettyurl
+    .filter((x) => !x.startsWith('searchparams'))
+    .join('/');
+
+  const urlSearchParams = new URLSearchParams(
+    decodeURIComponent(
+      prettyurl
+        .find((x) => x.startsWith('searchparams'))
+        ?.replace('searchparams%7C', '')
+    ) ?? {}
+  );
+
+  const searchParams = {};
+
+  for (const [key, value] of urlSearchParams.entries() as unknown as Array<
+    [string, string]
+  >) {
+    if (!searchParams[key]) {
+      searchParams[key] = [];
+    }
+    searchParams[key].push(value);
+  }
+
+  const result = await resolvePrettyUrlHandler(pageSlug, null)();
+
+  if (!result.matched) {
+    return notFound();
+  }
+
+  const commonProps = {
+    params: {
+      ...params,
+      pk: result.pk
+    },
+    searchParams
+  };
+
+  if (result.path.startsWith('/category/')) {
+    const CategoryPage = (await import('@category/[pk]/page')).default;
+    return <CategoryPage {...commonProps} />;
+  }
+
+  if (result.path.startsWith('/product/')) {
+    const ProductPage = (await import('@product/[pk]/page')).default;
+    return <ProductPage {...commonProps} />;
+  }
+
+  if (result.path.startsWith('/group-product/')) {
+    const GroupProduct = (await import('@group-product/[pk]/page')).default;
+    return <GroupProduct {...commonProps} />;
+  }
+
+  if (result.path.startsWith('/special-page/')) {
+    const SpecialPage = (await import('@special-page/[pk]/page')).default;
+    return <SpecialPage {...commonProps} />;
+  }
+
+  if (result.path.startsWith('/flat-page/')) {
+    const FlatPage = (await import('@flat-page/[pk]/page')).default;
+    return <FlatPage {...commonProps} />;
+  }
+
+  return null;
+}

package/types/commerce/account.ts

@@ -61,4 +61,5 @@ export type ContactFormType = {
   order?: string;
   country_code?: string;
   order_needed?: boolean;
+  file?: FileList
 };

package/types/commerce/address.ts

@@ -17,7 +17,7 @@ export type AddressFormType = {
   line: string;
   postcode: string;
   company_name?: string;
-  tax_no?: number;
+  tax_no?: string;
   tax_office?: string;
   e_bill_taxpayer?: boolean;
   country_code?: string;

package/types/commerce/checkout.ts

@@ -33,6 +33,23 @@ export interface ShippingOption {
   slug: string;
 }
 
+export interface DataSource {
+  pk: number;
+  name: string;
+  data_source_shipping_options: DataSourceShippingOption[];
+}
+
+export interface DataSourceShippingOption {
+  pk: number;
+  shipping_amount: string;
+  shipping_option_name: string;
+  shipping_option_logo: string | null;
+  data_source: {
+    pk: number;
+    title: string | null;
+  };
+}
+
 export interface CheckoutAddressType {
   label: string;
   text: string;
@@ -78,6 +95,7 @@ export interface PreOrder {
   retail_store?: RetailStore;
   gift_box?: GiftBox;
   credit_payment_option?: CheckoutCreditPaymentOption;
+  data_source_shipping_options: any;
 }
 
 export interface GuestLoginFormParams {

package/types/commerce/misc.ts

@@ -2,6 +2,8 @@ import { District } from './address';
 export interface Config {
   user_phone_regex: string;
   user_phone_format: string;
+  user_post_code_regex: string;
+  user_post_code_format: string;
   country: {
     pk: number;
     name: string;

package/types/commerce/order.ts

@@ -52,6 +52,10 @@ export interface OrderItem {
   quantity: string;
   unit_price: string;
   total_amount: string;
+  attributes: {
+    gift_note: string;
+    [key: string]: any;
+  };
 }
 
 export interface Order {
@@ -105,6 +109,9 @@ export interface Order {
   shipping_option: number;
   tracking_number: string;
   tracking_url: string;
+  bank: {
+    logo: string;
+  };
 }
 
 export interface Quotations {

package/types/index.ts

@@ -68,9 +68,17 @@ export interface Currency {
    * @see https://en.wikipedia.org/wiki/ISO_4217
    */
   code: string;
+  /**
+   * Number of decimal places to display.
+   *
+   * @example
+   * decimalScale: 3
+   */
+  decimalScale?: number;
 }
 
 export interface Settings {
+  usePrettyUrlRoute?: boolean;
   commerceUrl: string;
   redis: {
     defaultExpirationTime: number;
@@ -216,7 +224,7 @@ export type Translations = { [key: string]: object };
 
 export interface PageProps<T = any> {
   params: T;
-  searchParams: URLSearchParams;
+  searchParams: { [key: string]: string | string[] | undefined };
 }
 
 export interface LayoutProps<T = any> extends PageProps<T> {

package/utils/app-fetch.ts

@@ -41,7 +41,7 @@ const appFetch = async <T>(
     };
 
     init.next = {
-      revalidate: 60
+      revalidate: Settings.usePrettyUrlRoute ? 0 : 60
     };
 
     logger.debug(`FETCH START ${url}`, { requestURL, init, ip });