@akinon/next 2.0.0-beta.1 → 2.0.0-beta.3

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @akinon/next
 
+## 2.0.0-beta.3
+
+### Minor Changes
+
+- 5536b80: ZERO-3104: Add optional headers parameter
+
+## 2.0.0-beta.2
+
+### Minor Changes
+
+- a006015: ZERO-3116: Add not-found page and update default middleware.
+- 999168d: ZERO-3104: Remove local cache handler from CacheHandler initialization
+- 1eeb3d8: ZERO-3116: Add not found page
+- 86a5a62: ZERO-3104: Add optional headers parameter to data fetching functions
+- dd69cc6: ZERO-3079: Modularize pre-order middleware
+
 ## 2.0.0-beta.1
 
 ### Minor Changes

package/components/selected-payment-option-view.tsx

@@ -4,7 +4,7 @@ import { RootState } from 'redux/store';
 import { useAppSelector } from '../redux/hooks';
 import dynamic, { DynamicOptionsLoadingProps } from 'next/dynamic';
 import { PaymentOptionViews } from 'views/checkout/steps/payment';
-import { useMemo } from 'react';
+import { JSX, useMemo } from 'react';
 
 const fallbackView = () => <></>;
 

package/data/server/flatpage.ts

@@ -7,7 +7,8 @@ import { ServerVariables } from '../../utils/server-variables';
 const getFlatPageDataHandler = (
   pk: number,
   locale: string,
-  currency: string
+  currency: string,
+  headers?: Record<string, string>
 ) => {
   return async function () {
     const data = await appFetch<FlatPage>({
@@ -17,7 +18,8 @@ const getFlatPageDataHandler = (
       init: {
         headers: {
           Accept: 'application/json',
-          'Content-Type': 'application/json'
+          'Content-Type': 'application/json',
+          ...(headers ?? {})
         }
       }
     });
@@ -29,15 +31,17 @@ const getFlatPageDataHandler = (
 export const getFlatPageData = ({
   pk,
   locale = ServerVariables.locale,
-  currency = ServerVariables.currency
+  currency = ServerVariables.currency,
+  headers
 }: {
   pk: number;
   locale?: string;
   currency?: string;
+  headers?: Record<string, string>;
 }) => {
   return Cache.wrap(
     CacheKey.FlatPage(pk),
     locale,
-    getFlatPageDataHandler(pk, locale, currency)
+    getFlatPageDataHandler(pk, locale, currency, headers)
   );
 };

package/data/server/form.ts

@@ -5,7 +5,12 @@ import appFetch from '../../utils/app-fetch';
 import { ServerVariables } from '../../utils/server-variables';
 import { form } from '../urls';
 
-const getFormDataHandler = (pk: number, locale: string, currency: string) => {
+const getFormDataHandler = (
+  pk: number,
+  locale: string,
+  currency: string,
+  headers?: Record<string, string>
+) => {
   return async function () {
     const data = await appFetch<FormType>({
       url: form.getForm(pk),
@@ -14,7 +19,8 @@ const getFormDataHandler = (pk: number, locale: string, currency: string) => {
       init: {
         headers: {
           Accept: 'application/json',
-          'Content-Type': 'application/json'
+          'Content-Type': 'application/json',
+          ...(headers ?? {})
         }
       }
     });
@@ -26,15 +32,17 @@ const getFormDataHandler = (pk: number, locale: string, currency: string) => {
 export const getFormData = ({
   pk,
   locale = ServerVariables.locale,
-  currency = ServerVariables.currency
+  currency = ServerVariables.currency,
+  headers
 }: {
   pk: number;
   locale?: string;
   currency?: string;
+  headers?: Record<string, string>;
 }) => {
   return Cache.wrap(
     CacheKey.Form(pk),
     locale,
-    getFormDataHandler(pk, locale, currency)
+    getFormDataHandler(pk, locale, currency, headers)
   );
 };

package/data/server/landingpage.ts

@@ -7,7 +7,8 @@ import { ServerVariables } from '../../utils/server-variables';
 const getLandingPageHandler = (
   pk: number,
   locale: string,
-  currency: string
+  currency: string,
+  headers?: Record<string, string>
 ) => {
   return async function () {
     const data = await appFetch<LandingPage>({
@@ -17,7 +18,8 @@ const getLandingPageHandler = (
       init: {
         headers: {
           Accept: 'application/json',
-          'Content-Type': 'application/json'
+          'Content-Type': 'application/json',
+          ...(headers ?? {})
         }
       }
     });
@@ -29,15 +31,17 @@ const getLandingPageHandler = (
 export const getLandingPageData = ({
   pk,
   locale = ServerVariables.locale,
-  currency = ServerVariables.currency
+  currency = ServerVariables.currency,
+  headers
 }: {
   pk: number;
   locale?: string;
   currency?: string;
+  headers?: Record<string, string>;
 }) => {
   return Cache.wrap(
     CacheKey.LandingPage(pk),
     locale,
-    getLandingPageHandler(pk, locale, currency)
+    getLandingPageHandler(pk, locale, currency, headers)
   );
 };

package/data/server/menu.ts

@@ -13,6 +13,7 @@ interface MenuHandlerParams {
   currency?: string;
   depth?: number;
   parent?: string;
+  headers?: Record<string, string>;
 }
 
 const DEFAULT_DEPTH = 3;
@@ -22,13 +23,17 @@ const getMenuHandler =
     locale = ServerVariables.locale,
     currency = ServerVariables.currency,
     depth,
-    parent
+    parent,
+    headers
   }: MenuHandlerParams = {}) =>
   async () => {
     const response = await appFetch<MenuResponse>({
       url: misc.menus(depth ?? DEFAULT_DEPTH, parent),
       locale,
-      currency
+      currency,
+      init: {
+        headers
+      }
     });
 
     return response?.menu;

package/data/server/product.ts

@@ -11,6 +11,7 @@ type GetProduct = {
   currency?: string;
   searchParams?: URLSearchParams;
   groupProduct?: boolean;
+  headers?: Record<string, string>;
 };
 
 const getProductDataHandler = ({
@@ -18,7 +19,8 @@ const getProductDataHandler = ({
   locale,
   currency,
   searchParams,
-  groupProduct
+  groupProduct,
+  headers
 }: GetProduct) => {
   return async function () {
     let url = groupProduct
@@ -40,7 +42,8 @@ const getProductDataHandler = ({
       init: {
         headers: {
           Accept: 'application/json',
-          'Content-Type': 'application/json'
+          'Content-Type': 'application/json',
+          ...(headers ?? {})
         }
       }
     });
@@ -95,7 +98,8 @@ export const getProductData = async ({
   locale = ServerVariables.locale,
   currency = ServerVariables.currency,
   searchParams,
-  groupProduct
+  groupProduct,
+  headers
 }: GetProduct) => {
   return Cache.wrap(
     CacheKey[groupProduct ? 'GroupProduct' : 'Product'](
@@ -103,7 +107,14 @@ export const getProductData = async ({
       searchParams ?? new URLSearchParams()
     ),
     locale,
-    getProductDataHandler({ pk, locale, currency, searchParams, groupProduct }),
+    getProductDataHandler({
+      pk,
+      locale,
+      currency,
+      searchParams,
+      groupProduct,
+      headers
+    }),
     {
       expire: 300
     }

package/data/server/seo.ts

@@ -7,9 +7,10 @@ interface SeoDataParams {
   url: string;
   locale?: string;
   currency?: string;
+  headers?: Record<string, string>;
 }
 
-function getSeoDataHandler({ url, locale, currency }: SeoDataParams) {
+function getSeoDataHandler({ url, locale, currency, headers }: SeoDataParams) {
   return async function () {
     let data = {} as {
       title: string;
@@ -19,7 +20,12 @@ function getSeoDataHandler({ url, locale, currency }: SeoDataParams) {
     };
 
     try {
-      data = await appFetch({ url: misc.cmsSeo(url), locale, currency });
+      data = await appFetch({
+        url: misc.cmsSeo(url),
+        locale,
+        currency,
+        init: { headers }
+      });
     } catch (error) {
       // logger.error('Error while fetching seo data', { url, error });
     }
@@ -31,11 +37,12 @@ function getSeoDataHandler({ url, locale, currency }: SeoDataParams) {
 export const getSeoData = async (
   url,
   locale = ServerVariables.locale,
-  currency = ServerVariables.currency
+  currency = ServerVariables.currency,
+  headers?: Record<string, string>
 ) => {
   return Cache.wrap(
     CacheKey.Seo(url),
     locale,
-    getSeoDataHandler({ url, locale, currency })
+    getSeoDataHandler({ url, locale, currency, headers })
   );
 };

package/data/server/widget.ts

@@ -6,29 +6,44 @@ import { widgets } from '../urls';
 import { ServerVariables } from '../../utils/server-variables';
 
 const getWidgetDataHandler =
-  (slug: string, locale: string, currency: string) => async () => {
+  (
+    slug: string,
+    locale: string,
+    currency: string,
+    headers?: Record<string, string>
+  ) =>
+  async () => {
     if (!slug) {
       return null;
     }
 
-    return await appFetch({ url: widgets.getWidget(slug), locale, currency });
+    return await appFetch({
+      url: widgets.getWidget(slug),
+      locale,
+      currency,
+      init: {
+        headers
+      }
+    });
   };
 
 export const getWidgetData = async <T>({
   slug,
   locale = ServerVariables.locale,
   currency = ServerVariables.currency,
-  cacheOptions
+  cacheOptions,
+  headers
 }: {
   slug: string;
   locale?: string;
   currency?: string;
   cacheOptions?: CacheOptions;
+  headers?: Record<string, string>;
 }): Promise<WidgetResultType<T>> => {
   return Cache.wrap(
     CacheKey.Widget(slug),
     locale,
-    getWidgetDataHandler(slug, locale, currency),
+    getWidgetDataHandler(slug, locale, currency, headers),
     cacheOptions
   );
 };

package/lib/cache-handler.mjs

@@ -23,10 +23,10 @@ CacheHandler.onCreation(async () => {
     timeoutMs: 5000
   });
 
-  const localHandler = createLruHandler();
+  // const localHandler = createLruHandler();
 
   return {
-    handlers: [redisHandler, localHandler]
+    handlers: [redisHandler]
   };
 });
 

package/middlewares/default.ts

@@ -288,19 +288,6 @@ const withPzDefault =
                                   `searchparams|${url.searchParams.toString()}`;
                               }
 
-                              if (
-                                !req.middlewareParams.found &&
-                                Settings.customNotFoundEnabled
-                              ) {
-                                let pathname = url.pathname
-                                  .replace(/\/+$/, '')
-                                  .split('/');
-                                url.pathname = url.pathname.replace(
-                                  pathname.pop(),
-                                  'pz-not-found'
-                                );
-                              }
-
                               Settings.rewrites.forEach((rewrite) => {
                                 url.pathname = url.pathname.replace(
                                   rewrite.source,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@akinon/next",
   "description": "Core package for Project Zero Next",
-  "version": "2.0.0-beta.1",
+  "version": "2.0.0-beta.3",
   "private": false,
   "license": "MIT",
   "bin": {
@@ -30,7 +30,7 @@
     "set-cookie-parser": "2.6.0"
   },
   "devDependencies": {
-    "@akinon/eslint-plugin-projectzero": "2.0.0-beta.1",
+    "@akinon/eslint-plugin-projectzero": "2.0.0-beta.3",
     "@types/react-redux": "7.1.30",
     "@types/set-cookie-parser": "2.4.7",
     "@typescript-eslint/eslint-plugin": "8.18.2",

package/redux/middlewares/index.ts

@@ -6,10 +6,12 @@ import type { Middleware } from '@reduxjs/toolkit';
 import {
   errorMiddleware,
   contextListMiddleware,
-  preOrderMiddleware,
   hepsiPayMiddleware,
   walletPaymentMiddleware
 } from './checkout';
+
+import { preOrderMiddlewares } from './pre-order';
+
 import { api } from '../../data/client/api';
 import logger from '@akinon/next/utils/log';
 
@@ -48,7 +50,7 @@ const middlewares = [
   rtkQueryResponseHandler,
   rtkQueryErrorHandler,
   errorMiddleware,
-  preOrderMiddleware,
+  ...preOrderMiddlewares,
   contextListMiddleware,
   hepsiPayMiddleware,
   walletPaymentMiddleware,

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

@@ -0,0 +1,45 @@
+import { Middleware } from '@reduxjs/toolkit';
+import { CheckoutResult, MiddlewareParams } from '../../../types';
+import { checkoutApi } from '../../../data/client/checkout';
+import { setPreOrder } from '../../../redux/reducers/checkout';
+
+export const setAddressMiddleware: 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;
+    const { endpoints: apiEndpoints } = checkoutApi;
+
+    const hasNoAddresses =
+      !preOrder?.shipping_address || !preOrder?.billing_address;
+    const isCustomerDelivery =
+      !preOrder?.delivery_option ||
+      preOrder.delivery_option.delivery_option_type === 'customer';
+
+    const firstAddressPk = addresses?.[0]?.pk;
+
+    if (
+      hasNoAddresses &&
+      addresses?.length > 0 &&
+      isCustomerDelivery &&
+      firstAddressPk
+    ) {
+      dispatch(
+        apiEndpoints.setAddresses.initiate({
+          shippingAddressPk: firstAddressPk,
+          billingAddressPk: firstAddressPk
+        })
+      );
+    }
+
+    return result;
+  };
+};

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

@@ -0,0 +1,40 @@
+import { Middleware } from '@reduxjs/toolkit';
+import { CheckoutResult, MiddlewareParams } from '../../../types';
+import { checkoutApi } from '../../../data/client/checkout';
+
+export const attributeBasedShippingOptionMiddleware: Middleware = ({
+  getState,
+  dispatch
+}: MiddlewareParams) => {
+  return (next) => (action) => {
+    const result: CheckoutResult = next(action);
+    const preOrder = result?.payload?.pre_order;
+
+    if (!preOrder) {
+      return result;
+    }
+
+    const { attributeBasedShippingOptions } = getState().checkout;
+    const { endpoints: apiEndpoints } = checkoutApi;
+
+    if (
+      Object.keys(attributeBasedShippingOptions).length > 0 &&
+      !preOrder.attribute_based_shipping_options
+    ) {
+      const initialSelectedOptions: Record<string, number> = Object.fromEntries(
+        Object.entries(attributeBasedShippingOptions).map(([key, options]) => [
+          key,
+          options.attribute_based_shipping_options[0].pk
+        ])
+      );
+
+      dispatch(
+        apiEndpoints.setAttributeBasedShippingOptions.initiate(
+          initialSelectedOptions
+        )
+      );
+    }
+
+    return result;
+  };
+};

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

@@ -0,0 +1,37 @@
+import { Middleware } from '@reduxjs/toolkit';
+import { CheckoutResult, MiddlewareParams } from '../../../types';
+import { checkoutApi } from '../../../data/client/checkout';
+
+export const dataSourceShippingOptionMiddleware: Middleware = ({
+  getState,
+  dispatch
+}: MiddlewareParams) => {
+  return (next) => (action) => {
+    const result: CheckoutResult = next(action);
+    const preOrder = result?.payload?.pre_order;
+
+    if (!preOrder) {
+      return result;
+    }
+
+    const { dataSourceShippingOptions } = getState().checkout;
+    const { endpoints: apiEndpoints } = checkoutApi;
+
+    if (
+      dataSourceShippingOptions?.length > 0 &&
+      !preOrder?.data_source_shipping_options
+    ) {
+      const selectedPks = dataSourceShippingOptions
+        .map((opt) => opt.data_source_shipping_options?.[0]?.pk)
+        .filter((pk) => pk);
+
+      if (selectedPks.length > 0) {
+        dispatch(
+          apiEndpoints.setDataSourceShippingOptions.initiate(selectedPks)
+        );
+      }
+    }
+
+    return result;
+  };
+};

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

@@ -4,6 +4,7 @@ import { RetailStore } from './misc';
 import { PaymentOption } from './order';
 import { Product } from './product';
 import { JSX } from 'react';
+import { RootState, TypedDispatch } from 'redux/store';
 
 export enum CheckoutStep {
   Shipping = 'shipping',
@@ -186,3 +187,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/index.ts

@@ -199,7 +199,6 @@ export interface Settings {
     extraPaymentTypes?: string[];
     masterpassJsUrl?: string;
   };
-  customNotFoundEnabled: boolean;
   useOptimizedTranslations?: boolean;
   plugins?: Record<string, Record<string, any>>;
   includedProxyHeaders?: string[];

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;
+    }
+  });
+};