@cimplify/sdk 0.102.0 → 0.103.0

package/dist/chunk-CNN7Z2IP.js

@@ -0,0 +1,125 @@
+'use strict';
+
+// src/constants.ts
+var CHECKOUT_MODE = {
+  LINK: "link",
+  GUEST: "guest"
+};
+var ORDER_TYPE = {
+  DELIVERY: "delivery",
+  PICKUP: "pickup",
+  DINE_IN: "dine-in",
+  WALK_IN: "walk-in"
+};
+var PAYMENT_METHOD = {
+  MOBILE_MONEY: "mobile_money",
+  CARD: "card"
+};
+var CHECKOUT_STEP = {
+  AUTHENTICATION: "authentication",
+  ORDER_DETAILS: "order_details",
+  PAYMENT_METHOD: "payment_method",
+  PAYMENT: "payment",
+  CONFIRMATION: "confirmation"
+};
+var PAYMENT_STATE = {
+  INITIAL: "initial",
+  PREPARING: "preparing",
+  PROCESSING: "processing",
+  VERIFYING: "verifying",
+  AWAITING_AUTHORIZATION: "awaiting_authorization",
+  SUCCESS: "success",
+  ERROR: "error",
+  TIMEOUT: "timeout"
+};
+var PICKUP_TIME_TYPE = {
+  ASAP: "asap",
+  SCHEDULED: "scheduled"
+};
+var MOBILE_MONEY_PROVIDER = {
+  MTN: "mtn",
+  VODAFONE: "vodafone",
+  TELECEL: "telecel",
+  AIRTEL: "airtel",
+  AIRTELTIGO: "airteltigo",
+  MPESA: "mpesa"
+};
+var AUTHORIZATION_TYPE = {
+  OTP: "otp",
+  PIN: "pin",
+  PHONE: "phone",
+  BIRTHDAY: "birthday",
+  ADDRESS: "address"
+};
+var MAX_PAYMENT_AUTHORIZATION_STEPS = 8;
+var DEVICE_TYPE = {
+  MOBILE: "mobile",
+  DESKTOP: "desktop",
+  TABLET: "tablet",
+  UNKNOWN: "unknown"
+};
+var CONTACT_TYPE = {
+  PHONE: "phone",
+  EMAIL: "email"
+};
+var LINK_QUERY = {
+  DATA: "link.data",
+  ADDRESSES: "link.addresses",
+  MOBILE_MONEY: "link.mobile_money",
+  PREFERENCES: "link.preferences",
+  SESSIONS: "link.sessions"
+};
+var LINK_MUTATION = {
+  CHECK_STATUS: "link.check_status",
+  ENROLL: "link.enroll",
+  ENROLL_AND_LINK_ORDER: "link.enroll_and_link_order",
+  UPDATE_PREFERENCES: "link.update_preferences",
+  CREATE_ADDRESS: "link.create_address",
+  UPDATE_ADDRESS: "link.update_address",
+  DELETE_ADDRESS: "link.delete_address",
+  SET_DEFAULT_ADDRESS: "link.set_default_address",
+  TRACK_ADDRESS_USAGE: "link.track_address_usage",
+  CREATE_MOBILE_MONEY: "link.create_mobile_money",
+  DELETE_MOBILE_MONEY: "link.delete_mobile_money",
+  SET_DEFAULT_MOBILE_MONEY: "link.set_default_mobile_money",
+  TRACK_MOBILE_MONEY_USAGE: "link.track_mobile_money_usage",
+  VERIFY_MOBILE_MONEY: "link.verify_mobile_money",
+  REVOKE_SESSION: "link.revoke_session",
+  REVOKE_ALL_SESSIONS: "link.revoke_all_sessions"
+};
+var AUTH_MUTATION = {
+  REQUEST_OTP: "auth.request_otp",
+  VERIFY_OTP: "auth.verify_otp"
+};
+var CHECKOUT_MUTATION = {
+  PROCESS: "checkout.process"
+};
+var PAYMENT_MUTATION = {
+  SUBMIT_AUTHORIZATION: "payment.submit_authorization",
+  CHECK_STATUS: "order.poll_payment_status"
+};
+var ORDER_MUTATION = {
+  UPDATE_CUSTOMER: "order.update_order_customer"
+};
+var DEFAULT_CURRENCY = "GHS";
+var DEFAULT_COUNTRY = "GHA";
+
+exports.AUTHORIZATION_TYPE = AUTHORIZATION_TYPE;
+exports.AUTH_MUTATION = AUTH_MUTATION;
+exports.CHECKOUT_MODE = CHECKOUT_MODE;
+exports.CHECKOUT_MUTATION = CHECKOUT_MUTATION;
+exports.CHECKOUT_STEP = CHECKOUT_STEP;
+exports.CONTACT_TYPE = CONTACT_TYPE;
+exports.DEFAULT_COUNTRY = DEFAULT_COUNTRY;
+exports.DEFAULT_CURRENCY = DEFAULT_CURRENCY;
+exports.DEVICE_TYPE = DEVICE_TYPE;
+exports.LINK_MUTATION = LINK_MUTATION;
+exports.LINK_QUERY = LINK_QUERY;
+exports.MAX_PAYMENT_AUTHORIZATION_STEPS = MAX_PAYMENT_AUTHORIZATION_STEPS;
+exports.MOBILE_MONEY_PROVIDER = MOBILE_MONEY_PROVIDER;
+exports.ORDER_MUTATION = ORDER_MUTATION;
+exports.ORDER_TYPE = ORDER_TYPE;
+exports.PAYMENT_METHOD = PAYMENT_METHOD;
+exports.PAYMENT_MUTATION = PAYMENT_MUTATION;
+exports.PAYMENT_STATE = PAYMENT_STATE;
+exports.PICKUP_TIME_TYPE = PICKUP_TIME_TYPE;

package/dist/{chunk-DKLHCZ5M.mjs → chunk-GERXZQSX.mjs}

@@ -1,5 +1,5 @@
-import { safe, generateIdempotencyKey, err, ok, CatalogueQueries, CartOperations, CheckoutService, OrderQueries, LinkService, AuthService, BusinessService, InventoryService, SchedulingService, LiteService, FxService, createElements } from './chunk-Z3K2D3TE.mjs';
-import { CimplifyError, ErrorCode, IdempotencyMismatchError, enrichError } from './chunk-O3YUHLZL.mjs';
+import { safe, generateIdempotencyKey, err, ok, CatalogueQueries, CartOperations, CheckoutService, OrderQueries, LinkService, AuthService, BusinessService, InventoryService, SchedulingService, LiteService, FxService, createElements } from './chunk-J6PNHDHL.mjs';
+import { CimplifyError, ErrorCode, IdempotencyMismatchError, enrichError } from './chunk-VNPEYLB2.mjs';
 
 // src/store-credit.ts
 var StoreCreditQueries = class {
@@ -721,6 +721,453 @@ var SupportService = class {
   }
 };
 
+// src/payment-authorization/providers/paystack.ts
+async function openPaystackPopup(options, signal) {
+  if (typeof window === "undefined") {
+    return { success: false, error: "PROVIDER_UNAVAILABLE" };
+  }
+  let PaystackPop;
+  try {
+    const imported = await import('@paystack/inline-js');
+    PaystackPop = imported.default;
+  } catch {
+    return { success: false, error: "PROVIDER_UNAVAILABLE" };
+  }
+  return new Promise((resolve) => {
+    let settled = false;
+    let providerStarted = false;
+    const resolveOnce = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (signal) {
+        signal.removeEventListener("abort", onAbort);
+      }
+      resolve(result);
+    };
+    const onAbort = () => {
+      resolveOnce({
+        success: false,
+        // Once Paystack owns the transaction, cancellation is ambiguous. The
+        // adapter converts this into submitted so Cimplify polling decides.
+        error: providerStarted ? "SUBMISSION_UNKNOWN" : "CANCELLED"
+      });
+    };
+    if (signal?.aborted) {
+      resolveOnce({ success: false, error: "CANCELLED" });
+      return;
+    }
+    if (signal) {
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+    try {
+      const popup = new PaystackPop();
+      popup.newTransaction({
+        key: options.key,
+        email: options.email,
+        amount: options.amount,
+        currency: options.currency,
+        reference: options.reference,
+        accessCode: options.accessCode,
+        onSuccess: (transaction) => {
+          resolveOnce({
+            success: true,
+            reference: transaction.reference ?? options.reference
+          });
+        },
+        onCancel: () => {
+          resolveOnce({ success: false, error: "PAYMENT_CANCELLED" });
+        },
+        onError: (error) => {
+          resolveOnce({
+            success: false,
+            error: error?.message || "PAYMENT_FAILED"
+          });
+        }
+      });
+      providerStarted = true;
+    } catch {
+      resolveOnce({ success: false, error: "POPUP_BLOCKED" });
+    }
+  });
+}
+var PaystackAuthorizationAdapter = class {
+  constructor(openPopup = openPaystackPopup) {
+    this.openPopup = openPopup;
+    this.provider = "paystack";
+  }
+  async authorize(context) {
+    const result = await this.openPopup(
+      {
+        key: context.action.public_key,
+        email: context.email,
+        accessCode: context.action.client_secret,
+        reference: context.reference || context.action.client_secret,
+        currency: context.currency
+      },
+      context.signal
+    );
+    if (result.success) {
+      return { status: "submitted", reference: result.reference || context.reference };
+    }
+    if (result.error === "SUBMISSION_UNKNOWN") {
+      return { status: "submitted", reference: context.reference };
+    }
+    if (!result.error || result.error === "CANCELLED" || result.error === "PAYMENT_CANCELLED") {
+      return { status: "cancelled" };
+    }
+    if (result.error === "POPUP_BLOCKED") {
+      return {
+        status: "failed",
+        code: "POPUP_BLOCKED",
+        message: "Unable to open the Paystack payment popup. Please allow popups and try again.",
+        recoverable: true
+      };
+    }
+    if (result.error === "PROVIDER_UNAVAILABLE") {
+      return {
+        status: "failed",
+        code: "PROVIDER_UNAVAILABLE",
+        message: "Paystack is unavailable in this environment.",
+        recoverable: false
+      };
+    }
+    return {
+      status: "failed",
+      code: "PAYMENT_FAILED",
+      message: result.error || "Paystack payment could not be submitted.",
+      recoverable: true
+    };
+  }
+};
+
+// src/payment-authorization/providers/stripe.ts
+async function loadStripeFromPeer(publicKey) {
+  try {
+    const imported = await import('@stripe/stripe-js');
+    return imported.loadStripe ? imported.loadStripe(publicKey) : null;
+  } catch {
+    return null;
+  }
+}
+function createStripeModal() {
+  if (typeof document === "undefined" || !document.body) return null;
+  const previousFocus = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+  const root = document.createElement("div");
+  root.setAttribute("role", "dialog");
+  root.setAttribute("aria-modal", "true");
+  root.setAttribute("aria-label", "Secure card payment");
+  Object.assign(root.style, {
+    position: "fixed",
+    inset: "0",
+    zIndex: "2147483647",
+    display: "grid",
+    placeItems: "center",
+    padding: "16px",
+    background: "rgba(15, 23, 42, 0.58)"
+  });
+  const form = document.createElement("form");
+  Object.assign(form.style, {
+    width: "min(100%, 480px)",
+    maxHeight: "calc(100vh - 32px)",
+    overflow: "auto",
+    borderRadius: "12px",
+    padding: "24px",
+    background: "#fff",
+    boxShadow: "0 24px 80px rgba(15, 23, 42, 0.32)"
+  });
+  const title = document.createElement("h2");
+  title.textContent = "Complete card payment";
+  Object.assign(title.style, { margin: "0 0 18px", font: "600 18px/1.4 system-ui" });
+  const paymentMount = document.createElement("div");
+  paymentMount.setAttribute("data-cimplify-stripe-payment-element", "");
+  const error = document.createElement("p");
+  error.setAttribute("role", "alert");
+  Object.assign(error.style, {
+    minHeight: "20px",
+    margin: "14px 0 0",
+    color: "#b91c1c",
+    font: "14px/1.4 system-ui"
+  });
+  const actions = document.createElement("div");
+  Object.assign(actions.style, {
+    display: "flex",
+    justifyContent: "flex-end",
+    gap: "10px",
+    marginTop: "18px"
+  });
+  const cancelButton = document.createElement("button");
+  cancelButton.type = "button";
+  cancelButton.textContent = "Cancel";
+  Object.assign(cancelButton.style, {
+    border: "1px solid #cbd5e1",
+    borderRadius: "8px",
+    padding: "10px 16px",
+    background: "#fff",
+    color: "#0f172a",
+    cursor: "pointer"
+  });
+  const submitButton = document.createElement("button");
+  submitButton.type = "submit";
+  submitButton.textContent = "Pay securely";
+  Object.assign(submitButton.style, {
+    border: "0",
+    borderRadius: "8px",
+    padding: "10px 16px",
+    background: "#0f172a",
+    color: "#fff",
+    cursor: "pointer"
+  });
+  actions.append(cancelButton, submitButton);
+  form.append(title, paymentMount, error, actions);
+  root.append(form);
+  document.body.append(root);
+  cancelButton.focus();
+  return { root, form, paymentMount, submitButton, cancelButton, error, previousFocus };
+}
+function stripeFailure(error) {
+  const message = error?.message || "Stripe could not authorize this payment.";
+  if (error?.code === "payment_intent_authentication_failure" || error?.type === "invalid_request_error") {
+    return {
+      status: "failed",
+      code: "AUTHORIZATION_FAILED",
+      message,
+      recoverable: true
+    };
+  }
+  return { status: "failed", code: "PAYMENT_FAILED", message, recoverable: true };
+}
+var StripeAuthorizationAdapter = class {
+  constructor(loadStripe = loadStripeFromPeer) {
+    this.loadStripe = loadStripe;
+    this.provider = "stripe";
+  }
+  async authorize(context) {
+    if (typeof window === "undefined" || typeof document === "undefined" || context.signal?.aborted) {
+      return context.signal?.aborted ? { status: "cancelled" } : {
+        status: "failed",
+        code: "PROVIDER_UNAVAILABLE",
+        message: "Stripe Payment Element is unavailable in this environment.",
+        recoverable: false
+      };
+    }
+    let stripe;
+    try {
+      stripe = await this.loadStripe(context.action.public_key);
+    } catch (error) {
+      return {
+        status: "failed",
+        code: "PROVIDER_UNAVAILABLE",
+        message: error instanceof Error ? error.message : "Stripe.js could not be loaded.",
+        recoverable: true
+      };
+    }
+    if (context.signal?.aborted) {
+      return { status: "cancelled" };
+    }
+    if (!stripe) {
+      return {
+        status: "failed",
+        code: "PROVIDER_UNAVAILABLE",
+        message: "Stripe.js could not be loaded.",
+        recoverable: false
+      };
+    }
+    const modal = createStripeModal();
+    if (!modal) {
+      return {
+        status: "failed",
+        code: "PROVIDER_UNAVAILABLE",
+        message: "Stripe Payment Element could not be mounted.",
+        recoverable: false
+      };
+    }
+    let paymentElement;
+    let elements;
+    try {
+      elements = stripe.elements({ clientSecret: context.action.client_secret });
+      paymentElement = elements.create("payment");
+      paymentElement.mount(modal.paymentMount);
+    } catch {
+      modal.root.remove();
+      modal.previousFocus?.focus();
+      return {
+        status: "failed",
+        code: "PROVIDER_UNAVAILABLE",
+        message: "Stripe Payment Element could not be initialized.",
+        recoverable: false
+      };
+    }
+    if (context.signal?.aborted) {
+      if (paymentElement.destroy) paymentElement.destroy();
+      else paymentElement.unmount?.();
+      modal.root.remove();
+      modal.previousFocus?.focus();
+      return { status: "cancelled" };
+    }
+    return new Promise((resolve) => {
+      let settled = false;
+      let submitting = false;
+      let confirmationStarted = false;
+      const cleanup = () => {
+        context.signal?.removeEventListener("abort", onAbort);
+        modal.form.removeEventListener("submit", onSubmit);
+        modal.cancelButton.removeEventListener("click", onCancel);
+        if (paymentElement.destroy) paymentElement.destroy();
+        else paymentElement.unmount?.();
+        modal.root.remove();
+        modal.previousFocus?.focus();
+      };
+      const settle = (outcome) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        resolve(outcome);
+      };
+      const onAbort = () => {
+        if (confirmationStarted) {
+          settle({ status: "submitted", reference: context.reference });
+          return;
+        }
+        settle({ status: "cancelled" });
+      };
+      const onCancel = () => {
+        if (!confirmationStarted) settle({ status: "cancelled" });
+      };
+      const onSubmit = async (event) => {
+        event.preventDefault();
+        if (submitting || settled) return;
+        submitting = true;
+        modal.submitButton.disabled = true;
+        modal.error.textContent = "";
+        try {
+          const validation = elements.submit ? await elements.submit() : {};
+          if (validation.error) {
+            modal.error.textContent = validation.error.message || "Check your payment details.";
+            submitting = false;
+            modal.submitButton.disabled = false;
+            return;
+          }
+          if (settled || context.signal?.aborted) {
+            settle({ status: "cancelled" });
+            return;
+          }
+          confirmationStarted = true;
+          modal.cancelButton.disabled = true;
+          const confirmation = await stripe.confirmPayment({
+            elements,
+            confirmParams: { return_url: context.returnUrl || window.location.href },
+            redirect: "if_required"
+          });
+          if (settled) return;
+          if (confirmation.error) {
+            settle(stripeFailure(confirmation.error));
+            return;
+          }
+          settle({
+            status: "submitted",
+            reference: confirmation.paymentIntent?.id || context.reference
+          });
+        } catch (error) {
+          if (confirmationStarted) {
+            settle({ status: "submitted", reference: context.reference });
+            return;
+          }
+          settle(
+            stripeFailure({
+              message: error instanceof Error ? error.message : "Stripe confirmation failed."
+            })
+          );
+        }
+      };
+      modal.form.addEventListener("submit", onSubmit);
+      modal.cancelButton.addEventListener("click", onCancel);
+      context.signal?.addEventListener("abort", onAbort, { once: true });
+      paymentElement.on?.("escape", onCancel);
+      paymentElement.on?.("loaderror", (event) => {
+        if (confirmationStarted) return;
+        settle({
+          status: "failed",
+          code: "PROVIDER_UNAVAILABLE",
+          message: event?.error?.message || "Stripe Payment Element failed to load.",
+          recoverable: true
+        });
+      });
+    });
+  }
+};
+
+// src/payment-authorization/registry.ts
+function normalizeProvider(provider) {
+  return typeof provider === "string" ? provider.trim().toLowerCase() : "";
+}
+var PaymentAuthorizationAdapterRegistry = class {
+  constructor(adapters = []) {
+    this.adapters = /* @__PURE__ */ new Map();
+    for (const adapter of adapters) {
+      this.register(adapter);
+    }
+  }
+  register(adapter) {
+    const provider = normalizeProvider(adapter.provider);
+    if (!provider) {
+      throw new TypeError("Payment authorization adapter provider cannot be empty.");
+    }
+    this.adapters.set(provider, adapter);
+    return this;
+  }
+  unregister(provider) {
+    return this.adapters.delete(normalizeProvider(provider));
+  }
+  get(provider) {
+    return this.adapters.get(normalizeProvider(provider));
+  }
+  supports(provider) {
+    return this.adapters.has(normalizeProvider(provider));
+  }
+  providers() {
+    return [...this.adapters.keys()];
+  }
+  async authorize(action, options) {
+    const provider = normalizeProvider(action.provider);
+    if (!provider) {
+      return {
+        status: "failed",
+        code: "PROVIDER_UNAVAILABLE",
+        message: "Card authorization response did not identify a payment provider.",
+        recoverable: false
+      };
+    }
+    const adapter = this.adapters.get(provider);
+    if (!adapter) {
+      return {
+        status: "failed",
+        code: "PROVIDER_UNAVAILABLE",
+        message: `Card authorization provider '${provider}' is not supported by this SDK client.`,
+        recoverable: false
+      };
+    }
+    try {
+      const normalizedAction = action.provider === provider ? action : { ...action, provider };
+      return await adapter.authorize({ ...options, action: normalizedAction });
+    } catch (error) {
+      return {
+        status: "failed",
+        code: "PAYMENT_FAILED",
+        message: error instanceof Error ? error.message : `Card authorization provider '${provider}' failed unexpectedly.`,
+        recoverable: true
+      };
+    }
+  }
+};
+function createDefaultPaymentAuthorizationAdapterRegistry() {
+  return new PaymentAuthorizationAdapterRegistry([
+    new PaystackAuthorizationAdapter(),
+    new StripeAuthorizationAdapter()
+  ]);
+}
+
 // src/client.ts
 var SESSION_TOKEN_STORAGE_KEY = "cimplify_session_token";
 var SESSION_SYNC_STORAGE_KEY = "cimplify_session_sync";
@@ -845,6 +1292,7 @@ var CimplifyClient = class {
     this.context = {};
     this.businessId = null;
     this.businessIdResolvePromise = null;
+    this.publicKeyEpoch = 0;
     this.inflightRequests = /* @__PURE__ */ new Map();
     /**
      * App-level event channel. Subscribe to surface mutation rollbacks, outbox
@@ -863,6 +1311,7 @@ var CimplifyClient = class {
     this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
     this.retryDelay = config.retryDelay ?? DEFAULT_RETRY_DELAY_MS;
     this.hooks = config.hooks ?? {};
+    this.authorizationAdapters = config.authorizationAdapterRegistry ?? createDefaultPaymentAuthorizationAdapterRegistry();
     this.fetchImpl = (config.fetch ?? globalThis.fetch).bind(globalThis);
     this.sessionToken = this.loadSessionToken() ?? this.mintSessionToken();
     this.watchCrossTabSession();
@@ -1079,10 +1528,18 @@ var CimplifyClient = class {
   // X-API-Key and the business can't be resolved.
   setPublicKey(publicKey) {
     const normalized = publicKey.trim();
-    if (!normalized) {
-      return;
-    }
+    if (normalized === this.publicKey) return;
     this.publicKey = normalized;
+    this.publicKeyEpoch += 1;
+    this.businessId = null;
+    this.businessIdResolvePromise = null;
+    this.inflightRequests.clear();
+    this._activity?.resetSession();
+    delete this.context.location_id;
+    if (this.accessToken !== null) {
+      this.setAccessToken(null);
+    }
+    this.events.emit(SESSION_CLEARED, {});
   }
   getBusinessId() {
     return this.businessId;
@@ -1094,7 +1551,8 @@ var CimplifyClient = class {
     if (this.businessIdResolvePromise) {
       return this.businessIdResolvePromise;
     }
-    this.businessIdResolvePromise = (async () => {
+    const publicKeyEpoch = this.publicKeyEpoch;
+    const resolution = (async () => {
       const result = await this.business.getInfo();
       if (!result.ok || !result.value?.id) {
         throw new CimplifyError(
@@ -1103,13 +1561,23 @@ var CimplifyClient = class {
           true
         );
       }
+      if (this.publicKeyEpoch !== publicKeyEpoch) {
+        throw new CimplifyError(
+          ErrorCode.TENANT_CONTEXT_CHANGED,
+          "The storefront tenant changed while resolving its business identity.",
+          true
+        );
+      }
       this.businessId = result.value.id;
       return result.value.id;
     })();
+    this.businessIdResolvePromise = resolution;
     try {
-      return await this.businessIdResolvePromise;
+      return await resolution;
     } finally {
-      this.businessIdResolvePromise = null;
+      if (this.businessIdResolvePromise === resolution) {
+        this.businessIdResolvePromise = null;
+      }
     }
   }
   async authedFetch(url, options, timeoutMs) {
@@ -1312,7 +1780,13 @@ var CimplifyClient = class {
   }
   getDedupeKey(type, payload, cacheOptions) {
     const cacheKey = cacheOptions ? `|${JSON.stringify(cacheOptions)}` : "";
-    return `${type}:${JSON.stringify(payload)}${cacheKey}`;
+    const identityKey = JSON.stringify([
+      this.publicKey.trim(),
+      this.publicKeyEpoch,
+      this.sessionEpoch,
+      this.context.location_id ?? null
+    ]);
+    return `${type}:${identityKey}:${JSON.stringify(payload)}${cacheKey}`;
   }
   async deduplicatedRequest(key, requestFn) {
     const existing = this.inflightRequests.get(key);
@@ -1320,7 +1794,9 @@ var CimplifyClient = class {
       return existing;
     }
     const request = requestFn().finally(() => {
-      this.inflightRequests.delete(key);
+      if (this.inflightRequests.get(key) === request) {
+        this.inflightRequests.delete(key);
+      }
     });
     this.inflightRequests.set(key, request);
     return request;
@@ -1572,4 +2048,4 @@ function createCimplifyClient(config = {}) {
   return new CimplifyClient(config);
 }
 
-export { AUTH_TOKEN_CHANGED, ActivityService, CimplifyClient, DeliveryService, MUTATION_ERROR, PlacesService, SESSION_CLAIMED, SESSION_CLEARED, StoreCreditQueries, SubscriptionService, SupportService, UploadService, createCimplifyClient };
+export { AUTH_TOKEN_CHANGED, ActivityService, CimplifyClient, DeliveryService, MUTATION_ERROR, PaymentAuthorizationAdapterRegistry, PaystackAuthorizationAdapter, PlacesService, SESSION_CLAIMED, SESSION_CLEARED, StoreCreditQueries, StripeAuthorizationAdapter, SubscriptionService, SupportService, UploadService, createCimplifyClient, createDefaultPaymentAuthorizationAdapterRegistry };