@ordergroove/offers 2.44.0 → 2.44.1-alpha-PR-1167-2.36

package/src/shopify/__tests__/utils.spec.js

@@ -1,4 +1,4 @@
-import { getPayAsYouGoSellingPlanGroups, money, percentage } from '../utils';
+import { getPayAsYouGoSellingPlanGroups, money, percentage, textToFreq } from '../utils';
 
 describe('Shopify Utils', () => {
   describe('Money', () => {
@@ -26,6 +26,29 @@ describe('Shopify Utils', () => {
       expect(formattedPrice).toBe('10%');
     });
   });
+
+  describe('textToFreq', () => {
+    it('textToFreq should return freq', () => {
+      expect(textToFreq('DAY')).toEqual('1_1');
+      expect(textToFreq('DAYS')).toEqual('1_1');
+      expect(textToFreq('DAYLY')).toEqual('1_1');
+      expect(textToFreq('1 DAY')).toEqual('1_1');
+      expect(textToFreq('2 DAYS')).toEqual('2_1');
+      expect(textToFreq('2 day(s)')).toEqual('2_1');
+
+      expect(textToFreq('week')).toEqual('1_2');
+      expect(textToFreq('weekly')).toEqual('1_2');
+      expect(textToFreq('1 week')).toEqual('1_2');
+      expect(textToFreq('2 weeks')).toEqual('2_2');
+      expect(textToFreq('2 week(s)')).toEqual('2_2');
+
+      expect(textToFreq('MONTH')).toEqual('1_3');
+      expect(textToFreq('MONTHLY')).toEqual('1_3');
+      expect(textToFreq('1 month')).toEqual('1_3');
+      expect(textToFreq('2 months')).toEqual('2_3');
+      expect(textToFreq('2 month(s)')).toEqual('2_3');
+    });
+  });
 });
 
 describe('selling plan queries', () => {

package/src/shopify/reducers/config.ts

@@ -0,0 +1,185 @@
+import * as constants from '../../core/constants';
+import { getFirstSellingPlan, isOgFrequency, mapFrequencyToSellingPlan, safeProductId } from '../../core/utils';
+import type {
+  ConfigState,
+  ReceiveMerchantSettingsPayload,
+  ReceiveOfferPayload,
+  SetupProductPayload
+} from '../../core/types/reducer';
+
+import {
+  getPayAsYouGoSellingPlanGroup,
+  sellingPlansToEveryPeriod,
+  sellingPlansToFrequencies,
+  getPrepaidShipments
+} from '../utils';
+import { ShopifySellingPlanGroupsEntity, ShopifyVariantsEntity } from '../types/shopify';
+
+const config = (
+  state: ConfigState = {
+    offerType: 'radio',
+    productFrequencies: {}
+  },
+  action
+): ConfigState => {
+  if (constants.SETUP_PRODUCT === action.type) {
+    const {
+      payload: { product, currency }
+    } = action as { payload: SetupProductPayload };
+    let configToAdd: ConfigState = {};
+    let productFrequencies = product.variants?.reduce(
+      (acc, variant) => reduceSellingPlansToFrequencies(acc, variant, product.selling_plan_groups, state),
+      {}
+    );
+
+    configToAdd = {
+      ...configToAdd,
+
+      productFrequencies: {
+        ...state.productFrequencies,
+        ...productFrequencies
+      }
+    };
+
+    // prepaid selling plans
+    const prepaidSellingPlanGroups = product?.selling_plan_groups.filter(group => /^Prepaid-.*/.test(group.name));
+    if (prepaidSellingPlanGroups.length) {
+      configToAdd = {
+        ...configToAdd,
+        prepaidSellingPlans: { ...state.prepaidSellingPlans, ...getPrepaidSellingPlans(prepaidSellingPlanGroups) }
+      };
+    }
+    return {
+      ...state,
+      ...configToAdd,
+      storeCurrency: currency
+    };
+  }
+
+  if (constants.RECEIVE_OFFER === action.type) {
+    const {
+      payload: { offer: offerEl }
+    } = action as { payload: ReceiveOfferPayload };
+    const { defaultFrequency, product } = offerEl || {};
+    const { prepaidSellingPlans = {} } = state;
+
+    // productFrequencies does not have entries for the cart ID
+    // eligible frequencies apply to cart entries for the product
+    const productId = safeProductId(product?.id);
+    const currentProductFrequencies = state.productFrequencies[productId];
+
+    return {
+      ...state,
+      productFrequencies: {
+        ...state.productFrequencies,
+        [productId]: {
+          ...currentProductFrequencies,
+          defaultFrequency: getUpdatedDefaultFrequency(
+            productId,
+            defaultFrequency,
+            prepaidSellingPlans,
+            currentProductFrequencies?.frequencies,
+            currentProductFrequencies?.frequenciesEveryPeriod
+          )
+        }
+      }
+    };
+  }
+
+  if (constants.RECEIVE_MERCHANT_SETTINGS === action.type) {
+    return {
+      ...state,
+      merchantSettings: {
+        ...(action.payload as ReceiveMerchantSettingsPayload)
+      }
+    };
+  }
+
+  return state;
+};
+
+function getFrequencies(
+  productSellingPlanGroups: ShopifySellingPlanGroupsEntity[],
+  state: { defaultFrequency?: string }
+) {
+  const sellingPlanGroup = getPayAsYouGoSellingPlanGroup(productSellingPlanGroups);
+  const frequencies = sellingPlansToFrequencies(sellingPlanGroup);
+  if (frequencies?.length) {
+    const frequenciesEveryPeriod = sellingPlansToEveryPeriod(sellingPlanGroup);
+    const frequenciesText = sellingPlanGroup.options?.[0]?.values || frequencies;
+    let defaultFrequency = state?.defaultFrequency;
+
+    if (defaultFrequency && isOgFrequency(defaultFrequency)) {
+      defaultFrequency =
+        mapFrequencyToSellingPlan(frequencies, frequenciesEveryPeriod, defaultFrequency) ||
+        getFirstSellingPlan(frequencies) ||
+        defaultFrequency;
+    }
+    return {
+      frequencies,
+      frequenciesEveryPeriod,
+      frequenciesText,
+      ...(defaultFrequency ? { defaultFrequency } : {})
+    };
+  }
+  return null;
+}
+
+function reduceSellingPlansToFrequencies(
+  acc: ConfigState['productFrequencies'],
+  variant: ShopifyVariantsEntity,
+  sellingPlanGroups: ShopifySellingPlanGroupsEntity[],
+  state: ConfigState
+) {
+  const sellingPlanGroupIdsForProduct = variant.selling_plan_allocations.map(
+    allocation => allocation.selling_plan_group_id
+  );
+  const applicableSellingPlanGroups = sellingPlanGroups.filter(group =>
+    sellingPlanGroupIdsForProduct.includes(group.id)
+  );
+  const frequencies = getFrequencies(applicableSellingPlanGroups, state.productFrequencies[variant.id]);
+  if (frequencies) {
+    acc[variant.id] = frequencies;
+  }
+  return acc;
+}
+
+function getUpdatedDefaultFrequency(
+  productId: string,
+  offerElementDefaultFrequency: string,
+  prepaidSellingPlans: ConfigState['prepaidSellingPlans'],
+  frequencies: string[] | undefined = [],
+  frequenciesEveryPeriod: string[] | undefined = []
+) {
+  // We don't want to be setting the default frequency to a prepaid selling plan
+  if (prepaidSellingPlans[productId]?.some(({ sellingPlan }) => sellingPlan === offerElementDefaultFrequency)) {
+    return getFirstSellingPlan(frequencies) || offerElementDefaultFrequency;
+  }
+
+  if (!isOgFrequency(offerElementDefaultFrequency)) {
+    return offerElementDefaultFrequency;
+  }
+
+  return (
+    mapFrequencyToSellingPlan(frequencies, frequenciesEveryPeriod, offerElementDefaultFrequency) ||
+    getFirstSellingPlan(frequencies) ||
+    offerElementDefaultFrequency
+  );
+}
+
+function getPrepaidSellingPlans(prepaidSellingPlanGroups) {
+  return prepaidSellingPlanGroups.reduce((acc, cur) => {
+    const variant = cur.name.split('-')[1];
+
+    const sellingPlanInfo = cur.selling_plans.map(sellingPlanObject => {
+      return {
+        numberShipments: getPrepaidShipments(sellingPlanObject),
+        sellingPlan: String(sellingPlanObject.id)
+      };
+    });
+
+    return { ...acc, [variant]: sellingPlanInfo };
+  }, {});
+}
+
+export default config;

package/src/shopify/shopifyMiddleware.ts

@@ -18,6 +18,7 @@ import { makeSubscribedSelector } from '../core/selectors';
 import { getOrCreateHidden, safeProductId } from '../core/utils';
 import { getTrackingKey } from './shopifyTrackingMiddleware';
 import { ShopifyCart, ShopifyProductEntity } from './types/shopify';
+import { SetupProductPayload, SetupCartPayload, OfferElement } from '../core/types/reducer';
 
 const SHOPIFY_ROOT = window.Shopify?.routes?.root || '/';
 const CART_PAGE_URL = '/cart';
@@ -25,14 +26,6 @@ const CART_JS_URL = `${SHOPIFY_ROOT}cart.js`;
 const CART_CHANGE_URL = `${SHOPIFY_ROOT}cart/change.js`;
 const PRODUCTS_URL = `${SHOPIFY_ROOT}products/`;
 
-type SetupProductPayload = {
-  product: ShopifyProductEntity;
-  offer: any;
-  currency: string;
-};
-
-type SetupCartPayload = ShopifyCart;
-
 /**
  * List of section DOM elements to update via section-rendering api https://shopify.dev/api/section-rendering
  */
@@ -344,7 +337,7 @@ export function getSubscribedFrequency(productId, store) {
  *
  * @param store
  */
-function synchronizeSellingPlan(store: any, offerElement?: HTMLElement) {
+function synchronizeSellingPlan(store: any, offerElement?: OfferElement) {
   if (offerElement?.isCart) return; // hidden inputs are used when product page, not cart.
   if (!offerElement?.shouldEnableOffer) return; // do not set a selling plan if we're hiding the offer
 

package/src/shopify/{shopifyReducer.js → shopifyReducer.ts}

@@ -31,16 +31,26 @@ import {
   safeProductId,
   getMatchingProductIfExists
 } from '../core/utils';
-
-import { getObjectStructuredProductPlans } from '../core/adapters';
+import type {
+  AutoshipEligibleState,
+  OfferElement,
+  OptedInState,
+  OptInItem,
+  ReceiveOfferPayload,
+  SetupProductPayload
+} from '../core/types/reducer';
 
 import { sellingPlanAllocationsReducer, getSellingPlans } from './reducers/productPlans';
+import config from './reducers/config';
 import { experimentsReducer } from '../core/experiments';
 import {
   getPayAsYouGoSellingPlanGroup,
   getPayAsYouGoSellingPlanGroups,
-  isProductSpecificFrequencySellingPlanGroup
+  sellingPlansToEveryPeriod,
+  sellingPlansToFrequencies,
+  getPrepaidShipments
 } from './utils';
+import { EmptyObject } from '../core/types/utility';
 
 const overrideLineKey = (state, productId, newValue) => {
   const keys = Object.keys(state).filter(it => it.startsWith(productId.toString()));
@@ -50,7 +60,11 @@ const overrideLineKey = (state, productId, newValue) => {
   return state;
 };
 
-export const getDefaultSellingPlan = (sellingPlans, frequenciesEveryPeriod, defaultFrequency) => {
+export const getDefaultSellingPlan = (
+  sellingPlans: string[],
+  frequenciesEveryPeriod: string[],
+  defaultFrequency: string | undefined
+) => {
   if (!defaultFrequency) {
     return null;
   }
@@ -72,23 +86,27 @@ export const getDefaultSellingPlan = (sellingPlans, frequenciesEveryPeriod, defa
   return defaultFrequency;
 };
 
-export const mapExistingOptinsFromOfferResponse = (state, offerEl) =>
+export const mapExistingOptinsFromOfferResponse = (
+  state: OptedInState,
+  offerEl: OfferElement | EmptyObject,
+  frequencyConfig: ReceiveOfferPayload['frequencyConfig']
+) =>
   state.map(it => {
     if (isOgFrequency(it?.frequency)) {
       return {
         ...it,
-        frequency: hasShopifySellingPlans(offerEl?.config?.frequencies, offerEl?.config?.frequenciesEveryPeriod)
+        frequency: hasShopifySellingPlans(frequencyConfig?.frequencies, frequencyConfig?.frequenciesEveryPeriod)
           ? mapFrequencyToSellingPlan(
-              offerEl?.config?.frequencies,
-              offerEl?.config?.frequenciesEveryPeriod,
+              frequencyConfig?.frequencies,
+              frequencyConfig?.frequenciesEveryPeriod,
               it.frequency
             ) ||
             mapFrequencyToSellingPlan(
-              offerEl?.config?.frequencies,
-              offerEl?.config?.frequenciesEveryPeriod,
+              frequencyConfig?.frequencies,
+              frequencyConfig?.frequenciesEveryPeriod,
               offerEl?.defaultFrequency
             ) ||
-            getFirstSellingPlan(offerEl?.config?.frequencies)
+            getFirstSellingPlan(frequencyConfig?.frequencies)
           : it.frequency
       };
     }
@@ -97,14 +115,16 @@ export const mapExistingOptinsFromOfferResponse = (state, offerEl) =>
   });
 
 export const reduceNewOptinsFromOfferResponse = (
-  { autoship = {}, autoship_by_default = {}, default_frequencies = {}, in_stock = {} },
-  existingOptins,
-  offerEl
+  { autoship = {}, autoship_by_default = {}, default_frequencies = {}, in_stock = {} }: ReceiveOfferPayload,
+  existingOptins: OptedInState,
+  offerEl: OfferElement | EmptyObject,
+  frequencyConfig: ReceiveOfferPayload['frequencyConfig']
 ) =>
   Object.keys(autoship).reduce((acc, id) => {
     if (!existingOptins.some(it => it.id === id)) {
       if (!(autoship[id] && autoship_by_default[id] && in_stock[id])) return acc;
-      const { config: { frequencies: sellingPlans, frequenciesEveryPeriod } = {}, defaultFrequency } = offerEl || {};
+      const { frequencies: sellingPlans, frequenciesEveryPeriod } = frequencyConfig;
+      const { defaultFrequency } = offerEl || {};
       const psdf = default_frequencies[id];
       let frequency;
 
@@ -133,17 +153,12 @@ const productOrVariantInStockReducer = (acc, cur) => ({
   [cur.id]: cur.available
 });
 
-const productTrue = (acc, [id]) => ({ ...acc, [id]: true });
-
 const reduceProductCartLine = (acc, cur) => {
   const productId = safeProductId(cur.key);
   return { ...acc, [cur.key]: acc[productId] || null };
 };
 
-export const autoshipEligible = (state = {}, action) => {
-  if (constants.RECEIVE_PRODUCT_PLANS === action.type) {
-    return Object.entries(action.payload).reduce(productTrue, state);
-  }
+export const autoshipEligible = (state: AutoshipEligibleState = {}, action): AutoshipEligibleState => {
   if (constants.SETUP_CART === action.type) {
     const { payload: cart } = action;
     return cart.items.reduce(reduceProductCartLine, state);
@@ -151,14 +166,14 @@ export const autoshipEligible = (state = {}, action) => {
   if (constants.SETUP_PRODUCT === action.type) {
     const {
       payload: { product }
-    } = action;
+    } = action as { payload: SetupProductPayload };
     const applicableSellingPlanGroups = getPayAsYouGoSellingPlanGroups(product?.selling_plan_groups);
 
     const ogSellingPlanIds = new Set(
       applicableSellingPlanGroups.flatMap(group => group.selling_plans.map(sellingPlan => sellingPlan.id)) ?? []
     );
 
-    return [product, ...(product?.variants || [])]?.reduce((acc, cur) => {
+    return product.variants.reduce((acc, cur) => {
       const productSellingPlansFromOG =
         cur?.selling_plan_allocations?.filter(sellingPlan => ogSellingPlanIds.has(sellingPlan.selling_plan_id)) ?? [];
       // a product is autoship eligible if it has plans from the default or PSFL selling plan group
@@ -178,157 +193,7 @@ export const autoshipEligible = (state = {}, action) => {
   return state;
 };
 
-export function textToFreq(text) {
-  const period = ['day', 'week', 'month'].findIndex(it => text.toLowerCase().includes(it)) + 1;
-  const every = (text.match(/(\d+)/) || ['', 1])[1];
-  if (every && period) {
-    return `${every}_${period}`;
-  }
-  return null;
-}
-
-export function sellingPlansToEveryPeriod(sellingPlanGroup) {
-  return sellingPlanGroup?.selling_plans
-    ?.map(({ options }) => options || [])
-    .flat()
-    .map(({ value }) => textToFreq(value));
-}
-
-export function sellingPlansToText(sellingPlanGroup, frequencies) {
-  return sellingPlanGroup.options?.[0]?.values || frequencies;
-}
-
-export function sellingPlansToFrequencies(sellingPlanGroup) {
-  return sellingPlanGroup?.selling_plans?.map(({ id }) => `${id}`);
-}
-
-function getPrepaidShipments(sellingPlan) {
-  const shipments = sellingPlan?.options.find(({ name }) => name === 'Shipment amount')?.value.split(' ')[0];
-  return shipments ? Number(shipments) : undefined;
-}
-
-function getPrepaidSellingPlans(prepaidSellingPlanGroups) {
-  return prepaidSellingPlanGroups.reduce((acc, cur) => {
-    const variant = cur.name.split('-')[1];
-
-    const sellingPlanInfo = cur.selling_plans.map(sellingPlanObject => {
-      return {
-        numberShipments: getPrepaidShipments(sellingPlanObject),
-        sellingPlan: String(sellingPlanObject.id)
-      };
-    });
-
-    return { ...acc, [variant]: sellingPlanInfo };
-  }, {});
-}
-
-export const config = (
-  state = {
-    frequencies: [],
-    offerType: 'radio',
-    frequenciesEveryPeriod: []
-  },
-  action
-) => {
-  if (constants.RECEIVE_PRODUCT_PLANS === action.type) {
-    const frequencies = [...new Set(Object.values(action.payload).map(Object.keys).flat())];
-    return {
-      ...state,
-      frequencies
-    };
-  }
-
-  if (constants.SETUP_PRODUCT === action.type) {
-    const {
-      payload: { product, currency }
-    } = action;
-    let configToAdd = {};
-    // pay as you go selling plans
-    const sellingPlanGroup = getPayAsYouGoSellingPlanGroup(product?.selling_plan_groups);
-    const frequencies = sellingPlansToFrequencies(sellingPlanGroup);
-    if (frequencies?.length) {
-      const frequenciesEveryPeriod = sellingPlansToEveryPeriod(sellingPlanGroup);
-      const frequenciesText = sellingPlanGroup.options?.[0]?.values || frequencies;
-      let defaultFrequency = state.defaultFrequency;
-
-      if (defaultFrequency && isOgFrequency(defaultFrequency)) {
-        defaultFrequency =
-          mapFrequencyToSellingPlan(frequencies, frequenciesEveryPeriod, defaultFrequency) ||
-          getFirstSellingPlan(frequencies) ||
-          defaultFrequency;
-      }
-      configToAdd = {
-        frequencies,
-        frequenciesEveryPeriod,
-        frequenciesText,
-        ...(defaultFrequency ? { defaultFrequency } : {}),
-        hasProductSpecificFrequencies:
-          state.hasProductSpecificFrequencies || isProductSpecificFrequencySellingPlanGroup(sellingPlanGroup)
-      };
-    }
-
-    // prepaid selling plans
-    const prepaidSellingPlanGroups = product?.selling_plan_groups.filter(group => /^Prepaid-.*/.test(group.name));
-    if (prepaidSellingPlanGroups.length) {
-      configToAdd = {
-        ...configToAdd,
-        prepaidSellingPlans: { ...state.prepaidSellingPlans, ...getPrepaidSellingPlans(prepaidSellingPlanGroups) }
-      };
-    }
-    return {
-      ...state,
-      ...configToAdd,
-      storeCurrency: currency
-    };
-  }
-
-  if (constants.RECEIVE_OFFER === action.type) {
-    const {
-      payload: { offer: offerEl }
-    } = action;
-    const {
-      defaultFrequency,
-      config: { frequencies: sellingPlans, frequenciesEveryPeriod, prepaidSellingPlans = {} } = {},
-      product
-    } = offerEl || {};
-
-    // We don't want to be setting the default frequency to a prepaid selling plan
-    if (prepaidSellingPlans[product?.id]?.some(({ sellingPlan }) => sellingPlan === defaultFrequency)) {
-      return { ...state, defaultFrequency: getFirstSellingPlan(sellingPlans) || defaultFrequency };
-    }
-
-    if (!isOgFrequency(defaultFrequency))
-      return {
-        ...state,
-        defaultFrequency: defaultFrequency
-      };
-
-    return {
-      ...state,
-      defaultFrequency:
-        mapFrequencyToSellingPlan(sellingPlans, frequenciesEveryPeriod, defaultFrequency) ||
-        getFirstSellingPlan(sellingPlans) ||
-        defaultFrequency
-    };
-  }
-
-  if (constants.RECEIVE_MERCHANT_SETTINGS === action.type) {
-    return {
-      ...state,
-      merchantSettings: {
-        ...action.payload
-      }
-    };
-  }
-
-  return state;
-};
-
 export const inStock = (state = {}, action) => {
-  if (constants.RECEIVE_PRODUCT_PLANS === action.type) {
-    return Object.entries(action.payload).reduce(productTrue, state);
-  }
-
   if (constants.SETUP_CART === action.type) {
     const cart = action.payload;
 
@@ -338,7 +203,9 @@ export const inStock = (state = {}, action) => {
   if (constants.SETUP_PRODUCT === action.type) {
     const {
       payload: { product }
-    } = action;
+    } = action as { payload: SetupProductPayload };
+    // it's unclear whether this needs to check the base product object or could only check the variants
+    // leaving for now to preserve backwards compatibility
     return [product, ...(product?.variants ?? [])]?.reduce(productOrVariantInStockReducer, state) || state;
   }
   // force offer to refresh when requesting a new one
@@ -354,18 +221,9 @@ export const inStock = (state = {}, action) => {
 
 export const offer = (state = {}, _action) => state;
 
-function getFrequencyForPrepaidShipments({ prepaidShipments, offer: offerEl, product }) {
-  if (prepaidShipments) {
-    const productId = safeProductId(product.id);
-    const plan = offerEl?.config.prepaidSellingPlans[productId]?.find(p => p.numberShipments === prepaidShipments);
-    return plan ? plan.sellingPlan : null;
-  }
-  return offerEl?.config.frequencies[0];
-}
-
 function getOptedInItem(cartItem) {
   const prepaidShipments = getPrepaidShipments(cartItem.selling_plan_allocation.selling_plan);
-  const item = {
+  const item: OptInItem = {
     id: cartItem.key,
     frequency: `${cartItem.selling_plan_allocation.selling_plan.id}`
   };
@@ -375,7 +233,7 @@ function getOptedInItem(cartItem) {
   return item;
 }
 
-export const optedin = (state = [], action) => {
+export const optedin = (state: OptedInState = [], action): OptedInState => {
   if (constants.SETUP_CART === action.type) {
     const cart = action.payload;
     return state
@@ -384,9 +242,10 @@ export const optedin = (state = [], action) => {
   }
 
   if (constants.RECEIVE_OFFER === action.type) {
-    const { offer: offerEl = {}, ...payload } = action.payload;
-    const existingOptins = mapExistingOptinsFromOfferResponse(state, offerEl);
-    const newOptins = reduceNewOptinsFromOfferResponse(payload, existingOptins, offerEl);
+    const payload = action.payload as ReceiveOfferPayload;
+    const { offer: offerEl = {}, frequencyConfig } = payload;
+    const existingOptins = mapExistingOptinsFromOfferResponse(state, offerEl, frequencyConfig);
+    const newOptins = reduceNewOptinsFromOfferResponse(payload, existingOptins, offerEl, frequencyConfig);
 
     return [...existingOptins, ...newOptins];
   }
@@ -423,7 +282,7 @@ export const optedin = (state = [], action) => {
     return rest.concat({
       ...oldone,
       ...payload.product,
-      frequency: getFrequencyForPrepaidShipments(payload)
+      frequency: payload.frequency
     });
   }
 
@@ -436,13 +295,12 @@ export const productPlans = (state = {}, action) => {
   if (constants.SETUP_PRODUCT === action.type) {
     const {
       payload: { product, currency }
-    } = action;
+    } = action as { payload: SetupProductPayload };
 
     const sellingPlans = getSellingPlans(product);
 
     return (
-      // We consider the product here as well for cases where we don't have any variants
-      [product, ...(product?.variants ?? [])]?.reduce(
+      product.variants.reduce(
         (acc, cur) => ({
           ...acc,
           [cur.id]: cur.selling_plan_allocations?.reduce(
@@ -469,9 +327,6 @@ export const productPlans = (state = {}, action) => {
       ) || state
     );
   }
-  if (constants.RECEIVE_PRODUCT_PLANS === action.type) {
-    return getObjectStructuredProductPlans(action.payload);
-  }
   return state;
 };
 

package/src/shopify/utils.ts

@@ -52,3 +52,28 @@ export const getPayAsYouGoSellingPlan = (sellingPlans: ShopifySellingPlansEntity
   const group = getPayAsYouGoSellingPlanGroup(sellingPlans.map(plan => plan.group));
   return sellingPlans.find(plan => plan.group === group);
 };
+
+export function sellingPlansToFrequencies(sellingPlanGroup: ShopifySellingPlanGroupsEntity) {
+  return sellingPlanGroup?.selling_plans?.map(({ id }) => `${id}`);
+}
+
+export function sellingPlansToEveryPeriod(sellingPlanGroup: ShopifySellingPlanGroupsEntity) {
+  return sellingPlanGroup?.selling_plans
+    ?.map(({ options }) => options || [])
+    .flat()
+    .map(({ value }) => textToFreq(value));
+}
+
+export function textToFreq(text) {
+  const period = ['day', 'week', 'month'].findIndex(it => text.toLowerCase().includes(it)) + 1;
+  const every = (text.match(/(\d+)/) || ['', 1])[1];
+  if (every && period) {
+    return `${every}_${period}`;
+  }
+  return null;
+}
+
+export function getPrepaidShipments(sellingPlan) {
+  const shipments = sellingPlan?.options.find(({ name }) => name === 'Shipment amount')?.value.split(' ')[0];
+  return shipments ? Number(shipments) : undefined;
+}