@akinon/next 1.76.0-rc.0 → 1.76.0-rc.1

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @akinon/next
 
+## 1.76.0-rc.1
+
+### Minor Changes
+
+- 5dfeea04: ZERO-2801: Revert ZERO-2801
+- 2d9b2b2c: ZERO-2816: Add segment to headers
+- f49bb74f: ZERO-3097: Add setCookie to logging in payment redirection middlewares
+- e9541a13: ZERO-2816: Add headers to url
+- 4d3deb4f: ZERO-2935: sentry 8 upgrade
+- 72fd4d67: ZERO-3084: Fix URL search parameters encoding in default middleware
+- c53ef7b9: ZERO-2668: The Link component has been updated to improve the logic for handling href values. Previously, if the href was not a string or started with 'http', it would return the href as is. Now, if the href is not provided, it will default to '#' to prevent any potential errors. Additionally, if the href is a string and does not start with 'http', it will be formatted with the locale and pathname, based on the localeUrlStrategy and defaultLocaleValue. This ensures that the correct href is generated based on the localization settings.
+- 64699d3f: ZERO-2761: Fix invalid import for plugin module
+- 999168d6: ZERO-3104: Remove local cache handler from CacheHandler initialization
+- 7727ae55: ZERO-3073: Refactor basket page to use server-side data fetching and simplify component structure
+- 17f87524: ZERO-2816: Make the incoming currency lowercase
+- 65d3b862: ZERO-3054: Update headers in appFetch
+- bbe18b9f: ZERO-2575: Fix build error
+- 4920742c: Disable getCachedTranslations
+- 7e56d6b6: ZERO-2841: Update api tagTypes
+- 43c182ee: ZERO-3054: Update Redis variable checks to conditionally include CACHE_SECRET
+- 2d305aaf: ZERO-2935: Update Sentry configuration: remove hideSourceMaps option and add it to withPzConfig
+- eeb20bea: Revert "ZERO-3054: Refactor cache handler to use custom Redis handler and implement key hashing"
+- f2c92d5c: ZERO-2816: Update cookie name
+- 7bd3d992: ZERO-2801: Refactor locale middleware to handle single locale configuration
+- fdd255ee: ZERO-3054: Refactor cache handler to use custom Redis handler and implement key hashing
+- 86a5a620: ZERO-3104: Add optional headers parameter to data fetching functions
+- dd69cc63: ZERO-3079: Modularize pre-order middleware
+- 49eeebfa: ZERO-2909: Add deleteCollectionItem query to wishlistApi
+- 3f9b8d7e: ZERO-2761: Update plugins.js for akinon-next
+
 ## 1.76.0-rc.0
 
 ### Minor Changes

package/package.json

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

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

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