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

package/redux/middlewares/checkout.ts

@@ -16,12 +16,11 @@ import {
   setLoyaltyBalance,
   setPaymentChoices,
   setPaymentOptions,
-  setPreOrder,
   setRetailStores,
   setShippingOptions,
-  setShippingStepCompleted,
   setHepsipayAvailability,
-  setWalletPaymentData
+  setWalletPaymentData,
+  setPayOnDeliveryOtpModalActive
 } from '../../redux/reducers/checkout';
 import { RootState, TypedDispatch } from 'redux/store';
 import { checkoutApi } from '../../data/client/checkout';
@@ -58,153 +57,14 @@ export const errorMiddleware: Middleware = ({ dispatch }: MiddlewareParams) => {
   };
 };
 
-export const preOrderMiddleware: Middleware = ({
-  getState,
-  dispatch
-}: MiddlewareParams) => {
-  return (next) => (action) => {
-    const result: CheckoutResult = next(action);
-    const preOrder = result?.payload?.pre_order;
-
-    if (
-      !preOrder ||
-      action?.meta?.arg?.endpointName === 'guestLogin' ||
-      action?.meta?.arg?.endpointName === 'getCheckoutLoyaltyBalance'
-    ) {
-      return result;
-    }
-
-    const {
-      deliveryOptions,
-      addressList: addresses,
-      shippingOptions,
-      dataSourceShippingOptions,
-      paymentOptions,
-      installmentOptions,
-      attributeBasedShippingOptions
-    } = getState().checkout;
-    const { endpoints: apiEndpoints } = checkoutApi;
-
-    if (preOrder.is_redirected) {
-      const contextList = result?.payload?.context_list;
-
-      if (
-        contextList.find(
-          (ctx) => ctx.page_name === 'RedirectionPaymentSelectedPage'
-        )
-      ) {
-        dispatch(
-          apiEndpoints.setPaymentOption.initiate(preOrder.payment_option?.pk)
-        );
-        return;
-      }
-    }
-
-    dispatch(setPreOrder(preOrder));
-
-    if (!preOrder.delivery_option && deliveryOptions.length > 0) {
-      dispatch(
-        apiEndpoints.setDeliveryOption.initiate(
-          deliveryOptions.find((opt) => opt.delivery_option_type === 'customer')
-            ?.pk
-        )
-      );
-    }
-
-    if (
-      (!preOrder.shipping_address || !preOrder.billing_address) &&
-      addresses.length > 0 &&
-      (!preOrder.delivery_option ||
-        preOrder.delivery_option.delivery_option_type === 'customer')
-    ) {
-      dispatch(
-        apiEndpoints.setAddresses.initiate({
-          shippingAddressPk: addresses[0].pk,
-          billingAddressPk: addresses[0].pk
-        })
-      );
-    }
-
-    if (
-      shippingOptions.length > 0 &&
-      (!preOrder.shipping_option ||
-        !shippingOptions.find((opt) => opt.pk === preOrder.shipping_option?.pk))
-    ) {
-      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 (
-      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
-        )
-      );
-    }
-
-    if (!preOrder.payment_option && paymentOptions.length > 0) {
-      dispatch(apiEndpoints.setPaymentOption.initiate(paymentOptions[0].pk));
-    }
-
-    if (
-      !preOrder.installment &&
-      preOrder.payment_option?.payment_type !== 'saved_card' &&
-      installmentOptions.length > 0
-    ) {
-      dispatch(
-        apiEndpoints.setInstallmentOption.initiate(installmentOptions[0].pk)
-      );
-    }
-
-    dispatch(
-      setShippingStepCompleted(
-        [
-          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)
-      )
-    );
-
-    return result;
-  };
-};
-
 export const contextListMiddleware: Middleware = ({
   dispatch,
   getState
 }: MiddlewareParams) => {
   return (next) => (action) => {
-    const { isMobileApp } = getState().root;
+    const { isMobileApp, userPhoneNumber } = getState().root;
     const result: CheckoutResult = next(action);
+    const preOrder = result?.payload?.pre_order;
 
     if (result?.payload?.context_list) {
       result.payload.context_list.forEach((context) => {
@@ -323,6 +183,18 @@ export const contextListMiddleware: Middleware = ({
         if (context.page_context.retail_stores) {
           dispatch(setRetailStores(context.page_context.retail_stores));
         }
+
+        if (context.page_name === 'SendSmsPage' && !preOrder?.phone_number) {
+          dispatch(
+            checkoutApi.endpoints.sendSms.initiate({
+              phone_number: userPhoneNumber ?? preOrder?.user_phone_number
+            })
+          );
+        }
+
+        if (context.page_name === 'VerifySmsPage') {
+          dispatch(setPayOnDeliveryOtpModalActive(true));
+        }
       });
     }
 

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,50 @@
+import { Middleware } from '@reduxjs/toolkit';
+import { CheckoutResult, MiddlewareParams } from '../../../types';
+import { checkoutApi } from '../../../data/client/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 null;
+    }
+
+    return result;
+  };
+};
+
+Object.defineProperty(setAddressMiddleware, 'name', {
+  value: 'setAddressMiddleware'
+});

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

@@ -0,0 +1,46 @@
+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 null;
+    }
+
+    return result;
+  };
+};
+
+Object.defineProperty(attributeBasedShippingOptionMiddleware, 'name', {
+  value: 'attributeBasedShippingOptionMiddleware'
+});

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

@@ -0,0 +1,43 @@
+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 null;
+      }
+    }
+
+    return result;
+  };
+};
+
+Object.defineProperty(dataSourceShippingOptionMiddleware, 'name', {
+  value: 'dataSourceShippingOptionMiddleware'
+});

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

@@ -0,0 +1,40 @@
+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 null;
+      }
+    }
+
+    return result;
+  };
+};
+
+Object.defineProperty(deliveryOptionMiddleware, 'name', {
+  value: 'deliveryOptionMiddleware'
+});

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

@@ -0,0 +1,29 @@
+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';
+
+// ⚠️ WARNING: Redux Toolkit applies middlewares in reverse order (from last to first).
+// This list is written **in reverse execution order** to ensure they run in the correct sequence.  
+// If you add a new middleware, make sure to insert it **in reverse order** based on execution priority.
+
+export const preOrderMiddlewares = [
+  shippingStepMiddleware,
+  installmentOptionMiddleware,
+  paymentOptionMiddleware,
+  attributeBasedShippingOptionMiddleware,
+  dataSourceShippingOptionMiddleware,
+  shippingOptionMiddleware,
+  setAddressMiddleware,
+  deliveryOptionMiddleware,
+  setPreOrderMiddleware,
+  redirectionMiddleware,
+  preOrderValidationMiddleware
+];

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

@@ -0,0 +1,42 @@
+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 null;
+      }
+    }
+
+    return result;
+  };
+};
+
+Object.defineProperty(installmentOptionMiddleware, 'name', {
+  value: 'installmentOptionMiddleware'
+});

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

@@ -0,0 +1,34 @@
+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 null;
+    }
+
+    return result;
+  };
+};
+
+Object.defineProperty(paymentOptionMiddleware, 'name', {
+  value: 'paymentOptionMiddleware'
+});

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

@@ -0,0 +1,24 @@
+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;
+  };
+};
+
+Object.defineProperty(preOrderValidationMiddleware, 'name', {
+  value: 'preOrderValidationMiddleware'
+});

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

@@ -0,0 +1,40 @@
+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 null;
+      }
+    }
+
+    return result;
+  };
+};
+
+Object.defineProperty(redirectionMiddleware, 'name', {
+  value: 'redirectionMiddleware'
+});

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

@@ -0,0 +1,22 @@
+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;
+  };
+};
+
+Object.defineProperty(setPreOrderMiddleware, 'name', {
+  value: 'setPreOrderMiddleware'
+});

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

@@ -0,0 +1,44 @@
+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 null;
+      }
+    }
+
+    return result;
+  };
+};
+
+Object.defineProperty(shippingOptionMiddleware, 'name', {
+  value: 'shippingOptionMiddleware'
+});

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

@@ -0,0 +1,38 @@
+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;
+  };
+};
+
+Object.defineProperty(shippingStepMiddleware, 'name', {
+  value: 'shippingStepMiddleware'
+});