@akinon/next 1.76.0-rc.0 → 1.76.0

package/redux/middlewares/pre-order/delivery-option.ts

@@ -0,0 +1,34 @@
+import { Middleware } from '@reduxjs/toolkit';
+import { CheckoutResult, MiddlewareParams } from '../../../types';
+import { checkoutApi } from '../../../data/client/checkout';
+
+export const deliveryOptionMiddleware: Middleware = ({
+  getState,
+  dispatch
+}: MiddlewareParams) => {
+  return (next) => (action) => {
+    const result: CheckoutResult = next(action);
+    const preOrder = result?.payload?.pre_order;
+
+    if (!preOrder) {
+      return result;
+    }
+
+    const { deliveryOptions } = getState().checkout;
+    const { endpoints: apiEndpoints } = checkoutApi;
+
+    if (!preOrder?.delivery_option && deliveryOptions?.length > 0) {
+      const customerDeliveryOption = deliveryOptions.find(
+        (opt) => opt.delivery_option_type === 'customer'
+      )?.pk;
+
+      if (customerDeliveryOption) {
+        dispatch(
+          apiEndpoints.setDeliveryOption.initiate(customerDeliveryOption)
+        );
+      }
+    }
+
+    return result;
+  };
+};

package/redux/middlewares/pre-order/index.ts

@@ -0,0 +1,25 @@
+import { preOrderValidationMiddleware } from './pre-order-validation';
+import { redirectionMiddleware } from './redirection';
+import { setPreOrderMiddleware } from './set-pre-order';
+import { deliveryOptionMiddleware } from './delivery-option';
+import { setAddressMiddleware } from './address';
+import { shippingOptionMiddleware } from './shipping-option';
+import { dataSourceShippingOptionMiddleware } from './data-source-shipping-option';
+import { attributeBasedShippingOptionMiddleware } from './attribute-based-shipping-option';
+import { paymentOptionMiddleware } from './payment-option';
+import { installmentOptionMiddleware } from './installment-option';
+import { shippingStepMiddleware } from './shipping-step';
+
+export const preOrderMiddlewares = [
+  preOrderValidationMiddleware,
+  redirectionMiddleware,
+  setPreOrderMiddleware,
+  deliveryOptionMiddleware,
+  setAddressMiddleware,
+  shippingOptionMiddleware,
+  dataSourceShippingOptionMiddleware,
+  attributeBasedShippingOptionMiddleware,
+  paymentOptionMiddleware,
+  installmentOptionMiddleware,
+  shippingStepMiddleware
+];

package/redux/middlewares/pre-order/installment-option.ts

@@ -0,0 +1,36 @@
+import { Middleware } from '@reduxjs/toolkit';
+import { CheckoutResult, MiddlewareParams } from '../../../types';
+import { checkoutApi } from '../../../data/client/checkout';
+
+export const installmentOptionMiddleware: Middleware = ({
+  getState,
+  dispatch
+}: MiddlewareParams) => {
+  return (next) => (action) => {
+    const result: CheckoutResult = next(action);
+    const preOrder = result?.payload?.pre_order;
+
+    if (!preOrder) {
+      return result;
+    }
+
+    const { installmentOptions } = getState().checkout;
+    const { endpoints: apiEndpoints } = checkoutApi;
+
+    if (
+      !preOrder?.installment &&
+      preOrder?.payment_option?.payment_type !== 'saved_card' &&
+      installmentOptions.length > 0
+    ) {
+      const firstInstallmentOptionPk = installmentOptions[0]?.pk;
+
+      if (firstInstallmentOptionPk) {
+        dispatch(
+          apiEndpoints.setInstallmentOption.initiate(firstInstallmentOptionPk)
+        );
+      }
+    }
+
+    return result;
+  };
+};

package/redux/middlewares/pre-order/payment-option.ts

@@ -0,0 +1,28 @@
+import { Middleware } from '@reduxjs/toolkit';
+import { CheckoutResult, MiddlewareParams } from '../../../types';
+import { checkoutApi } from '../../../data/client/checkout';
+
+export const paymentOptionMiddleware: Middleware = ({
+  getState,
+  dispatch
+}: MiddlewareParams) => {
+  return (next) => (action) => {
+    const result: CheckoutResult = next(action);
+    const preOrder = result?.payload?.pre_order;
+
+    if (!preOrder) {
+      return result;
+    }
+
+    const { paymentOptions } = getState().checkout;
+    const { endpoints: apiEndpoints } = checkoutApi;
+
+    if (!preOrder?.payment_option && paymentOptions.length > 0) {
+      const firstPaymentOptionPk = paymentOptions[0]?.pk;
+
+      dispatch(apiEndpoints.setPaymentOption.initiate(firstPaymentOptionPk));
+    }
+
+    return result;
+  };
+};

package/redux/middlewares/pre-order/pre-order-validation.ts

@@ -0,0 +1,20 @@
+import { Middleware } from '@reduxjs/toolkit';
+import { CheckoutResult } from '../../../types';
+
+export const preOrderValidationMiddleware: Middleware = () => {
+  return (next) => (action) => {
+    const result: CheckoutResult = next(action);
+    const preOrder = result?.payload?.pre_order;
+
+    if (
+      !preOrder ||
+      ['guestLogin', 'getCheckoutLoyaltyBalance'].includes(
+        action?.meta?.arg?.endpointName
+      )
+    ) {
+      return result;
+    }
+
+    return result;
+  };
+};

package/redux/middlewares/pre-order/redirection.ts

@@ -0,0 +1,34 @@
+import { Middleware } from '@reduxjs/toolkit';
+import { MiddlewareParams } from '../../../types';
+import { checkoutApi } from '../../../data/client/checkout';
+
+export const redirectionMiddleware: Middleware = ({
+  dispatch
+}: MiddlewareParams) => {
+  return (next) => (action) => {
+    const result = next(action);
+    const preOrder = result?.payload?.pre_order;
+
+    if (!preOrder) {
+      return result;
+    }
+
+    if (preOrder?.is_redirected) {
+      const contextList = result?.payload?.context_list;
+
+      if (
+        contextList?.find(
+          (ctx) => ctx.page_name === 'RedirectionPaymentSelectedPage'
+        )
+      ) {
+        dispatch(
+          checkoutApi.endpoints.setPaymentOption.initiate(
+            preOrder.payment_option?.pk
+          )
+        );
+      }
+    }
+
+    return result;
+  };
+};

package/redux/middlewares/pre-order/set-pre-order.ts

@@ -0,0 +1,18 @@
+import { Middleware } from '@reduxjs/toolkit';
+import { MiddlewareParams } from '../../../types';
+import { setPreOrder } from '../../../redux/reducers/checkout';
+
+export const setPreOrderMiddleware: Middleware = ({
+  dispatch
+}: MiddlewareParams) => {
+  return (next) => (action) => {
+    const result = next(action);
+    const preOrder = result?.payload?.pre_order;
+
+    if (preOrder) {
+      dispatch(setPreOrder(preOrder));
+    }
+
+    return result;
+  };
+};

package/redux/middlewares/pre-order/shipping-option.ts

@@ -0,0 +1,38 @@
+import { Middleware } from '@reduxjs/toolkit';
+import { CheckoutResult, MiddlewareParams } from '../../../types';
+import { checkoutApi } from '../../../data/client/checkout';
+
+export const shippingOptionMiddleware: Middleware = ({
+  getState,
+  dispatch
+}: MiddlewareParams) => {
+  return (next) => (action) => {
+    const result: CheckoutResult = next(action);
+    const preOrder = result?.payload?.pre_order;
+
+    if (!preOrder) {
+      return result;
+    }
+
+    const { shippingOptions } = getState().checkout;
+    const { endpoints: apiEndpoints } = checkoutApi;
+
+    const hasShippingOptions = shippingOptions?.length > 0;
+
+    const isShippingOptionValid = preOrder?.shipping_option
+      ? shippingOptions.some((opt) => opt.pk === preOrder.shipping_option.pk)
+      : false;
+
+    if (hasShippingOptions && !isShippingOptionValid) {
+      const defaultShippingOption = shippingOptions[0]?.pk;
+
+      if (defaultShippingOption) {
+        dispatch(
+          apiEndpoints.setShippingOption.initiate(defaultShippingOption)
+        );
+      }
+    }
+
+    return result;
+  };
+};

package/redux/middlewares/pre-order/shipping-step.ts

@@ -0,0 +1,34 @@
+import { Middleware } from '@reduxjs/toolkit';
+import { CheckoutResult, MiddlewareParams } from '../../../types';
+import { setShippingStepCompleted } from '../../reducers/checkout';
+
+export const shippingStepMiddleware: Middleware = ({
+  getState,
+  dispatch
+}: MiddlewareParams) => {
+  return (next) => (action) => {
+    const result: CheckoutResult = next(action);
+    const preOrder = result?.payload?.pre_order;
+
+    if (!preOrder) {
+      return result;
+    }
+
+    const { addressList: addresses } = getState().checkout;
+
+    if (preOrder) {
+      const stepCompleted = [
+        preOrder.delivery_option?.delivery_option_type === 'retail_store'
+          ? true
+          : preOrder.shipping_address?.pk,
+        preOrder.billing_address?.pk,
+        preOrder.shipping_option?.pk,
+        addresses.length > 0
+      ].every(Boolean);
+
+      dispatch(setShippingStepCompleted(stepCompleted));
+    }
+
+    return result;
+  };
+};

package/types/commerce/checkout.ts

@@ -3,6 +3,7 @@ import { Basket } from './basket';
 import { RetailStore } from './misc';
 import { PaymentOption } from './order';
 import { Product } from './product';
+import { RootState, TypedDispatch } from 'redux/store';
 
 export enum CheckoutStep {
   Shipping = 'shipping',
@@ -185,3 +186,16 @@ export interface AttributeBasedShippingOption {
   attribute_key: string;
   [key: string]: any;
 }
+
+export interface CheckoutResult {
+  payload: {
+    errors?: Record<string, string[]>;
+    pre_order?: PreOrder;
+    context_list?: CheckoutContext[];
+  };
+}
+
+export interface MiddlewareParams {
+  getState: () => RootState;
+  dispatch: TypedDispatch;
+}

package/types/commerce/order.ts

@@ -114,7 +114,6 @@ export interface Order {
     pk: number;
     name: string;
     slug: string;
-    logo: string;
     [key: string]: any;
   };
 }

package/utils/app-fetch.ts

@@ -43,12 +43,12 @@ const appFetch = async <T>({
     const requestURL = `${decodeURIComponent(commerceUrl)}${url}`;
 
     init.headers = {
-      cookie: nextCookies.toString(),
       ...(init.headers ?? {}),
       ...(ServerVariables.globalHeaders ?? {}),
       'Accept-Language': currentLocale.apiValue,
       'x-currency': currency,
-      'x-forwarded-for': ip
+      'x-forwarded-for': ip,
+      cookie: nextCookies.toString()
     };
 
     init.next = {

package/utils/override-middleware.ts

@@ -0,0 +1,31 @@
+import { Middleware } from '@reduxjs/toolkit';
+
+export enum MiddlewareNames {
+  PreOrderValidationMiddleware = 'preOrderValidationMiddleware',
+  RedirectionMiddleware = 'redirectionMiddleware',
+  SetPreOrderMiddleware = 'setPreOrderMiddleware',
+  DeliveryOptionMiddleware = 'deliveryOptionMiddleware',
+  SetAddressMiddleware = 'setAddressMiddleware',
+  ShippingOptionMiddleware = 'shippingOptionMiddleware',
+  DataSourceShippingOptionMiddleware = 'dataSourceShippingOptionMiddleware',
+  AttributeBasedShippingOptionMiddleware = 'attributeBasedShippingOptionMiddleware',
+  PaymentOptionMiddleware = 'paymentOptionMiddleware',
+  InstallmentOptionMiddleware = 'installmentOptionMiddleware',
+  ShippingStepMiddleware = 'shippingStepMiddleware'
+}
+
+export const overrideMiddleware = (
+  middlewares: Middleware[],
+  updates: { name: MiddlewareNames; middleware: Middleware }[]
+): void => {
+  const updatesMap = new Map(
+    updates.map(({ name, middleware }) => [name, middleware])
+  );
+
+  middlewares.forEach((mw, index) => {
+    const updatedMiddleware = updatesMap.get(mw.name as MiddlewareNames);
+    if (updatedMiddleware) {
+      middlewares[index] = updatedMiddleware;
+    }
+  });
+};

package/with-pz-config.js

@@ -64,7 +64,7 @@ const defaultConfig = {
   },
   sentry: {
     hideSourceMaps: true
-  } // TODO: This section will be reviewed again in the Sentry 8 update.
+  }
 };
 
 const withPzConfig = (

package/data/server/basket.ts

@@ -1,72 +0,0 @@
-import { Cache, CacheKey } from '../../lib/cache';
-import { basket } from '../../data/urls';
-import { Basket } from '../../types';
-import appFetch from '../../utils/app-fetch';
-import { ServerVariables } from '../../utils/server-variables';
-import logger from '../../utils/log';
-
-type GetBasketParams = {
-  locale?: string;
-  currency?: string;
-  namespace?: string;
-};
-
-const getBasketDataHandler = ({
-  locale,
-  currency,
-  namespace
-}: GetBasketParams) => {
-  return async function () {
-    try {
-      const url = namespace
-        ? basket.getBasketDetail(namespace)
-        : basket.getBasket;
-
-      const basketData = await appFetch<{ basket: Basket }>({
-        url,
-        locale,
-        currency,
-        init: {
-          headers: {
-            Accept: 'application/json',
-            'Content-Type': 'application/json'
-          }
-        }
-      });
-
-      if (!basketData?.basket) {
-        logger.warn('Basket data is undefined', {
-          handler: 'getBasketDataHandler',
-          namespace
-        });
-      }
-
-      return basketData;
-    } catch (error) {
-      logger.error('Error fetching basket data', {
-        handler: 'getBasketDataHandler',
-        error,
-        namespace
-      });
-      throw error;
-    }
-  };
-};
-
-export const getBasketData = async ({
-  locale = ServerVariables.locale,
-  currency = ServerVariables.currency,
-  namespace
-}: GetBasketParams = {}) => {
-  return Cache.wrap(
-    CacheKey.Basket(namespace),
-    locale,
-    getBasketDataHandler({ locale, currency, namespace }),
-    {
-      expire: 0,
-      cache: false
-    }
-  );
-};
-
-