@ordergroove/offers 2.47.2-alpha-PR-1356-3.33 → 2.47.2

package/src/shopify/reducers/config.ts

@@ -13,7 +13,7 @@ import {
   sellingPlansToFrequencies,
   getPrepaidShipments
 } from '../utils';
-import { ShopifyProductEntity, ShopifySellingPlanGroupsEntity, ShopifyVariantsEntity } from '../types/shopify';
+import { ShopifySellingPlanGroupsEntity, ShopifyVariantsEntity } from '../types/shopify';
 
 const config = (
   state: ConfigState = {
@@ -48,11 +48,11 @@ const config = (
     };
 
     // prepaid selling plans
-    const prepaidSellingPlans = getPrepaidSellingPlans(product);
-    if (Object.keys(prepaidSellingPlans).length) {
+    const prepaidSellingPlanGroups = product?.selling_plan_groups.filter(group => /^Prepaid-.*/.test(group.name));
+    if (prepaidSellingPlanGroups.length) {
       configToAdd = {
         ...configToAdd,
-        prepaidSellingPlans: { ...state.prepaidSellingPlans, ...prepaidSellingPlans }
+        prepaidSellingPlans: { ...state.prepaidSellingPlans, ...getPrepaidSellingPlans(prepaidSellingPlanGroups) }
       };
     }
     return {
@@ -177,14 +177,7 @@ function getUpdatedDefaultFrequency(
   );
 }
 
-export function getPrepaidSellingPlans(
-  product: ShopifyProductEntity
-): Record<string, { numberShipments: number; sellingPlan: string }[]> {
-  const prepaidSellingPlanGroups = product?.selling_plan_groups.filter(group => /^Prepaid-.*/.test(group.name));
-  if (!prepaidSellingPlanGroups.length) {
-    return {};
-  }
-
+function getPrepaidSellingPlans(prepaidSellingPlanGroups) {
   return prepaidSellingPlanGroups.reduce((acc, cur) => {
     const variant = cur.name.split('-')[1];
 

package/src/shopify/shopifyReducer.ts

@@ -42,18 +42,16 @@ import type {
 } from '../core/types/reducer';
 
 import { sellingPlanAllocationsReducer, getSellingPlans } from './reducers/productPlans';
-import config, { getPrepaidSellingPlans } from './reducers/config';
+import config from './reducers/config';
 import { experimentsReducer } from '../core/experiments';
 import {
   getPayAsYouGoSellingPlanGroup,
   getPayAsYouGoSellingPlanGroups,
   sellingPlansToEveryPeriod,
   sellingPlansToFrequencies,
-  getPrepaidShipments,
-  getDefaultPrepaidOption
+  getPrepaidShipments
 } from './utils';
 import { EmptyObject } from '../core/types/utility';
-import { ELIGIBILITY_GROUPS } from '../core/constants';
 
 const overrideLineKey = (state, productId, newValue) => {
   const keys = Object.keys(state).filter(it => it.startsWith(productId.toString()));
@@ -118,76 +116,39 @@ export const mapExistingOptinsFromOfferResponse = (
   });
 
 export const reduceNewOptinsFromOfferResponse = (
-  {
-    autoship = {},
-    autoship_by_default = {},
-    default_frequencies = {},
-    in_stock = {},
-    eligibility_groups
-  }: ReceiveOfferPayload,
+  { autoship = {}, autoship_by_default = {}, default_frequencies = {}, in_stock = {} }: ReceiveOfferPayload,
   existingOptins: OptedInState,
   offerEl: OfferElement | EmptyObject,
-  frequencyConfig: ReceiveOfferPayload['frequencyConfig'],
-  prepaidSellingPlans: ReceiveOfferPayload['prepaidSellingPlans']
+  frequencyConfig: ReceiveOfferPayload['frequencyConfig']
 ) =>
   Object.keys(autoship).reduce((acc, id) => {
-    // if the user is not opted in and the product is set to default to subscription
-    if (!existingOptins.some(it => it.id === id) && autoship_by_default[id] && in_stock[id]) {
-      if (autoship[id]) {
-        return acc.concat({
-          id,
-          frequency: getOptInDefaultFrequency({
-            frequencyConfig,
-            offerEl,
-            default_frequencies,
-            id
-          })
-        });
-      } else if (eligibility_groups[id].includes(ELIGIBILITY_GROUPS.PREPAID)) {
-        // if the product is prepaid eligible but not subscription eligible, opt them into a prepaid subscription
-        const prepaidPlan = prepaidSellingPlans ? getDefaultPrepaidOption(prepaidSellingPlans) : null;
-        return acc.concat({
-          id,
-          // we might not have a prepaid plan yet if the Shopify product request hasn't completed (SETUP_PRODUCT)
-          frequency: prepaidPlan?.sellingPlan || PREPAID_PLACEHOLDER,
-          prepaidShipments: prepaidPlan?.numberShipments || null
-        });
+    if (!existingOptins.some(it => it.id === id)) {
+      if (!(autoship[id] && autoship_by_default[id] && in_stock[id])) return acc;
+      const { frequencies: sellingPlans, frequenciesEveryPeriod } = frequencyConfig;
+      const { defaultFrequency } = offerEl || {};
+      const psdf = default_frequencies[id];
+      let frequency;
+
+      if (default_frequencies[id] && hasShopifySellingPlans(sellingPlans, frequenciesEveryPeriod)) {
+        frequency =
+          mapFrequencyToSellingPlan(sellingPlans, frequenciesEveryPeriod, `${psdf.every}_${psdf.every_period}`) ||
+          getDefaultSellingPlan(sellingPlans, frequenciesEveryPeriod, defaultFrequency) ||
+          getFirstSellingPlan(sellingPlans);
+      } else if (default_frequencies[id]) {
+        frequency = `${psdf.every}_${psdf.every_period}`;
+      } else {
+        frequency = getDefaultSellingPlan(sellingPlans, frequenciesEveryPeriod, defaultFrequency) || '_'; // Placeholder to be backfilled in SETUP_PRODUCT reducer
       }
+
+      return acc.concat({
+        id,
+        frequency
+      });
     }
 
     return acc;
   }, []);
 
-const getOptInDefaultFrequency = ({
-  frequencyConfig,
-  offerEl,
-  default_frequencies,
-  id
-}: {
-  frequencyConfig: ReceiveOfferPayload['frequencyConfig'];
-  offerEl: OfferElement | EmptyObject;
-  default_frequencies: ReceiveOfferPayload['default_frequencies'];
-  id: string;
-}) => {
-  const { frequencies: sellingPlans, frequenciesEveryPeriod } = frequencyConfig;
-  const { defaultFrequency } = offerEl || {};
-  const psdf = default_frequencies[id];
-  let frequency;
-
-  if (default_frequencies[id] && hasShopifySellingPlans(sellingPlans, frequenciesEveryPeriod)) {
-    frequency =
-      mapFrequencyToSellingPlan(sellingPlans, frequenciesEveryPeriod, `${psdf.every}_${psdf.every_period}`) ||
-      getDefaultSellingPlan(sellingPlans, frequenciesEveryPeriod, defaultFrequency) ||
-      getFirstSellingPlan(sellingPlans);
-  } else if (default_frequencies[id]) {
-    frequency = `${psdf.every}_${psdf.every_period}`;
-  } else {
-    frequency = getDefaultSellingPlan(sellingPlans, frequenciesEveryPeriod, defaultFrequency) || '_'; // Placeholder to be backfilled in SETUP_PRODUCT reducer
-  }
-
-  return frequency;
-};
-
 const productOrVariantInStockReducer = (acc, cur) => ({
   ...overrideLineKey(acc, cur.id, cur.available),
   [cur.id]: cur.available
@@ -273,7 +234,6 @@ function getOptedInItem(cartItem) {
   return item;
 }
 
-const PREPAID_PLACEHOLDER = 'prepaid-replace-me';
 export const optedin = (state: OptedInState = [], action): OptedInState => {
   if (constants.SETUP_CART === action.type) {
     const cart = action.payload;
@@ -284,15 +244,9 @@ export const optedin = (state: OptedInState = [], action): OptedInState => {
 
   if (constants.RECEIVE_OFFER === action.type) {
     const payload = action.payload as ReceiveOfferPayload;
-    const { offer: offerEl = {}, frequencyConfig, prepaidSellingPlans } = payload;
+    const { offer: offerEl = {}, frequencyConfig } = payload;
     const existingOptins = mapExistingOptinsFromOfferResponse(state, offerEl, frequencyConfig);
-    const newOptins = reduceNewOptinsFromOfferResponse(
-      payload,
-      existingOptins,
-      offerEl,
-      frequencyConfig,
-      prepaidSellingPlans
-    );
+    const newOptins = reduceNewOptinsFromOfferResponse(payload, existingOptins, offerEl, frequencyConfig);
 
     return [...existingOptins, ...newOptins];
   }
@@ -300,33 +254,24 @@ export const optedin = (state: OptedInState = [], action): OptedInState => {
   if (constants.SETUP_PRODUCT === action.type) {
     const { product } = action.payload;
     const sellingPlanGroup = getPayAsYouGoSellingPlanGroup(product?.selling_plan_groups);
-    const prepaidSellingPlans = getPrepaidSellingPlans(product);
-    const frequencies = sellingPlanGroup ? sellingPlansToFrequencies(sellingPlanGroup) : [];
-    const frequenciesEveryPeriod = sellingPlanGroup ? sellingPlansToEveryPeriod(sellingPlanGroup) : [];
+    if (!sellingPlanGroup) {
+      return state;
+    }
+    const frequencies = sellingPlansToFrequencies(sellingPlanGroup);
+    const frequenciesEveryPeriod = sellingPlansToEveryPeriod(sellingPlanGroup);
+
+    return state.map(curr => {
+      if (isOgFrequency(curr.frequency)) {
+        return {
+          ...curr,
+          frequency:
+            mapFrequencyToSellingPlan(frequencies, frequenciesEveryPeriod, curr.frequency) ||
+            getFirstSellingPlan(frequencies)
+        };
+      }
 
-    return state
-      .map(curr => {
-        const prepaidSellingPlansForVariant = prepaidSellingPlans[curr.id];
-        if (sellingPlanGroup && isOgFrequency(curr.frequency)) {
-          return {
-            ...curr,
-            frequency:
-              mapFrequencyToSellingPlan(frequencies, frequenciesEveryPeriod, curr.frequency) ||
-              getFirstSellingPlan(frequencies)
-          };
-        } else if (curr.frequency === PREPAID_PLACEHOLDER && prepaidSellingPlansForVariant?.length > 0) {
-          // if we opted the user into a prepaid plan on RECEIVE_OFFER and now have the actual selling plan information, update it
-          const { sellingPlan, numberShipments } = getDefaultPrepaidOption(prepaidSellingPlansForVariant);
-          return {
-            ...curr,
-            frequency: sellingPlan,
-            prepaidShipments: numberShipments
-          };
-        }
-
-        return curr;
-      })
-      .filter(i => i.frequency !== PREPAID_PLACEHOLDER); // remove any leftover placeholders
+      return curr;
+    });
   }
 
   if (constants.PRODUCT_CHANGE_PREPAID_SHIPMENTS === action.type) {

package/src/shopify/utils.ts

@@ -77,8 +77,3 @@ export function getPrepaidShipments(sellingPlan) {
   const shipments = sellingPlan?.options.find(({ name }) => name === 'Shipment amount')?.value.split(' ')[0];
   return shipments ? Number(shipments) : undefined;
 }
-
-export function getDefaultPrepaidOption<T>(options: T[]): T {
-  // prefer the second plan by default, which has more prepaid shipments
-  return options[1] || options[0];
-}