@ordergroove/offers 2.43.0 → 2.44.1-alpha-PR-1166-3.30

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

@@ -31,17 +31,28 @@ import {
   safeProductId,
   getMatchingProductIfExists
 } from '../core/utils';
+import type {
+  AutoshipEligibleState,
+  OfferElement,
+  OptedInState,
+  OptInItem,
+  ReceiveOfferPayload,
+  ReceiveProductPlansPayload
+} from '../core/types/reducer';
 
 import { getObjectStructuredProductPlans } from '../core/adapters';
 
-import {
-  sellingPlanAllocationsReducer,
-  getSellingPlans,
-  DEFAULT_PAY_AS_YOU_GO_GROUP_NAME
-} from './reducers/productPlans';
+import { sellingPlanAllocationsReducer, getSellingPlans } from './reducers/productPlans';
+import config from './reducers/config';
 import { experimentsReducer } from '../core/experiments';
-
-export const EXPERIMENT_SHOPIFY_APP_ID_PREFIX = 'ordergroove-subscribe-and-save-';
+import {
+  getPayAsYouGoSellingPlanGroup,
+  getPayAsYouGoSellingPlanGroups,
+  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()));
@@ -51,7 +62,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;
   }
@@ -73,23 +88,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
       };
     }
@@ -98,14 +117,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;
 
@@ -129,57 +150,21 @@ export const reduceNewOptinsFromOfferResponse = (
     return acc;
   }, []);
 
-const getExperimentSellingPlanGroup = product => {
-  return product?.selling_plan_groups.find(group => group.app_id?.startsWith(EXPERIMENT_SHOPIFY_APP_ID_PREFIX));
-};
-
-const getOGSellingPlanGroup = product => {
-  // retrieve an OG Default or PSFL Selling Plan Group, preferring to return PSFL groups if they exist
-  const productSpecificFrequencySellingPlanGroup = product?.selling_plan_groups.find(
-    isProductSpecificFrequencySellingPlanGroup
-  );
-
-  return (
-    productSpecificFrequencySellingPlanGroup ||
-    getDefaultSubscriptionSellingPlanGroup(product) ||
-    getExperimentSellingPlanGroup(product)
-  );
-};
-
-const getOGSellingPlanGroups = product => {
-  const sellingPlanGroups = (product?.selling_plan_groups || []).filter(
-    group =>
-      isDefaultSellingPlanGroup(group) ||
-      isProductSpecificFrequencySellingPlanGroup(group) ||
-      group.app_id?.startsWith(EXPERIMENT_SHOPIFY_APP_ID_PREFIX)
-  );
-  return sellingPlanGroups;
-};
-
-const getDefaultSubscriptionSellingPlanGroup = product => {
-  // retrieve the OG Default Selling Plan Group
-  return product?.selling_plan_groups.find(isDefaultSellingPlanGroup);
-};
-
-const isDefaultSellingPlanGroup = group => group.name === DEFAULT_PAY_AS_YOU_GO_GROUP_NAME;
-
-const isProductSpecificFrequencySellingPlanGroup = group => group.name.startsWith('og_psfl');
-
 const productOrVariantInStockReducer = (acc, cur) => ({
   ...overrideLineKey(acc, cur.id, cur.available),
   [cur.id]: cur.available
 });
 
-const productTrue = (acc, [id]) => ({ ...acc, [id]: true });
+const productTrue = (acc: Record<string, boolean>, [id]: [string, string[]]) => ({ ...acc, [id]: true });
 
 const reduceProductCartLine = (acc, cur) => {
   const productId = safeProductId(cur.key);
   return { ...acc, [cur.key]: acc[productId] || null };
 };
 
-export const autoshipEligible = (state = {}, action) => {
+export const autoshipEligible = (state: AutoshipEligibleState = {}, action): AutoshipEligibleState => {
   if (constants.RECEIVE_PRODUCT_PLANS === action.type) {
-    return Object.entries(action.payload).reduce(productTrue, state);
+    return Object.entries(action.payload as ReceiveProductPlansPayload).reduce(productTrue, state);
   }
   if (constants.SETUP_CART === action.type) {
     const { payload: cart } = action;
@@ -189,7 +174,7 @@ export const autoshipEligible = (state = {}, action) => {
     const {
       payload: { product }
     } = action;
-    const applicableSellingPlanGroups = getOGSellingPlanGroups(product);
+    const applicableSellingPlanGroups = getPayAsYouGoSellingPlanGroups(product?.selling_plan_groups);
 
     const ogSellingPlanIds = new Set(
       applicableSellingPlanGroups.flatMap(group => group.selling_plans.map(sellingPlan => sellingPlan.id)) ?? []
@@ -215,152 +200,6 @@ 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 = getOGSellingPlanGroup(product);
-    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);
@@ -391,18 +230,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}`
   };
@@ -412,7 +242,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
@@ -421,16 +251,17 @@ 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];
   }
 
   if (constants.SETUP_PRODUCT === action.type) {
     const { product } = action.payload;
-    const sellingPlanGroup = getOGSellingPlanGroup(product);
+    const sellingPlanGroup = getPayAsYouGoSellingPlanGroup(product?.selling_plan_groups);
     if (!sellingPlanGroup) {
       return state;
     }
@@ -460,7 +291,7 @@ export const optedin = (state = [], action) => {
     return rest.concat({
       ...oldone,
       ...payload.product,
-      frequency: getFrequencyForPrepaidShipments(payload)
+      frequency: payload.frequency
     });
   }
 

package/src/shopify/types/shopify.ts

@@ -25,7 +25,7 @@ export interface ShopifySellingPlansEntity {
   options?: ShopifyOptionsEntity[] | null;
   recurring_deliveries: boolean;
   price_adjustments?: ShopifyPriceAdjustmentsEntity[] | null;
-  group_name?: string;
+  group: ShopifySellingPlanGroupsEntity;
 }
 
 export interface ShopifySellingPlanGroupsEntity {

package/src/shopify/utils.ts

@@ -1,3 +1,5 @@
+import { ShopifySellingPlanGroupsEntity, ShopifySellingPlansEntity } from './types/shopify';
+
 export const money = (val: number, currency: string) =>
   val === null
     ? ''
@@ -7,3 +9,71 @@ export const money = (val: number, currency: string) =>
       }).format(val / 100);
 
 export const percentage = val => `${val}%`;
+
+export const DEFAULT_PAY_AS_YOU_GO_GROUP_NAME = 'Subscribe and Save';
+const EXPERIMENT_SHOPIFY_APP_ID_PREFIX = 'ordergroove-subscribe-and-save-';
+
+// returns the non-prepaid OG selling plan to use for displaying frequencies
+export const getPayAsYouGoSellingPlanGroup = (sellingPlanGroups: ShopifySellingPlanGroupsEntity[] = []) => {
+  // retrieve an OG Default or PSFL Selling Plan Group, preferring to return PSFL groups if they exist
+  const productSpecificFrequencySellingPlanGroup = sellingPlanGroups.find(isProductSpecificFrequencySellingPlanGroup);
+
+  return (
+    productSpecificFrequencySellingPlanGroup ||
+    sellingPlanGroups.find(isDefaultSellingPlanGroup) ||
+    sellingPlanGroups.find(isExperimentSellingPlanGroup)
+  );
+};
+
+// returns OG selling plan groups that are not prepaid
+export const getPayAsYouGoSellingPlanGroups = (sellingPlanGroups: ShopifySellingPlanGroupsEntity[] = []) => {
+  return sellingPlanGroups.filter(
+    group =>
+      isDefaultSellingPlanGroup(group) ||
+      isProductSpecificFrequencySellingPlanGroup(group) ||
+      isExperimentSellingPlanGroup(group)
+  );
+};
+
+const isDefaultSellingPlanGroup = (group: ShopifySellingPlanGroupsEntity) =>
+  // we need to check name or app_id - the app_id is newer and not all selling plans have it
+  // the default group name is only applied to the default selling plan group
+  // flex incentives selling plan groups have a different name but the same subscribe-and-save app ID
+  group.name === DEFAULT_PAY_AS_YOU_GO_GROUP_NAME || group.app_id === 'ordergroove-subscribe-and-save';
+
+export const isProductSpecificFrequencySellingPlanGroup = (group: ShopifySellingPlanGroupsEntity) =>
+  group.name.startsWith('og_psfl') || group.app_id === 'ordergroove-product-specific-frequency-list';
+
+export const isExperimentSellingPlanGroup = (group: ShopifySellingPlanGroupsEntity) =>
+  // @ts-expect-error 18047
+  group.app_id?.startsWith(EXPERIMENT_SHOPIFY_APP_ID_PREFIX);
+
+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;
+}

package/src/types.ts

@@ -1,16 +0,0 @@
-export type ExperimentVariant = {
-  public_id: string;
-  parameters: any;
-  weight: number;
-};
-
-export type ExperimentConfig = {
-  public_id: string;
-  variants: ExperimentVariant[];
-};
-
-export interface MerchantSettings {
-  currency_code: string;
-  multicurrency_enabled: boolean;
-  experiments?: ExperimentConfig;
-}