@occluze/tether 0.6.8 → 0.7.1

package/src/cart.js

@@ -1,391 +0,0 @@
-/**
- * The cart, as one object: `Tether.cart`. Every change goes through one queue (fast clicks never race) and resolves
- * with the cart Shopify sent back. The state lives in `cart/store.js`, the Cart API calls in `cart/mutations.js`, the
- * drawer in `cart/drawer.js`, the document rendering in `cart/render.js` and the checkout in `cart/checkout.js`.
- */
-import { cfg, reportError } from './config.js';
-import { TetherError } from './client.js';
-import { emit, toAttributes } from './dom.js';
-import {
-  fetchCart,
-  isCartGone,
-  mutateCart,
-  removeLines,
-  setLineQuantity,
-  toLineInput,
-  toLineUpdate,
-  updateLines,
-} from './cart/mutations.js';
-import { checkout } from './cart/checkout.js';
-import { drawers, isOpen, openCart, closeCart, toggleCart, trapFocus } from './cart/drawer.js';
-import {
-  announce,
-  cartStatus,
-  commit,
-  currentCart,
-  currentWarnings,
-  customer,
-  enqueue,
-  forgetSavedCart,
-  keepQuietly,
-  pendingQuantities,
-  pendingQuantityOf,
-  render,
-  savedCartId,
-  setFailure,
-  settleLoad,
-  showLastKnownCount,
-  subscribe,
-} from './cart/store.js';
-/** @import { CartWarning } from './config.js' */
-/** @import { Attributes, LineSpec, CartLineInput, LinePatch } from './cart/mutations.js' */
-/** @import { ShopifyCart, ShopifyCartLine, CustomerLink, CartStatus } from './cart/store.js' */
-
-export { trapFocus };
-
-/** @returns {readonly ShopifyCartLine[]} */
-const currentLines = () => currentCart()?.lines.nodes ?? [];
-
-/**
- * +1 / -1 for a line. Quick clicks add up: each builds on the quantity the click before asked for, which shows at once
- * (`tether-line="quantity"`, `quantityOf`) until Shopify has answered. Only the latest target is sent; the ones it
- * replaced are skipped.
- *
- * @param {string} lineId
- * @param {number} delta
- * @returns {Promise<ShopifyCart | null>}
- */
-function changeQuantity(lineId, delta) {
-  const line = currentLines().find((candidate) => candidate.id === lineId);
-  if (!line) return Promise.resolve(currentCart());
-  const target = Math.max(0, pendingQuantityOf(line) + delta);
-  const job = { quantity: target };
-  pendingQuantities.set(lineId, job);
-  announce('pending');
-  const isLatest = () => pendingQuantities.get(lineId) === job;
-  const sent = enqueue(async () => {
-    if (!isLatest()) return currentCart();
-    const now = currentLines().find((candidate) => candidate.id === lineId);
-    // A + then a -: Shopify already has the quantity.
-    if (now?.quantity === target) return currentCart();
-    const cart = await setLineQuantity(lineId, target);
-    // A newer click is on its way: keep this answer, but show totals and count once that one is in, instead of
-    // stepping through every reply.
-    if (!isLatest()) {
-      keepQuietly(cart);
-      return cart;
-    }
-    return commit(cart, target > 0 ? 'update' : 'remove');
-  });
-  return sent.finally(() => {
-    if (!isLatest()) return;
-    pendingQuantities.delete(lineId);
-    announce('settled');
-  });
-}
-
-/**
- * The codes the cart has once a change is its turn in the queue.
- *
- * @param {string[] | string | ((current: string[]) => string[])} codes A function gets the codes as they are by then.
- * @returns {string[]}
- */
-function discountCodesFrom(codes) {
-  const current = (currentCart()?.discountCodes ?? []).map((discount) => discount.code);
-  const list = typeof codes === 'function' ? codes(current) : codes;
-  return (Array.isArray(list) ? list : [list]).map((code) => code.trim()).filter(Boolean);
-}
-
-/**
- * @param {Attributes} attributes
- * @returns {{ key: string, value: string }[]} The cart's attributes with `attributes` merged in; `''` removes a key.
- */
-function mergedAttributes(attributes) {
-  const merged = new Map((currentCart()?.attributes ?? []).map((attribute) => [attribute.key, attribute.value]));
-  toAttributes(attributes).forEach((attribute) => merged.set(attribute.key, attribute.value));
-  return [...merged].filter(([, value]) => value !== '').map(([key, value]) => ({ key, value }));
-}
-
-/**
- * Loads the saved cart. A cart Shopify no longer has is forgotten; one it can't be asked about (the network, the
- * token) is kept, because it is probably fine.
- *
- * @returns {Promise<ShopifyCart | null>}
- */
-async function init() {
-  const id = savedCartId();
-  if (!id) {
-    settleLoad({ kind: 'loaded', cart: null });
-    return null;
-  }
-  showLastKnownCount();
-  try {
-    const cart = await fetchCart(id);
-    if (!cart) forgetSavedCart();
-    settleLoad({ kind: 'loaded', cart });
-  } catch (error) {
-    reportError(error, 'cart load failed');
-    if (isCartGone(error)) forgetSavedCart();
-    settleLoad({ kind: 'failed', error });
-  }
-  return currentCart();
-}
-
-export const Cart = {
-  init,
-  /** @returns {string | null} The saved cart's id. */
-  id: savedCartId,
-
-  /** @returns {CartStatus} */
-  get status() {
-    return cartStatus();
-  },
-  /** @returns {ShopifyCart | null} */
-  get state() {
-    return currentCart();
-  },
-  /** @returns {readonly ShopifyCartLine[]} */
-  get lines() {
-    return currentLines();
-  },
-  /** @returns {number} */
-  get count() {
-    return currentCart()?.totalQuantity ?? 0;
-  },
-  /** @returns {boolean} True once the saved cart, or that there is none, is known. */
-  get loaded() {
-    return cartStatus().kind !== 'unknown';
-  },
-  /** @returns {unknown} The failure of the last load or change, until a change succeeds. */
-  get lastError() {
-    const current = cartStatus();
-    return current.kind === 'error' ? current.error : null;
-  },
-  set lastError(error) {
-    setFailure(error);
-  },
-  /** @returns {readonly CartWarning[]} Shopify's notes on the last change. */
-  get warnings() {
-    return currentWarnings();
-  },
-  /** @returns {ReadonlyMap<string, { quantity: number }>} Line id → the quantity quick clicks asked for. */
-  get pendingQty() {
-    return pendingQuantities;
-  },
-
-  /** @returns {string | null} The logged-in customer's Customer Account API token (set by the account part). */
-  get customerAccessToken() {
-    return customer.accessToken;
-  },
-  set customerAccessToken(token) {
-    customer.accessToken = token || null;
-  },
-  /** @returns {(() => Promise<string | null>) | null} The account's own checkout URL (set by the account part). */
-  get beforeCheckout() {
-    return customer.beforeCheckout;
-  },
-  set beforeCheckout(fetchUrl) {
-    customer.beforeCheckout = typeof fetchUrl === 'function' ? fetchUrl : null;
-  },
-  /**
-   * Links the cart to a logged-in customer, or unlinks it with `null`s. Carts created from now on belong to the
-   * customer; `beforeCheckout` gives the checkout URL (`null` from it uses the cart's).
-   *
-   * @param {Partial<CustomerLink>} link Fields left out keep their value.
-   */
-  setCustomer(link) {
-    if (link.accessToken !== undefined) customer.accessToken = link.accessToken;
-    if (link.beforeCheckout !== undefined) customer.beforeCheckout = link.beforeCheckout;
-  },
-
-  /** Keeps a cart and shows it, as a change does; tests seed the cart with it. */
-  _commit: commit,
-  render,
-  subscribe,
-
-  /**
-   * `add(variantId, 2)`, `add({ variantId, quantity, sellingPlanId, attributes })`, or `add([line, line])` for
-   * bundles in one request. Creates the cart when there is none.
-   *
-   * @param {string | number | LineSpec | (string | number | LineSpec)[]} input
-   * @param {number} [quantity]
-   * @param {Omit<LineSpec, 'variantId' | 'quantity'>} [options]
-   * @returns {Promise<ShopifyCart | null>}
-   */
-  add(input, quantity = 1, options = {}) {
-    /** @type {CartLineInput[]} */
-    const lines = (Array.isArray(input) ? input : [input]).map((line) => toLineInput(line, quantity, options));
-    return enqueue(async () => {
-      const cart = await mutateCart({
-        name: 'cartLinesAdd',
-        args: '$lines: [CartLineInput!]!',
-        inner: 'lines: $lines',
-        variables: { lines },
-        createInput: { lines },
-      });
-      commit(cart, 'add');
-      emit('added', { cart, lines });
-      if (cfg.openCartOnAdd) openCart();
-      return cart;
-    });
-  },
-
-  /**
-   * `updateLine(lineId, 3)` or `updateLine(lineId, { quantity, sellingPlanId, attributes })`.
-   *
-   * @param {string} lineId
-   * @param {number | LinePatch} patch A quantity of 0 or less removes the line.
-   * @returns {Promise<ShopifyCart | null>}
-   */
-  updateLine(lineId, patch) {
-    const quantity = typeof patch === 'number' ? patch : patch.quantity;
-    if (quantity !== undefined && quantity <= 0) return Cart.removeLine(lineId);
-    const line = toLineUpdate(lineId, patch);
-    return enqueue(async () => commit(await updateLines([line]), 'update'));
-  },
-
-  changeQuantity,
-
-  /**
-   * @param {ShopifyCartLine} line
-   * @returns {number} The quantity to show: the one asked for while an update is on its way.
-   */
-  quantityOf: pendingQuantityOf,
-
-  /**
-   * @param {string | string[]} lineIds
-   * @returns {Promise<ShopifyCart | null>}
-   */
-  removeLine(lineIds) {
-    const ids = Array.isArray(lineIds) ? lineIds : [lineIds];
-    return enqueue(async () => commit(await removeLines(ids), 'remove'));
-  },
-
-  /** @returns {Promise<ShopifyCart | null>} */
-  clear() {
-    const ids = currentLines().map((line) => line.id);
-    if (!ids.length) return Promise.resolve(currentCart());
-    return Cart.removeLine(ids);
-  },
-
-  /**
-   * @param {string | null | undefined} note
-   * @returns {Promise<ShopifyCart | null>}
-   */
-  setNote(note) {
-    const variables = { note: note ?? '' };
-    return enqueue(async () =>
-      commit(
-        await mutateCart({
-          name: 'cartNoteUpdate',
-          args: '$note: String!',
-          inner: 'note: $note',
-          variables,
-          createInput: variables,
-        }),
-        'note',
-      ),
-    );
-  },
-
-  /**
-   * Cart attributes, merged with the cart's (as it is when the change runs, so quick calls don't drop each other).
-   *
-   * @param {Attributes} attributes The value `''` removes a key.
-   * @returns {Promise<ShopifyCart | null>}
-   */
-  setAttributes(attributes) {
-    return enqueue(async () => {
-      const variables = { attributes: mergedAttributes(attributes) };
-      const cart = await mutateCart({
-        name: 'cartAttributesUpdate',
-        args: '$attributes: [AttributeInput!]!',
-        inner: 'attributes: $attributes',
-        variables,
-        createInput: variables,
-      });
-      return commit(cart, 'attributes');
-    });
-  },
-
-  /**
-   * Replaces the discount codes; `[]` removes them all.
-   *
-   * @param {string[] | string | ((current: string[]) => string[])} codes
-   * @returns {Promise<ShopifyCart | null>}
-   */
-  setDiscountCodes(codes) {
-    return enqueue(async () => {
-      const variables = { discountCodes: discountCodesFrom(codes) };
-      const cart = await mutateCart({
-        name: 'cartDiscountCodesUpdate',
-        args: '$discountCodes: [String!]!',
-        inner: 'discountCodes: $discountCodes',
-        variables,
-        createInput: variables,
-      });
-      return commit(cart, 'discount');
-    });
-  },
-
-  /**
-   * Adds a code. A code Shopify doesn't accept is removed again, so it doesn't warn on every later change.
-   *
-   * @param {string} code
-   * @returns {Promise<ShopifyCart | null>}
-   * @throws {TetherError} `INVALID_DISCOUNT` (rejected) when Shopify doesn't accept the code.
-   */
-  async applyDiscount(code) {
-    const cart = await Cart.setDiscountCodes((current) => [...new Set([...current, code])]);
-    const wanted = code.toLowerCase();
-    const applied = (cart?.discountCodes ?? []).find((discount) => discount.code.toLowerCase() === wanted);
-    if (applied?.applicable) return cart;
-    try {
-      await Cart.removeDiscount(code);
-    } catch (error) {
-      reportError(error, 'removing a discount code Shopify refused');
-    }
-    throw new TetherError(`Discount code not valid: ${code}`, { code: 'INVALID_DISCOUNT' });
-  },
-
-  /**
-   * @param {string} code
-   * @returns {Promise<ShopifyCart | null>}
-   */
-  removeDiscount(code) {
-    const unwanted = code.toLowerCase();
-    return Cart.setDiscountCodes((current) => current.filter((existing) => existing.toLowerCase() !== unwanted));
-  },
-
-  /**
-   * Sets who is buying; a country changes the cart's currency and prices to that market's.
-   *
-   * @param {{ countryCode?: string, email?: string, phone?: string, customerAccessToken?: string | null }} buyerIdentity
-   * @param {{ create?: boolean }} [options] `create: false` forgets an expired cart instead of creating an empty one.
-   * @returns {Promise<ShopifyCart | null>}
-   */
-  setBuyerIdentity(buyerIdentity, { create = true } = {}) {
-    return enqueue(async () => {
-      const cart = await mutateCart({
-        name: 'cartBuyerIdentityUpdate',
-        args: '$buyerIdentity: CartBuyerIdentityInput!',
-        inner: 'buyerIdentity: $buyerIdentity',
-        variables: { buyerIdentity },
-        createInput: create ? { buyerIdentity } : null,
-      }).catch((/** @type {unknown} */ error) => {
-        // mutateCart has forgotten the cart Shopify no longer has; without `create` that leaves no cart.
-        if (create || !isCartGone(error)) throw error;
-        return null;
-      });
-      return commit(cart, 'buyer-identity');
-    });
-  },
-
-  checkout,
-
-  drawers,
-  isOpen,
-  open: openCart,
-  close: closeCart,
-  toggle: toggleCart,
-};

package/src/client.js

@@ -1,267 +0,0 @@
-/**
- * The one Storefront API client: a fetch wrapper that adds the market (`@inContext`), retries what Shopify asks to be
- * retried, and turns every failure into a `TetherError`. The browser (`gql`, also `Tether.query()`) and the server
- * helpers (`request` with their own config) share it.
- */
-import { cfg, log } from './config.js';
-import { toCountry, toLanguage } from './market-codes.js';
-/** @import { TetherConfig } from './config.js' */
-
-/**
- * @typedef {'NOT_FOUND' | 'NETWORK' | 'NOT_CONFIGURED' | 'NOT_LOGGED_IN' | 'NOT_ALLOWED' | 'INVALID'
- *   | 'INVALID_COUNTRY' | 'INVALID_DISCOUNT' | 'SESSION_ENDED' | 'TOKEN_FAILED' | 'ERROR' | `HTTP_${number}`}
- *   TetherErrorCode
- */
-/** @typedef {{ message: string, extensions?: { code?: string } }} GraphQLError */
-/** @typedef {{ data?: unknown, errors?: GraphQLError[] }} GraphQLResponse The response shape the GraphQL spec sets. */
-/** @typedef {{ message: string, field?: string[] | null, code?: string | null }} UserError */
-/**
- * @typedef {object} TetherErrorDetails
- * @property {TetherErrorCode} [code] Default `HTTP_<status>` with a status, else `ERROR`.
- * @property {number} [status] The HTTP status of the response that failed.
- * @property {GraphQLError[]} [errors] The GraphQL errors of that response.
- * @property {readonly UserError[]} [userErrors] A mutation's user errors.
- */
-
-export class TetherError extends Error {
-  /**
-   * @param {string} message
-   * @param {TetherErrorDetails} [details]
-   */
-  constructor(message, { status, errors, userErrors, code } = {}) {
-    super(message);
-    this.name = 'TetherError';
-    /** @type {TetherErrorCode} */
-    this.code = code ?? (status ? `HTTP_${status}` : 'ERROR');
-    /** @type {number | undefined} */
-    this.status = status;
-    /** @type {GraphQLError[] | undefined} */
-    this.errors = errors;
-    /** @type {readonly UserError[] | undefined} */
-    this.userErrors = userErrors;
-  }
-}
-
-/**
- * What a request needs from a config: the browser's `cfg`, or a config the server helpers build.
- *
- * @typedef {Pick<TetherConfig, 'domain' | 'token' | 'apiVersion' | 'country' | 'language' | 'maxAge' | 'retries'>
- *   & { fetch?: typeof fetch }} StorefrontConfig
- */
-/** @typedef {{ context?: boolean }} RequestOptions `context: false` sends the query without `@inContext`. */
-
-/**
- * @param {Pick<TetherConfig, 'domain' | 'apiVersion'>} [conf]
- * @returns {string} The Storefront GraphQL endpoint of `conf`'s store.
- */
-export function endpoint(conf = cfg) {
-  return `https://${conf.domain}/api/${conf.apiVersion}/graphql.json`;
-}
-
-/**
- * Adds @inContext(country, language) to the first operation in the document, so prices, currency and translations
- * follow the configured market. Operations are always written first, fragments after, so the first match is the
- * operation. A country or language that isn't a valid code is left out.
- *
- * @param {string} query
- * @param {{ country?: string | undefined, language?: string | undefined }} [ctx]
- * @returns {string}
- */
-export function withContext(query, ctx = cfg) {
-  const args = [];
-  const country = toCountry(ctx.country);
-  const language = toLanguage(ctx.language);
-  if (country) args.push(`country: ${country}`);
-  if (language) args.push(`language: ${language}`);
-  if (!args.length || query.includes('@inContext')) return query;
-
-  const tag = `@inContext(${args.join(', ')})`;
-  // Named (query Name($x: T)), anonymous (query { … }) and shorthand ({ … }) queries.
-  if (/^\s*\{/.test(query)) return `query ${tag} ${query.trimStart()}`;
-  return query.replace(/^(\s*(?:query|mutation)(?:\s+\w+)?\s*(?:\([^)]*\))?)/, `$1 ${tag}`);
-}
-
-/** Backoff after a network error or a 429/5xx: this times 2^attempt. */
-const RETRY_BACKOFF_MS = 300;
-/** Backoff after Shopify's `THROTTLED` error, which asks for a longer wait: this times 2^attempt. */
-const THROTTLE_BACKOFF_MS = 500;
-/** Shopify's status for a request its bot protection rejected; retrying doesn't help. */
-const SECURITY_REJECTION = 430;
-
-/**
- * `quantityAvailable` needs the token's `unauthenticated_read_product_inventory` scope; without it Shopify refuses the
- * whole query with an error naming the field. That refusal is learned once per page and store: every later query to
- * the store goes out without the field, so stock levels are unknown and everything else works for one extra request.
- */
-const INVENTORY_FIELD = 'quantityAvailable';
-
-/** @type {Set<string>} The stores (domain, version and token) whose token can't read inventory. */
-const storesWithoutInventory = new Set();
-
-/** @param {StorefrontConfig} conf */
-const storeOf = (conf) => `${conf.domain} ${conf.apiVersion} ${conf.token}`;
-
-/** @param {number} ms */
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-
-/**
- * What a status means, for errors Shopify sends without a message (401/403 have none).
- *
- * @param {number} status
- * @param {StorefrontConfig} conf
- */
-function statusText(status, conf) {
-  if (status === 401 || status === 403) {
-    const adminHint = conf.token.startsWith('shpat_') ? ', not an Admin API token (shpat_…)' : '';
-    return `Shopify rejected the Storefront token for ${conf.domain} (${status}): use the public Storefront API token (Headless channel)${adminHint}`;
-  }
-  if (status === 404) {
-    return `Store or API version not found (404): check domain ${conf.domain} and apiVersion ${conf.apiVersion}`;
-  }
-  return `HTTP ${status} from ${conf.domain}`;
-}
-
-/**
- * @param {Response} res
- * @param {GraphQLError[]} errors
- * @param {StorefrontConfig} conf
- */
-function graphQLFailure(res, errors, conf) {
-  const message = errors
-    .map((error) => error.message)
-    .filter(Boolean)
-    .join(' | ');
-  let text = message || 'Storefront API error';
-  if (!res.ok) text = res.status === 401 || res.status === 403 || !message ? statusText(res.status, conf) : message;
-  return new TetherError(text, { status: res.status, errors });
-}
-
-/**
- * @typedef {{ kind: 'data', data: unknown }
- *   | { kind: 'retry', backoffMs: number }
- *   | { kind: 'inventory-refused' }} Attempt
- */
-
-/**
- * One request. Failures that retrying can't fix throw.
- *
- * @param {StorefrontConfig} conf
- * @param {string} query
- * @param {Record<string, unknown>} variables
- * @param {boolean} canRetry False on the last attempt: a retryable failure then throws too.
- * @returns {Promise<Attempt>}
- */
-async function attempt(conf, query, variables, canRetry) {
-  let res;
-  try {
-    res = await (conf.fetch ?? fetch)(endpoint(conf), {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json', 'X-Shopify-Storefront-Access-Token': conf.token },
-      body: JSON.stringify({ query, variables }),
-    });
-  } catch (error) {
-    if (canRetry) return { kind: 'retry', backoffMs: RETRY_BACKOFF_MS };
-    throw new TetherError(`Network error: ${error instanceof Error ? error.message : String(error)}`, {
-      code: 'NETWORK',
-    });
-  }
-  if (res.status === SECURITY_REJECTION) {
-    throw new TetherError('Shopify security rejection (430)', { status: SECURITY_REJECTION });
-  }
-  if (canRetry && (res.status === 429 || res.status >= 500)) {
-    return { kind: 'retry', backoffMs: RETRY_BACKOFF_MS };
-  }
-
-  /** @type {unknown} */
-  let json;
-  try {
-    json = await res.json();
-  } catch {
-    const text = res.ok ? `Invalid response (${res.status})` : statusText(res.status, conf);
-    throw new TetherError(text, { status: res.status });
-  }
-  // The Storefront API answers in the shape the GraphQL spec sets, or with an error page that isn't JSON.
-  const { data, errors = [] } = /** @type {GraphQLResponse | null} */ (json) ?? {};
-  if (errors.length) {
-    if (query.includes(INVENTORY_FIELD) && errors.some((error) => error.message.includes(INVENTORY_FIELD))) {
-      return { kind: 'inventory-refused' };
-    }
-    if (canRetry && errors.some((error) => error.extensions?.code === 'THROTTLED')) {
-      return { kind: 'retry', backoffMs: THROTTLE_BACKOFF_MS };
-    }
-    throw graphQLFailure(res, errors, conf);
-  }
-  if (!res.ok) throw new TetherError(statusText(res.status, conf), { status: res.status });
-  return { kind: 'data', data };
-}
-
-/**
- * One Storefront API request, for any config: the browser's shared one (`gql`) or one the server helpers build.
- * Queries carry a time bucket so Shopify's cache of an identical query text is at most `maxAge` seconds old, and
- * leave out inventory for a store whose token can't read it (`INVENTORY_FIELD`).
- *
- * @template T The shape of the query's `data`, which the caller's query text decides.
- * @param {StorefrontConfig} conf
- * @param {string} query
- * @param {Record<string, unknown>} [variables]
- * @param {RequestOptions} [options]
- * @returns {Promise<T>}
- * @throws {TetherError} `NOT_CONFIGURED` without a domain or token, `NETWORK` when the store can't be reached,
- *   `HTTP_<status>` for an HTTP or GraphQL failure.
- */
-export async function request(conf, query, variables = {}, { context = true } = {}) {
-  if (!conf.domain || !conf.token) {
-    throw new TetherError('Tether is not configured: domain and token are required', { code: 'NOT_CONFIGURED' });
-  }
-  let text = context ? withContext(query, conf) : query;
-  if (conf.maxAge > 0 && !/^\s*mutation\b/.test(text)) {
-    text += ` #${Math.floor(Date.now() / (conf.maxAge * 1000))}`;
-  }
-  const store = storeOf(conf);
-  let retries = 0;
-  for (;;) {
-    const sent = storesWithoutInventory.has(store) ? text.replaceAll(INVENTORY_FIELD, '') : text;
-    const outcome = await attempt(conf, sent, variables, retries < conf.retries);
-    switch (outcome.kind) {
-      case 'data':
-        // The query text decides the shape of `data`; the caller's `T` states it.
-        return /** @type {T} */ (outcome.data);
-      case 'inventory-refused':
-        log(`the token can't read inventory: ${INVENTORY_FIELD} is left out from now on`);
-        storesWithoutInventory.add(store);
-        break;
-      case 'retry':
-        retries += 1;
-        log('retry', retries);
-        await sleep(outcome.backoffMs * 2 ** retries);
-        break;
-    }
-  }
-}
-
-/**
- * `request` with the browser's shared config.
- *
- * @template T
- * @param {string} query
- * @param {Record<string, unknown>} [variables]
- * @param {RequestOptions} [options]
- * @returns {Promise<T>}
- */
-export const gql = (query, variables, options) => request(cfg, query, variables, options);
-
-/**
- * @template {{ userErrors?: readonly UserError[] | null }} Payload
- * @param {Payload | null | undefined} payload A mutation's payload.
- * @param {string} name The mutation, for the error message.
- * @returns {Payload}
- * @throws {TetherError} `ERROR` on an empty payload or on user errors (in `userErrors`).
- */
-export function unwrap(payload, name) {
-  if (!payload) throw new TetherError(`${name}: empty response`);
-  const userErrors = payload.userErrors ?? [];
-  if (userErrors.length) {
-    throw new TetherError(userErrors.map((error) => error.message).join(' | '), { userErrors });
-  }
-  return payload;
-}