@ordergroove/offers 2.46.0 → 2.46.1-alpha-PR-1280-4.55

package/src/core/__tests__/selectors.spec.js

@@ -5,7 +5,9 @@ import {
   templatesSelector,
   makeProductSpecificDefaultFrequencySelector,
   makeProductPrepaidShipmentOptionsSelector,
-  makeProductFrequenciesSelector
+  makeProductFrequenciesSelector,
+  makeDiscountedProductPriceSelector,
+  isShopifyDiscountFunctionInUseSelector
 } from '../selectors';
 import { stringifyFrequency } from '../api';
 
@@ -231,3 +233,405 @@ describe('makeProductFrequenciesSelector', () => {
     });
   });
 });
+
+describe('makeDiscountedProductPriceSelector', () => {
+  /** @returns {import('../types/reducer').State} */
+  function makeTestState({
+    incentives = [
+      {
+        object: 'item',
+        field: 'total_price',
+        type: 'Discount Percent',
+        value: 11,
+        criteria: {
+          node_type: 'PREMISE',
+          standard: 'PROGRAM_WIDE'
+        }
+      }
+    ],
+    price = 1000,
+    currency = 'USD',
+    productId = 123
+  } = {}) {
+    return {
+      config: {
+        storeCurrency: currency
+      },
+      price: {
+        [productId]: { value: price }
+      },
+      incentives: {
+        [productId]: {
+          initial: incentives,
+          ongoing: []
+        }
+      }
+    };
+  }
+
+  it('applies Discount Percent incentive (USD)', () => {
+    const selector = makeDiscountedProductPriceSelector(123);
+    const result = selector(makeTestState());
+    expect(result).toEqual({
+      regularPrice: '$10.00',
+      discountRate: '11%',
+      subscriptionPrice: '$8.90'
+    });
+  });
+
+  it('applies Discount Amount incentive (USD)', () => {
+    const selector = makeDiscountedProductPriceSelector(123);
+    const result = selector(
+      makeTestState({
+        incentives: [
+          {
+            object: 'item',
+            field: 'total_price',
+            type: 'Discount Amount',
+            value: 2.5, // $2.50 off
+            criteria: {
+              node_type: 'PREMISE',
+              standard: 'PROGRAM_WIDE'
+            }
+          }
+        ]
+      })
+    );
+    expect(result).toEqual({
+      regularPrice: '$10.00',
+      discountRate: '$2.50',
+      subscriptionPrice: '$7.50'
+    });
+  });
+
+  it('handles Discount Amount larger than price', () => {
+    const selector = makeDiscountedProductPriceSelector(123);
+    const result = selector(
+      makeTestState({
+        incentives: [
+          {
+            object: 'item',
+            field: 'total_price',
+            type: 'Discount Amount',
+            value: 15, // $15.00 off
+            criteria: {
+              node_type: 'PREMISE',
+              standard: 'PROGRAM_WIDE'
+            }
+          }
+        ]
+      })
+    );
+    expect(result).toEqual({
+      regularPrice: '$10.00',
+      discountRate: '$10.00',
+      subscriptionPrice: '$0.00'
+    });
+  });
+
+  it('does not apply Discount Amount for non-USD currency', () => {
+    const selector = makeDiscountedProductPriceSelector(123);
+    const result = selector(
+      makeTestState({
+        incentives: [
+          {
+            object: 'item',
+            field: 'total_price',
+            type: 'Discount Amount',
+            value: 2.5,
+            criteria: {
+              node_type: 'PREMISE',
+              standard: 'PROGRAM_WIDE'
+            }
+          }
+        ],
+        currency: 'EUR'
+      })
+    );
+    expect(result).toEqual({
+      regularPrice: '€10.00',
+      discountRate: '€0.00', // no discount applied
+      subscriptionPrice: '€10.00'
+    });
+  });
+
+  it('applies Discount Percent for non-USD currency', () => {
+    const selector = makeDiscountedProductPriceSelector(123);
+    const result = selector(
+      makeTestState({
+        incentives: [
+          {
+            object: 'item',
+            field: 'total_price',
+            type: 'Discount Percent',
+            value: 20,
+            criteria: {
+              node_type: 'PREMISE',
+              standard: 'PROGRAM_WIDE'
+            }
+          }
+        ],
+        currency: 'GBP'
+      })
+    );
+    expect(result).toEqual({
+      regularPrice: '£10.00',
+      discountRate: '20%',
+      subscriptionPrice: '£8.00'
+    });
+  });
+
+  it('handles missing price for product', () => {
+    const selector = makeDiscountedProductPriceSelector(123);
+    const state = makeTestState({ productId: 123 });
+    delete state.price[123];
+
+    const result = selector(state);
+    expect(result).toEqual({});
+  });
+
+  it('handles empty incentives array', () => {
+    const selector = makeDiscountedProductPriceSelector(123);
+    const result = selector(makeTestState({ incentives: [] }));
+    expect(result).toEqual({
+      regularPrice: '$10.00',
+      discountRate: '$0.00',
+      subscriptionPrice: '$10.00'
+    });
+  });
+
+  it('applies 100% discount', () => {
+    const selector = makeDiscountedProductPriceSelector(123);
+    const result = selector(
+      makeTestState({
+        incentives: [
+          {
+            object: 'item',
+            field: 'total_price',
+            type: 'Discount Percent',
+            value: 100,
+            criteria: {
+              node_type: 'PREMISE',
+              standard: 'PROGRAM_WIDE'
+            }
+          }
+        ]
+      })
+    );
+    expect(result).toEqual({
+      regularPrice: '$10.00',
+      discountRate: '100%',
+      subscriptionPrice: '$0.00'
+    });
+  });
+
+  it('handles zero price', () => {
+    const selector = makeDiscountedProductPriceSelector(123);
+    const result = selector(
+      makeTestState({
+        price: 0
+      })
+    );
+    expect(result).toEqual({
+      regularPrice: '$0.00',
+      discountRate: '11%',
+      subscriptionPrice: '$0.00'
+    });
+  });
+
+  it('ignores unknown incentive types', () => {
+    const selector = makeDiscountedProductPriceSelector(123);
+    const result = selector(
+      makeTestState({
+        incentives: [
+          {
+            object: 'item',
+            field: 'total_price',
+            type: 'Unknown Type',
+            value: 50,
+            criteria: {
+              node_type: 'PREMISE',
+              standard: 'PROGRAM_WIDE'
+            }
+          }
+        ],
+        price: 1000
+      })
+    );
+    expect(result).toEqual({
+      regularPrice: '$10.00',
+      discountRate: '$0.00',
+      subscriptionPrice: '$10.00'
+    });
+  });
+
+  it('filters out irrelevant incentives', () => {
+    const selector = makeDiscountedProductPriceSelector(123);
+    const result = selector(
+      makeTestState({
+        incentives: [
+          {
+            object: 'order',
+            field: 'total_price',
+            type: 'Discount Percent',
+            value: 50,
+            criteria: {
+              node_type: 'PREMISE',
+              standard: 'PROGRAM_WIDE'
+            }
+          },
+          {
+            object: 'order',
+            field: 'shipping_total',
+            type: 'Discount Percent',
+            value: 25,
+            criteria: {
+              node_type: 'PREMISE',
+              standard: 'PROGRAM_WIDE'
+            }
+          },
+
+          {
+            object: 'item',
+            field: 'total_price',
+            type: 'Discount Percent',
+            value: 33,
+            criteria: {
+              node_type: 'PREMISE',
+              standard: 'PREPAID_ORDERS_PER_BILLING'
+            }
+          },
+          {
+            object: 'item',
+            field: 'total_price',
+            type: 'Discount Percent',
+            value: 37,
+            criteria: {
+              node_type: 'AND',
+              children: [
+                {
+                  node_type: 'PREMISE',
+                  standard: 'NTH_ORDER_FOR_SUBSCRIBER',
+                  premise_value: 3,
+                  premise_operand: 'GREATER_THAN'
+                },
+                {
+                  node_type: 'PREMISE',
+                  standard: 'ITEM_HAS_SUBSCRIPTION',
+                  premise_value: true
+                }
+              ]
+            }
+          },
+          {
+            object: 'item',
+            field: 'total_price',
+            type: 'Discount Percent',
+            value: 10,
+            criteria: {
+              node_type: 'PREMISE',
+              standard: 'PROGRAM_WIDE'
+            }
+          }
+        ]
+      })
+    );
+    expect(result).toEqual({
+      regularPrice: '$10.00',
+      discountRate: '10%',
+      subscriptionPrice: '$9.00'
+    });
+  });
+
+  it('displays PSI incentive when available', () => {
+    const selector = makeDiscountedProductPriceSelector(123);
+    const result = selector(
+      makeTestState({
+        incentives: [
+          {
+            object: 'item',
+            field: 'total_price',
+            type: 'Discount Percent',
+            value: 15,
+            criteria: {
+              node_type: 'PREMISE',
+              standard: 'PSI'
+            }
+          }
+        ]
+      })
+    );
+    expect(result).toEqual({
+      regularPrice: '$10.00',
+      discountRate: '15%',
+      subscriptionPrice: '$8.50'
+    });
+  });
+
+  it('does not calculate a discount if no standardized incentives', () => {
+    const selector = makeDiscountedProductPriceSelector(123);
+    const result = selector(
+      makeTestState({
+        incentives: [
+          {
+            object: 'item',
+            field: 'total_price',
+            type: 'Discount Percent',
+            value: 50
+          }
+        ]
+      })
+    );
+    expect(result).toEqual({
+      regularPrice: '$10.00',
+      discountRate: '$0.00',
+      subscriptionPrice: '$10.00'
+    });
+  });
+});
+
+describe('isShopifyDiscountFunctionInUseSelector', () => {
+  it('should return false when productPlans is an empty object', () => {
+    const state = { productPlans: {} };
+    expect(isShopifyDiscountFunctionInUseSelector(state)).toBe(false);
+  });
+
+  it('should return false when productPlans has product with empty array', () => {
+    const state = { productPlans: { 123: [] } };
+    expect(isShopifyDiscountFunctionInUseSelector(state)).toBe(false);
+  });
+
+  it('should return false when some product plan does not have hasPriceAdjustments property', () => {
+    const state = {
+      productPlans: {
+        123: [{ id: 'plan-1' }],
+        456: [{ id: 'plan-2', hasPriceAdjustments: false }]
+      }
+    };
+    expect(isShopifyDiscountFunctionInUseSelector(state)).toBe(false);
+  });
+
+  it('should return false when some product plan has hasPriceAdjustments = true', () => {
+    const state = {
+      productPlans: {
+        123: [{ id: 'plan-1', hasPriceAdjustments: false }],
+        456: [{ id: 'plan-2', hasPriceAdjustments: true }]
+      }
+    };
+    expect(isShopifyDiscountFunctionInUseSelector(state)).toBe(false);
+  });
+
+  it('should return true when all product plans have hasPriceAdjustments = false or are prepaid', () => {
+    const state = {
+      productPlans: {
+        123: [{ id: 'plan-1', hasPriceAdjustments: false }],
+        456: [
+          { id: 'plan-2', hasPriceAdjustments: false },
+          { id: 'plan-3', hasPriceAdjustments: false },
+          { id: 'plan-3', hasPriceAdjustments: true, prepaidShipments: 3 }
+        ]
+      }
+    };
+    expect(isShopifyDiscountFunctionInUseSelector(state)).toBe(true);
+  });
+});

package/src/core/adapters.js

@@ -45,6 +45,8 @@ export const getProductsForPurchasePost = (state = {}, productIds = []) =>
  *     discountRate: '10%'
  *   },
  * ]
+ *
+ * @returns {import('./types/reducer').ProductPlansState}
  */
 export const getObjectStructuredProductPlans = (productPlans = {}) => {
   const adaptedProductPlans = {};

package/src/core/constants.js

@@ -54,6 +54,13 @@ export const ENV_PROD = 'prod';
 export const STATIC_HOST = 'static.ordergroove.com';
 export const STAGING_STATIC_HOST = 'staging.static.ordergroove.com';
 
+export const INCENTIVE_STANDARD_TYPES = {
+  PSI: 'PSI',
+  // note: this is a "pseudo-standard" that we set in our own code
+  // the API actually returns no criteria for program wide incentives
+  PROGRAM_WIDE: 'PROGRAM_WIDE'
+};
+
 /**
  * @event
  * Events that fires once optin/optout occurs on a cart offer

package/src/core/experiments.js

@@ -71,8 +71,9 @@ export function experimentsReducer(state = {}, action) {
  * object.
  */
 function resolveShopifySetupProductWhenExperiment(variant, product, experimentSettings) {
-  // So, on the sellingPlanGroup appId we are doing "ordergroove-subscribe-and-save-{experiment_variant_id}"
-  // this logic will only be enabled if we are in an experiment, there are at least 2 groups in the OG selling plan group
+  // When an experiment is running, you may have multiple selling plan groups with the app_id "ordergroove-subscribe-and-save-{experiment_variant_id}"
+  // We want offers to use only the selling plan group that matches the assigned experiment variant
+  // Note: whether or not you have variant-specific selling plan groups depends on if the Shopify Discount Function is being used. If it is, then the selling plan groups do not contain price adjustments and there is only a single selling plan group (all variants use the same group).
   if (!variant) return;
 
   if (experimentSettings.variants.length === 0) return;

package/src/core/reducer.ts

@@ -10,15 +10,19 @@ import {
   AutoshipByDefaultState,
   AutoshipEligibleState,
   ConfigState,
+  Incentive,
   IncentiveObject,
   IncentivesState,
   NextUpcomingOrderState,
   OptedInState,
   OptedOutState,
   PrepaidShipmentsSelectedState,
+  PriceState,
+  ProductPlansState,
   ReceiveOfferPayload
 } from './types/reducer';
 import { EmptyObject } from './types/utility';
+import { IncentiveDisplay, IncentivesDisplayEnhanced } from './types/api';
 
 export const optedin = (state: OptedInState = [], action): OptedInState => {
   switch (action.type) {
@@ -160,11 +164,28 @@ export const eligibilityGroups = (state = {}, action) => {
   }
 };
 
-const mapIncentive = (incentive, incentiveDisplay) => {
-  return incentive.map(i => ({
-    ...incentiveDisplay[i],
-    id: [i][0]
-  }));
+const mapIncentive = (
+  incentive: string[],
+  incentiveDisplay: IncentiveDisplay,
+  incentiveDisplayEnhanced?: IncentivesDisplayEnhanced
+): Incentive[] => {
+  return incentive.map(i => {
+    const enhanced = incentiveDisplayEnhanced?.[i];
+    return {
+      ...incentiveDisplay[i],
+      // for standard incentives, include the criteria so we know which kind of incentive (e.g. PSI, prepaid, etc)
+      ...(enhanced
+        ? {
+            criteria: enhanced.criteria
+              ? enhanced.criteria
+              : // when there is no criteria in the enhanced incentive, it means it's a program wide incentive
+                // for ease-of-use, we set use a "PROGRAM_WIDE" pseudo-standard here
+                { node_type: 'PREMISE', standard: constants.INCENTIVE_STANDARD_TYPES.PROGRAM_WIDE, premise_value: null }
+          }
+        : {}),
+      id: [i][0]
+    };
+  });
 };
 
 export const incentives = (
@@ -185,11 +206,19 @@ export const incentives = (
                   ...incentiveObj,
                   initial: [
                     ...(incentiveObj.initial || []),
-                    ...mapIncentive(initial, action.payload.incentives_display)
+                    ...mapIncentive(
+                      initial,
+                      action.payload.incentives_display,
+                      action.payload.incentives_display_enhanced
+                    )
                   ],
                   ongoing: [
                     ...(incentiveObj.ongoing || []),
-                    ...mapIncentive(ongoing, action.payload.incentives_display)
+                    ...mapIncentive(
+                      ongoing,
+                      action.payload.incentives_display,
+                      action.payload.incentives_display_enhanced
+                    )
                   ]
                 }),
                 {}
@@ -501,7 +530,7 @@ export const templates = (state = [], action) => {
   }
 };
 
-export const productPlans = (state = {}, action) => {
+export const productPlans = (state: ProductPlansState = {}, action): ProductPlansState => {
   switch (action.type) {
     case constants.RECEIVE_PRODUCT_PLANS:
       return getObjectStructuredProductPlans(action.payload);
@@ -533,6 +562,8 @@ export const prepaidShipmentsSelected = (
   }
 };
 
+export const price = (state: PriceState = {}, _action) => state;
+
 export default combineReducers({
   optedin,
   optedout,
@@ -561,5 +592,6 @@ export default combineReducers({
   defaultFrequencies,
   templates,
   productPlans,
-  prepaidShipmentsSelected
+  prepaidShipmentsSelected,
+  price
 });

package/src/core/selectors.ts

@@ -3,7 +3,9 @@ import memoize from 'lodash.memoize';
 import { stringifyFrequency } from './api';
 import platform from '../platform';
 import { mapFrequencyToSellingPlan, safeProductId } from './utils';
-import { OfferElement, ProductFrequencyConfig, State } from './types/reducer';
+import { Incentive, OfferElement, ProductFrequencyConfig, State } from './types/reducer';
+import { money, percentage } from '../shopify/utils';
+import { INCENTIVE_STANDARD_TYPES } from './constants';
 
 memoize.Cache = Map;
 
@@ -230,6 +232,59 @@ export const makeFrequencyForPrepaidShipmentsSelector = (product: BaseProduct, p
     }
   );
 
+/** 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(
+    (state: State) => state.price || {},
+    (state: State) => state.incentives || {},
+    (state: State) => state.config.storeCurrency,
+    (prices, incentives, currency) => {
+      const productPriceObj = prices[safeProductId(productId)];
+      if (productPriceObj === undefined || productPriceObj === null || !currency) return {};
+
+      const productPrice = productPriceObj.value;
+      let regularPrice = productPrice;
+      let subscriptionPrice = productPrice;
+
+      const productIncentives = incentives[safeProductId(productId)];
+      const incentive = productIncentives?.initial.find(findRelevantIncentive);
+
+      let formatted_discount = '';
+
+      if (incentive) {
+        if (incentive.type === 'Discount Percent') {
+          // note: productPrice is in cents ($10 => 1000), so we round to the nearest whole number after applying the discount
+          subscriptionPrice = Math.round((productPrice * (100 - incentive.value)) / 100);
+          formatted_discount = percentage(incentive.value);
+        } else if (incentive.type === 'Discount Amount' && currency === 'USD') {
+          // for now, we only support USD for "dollar-off" discounts
+          // productPrice is in cents, while the incentive value is in dollars, so we multiply by 100
+          subscriptionPrice = Math.max(0, productPrice - Math.round(incentive.value * 100));
+        }
+      }
+      return {
+        regularPrice: money(regularPrice, currency),
+        subscriptionPrice: money(subscriptionPrice, currency),
+        discountRate: formatted_discount || money(regularPrice - subscriptionPrice, currency)
+      };
+    }
+  )
+);
+
+const validIncentiveStandards = [INCENTIVE_STANDARD_TYPES.PROGRAM_WIDE, INCENTIVE_STANDARD_TYPES.PSI];
+
+function findRelevantIncentive(incentive: Incentive) {
+  return (
+    incentive.object === 'item' &&
+    (incentive.type === 'Discount Percent' || incentive.type === 'Discount Amount') &&
+    // only attempt to determine a discount if the incentive is standardized, i.e. we have a criteria object
+    incentive.criteria &&
+    // note: the API should return either a PSI or a program-wide, not both
+    incentive.criteria.node_type === 'PREMISE' &&
+    validIncentiveStandards.includes(incentive.criteria.standard)
+  );
+}
+
 /**
  * Convert a string from camel case to kebab case.
  */
@@ -246,3 +301,13 @@ export const getFallbackValue = (element: HTMLElement & { offer: OfferElement },
  * Returns a list of opted in products id from the state
  */
 export const templatesSelector = (state: State) => ({ templates: state.templates || [] });
+
+/**
+ * Returns true if no selling plan has price adjustments (except for prepaid, which still use price adjustments). This means that we are calculating the subscription discount using a Shopify Discount Function instead of that information being stored in the selling plan.
+ * Generally, the Shopify Discount Function is used when the merchant is using standard flex incentives, i.e. the offer profile is standardized
+ */
+export const isShopifyDiscountFunctionInUseSelector = (state: State) => {
+  const plans = Object.values(state.productPlans).flat();
+
+  return plans.length > 0 && plans.every(plan => plan.hasPriceAdjustments === false || plan.prepaidShipments);
+};

package/src/core/types/api.ts

@@ -32,6 +32,19 @@ export type Incentive = {
   value: number;
 };
 
+export type StandardIncentive = {
+  incentive_target: string;
+  incentive_type: string;
+  incentive_value: string;
+  threshold_field: string | null;
+  threshold_value: string | null;
+  criteria?: {
+    node_type: string;
+    premise_value: unknown;
+    standard: string;
+  };
+};
+
 type ExperimentVariant = {
   public_id: string;
   parameters: any;
@@ -67,5 +80,10 @@ export type OfferResponse = {
       initial: string[];
     }
   >;
-  incentives_display: Record<string, Incentive>;
+  incentives_display: IncentiveDisplay;
+  // only present for standardized offer profiles
+  incentives_display_enhanced?: IncentivesDisplayEnhanced;
 };
+
+export type IncentiveDisplay = Record<string, Incentive>;
+export type IncentivesDisplayEnhanced = Record<string, StandardIncentive>;