@ordergroove/offers 2.37.0 → 2.37.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ordergroove/offers",
-  "version": "2.37.0",
+  "version": "2.37.1",
   "description": "offer state component",
   "author": "Eugenio Lattanzio <eugenio63@gmail.com>",
   "homepage": "https://github.com/ordergroove/plush-toys#readme",
@@ -48,5 +48,5 @@
     "@ordergroove/offers-templates": "^0.9.6",
     "@types/lodash.memoize": "^4.1.9"
   },
-  "gitHead": "e702e182ecc53ced69c632d6269bb8f98c778b42"
+  "gitHead": "86082af8c6c8146e19c68a17e5a374873c4d595d"
 }

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

@@ -47,23 +47,44 @@ describe('autoshipEligible', () => {
     expect(actual).toEqual({ 'yum key 1': null, 'yum key 2': null });
   });
 
+  const sellingPlans = {
+    default: 1,
+    prepaid1: 2,
+    prepaid2: 3,
+    psfl: 4
+  };
+  function getSetupProductPayload({ productSellingPlans, variants = {}, additionalSellingPlanGroups = {} } = {}) {
+    const sellingPlanGroups = {
+      'Subscribe and Save': [sellingPlans.default],
+      ...additionalSellingPlanGroups
+    };
+    return {
+      product: {
+        id: 'yum product id',
+        selling_plan_allocations: productSellingPlans?.map(id => ({ selling_plan_id: id })),
+        variants: Object.entries(variants).map(([productId, sellingPlanIds]) => ({
+          id: productId,
+          selling_plan_allocations: sellingPlanIds.map(id => ({ selling_plan_id: id }))
+        })),
+        selling_plan_groups: Object.entries(sellingPlanGroups).map(([sellingPlanName, sellingPlanIds]) => ({
+          name: sellingPlanName,
+          selling_plans: sellingPlanIds.map(id => ({ id }))
+        }))
+      }
+    };
+  }
+
   it('should return true for each product and variant given action SETUP_PRODUCT and products have selling plan allocations', () => {
     const actual = autoshipEligible(
       {},
       {
         type: constants.SETUP_PRODUCT,
-        payload: {
-          product: {
-            id: 'yum product id',
-            selling_plan_allocations: [{ 'yum key': 'yum value' }],
-            variants: [
-              {
-                id: 'yum variant id',
-                selling_plan_allocations: [{ 'yum key': 'yum value' }]
-              }
-            ]
+        payload: getSetupProductPayload({
+          productSellingPlans: [sellingPlans.default],
+          variants: {
+            'yum variant id': [sellingPlans.default]
           }
-        }
+        })
       }
     );
 
@@ -75,18 +96,11 @@ describe('autoshipEligible', () => {
       {},
       {
         type: constants.SETUP_PRODUCT,
-        payload: {
-          product: {
-            id: 'yum product id',
-            selling_plan_allocations: [],
-            variants: [
-              {
-                id: 'yum variant id',
-                selling_plan_allocations: []
-              }
-            ]
+        payload: getSetupProductPayload({
+          variants: {
+            'yum variant id': []
           }
-        }
+        })
       }
     );
 
@@ -110,51 +124,17 @@ describe('autoshipEligible', () => {
       {},
       {
         type: constants.SETUP_PRODUCT,
-        payload: {
-          product: {
-            id: 'yum product id',
-            selling_plan_allocations: [],
-            variants: [
-              {
-                id: 'single-non-prepaid',
-                selling_plan_allocations: [{ selling_plan_id: 1 }]
-              },
-              {
-                id: 'prepaid-and-non-prepaid',
-                selling_plan_allocations: [{ selling_plan_id: 1 }, { selling_plan_id: 2 }]
-              },
-              {
-                id: 'single-prepaid',
-                selling_plan_allocations: [{ selling_plan_id: 2 }]
-              },
-              {
-                id: 'multiple-prepaid',
-                selling_plan_allocations: [{ selling_plan_id: 2 }, { selling_plan_id: 3 }]
-              }
-            ],
-            selling_plan_groups: [
-              {
-                name: 'Subscribe and Save',
-                selling_plans: [
-                  {
-                    id: 1
-                  }
-                ]
-              },
-              {
-                name: 'Prepaid-yum variant id',
-                selling_plans: [
-                  {
-                    id: 2
-                  },
-                  {
-                    id: 3
-                  }
-                ]
-              }
-            ]
+        payload: getSetupProductPayload({
+          variants: {
+            'single-non-prepaid': [sellingPlans.default],
+            'prepaid-and-non-prepaid': [sellingPlans.default, sellingPlans.prepaid1],
+            'single-prepaid': [sellingPlans.prepaid1],
+            'multiple-prepaid': [sellingPlans.prepaid1, sellingPlans.prepaid2]
+          },
+          additionalSellingPlanGroups: {
+            'Prepaid-yum variant id': [sellingPlans.prepaid1, sellingPlans.prepaid2]
           }
-        }
+        })
       }
     );
 
@@ -166,6 +146,32 @@ describe('autoshipEligible', () => {
       'multiple-prepaid': false
     });
   });
+
+  it('should return false if there are only PSFL selling plans', () => {
+    const actual = autoshipEligible(
+      {},
+      {
+        type: constants.SETUP_PRODUCT,
+        payload: getSetupProductPayload({
+          variants: {
+            'single-non-psfl': [sellingPlans.default],
+            'sub-eligible-psfl': [sellingPlans.default, sellingPlans.psfl],
+            'not-sub-eligible-psfl': [sellingPlans.psfl]
+          },
+          additionalSellingPlanGroups: {
+            og_psfl_2m: [sellingPlans.psfl]
+          }
+        })
+      }
+    );
+
+    expect(actual).toEqual({
+      'yum product id': false,
+      'single-non-psfl': true,
+      'sub-eligible-psfl': true,
+      'not-sub-eligible-psfl': false
+    });
+  });
 });
 
 describe('config', () => {

package/src/shopify/shopifyReducer.js

@@ -131,10 +131,11 @@ const getOGSellingPlanGroup = product => {
     isProductSpecificFrequencySellingPlanGroup
   );
 
-  return (
-    productSpecificFrequencySellingPlanGroup ||
-    product?.selling_plan_groups.find(group => group.name === DEFAULT_PAY_AS_YOU_GO_GROUP_NAME)
-  );
+  return productSpecificFrequencySellingPlanGroup || getDefaultSubscriptionSellingPlanGroup(product);
+};
+
+const getDefaultSubscriptionSellingPlanGroup = product => {
+  return product?.selling_plan_groups.find(group => group.name === DEFAULT_PAY_AS_YOU_GO_GROUP_NAME);
 };
 
 const isProductSpecificFrequencySellingPlanGroup = group => group.name.startsWith('og_psfl');
@@ -151,28 +152,6 @@ const reduceProductCartLine = (acc, cur) => {
   return { ...acc, [cur.key]: acc[productId] || null };
 };
 
-const isPrepaidSellingPlanGroup = sellingPlanGroup => sellingPlanGroup.name.toUpperCase().includes('PREPAID');
-
-const filterNonPrepaidSellingPlans = (sellingPlanAllocations, sellingPlanGroups) => {
-  if (!sellingPlanAllocations || sellingPlanAllocations.length === 0) {
-    return [];
-  }
-  if (!sellingPlanGroups || sellingPlanGroups.length === 0) {
-    return sellingPlanAllocations;
-  }
-
-  const nonPrepaidSellingPlansIds = sellingPlanGroups.reduce((allIds, group) => {
-    if (!isPrepaidSellingPlanGroup(group)) {
-      allIds.push(...group.selling_plans.map(sellingPlan => sellingPlan.id));
-    }
-    return allIds;
-  }, []);
-
-  return sellingPlanAllocations.filter(sellingPlanAllocation =>
-    nonPrepaidSellingPlansIds.includes(sellingPlanAllocation.selling_plan_id)
-  );
-};
-
 export const autoshipEligible = (state = {}, action) => {
   if (constants.RECEIVE_PRODUCT_PLANS === action.type) {
     return Object.entries(action.payload).reduce(productTrue, state);
@@ -185,15 +164,23 @@ export const autoshipEligible = (state = {}, action) => {
     const {
       payload: { product }
     } = action;
+    const defaultSellingPlanGroup = getDefaultSubscriptionSellingPlanGroup(product);
+    const sellingPlanIdsInDefaultGroup = new Set(
+      defaultSellingPlanGroup?.selling_plans.map(sellingPlan => sellingPlan.id) ?? []
+    );
     return [product, ...(product?.variants || [])]?.reduce((acc, cur) => {
-      const selling_plans_without_prepaid = filterNonPrepaidSellingPlans(
-        cur?.selling_plan_allocations,
-        product?.selling_plan_groups
-      );
+      const productSellingPlansFromDefaultGroup =
+        cur?.selling_plan_allocations?.filter(sellingPlan =>
+          sellingPlanIdsInDefaultGroup.has(sellingPlan.selling_plan_id)
+        ) ?? [];
+
+      // a product is autoship eligible if it has plans from the default "Subscribe and Save" selling plan group
+      // the presence of other selling plans (prepaid, product-specific frequencies) does not mean it is autoship eligible
+      const isAutoshipEligible = productSellingPlansFromDefaultGroup.length > 0;
 
       return {
-        ...overrideLineKey(acc, cur.id, selling_plans_without_prepaid?.length > 0),
-        [cur.id]: selling_plans_without_prepaid?.length > 0
+        ...overrideLineKey(acc, cur.id, isAutoshipEligible),
+        [cur.id]: isAutoshipEligible
       };
     }, state);
   }