@kiva/kv-shop 1.3.1 → 1.4.0

package/dist/index.cjs

@@ -30,27 +30,49 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   ShopError: () => ShopError,
+  VerificationState: () => VerificationState,
+  applyKivaCredit: () => applyKivaCredit,
+  basketTotalsQuery: () => basketTotalsQuery,
+  callShopMutation: () => callShopMutation,
+  callShopQuery: () => callShopQuery,
   checkSubscriptionStatus: () => checkSubscriptionStatus,
   createBasket: () => createBasket,
   defaultPaymentTypes: () => defaultPaymentTypes,
   executeNewSubscriptionCheckout: () => executeNewSubscriptionCheckout,
   executeOneTimeCheckout: () => executeOneTimeCheckout,
   getBasketID: () => getBasketID,
+  getCheckoutStatus: () => getCheckoutStatus,
   getClientToken: () => getClientToken,
-  getCookieValue: () => getCookieValue,
   hasBasketExpired: () => hasBasketExpired,
+  isBasketVerified: () => isBasketVerified,
   parseShopError: () => parseShopError,
+  pollForFinishedCheckout: () => pollForFinishedCheckout,
+  removeKivaCredit: () => removeKivaCredit,
   setBasketID: () => setBasketID,
-  setCookieValue: () => setCookieValue,
   setTipDonation: () => setTipDonation,
   useBraintreeDropIn: () => useBraintreeDropIn,
-  waitOnTransaction: () => waitOnTransaction
+  validatePreCheckout: () => validatePreCheckout,
+  validatePreCheckoutMutation: () => validatePreCheckoutMutation,
+  watchBasketTotals: () => watchBasketTotals,
+  watchShopQuery: () => watchShopQuery
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/basket.ts
 var import_core = require("@apollo/client/core");
 
+// src/util/cookie.ts
+var getCookieValue = (name) => {
+  if (typeof document !== void 0) {
+    return decodeURIComponent(document.cookie.match(`(^|;)\\s*${name}\\s*=\\s*([^;]+)`)?.pop() || "");
+  }
+};
+var setCookieValue = (name, value, options = "") => {
+  if (typeof document !== void 0) {
+    document.cookie = `${name}=${encodeURIComponent(value)};${options}`;
+  }
+};
+
 // src/shopError.ts
 var ShopError = class extends Error {
   constructor({ code, original }, ...params) {
@@ -62,8 +84,14 @@ var ShopError = class extends Error {
     this.code = code;
     this.original = original;
   }
+  aggregateErrors(errors) {
+    this.errors = errors;
+  }
 };
 function parseShopError(error) {
+  if (error instanceof ShopError) {
+    return error;
+  }
   const errorCode = error?.code ?? error?.extensions?.code ?? error?.name ?? "";
   const errorMessage = typeof error === "string" ? error : error?.message ?? "";
   if (errorCode === "invalidMethodParameter" && errorMessage.includes("paymentMethod.create")) {
@@ -72,6 +100,21 @@ function parseShopError(error) {
       original: error
     }, "There was a problem validating your payment information. Please double-check the details and try again.");
   }
+  if (errorMessage.includes("Invalid request: ")) {
+    const finalError = errorMessage.split("Invalid request: ")[1].split("., ").map((e) => e.matchAll(/[A-Z_]+: (.*)/g))[0];
+    const finalCode = finalError[1];
+    const finalMessage = finalError[2];
+    return new ShopError({
+      code: `paymentMethod.${finalCode}`,
+      original: error
+    }, finalMessage);
+  }
+  if (errorCode === "insufficientFunds" || errorMessage.includes("There is not enough credit")) {
+    return new ShopError({
+      code: "shop.insufficientFunds",
+      original: error
+    }, "There is not enough money to complete the checkout. Please double-check the details and try again.");
+  }
   if (errorCode === "shop.invalidBasketId" || errorCode === "shop.basketRequired" || errorCode === "shop.alreadyCheckedOut") {
     return new ShopError({
       code: errorCode,
@@ -91,21 +134,13 @@ function parseShopError(error) {
 }
 
 // src/basket.ts
-var getCookieValue = (name) => {
-  if (typeof document !== void 0) {
-    return decodeURIComponent(document.cookie.match(`(^|;)\\s*${name}\\s*=\\s*([^;]+)`)?.pop() || "");
-  }
-};
-var setCookieValue = (name, value, options = "") => {
-  document.cookie = `${name}=${encodeURIComponent(value)};${options}`;
-};
 function getBasketID() {
   return getCookieValue("kvbskt");
 }
 function setBasketID(basketId) {
   setCookieValue("kvbskt", basketId, "path=/;secure;");
 }
-async function createBasket(apollo) {
+async function createBasketHelper(apollo) {
   try {
     return apollo.mutate({
       mutation: import_core.gql`mutation createNewBasketForUser { shop { id createBasket } }`
@@ -119,91 +154,472 @@ async function createBasket(apollo) {
     throw parseShopError(error);
   }
 }
+var activeBasketCreationQuery = null;
+async function createBasket(apollo) {
+  if (activeBasketCreationQuery) {
+    return activeBasketCreationQuery;
+  }
+  activeBasketCreationQuery = createBasketHelper(apollo);
+  return activeBasketCreationQuery;
+}
 function hasBasketExpired(error) {
   const errorCode = error?.code ?? error?.extensions?.code ?? error?.name ?? "";
   return ["shop.invalidBasketId", "shop.basketRequired", "shop.alreadyCheckedOut"].includes(errorCode);
 }
 
-// src/basketItems.ts
+// src/basketCredits.ts
 var import_core2 = require("@apollo/client/core");
-var import_numeral = __toESM(require("numeral"), 1);
-async function callShopMutation(apollo, mutation, variables, maxretries = 2) {
+
+// src/shopQueries.ts
+var watchQueries = /* @__PURE__ */ new Set();
+async function callShopMutation(apollo, options, maxretries = 2) {
   try {
     const result = await apollo.mutate({
-      mutation,
+      ...options,
       variables: {
-        ...variables,
+        ...options.variables,
         basketId: getBasketID()
-      }
+      },
+      refetchQueries: options.awaitRefetchQueries ? Array.from(watchQueries) : []
     });
     if (result?.errors?.length) {
       const basketErrors = result?.errors.filter((err) => hasBasketExpired(err));
       if (basketErrors.length) {
         if (maxretries > 0) {
           await createBasket(apollo);
-          return callShopMutation(apollo, mutation, variables, maxretries - 1);
+          return callShopMutation(apollo, options, maxretries - 1);
         }
         throw basketErrors[0];
       }
-      const otherErrors = result?.errors?.filter((err) => !hasBasketExpired(err));
-      if (otherErrors.length) {
-        throw otherErrors[0];
+      if (result?.errors?.length) {
+        throw result.errors[0];
       }
     }
     return result?.data;
   } catch (e) {
-    if (e instanceof ShopError) {
-      throw e;
+    throw parseShopError(e);
+  }
+}
+async function callShopQuery(apollo, options, maxretries = 2) {
+  try {
+    const result = await apollo.query({
+      ...options,
+      variables: {
+        ...options.variables,
+        basketId: getBasketID()
+      }
+    });
+    if (result?.errors?.length) {
+      const basketErrors = result?.errors.filter((err) => hasBasketExpired(err));
+      if (basketErrors.length) {
+        if (maxretries > 0) {
+          await createBasket(apollo);
+          return callShopQuery(apollo, options, maxretries - 1);
+        }
+        throw basketErrors[0];
+      }
+      if (result?.errors?.length) {
+        throw result.errors[0];
+      }
     }
+    return result?.data;
+  } catch (e) {
     throw parseShopError(e);
   }
 }
+function watchShopQuery(apollo, options, maxretries = 2) {
+  let retries = 0;
+  watchQueries.add(options.query);
+  const observable = apollo.watchQuery({
+    ...options,
+    variables: {
+      ...options.variables,
+      basketId: getBasketID()
+    }
+  });
+  const oldSubscribe = observable.subscribe.bind(observable);
+  observable.subscribe = (...args) => {
+    let nextFn;
+    let errorFn;
+    let completeFn;
+    if (typeof args[0] === "function") {
+      [nextFn, errorFn, completeFn] = args;
+    } else {
+      nextFn = args[0]?.next;
+      errorFn = args[0]?.error;
+      completeFn = args[0]?.complete;
+    }
+    const newErrorFn = (err) => {
+      const basketErrors = err?.graphQLErrors?.filter((e) => hasBasketExpired(e));
+      if (basketErrors.length) {
+        if (retries < maxretries) {
+          createBasket(apollo).then(() => {
+            retries += 1;
+            observable.refetch({
+              ...observable.variables,
+              basketId: getBasketID()
+            });
+          });
+        } else {
+          errorFn(parseShopError(basketErrors[0]));
+        }
+      } else {
+        if (err?.graphQLErrors?.length) {
+          errorFn(parseShopError(err.graphQLErrors[0]));
+        }
+        if (err?.networkError) {
+          errorFn(parseShopError(err.networkError));
+        }
+      }
+    };
+    return oldSubscribe(nextFn, newErrorFn, completeFn);
+  };
+  return observable;
+}
+
+// src/basketCredits.ts
+async function applyKivaCredit(apollo) {
+  const data = await callShopMutation(apollo, {
+    awaitRefetchQueries: true,
+    mutation: import_core2.gql`mutation applyKivaCredit($basketId: String) {
+			shop (basketId: $basketId) {
+				id
+				addCreditByType(creditType: kiva_credit)
+			}
+		}`
+  });
+  return !!data?.shop?.addCreditByType;
+}
+async function removeKivaCredit(apollo) {
+  const data = await callShopMutation(apollo, {
+    awaitRefetchQueries: true,
+    mutation: import_core2.gql`mutation removeKivaCredit($basketId: String) {
+			shop (basketId: $basketId) {
+				id
+				removeCreditByType(creditType: kiva_credit)
+			}
+		}`
+  });
+  return !!data?.shop?.removeCreditByType;
+}
+
+// src/basketItems.ts
+var import_core3 = require("@apollo/client/core");
+var import_numeral = __toESM(require("numeral"), 1);
 async function setTipDonation({ amount, apollo }) {
   const donationAmount = (0, import_numeral.default)(amount).format("0.00");
-  const data = await callShopMutation(apollo, import_core2.gql`mutation setTipDonation($price: Money!, $basketId: String) {
-		shop (basketId: $basketId) {
-			id
-			updateDonation (donation: {
-				price: $price,
-				isTip: true
-			})
-			{
+  const data = await callShopMutation(apollo, {
+    awaitRefetchQueries: true,
+    mutation: import_core3.gql`mutation setTipDonation($price: Money!, $basketId: String) {
+			shop (basketId: $basketId) {
 				id
-				price
-				isTip
+				updateDonation (donation: {
+					price: $price,
+					isTip: true
+				})
+				{
+					id
+					price
+					isTip
+				}
 			}
-		}
-	}`, { price: donationAmount });
+		}`,
+    variables: { price: donationAmount }
+  });
   return data?.shop?.updateDonation;
 }
 
-// src/oneTimeCheckout.ts
-var import_core3 = require("@apollo/client/core");
-async function executeOneTimeCheckout({ apollo }) {
+// src/basketTotals.ts
+var import_core4 = require("@apollo/client/core");
+var basketTotalsQuery = import_core4.gql`query basketTotals($basketId: String) {
+	shop (basketId: $basketId) {
+		id
+		basket {
+			id
+			totals {
+				bonusAppliedTotal
+				bonusAvailableTotal
+				creditAmountNeeded
+				creditAppliedTotal
+				creditAvailableTotal
+				donationTotal
+				itemTotal
+				freeTrialAppliedTotal
+				freeTrialAvailableTotal
+				loanReservationTotal
+				kivaCardTotal
+				kivaCreditAppliedTotal
+				kivaCreditAvailableTotal
+				kivaCreditRemaining
+				kivaCreditToReapply
+				redemptionCodeAppliedTotal
+				redemptionCodeAvailableTotal
+				universalCodeAppliedTotal
+				universalCodeAvailableTotal
+			}
+		}
+	}
+}`;
+function watchBasketTotals(apollo) {
+  return watchShopQuery(apollo, {
+    query: basketTotalsQuery
+  });
+}
+
+// src/basketVerification.ts
+var VerificationState = /* @__PURE__ */ ((VerificationState2) => {
+  VerificationState2["VERIFIED"] = "verified";
+  VerificationState2["PENDING"] = "pending";
+  VerificationState2["REQUIRED"] = "required";
+  VerificationState2["MAY_BE_NEEDED"] = "may_be_needed";
+  VerificationState2["NOT_NEEDED"] = "not_needed";
+  return VerificationState2;
+})(VerificationState || {});
+function isBasketVerified(state) {
+  return state === "verified" /* VERIFIED */ || state === "not_needed" /* NOT_NEEDED */;
+}
+
+// src/checkoutStatus.ts
+var import_core5 = require("@apollo/client/core");
+
+// src/util/poll.ts
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function poll(fn, fnCondition, interval, timeout) {
+  const endTime = Date.now() + timeout;
+  let result = await fn();
+  while (!fnCondition(result)) {
+    if (Date.now() > endTime) {
+      throw new Error("Polling timed out");
+    }
+    await wait(interval);
+    result = await fn();
+  }
+  return result;
 }
-async function waitOnTransaction({ apollo, transactionId }) {
-  const result = await apollo.query({
-    query: import_core3.gql`
-			query checkoutStatus($transactionId: String!, $visitorId: string) {
+
+// src/util/visitorId.ts
+function getVisitorID() {
+  return getCookieValue("uiv");
+}
+
+// src/checkoutStatus.ts
+async function getCheckoutStatus({ apollo, transactionSagaId }) {
+  return apollo.query({
+    query: import_core5.gql`
+			query checkoutStatus($transactionId: String!, $visitorId: String) {
 				checkoutStatus(transactionId: $transactionId, visitorId: $visitorId) {
+					basketId
 					errorCode
 					errorMessage
+					receipt {
+						checkoutId
+					}
+					requestedAt
 					status
 					transactionId
+					updatedAt
 				}
 			}
 		`,
     variables: {
-      transactionId
+      transactionId: transactionSagaId,
+      visitorId: getVisitorID()
     }
   });
 }
+async function pollForFinishedCheckout({
+  apollo,
+  transactionSagaId,
+  interval = 1e3,
+  timeout = 6e4
+}) {
+  return poll(
+    // function to poll
+    () => getCheckoutStatus({
+      apollo,
+      transactionSagaId
+    }),
+    // function to check for completed status
+    (result) => {
+      const { status, errorCode, errorMessage } = result?.data?.checkoutStatus;
+      if (status === "COMPLETED" || errorCode || errorMessage) {
+        return true;
+      }
+      return false;
+    },
+    interval,
+    timeout
+  );
+}
+
+// src/oneTimeCheckout.ts
+var import_core7 = require("@apollo/client/core");
+var import_numeral2 = __toESM(require("numeral"), 1);
+
+// src/validatePreCheckout.ts
+var import_core6 = require("@apollo/client/core");
+var validatePreCheckoutMutation = import_core6.gql`
+	mutation validatePreCheckout($basketId: String, $email: String, $visitorId: String, $emailOptIn: Boolean) {
+	shop (basketId: $basketId) {
+		id
+		validatePreCheckout (email: $email, visitorId: $visitorId, emailOptIn: $emailOptIn) {
+			error
+			success
+			value
+		}
+	}
+}`;
+async function validatePreCheckout({
+  apollo,
+  emailAddress,
+  emailOptIn
+}) {
+  const data = await callShopMutation(apollo, {
+    mutation: validatePreCheckoutMutation,
+    variables: {
+      visitorId: getVisitorID(),
+      email: emailAddress,
+      emailOptIn
+    }
+  }, 0);
+  const results = data?.shop?.validatePreCheckout;
+  const errors = results.filter(({ success }) => !success).map((result) => parseShopError(result));
+  if (errors.length) {
+    const aggregate = new ShopError({ code: "shop.failedCheckoutValidation" });
+    aggregate.aggregateErrors(errors);
+    throw aggregate;
+  }
+}
+
+// src/oneTimeCheckout.ts
+async function creditAmountNeeded(apollo) {
+  const data = await callShopQuery(apollo, {
+    query: import_core7.gql`
+			query creditAmountNeeded($basketId: String) {
+				shop (basketId: $basketId) {
+					id
+					basket {
+						id
+						totals {
+							creditAmountNeeded
+						}
+					}
+				}
+			}
+		`
+  }, 0);
+  return data?.shop?.basket?.totals?.creditAmountNeeded;
+}
+var creditCheckoutMutation = import_core7.gql`
+	mutation creditCheckout(
+		$basketId: String,
+		$visitorId: String
+	) {
+		shop (basketId: $basketId) {
+			id
+			transactionId: checkoutAsync (visitorId: $visitorId)
+		}
+	}
+`;
+var depositCheckoutMutation = import_core7.gql`
+	mutation depositCheckout(
+		$basketId: String,
+		$amount: Money!,
+		$nonce: String!,
+		$savePaymentMethod: Boolean,
+		$deviceData: String,
+		$visitorId: String
+	) {
+		shop (basketId: $basketId) {
+			id
+			transactionId: doNoncePaymentDepositAndCheckoutAsync(
+				amount: $amount,
+				nonce: $nonce,
+				savePaymentMethod: $savePaymentMethod,
+				deviceData: $deviceData,
+				visitorId: $visitorId
+			)
+		}
+	}
+`;
+function creditCheckout(apollo) {
+  return callShopMutation(apollo, {
+    mutation: creditCheckoutMutation,
+    variables: {
+      visitorId: getVisitorID()
+    }
+  }, 0);
+}
+async function depositCheckout({
+  apollo,
+  braintree,
+  amount
+}) {
+  try {
+    const paymentMethod = await braintree.requestPaymentMethod();
+    if (!paymentMethod) {
+      throw new ShopError(
+        { code: "shop.dropinNoPaymentMethod" },
+        "No payment method returned from braintree dropin"
+      );
+    }
+    const { nonce, deviceData } = paymentMethod;
+    return callShopMutation(apollo, {
+      mutation: depositCheckoutMutation,
+      variables: {
+        nonce,
+        amount,
+        savePaymentMethod: false,
+        // save payment methods handled by braintree drop in UI
+        deviceData,
+        visitorId: getVisitorID()
+      }
+    }, 0);
+  } catch (e) {
+    throw parseShopError(e);
+  }
+}
+async function executeOneTimeCheckout({
+  apollo,
+  braintree,
+  emailAddress,
+  emailOptIn
+}) {
+  await validatePreCheckout({
+    apollo,
+    emailAddress,
+    emailOptIn
+  });
+  const creditNeeded = await creditAmountNeeded(apollo);
+  const creditRequired = (0, import_numeral2.default)(creditNeeded).value() > 0;
+  if (creditRequired && !braintree) {
+    throw new ShopError({ code: "shop.dropinRequired" }, "Braintree dropin required for credit deposit checkout");
+  }
+  const data = creditRequired ? await depositCheckout({
+    apollo,
+    braintree,
+    amount: creditNeeded
+  }) : await creditCheckout(apollo);
+  const transactionId = data?.shop?.transactionId;
+  const result = await pollForFinishedCheckout({
+    apollo,
+    transactionSagaId: transactionId,
+    timeout: 3e5
+    // five minutes
+  });
+  if (result.errors?.length) {
+    throw parseShopError(result.errors[0]);
+  }
+  window.location.href = `/checkout/post-purchase?kiva_transaction_id=${transactionId}`;
+}
 
 // src/subscriptionCheckout.ts
-var import_core4 = require("@apollo/client/core");
+var import_core8 = require("@apollo/client/core");
 async function checkSubscriptionStatus(apollo) {
   const { data: subsData } = await apollo.query({
-    query: import_core4.gql`query subscriptionStatus{
+    query: import_core8.gql`query subscriptionStatus{
 			my {
 				id
 				subscriptions {
@@ -253,7 +669,7 @@ async function executeNewSubscriptionCheckout({
         donateAmount,
         dayOfMonth
       },
-      mutation: import_core4.gql`mutation createAutoDepositSubscription(
+      mutation: import_core8.gql`mutation createAutoDepositSubscription(
 				$nonce: String!,
 				$deviceData: String,
 				$amount: Money!,
@@ -297,13 +713,13 @@ async function executeNewSubscriptionCheckout({
 }
 
 // src/useBraintreeDropIn.ts
-var import_core5 = require("@apollo/client/core");
-var import_numeral2 = __toESM(require("numeral"), 1);
+var import_core9 = require("@apollo/client/core");
+var import_numeral3 = __toESM(require("numeral"), 1);
 var import_vue_demi = require("vue-demi");
 var defaultPaymentTypes = ["paypal", "card", "applePay", "googlePay"];
 async function getClientToken(apollo) {
   const { data, error, errors } = await apollo.query({
-    query: import_core5.gql`query getClientToken {
+    query: import_core9.gql`query getClientToken {
 			shop {
 				id
 				getClientToken(useCustomerId: true)
@@ -315,7 +731,7 @@ async function getClientToken(apollo) {
   }
   return data?.shop?.getClientToken;
 }
-function useBraintreeDropIn() {
+function initBraintreeDropin() {
   let instance;
   let formattedAmount = "";
   const paymentMethodRequestable = (0, import_vue_demi.ref)(false);
@@ -360,7 +776,7 @@ function useBraintreeDropIn() {
     preselectVaultedPaymentMethod = true,
     paypalFlow = "checkout"
   }) {
-    formattedAmount = (0, import_numeral2.default)(amount).format("0.00");
+    formattedAmount = (0, import_numeral3.default)(amount).format("0.00");
     const { default: DropIn } = await import("braintree-web-drop-in");
     try {
       instance = await DropIn.create({
@@ -430,7 +846,7 @@ function useBraintreeDropIn() {
     }
   }
   function updateAmount(amount) {
-    const newAmount = (0, import_numeral2.default)(amount).format("0.00");
+    const newAmount = (0, import_numeral3.default)(amount).format("0.00");
     if (newAmount !== formattedAmount) {
       formattedAmount = newAmount;
       instance?.updateConfiguration("paypal", "amount", formattedAmount);
@@ -445,22 +861,39 @@ function useBraintreeDropIn() {
     updateAmount
   };
 }
+var instances = {};
+function useBraintreeDropIn(key = "default") {
+  if (!instances[key]) {
+    instances[key] = initBraintreeDropin();
+  }
+  return instances[key];
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ShopError,
+  VerificationState,
+  applyKivaCredit,
+  basketTotalsQuery,
+  callShopMutation,
+  callShopQuery,
   checkSubscriptionStatus,
   createBasket,
   defaultPaymentTypes,
   executeNewSubscriptionCheckout,
   executeOneTimeCheckout,
   getBasketID,
+  getCheckoutStatus,
   getClientToken,
-  getCookieValue,
   hasBasketExpired,
+  isBasketVerified,
   parseShopError,
+  pollForFinishedCheckout,
+  removeKivaCredit,
   setBasketID,
-  setCookieValue,
   setTipDonation,
   useBraintreeDropIn,
-  waitOnTransaction
+  validatePreCheckout,
+  validatePreCheckoutMutation,
+  watchBasketTotals,
+  watchShopQuery
 });