@moonbase.sh/storefront-api 3.0.0 → 3.2.0

package/README.md

@@ -122,7 +122,17 @@ host — is returned untouched and logs a warning, since it will be served at fu
 
 ## Token storage and logging
 
-By default, credentials are stored in localStorage (or in-memory if localStorage is unavailable).
+By default, credentials are stored in localStorage, falling back to memory only when localStorage
+cannot be reached at all. Even that check sits inside a `try`, because reading
+`window.localStorage` itself throws in Firefox when the buyer has blocked cookies and site data.
+
+Reachability, not writability, is the test on purpose: an origin that is merely full is still
+holding the buyer's existing session, so it is used rather than discarded. Individual reads and
+writes that fail degrade to an in-memory copy and warn through the configured logger. The session
+stays valid for that page load; it just doesn't survive a reload, and
+`client.tokenStore.isPersistent` goes false once that has happened if you want to tell the buyer.
+A failure to *persist* credentials is never reported as a failure to sign in, so a locked-down
+browser can't strand someone in a sign-in loop.
 
 You can inject your own storage/logger implementations:
 

package/dist/index.cjs

@@ -49,6 +49,7 @@ __export(index_exports, {
   SubscriptionStatus: () => SubscriptionStatus,
   TokenStore: () => TokenStore,
   imageWidths: () => imageWidths,
+  isLocalStorageAvailable: () => isLocalStorageAvailable,
   isPromotionDisplay: () => isPromotionDisplay,
   isTransformableImageUrl: () => isTransformableImageUrl,
   maxImageDimension: () => maxImageDimension,
@@ -266,6 +267,10 @@ var productSummarySchema = import_zod2.z.object({
   releaseDescription: import_zod2.z.string().optional(),
   downloadsNeedsUser: import_zod2.z.boolean(),
   downloadsNeedsOwnership: import_zod2.z.boolean(),
+  downloadsNeedsGroupMembership: import_zod2.z.boolean(),
+  // Whether this caller clears every requirement above, including the group membership the client
+  // can't see for itself.
+  downloadsAllowed: import_zod2.z.boolean(),
   downloads: import_zod2.z.array(downloadSchema).optional()
 });
 
@@ -753,15 +758,15 @@ var IdentityEndpoints = class {
       throw new NotFoundError("User not found");
     if (response.status >= 400)
       await handleResponseProblem(response, this.logger);
+    let identity;
     try {
-      const data = await response.json();
-      const user = identitySchema.parse(data);
-      this.tokenStore.setUser(user);
-      return userSchema.parse(user);
+      identity = identitySchema.parse(await response.json());
     } catch (err) {
       this.logger.warn("Could not sign in user", { email, response, err });
       throw new MoonbaseError("Bad response", "Could not sign in user", response.status);
     }
+    this.tokenStore.setUser(identity);
+    return userSchema.parse(identity);
   }
   async signUp(name, email, password, address, acceptedPrivacyPolicy, acceptedTermsAndConditions, communicationOptIn) {
     const path = `/api/customer/identity/sign-up?scheme=JWT&communicationOptIn=${communicationOptIn ? "true" : "false"}`;
@@ -788,14 +793,15 @@ var IdentityEndpoints = class {
       const parsed = pendingActivationSchema.parse(data);
       return { status: "activation-pending", email: parsed.email };
     }
+    let identity;
     try {
-      const identity = identitySchema.parse(data);
-      this.tokenStore.setUser(identity);
-      return { status: "signed-in", user: userSchema.parse(identity) };
+      identity = identitySchema.parse(data);
     } catch (err) {
       this.logger.warn("Could not sign up user", { email, response, err });
       throw new MoonbaseError("Bad response", "Could not sign up user", response.status);
     }
+    this.tokenStore.setUser(identity);
+    return { status: "signed-in", user: userSchema.parse(identity) };
   }
   async signOut() {
     this.tokenStore.clear();
@@ -1075,6 +1081,15 @@ var MoonbaseApi = class {
       status: response.status,
       duration: finishedAt.getTime() - startedAt.getTime()
     });
+    if (response.type === "opaqueredirect" || response.status === 0) {
+      const err = new MoonbaseError(
+        "Unexpected redirect",
+        `The Moonbase API redirected ${path}, which the SDK is not configured to follow`,
+        response.status
+      );
+      this.reportRequestProblem(path, request, response, err);
+      throw err;
+    }
     if (response.status >= 400) {
       try {
         await handleResponseProblem(response, this.logger);
@@ -1430,6 +1445,9 @@ var OrderEndpoints = class {
       if (options.checkout.returnUrl) {
         query.append("returnUrl", options.checkout.returnUrl);
       }
+      if (options.checkout.embedded !== void 0) {
+        query.append("embedded", options.checkout.embedded ? "true" : "false");
+      }
     }
     const response = await this.api.fetch(`/api/customer/orders/${orderId}?${query.toString()}`, orderSchema, {
       abort: options == null ? void 0 : options.abort
@@ -1444,6 +1462,8 @@ var OrderEndpoints = class {
       query.checkout = "true";
       if (checkout.returnUrl)
         query.returnUrl = checkout.returnUrl;
+      if (checkout.embedded !== void 0)
+        query.embedded = checkout.embedded ? "true" : "false";
     }
     const response = await this.api.fetch(
       `/api/customer/orders/${order.id}?${new URLSearchParams(query).toString()}`,
@@ -1534,28 +1554,81 @@ var ConsoleLogger = class {
 };
 
 // src/utils/store.ts
+function isLocalStorageAvailable() {
+  try {
+    return typeof window !== "undefined" && !!window.localStorage;
+  } catch (e) {
+    return false;
+  }
+}
 var LocalStorageStore = class {
+  constructor(onDegraded) {
+    this.onDegraded = onDegraded;
+    // Values whose write to localStorage failed. Read back in preference to
+    // localStorage so the rest of the session sees what it just wrote.
+    this.fallback = /* @__PURE__ */ new Map();
+    this.degraded = false;
+  }
+  get isDegraded() {
+    return this.degraded;
+  }
   get(key) {
-    const item = localStorage.getItem(key);
-    if (item) {
-      return JSON.parse(item);
+    if (this.fallback.has(key))
+      return this.fallback.get(key);
+    try {
+      const item = localStorage.getItem(key);
+      if (item) {
+        return JSON.parse(item);
+      }
+      return null;
+    } catch (err) {
+      this.reportDegraded(err);
+      return null;
     }
-    return null;
   }
   set(key, item) {
-    localStorage.setItem(key, JSON.stringify(item));
+    try {
+      localStorage.setItem(key, JSON.stringify(item));
+      this.fallback.delete(key);
+    } catch (err) {
+      this.reportDegraded(err);
+      this.fallback.set(key, item);
+    }
   }
   remove(key) {
-    localStorage.removeItem(key);
+    try {
+      localStorage.removeItem(key);
+      this.fallback.delete(key);
+      return;
+    } catch (err) {
+      this.reportDegraded(err);
+    }
+    this.fallback.set(key, null);
+    try {
+      localStorage.setItem(key, "");
+    } catch (e) {
+    }
   }
   listen(key, callback) {
-    if (typeof window !== "undefined") {
-      window.addEventListener("storage", (event) => {
-        if (event.key === key) {
-          callback(event.newValue ? JSON.parse(event.newValue) : null);
-        }
-      });
-    }
+    if (typeof window === "undefined")
+      return;
+    window.addEventListener("storage", (event) => {
+      if (event.key !== key)
+        return;
+      this.fallback.delete(key);
+      try {
+        callback(event.newValue ? JSON.parse(event.newValue) : null);
+      } catch (err) {
+        console.warn(`Moonbase could not parse the stored value for ${key}`, err);
+      }
+    });
+  }
+  reportDegraded(err) {
+    var _a;
+    if (this.degraded)
+      return;
+    this.degraded = true;
+    (_a = this.onDegraded) == null ? void 0 : _a.call(this, err);
   }
 };
 var InMemoryStore = class {
@@ -1593,8 +1666,11 @@ var _TokenStore = class _TokenStore {
     this.tokens = null;
     this.refreshTimeoutId = null;
     this.refreshPromise = null;
-    var _a;
-    this.store = (_a = configuration.store) != null ? _a : typeof window !== "undefined" && localStorage ? new LocalStorageStore() : new InMemoryStore();
+    var _a, _b;
+    this.logger = (_a = configuration.logger) != null ? _a : new ConsoleLogger();
+    this.store = (_b = configuration.store) != null ? _b : isLocalStorageAvailable() ? new LocalStorageStore((err) => this.warnAboutStorage(err)) : new InMemoryStore();
+    if (typeof window !== "undefined" && !configuration.store && !(this.store instanceof LocalStorageStore))
+      this.warnAboutStorage();
     const storedToken = this.store.get(_TokenStore.storageKey);
     if (storedToken) {
       this.tokens = {
@@ -1609,18 +1685,17 @@ var _TokenStore = class _TokenStore {
       return this.tokens;
     return null;
   }
+  get isPersistent() {
+    return this.store instanceof LocalStorageStore && !this.store.isDegraded;
+  }
   async getAccessToken() {
     var _a, _b, _c;
-    if (this.isExpired) {
-      if (this.refreshPromise) {
-        const tokens2 = await this.refreshPromise;
-        return (_a = tokens2 == null ? void 0 : tokens2.accessToken) != null ? _a : null;
-      }
-      this.refreshPromise = this.refreshTokens();
-      const tokens = await this.refreshPromise;
-      return (_b = tokens == null ? void 0 : tokens.accessToken) != null ? _b : null;
+    if (!this.isExpired) {
+      return ((_a = this.tokens) == null ? void 0 : _a.accessToken) || null;
     }
-    return ((_c = this.tokens) == null ? void 0 : _c.accessToken) || null;
+    const pending = (_b = this.refreshPromise) != null ? _b : this.startRefresh();
+    const tokens = await pending;
+    return (_c = tokens == null ? void 0 : tokens.accessToken) != null ? _c : null;
   }
   setUser(user) {
     const identity = user;
@@ -1645,7 +1720,7 @@ var _TokenStore = class _TokenStore {
       if (this.refreshTimeoutId != null)
         window.clearTimeout(this.refreshTimeoutId);
       this.refreshTimeoutId = window.setTimeout(() => {
-        this.refreshPromise = this.refreshTokens();
+        this.startRefresh().catch((err) => this.logger.warn("Could not refresh access token", err));
       }, 10 * 60 * 1e3);
     }
     return this.tokens;
@@ -1660,10 +1735,25 @@ var _TokenStore = class _TokenStore {
   get isExpired() {
     return this.tokens != null && this.tokens.expiresAt < /* @__PURE__ */ new Date();
   }
+  /**
+   * Start a refresh and hold it so concurrent callers join it rather than firing
+   * their own. The slot is cleared as soon as it settles: a retained promise
+   * would hand every later expiry the same stale access token, and a rejected one
+   * that stayed put would re-throw on every subsequent request (including the
+   * anonymous ones) for the rest of the session.
+   */
+  startRefresh() {
+    const pending = this.refreshTokens().finally(() => {
+      if (this.refreshPromise === pending)
+        this.refreshPromise = null;
+    });
+    this.refreshPromise = pending;
+    return pending;
+  }
   async refreshTokens() {
     if (!this.tokens)
       throw new Error("No tokens found to refresh");
-    const response = await fetch(`${this.configuration.endpoint}/api/customer/identity/refresh?token=${this.tokens.refreshToken}`, {
+    const response = await fetch(`${this.configuration.endpoint}/api/customer/identity/refresh?token=${encodeURIComponent(this.tokens.refreshToken)}`, {
       method: "POST",
       headers: {
         "Accept": "application/json",
@@ -1685,12 +1775,18 @@ var _TokenStore = class _TokenStore {
   }
   handleStorageUpdate(updatedTokens) {
     this.tokens = updatedTokens;
-    if (this.refreshTimeoutId != null)
+    if (this.refreshTimeoutId != null && typeof window !== "undefined")
       window.clearTimeout(this.refreshTimeoutId);
     if (this.tokens) {
       this.tokens.expiresAt = new Date(this.tokens.expiresAt);
     }
   }
+  warnAboutStorage(err) {
+    this.logger.warn(
+      "Moonbase could not persist credentials to localStorage: this browser is blocking or has exhausted site storage. Sign-in will work for this page load but will not survive a reload.",
+      err
+    );
+  }
 };
 _TokenStore.storageKey = "moonbase_auth";
 var TokenStore = _TokenStore;
@@ -1878,10 +1974,29 @@ var OfferUtils = class _OfferUtils {
   static relevantTargets(offer, cartItems) {
     if (offer.targets.length > 1) {
       const allOwned = offer.targets.every((t) => t.item.owned);
-      return offer.targets.filter((t) => (allOwned || !t.item.owned) && !cartItems.some((l) => l.type === t.item.type && t.item.id === (l.type === "Product" ? l.productId : l.bundleId)));
+      return offer.targets.filter((t) => (allOwned || !t.item.owned) && !_OfferUtils.targetInCart(t, cartItems));
     }
     return offer.targets;
   }
+  /**
+   * Whether every item an offer targets is already in the cart, so the offer has no upsell left to
+   * show.
+   *
+   * This is the set of offers the cart hides: a card inviting the buyer to add what they have already
+   * added says nothing, so it is dropped. Which makes it exactly the set whose discount nothing can
+   * currently claim: an offer is only good for one line, and there is no card left to spend it from.
+   *
+   * An offer with no targets names nothing and so is never in this set.
+   */
+  static allTargetsInCart(offer, cartItems) {
+    return offer.targets.length > 0 && offer.targets.every((target) => _OfferUtils.targetInCart(target, cartItems));
+  }
+  // Matched on the item alone, not the variation: a target narrowed to one variation still counts as
+  // in the cart when another variation of it is. That is the reading the cart's own upsell has always
+  // taken, and the two have to agree or an offer could be hidden and auto-applied at once.
+  static targetInCart(target, cartItems) {
+    return cartItems.some((l) => l.type === target.item.type && target.item.id === (l.type === "Product" ? l.productId : l.bundleId));
+  }
   // The pricing variations a target restricts the offer to. An empty (or missing) variation list
   // means the offer is not narrowed to specific variations, in which case we keep the established
   // single default-variation upsell.
@@ -1912,7 +2027,7 @@ var OfferUtils = class _OfferUtils {
 };
 
 // src/utils/cart.ts
-var CartUtils = class _CartUtils {
+var _CartUtils = class _CartUtils {
   // The pricing variation a line item points at, falling back to the item's default variation when
   // the variation id doesn't resolve, which is what the cart has always displayed.
   static resolveVariation(catalog, item) {
@@ -1970,8 +2085,13 @@ var CartUtils = class _CartUtils {
   // Which lines a cart offer discounts. No targets means the whole cart, a reading that only holds
   // for cart-scope offers, where an empty target list is the API's way of saying "every line".
   static cartOfferAppliesToLine(offer, item) {
-    if (offer.targets.length === 0)
-      return true;
+    return offer.targets.length === 0 || _CartUtils.offerTargetsLine(offer, item);
+  }
+  // Whether an offer names this line among its targets. An empty variation list on a target leaves
+  // the offer open to every variation of that item. An offer with no targets at all names nothing
+  // here, which is why the "every line" reading stays in `cartOfferAppliesToLine`: it is only true
+  // of a cart offer.
+  static offerTargetsLine(offer, item) {
     return offer.targets.some(({ item: target, variations }) => target.type === item.type && target.id === (item.type === "Product" ? item.productId : item.bundleId) && (variations.length === 0 || variations.includes(item.variationId)));
   }
   // The cart offer actually discounting this cart, as opposed to the one attached to the order. An
@@ -2048,6 +2168,148 @@ var CartUtils = class _CartUtils {
       return aggregate + DiscountUtils.apply(offer.discount, { [currency]: unitPrice })[currency] * item.quantity;
     }, 0);
   }
+  /**
+   * The item-scope offer worth attaching to a single line, or `undefined` when none is.
+   *
+   * Ranked by what it would actually take off this line rather than by percentage, the same way
+   * `bestCartOffer` ranks a cart: a flat amount off can beat a bigger-looking percentage on a cheap
+   * line, and the other way round on an expensive one.
+   *
+   * `unavailableOfferIds` are offers the rest of the cart has already claimed. An offer is only ever
+   * good for one line, since the cart treats an offer held by any line as in use. So a caller walking
+   * the cart must reserve each one as it goes, or two lines would both count on the same offer and
+   * the API would honour it once. `assignItemOffers` does that bookkeeping for a whole cart.
+   */
+  static bestItemOffer(catalog, item, currency, context, unavailableOfferIds) {
+    let best;
+    for (const candidate of _CartUtils.itemOfferCandidates(catalog, [item], currency, context, unavailableOfferIds)) {
+      if (!best || candidate.value > best.value)
+        best = candidate;
+    }
+    return best == null ? void 0 : best.offer;
+  }
+  /**
+   * Which item-scope offer to attach to which line, for the lines not already carrying one.
+   *
+   * Chosen for what the pairings are worth together rather than by cart order. An offer is only good
+   * for one line, so walking the cart and taking the best offer for each line in turn hands a
+   * multi-target offer to whichever line the buyer happened to add first, which is arbitrary and can
+   * be the cheapest one. A buyer claiming these from the upsell cards would have placed them where
+   * they are worth most, so that is what this does.
+   *
+   * Lines already holding an offer are left alone and their offers reserved: an offer on a line is
+   * intent, whether the buyer's from the upsell or the API's from a refreshed order, and this is not
+   * the place to second-guess it.
+   */
+  static assignItemOffers(catalog, order, currency, context) {
+    const conditionContext = context != null ? context : _CartUtils.conditionContext(catalog, order, currency);
+    const claimed = new Set(order.items.map((i) => i.offerId).filter((id) => !!id));
+    return _CartUtils.maximalItemOfferAssignment(
+      _CartUtils.itemOfferCandidates(catalog, order.items.filter((i) => !i.offerId), currency, conditionContext, claimed)
+    );
+  }
+  /**
+   * The pairings worth the most together, given each offer can only be spent once.
+   *
+   * Taking the most valuable pairing first is not enough: with one offer worth 100 on line A and 99 on
+   * line B, and a second offer worth 98 on line A alone, claiming the 100 strands the second offer and
+   * saves 100, where putting the first offer on B and the second on A saves 197. The pairings have to
+   * be chosen as a set.
+   *
+   * Walked line by line, memoised on which offers are still free. The candidates have already been
+   * through targeting and eligibility, so in a real cart there are a handful; past `searchableOffers`
+   * distinct offers it takes the most valuable pairing first instead, which is never worse than
+   * applying nothing.
+   */
+  static maximalItemOfferAssignment(candidates) {
+    var _a;
+    const optionsByItem = /* @__PURE__ */ new Map();
+    const offerBits = /* @__PURE__ */ new Map();
+    for (const { item, offer, value } of candidates) {
+      let bit = offerBits.get(offer.id);
+      if (bit === void 0) {
+        bit = offerBits.size;
+        offerBits.set(offer.id, bit);
+      }
+      const options = (_a = optionsByItem.get(item.id)) != null ? _a : [];
+      options.push({ offerId: offer.id, bit, value });
+      optionsByItem.set(item.id, options);
+    }
+    if (offerBits.size > _CartUtils.searchableOffers)
+      return _CartUtils.mostValuableItemOfferPairings(candidates);
+    const itemIds = [...optionsByItem.keys()];
+    const memo = /* @__PURE__ */ new Map();
+    const from = (index, spent) => {
+      var _a2;
+      if (index >= itemIds.length)
+        return { value: 0, assignments: [] };
+      const key = `${index}:${spent}`;
+      const memoised = memo.get(key);
+      if (memoised)
+        return memoised;
+      let best = from(index + 1, spent);
+      const itemId = itemIds[index];
+      for (const option of (_a2 = optionsByItem.get(itemId)) != null ? _a2 : []) {
+        if (spent & 1 << option.bit)
+          continue;
+        const rest = from(index + 1, spent | 1 << option.bit);
+        const value = option.value + rest.value;
+        if (value > best.value)
+          best = { value, assignments: [{ itemId, offerId: option.offerId }, ...rest.assignments] };
+      }
+      memo.set(key, best);
+      return best;
+    };
+    return from(0, 0).assignments;
+  }
+  // The fallback for a candidate set too large to search: repeatedly take the most valuable pairing
+  // still available. Can strand a better combination, which is the whole reason it is only a fallback.
+  static mostValuableItemOfferPairings(candidates) {
+    const assignments = [];
+    const assignedItemIds = /* @__PURE__ */ new Set();
+    const spentOfferIds = /* @__PURE__ */ new Set();
+    for (const { item, offer } of [...candidates].sort((a, b) => b.value - a.value)) {
+      if (assignedItemIds.has(item.id) || spentOfferIds.has(offer.id))
+        continue;
+      assignedItemIds.add(item.id);
+      spentOfferIds.add(offer.id);
+      assignments.push({ itemId: item.id, offerId: offer.id });
+    }
+    return assignments;
+  }
+  // Every line-and-offer pairing the cart could make, and what each would save. Enumerated in cart
+  // order and then catalog order, which `sort` preserves for equal savings, so an unchanged cart
+  // always resolves the same way.
+  static itemOfferCandidates(catalog, items, currency, context, unavailableOfferIds) {
+    var _a;
+    const candidates = [];
+    for (const item of items) {
+      const unitPrice = _CartUtils.unitPrice(catalog, item, currency);
+      if (unitPrice === void 0)
+        continue;
+      for (const offer of (_a = catalog.offers) != null ? _a : []) {
+        if (offer.scope === "Cart" || (unavailableOfferIds == null ? void 0 : unavailableOfferIds.has(offer.id)))
+          continue;
+        if (!_CartUtils.offerTargetsLine(offer, item))
+          continue;
+        if (!OfferUtils.allTargetsInCart(offer, context.order.items))
+          continue;
+        if (!OfferUtils.eligible(offer, context))
+          continue;
+        const value = _CartUtils.itemOfferUnitDiscount(offer, unitPrice, currency) * item.quantity;
+        if (value <= 0)
+          continue;
+        candidates.push({ item, offer, value });
+      }
+    }
+    return candidates;
+  }
+  // What an item offer takes off one unit of a line. Measured off the post-product-discount price,
+  // which is what an item offer comes off in the API's order: product discount -> line offer -> cart
+  // offer -> coupons.
+  static itemOfferUnitDiscount(offer, unitPrice, currency) {
+    return DiscountUtils.apply(offer.discount, { [currency]: unitPrice })[currency];
+  }
   // A line's unit price once its own offer has come off, which is what a cart offer is applied to:
   // the API discounts in the order product discount -> line offer -> cart offer -> coupons. An
   // unresolvable price counts as zero, matching `total`'s "still render something" stance rather
@@ -2058,9 +2320,14 @@ var CartUtils = class _CartUtils {
     const itemOffer = item.offerId ? (_b = catalog.offers) == null ? void 0 : _b.find((o) => o.id === item.offerId) : void 0;
     if (!itemOffer || !OfferUtils.eligible(itemOffer, context))
       return unitPrice;
-    return unitPrice - DiscountUtils.apply(itemOffer.discount, { [currency]: unitPrice })[currency];
+    return unitPrice - _CartUtils.itemOfferUnitDiscount(itemOffer, unitPrice, currency);
   }
 };
+// How many distinct offers can compete for the same cart before the exact search is given up on.
+// 12 leaves 4096 states per line, which is nothing, and no real storefront has a dozen item offers
+// eligible against one cart at once.
+_CartUtils.searchableOffers = 12;
+var CartUtils = _CartUtils;
 
 // src/utils/image.ts
 var imageWidths = [16, 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, 1024, 1536, 2048];
@@ -2252,6 +2519,7 @@ var MoonbaseClient = class {
   SubscriptionStatus,
   TokenStore,
   imageWidths,
+  isLocalStorageAvailable,
   isPromotionDisplay,
   isTransformableImageUrl,
   maxImageDimension,