@kiva/kv-shop 1.3.2 → 1.4.1

package/dist/index.d.ts

@@ -1,9 +1,16 @@
-export { createBasket, getBasketID, getCookieValue, hasBasketExpired, setBasketID, setCookieValue } from './basket.js';
-export { SetTipDonationOptions, setTipDonation } from './basketItems.js';
-export { OneTimeCheckoutOptions, WaitOnTransactionOptions, executeOneTimeCheckout, waitOnTransaction } from './oneTimeCheckout.js';
+export { createBasket, getBasketID, hasBasketExpired, setBasketID } from './basket.js';
+export { ApplyKivaCreditData, RemoveKivaCreditData, applyKivaCredit, removeKivaCredit } from './basketCredits.js';
+export { SetTipDonationData, SetTipDonationOptions, setTipDonation } from './basketItems.js';
+export { BasketTotalsData, basketTotalsQuery, watchBasketTotals } from './basketTotals.js';
+export { VerificationState, isBasketVerified } from './basketVerification.js';
+export { CheckoutStatusQueryResult, GetCheckoutStatusOptions, PollForCheckoutStatusOptions, getCheckoutStatus, pollForFinishedCheckout } from './checkoutStatus.js';
+export { OneTimeCheckoutOptions, executeOneTimeCheckout } from './oneTimeCheckout.js';
 export { ShopError, ShopErrorOptions, parseShopError } from './shopError.js';
+export { callShopMutation, callShopQuery, watchShopQuery } from './shopQueries.js';
 export { SubscriptionCheckoutOptions, checkSubscriptionStatus, executeNewSubscriptionCheckout } from './subscriptionCheckout.js';
-export { DropInInitOptions, PayPalFlowType, PaymentType, defaultPaymentTypes, getClientToken, default as useBraintreeDropIn } from './useBraintreeDropIn.js';
+export { DropInInitOptions, DropInWrapper, PayPalFlowType, PaymentType, defaultPaymentTypes, getClientToken, default as useBraintreeDropIn } from './useBraintreeDropIn.js';
+export { ValidatePreCheckoutData, ValidatePreCheckoutOptions, validatePreCheckout, validatePreCheckoutMutation } from './validatePreCheckout.js';
 import '@apollo/client/core';
+import 'graphql/language/ast';
 import 'braintree-web-drop-in';
-import '@vue/composition-api';
+import 'vue-demi';

package/dist/index.js

@@ -1,46 +1,80 @@
-import {
-  setTipDonation
-} from "./chunk-NC7RAUNV.js";
-import {
-  createBasket,
-  getBasketID,
-  getCookieValue,
-  hasBasketExpired,
-  setBasketID,
-  setCookieValue
-} from "./chunk-B7RLQXI6.js";
-import {
-  executeOneTimeCheckout,
-  waitOnTransaction
-} from "./chunk-M4CJOCIQ.js";
 import {
   checkSubscriptionStatus,
   executeNewSubscriptionCheckout
-} from "./chunk-TIASV6B2.js";
+} from "./chunk-KV4SOUVF.js";
 import {
   defaultPaymentTypes,
   getClientToken,
   useBraintreeDropIn
-} from "./chunk-SLMBU6L7.js";
+} from "./chunk-JXQPCEKG.js";
+import {
+  applyKivaCredit,
+  removeKivaCredit
+} from "./chunk-MRCBNXPS.js";
+import {
+  setTipDonation
+} from "./chunk-AI6E33YE.js";
+import {
+  basketTotalsQuery,
+  watchBasketTotals
+} from "./chunk-DZGZX4F6.js";
+import {
+  VerificationState,
+  isBasketVerified
+} from "./chunk-FCAOCO7O.js";
+import {
+  executeOneTimeCheckout
+} from "./chunk-EJ5NGYPO.js";
+import {
+  validatePreCheckout,
+  validatePreCheckoutMutation
+} from "./chunk-JBQ2KNMP.js";
+import {
+  callShopMutation,
+  callShopQuery,
+  watchShopQuery
+} from "./chunk-CBJJUUVR.js";
+import {
+  createBasket,
+  getBasketID,
+  hasBasketExpired,
+  setBasketID
+} from "./chunk-2NC7LGGO.js";
 import {
   ShopError,
   parseShopError
-} from "./chunk-IYCMZ5WV.js";
+} from "./chunk-4ODZGLWK.js";
+import {
+  getCheckoutStatus,
+  pollForFinishedCheckout
+} from "./chunk-PC4WUPYU.js";
+import "./chunk-TPJPGUO7.js";
+import "./chunk-LZ4UMRCV.js";
 export {
   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
 };

package/dist/oneTimeCheckout.cjs

@@ -1,6 +1,8 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -14,37 +16,422 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/oneTimeCheckout.ts
 var oneTimeCheckout_exports = {};
 __export(oneTimeCheckout_exports, {
-  executeOneTimeCheckout: () => executeOneTimeCheckout,
-  waitOnTransaction: () => waitOnTransaction
+  executeOneTimeCheckout: () => executeOneTimeCheckout
 });
 module.exports = __toCommonJS(oneTimeCheckout_exports);
+var import_core4 = require("@apollo/client/core");
+var import_numeral = __toESM(require("numeral"), 1);
+
+// src/checkoutStatus.ts
 var import_core = require("@apollo/client/core");
-async function executeOneTimeCheckout({ apollo }) {
+
+// 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;
+}
+
+// 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/util/visitorId.ts
+function getVisitorID() {
+  return getCookieValue("uiv");
 }
-async function waitOnTransaction({ apollo, transactionId }) {
-  const result = await apollo.query({
+
+// src/checkoutStatus.ts
+async function getCheckoutStatus({ apollo, transactionSagaId }) {
+  return apollo.query({
     query: import_core.gql`
-			query checkoutStatus($transactionId: String!, $visitorId: string) {
+			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/shopError.ts
+var ShopError = class extends Error {
+  constructor({ code, original }, ...params) {
+    super(...params);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, ShopError);
+    }
+    this.name = "ShopError";
+    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")) {
+    return new ShopError({
+      code: "paymentMethod.create.invalidMethodParameter",
+      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,
+      original: error
+    }, "There was a problem with your basket. Please, refresh the page and try again.");
+  }
+  if (errorCode === "donationAmountTooLarge") {
+    return new ShopError({
+      code: errorCode,
+      original: error
+    }, errorMessage);
+  }
+  return new ShopError({
+    code: "shop.unknown",
+    original: error
+  }, "An unknown error occurred.");
+}
+
+// src/basket.ts
+var import_core2 = require("@apollo/client/core");
+function getBasketID() {
+  return getCookieValue("kvbskt");
+}
+function setBasketID(basketId) {
+  setCookieValue("kvbskt", basketId, "path=/;secure;");
+}
+async function createBasketHelper(apollo) {
+  try {
+    return apollo.mutate({
+      mutation: import_core2.gql`mutation createNewBasketForUser { shop { id createBasket } }`
+    }).then(({ data }) => {
+      const newBasketId = data.shop?.createBasket ?? null;
+      if (newBasketId) {
+        setBasketID(newBasketId);
+      }
+    });
+  } catch (error) {
+    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/shopQueries.ts
+var watchQueries = /* @__PURE__ */ new Set();
+async function callShopMutation(apollo, options, maxretries = 2) {
+  try {
+    const result = await apollo.mutate({
+      ...options,
+      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, options, maxretries - 1);
+        }
+        throw basketErrors[0];
+      }
+      if (result?.errors?.length) {
+        throw result.errors[0];
+      }
+    }
+    return result?.data;
+  } catch (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);
+  }
+}
+
+// src/validatePreCheckout.ts
+var import_core3 = require("@apollo/client/core");
+var validatePreCheckoutMutation = import_core3.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_core4.gql`
+			query creditAmountNeeded($basketId: String) {
+				shop (basketId: $basketId) {
+					id
+					basket {
+						id
+						totals {
+							creditAmountNeeded
+						}
+					}
+				}
+			}
+		`
+  }, 0);
+  return data?.shop?.basket?.totals?.creditAmountNeeded;
+}
+var creditCheckoutMutation = import_core4.gql`
+	mutation creditCheckout(
+		$basketId: String,
+		$visitorId: String
+	) {
+		shop (basketId: $basketId) {
+			id
+			transactionId: checkoutAsync (visitorId: $visitorId)
+		}
+	}
+`;
+var depositCheckoutMutation = import_core4.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_numeral.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}`;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  executeOneTimeCheckout,
-  waitOnTransaction
+  executeOneTimeCheckout
 });

package/dist/oneTimeCheckout.d.ts

@@ -1,13 +1,14 @@
+import { ApolloClient } from '@apollo/client/core';
+import { DropInWrapper } from './useBraintreeDropIn.js';
+import 'vue-demi';
+import 'braintree-web-drop-in';
+
 interface OneTimeCheckoutOptions {
-    apollo: any;
-    basketId: string;
-    visitorId: string | null | undefined;
-}
-declare function executeOneTimeCheckout({ apollo }: OneTimeCheckoutOptions): Promise<void>;
-interface WaitOnTransactionOptions {
-    apollo: any;
-    transactionId: string;
+    apollo: ApolloClient<any>;
+    braintree?: DropInWrapper;
+    emailAddress?: string;
+    emailOptIn?: boolean;
 }
-declare function waitOnTransaction({ apollo, transactionId }: WaitOnTransactionOptions): Promise<void>;
+declare function executeOneTimeCheckout({ apollo, braintree, emailAddress, emailOptIn, }: OneTimeCheckoutOptions): Promise<void>;
 
-export { OneTimeCheckoutOptions, WaitOnTransactionOptions, executeOneTimeCheckout, waitOnTransaction };
+export { OneTimeCheckoutOptions, executeOneTimeCheckout };

package/dist/oneTimeCheckout.js

@@ -1,8 +1,13 @@
 import {
-  executeOneTimeCheckout,
-  waitOnTransaction
-} from "./chunk-M4CJOCIQ.js";
+  executeOneTimeCheckout
+} from "./chunk-EJ5NGYPO.js";
+import "./chunk-JBQ2KNMP.js";
+import "./chunk-CBJJUUVR.js";
+import "./chunk-2NC7LGGO.js";
+import "./chunk-4ODZGLWK.js";
+import "./chunk-PC4WUPYU.js";
+import "./chunk-TPJPGUO7.js";
+import "./chunk-LZ4UMRCV.js";
 export {
-  executeOneTimeCheckout,
-  waitOnTransaction
+  executeOneTimeCheckout
 };

package/dist/shopError.cjs

@@ -33,8 +33,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")) {
@@ -43,6 +49,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,

package/dist/shopError.d.ts

@@ -5,7 +5,9 @@ interface ShopErrorOptions {
 declare class ShopError extends Error {
     code: string;
     original?: object;
+    errors?: Array<ShopError>;
     constructor({ code, original }: ShopErrorOptions, ...params: any[]);
+    aggregateErrors(errors: Array<ShopError>): void;
 }
 declare function parseShopError(error: any): ShopError;
 

package/dist/shopError.js

@@ -1,7 +1,7 @@
 import {
   ShopError,
   parseShopError
-} from "./chunk-IYCMZ5WV.js";
+} from "./chunk-4ODZGLWK.js";
 export {
   ShopError,
   parseShopError