@asteby/storefront 0.5.0 → 0.6.0

package/dist/mock.cjs

@@ -24,6 +24,26 @@ function rankByDistance(items, origin, { radiusKm, limit, getPoint = (i) => i }
   return limit === void 0 ? out : out.slice(0, Math.max(0, limit));
 }
 
+// src/availability.ts
+function resolveAvailability(source, options = {}) {
+  const a = source.availability;
+  if (a && typeof a === "object" && typeof a.status === "string") return a;
+  const qty = typeof source.quantity_available === "number" ? source.quantity_available : null;
+  const sellable = source.available_for_sale && (qty === null || qty > 0);
+  const threshold = options.lowStockThreshold;
+  const low = sellable && qty !== null && typeof threshold === "number" && threshold > 0 && qty <= threshold;
+  const status = !sellable ? "out_of_stock" : low ? "low_stock" : "in_stock";
+  return {
+    status,
+    quantity: sellable ? qty : null,
+    max_per_order: sellable ? qty : null,
+    restock_eta: null,
+    preorder_release_at: null,
+    // Old servers have no subscription route: never offer a form that cannot work.
+    notify_available: false
+  };
+}
+
 // src/mock/seed.ts
 var MOCK_IMAGE_URL = (seed, width = 800, height = 800) => `https://picsum.photos/seed/${encodeURIComponent(seed)}/${width}/${height}`;
 var MOCK_CURRENCY = "MXN";
@@ -362,15 +382,17 @@ function buildCustomers() {
 
 // src/mock/index.ts
 var HttpError = class extends Error {
-  constructor(status, code, message, field) {
+  constructor(status, code, message, field, details) {
     super(message);
     this.status = status;
     this.code = code;
     this.field = field;
+    this.details = details;
   }
   status;
   code;
   field;
+  details;
 };
 var PUBLIC_CACHE = "public, max-age=60, stale-while-revalidate=600";
 var PRIVATE_CACHE = "private, no-store";
@@ -451,10 +473,36 @@ function createMockStorefront(options = {}) {
       sessions: /* @__PURE__ */ new Map(),
       idempotency: /* @__PURE__ */ new Map(),
       checkouts: /* @__PURE__ */ new Map(),
+      payments: /* @__PURE__ */ new Map(),
+      restock: /* @__PURE__ */ new Set(),
       seq: 0
     };
   }
+  const lowStockThreshold = options.lowStockThreshold ?? 5;
+  function syncAvailability(products) {
+    for (const p of products) {
+      for (const v of p.variants) {
+        const qty = v.quantity_available;
+        const sellable = v.available_for_sale && (qty === null || qty > 0);
+        v.available_for_sale = sellable;
+        const low = sellable && qty !== null && lowStockThreshold > 0 && qty <= lowStockThreshold;
+        v.availability = {
+          status: !sellable ? "out_of_stock" : low ? "low_stock" : "in_stock",
+          quantity: low ? qty : null,
+          max_per_order: sellable ? qty === null ? null : Math.min(qty, 10) : null,
+          restock_eta: null,
+          preorder_release_at: null,
+          notify_available: !sellable
+        };
+      }
+      p.available_for_sale = p.variants.some((v) => v.available_for_sale);
+      const rank = ["in_stock", "low_stock", "backorder", "preorder", "out_of_stock"];
+      const best = p.variants.map((v) => v.availability).sort((a, b) => rank.indexOf(a.status) - rank.indexOf(b.status))[0];
+      p.availability = best ?? resolveAvailability(p);
+    }
+  }
   let state = seed();
+  syncAvailability(state.products);
   const nextId = (prefix) => `${prefix}_${(++state.seq).toString(36)}${Math.random().toString(36).slice(2, 8)}`;
   function findVariant(variantId) {
     for (const product of state.products) {
@@ -573,7 +621,8 @@ function createMockStorefront(options = {}) {
   }
   function validateLines(lines, cart) {
     if (!Array.isArray(lines)) throw new HttpError(400, "validation", "`lines` must be an array", "lines");
-    return lines.map((raw, i) => {
+    const toCheck = [];
+    const out = lines.map((raw, i) => {
       const l = raw;
       if (typeof l.variant_id !== "string") throw new HttpError(400, "validation", "variant_id is required", `lines[${i}].variant_id`);
       const quantity = l.quantity === void 0 ? 1 : l.quantity;
@@ -582,15 +631,36 @@ function createMockStorefront(options = {}) {
       }
       const found = findVariant(l.variant_id);
       if (!found) throw new HttpError(400, "validation", `Unknown variant ${l.variant_id}`, `lines[${i}].variant_id`);
-      const already = cart?.lines.find((x) => x.variant_id === l.variant_id)?.quantity ?? 0;
-      checkStock(found.variant, already + quantity, `lines[${i}].quantity`);
+      const existing = cart?.lines.find((x) => x.variant_id === l.variant_id);
+      toCheck.push({ variant: found.variant, quantity: (existing?.quantity ?? 0) + quantity, lineId: existing?.id ?? null, field: `lines[${i}].quantity` });
       return { variant_id: l.variant_id, quantity };
     });
+    checkStock(toCheck);
+    return out;
   }
-  function checkStock(variant, quantity, field) {
-    if (!variant.available_for_sale || variant.quantity_available !== null && quantity > variant.quantity_available) {
-      throw new HttpError(409, "insufficient_stock", `Only ${variant.quantity_available ?? 0} available for ${variant.sku}`, field);
+  function visibleMax(variant) {
+    const a = variant.availability;
+    if (!a || a.status === "out_of_stock") return 0;
+    return a.status === "low_stock" ? a.quantity : null;
+  }
+  function lineProblem(variant, quantity) {
+    if (!variant.available_for_sale) return { code: "out_of_stock", max_quantity: 0 };
+    if (variant.quantity_available !== null && quantity > variant.quantity_available) {
+      return { code: "insufficient_stock", max_quantity: visibleMax(variant) };
     }
+    return null;
+  }
+  function checkStock(items) {
+    const bad = items.filter((i) => lineProblem(i.variant, i.quantity));
+    if (bad.length === 0) return;
+    const lines = bad.map((i) => ({
+      line_id: i.lineId,
+      variant_id: i.variant.id,
+      sku: i.variant.sku,
+      status: i.variant.availability?.status ?? "out_of_stock",
+      max_quantity: visibleMax(i.variant)
+    }));
+    throw new HttpError(409, "insufficient_stock", "Algunos productos ya no tienen existencias suficientes", bad[0].field, { lines });
   }
   function addLines(cart, lines) {
     for (const l of lines) {
@@ -623,6 +693,7 @@ function createMockStorefront(options = {}) {
       lines.push({
         id: l.id,
         quantity: l.quantity,
+        problem: lineProblem(variant, l.quantity),
         merchandise: {
           ...variant,
           product: { handle: product.handle, title: product.title, featured_image: product.featured_image }
@@ -661,6 +732,7 @@ function createMockStorefront(options = {}) {
         total: fromCents(total, currency),
         tax_included: true
       },
+      note: cart.note,
       updated_at: cart.updated_at
     };
   }
@@ -744,7 +816,7 @@ function createMockStorefront(options = {}) {
     const nodes = skus.flatMap((sku) => {
       for (const p of state.products) {
         const v = p.variants.find((x) => x.sku === sku);
-        if (v) return [{ sku, quantity_available: v.quantity_available }];
+        if (v) return [{ sku, quantity_available: v.quantity_available, ...v.availability ? { availability: v.availability } : {} }];
       }
       return [];
     });
@@ -758,6 +830,7 @@ function createMockStorefront(options = {}) {
       buyer: { email: null, phone: null, customer_id: null },
       shipping_address: null,
       delivery: { method: null, rate_id: null, branch_id: null },
+      note: null,
       updated_at: now()
     };
     if (body.lines !== void 0) addLines(cart, validateLines(body.lines));
@@ -781,8 +854,13 @@ function createMockStorefront(options = {}) {
       if (typeof u.quantity !== "number" || !Number.isInteger(u.quantity) || u.quantity < 0) {
         throw new HttpError(400, "validation", "quantity must be a non-negative integer", `lines[${i}].quantity`);
       }
-      if (u.quantity > 0) checkStock(findVariant(line.variant_id).variant, u.quantity, `lines[${i}].quantity`);
     });
+    checkStock(
+      updates.flatMap((u, i) => {
+        const line = cart.lines.find((l) => l.id === u.id);
+        return u.quantity > 0 ? [{ variant: findVariant(line.variant_id).variant, quantity: u.quantity, lineId: line.id, field: `lines[${i}].quantity` }] : [];
+      })
+    );
     for (const u of updates) {
       const line = cart.lines.find((l) => l.id === u.id);
       line.quantity = u.quantity;
@@ -849,6 +927,40 @@ function createMockStorefront(options = {}) {
     cart.updated_at = now();
     return { body: renderCart(cart), cache: "private" };
   });
+  route("PUT", "/carts/:id/note", "cart:write", ({ params, body }) => {
+    const cart = getCartRecord(params[0]);
+    const raw = body.note;
+    if (raw !== null && raw !== void 0 && typeof raw !== "string") throw new HttpError(400, "validation", "note must be a string or null", "note");
+    const text = typeof raw === "string" ? raw.trim() : "";
+    if (text.length > 1e3) throw new HttpError(400, "validation", "note must be at most 1000 characters", "note");
+    cart.note = text || null;
+    cart.updated_at = now();
+    return { body: renderCart(cart), cache: "private" };
+  });
+  route("GET", "/carts/:id/recommendations", "cart:write", ({ params, search }) => {
+    const cart = getCartRecord(params[0]);
+    const first = Math.min(8, Math.max(1, Number.parseInt(search.get("first") ?? "4", 10) || 4));
+    const inCart = new Set(cart.lines.map((l) => findVariant(l.variant_id)?.product.id));
+    const nodes = [];
+    for (const p of state.products) {
+      if (inCart.has(p.id)) continue;
+      const variants = p.variants.filter((v) => v.available_for_sale);
+      if (variants.length === 0) continue;
+      nodes.push({
+        product: { id: p.id, handle: p.handle, title: p.title, featured_image: p.featured_image, options: p.options, vendor: p.vendor },
+        variants,
+        default_variant_id: variants[0].id,
+        source: "similar",
+        unlocks: null
+      });
+      if (nodes.length >= first) break;
+    }
+    return { body: { nodes, promotions: null }, cache: "private" };
+  });
+  route("GET", "/promotions", "catalog:read", () => ({
+    body: { nodes: [], announcements: options.announcements ?? [] },
+    cache: "public"
+  }));
   route("POST", "/carts/:id/checkout", "checkout:write", ({ params, body, headers }) => {
     const key = headers.get("idempotency-key");
     if (key) {
@@ -865,7 +977,7 @@ function createMockStorefront(options = {}) {
     }
     if (typeof body.payment_method !== "string" || !body.payment_method) throw new HttpError(400, "validation", "payment_method is required", "payment_method");
     if (typeof body.return_url !== "string" || !body.return_url) throw new HttpError(400, "validation", "return_url is required", "return_url");
-    record.lines.forEach((l, i) => checkStock(findVariant(l.variant_id).variant, l.quantity, `lines[${i}].quantity`));
+    checkStock(record.lines.map((l, i) => ({ variant: findVariant(l.variant_id).variant, quantity: l.quantity, lineId: l.id, field: `lines[${i}].quantity` })));
     for (const l of record.lines) {
       const v = findVariant(l.variant_id).variant;
       if (v.quantity_available !== null) {
@@ -873,7 +985,7 @@ function createMockStorefront(options = {}) {
         v.available_for_sale = v.quantity_available > 0;
       }
     }
-    for (const p of state.products) p.available_for_sale = p.variants.some((v) => v.available_for_sale);
+    syncAvailability(state.products);
     const orderId = nextId("ord");
     const number = String(1001 + state.orders.length - 1);
     const customerId = cart.buyer.customer_id ?? state.customers.find((c) => c.email && c.email === cart.buyer.email)?.id ?? null;
@@ -917,6 +1029,110 @@ function createMockStorefront(options = {}) {
     if (!found) throw new HttpError(404, "not_found", "Checkout not found");
     return { body: found, cache: "private" };
   });
+  const DECLINES = {
+    tok_OTHE: "declined",
+    tok_CALL: "call_issuer",
+    tok_FUND: "insufficient_funds",
+    tok_SECU: "invalid_cvc",
+    tok_EXPI: "invalid_expiry",
+    tok_FORM: "invalid_card_data"
+  };
+  const maxPaymentAttempts = options.maxPaymentAttempts ?? 5;
+  route("GET", "/checkouts/:id/payment-config", "checkout:write", ({ params }) => {
+    const found = state.checkouts.get(params[0]);
+    if (!found) throw new HttpError(404, "not_found", "Checkout not found");
+    const st = state.payments.get(params[0]);
+    const config = {
+      provider: "mock",
+      flow: "embedded",
+      option: "card",
+      payable: found.checkout.status === "pending" && (st?.attempts ?? 0) < maxPaymentAttempts,
+      reason: null,
+      amount: found.checkout.total,
+      currency: found.checkout.total.currency_code,
+      public_key: "TEST-mock-public-key",
+      methods: ["card", "cash"],
+      options: [{ key: "card", redirect: false, max_installments: 12 }, { key: "cash", redirect: false }],
+      client: { kind: "mock", sdk_url: "https://mock.local/sdk.js", public_key: "TEST-mock-public-key" },
+      checkout: found.checkout,
+      action: st?.last?.payment.action ?? null,
+      attempts_left: maxPaymentAttempts - (st?.attempts ?? 0)
+    };
+    return { body: config, cache: "private" };
+  });
+  route("POST", "/checkouts/:id/payment", "checkout:write", ({ params, body, headers }) => {
+    const key = headers.get("idempotency-key");
+    if (!key) throw new HttpError(400, "validation", "Idempotency-Key header is required", "Idempotency-Key");
+    const id = params[0];
+    const prev = state.idempotency.get(`pay:${id}:${key}`);
+    if (prev) return { status: prev.status, body: prev.body, cache: "private" };
+    const found = state.checkouts.get(id);
+    if (!found) throw new HttpError(404, "not_found", "Checkout not found");
+    const method = body.method;
+    if (method !== "card" && method !== "cash" && method !== "bank_transfer") throw new HttpError(400, "validation", "method must be card, cash or bank_transfer", "method");
+    const data = body.provider_data;
+    if (typeof data !== "object" || data === null || Array.isArray(data)) throw new HttpError(400, "validation", "provider_data is required", "provider_data");
+    const exp = body.expected_total;
+    if (exp && exp.amount !== void 0 && toCents(exp.amount) !== toCents(found.checkout.total.amount)) {
+      throw new HttpError(422, "price_mismatch", "The total changed", "expected_total", { cost: found.checkout.total });
+    }
+    const st = state.payments.get(id) ?? { attempts: 0, last: null };
+    if (found.checkout.status === "paid" || st.last?.payment.status === "pending" || st.last?.payment.status === "requires_action") {
+      throw new HttpError(409, "conflict", "A payment is already in progress", "payment_in_progress");
+    }
+    if (found.checkout.stock_hold_expires_at && Date.parse(found.checkout.stock_hold_expires_at) < Date.now()) {
+      throw new HttpError(409, "expired", "The reservation expired");
+    }
+    if (st.attempts >= maxPaymentAttempts) throw new HttpError(429, "rate_limited", "too_many_attempts");
+    st.attempts += 1;
+    const token = typeof data.token === "string" ? data.token : "";
+    const attemptsLeft = maxPaymentAttempts - st.attempts;
+    let payment;
+    if (method !== "card") {
+      const pointId = String(data.payment_method_id ?? "oxxo");
+      payment = {
+        provider: "mock",
+        status: "requires_action",
+        action: {
+          type: "voucher",
+          voucher: {
+            payment_point: pointId,
+            reference: `${pointId.toUpperCase()}-${id.slice(-6).toUpperCase()}`,
+            voucher_url: `https://mock.local/voucher/${id}`,
+            amount: found.checkout.total.amount,
+            currency: found.checkout.total.currency_code,
+            expires_at: new Date(Date.now() + 48 * 36e5).toISOString()
+          }
+        }
+      };
+    } else if (token in DECLINES) {
+      payment = { provider: "mock", status: "failed", decline_code: DECLINES[token], retryable: true };
+    } else if (token === "tok_CONT") {
+      payment = { provider: "mock", status: "pending", action: { type: "none" } };
+    } else if (token === "tok_3DS") {
+      payment = { provider: "mock", status: "requires_action", action: { type: "challenge", challenge: { url: "https://mock.local/3ds", creq: "creq" } } };
+    } else {
+      payment = { provider: "mock", status: "paid" };
+      found.checkout.status = "paid";
+    }
+    payment.outcome = payment.status === "paid" ? "approved" : payment.status === "failed" ? "rejected" : payment.action?.type === "challenge" ? "challenge" : "pending";
+    const result = { attempt: { n: st.attempts }, payment, checkout: found.checkout, attempts_left: attemptsLeft };
+    st.last = result;
+    state.payments.set(id, st);
+    state.idempotency.set(`pay:${id}:${key}`, { status: 200, body: result });
+    return { body: result, cache: "private" };
+  });
+  route("POST", "/restock-subscriptions", "customer:write", ({ body }) => {
+    if (typeof body.sku !== "string" || !body.sku) throw new HttpError(400, "validation", "sku is required", "sku");
+    if (typeof body.locale !== "string" || !body.locale) throw new HttpError(400, "validation", "locale is required", "locale");
+    if (body.consent !== true) throw new HttpError(422, "invalid_state", "consent must be true", "consent");
+    const contact = typeof body.email === "string" && body.email ? body.email.toLowerCase() : typeof body.phone === "string" ? body.phone : "";
+    if (!contact) throw new HttpError(400, "validation", "email or phone is required", "email");
+    const known = state.products.some((p) => p.variants.some((v) => v.sku === body.sku));
+    if (!known) throw new HttpError(404, "not_found", `SKU ${body.sku} not found`, "sku");
+    state.restock.add(`${contact}|${body.sku}`);
+    return { status: 202, body: { status: "pending" }, cache: "private" };
+  });
   route("POST", "/customer/otp", "customer:write", ({ body }) => {
     state.otps.set(identifierOf(body), otpCode);
     return { status: 204 };
@@ -1034,7 +1250,11 @@ function createMockStorefront(options = {}) {
     });
   }
   function errorResponse(err) {
-    return json(err.status, { error: { code: err.code, message: err.message, ...err.field ? { field: err.field } : {} } }, { "Cache-Control": PRIVATE_CACHE });
+    return json(
+      err.status,
+      { error: { code: err.code, message: err.message, ...err.field ? { field: err.field } : {}, ...err.details !== void 0 ? { details: err.details } : {} } },
+      { "Cache-Control": PRIVATE_CACHE }
+    );
   }
   async function handle(request) {
     const url = new URL(request.url);
@@ -1098,6 +1318,7 @@ function createMockStorefront(options = {}) {
     /** Restores the seed data and clears carts, sessions and orders. */
     reset() {
       state = seed();
+      syncAvailability(state.products);
     },
     /** OTP code accepted by `/customer/session`. */
     otpCode