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

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

@@ -1,4 +1,4 @@
-import { money, percentage } from '../utils';
+import { getPayAsYouGoSellingPlanGroups, money, percentage, textToFreq } from '../utils';
 
 describe('Shopify Utils', () => {
   describe('Money', () => {
@@ -26,4 +26,71 @@ 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', () => {
+  describe('getPayAsYouGoSellingPlanGroups', () => {
+    it('returns default group with app ID', () => {
+      expect(
+        getPayAsYouGoSellingPlanGroups([{ name: 'Subscribe and Save', app_id: 'ordergroove-subscribe-and-save' }])
+          .length
+      ).toBe(1);
+    });
+
+    it('returns default group without app ID', () => {
+      expect(getPayAsYouGoSellingPlanGroups([{ name: 'Subscribe and Save', app_id: null }]).length).toBe(1);
+    });
+
+    it('returns PSI selling plan groups', () => {
+      expect(
+        getPayAsYouGoSellingPlanGroups([{ name: 'incentive-group', app_id: 'ordergroove-subscribe-and-save' }]).length
+      ).toBe(1);
+    });
+
+    it('does not return prepaid selling plan groups', () => {
+      expect(
+        getPayAsYouGoSellingPlanGroups([{ name: 'Prepaid-1', app_id: 'ordergroove-prepaid-and-save' }]).length
+      ).toBe(0);
+    });
+
+    it('returns PSFL group with app ID', () => {
+      expect(
+        getPayAsYouGoSellingPlanGroups([
+          {
+            // name probably still starts with og_psfl
+            // but changing it so that the app_id branch is hit
+            name: 'changed-psfl-name',
+            app_id: 'ordergroove-product-specific-frequency-list'
+          }
+        ]).length
+      ).toBe(1);
+    });
+
+    it('returns PSFL group without app ID', () => {
+      expect(getPayAsYouGoSellingPlanGroups([{ name: 'og_psfl_1w', app_id: null }]).length).toBe(1);
+    });
+  });
 });

package/src/shopify/reducers/config.ts

@@ -0,0 +1,223 @@
+import * as constants from '../../core/constants';
+import { getFirstSellingPlan, isOgFrequency, mapFrequencyToSellingPlan, safeProductId } from '../../core/utils';
+import type {
+  ConfigState,
+  ReceiveMerchantSettingsPayload,
+  ReceiveOfferPayload,
+  ReceiveProductPlansPayload,
+  SetupProductPayload
+} from '../../core/types/reducer';
+
+import {
+  getPayAsYouGoSellingPlanGroup,
+  isProductSpecificFrequencySellingPlanGroup,
+  sellingPlansToEveryPeriod,
+  sellingPlansToFrequencies,
+  getPrepaidShipments
+} from '../utils';
+import { ShopifySellingPlanGroupsEntity, ShopifyVariantsEntity } from '../types/shopify';
+
+const config = (
+  state: ConfigState = {
+    frequencies: [],
+    offerType: 'radio',
+    frequenciesEveryPeriod: [],
+    productFrequencies: {}
+  },
+  action
+): ConfigState => {
+  if (constants.RECEIVE_PRODUCT_PLANS === action.type) {
+    const frequencies = [
+      ...new Set(
+        Object.values(action.payload as ReceiveProductPlansPayload)
+          .map(Object.keys)
+          .flat()
+      )
+    ];
+    return {
+      ...state,
+      frequencies
+    };
+  }
+
+  if (constants.SETUP_PRODUCT === action.type) {
+    const {
+      payload: { product, currency }
+    } = action as { payload: SetupProductPayload };
+    let configToAdd: ConfigState = {};
+
+    // get the frequency values for the old config structure
+    // leaving for now for backwards compatibility, but they should eventually be removed in favor of productFrequencies
+    let globalFrequencies = getFrequencies(product.selling_plan_groups, state);
+    if (globalFrequencies?.frequencies?.length) {
+      configToAdd = {
+        ...globalFrequencies,
+        hasProductSpecificFrequencies:
+          state.hasProductSpecificFrequencies ||
+          isProductSpecificFrequencySellingPlanGroup(getPayAsYouGoSellingPlanGroup(product.selling_plan_groups))
+      };
+    }
+
+    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 { frequencies: sellingPlans, frequenciesEveryPeriod, 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,
+      // populate this field for backwards compatibility
+      // this should eventually be removed in favor of productFrequencies
+      defaultFrequency: getUpdatedDefaultFrequency(
+        productId,
+        defaultFrequency,
+        prepaidSellingPlans,
+        sellingPlans,
+        frequenciesEveryPeriod
+      ),
+      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(all => all.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/reducers/productPlans.ts

@@ -1,4 +1,4 @@
-import { money, percentage } from '../utils';
+import { getPayAsYouGoSellingPlan, money, percentage } from '../utils';
 import { ShopifyProductEntity, ShopifySellingPlanAllocationsEntity, ShopifySellingPlansEntity } from '../types/shopify';
 import { ProductPlanEntity } from '../types/productPlan';
 
@@ -92,8 +92,6 @@ export const addPrepaidPriceAndSavings = (
   return productPlan;
 };
 
-export const DEFAULT_PAY_AS_YOU_GO_GROUP_NAME = 'Subscribe and Save';
-
 export const mapSellingPlanToDiscount = (
   allocation: ShopifySellingPlanAllocationsEntity,
   sellingPlans: ShopifySellingPlansEntity[],
@@ -112,9 +110,7 @@ export const mapSellingPlanToDiscount = (
   };
 
   if (isPrepaidAllocation(allocation)) {
-    const payAsYouGoPlan = sellingPlans.find(
-      plan => plan.group_name === DEFAULT_PAY_AS_YOU_GO_GROUP_NAME && plan.options.length === 1
-    );
+    const payAsYouGoPlan = getPayAsYouGoSellingPlan(sellingPlans);
     return addPrepaidPriceAndSavings(allocation, productPlan, payAsYouGoPlan, currency);
   }
 
@@ -130,9 +126,6 @@ export const sellingPlanAllocationsReducer = (
 
 export const getSellingPlans = (product: ShopifyProductEntity) =>
   product.selling_plan_groups.reduce<ShopifySellingPlansEntity[]>(
-    (allGroups, group) => [
-      ...allGroups,
-      ...group.selling_plans.map(selling_plan => ({ ...selling_plan, group_name: group.name }))
-    ],
+    (allGroups, group) => [...allGroups, ...group.selling_plans.map(selling_plan => ({ ...selling_plan, group }))],
     []
   );

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