Problem with discounts canceling our global discount.

[vpawebmaster]

We have created a function that checks each line item in the cart and applies a volume discount if it meets certain criteria. This function works fine, however if another discount kicks in our function discount disappears. A single discount replaces all of our line discounts. See video:

https://www.loom.com/share/b91a13c7cc354811a95e0ff8784b98b6

query RunInput {
    cart {
        lines {
            id
            quantity
            vpa_bundle:  attribute(key: "vpa_bundle"){
                key
                value
            }
            cost {
                 subtotalAmount{
                     amount
                 }
            }
            merchandise{
                ... on ProductVariant {
                    product {
                        id,
                        tier_prices: metafield(namespace: "custom", key: "qty_price_breaks") {
                              value
                        }
                    }
                }
            }
        }
    }
}

// @ts-check
import { DiscountApplicationStrategy } from "../generated/api";

/**
 * @typedef {import("../generated/api").RunInput} RunInput
 * @typedef {import("../generated/api").FunctionRunResult} FunctionRunResult
 */

/**
 * @type {FunctionRunResult}
 */
const EMPTY_DISCOUNT = {
  discountApplicationStrategy: DiscountApplicationStrategy.First,
  discounts: [],
};


function getNumericId(id){
  const parts = id.split('/')
  return parts[parts.length - 1];
}

/**
 * @param {RunInput} input
 * @returns {FunctionRunResult}
 */
export function run(input) {
  const lines_length = input.cart.lines.length;
  //console.error(JSON.stringify(input))
  let count_of_products = {};
  let line_items_of_products = {};
  let qty_price_breaks = {};

  let bundles_cost = {}
  let bundles_line_items = {};
  let bundles_total_cost = {};
  let bundle_products = {};
  let bundle_ratio = {};

  for(let i = 0; i < lines_length; i++){
    if(input.cart.lines[i].vpa_bundle !== null && input.cart.lines[i].vpa_bundle.value.length > 0){
     
      //do bundle discounting
      const bundle_parts = input.cart.lines[i].vpa_bundle.value.split(';')

      if(typeof bundle_products[bundle_parts[0]] === 'undefined'){
        bundle_products[bundle_parts[0]] = {};

        const ids = bundle_parts[2].split(',');
        const id_length = ids.length

        for(let j = 0; j < id_length; j++){
          bundle_products[bundle_parts[0]][ids[j]] = 0;

          if(typeof bundle_ratio[bundle_parts[0]] === 'undefined'){
            bundle_ratio[bundle_parts[0]] = {};
          }

          if(typeof bundle_ratio[bundle_parts[0]][ids[j]] === 'undefined'){
            bundle_ratio[bundle_parts[0]][ids[j]] = 0;
          }
        }

        for(let j = 0; j < id_length; j++){

          bundle_ratio[bundle_parts[0]][ids[j]] += input.cart.lines[i].quantity;

        }

      }



    bundle_products[bundle_parts[0]][getNumericId(input.cart.lines[i].merchandise.product.id)] += input.cart.lines[i].quantity;

    if(typeof bundles_cost[bundle_parts[0]] === 'undefined'){
      bundles_cost[bundle_parts[0]] = 0;
    }
    if(typeof bundles_line_items[bundle_parts[0]] === 'undefined'){
      bundles_line_items[bundle_parts[0]] = [];
    }
    bundles_cost[bundle_parts[0]] += (1* input.cart.lines[i].cost.subtotalAmount.amount)
    bundles_total_cost[bundle_parts[0]] = bundle_parts[1] * input.cart.lines[i].quantity;
    bundles_line_items[bundle_parts[0]].push(input.cart.lines[i].id)
  } else {

    if(typeof line_items_of_products[input.cart.lines[i].merchandise.product.id] === 'undefined'){
      line_items_of_products[input.cart.lines[i].merchandise.product.id] = [];
    }

    line_items_of_products[input.cart.lines[i].merchandise.product.id].push(input.cart.lines[i].id)

 
    if(typeof count_of_products[input.cart.lines[i].merchandise.product.id] === 'undefined'){
      count_of_products[input.cart.lines[i].merchandise.product.id] = 0;
    }
    count_of_products[input.cart.lines[i].merchandise.product.id] += input.cart.lines[i].quantity;
   
    if(typeof qty_price_breaks[input.cart.lines[i].merchandise.product.id] === 'undefined' && input.cart.lines[i].merchandise.product.tier_prices !== null){
      qty_price_breaks[input.cart.lines[i].merchandise.product.id] = input.cart.lines[i].merchandise.product.tier_prices.value;
    }
  }
}


let discounts = [];

for(let i in bundle_products) {
  if (bundle_products.hasOwnProperty(i)) {
    let count_ok = true;
    let count = null;

    for (let j in bundle_products[i]) {
      if (bundle_products[i].hasOwnProperty(j)) {
        if (count === null) {
          count = bundle_products[i][j] / bundle_ratio[i][j];
        }
        if (count !== (bundle_products[i][j] / bundle_ratio[i][j])) {
          count_ok = false;
        }
      }
    }

    if (count_ok) {
      let discount = (100 - ((bundles_total_cost[i] / bundles_cost[i]) * 100));
      let cartLines = [];
      const len = bundles_line_items[i].length
      for (let k = 0; k < len; k++) {

        cartLines.push({
          // Use the variant ID to create a discount target
          cartLine: {
            id: bundles_line_items[i][k]
          }
        })
      }

      discounts.push({
        // Apply the discount to the collected targets
        targets: cartLines,
        // Define a percentage-based discount
        value: {
          percentage: {
            value: discount
          }
        }
      })
    }
  }
}



  for(let i in count_of_products){
    if(count_of_products.hasOwnProperty(i)){
      if(typeof qty_price_breaks[i] !== 'undefined'){
        const qty_bits = qty_price_breaks[i].split(";");
        let discount = 0;
        for(let j = 0; j < qty_bits.length; j++){
          if(count_of_products[i] >= qty_bits[j].split(":")[0]){
            discount = qty_bits[j].split(":")[1];
          }
        }

        if(discount >  0) {
          let cartLines = [];
          const len = line_items_of_products[i].length
          for (let k=0; k< len;k++) {

            cartLines.push({
              // Use the variant ID to create a discount target
              cartLine: {
                id: line_items_of_products[i][k]
              }
            })
          }

          discounts.push({
            // Apply the discount to the collected targets
            targets: cartLines,
            // Define a percentage-based discount
            value: {
              percentage: {
                value: discount
              }
            }
          })
        }
      }

    }
  }



  if(discounts.length === 0){
    return EMPTY_DISCOUNT;
  } else {


    return {
      discounts: discounts,
      discountApplicationStrategy: DiscountApplicationStrategy.All
    };
  }


};

[vpawebmaster]

Found a way to fix this behaviour. There is a combinesWith flag that you can use, to allow this discount to combine with others. But you must set it when adding the function to your store with a mutation. Below is an example of how to do this.

mutation {
  discountAutomaticAppCreate(automaticAppDiscount: {
    title: "Volume discount",
    functionId: "5e34567c-0a0e-4995-9983-567003452",
combinesWith: {
      orderDiscounts: true,
      productDiscounts: true,
      shippingDiscounts: true
    },
    startsAt: "2022-06-22T00:00:00"
  }) {
     automaticAppDiscount {
      discountId
     }
     userErrors {
      field
      message
     }
  }
}

The only problem that I can see with using this method, is we don't want discounts to stack.

[thosakwe]

Discounts in Shopify don't "stack." That is to say, you will never have 2 product discounts applying to the same product.

You can, however, have product discounts and order discounts applying within the same cart.

Here's a helpdesk article that explains the rules:

https://help.shopify.com/en/manual/discounts/combining-discounts/discount-combinations