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

package/src/core/utils.ts

@@ -1,6 +1,7 @@
 import platform from '../platform';
 import { ENV_PROD, ENV_STAGING, STAGING_STATIC_HOST, STATIC_HOST } from './constants';
 import { isSameProduct } from './selectors';
+import { ConfigState } from './types/reducer';
 
 export function onReady(fn) {
   if (document.readyState === 'loading') {
@@ -47,33 +48,45 @@ export const safeProductId = product => {
   return productId;
 };
 
+type Frequencies = ConfigState['frequencies'];
+type FrequenciesEveryPeriod = ConfigState['frequenciesEveryPeriod'];
+
 /**
  * Returns the OG frequency if platform is running on selling plans
- * @param initialFrequency
- * @param config
  */
-export const safeOgFrequency = (initialFrequency, config) => {
+export const safeOgFrequency = (
+  initialFrequency: string | null,
+  frequencies: Frequencies,
+  frequenciesEveryPeriod: FrequenciesEveryPeriod
+) => {
   if (platform.shopify_selling_plans) {
-    const ix = config.frequencies?.indexOf(initialFrequency);
-    if (ix >= 0 && config.frequenciesEveryPeriod[ix]) {
-      return config.frequenciesEveryPeriod[ix];
+    const ix = frequencies?.indexOf(initialFrequency);
+    if (ix >= 0 && frequenciesEveryPeriod[ix]) {
+      return frequenciesEveryPeriod[ix];
     }
   }
   return initialFrequency;
 };
 
-export const frequencyToSellingPlan = (ogFrequency, config) => {
+export const frequencyToSellingPlan = (
+  ogFrequency: string,
+  frequencyConfig: {
+    frequencies: Frequencies;
+    frequenciesEveryPeriod: FrequenciesEveryPeriod;
+  }
+) => {
   // og frequency contains underscore
   if (!`${ogFrequency}`.includes('_')) return ogFrequency;
-  const ix = config.frequenciesEveryPeriod?.indexOf(ogFrequency);
-  if (ix >= 0 && config.frequenciesEveryPeriod[ix]) {
-    return config.frequencies[ix];
+  const { frequencies, frequenciesEveryPeriod } = frequencyConfig;
+  const ix = frequenciesEveryPeriod?.indexOf(ogFrequency);
+  if (ix >= 0 && frequenciesEveryPeriod[ix]) {
+    return frequencies[ix];
   }
 
   // if we can't find the OG frequency, but we have selling plans, return the first selling plan
-  if (config.frequencies?.length > 0 && config.frequenciesEveryPeriod?.length > 0) {
+  if (frequencies?.length > 0 && frequenciesEveryPeriod?.length > 0) {
     console.warn(`Unable to find selling plan match for frequency ${ogFrequency}; falling back to first selling plan`);
-    return config.frequencies[0];
+    return frequencies[0];
   }
 
   return ogFrequency;
@@ -110,14 +123,18 @@ export function getCookieValue(cookieId) {
   const cookie = document.cookie.match(`(^|;) ?${cookieId}=([^;]*)(;|$)`);
   return cookie ? cookie[2] : null;
 }
-export const isOgFrequency = frequency => !!(frequency && frequency?.includes('_'));
+export const isOgFrequency = (frequency: string) => !!(frequency && frequency?.includes('_'));
 
-export const getFirstSellingPlan = (frequencies = []) => frequencies?.[0] || null;
+export const getFirstSellingPlan = (frequencies: string[] = []) => frequencies?.[0] || null;
 
 export const hasShopifySellingPlans = (sellingPlans = [], frequenciesEveryPeriod = []) =>
   !!(platform?.shopify_selling_plans && sellingPlans.length && frequenciesEveryPeriod.length);
 
-export const mapFrequencyToSellingPlan = (sellingPlans, frequenciesEveryPeriod, frequency) => {
+export const mapFrequencyToSellingPlan = (
+  sellingPlans: string[],
+  frequenciesEveryPeriod: string[],
+  frequency: string
+) => {
   if (sellingPlans.length !== frequenciesEveryPeriod.length) {
     return null;
   }

package/src/make-api.js

@@ -164,7 +164,7 @@ export default function makeApi(store) {
      * @param {*} merchantId
      * @param {*} env
      * @param {*} authUrl
-     * @param {import('./types').MerchantSettings} merchantSettings
+     * @param {import('./core/types/api').MerchantSettings} merchantSettings
      */
     initialize(merchantId, env, authUrl, merchantSettings = {}) {
       // settings resolves once, before anything.

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

@@ -0,0 +1,497 @@
+import config from '../../reducers/config';
+import * as constants from '../../../core/constants';
+import { DEFAULT_PAY_AS_YOU_GO_GROUP_NAME } from '../../utils';
+
+describe('config', () => {
+  it('should return unique frequencies given action RECEIVE_PRODUCT_PLANS', () => {
+    const actual = config(
+      {},
+      {
+        type: constants.RECEIVE_PRODUCT_PLANS,
+        payload: {
+          'product plan id': { '1_1': {}, '3_1': {} }
+        }
+      }
+    );
+
+    expect(actual).toEqual(
+      jasmine.objectContaining({
+        frequencies: ['1_1', '3_1']
+      })
+    );
+  });
+
+  it('should set defaultFrequency to selling plan given selling plan exists for frequency given action SETUP_PRODUCT', () => {
+    const actual = config(
+      {
+        defaultFrequency: '1_2'
+      },
+      {
+        type: constants.SETUP_PRODUCT,
+        payload: {
+          offer: {
+            config: {
+              frequencies: ['yum selling plan id 1', 'yum selling plan id 2'],
+              frequenciesEveryPeriod: ['1_1', '1_2']
+            }
+          },
+          product: {
+            selling_plan_groups: [
+              {
+                name: DEFAULT_PAY_AS_YOU_GO_GROUP_NAME,
+                selling_plans: [
+                  {
+                    id: 'yum selling plan id 1',
+                    options: [
+                      {
+                        value: '1 day'
+                      }
+                    ]
+                  },
+                  {
+                    id: 'yum selling plan id 2',
+                    options: [
+                      {
+                        value: '1 week'
+                      }
+                    ]
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      }
+    );
+
+    expect(actual).toEqual(
+      jasmine.objectContaining({
+        defaultFrequency: 'yum selling plan id 2'
+      })
+    );
+  });
+
+  it('should set defaultFrequency to first selling plan given selling plan does not exist for frequency given action SETUP_PRODUCT', () => {
+    const actual = config(
+      {
+        defaultFrequency: '1_3'
+      },
+      {
+        type: constants.SETUP_PRODUCT,
+        payload: {
+          offer: {
+            config: {
+              frequencies: ['yum selling plan id 1', 'yum selling plan id 2'],
+              frequenciesEveryPeriod: ['1_1', '1_2']
+            }
+          },
+          product: {
+            selling_plan_groups: [
+              {
+                name: DEFAULT_PAY_AS_YOU_GO_GROUP_NAME,
+                selling_plans: [
+                  {
+                    id: 'yum selling plan id 1',
+                    options: [
+                      {
+                        value: '1 day'
+                      }
+                    ]
+                  },
+                  {
+                    id: 'yum selling plan id 2',
+                    options: [
+                      {
+                        value: '1 week'
+                      }
+                    ]
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      }
+    );
+
+    expect(actual).toEqual(
+      jasmine.objectContaining({
+        defaultFrequency: 'yum selling plan id 1'
+      })
+    );
+  });
+
+  it('should not change default frequency if is already a selling plan given action SETUP_PRODUCT', () => {
+    const actual = config(
+      {
+        defaultFrequency: 'yum selling plan id 5'
+      },
+      {
+        type: constants.SETUP_PRODUCT,
+        payload: {
+          offer: {
+            config: {
+              frequencies: ['yum selling plan id 1', 'yum selling plan id 2'],
+              frequenciesEveryPeriod: ['1_1', '1_2']
+            }
+          },
+          product: {
+            selling_plan_groups: [
+              {
+                name: DEFAULT_PAY_AS_YOU_GO_GROUP_NAME,
+                selling_plans: [
+                  {
+                    id: 'yum selling plan id 1',
+                    options: [
+                      {
+                        value: '1 day'
+                      }
+                    ]
+                  },
+                  {
+                    id: 'yum selling plan id 2',
+                    options: [
+                      {
+                        value: '1 week'
+                      }
+                    ]
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      }
+    );
+
+    expect(actual).toEqual(
+      jasmine.objectContaining({
+        defaultFrequency: 'yum selling plan id 5'
+      })
+    );
+  });
+
+  const defaultSellingPlanPayload = {
+    product: {
+      selling_plan_groups: [
+        {
+          name: DEFAULT_PAY_AS_YOU_GO_GROUP_NAME,
+          selling_plans: [
+            {
+              id: 'yum selling plan id 1'
+            },
+            {
+              id: 'yum selling plan id 2'
+            }
+          ]
+        }
+      ]
+    }
+  };
+
+  it('should return selling plan ids as frequencies given action SETUP_PRODUCT', () => {
+    const actual = config(
+      {},
+      {
+        type: constants.SETUP_PRODUCT,
+        payload: defaultSellingPlanPayload
+      }
+    );
+
+    expect(actual).toEqual(
+      jasmine.objectContaining({
+        frequencies: ['yum selling plan id 1', 'yum selling plan id 2'],
+        hasProductSpecificFrequencies: false
+      })
+    );
+  });
+
+  it('should return values of first OG selling plan group as frequencies text given action SETUP_PRODUCT', () => {
+    const actual = config(
+      {},
+      {
+        type: constants.SETUP_PRODUCT,
+        payload: {
+          product: {
+            selling_plan_groups: [
+              {
+                name: 'Old Selling Plan Group',
+                options: [{ values: 'old yum values' }],
+                selling_plans: [
+                  {
+                    id: 'old yum selling plan id'
+                  }
+                ]
+              },
+              {
+                name: DEFAULT_PAY_AS_YOU_GO_GROUP_NAME,
+                options: [{ values: 'yum values' }],
+                selling_plans: [
+                  {
+                    id: 'yum selling plan id'
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      }
+    );
+
+    expect(actual).toEqual(
+      jasmine.objectContaining({
+        frequenciesText: 'yum values'
+      })
+    );
+  });
+
+  it('should use product-specific frequency selling plan groups if present', () => {
+    const actual = config(
+      {},
+      {
+        type: constants.SETUP_PRODUCT,
+        payload: {
+          product: {
+            selling_plan_groups: [
+              {
+                name: 'og_psfl_2m4m6m',
+                options: [
+                  {
+                    values: ['2 months', '4 months', '6 months']
+                  }
+                ],
+                selling_plans: [
+                  {
+                    id: 'psfl-id-1'
+                  },
+                  {
+                    id: 'psfl-id-2'
+                  },
+                  {
+                    id: 'psfl-id-3'
+                  }
+                ]
+              },
+              {
+                name: 'Subscribe and Save',
+                options: [
+                  {
+                    values: ['month', '2 months', '3 months']
+                  }
+                ],
+                selling_plans: [
+                  {
+                    id: 'regular-id-1'
+                  },
+                  {
+                    id: 'regular-id-2'
+                  },
+                  {
+                    id: 'regular-id-3'
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      }
+    );
+
+    expect(actual).toEqual(
+      jasmine.objectContaining({
+        frequencies: ['psfl-id-1', 'psfl-id-2', 'psfl-id-3'],
+        hasProductSpecificFrequencies: true
+      })
+    );
+  });
+
+  it('does not overwrite hasProductSpecificFrequencies on subsequent calls', () => {
+    const actual = config(
+      {
+        hasProductSpecificFrequencies: true
+      },
+      {
+        type: constants.SETUP_PRODUCT,
+        payload: defaultSellingPlanPayload
+      }
+    );
+
+    expect(actual).toEqual(
+      jasmine.objectContaining({
+        hasProductSpecificFrequencies: true
+      })
+    );
+  });
+
+  it('should set prepaidSellingPlans', () => {
+    const sellingPlanGroups = [
+      {
+        name: 'Prepaid-43017264201944',
+        selling_plans: [
+          {
+            id: 2146042072,
+            name: 'Delivered every 2 months, prepaid for 4 shipments',
+            options: [
+              { name: 'Delivery every', position: 1, value: 'PREPAID-2 months' },
+              { name: 'Shipment amount', position: 2, value: '4 shipments' }
+            ]
+          }
+        ]
+      }
+    ];
+    const actual = config(
+      {},
+      {
+        type: constants.SETUP_PRODUCT,
+        payload: {
+          product: {
+            selling_plan_groups: sellingPlanGroups
+          }
+        }
+      }
+    );
+    expect(actual).toEqual(
+      jasmine.objectContaining({
+        prepaidSellingPlans: {
+          43017264201944: [
+            {
+              numberShipments: 4,
+              sellingPlan: '2146042072'
+            }
+          ]
+        }
+      })
+    );
+  });
+
+  it('should add prepaidSellingPlans on top of old ones', () => {
+    const sellingPlanGroups = [
+      {
+        name: 'Prepaid-43017264201946',
+        selling_plans: [
+          {
+            id: 2146042072,
+            name: 'Delivered every 1 months, prepaid for 3 shipments',
+            options: [
+              { name: 'Delivery every', position: 1, value: 'PREPAID-1 months' },
+              { name: 'Shipment amount', position: 2, value: '3 shipments' }
+            ]
+          }
+        ]
+      },
+      {
+        name: 'Prepaid-43017264201945',
+        selling_plans: [
+          {
+            id: 2146042073,
+            name: 'Delivered every 3 months, prepaid for 5 shipments',
+            options: [
+              { name: 'Delivery every', position: 1, value: 'PREPAID-3 months' },
+              { name: 'Shipment amount', position: 2, value: '5 shipments' }
+            ]
+          }
+        ]
+      }
+    ];
+    const actual = config(
+      {
+        prepaidSellingPlans: {
+          43017264201946: [
+            {
+              numberShipments: 1,
+              sellingPlan: '2146042072'
+            }
+          ],
+          43017264201944: [
+            {
+              numberShipments: 4,
+              sellingPlan: '2146042071'
+            }
+          ]
+        }
+      },
+      {
+        type: constants.SETUP_PRODUCT,
+        payload: {
+          product: {
+            selling_plan_groups: sellingPlanGroups
+          }
+        }
+      }
+    );
+    expect(actual).toEqual(
+      jasmine.objectContaining({
+        prepaidSellingPlans: {
+          43017264201944: [
+            {
+              numberShipments: 4,
+              sellingPlan: '2146042071'
+            }
+          ],
+          43017264201946: [
+            {
+              numberShipments: 3,
+              sellingPlan: '2146042072'
+            }
+          ],
+          43017264201945: [
+            {
+              numberShipments: 5,
+              sellingPlan: '2146042073'
+            }
+          ]
+        }
+      })
+    );
+  });
+
+  it('should return unmodified state given unsupported action', () => {
+    const actual = config(
+      { 'yum existing key': 'yum existing value' },
+      {
+        type: 'yum unsupported action',
+        payload: {}
+      }
+    );
+
+    expect(actual).toEqual({ 'yum existing key': 'yum existing value' });
+  });
+
+  it('should not set prepaid selling plan as a defaultFrequency', () => {
+    const initial = {
+      frequencies: ['yum selling plan id 1', 'yum selling plan id 4'],
+      frequenciesEveryPeriod: ['1_1', '1_4'],
+      prepaidSellingPlans: {
+        123: [
+          {
+            sellingPlan: 'prepaid selling plan'
+          }
+        ]
+      },
+      productFrequencies: {
+        123: {
+          frequencies: ['yum selling plan id 1', 'yum selling plan id 4'],
+          frequenciesEveryPeriod: ['1_1', '1_4']
+        }
+      }
+    };
+    const actual = config(initial, {
+      type: constants.RECEIVE_OFFER,
+      payload: {
+        offer: {
+          product: { id: 123 },
+          defaultFrequency: 'prepaid selling plan'
+        }
+      }
+    });
+    expect(actual).toEqual({
+      ...initial,
+      defaultFrequency: 'yum selling plan id 1',
+      productFrequencies: {
+        123: jasmine.objectContaining({
+          defaultFrequency: 'yum selling plan id 1'
+        })
+      }
+    });
+  });
+});