@zoxllc/shopify-checkout-extensions 0.0.3 → 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.3",
+  "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 '../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,4 +1,4 @@
-import type { CartLine } from '../generated/api';
+import type { CartLine } from '../lineItem/api';
 import type { DiscountCart } from './DiscountCart';
 import {
   type NumericalComparisonType,

package/src/common/CartQuantityQualifier.ts

@@ -1,4 +1,4 @@
-import type { CartLine } from '../generated/api';
+import type { CartLine } from '../lineItem/api';
 import type { DiscountCart } from './DiscountCart';
 import {
   type NumericalComparisonType,

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;
+  }
+}

package/src/common/CustomerEmailQualifier.ts

@@ -1,10 +1,10 @@
-import type { DiscountCart } from "./DiscountCart";
+import type { DiscountCart } from './DiscountCart';
 import {
   StringComparisonType,
   QualifierMatchType,
   Qualifier,
-} from "./Qualifier";
-import { type Selector } from "./Selector";
+} from './Qualifier';
+import { type Selector } from './Selector';
 
 export class CustomerEmailQualifier extends Qualifier {
   invert: boolean;
@@ -34,20 +34,27 @@ export class CustomerEmailQualifier extends Qualifier {
 
     let matchResult = false;
 
-    const email = discountCart.cart.buyerIdentity.customer.email;
+    const email =
+      discountCart.cart.buyerIdentity.customer.email.toLowerCase();
 
     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;
+        matchResult =
+          this.emails.filter((e) => email.includes(e))
+            .length > 0;
         break;
       case StringComparisonType.START_WITH:
-        matchResult = this.emails.filter((e) => e.startsWith(email)).length > 0;
+        matchResult =
+          this.emails.filter((e) => email.startsWith(e))
+            .length > 0;
         break;
       case StringComparisonType.END_WITH:
-        matchResult = this.emails.filter((e) => e.endsWith(email)).length > 0;
+        matchResult =
+          this.emails.filter((e) => email.endsWith(e))
+            .length > 0;
         break;
     }
 

package/src/common/CustomerTagQualifier.ts

@@ -1,10 +1,10 @@
-import type { DiscountCart } from "./DiscountCart";
+import type { DiscountCart } from './DiscountCart';
 import {
   StringComparisonType,
   QualifierMatchType,
   Qualifier,
-} from "./Qualifier";
-import { type Selector } from "./Selector";
+} from './Qualifier';
+import { type Selector } from './Selector';
 
 export class CustomerTagQualifier extends Qualifier {
   invert: boolean;
@@ -30,21 +30,34 @@ export class CustomerTagQualifier extends Qualifier {
   match(discountCart: DiscountCart, selector?: Selector) {
     const matchResult =
       (
-        discountCart.cart.buyerIdentity?.customer?.hasTags.filter((t) => {
-          if (t.hasTag) {
-            switch (this.matchCondition) {
-              case StringComparisonType.MATCH:
-                return this.tags.includes(t.tag);
-              case StringComparisonType.CONTAINS:
-                return this.tags.filter((e) => e.includes(t.tag)).length > 0;
-              case StringComparisonType.START_WITH:
-                return this.tags.filter((e) => e.startsWith(t.tag)).length > 0;
-              case StringComparisonType.END_WITH:
-                return this.tags.filter((e) => e.endsWith(t.tag)).length > 0;
+        discountCart.cart.buyerIdentity?.customer?.hasTags.filter(
+          (t) => {
+            if (t.hasTag) {
+              const tag = t.tag.toLowerCase();
+              switch (this.matchCondition) {
+                case StringComparisonType.MATCH:
+                  return this.tags.includes(tag);
+                case StringComparisonType.CONTAINS:
+                  return (
+                    this.tags.filter((e) => tag.includes(e))
+                      .length > 0
+                  );
+                case StringComparisonType.START_WITH:
+                  return (
+                    this.tags.filter((e) =>
+                      tag.startsWith(e)
+                    ).length > 0
+                  );
+                case StringComparisonType.END_WITH:
+                  return (
+                    this.tags.filter((e) => tag.endsWith(e))
+                      .length > 0
+                  );
+              }
             }
+            return false;
           }
-          return false;
-        }) || []
+        ) || []
       ).length > 0;
 
     if (this.invert) {