@zoxllc/shopify-checkout-extensions 0.0.1

package/src/index.ts

@@ -0,0 +1,39 @@
+export { ConditionalDiscount } from './lineItem/ConditionalDiscount';
+export { DiscountCodeList } from './lineItem/DiscountCodeList';
+export { FixedItemDiscount } from './lineItem/FixedItemDiscount';
+export { PercentageDiscount } from './lineItem/PercentageDiscount';
+export { AndSelector } from './common/AndSelector';
+export { BuyXGetY } from './common/BuyXGetY';
+export { Campaign } from './common/Campaign';
+export type {
+  CampaignType,
+  CampaignConfiguration,
+} from './common/CampaignConfiguration';
+export {
+  CampaignFactory,
+  type InputConfig,
+} from './common/CampaignFactory';
+export { CartAmountQualifier } from './common/CartAmountQualifier';
+export { CartHasItemQualifier } from './common/CartHasItemQualifier';
+export { CartQuantityQualifier } from './common/CartQuantityQualifier';
+export { CustomerEmailQualifier } from './common/CustomerEmailQualifier';
+export { CustomerSubscriberQualifier } from './common/CustomerSubscriberQualifier';
+export { CustomerTagQualifier } from './common/CustomerTagQualifier';
+export { DiscountCart } from './common/DiscountCart';
+export type { DiscountInterface } from './common/DiscountInterface';
+export { OrSelector } from './common/OrSelector';
+export { PostCartAmountQualifier } from './common/PostCartAmountQualifier';
+export { ProductHandleSelector } from './common/ProductHandleSelector';
+export { ProductIdSelector } from './common/ProductIdSelector';
+export { ProductTagSelector } from './common/ProductTagSelector';
+export { ProductTypeSelector } from './common/ProductTypeSelector';
+export {
+  Qualifier,
+  QualifierBehavior,
+  QualifierMatchType,
+  NumericalComparisonType,
+  StringComparisonType,
+} from './common/Qualifier';
+export { SaleItemSelector } from './common/SaleItemSelector';
+export { Selector } from './common/Selector';
+export { SubscriptionItemSelector } from './common/SubscriptionItemSelector';

package/src/lineItem/ConditionalDiscount.ts

@@ -0,0 +1,102 @@
+import type { CartLine } from '../generated/api';
+import { Campaign } from '../common/Campaign';
+import type { DiscountCart } from '../common/DiscountCart';
+import type {
+  ApplyDiscount,
+  DiscountInterface,
+} from '../common/DiscountInterface';
+import type {
+  QualifierBehavior,
+  Qualifier,
+} from '../common/Qualifier';
+import type { Selector } from '../common/Selector';
+import type { AndSelector } from '../common/AndSelector';
+import type { OrSelector } from '../common/OrSelector';
+
+export class ConditionalDiscount extends Campaign {
+  discount: DiscountInterface;
+  itemsToDiscount?: number;
+
+  constructor(
+    behavior: QualifierBehavior,
+    qualifiers: [Qualifier | AndSelector | OrSelector],
+    discount: DiscountInterface,
+    lineItemSelector?: Selector,
+    maxDiscounts?: number
+  ) {
+    super(behavior, qualifiers);
+    this.discount = discount;
+    this.lineItemSelector = lineItemSelector;
+    this.itemsToDiscount =
+      maxDiscounts == 0 ? undefined : maxDiscounts;
+  }
+
+  run(discountCart: DiscountCart) {
+    // First we see if this cart qualifies for this discount
+    if (this.qualifies(discountCart)) {
+      // Now that it qualifies, we can determine the applicableLineItems
+      // to apply discounts to
+
+      // figure out applicable lineItems...
+      const applicableLineItems = discountCart.cart.lines
+        .filter((lineItem) => {
+          if (this.lineItemSelector === undefined) {
+            return true;
+          }
+          return this.lineItemSelector.match(
+            lineItem as CartLine
+          );
+        })
+        .sort((a, b) => {
+          const priceA = a.cost.amountPerQuantity
+            .amount as number;
+          const priceB = b.cost.amountPerQuantity
+            .amount as number;
+
+          if (priceA < priceB) return -1;
+          if (priceA == priceB) return 0;
+          return 1;
+        });
+
+      const itemsToApplyDiscounts: ApplyDiscount[] = [];
+
+      // Loop over the applicable line items and deduct the itemsToDiscount count
+      // as they are applied to not exceed a maximum.
+      applicableLineItems.forEach((lineItem) => {
+        // If there are no more items to discount, return/skip
+        if (this.itemsToDiscount === 0) return;
+
+        // If items to discount is not undefined, apply as many as possible
+        if (this.itemsToDiscount !== undefined) {
+          // There are more than enough qty to apply, apply the maximum
+          if (lineItem.quantity >= this.itemsToDiscount) {
+            itemsToApplyDiscounts.push({
+              lineItem,
+              maxDiscounts: this.itemsToDiscount,
+            } as ApplyDiscount);
+            this.itemsToDiscount = 0;
+          } else {
+            itemsToApplyDiscounts.push({
+              lineItem,
+            } as ApplyDiscount);
+            this.itemsToDiscount -= lineItem.quantity;
+          }
+        } else {
+          // items to discount is undefined, so apply to entire item count
+          itemsToApplyDiscounts.push({
+            lineItem,
+          } as ApplyDiscount);
+        }
+
+        if (itemsToApplyDiscounts.length) {
+          // append the discount to the discountCart singleton
+          const discount = this.discount.apply(
+            itemsToApplyDiscounts
+          );
+          discountCart.addDiscount(discount);
+        }
+      });
+    }
+    return discountCart;
+  }
+}

package/src/lineItem/DiscountCodeList.ts

@@ -0,0 +1,91 @@
+import type { DiscountCart } from '../common/DiscountCart';
+import type {
+  QualifierBehavior,
+  Qualifier,
+} from '../common/Qualifier';
+import type { Selector } from '../common/Selector';
+import { Campaign } from '../common/Campaign';
+import type { CartLine, Discount } from '../generated/api';
+import { AndSelector } from '~/common/AndSelector';
+import { OrSelector } from '~/common/OrSelector';
+
+export class DiscountCodeList extends Campaign {
+  discountList: string[];
+
+  constructor(
+    behavior: QualifierBehavior,
+    qualifiers: [Qualifier | AndSelector | OrSelector],
+    lineItemSelector?: Selector,
+    discountList?: string[]
+  ) {
+    super(behavior, qualifiers);
+    this.lineItemSelector = lineItemSelector;
+    this.discountList = discountList ? discountList : [];
+  }
+
+  run(discountCart: DiscountCart) {
+    // First we see if this cart qualifies for this discount
+    if (this.qualifies(discountCart)) {
+      // Now that it qualifies, we can determine the applicableLineItems
+      // to apply discounts to
+
+      // figure out applicable lineItems...
+      const applicableLineItems = discountCart.cart.lines
+        .filter((lineItem) => {
+          if (this.lineItemSelector === undefined) {
+            return true;
+          }
+          return this.lineItemSelector.match(
+            lineItem as CartLine
+          );
+        })
+        .sort((a, b) => {
+          const priceA = a.cost.amountPerQuantity
+            .amount as number;
+          const priceB = b.cost.amountPerQuantity
+            .amount as number;
+
+          if (priceA < priceB) return -1;
+          if (priceA == priceB) return 0;
+          return 1;
+        });
+
+      // Loop over the applicable line items and deduct the itemsToDiscount count
+      // as they are applied to not exceed a maximum.
+      applicableLineItems.forEach((lineItem) => {
+        // If there are no more items to discount, return/skip
+        if (this.itemsToDiscount === 0) return;
+
+        let discount: Discount;
+
+        // If items to discount is not undefined, apply as many as possible
+        if (this.itemsToDiscount !== undefined) {
+          // There are more than enough qty to apply, apply the maximum
+          if (lineItem.quantity >= this.itemsToDiscount) {
+            discount = this.discount.apply(
+              lineItem as CartLine,
+              this.itemsToDiscount
+            );
+            this.itemsToDiscount = 0;
+          } else {
+            discount = this.discount.apply(
+              lineItem as CartLine
+            );
+            this.itemsToDiscount -= lineItem.quantity;
+          }
+        } else {
+          // items to discount is undefined, so apply to entire item count
+          discount = this.discount.apply(
+            lineItem as CartLine
+          );
+        }
+
+        if (discount) {
+          // append the discount to the discountCart singleton
+          discountCart.addDiscount(discount);
+        }
+      });
+    }
+    return discountCart;
+  }
+}

package/src/lineItem/FixedItemDiscount.ts

@@ -0,0 +1,53 @@
+import type {
+  Discount,
+  ProductVariant,
+} from '../generated/api';
+import type {
+  ApplyDiscount,
+  DiscountInterface,
+} from '../common/DiscountInterface';
+
+export class FixedItemDiscount
+  implements DiscountInterface
+{
+  amount: number;
+  appliesToEachItem: boolean;
+  message: string;
+
+  constructor(
+    amount: number,
+    appliesToEachItem: boolean,
+    message: string
+  ) {
+    this.amount = amount;
+    this.appliesToEachItem = appliesToEachItem;
+    this.message = message;
+  }
+
+  apply(items: ApplyDiscount[]): Discount {
+    const targets = items.map(
+      ({ lineItem, maxDiscounts }) => {
+        const variant =
+          lineItem.merchandise as ProductVariant;
+        return {
+          productVariant: {
+            id: variant.id,
+            quantity:
+              maxDiscounts == 0 ? undefined : maxDiscounts,
+          },
+        };
+      }
+    );
+
+    return {
+      targets,
+      value: {
+        fixedAmount: {
+          amount: this.amount,
+          appliesToEachItem: this.appliesToEachItem,
+        },
+      },
+      message: this.message,
+    } as Discount;
+  }
+}

package/src/lineItem/PercentageDiscount.ts

@@ -0,0 +1,46 @@
+import type {
+  Discount,
+  ProductVariant,
+} from '../generated/api';
+import type {
+  ApplyDiscount,
+  DiscountInterface,
+} from '../common/DiscountInterface';
+
+export class PercentageDiscount
+  implements DiscountInterface
+{
+  discount: number;
+  message?: string;
+
+  constructor(percentage: number, message?: string) {
+    this.discount = percentage;
+    this.message = message;
+  }
+
+  apply(items: ApplyDiscount[]): Discount {
+    const targets = items.map(
+      ({ lineItem, maxDiscounts }) => {
+        const variant =
+          lineItem.merchandise as ProductVariant;
+        return {
+          productVariant: {
+            id: variant.id,
+            quantity:
+              maxDiscounts == 0 ? undefined : maxDiscounts,
+          },
+        };
+      }
+    );
+
+    return {
+      targets,
+      value: {
+        percentage: {
+          value: this.discount,
+        },
+      },
+      message: this.message,
+    };
+  }
+}

package/tests/AndSelector.test.ts

@@ -0,0 +1,27 @@
+import { describe, it, expect } from 'vitest';
+import { AndSelector } from '../src/common/AndSelector';
+import { CartLine } from '../src/generated/api';
+import {
+  MockFalseyQualifier,
+  MockTruthyQualifier,
+} from './Qualifier.test';
+
+describe('AndSelector', () => {
+  it('Returns true if all conditions are met', () => {
+    const selector = new AndSelector([
+      new MockTruthyQualifier(),
+      new MockTruthyQualifier(),
+    ]);
+
+    expect(selector.match({} as CartLine)).toBeTruthy();
+  });
+
+  it('Returns false if any conditions are not met', () => {
+    const selector = new AndSelector([
+      new MockTruthyQualifier(),
+      new MockFalseyQualifier(),
+    ]);
+
+    expect(selector.match({} as CartLine)).toBeFalsy();
+  });
+});