@ordergroove/offers 2.47.2 → 2.48.1-alpha-PR-1357-7.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ordergroove/offers",
-  "version": "2.47.2",
+  "version": "2.48.1-alpha-PR-1357-7.8+4d0ab39c0",
   "description": "offer state component",
   "author": "Eugenio Lattanzio <eugenio63@gmail.com>",
   "homepage": "https://github.com/ordergroove/plush-toys#readme",
@@ -49,5 +49,5 @@
     "@ordergroove/offers-templates": "^0.10.0",
     "@types/lodash.memoize": "^4.1.9"
   },
-  "gitHead": "b039a0b5286ac8736eb4501b4763512f27e58953"
+  "gitHead": "4d0ab39c0427f98fdf5165d98d7b00299c4d2a34"
 }

package/src/components/PrepaidStatus.js

@@ -7,6 +7,7 @@ import {
 } from '../core/selectors';
 import { productChangePrepaidShipments } from '../core/actions';
 import { withProduct } from '../core/resolveProperties';
+import { getDefaultPrepaidOption } from '../shopify/utils';
 
 export class PrepaidStatus extends withProduct(LitElement) {
   static get properties() {
@@ -29,7 +30,7 @@ export class PrepaidStatus extends withProduct(LitElement) {
   getDefaultPrepaidShipments() {
     return this.options.includes(this.defaultPrepaidShipments)
       ? this.defaultPrepaidShipments
-      : this.options[1] || this.options[0];
+      : getDefaultPrepaidOption(this.options);
   }
 
   handleSelect({ target: { value } }) {

package/src/core/actions.js

@@ -2,7 +2,11 @@ import { resolveAuth } from '@ordergroove/auth';
 import * as constants from './constants';
 import { api } from './api';
 import { safeOgFrequency } from './utils';
-import { makeFrequencyForPrepaidShipmentsSelector, makeProductFrequenciesSelector } from './selectors';
+import {
+  makeFrequencyForPrepaidShipmentsSelector,
+  makePrepaidSellingPlansSelector,
+  makeProductFrequenciesSelector
+} from './selectors';
 
 export const optinProduct = (product, frequency, offer) => ({
   type: constants.OPTIN_PRODUCT,
@@ -190,10 +194,12 @@ export const requestSessionId = () => (dispatch, getState) => {
 
 export const receiveOffer = (response, offer, productId) => (dispatch, getState) => {
   // this is a thunk so that we access the state for the selector
-  const frequencyConfig = makeProductFrequenciesSelector(productId)(getState());
+  const state = getState();
+  const frequencyConfig = makeProductFrequenciesSelector(productId)(state);
+  const prepaidSellingPlans = makePrepaidSellingPlansSelector(productId)(state);
   dispatch({
     type: constants.RECEIVE_OFFER,
-    payload: { ...response, offer, frequencyConfig }
+    payload: { ...response, offer, frequencyConfig, prepaidSellingPlans }
   });
 };
 

package/src/core/constants.js

@@ -61,6 +61,10 @@ export const INCENTIVE_STANDARD_TYPES = {
   PROGRAM_WIDE: 'PROGRAM_WIDE'
 };
 
+export const ELIGIBILITY_GROUPS = {
+  PREPAID: 'prepaid'
+};
+
 /**
  * @event
  * Events that fires once optin/optout occurs on a cart offer

package/src/core/descriptors.js

@@ -1,3 +1,4 @@
+import { ELIGIBILITY_GROUPS } from './constants';
 import {
   makeSubscribedSelector,
   makeOptedoutSelector,
@@ -25,7 +26,7 @@ export const hasUpsellGroup = (state, ownProps) => {
 
 export const prepaidEligible = (state, ownProps) => {
   const groups = eligibilityGroups(state, ownProps);
-  return groups?.some(it => it === 'prepaid') || false;
+  return groups?.some(it => it === ELIGIBILITY_GROUPS.PREPAID) || false;
 };
 
 export const subscribed = (state, ownProps) => makeSubscribedSelector(ownProps.product)(state);

package/src/core/selectors.ts

@@ -232,6 +232,12 @@ export const makeFrequencyForPrepaidShipmentsSelector = (product: BaseProduct, p
     }
   );
 
+export const makePrepaidSellingPlansSelector = (product: string) =>
+  createSelector(prepaidSellingPlansSelector, prepaidSellingPlans => {
+    const productId = safeProductId(product);
+    return prepaidSellingPlans[productId] || [];
+  });
+
 /** Determine the discounted price of the product, based on the incentives returned from the Offers endpoint. This assumes a pay-as-you-go subscription. */
 export const makeDiscountedProductPriceSelector = memoize((productId: string) =>
   createSelector(

package/src/core/types/reducer.ts

@@ -55,11 +55,13 @@ export type ConfigState = Partial<{
    * @deprecated use productFrequencies instead
    */
   frequenciesText: string[];
-  prepaidSellingPlans: Record<string, { numberShipments: number; sellingPlan: string }[]>;
+  prepaidSellingPlans: Record<string, PrepaidSellingPlan[]>;
   storeCurrency: string;
   productFrequencies: Record<string, ProductFrequencyConfig>;
 }>;
 
+export type PrepaidSellingPlan = { numberShipments: number; sellingPlan: string };
+
 export type ProductFrequencyConfig = {
   frequencies?: string[];
   frequenciesEveryPeriod?: string[];
@@ -92,6 +94,7 @@ export type ReceiveOfferPayload = OfferResponse & {
     frequenciesEveryPeriod?: string[];
     frequenciesText?: string[];
   };
+  prepaidSellingPlans: PrepaidSellingPlan[];
 };
 
 export type OfferElement = InstanceType<typeof Offer> & { config: ConfigState };

package/src/shopify/__tests__/reducers/optedin.spec.js

@@ -2,6 +2,45 @@ import * as constants from '../../../core/constants';
 import { optedin } from '../../shopifyReducer';
 import { DEFAULT_PAY_AS_YOU_GO_GROUP_NAME } from '../../utils';
 
+const PREPAID_PRODUCT_ID = '43017264201944';
+const BOTH_ELIGIBLE_PRODUCT_ID = '43017264201946';
+
+const PREPAID_PLAN_3_SHIPMENTS = 'prepaid-plan-3-shipments';
+const PREPAID_PLAN_6_SHIPMENTS = 'prepaid-plan-6-shipments';
+
+const prepaidPlanWith3Shipments = { sellingPlan: PREPAID_PLAN_3_SHIPMENTS, numberShipments: 3 };
+const prepaidPlanWith6Shipments = { sellingPlan: PREPAID_PLAN_6_SHIPMENTS, numberShipments: 6 };
+
+function buildReceiveOfferPayload(overrides = {}) {
+  return {
+    autoship: {},
+    autoship_by_default: {},
+    default_frequencies: {},
+    in_stock: {},
+    eligibility_groups: {},
+    offer: {},
+    frequencyConfig: {
+      frequencies: [],
+      frequenciesEveryPeriod: []
+    },
+    prepaidSellingPlans: [],
+    ...overrides
+  };
+}
+
+function buildPrepaidSellingPlanGroup(variantId, plans) {
+  return {
+    name: `Prepaid-${variantId}`,
+    selling_plans: plans.map((plan, index) => ({
+      id: plan.sellingPlan,
+      options: [
+        { name: 'Delivery every', value: `PREPAID-${index + 1} months` },
+        { name: 'Shipment amount', value: `${plan.numberShipments} shipments` }
+      ]
+    }))
+  };
+}
+
 describe('optedin', () => {
   it('should return optins given action SETUP_CART', () => {
     const actual = optedin([], {
@@ -583,6 +622,208 @@ describe('optedin', () => {
           ]);
         });
       });
+
+      describe('given product is prepaid eligible but NOT autoship eligible', () => {
+        describe('given prepaidSellingPlans are populated', () => {
+          it('should opt into 2nd prepaid plan and set prepaidShipments when multiple plans available', () => {
+            const actual = optedin([], {
+              type: constants.RECEIVE_OFFER,
+              payload: buildReceiveOfferPayload({
+                autoship: {
+                  [PREPAID_PRODUCT_ID]: false
+                },
+                autoship_by_default: {
+                  [PREPAID_PRODUCT_ID]: true
+                },
+                in_stock: {
+                  [PREPAID_PRODUCT_ID]: true
+                },
+                eligibility_groups: {
+                  [PREPAID_PRODUCT_ID]: [constants.ELIGIBILITY_GROUPS.PREPAID]
+                },
+                prepaidSellingPlans: [prepaidPlanWith3Shipments, prepaidPlanWith6Shipments]
+              })
+            });
+
+            expect(actual).toEqual([
+              {
+                id: PREPAID_PRODUCT_ID,
+                frequency: PREPAID_PLAN_6_SHIPMENTS,
+                prepaidShipments: 6
+              }
+            ]);
+          });
+
+          it('should opt into 1st prepaid plan and set prepaidShipments when only one plan available', () => {
+            const actual = optedin([], {
+              type: constants.RECEIVE_OFFER,
+              payload: buildReceiveOfferPayload({
+                autoship: {
+                  [PREPAID_PRODUCT_ID]: false
+                },
+                autoship_by_default: {
+                  [PREPAID_PRODUCT_ID]: true
+                },
+                in_stock: {
+                  [PREPAID_PRODUCT_ID]: true
+                },
+                eligibility_groups: {
+                  [PREPAID_PRODUCT_ID]: [constants.ELIGIBILITY_GROUPS.PREPAID]
+                },
+                prepaidSellingPlans: [prepaidPlanWith3Shipments]
+              })
+            });
+
+            expect(actual).toEqual([
+              {
+                id: PREPAID_PRODUCT_ID,
+                frequency: PREPAID_PLAN_3_SHIPMENTS,
+                prepaidShipments: 3
+              }
+            ]);
+          });
+        });
+
+        describe('given prepaidSellingPlans are NOT populated', () => {
+          it('should opt into prepaid with PREPAID_PLACEHOLDER and prepaidShipments null', () => {
+            const actual = optedin([], {
+              type: constants.RECEIVE_OFFER,
+              payload: buildReceiveOfferPayload({
+                autoship: {
+                  [PREPAID_PRODUCT_ID]: false
+                },
+                autoship_by_default: {
+                  [PREPAID_PRODUCT_ID]: true
+                },
+                in_stock: {
+                  [PREPAID_PRODUCT_ID]: true
+                },
+                eligibility_groups: {
+                  [PREPAID_PRODUCT_ID]: [constants.ELIGIBILITY_GROUPS.PREPAID]
+                },
+                prepaidSellingPlans: []
+              })
+            });
+
+            expect(actual).toEqual([
+              {
+                id: PREPAID_PRODUCT_ID,
+                frequency: 'prepaid-replace-me',
+                prepaidShipments: null
+              }
+            ]);
+          });
+        });
+
+        describe('edge cases', () => {
+          it('should not create optin when product not in stock, not autoship_by_default, or not in eligibility_groups', () => {
+            // Product not in stock
+            const notInStock = optedin([], {
+              type: constants.RECEIVE_OFFER,
+              payload: buildReceiveOfferPayload({
+                autoship: {
+                  [PREPAID_PRODUCT_ID]: false
+                },
+                autoship_by_default: {
+                  [PREPAID_PRODUCT_ID]: true
+                },
+                in_stock: {
+                  [PREPAID_PRODUCT_ID]: false
+                },
+                eligibility_groups: {
+                  [PREPAID_PRODUCT_ID]: [constants.ELIGIBILITY_GROUPS.PREPAID]
+                },
+                prepaidSellingPlans: [prepaidPlanWith3Shipments]
+              })
+            });
+
+            // Product not autoship_by_default
+            const notAutoshipByDefault = optedin([], {
+              type: constants.RECEIVE_OFFER,
+              payload: buildReceiveOfferPayload({
+                autoship: {
+                  [PREPAID_PRODUCT_ID]: false
+                },
+                autoship_by_default: {
+                  [PREPAID_PRODUCT_ID]: false
+                },
+                in_stock: {
+                  [PREPAID_PRODUCT_ID]: true
+                },
+                eligibility_groups: {
+                  [PREPAID_PRODUCT_ID]: [constants.ELIGIBILITY_GROUPS.PREPAID]
+                },
+                prepaidSellingPlans: [prepaidPlanWith3Shipments]
+              })
+            });
+
+            // Product not in eligibility_groups
+            const notInEligibilityGroups = optedin([], {
+              type: constants.RECEIVE_OFFER,
+              payload: buildReceiveOfferPayload({
+                autoship: {
+                  [PREPAID_PRODUCT_ID]: false
+                },
+                autoship_by_default: {
+                  [PREPAID_PRODUCT_ID]: true
+                },
+                in_stock: {
+                  [PREPAID_PRODUCT_ID]: true
+                },
+                eligibility_groups: {
+                  [PREPAID_PRODUCT_ID]: []
+                },
+                prepaidSellingPlans: [prepaidPlanWith3Shipments]
+              })
+            });
+
+            expect(notInStock).toEqual([]);
+            expect(notAutoshipByDefault).toEqual([]);
+            expect(notInEligibilityGroups).toEqual([]);
+          });
+        });
+      });
+
+      describe('given product is BOTH prepaid eligible AND autoship eligible', () => {
+        it('should opt into regular subscription with PSDF frequency, not prepaid', () => {
+          const actual = optedin([], {
+            type: constants.RECEIVE_OFFER,
+            payload: buildReceiveOfferPayload({
+              autoship: {
+                [BOTH_ELIGIBLE_PRODUCT_ID]: true
+              },
+              autoship_by_default: {
+                [BOTH_ELIGIBLE_PRODUCT_ID]: true
+              },
+              default_frequencies: {
+                [BOTH_ELIGIBLE_PRODUCT_ID]: {
+                  every: 1,
+                  every_period: 2
+                }
+              },
+              in_stock: {
+                [BOTH_ELIGIBLE_PRODUCT_ID]: true
+              },
+              eligibility_groups: {
+                [BOTH_ELIGIBLE_PRODUCT_ID]: [constants.ELIGIBILITY_GROUPS.PREPAID]
+              },
+              frequencyConfig: {
+                frequencies: ['yum selling plan id 1', 'yum selling plan id 2'],
+                frequenciesEveryPeriod: ['1_1', '1_2']
+              },
+              prepaidSellingPlans: [prepaidPlanWith3Shipments, prepaidPlanWith6Shipments]
+            })
+          });
+
+          expect(actual).toEqual([
+            {
+              id: BOTH_ELIGIBLE_PRODUCT_ID,
+              frequency: 'yum selling plan id 2'
+            }
+          ]);
+          expect(actual[0].prepaidShipments).toBeUndefined();
+        });
+      });
     });
   });
 
@@ -756,6 +997,69 @@ describe('optedin', () => {
         }
       ]);
     });
+
+    describe('given frequency is PREPAID_PLACEHOLDER', () => {
+      describe('given prepaidSellingPlans exist for variant', () => {
+        it('should replace prepaid placeholder optin', () => {
+          const actual = optedin(
+            [
+              {
+                id: PREPAID_PRODUCT_ID,
+                frequency: 'prepaid-replace-me',
+                prepaidShipments: null
+              }
+            ],
+            {
+              type: constants.SETUP_PRODUCT,
+              payload: {
+                product: {
+                  variants: [{ id: PREPAID_PRODUCT_ID }],
+                  selling_plan_groups: [
+                    buildPrepaidSellingPlanGroup(PREPAID_PRODUCT_ID, [
+                      prepaidPlanWith3Shipments,
+                      prepaidPlanWith6Shipments
+                    ])
+                  ]
+                }
+              }
+            }
+          );
+
+          expect(actual).toEqual([
+            {
+              id: PREPAID_PRODUCT_ID,
+              frequency: PREPAID_PLAN_6_SHIPMENTS,
+              prepaidShipments: 6
+            }
+          ]);
+        });
+      });
+
+      describe('given prepaidSellingPlans do NOT exist for variant', () => {
+        it('should remove placeholder optin', () => {
+          const actual = optedin(
+            [
+              {
+                id: PREPAID_PRODUCT_ID,
+                frequency: 'prepaid-replace-me',
+                prepaidShipments: null
+              }
+            ],
+            {
+              type: constants.SETUP_PRODUCT,
+              payload: {
+                product: {
+                  variants: [{ id: PREPAID_PRODUCT_ID }],
+                  selling_plan_groups: []
+                }
+              }
+            }
+          );
+
+          expect(actual).toEqual([]);
+        });
+      });
+    });
   });
 
   describe('given action is PRODUCT_CHANGE_PREPAID_SHIPMENTS', () => {
@@ -807,6 +1111,49 @@ describe('optedin', () => {
     });
   });
 
+  it('integration: SETUP_PRODUCT after RECEIVE_OFFER should handle default prepaid optin', () => {
+    // Step 1: RECEIVE_OFFER creates optin with placeholder (no prepaidSellingPlans available yet)
+    const afterReceiveOffer = optedin([], {
+      type: constants.RECEIVE_OFFER,
+      payload: buildReceiveOfferPayload({
+        autoship: {
+          [PREPAID_PRODUCT_ID]: false
+        },
+        autoship_by_default: {
+          [PREPAID_PRODUCT_ID]: true
+        },
+        in_stock: {
+          [PREPAID_PRODUCT_ID]: true
+        },
+        eligibility_groups: {
+          [PREPAID_PRODUCT_ID]: [constants.ELIGIBILITY_GROUPS.PREPAID]
+        },
+        prepaidSellingPlans: []
+      })
+    });
+
+    // Step 2: SETUP_PRODUCT replaces placeholder with actual selling plan
+    const afterSetupProduct = optedin(afterReceiveOffer, {
+      type: constants.SETUP_PRODUCT,
+      payload: {
+        product: {
+          variants: [{ id: PREPAID_PRODUCT_ID }],
+          selling_plan_groups: [
+            buildPrepaidSellingPlanGroup(PREPAID_PRODUCT_ID, [prepaidPlanWith3Shipments, prepaidPlanWith6Shipments])
+          ]
+        }
+      }
+    });
+
+    expect(afterSetupProduct).toEqual([
+      {
+        id: PREPAID_PRODUCT_ID,
+        frequency: PREPAID_PLAN_6_SHIPMENTS,
+        prepaidShipments: 6
+      }
+    ]);
+  });
+
   it('should return unmodified state given unsupported action', () => {
     const actual = optedin(
       { 'yum existing key': 'yum existing value' },

package/src/shopify/reducers/config.ts

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