@zoxllc/shopify-checkout-extensions 0.0.1

package/README.md

@@ -0,0 +1,3 @@
+# ZOX Checkout Extensions lib
+
+This package aims to provide a common library for dealing with checkout extensions that deal specifically with product discounts or cart validation checks

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@zoxllc/shopify-checkout-extensions",
+  "version": "0.0.1",
+  "description": "ZOX helper lib for shopify checkout extensions",
+  "main": "src/index.ts",
+  "directories": {
+    "test": "tests"
+  },
+  "scripts": {
+    "test": "vitest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zoxllc/shopify-checkout-extensions.git"
+  },
+  "author": "Sebastian Nievas",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/zoxllc/shopify-checkout-extensions/issues"
+  },
+  "homepage": "https://github.com/zoxllc/shopify-checkout-extensions#readme",
+  "dependencies": {
+    "@shopify/shopify_function": "0.1.0",
+    "@types/lodash": "^4.14.202",
+    "javy": "0.1.1",
+    "lodash": "^4.17.21"
+  },
+  "devDependencies": {
+    "vitest": "^1.3.1"
+  }
+}

package/src/common/AndSelector.ts

@@ -0,0 +1,35 @@
+import type { DiscountCart } from "./DiscountCart";
+import type { Qualifier } from "./Qualifier";
+import type { Selector } from "./Selector";
+import type { CartLine } from "extensions/zox-product-discount/generated/api";
+
+export class AndSelector {
+  is_a: "AndSelector";
+  conditions: (Qualifier | Selector)[];
+
+  constructor(conditions: (Qualifier | Selector)[]) {
+    this.is_a = "AndSelector";
+    this.conditions = conditions;
+  }
+
+  match(subject: CartLine | DiscountCart, selector?: Selector) {
+    try {
+      const conditionsResult = this.conditions
+        .map((condition) => {
+          if (selector) {
+            return (condition as Qualifier).match(
+              subject as DiscountCart,
+              selector,
+            );
+          } else {
+            return (condition as Selector).match(subject as CartLine);
+          }
+        })
+        .filter((result) => result === true);
+
+      return conditionsResult.length == this.conditions.length;
+    } catch (e) {
+      return false;
+    }
+  }
+}

package/src/common/BuyXGetY.ts

@@ -0,0 +1,109 @@
+import { Campaign } from "./Campaign";
+import type { CartLine } from "../../../../extensions/zox-product-discount/generated/api";
+import type { AndSelector } from "./AndSelector";
+import type { DiscountCart } from "./DiscountCart";
+import type { ApplyDiscount, DiscountInterface } from "./DiscountInterface";
+import type { OrSelector } from "./OrSelector";
+import type { Qualifier, QualifierBehavior } from "./Qualifier";
+import type { Selector } from "./Selector";
+
+export class BuyXGetY extends Campaign {
+  lineItemSelector?: Selector;
+  getItemSelector?: Selector;
+  discount: DiscountInterface;
+  buyX: number;
+  getY: number;
+  maxSets?: number;
+
+  constructor(
+    behavior: QualifierBehavior,
+    conditions: [AndSelector | OrSelector | Qualifier],
+    discount: DiscountInterface,
+    buyItemSelector: Selector,
+    getItemSelector: Selector,
+    buyX: number,
+    getY: number,
+    maxSets?: number
+  ) {
+    super(behavior, conditions);
+    this.lineItemSelector = buyItemSelector;
+    this.getItemSelector = getItemSelector;
+    this.discount = discount;
+    this.buyX = buyX;
+    this.getY = getY;
+    this.maxSets = maxSets;
+  }
+
+  run(discountCart: DiscountCart) {
+    if (this.qualifies(discountCart)) {
+      // Find the items that qualify for buyX
+      let applicableBuyItems = discountCart.cart.lines;
+      if (this.lineItemSelector) {
+        applicableBuyItems = discountCart.cart.lines.filter((lineItem) => {
+          return this.lineItemSelector?.match(lineItem as CartLine);
+        });
+      }
+
+      if (
+        applicableBuyItems.reduce((qty, item) => (qty += item.quantity), 0) <
+        this.buyX
+      ) {
+        return discountCart;
+      }
+
+      // Find the items that qualify for getX
+      let eligibleGetItems = discountCart.cart.lines;
+      if (this.getItemSelector) {
+        eligibleGetItems = discountCart.cart.lines.filter((lineItem) => {
+          return this.getItemSelector?.match(lineItem as CartLine);
+        });
+      }
+
+      // Check if cart qualifies for discounts and limit the discount sets
+      const purchasedQuantity = applicableBuyItems.reduce(
+        (total, item) => (total += item.quantity),
+        0
+      );
+      const discountableSets = this.maxSets
+        ? [purchasedQuantity / this.buyX, this.maxSets].sort((a, b) => a - b)[0]
+        : Math.floor(purchasedQuantity / this.buyX);
+
+      if (discountableSets > 0) {
+        let discountableQuantity =
+          discountableSets *
+          (this.getY ? this.getY : discountCart.totalLineItemQuantity());
+
+        // Apply the discounts (sort to discount lower priced items first)
+        eligibleGetItems = eligibleGetItems.sort(
+          (item) => item.cost.amountPerQuantity.amount
+        );
+
+        const itemsToApplyDiscounts: ApplyDiscount[] = [];
+
+        eligibleGetItems.forEach((lineItem) => {
+          if (discountableQuantity == 0) {
+            return;
+          }
+
+          if (lineItem.quantity <= discountableQuantity) {
+            itemsToApplyDiscounts.push({ lineItem } as ApplyDiscount);
+            discountableQuantity -= lineItem.quantity;
+          } else {
+            itemsToApplyDiscounts.push({
+              lineItem,
+              maxDiscounts: discountableQuantity,
+            } as ApplyDiscount);
+            discountableQuantity = 0;
+          }
+        });
+
+        if (itemsToApplyDiscounts.length) {
+          const discount = this.discount.apply(itemsToApplyDiscounts);
+          discountCart.addDiscount(discount);
+        }
+      }
+    }
+
+    return discountCart;
+  }
+}

package/src/common/Campaign.ts

@@ -0,0 +1,55 @@
+import type { AndSelector } from "./AndSelector";
+import type { DiscountCart } from "./DiscountCart";
+import type { OrSelector } from "./OrSelector";
+import type { Selector } from "./Selector";
+import { type Qualifier, QualifierBehavior } from "./Qualifier";
+
+interface CampaignInterface {
+  runWithHooks(cart: DiscountCart): DiscountCart;
+  beforeRun?(cart: DiscountCart): DiscountCart;
+  run?(cart: DiscountCart): DiscountCart;
+  afterRun(cart: DiscountCart): DiscountCart;
+}
+
+export class Campaign implements CampaignInterface {
+  behavior: QualifierBehavior;
+  qualifiers: [AndSelector | OrSelector | Qualifier];
+  lineItemSelector?: Selector;
+  message?: string;
+
+  constructor(
+    behavior: QualifierBehavior,
+    qualifiers: [AndSelector | OrSelector | Qualifier]
+  ) {
+    this.behavior = behavior;
+    this.qualifiers = qualifiers;
+  }
+
+  qualifies(discountCart: DiscountCart): boolean {
+    // I have a feeling this needs to be revised... Check campaign.rb
+    const qualifierResults = this.qualifiers.map((qualifier) =>
+      qualifier.match(discountCart, this.lineItemSelector)
+    );
+
+    if (this.behavior == QualifierBehavior.ALL) {
+      return qualifierResults.filter((i) => i === false).length == 0;
+    } else if (this.behavior == QualifierBehavior.ANY) {
+      return qualifierResults.filter((i) => i === true).length > 0;
+    } else {
+      return true;
+    }
+  }
+
+  runWithHooks(cart: DiscountCart) {
+    this.run(cart);
+    return this.afterRun(cart);
+  }
+
+  run(cart: DiscountCart) {
+    return cart;
+  }
+
+  afterRun(cart: DiscountCart) {
+    return cart;
+  }
+}

package/src/common/CampaignConfiguration.ts

@@ -0,0 +1,10 @@
+export enum CampaignType {
+  ConditionalDiscount = "ConditionalDiscount",
+}
+
+export type CampaignConfiguration = {
+  priority: number;
+  campaignType: CampaignType;
+  name: string;
+  arguments: string;
+};

package/src/common/CampaignFactory.ts

@@ -0,0 +1,180 @@
+import { OrSelector } from "./OrSelector";
+import type { Campaign } from "./Campaign";
+import type { DiscountInterface } from "./DiscountInterface";
+import type {
+  NumericalComparisonType,
+  Qualifier,
+  QualifierBehavior,
+  QualifierMatchType,
+  StringComparisonType,
+} from "./Qualifier";
+import type { MatchType, Selector } from "./Selector";
+import { ConditionalDiscount } from "../lineItem/ConditionalDiscount";
+import { FixedItemDiscount } from "../lineItem/FixedItemDiscount";
+import { PercentageDiscount } from "../lineItem/PercentageDiscount";
+import { AndSelector } from "./AndSelector";
+import { BuyXGetY } from "./BuyXGetY";
+import {
+  type CartAmountBehavior,
+  CartAmountQualifier,
+} from "./CartAmountQualifier";
+import {
+  type CartQuantityBehavior,
+  CartQuantityQualifier,
+} from "./CartQuantityQualifier";
+import { CustomerEmailQualifier } from "./CustomerEmailQualifier";
+import { CustomerSubscriberQualifier } from "./CustomerSubscriberQualifier";
+import { CustomerTagQualifier } from "./CustomerTagQualifier";
+import { PostCartAmountQualifier } from "./PostCartAmountQualifier";
+import { ProductIdSelector } from "./ProductIdSelector";
+import { ProductTagSelector } from "./ProductTagSelector";
+import { ProductTypeSelector } from "./ProductTypeSelector";
+import {
+  SaleItemSelector,
+  type SaleItemSelectorMatchType,
+} from "./SaleItemSelector";
+import { SubscriptionItemSelector } from "./SubscriptionItemSelector";
+
+export type InputConfig = {
+  __type: string;
+  inputs: (
+    | boolean
+    | number
+    | string
+    | InputConfig
+    | boolean[]
+    | number[]
+    | string[]
+    | InputConfig[]
+  )[];
+};
+
+export class CampaignFactory {
+  static createFromConfig(config: InputConfig) {
+    return CampaignFactory.createInputsObject(config) as Campaign;
+  }
+
+  private static parseInputConfig(
+    input:
+      | boolean
+      | number
+      | string
+      | InputConfig
+      | boolean[]
+      | number[]
+      | string[]
+      | InputConfig[]
+  ) {
+    if (
+      typeof input == "string" ||
+      typeof input == "number" ||
+      typeof input == "boolean" ||
+      input === null
+    ) {
+      return input;
+    } else {
+      return CampaignFactory.createInputsObject(input as InputConfig);
+    }
+  }
+
+  static createInputsObject(
+    config: InputConfig
+  ):
+    | Campaign
+    | Qualifier
+    | AndSelector
+    | OrSelector
+    | Selector
+    | DiscountInterface
+    | undefined {
+    const args = config.inputs.map((input) => {
+      if (Array.isArray(input)) {
+        return input.map((i) => CampaignFactory.parseInputConfig(i));
+      } else {
+        return CampaignFactory.parseInputConfig(input);
+      }
+    });
+
+    switch (config.__type) {
+      case "ConditionalDiscount":
+        return new ConditionalDiscount(
+          args[0] as QualifierBehavior,
+          args[1] as [AndSelector | OrSelector | Qualifier],
+          args[2] as DiscountInterface,
+          args[3] as Selector,
+          args[4] as number
+        );
+      case "BuyXGetY":
+        return new BuyXGetY(
+          args[0] as QualifierBehavior,
+          args[1] as [AndSelector | OrSelector | Qualifier],
+          args[2] as DiscountInterface,
+          args[3] as Selector,
+          args[4] as Selector,
+          args[5] as number,
+          args[6] as number,
+          args[7] as number
+        );
+      case "AndSelector":
+        return new AndSelector([...args] as (Selector | Qualifier)[]);
+      case "OrSelector":
+        return new OrSelector([...args] as (Selector | Qualifier)[]);
+      case "PostCartAmountQualifier":
+        return new PostCartAmountQualifier(
+          args[0] as NumericalComparisonType,
+          args[1] as number
+        );
+      case "CartAmountQualifier":
+        return new CartAmountQualifier(
+          args[0] as CartAmountBehavior,
+          args[1] as NumericalComparisonType,
+          args[2] as number
+        );
+      case "CartQuantityQualifier":
+        return new CartQuantityQualifier(
+          args[0] as CartQuantityBehavior,
+          args[1] as NumericalComparisonType,
+          args[2] as number
+        );
+      case "SaleItemSelector":
+        return new SaleItemSelector(args[0] as SaleItemSelectorMatchType);
+      case "ProductIdSelector":
+        return new ProductIdSelector(args[0] as MatchType, args[1] as string[]);
+      case "ProductTypeSelector":
+        return new ProductTypeSelector(
+          args[0] as MatchType,
+          args[1] as string[]
+        );
+      case "ProductTagSelector":
+        return new ProductTagSelector(
+          args[0] as QualifierMatchType,
+          args[1] as StringComparisonType,
+          args[2] as string[]
+        );
+      case "PercentageDiscount":
+        return new PercentageDiscount(args[0] as number, args[1] as string);
+      case "FixedItemDiscount":
+        return new FixedItemDiscount(
+          args[0] as number,
+          args[1] as boolean,
+          args[2] as string
+        );
+      case "SubscriptionItemSelector":
+        return new SubscriptionItemSelector(args[0] as MatchType);
+      case "CustomerSubscriberQualifier":
+        return new CustomerSubscriberQualifier(args[0] as QualifierMatchType);
+      case "CustomerEmailQualifier":
+        return new CustomerEmailQualifier(
+          args[0] as QualifierMatchType,
+          args[1] as StringComparisonType,
+          args[2] as string[]
+        );
+      case "CustomerTagQualifier":
+        return new CustomerTagQualifier(
+          args[0] as QualifierMatchType,
+          args[1] as StringComparisonType,
+          args[2] as string[]
+        );
+    }
+  }
+}

package/src/common/CartAmountQualifier.ts

@@ -0,0 +1,64 @@
+import type { DiscountCart } from "./DiscountCart";
+import { type NumericalComparisonType, Qualifier } from "./Qualifier";
+import { type Selector } from "./Selector";
+
+export enum CartAmountBehavior {
+  CART = ":cart",
+  ITEM = ":item",
+  DIFF_CART = ":diff_cart",
+  DIFF_ITEM = ":diff_item",
+}
+
+export class CartAmountQualifier extends Qualifier {
+  behavior: CartAmountBehavior;
+  comparisonType: NumericalComparisonType;
+  amount: number;
+
+  constructor(
+    behavior: CartAmountBehavior,
+    comparisonType: NumericalComparisonType,
+    amount: number
+  ) {
+    super();
+    this.behavior = behavior;
+    this.comparisonType = comparisonType;
+    this.amount = amount;
+  }
+
+  /**
+   * Determines if the carts amount
+   * @param cart
+   * @param selector
+   */
+  match(discountCart: DiscountCart, selector?: Selector) {
+    let total =
+      parseFloat(discountCart.cart.cost.subtotalAmount.amount) -
+      discountCart.appliedDiscountTotal;
+
+    switch (this.behavior) {
+      case CartAmountBehavior.CART:
+      case CartAmountBehavior.ITEM:
+        return this.compareAmounts(total, this.comparisonType, this.amount);
+      case CartAmountBehavior.DIFF_CART:
+        return this.compareAmounts(
+          parseFloat(discountCart.cart.cost.subtotalAmount.amount) -
+            this.amount,
+          this.comparisonType,
+          total
+        );
+      case CartAmountBehavior.DIFF_ITEM:
+        const originalLineTotal = discountCart.cart.lines.reduce(
+          (runningTotal: number, line) => {
+            runningTotal += parseFloat(line.cost.subtotalAmount.amount);
+            return runningTotal;
+          },
+          total
+        );
+        return this.compareAmounts(
+          originalLineTotal - this.amount,
+          this.comparisonType,
+          total
+        );
+    }
+  }
+}

package/src/common/CartHasItemQualifier.ts

@@ -0,0 +1,64 @@
+import type { CartLine } from "extensions/zox-product-discount/generated/api";
+import type { DiscountCart } from "./DiscountCart";
+import { type NumericalComparisonType, Qualifier } from "./Qualifier";
+import { type Selector } from "./Selector";
+
+export enum CartHasItemBehavior {
+  QUANTITY = ":quantity",
+  SUBTOTAL = ":subtotal",
+}
+
+export class CartHasItemQualifier extends Qualifier {
+  quantityOrSubtotal: CartHasItemBehavior;
+  comparisonType: NumericalComparisonType;
+  amount: number;
+  itemSelector: Selector;
+
+  constructor(
+    quantityOrSubtotal: CartHasItemBehavior,
+    comparisonType: NumericalComparisonType,
+    amount: number,
+    itemSelector: Selector
+  ) {
+    super();
+    this.quantityOrSubtotal = quantityOrSubtotal;
+    this.comparisonType = comparisonType;
+    this.amount =
+      this.quantityOrSubtotal == CartHasItemBehavior.SUBTOTAL
+        ? amount
+        : Math.floor(amount);
+    this.itemSelector = itemSelector;
+  }
+
+  /**
+   * Determines if the carts amount
+   * @param cart
+   * @param selector
+   */
+  match(discountCart: DiscountCart, selector?: Selector) {
+    let total = 0;
+
+    switch (this.quantityOrSubtotal) {
+      case CartHasItemBehavior.QUANTITY:
+        total = discountCart.cart.lines.reduce((quantity, line) => {
+          return (
+            quantity +
+            (this.itemSelector.match(line as CartLine) ? line.quantity : 0)
+          );
+        }, 0);
+        break;
+      case CartHasItemBehavior.SUBTOTAL:
+        total = discountCart.cart.lines.reduce((amount, line) => {
+          return (
+            amount +
+            (this.itemSelector.match(line as CartLine)
+              ? line.cost.subtotalAmount.amount
+              : 0)
+          );
+        }, 0);
+        break;
+    }
+
+    return this.compareAmounts(total, this.comparisonType, this.amount);
+  }
+}

package/src/common/CartQuantityQualifier.ts

@@ -0,0 +1,73 @@
+import type { CartLine } from "extensions/zox-product-discount/generated/api";
+import type { DiscountCart } from "./DiscountCart";
+import { type NumericalComparisonType, Qualifier } from "./Qualifier";
+import { type Selector } from "./Selector";
+
+export enum CartQuantityBehavior {
+  CART = ":cart",
+  ITEM = ":item",
+  LINE_ANY = ":line_any",
+  LINE_ALL = ":line_all",
+}
+
+export class CartQuantityQualifier extends Qualifier {
+  totalMethod: CartQuantityBehavior;
+  comparisonType: NumericalComparisonType;
+  quantity: number;
+
+  constructor(
+    totalMethod: CartQuantityBehavior,
+    comparisonType: NumericalComparisonType,
+    quantity: number
+  ) {
+    super();
+    this.totalMethod = totalMethod;
+    this.comparisonType = comparisonType;
+    this.quantity = quantity;
+  }
+
+  /**
+   * Determines if the carts amount
+   * @param cart
+   * @param selector
+   */
+  match(discountCart: DiscountCart, selector?: Selector) {
+    let total = 0;
+
+    switch (this.totalMethod) {
+      case CartQuantityBehavior.ITEM:
+        total = discountCart.cart.lines.reduce((totalQty, line) => {
+          return (
+            totalQty +
+            ((selector ? selector.match(line as CartLine) : true)
+              ? line.quantity
+              : 0)
+          );
+        }, 0);
+        break;
+      case CartQuantityBehavior.CART:
+        total = discountCart.totalLineItemQuantityExcludingGifts();
+        break;
+    }
+
+    if (
+      this.totalMethod == CartQuantityBehavior.LINE_ANY ||
+      this.totalMethod == CartQuantityBehavior.LINE_ALL
+    ) {
+      const qualifiedItems = discountCart.cart.lines
+        .filter((line) => (selector ? selector.match(line as CartLine) : true))
+        .map((line) =>
+          this.compareAmounts(line.quantity, this.comparisonType, this.quantity)
+        );
+
+      switch (this.totalMethod) {
+        case CartQuantityBehavior.LINE_ANY:
+          return qualifiedItems.indexOf(true) > -1;
+        case CartQuantityBehavior.LINE_ALL:
+          return qualifiedItems.indexOf(false) == -1;
+      }
+    } else {
+      return this.compareAmounts(total, this.comparisonType, this.quantity);
+    }
+  }
+}

package/src/common/CustomerEmailQualifier.ts

@@ -0,0 +1,60 @@
+import type { DiscountCart } from "./DiscountCart";
+import {
+  StringComparisonType,
+  QualifierMatchType,
+  Qualifier,
+} from "./Qualifier";
+import { type Selector } from "./Selector";
+
+export class CustomerEmailQualifier extends Qualifier {
+  invert: boolean;
+  matchCondition: StringComparisonType;
+  emails: string[];
+
+  constructor(
+    matchType: QualifierMatchType,
+    matchCondition: StringComparisonType,
+    emails: string[]
+  ) {
+    super();
+    this.invert = matchType == QualifierMatchType.DOES_NOT;
+    this.matchCondition = matchCondition;
+    this.emails = emails.map((e) => e.toLowerCase());
+  }
+
+  /**
+   * Determines if the customer's email matches
+   * @param discountCart DiscountCart
+   * @param selector Selector
+   */
+  match(discountCart: DiscountCart, selector?: Selector) {
+    if (!discountCart.cart.buyerIdentity?.customer?.email) {
+      return false;
+    }
+
+    let matchResult = false;
+
+    const email = discountCart.cart.buyerIdentity.customer.email;
+
+    switch (this.matchCondition) {
+      case StringComparisonType.MATCH:
+        matchResult = this.emails.includes(email);
+        break;
+      case StringComparisonType.CONTAINS:
+        matchResult = this.emails.filter((e) => e.includes(email)).length > 0;
+        break;
+      case StringComparisonType.START_WITH:
+        matchResult = this.emails.filter((e) => e.startsWith(email)).length > 0;
+        break;
+      case StringComparisonType.END_WITH:
+        matchResult = this.emails.filter((e) => e.endsWith(email)).length > 0;
+        break;
+    }
+
+    if (this.invert) {
+      return !matchResult;
+    }
+
+    return matchResult;
+  }
+}