@zoxllc/shopify-checkout-extensions 0.0.2 → 0.0.4

package/migrate.ts

@@ -0,0 +1,64 @@
+ShippingDiscount.new(
+  :all,
+  CustomerTagQualifier.new(
+    :does,
+    :match,
+    ["new customer 35", "tier: Active Subscriber", "active_subscriber", "tier: Subscribers", "Active Subscriber"]
+  ),
+  AndSelector.new(
+    CartAmountQualifier.new(
+      :cart,
+      :greater_than,
+      50
+    ),
+    ReducedCartAmountQualifier.new(
+      :greater_than,
+      50
+    ),
+    nil
+  ),
+  :any,
+  nil,
+  RateNameSelector.new(
+    :does,
+    :include,
+    ["FedEx"]
+  ),
+  FixedDiscount.new(
+    10,
+    "ZOXPASS Discount"
+  )
+),
+ShippingDiscount.new(
+  :all,
+  nil,
+  CountryCodeQualifier.new(
+    :is_one,
+    ["US"]
+  ),
+  :any,
+  SubscriptionItemSelector.new(
+    :is
+  ),
+  nil,
+  FixedDiscount.new(
+    4,
+    ""
+  )
+),
+ShippingDiscount.new(
+  :all,
+  nil,
+  nil,
+  :any,
+  nil,
+  RateNameSelector.new(
+    :does,
+    :include,
+    ["Standard - Untracked"]
+  ),
+  FixedDiscount.new(
+    3,
+    ""
+  )
+)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zoxllc/shopify-checkout-extensions",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "ZOX helper lib for shopify checkout extensions",
   "main": "src/index.ts",
   "directories": {
@@ -20,6 +20,7 @@
   },
   "homepage": "https://github.com/zoxllc/shopify-checkout-extensions#readme",
   "dependencies": {
+    "@shopify/app-bridge-types": "^0.0.7",
     "@shopify/shopify_function": "0.1.0",
     "@types/lodash": "^4.14.202",
     "javy": "0.1.1",

package/src/common/AndSelector.ts

@@ -1,33 +1,40 @@
-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";
+import type { DiscountCart } from './DiscountCart';
+import type { Qualifier } from './Qualifier';
+import type { Selector } from './Selector';
+import type { CartLine } from '../lineItem/api';
 
 export class AndSelector {
-  is_a: "AndSelector";
+  is_a: 'AndSelector';
   conditions: (Qualifier | Selector)[];
 
   constructor(conditions: (Qualifier | Selector)[]) {
-    this.is_a = "AndSelector";
+    this.is_a = 'AndSelector';
     this.conditions = conditions;
   }
 
-  match(subject: CartLine | DiscountCart, selector?: Selector) {
+  match(
+    subject: CartLine | DiscountCart,
+    selector?: Selector
+  ) {
     try {
       const conditionsResult = this.conditions
         .map((condition) => {
           if (selector) {
             return (condition as Qualifier).match(
               subject as DiscountCart,
-              selector,
+              selector
             );
           } else {
-            return (condition as Selector).match(subject as CartLine);
+            return (condition as Selector).match(
+              subject as CartLine
+            );
           }
         })
         .filter((result) => result === true);
 
-      return conditionsResult.length == this.conditions.length;
+      return (
+        conditionsResult.length == this.conditions.length
+      );
     } catch (e) {
       return false;
     }

package/src/common/Campaign.ts

@@ -1,8 +1,11 @@
-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";
+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;
@@ -13,28 +16,40 @@ interface CampaignInterface {
 
 export class Campaign implements CampaignInterface {
   behavior: QualifierBehavior;
-  qualifiers: [AndSelector | OrSelector | Qualifier];
+  qualifiers?:
+    | (AndSelector | OrSelector | Qualifier)[]
+    | null;
   lineItemSelector?: Selector;
   message?: string;
 
   constructor(
     behavior: QualifierBehavior,
-    qualifiers: [AndSelector | OrSelector | Qualifier]
+    qualifiers?:
+      | (AndSelector | OrSelector | Qualifier)[]
+      | null
   ) {
     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.qualifiers == undefined) return true;
+
+    const qualifierResults = this.qualifiers.map(
+      (qualifier) =>
+        qualifier.match(discountCart, this.lineItemSelector)
     );
 
     if (this.behavior == QualifierBehavior.ALL) {
-      return qualifierResults.filter((i) => i === false).length == 0;
+      return (
+        qualifierResults.filter((i) => i === false)
+          .length == 0
+      );
     } else if (this.behavior == QualifierBehavior.ANY) {
-      return qualifierResults.filter((i) => i === true).length > 0;
+      return (
+        qualifierResults.filter((i) => i === true).length >
+        0
+      );
     } else {
       return true;
     }

package/src/common/CampaignFactory.ts

@@ -1,39 +1,43 @@
-import { OrSelector } from "./OrSelector";
-import type { Campaign } from "./Campaign";
-import type { DiscountInterface } from "./DiscountInterface";
+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";
+} 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 '../lineItem/BuyXGetY';
 import {
   type CartAmountBehavior,
   CartAmountQualifier,
-} from "./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";
+} 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";
+} from './SaleItemSelector';
+import { SubscriptionItemSelector } from './SubscriptionItemSelector';
+import { RateNameSelector } from '~/shipping/RateNameSelector';
+import { FixedDiscount } from '~/shipping/FixedDiscount';
+import { ShippingDiscount } from '~/shipping/ShippingDiscount';
+import { CountryCodeQualifier } from './CountryCodeQualifier';
 
 export type InputConfig = {
   __type: string;
@@ -51,7 +55,9 @@ export type InputConfig = {
 
 export class CampaignFactory {
   static createFromConfig(config: InputConfig) {
-    return CampaignFactory.createInputsObject(config) as Campaign;
+    return CampaignFactory.createInputsObject(
+      config
+    ) as Campaign;
   }
 
   private static parseInputConfig(
@@ -66,14 +72,16 @@ export class CampaignFactory {
       | InputConfig[]
   ) {
     if (
-      typeof input == "string" ||
-      typeof input == "number" ||
-      typeof input == "boolean" ||
+      typeof input == 'string' ||
+      typeof input == 'number' ||
+      typeof input == 'boolean' ||
       input === null
     ) {
       return input;
     } else {
-      return CampaignFactory.createInputsObject(input as InputConfig);
+      return CampaignFactory.createInputsObject(
+        input as InputConfig
+      );
     }
   }
 
@@ -89,14 +97,16 @@ export class CampaignFactory {
     | undefined {
     const args = config.inputs.map((input) => {
       if (Array.isArray(input)) {
-        return input.map((i) => CampaignFactory.parseInputConfig(i));
+        return input.map((i) =>
+          CampaignFactory.parseInputConfig(i)
+        );
       } else {
         return CampaignFactory.parseInputConfig(input);
       }
     });
 
     switch (config.__type) {
-      case "ConditionalDiscount":
+      case 'ConditionalDiscount':
         return new ConditionalDiscount(
           args[0] as QualifierBehavior,
           args[1] as [AndSelector | OrSelector | Qualifier],
@@ -104,7 +114,7 @@ export class CampaignFactory {
           args[3] as Selector,
           args[4] as number
         );
-      case "BuyXGetY":
+      case 'BuyXGetY':
         return new BuyXGetY(
           args[0] as QualifierBehavior,
           args[1] as [AndSelector | OrSelector | Qualifier],
@@ -115,61 +125,103 @@ export class CampaignFactory {
           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":
+      case 'ShippingDiscount':
+        return new ShippingDiscount(
+          args[0] as QualifierBehavior,
+          args[1] as [AndSelector | OrSelector | Qualifier],
+          args[2] as DiscountInterface,
+          args[3] as Selector
+        );
+      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":
+      case 'CartAmountQualifier':
         return new CartAmountQualifier(
           args[0] as CartAmountBehavior,
           args[1] as NumericalComparisonType,
           args[2] as number
         );
-      case "CartQuantityQualifier":
+      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":
+      case 'CountryCodeQualifier':
+        return new CountryCodeQualifier(
+          args[0] as QualifierMatchType,
+          args[1] as StringComparisonType,
+          args[2] as string[]
+        );
+      case 'SaleItemSelector':
+        return new SaleItemSelector(
+          args[0] as SaleItemSelectorMatchType
+        );
+      case 'ProductIdSelector':
+        return new ProductIdSelector(
+          args[0] as MatchType.IS_ONE | MatchType.NOT_ONE,
+          args[1] as string[]
+        );
+      case 'ProductTypeSelector':
         return new ProductTypeSelector(
           args[0] as MatchType,
           args[1] as string[]
         );
-      case "ProductTagSelector":
+      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":
+      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":
+      case 'FixedDiscount':
+        return new FixedDiscount(
+          args[0] as number,
+          args[1] as string
+        );
+      case 'SubscriptionItemSelector':
+        return new SubscriptionItemSelector(
+          args[0] as MatchType
+        );
+      case 'RateNameSelector':
+        return new RateNameSelector(
+          args[0] as MatchType.DOES | MatchType.DOES_NOT,
+          args[1] as StringComparisonType,
+          args[2] as string[]
+        );
+      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":
+      case 'CustomerTagQualifier':
         return new CustomerTagQualifier(
           args[0] as QualifierMatchType,
           args[1] as StringComparisonType,

package/src/common/CartHasItemQualifier.ts

@@ -1,11 +1,14 @@
-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";
+import type { CartLine } from '../lineItem/api';
+import type { DiscountCart } from './DiscountCart';
+import {
+  type NumericalComparisonType,
+  Qualifier,
+} from './Qualifier';
+import { type Selector } from './Selector';
 
 export enum CartHasItemBehavior {
-  QUANTITY = ":quantity",
-  SUBTOTAL = ":subtotal",
+  QUANTITY = ':quantity',
+  SUBTOTAL = ':subtotal',
 }
 
 export class CartHasItemQualifier extends Qualifier {
@@ -24,7 +27,8 @@ export class CartHasItemQualifier extends Qualifier {
     this.quantityOrSubtotal = quantityOrSubtotal;
     this.comparisonType = comparisonType;
     this.amount =
-      this.quantityOrSubtotal == CartHasItemBehavior.SUBTOTAL
+      this.quantityOrSubtotal ==
+      CartHasItemBehavior.SUBTOTAL
         ? amount
         : Math.floor(amount);
     this.itemSelector = itemSelector;
@@ -40,25 +44,37 @@ export class CartHasItemQualifier extends Qualifier {
 
     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);
+        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);
+        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);
+    return this.compareAmounts(
+      total,
+      this.comparisonType,
+      this.amount
+    );
   }
 }

package/src/common/CartQuantityQualifier.ts

@@ -1,13 +1,16 @@
-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";
+import type { CartLine } from '../lineItem/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",
+  CART = ':cart',
+  ITEM = ':item',
+  LINE_ANY = ':line_any',
+  LINE_ALL = ':line_all',
 }
 
 export class CartQuantityQualifier extends Qualifier {
@@ -36,17 +39,25 @@ export class CartQuantityQualifier extends Qualifier {
 
     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);
+        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();
+        total =
+          discountCart.totalLineItemQuantityExcludingGifts();
         break;
     }
 
@@ -55,9 +66,15 @@ export class CartQuantityQualifier extends Qualifier {
       this.totalMethod == CartQuantityBehavior.LINE_ALL
     ) {
       const qualifiedItems = discountCart.cart.lines
-        .filter((line) => (selector ? selector.match(line as CartLine) : true))
+        .filter((line) =>
+          selector ? selector.match(line as CartLine) : true
+        )
         .map((line) =>
-          this.compareAmounts(line.quantity, this.comparisonType, this.quantity)
+          this.compareAmounts(
+            line.quantity,
+            this.comparisonType,
+            this.quantity
+          )
         );
 
       switch (this.totalMethod) {
@@ -67,7 +84,11 @@ export class CartQuantityQualifier extends Qualifier {
           return qualifiedItems.indexOf(false) == -1;
       }
     } else {
-      return this.compareAmounts(total, this.comparisonType, this.quantity);
+      return this.compareAmounts(
+        total,
+        this.comparisonType,
+        this.quantity
+      );
     }
   }
 }

package/src/common/CountryCodeQualifier.ts

@@ -0,0 +1,49 @@
+import type { DiscountCart } from './DiscountCart';
+import {
+  StringComparisonType,
+  QualifierMatchType,
+  Qualifier,
+} from './Qualifier';
+import { type Selector } from './Selector';
+
+export class CountryCodeQualifier extends Qualifier {
+  invert: boolean;
+  countryCodes: string[];
+
+  constructor(
+    matchType: QualifierMatchType,
+    countryCodes: string[]
+  ) {
+    super();
+    this.invert = matchType == QualifierMatchType.DOES_NOT;
+    this.countryCodes = countryCodes.map((e) =>
+      e.toLowerCase()
+    );
+  }
+
+  /**
+   * Determines if the customer has specified tags
+   * @param discountCart DiscountCart
+   * @param selector Selector
+   */
+  match(discountCart: DiscountCart, selector?: Selector) {
+    const matchResult =
+      (
+        discountCart.cart.deliveryGroups.filter(
+          (deliveryGroup) => {
+            const countryCode =
+              // @ts-ignore
+              deliveryGroup.deliveryAddress.countryCode.toLowerCase();
+
+            return this.countryCodes.includes(countryCode);
+          }
+        ) || []
+      ).length > 0;
+
+    if (this.invert) {
+      return !matchResult;
+    }
+
+    return matchResult;
+  }
+}