@pcreative/commerce-contract 1.0.0 → 1.3.0

package/src/adapters/api.js

@@ -1,86 +1,26 @@
-/**
- * Adaptador HTTP del contrato de datos.
- *
- * Habla con la API de tienda por `fetch` a pelo, sin SDK. No es purismo: un SDK
- * trae su propio manejo de sesión y presupone un entorno de navegador, y eso es
- * justo lo que impedía que un tema Astro, un runtime edge o una app nativa
- * usaran el mismo código. `fetch` está en todos.
- *
- *   import { createCommerce } from "@pcreative/commerce-contract/api"
- *   const commerce = createCommerce({
- *     baseUrl: process.env.COMMERCE_URL,
- *     publishableKey: process.env.COMMERCE_KEY,
- *   })
- */
 import { money } from "../index.js"
 
-const PRODUCT_FIELDS = [
-  "id", "title", "subtitle", "handle", "description", "thumbnail", "metadata",
-  "*images", "*categories", "*tags", "*variants", "*variants.calculated_price",
-  "+variants.inventory_quantity", "variants.options.value", "variants.options.option.title",
-  // Marketplace: quién vende el producto. Con `+` porque no es un campo de
-  // serie del catálogo — sale de un enlace entre módulos. Si la instalación no
-  // tiene marketplace, sencillamente no viene nada y `seller` queda vacío.
-  "+vendedor.id", "+vendedor.nombre", "+vendedor.slug",
-].join(",")
-
-const CART_FIELDS =
-  "*items,*items.variant,*items.product,*region,*shipping_address,*billing_address,*shipping_methods,*promotions,*payment_collection,*payment_collection.payment_sessions"
+const ORDEN_DEL_CONTRATO = {
+  newest: "novedades",
+  price_asc: "precio_asc",
+  price_desc: "precio_desc",
+}
 
 export function createCommerce({
   baseUrl,
-  /**
-   * Usar el catálogo PROPIO (`/tienda/*`) en vez del del motor (`/store/*`).
-   *
-   * ── 🔴 POR QUÉ AHORA VIENE ENCENDIDO ────────────────────────────────────
-   *
-   * Venía APAGADO, y era el mismo fallo que ya se arregló en el panel el
-   * 2026-08-18 sin arreglarlo aquí. Aquel día `npm start` pasó a levantar el
-   * servidor propio, que sirve `/tienda/*` y NO sirve `/store/*`.
-   *
-   * Con el interruptor apagado por defecto, cualquier tema recién hecho pedía
-   * el catálogo al motor, recibía un 404 y salía con la tienda VACÍA. Y no
-   * daba un error: pintaba la portada entera, bien maquetada, sin un solo
-   * producto. Se descubrió probando un tema antes de publicarlo.
-   *
-   * Un valor por defecto que solo funciona si alguien se acuerda de cambiarlo
-   * no es un valor por defecto.
-   *
-   * Se pone a `false` a propósito para volver al motor, y va emparejado con
-   * `npm run start:motor` en el backend. Uno sin el otro es media vuelta
-   * atrás, que es peor que ninguna.
-   */
-  catalogoPropio = true,
   publishableKey,
-  /** Código de país de la región por defecto, p.ej. "es". */
   countryCode,
-  /**
-   * Idioma en el que se quiere el contenido, p.ej. "en-US".
-   *
-   * Va en una cabecera y no en cada llamada a propósito: el idioma es del
-   * VISITANTE, no de la consulta. Si hubiera que pasarlo función por función,
-   * bastaría con que un tema se olvidara en una sola pantalla para que esa
-   * página saliera en otro idioma — y ese fallo es de los que no se ven hasta
-   * que lo dice un cliente.
-   *
-   * Lo que no esté traducido vuelve en el idioma original, así que poner un
-   * idioma nunca deja la tienda vacía.
-   */
   locale,
-  /** `fetch` alternativo (para tests o para inyectar caché del framework). */
   fetch: fetchImpl,
-  /** Opciones extra por petición: `next: { revalidate }` en Next, `cache` en el edge… */
   requestInit = {},
 } = {}) {
   if (!baseUrl) throw new Error("createCommerce: falta baseUrl")
   const f = fetchImpl ?? globalThis.fetch
   const raiz = String(baseUrl).replace(/\/$/, "")
 
-  let regionPromesa = null
-
   async function api(ruta, { method = "GET", body, token, ...extra } = {}) {
     const cabeceras = { accept: "application/json", ...(extra.headers ?? {}) }
-    if (publishableKey) cabeceras["x-publishable-api-key"] = publishableKey
+    if (publishableKey) cabeceras["x-pcc-clave"] = publishableKey
     if (locale) cabeceras["x-pcc-locale"] = locale
     if (body !== undefined) cabeceras["content-type"] = "application/json"
     if (token) cabeceras.authorization = `Bearer ${token}`
@@ -98,22 +38,20 @@ export function createCommerce({
       try {
         detalle = (await res.json())?.message ?? ""
       } catch {
-        /* respuesta sin JSON */
+        detalle = ""
       }
-      // El código HTTP viaja en el error: un 404 de producto no es lo mismo que
-      // un 401 por clave publicable mal puesta, y el tema debe poder distinguirlo.
       const err = new Error(`${method} ${ruta} → ${res.status}${detalle ? `: ${detalle}` : ""}`)
       err.status = res.status
+      err.detalle = detalle
       throw err
     }
     return res.status === 204 ? null : res.json()
   }
 
-  /** La región fija moneda e impuestos. Se resuelve una vez y se reutiliza. */
+  let regionPromesa = null
+
   function region() {
-    // Con el catálogo propio, las regiones también salen de nuestras rutas: si
-    // no, la tienda leería la moneda del motor y los precios del nuestro.
-    regionPromesa ??= api(catalogoPropio ? "/tienda/regiones" : "/store/regions")
+    regionPromesa ??= api("/tienda/regiones")
       .then(({ regions = [] }) => {
         if (countryCode) {
           const r = regions.find((x) => (x.countries ?? []).some((c) => c.iso_2 === countryCode.toLowerCase()))
@@ -125,73 +63,7 @@ export function createCommerce({
     return regionPromesa
   }
 
-  // ── Mapeo ───────────────────────────────────────────────────────────────
-
-  const monedaDe = (v, fallback) =>
-    (v?.calculated_price?.currency_code ?? fallback ?? "eur").toLowerCase()
-
-  function mapVariant(v, fallbackCurrency) {
-    const cp = v?.calculated_price ?? {}
-    const precio = money(cp.calculated_amount, monedaDe(v, fallbackCurrency), true)
-    const original = cp.original_amount
-    return {
-      id: v.id,
-      title: v.title ?? "",
-      sku: v.sku ?? undefined,
-      barcode: v.barcode ?? undefined,
-      price: precio,
-      compareAt:
-        original != null && original > (cp.calculated_amount ?? 0)
-          ? money(original, precio.currency, true)
-          : null,
-      // `inventory_quantity` solo viene si la variante gestiona inventario;
-      // si no, no hay número que enseñar y `null` es la respuesta honesta.
-      stock: v.manage_inventory === false ? null : v.inventory_quantity ?? null,
-      available:
-        v.manage_inventory === false ||
-        v.allow_backorder === true ||
-        (v.inventory_quantity ?? 0) > 0,
-      options: (v.options ?? []).map((o) => ({
-        name: o.option?.title ?? "",
-        value: o.value ?? "",
-      })),
-      weight: v.weight ?? null,
-      image: null,
-    }
-  }
-
-  function mapProduct(p, fallbackCurrency) {
-    const variants = (p.variants ?? []).map((v) => mapVariant(v, fallbackCurrency))
-    const conPrecio = variants.filter((v) => v.price.amount > 0)
-    const minimo = conPrecio.length
-      ? conPrecio.reduce((a, b) => (b.price.amount < a.price.amount ? b : a))
-      : variants[0]
-
-    return {
-      id: p.id,
-      handle: p.handle,
-      title: p.title,
-      subtitle: p.subtitle ?? null,
-      description: p.description ?? null,
-      brand: p.metadata?.brand ?? p.metadata?.marca ?? null,
-      // El enlace puede llegar como objeto o como lista de uno, según por dónde
-      // se pida. Se normaliza aquí para que el tema no tenga que saberlo.
-      seller: (() => {
-        const v = Array.isArray(p.vendedor) ? p.vendedor[0] : p.vendedor
-        return v?.id ? { id: v.id, name: v.nombre, slug: v.slug } : null
-      })(),
-      images: (p.images ?? []).map((i) => ({ url: i.url, alt: p.title })),
-      thumbnail: p.thumbnail ?? p.images?.[0]?.url ?? null,
-      price: minimo?.price ?? money(0, fallbackCurrency ?? "eur", true),
-      variants,
-      categories: (p.categories ?? []).map((c) => ({ id: c.id, handle: c.handle, name: c.name })),
-      tags: (p.tags ?? []).map((t) => t.value ?? t.name).filter(Boolean),
-      rating: null,
-      reviewCount: 0,
-      available: variants.some((v) => v.available),
-      metadata: p.metadata ?? {},
-    }
-  }
+  const monedaDeLaTienda = async () => String((await region())?.currency_code ?? "eur").toLowerCase()
 
   function mapCategory(c) {
     return {
@@ -205,30 +77,18 @@ export function createCommerce({
     }
   }
 
-  /**
-   * Del producto que devuelve NUESTRO catálogo al del contrato.
-   *
-   * Viene casi con la forma correcta a propósito: el catálogo propio se
-   * escribió para hablar el contrato, no el idioma del motor.
-   */
-  function mapProductoPropio(p) {
+  function mapProducto(p) {
     return {
       id: p.id,
       handle: p.handle,
       title: p.title,
       subtitle: p.subtitle ?? null,
       description: p.description ?? null,
-      // El `alt` se pone aquí, como en el camino del motor: una imagen sin
-      // texto alternativo es una ficha que no se puede leer con un lector de
-      // pantalla y que el buscador no entiende.
       images: (p.images ?? []).map((i) => ({ url: i.url, alt: i.alt ?? p.title })),
-      thumbnail: p.thumbnail ?? null,
+      thumbnail: p.thumbnail ?? p.images?.[0]?.url ?? null,
       price: p.price,
-      // Los cuatro que faltaban. No son adorno: la marca y las etiquetas las
-      // pinta la ficha, y `reviewCount` decide si sale el bloque de reseñas.
-      // Al no venir, un tema los leía como `undefined` y dejaba huecos sin
-      // dar ningún error.
       brand: p.brand ?? p.metadata?.brand ?? p.metadata?.marca ?? null,
+      seller: p.seller ?? null,
       tags: p.tags ?? [],
       rating: p.rating ?? null,
       reviewCount: p.reviewCount ?? 0,
@@ -239,109 +99,40 @@ export function createCommerce({
         barcode: v.barcode ?? undefined,
         price: v.price,
         compareAt: v.compareAt ?? null,
-        // `null` = esa variante no lleva la cuenta unidad a unidad. NO es cero:
-        // decir cero sería afirmar que no queda, y el tema lo pintaría agotado.
         stock: v.stock ?? null,
         available: v.available,
         options: v.options ?? [],
+        weight: v.weight ?? null,
+        image: v.image ?? null,
+        images: v.images ?? [],
+        tiers: v.tiers ?? [],
+        digital: Boolean(v.digital),
+        requiresShipping: v.requiresShipping ?? !v.digital,
+        bundle: v.bundle ?? null,
+        bundleGroups: v.bundleGroups ?? null,
+        measure: v.measure ?? null,
+        unitPrice: v.unitPrice ?? null,
       })),
       categories: p.categories ?? [],
+      quantityRules: p.quantityRules ?? null,
+      customization: p.customization ?? [],
       available: p.available,
-      metadata: p.metadata,
-    }
-  }
-
-  function mapLineItem(i, currency) {
-    return {
-      id: i.id,
-      productId: i.product_id ?? i.product?.id ?? "",
-      variantId: i.variant_id ?? i.variant?.id ?? "",
-      handle: i.product?.handle ?? i.product_handle ?? undefined,
-      title: i.product_title ?? i.title ?? "",
-      variantTitle: i.variant_title ?? i.variant?.title ?? undefined,
-      thumbnail: i.thumbnail ?? null,
-      quantity: i.quantity ?? 0,
-      unitPrice: money(i.unit_price, currency, true),
-      total: money(i.total ?? (i.unit_price ?? 0) * (i.quantity ?? 0), currency, true),
-      // Un CARGO, no mercancía: el recargo por forma de pago, por ejemplo. No
-      // tiene variante y no se envía. El tema lo necesita para no contarlo dos
-      // veces cuando además lo enseña por separado.
-      isFee: i.requires_shipping === false && !(i.variant_id ?? i.variant?.id),
-    }
-  }
-
-  function mapCart(c) {
-    if (!c) return null
-    const currency = (c.currency_code ?? c.region?.currency_code ?? "eur").toLowerCase()
-    const items = (c.items ?? []).map((i) => mapLineItem(i, currency))
-    return {
-      id: c.id,
-      items,
-      subtotal: money(c.item_subtotal ?? c.subtotal, currency, true),
-      shipping: money(c.shipping_total, currency, true),
-      discount: money(c.discount_total, currency, true),
-      tax: money(c.tax_total, currency, true),
-      total: money(c.total, currency, true),
-      itemCount: items.reduce((n, i) => n + i.quantity, 0),
-      email: c.email ?? null,
-      shippingAddress: mapAddress(c.shipping_address),
-      billingAddress: mapAddress(c.billing_address),
-      shippingMethods: (c.shipping_methods ?? []).map((m) => ({
-        id: m.shipping_option_id ?? m.id,
-        name: m.name ?? "",
-        price: money(m.amount, currency, true),
-      })),
-      regionId: c.region_id ?? c.region?.id,
-      promoCodes: (c.promotions ?? []).map((p) => p.code).filter(Boolean),
-      pago: siguientePago(c),
-    }
-  }
-
-  /**
-   * Cómo tiene que seguir el comprador para pagar.
-   *
-   * Las pasarelas se reparten en dos familias: unas mandan al comprador a su
-   * página y otras le hacen confirmar en el navegador con un secreto. Sin esto
-   * el tema no puede hacer ninguna de las dos, y el comprador se queda mirando
-   * un botón que no lleva a ningún sitio.
-   *
-   * El dato lo pone el proveedor de pago del backend en la sesión. Los métodos
-   * sin pasarela —transferencia, contrarreembolso— no ponen nada, y entonces
-   * pagar es simplemente confirmar el pedido.
-   */
-  function siguientePago(c) {
-    const sesiones = c?.payment_collection?.payment_sessions ?? []
-    // La última pendiente: si alguien cambia de método, la anterior queda ahí
-    // y usarla mandaría a pagar por una pasarela que ya descartó.
-    const sesion = [...sesiones].reverse().find((s) => s.status === "pending" || s.status === "requires_more")
-    const paso = sesion?.data?.siguiente
-    if (!paso || typeof paso !== "object" || !paso.tipo) return null
-    if (paso.tipo === "redirigir" && typeof paso.url === "string") {
-      return { tipo: "redirigir", url: paso.url, proveedor: sesion.provider_id }
-    }
-    if (paso.tipo === "confirmar_en_cliente") {
-      return {
-        tipo: "confirmar_en_cliente",
-        pasarela: String(paso.pasarela ?? ""),
-        datos: paso.datos ?? {},
-        proveedor: sesion.provider_id,
-      }
+      metadata: p.metadata ?? {},
     }
-    return null
   }
 
   function mapAddress(a) {
     if (!a) return null
     return {
-      firstName: a.first_name ?? undefined,
-      lastName: a.last_name ?? undefined,
+      firstName: a.first_name ?? a.firstName ?? undefined,
+      lastName: a.last_name ?? a.lastName ?? undefined,
       company: a.company ?? undefined,
-      address1: a.address_1 ?? undefined,
-      address2: a.address_2 ?? undefined,
+      address1: a.address_1 ?? a.address1 ?? undefined,
+      address2: a.address_2 ?? a.address2 ?? undefined,
       city: a.city ?? undefined,
       province: a.province ?? undefined,
-      postalCode: a.postal_code ?? undefined,
-      countryCode: a.country_code ?? undefined,
+      postalCode: a.postal_code ?? a.postalCode ?? undefined,
+      countryCode: a.country_code ?? a.countryCode ?? undefined,
       phone: a.phone ?? undefined,
     }
   }
@@ -359,173 +150,96 @@ export function createCommerce({
     phone: a.phone,
   })
 
-  function mapOrder(o) {
-    const currency = (o.currency_code ?? "eur").toLowerCase()
+  function mapCart(c) {
+    if (!c || c.completedAt) return null
+    const items = (c.items ?? []).map((l) => ({
+      id: l.id,
+      productId: l.productId ?? "",
+      variantId: l.variantId ?? "",
+      handle: l.handle ?? undefined,
+      title: l.title ?? "",
+      variantTitle: l.variantTitle ?? undefined,
+      thumbnail: l.thumbnail ?? null,
+      quantity: l.quantity ?? 0,
+      unitPrice: l.unitPrice,
+      total: l.total,
+      isFee: !l.variantId,
+      customization: l.customization ?? null,
+      personalized: Boolean(l.personalized),
+      digital: Boolean(l.digital),
+      bundle: l.bundle ?? null,
+      quantityRule: l.quantityRule ?? null,
+      tier: l.tier ?? null,
+      nextTier: l.nextTier ?? null,
+      problem: l.problem ?? null,
+    }))
     return {
-      id: o.id,
-      displayId: o.display_id,
-      email: o.email,
-      status: o.status ?? "pending",
-      items: (o.items ?? []).map((i) => mapLineItem(i, currency)),
-      subtotal: money(o.item_subtotal ?? o.subtotal, currency, true),
-      shipping: money(o.shipping_total, currency, true),
-      discount: money(o.discount_total, currency, true),
-      tax: money(o.tax_total, currency, true),
-      total: money(o.total, currency, true),
-      shippingAddress: mapAddress(o.shipping_address),
-      createdAt: o.created_at,
+      id: c.id,
+      items,
+      subtotal: c.subtotal,
+      shipping: c.shipping,
+      discount: c.discount,
+      tax: c.tax,
+      total: c.total,
+      itemCount: c.itemCount ?? items.reduce((n, i) => n + i.quantity, 0),
+      email: c.email ?? null,
+      shippingAddress: mapAddress(c.shippingAddress),
+      billingAddress: mapAddress(c.billingAddress),
+      shippingMethods: c.shippingMethods ?? [],
+      regionId: c.regionId,
+      promoCodes: c.promoCodes ?? [],
+      hasDigital: Boolean(c.hasDigital),
+      digitalConsent: c.digitalConsent ?? null,
+      pago: c.pago ?? null,
+      vatNumber: c.vatNumber ?? null,
+      taxExempt: c.taxExempt ?? null,
     }
   }
 
-  // ── Catálogo ────────────────────────────────────────────────────────────
-
   async function listProducts(params = {}) {
-    if (catalogoPropio) {
-      const q = new URLSearchParams()
-      if (params.limit) q.set("limite", String(params.limit))
-      if (params.offset) q.set("desde", String(params.offset))
-      if (params.categoryId) q.set("categoria", params.categoryId)
-      // 🔴 EL TÉRMINO DE BÚSQUEDA. Sin esta línea `search()` devolvía el
-      // CATÁLOGO ENTERO para cualquier cosa que se escribiera: el buscador
-      // parecía funcionar —salían productos— y no eran los buscados. No daba
-      // ningún error; simplemente el buscador no buscaba.
-      if (params.q) q.set("q", String(params.q))
-      const r = await api(`/tienda/productos?${q}`)
-      return {
-        items: (r.productos ?? []).map(mapProductoPropio),
-        count: r.total ?? 0,
-        limit: params.limit ?? 24,
-        offset: params.offset ?? 0,
-      }
-    }
-    const r = await region()
     const limit = params.limit ?? 24
     const offset = params.offset ?? 0
-
-    let categoryId = params.categoryId
-    if (!categoryId && params.category) {
-      const c = await getCategoryRaw(params.category)
-      if (!c) return { items: [], count: 0, limit, offset }
-      categoryId = c.id
-    }
-
-    const qs = new URLSearchParams({ limit: String(limit), offset: String(offset), fields: PRODUCT_FIELDS })
-    if (r?.id) qs.set("region_id", r.id)
-    if (params.q) qs.set("q", params.q)
-    if (categoryId) qs.append("category_id[]", categoryId)
-    for (const id of params.ids ?? []) qs.append("id[]", id)
-    if (params.sort === "newest") qs.set("order", "-created_at")
-
-    const { products = [], count = 0 } = await api(`/store/products?${qs}`)
-    let items = products.map((p) => mapProduct(p, r?.currency_code))
-
-    // Ordenar por precio en el cliente sería mentir: solo ordenaría la página
-    // actual. Se delega en el endpoint del backend, y si no está, se avisa.
-    if (params.sort === "price_asc" || params.sort === "price_desc") {
-      const ordenados = await idsPorPrecio({ ...params, limit, offset, categoryId, region: r })
-      // Se exige la forma esperada, no solo que la respuesta no sea nula: un
-      // proxy mal configurado puede contestar 200 con cualquier otra cosa.
-      if (Array.isArray(ordenados?.ids)) {
-        const porId = new Map(items.map((p) => [p.id, p]))
-        const faltantes = ordenados.ids.filter((id) => !porId.has(id))
-        if (faltantes.length) {
-          for (const p of await getProductsByIds(faltantes)) porId.set(p.id, p)
-        }
-        items = ordenados.ids.map((id) => porId.get(id)).filter(Boolean)
-        return { items, count: ordenados.count, limit, offset }
-      }
-    }
-
-    return { items, count, limit, offset }
-  }
-
-  /**
-   * La Store API no sabe ordenar por precio (los precios viven en otro módulo y
-   * `order=variants.calculated_price` devuelve 500). El backend expone
-   * `/tienda/products-by-price`; si no está, se devuelve null y el llamador se
-   * queda con el orden por defecto en vez de romper.
-   */
-  async function idsPorPrecio({ q, categoryId, sort, limit, offset, region: r }) {
-    const qs = new URLSearchParams({
-      limit: String(limit),
-      offset: String(offset),
-      order: sort === "price_desc" ? "desc" : "asc",
-    })
-    if (q) qs.set("q", q)
-    if (categoryId) qs.set("category_id", categoryId)
-    if (r?.currency_code) qs.set("currency_code", r.currency_code)
-    try {
-      return await api(`/tienda/products-by-price?${qs}`)
-    } catch {
-      return null
-    }
+    const qs = new URLSearchParams({ limite: String(limit), desde: String(offset), moneda: await monedaDeLaTienda() })
+    if (params.q) qs.set("q", String(params.q))
+    if (params.category) qs.set("categoria_handle", params.category)
+    if (params.categoryId) qs.set("categoria", params.categoryId)
+    if (params.ids?.length) qs.set("ids", params.ids.join(","))
+    if (ORDEN_DEL_CONTRATO[params.sort]) qs.set("orden", ORDEN_DEL_CONTRATO[params.sort])
+    const r = await api(`/tienda/productos?${qs}`)
+    return { items: (r.productos ?? []).map(mapProducto), count: r.total ?? 0, limit, offset }
   }
 
   async function getProduct(handle) {
-    if (catalogoPropio) {
-      try {
-        const r = await api(`/tienda/productos/${encodeURIComponent(handle)}`)
-        return r.producto ? mapProductoPropio(r.producto) : null
-      } catch (e) {
-        // Un 404 aquí es «no existe», no un fallo: el escaparate lo trata como
-        // página no encontrada, no como tienda caída.
-        if (e?.status === 404) return null
-        throw e
-      }
+    try {
+      const r = await api(`/tienda/productos/${encodeURIComponent(handle)}`)
+      return r.producto ? mapProducto(r.producto) : null
+    } catch (e) {
+      if (e?.status === 404) return null
+      throw e
     }
-    const r = await region()
-    const qs = new URLSearchParams({ handle, limit: "1", fields: PRODUCT_FIELDS })
-    if (r?.id) qs.set("region_id", r.id)
-    const { products = [] } = await api(`/store/products?${qs}`)
-    return products[0] ? mapProduct(products[0], r?.currency_code) : null
   }
 
   async function getProductsByIds(ids) {
     if (!ids?.length) return []
-    const r = await region()
-    const qs = new URLSearchParams({ limit: String(ids.length), fields: PRODUCT_FIELDS })
-    if (r?.id) qs.set("region_id", r.id)
-    for (const id of ids) qs.append("id[]", id)
-    const { products = [] } = await api(`/store/products?${qs}`)
-    return products.map((p) => mapProduct(p, r?.currency_code))
-  }
-
-  async function getCategoryRaw(handle) {
-    if (catalogoPropio) {
-      const { product_categories = [] } = await api(`/tienda/categorias?handle=${encodeURIComponent(handle)}`)
-      return product_categories[0] ?? null
-    }
-    const qs = new URLSearchParams({ handle, limit: "1", fields: "id,name,handle,description,parent_category_id,metadata" })
-    const { product_categories = [] } = await api(`/store/product-categories?${qs}`)
-    return product_categories[0] ?? null
+    const { items } = await listProducts({ ids, limit: ids.length })
+    const porId = new Map(items.map((p) => [p.id, p]))
+    return ids.map((id) => porId.get(id)).filter(Boolean)
   }
 
   async function listCategories() {
-    if (catalogoPropio) {
-      const { product_categories = [] } = await api("/tienda/categorias")
-      // 🔴 Solo las de primer nivel: vienen planas Y anidadas a la vez, así que
-      // devolverlas todas duplicaría cada hija dentro y fuera de su madre, y un
-      // menú saldría con las subcategorías repetidas al final.
-      return product_categories.filter((c) => !c.parent_category_id).map(mapCategory)
-    }
-    const qs = new URLSearchParams({
-      limit: "200",
-      fields: "id,name,handle,description,parent_category_id,metadata,*category_children",
-    })
-    const { product_categories = [] } = await api(`/store/product-categories?${qs}`)
-    return product_categories.map(mapCategory)
+    const { product_categories = [] } = await api("/tienda/categorias")
+    return product_categories.filter((c) => !c.parent_category_id).map(mapCategory)
   }
 
   async function getCategory(handle) {
-    const c = await getCategoryRaw(handle)
-    return c ? mapCategory(c) : null
+    const { product_categories = [] } = await api(`/tienda/categorias?handle=${encodeURIComponent(handle)}`)
+    return product_categories[0] ? mapCategory(product_categories[0]) : null
   }
 
-  /** Pedido por id, para la página de confirmación. */
   async function getOrder(id) {
     try {
-      const { order } = await api(`/store/orders/${id}`)
-      return mapOrder(order)
+      const { order } = await api(`/tienda/pedidos/${encodeURIComponent(id)}`)
+      return order ?? null
     } catch (e) {
       if (e.status === 404 || e.status === 401) return null
       throw e
@@ -537,112 +251,133 @@ export function createCommerce({
     return items
   }
 
-  // ── Carrito ─────────────────────────────────────────────────────────────
+  const rutaCarrito = (cartId, resto = "") => `/tienda/carritos/${encodeURIComponent(cartId)}${resto}`
 
   const getCart = async (id) => {
     try {
-      const { cart } = await api(`/store/carts/${id}?fields=${encodeURIComponent(CART_FIELDS)}`)
+      const { cart } = await api(rutaCarrito(id))
       return mapCart(cart)
     } catch (e) {
-      // Un carrito caducado o completado es un caso normal, no un fallo: el
-      // tema debe crear uno nuevo, no enseñar una pantalla de error.
       if (e.status === 404) return null
       throw e
     }
   }
 
+  const subirFicheroCliente = async (archivo) => {
+    const cuerpo = new FormData()
+    cuerpo.append("fichero", archivo, archivo.name)
+    const r = await f(`${raiz}/tienda/personalizacion/ficheros`, {
+      method: "POST",
+      headers: publishableKey ? { "x-pcc-clave": publishableKey } : {},
+      body: cuerpo,
+    })
+    const datos = await r.json().catch(() => ({}))
+    if (!r.ok) throw new Error(datos?.message || "No se pudo subir el fichero.")
+    return datos.fichero
+  }
+
   const cart = {
     get: getCart,
     async create() {
       const r = await region()
-      const { cart } = await api("/store/carts", { method: "POST", body: r?.id ? { region_id: r.id } : {} })
-      return mapCart(cart)
+      const { cart: c } = await api("/tienda/carritos", {
+        method: "POST",
+        body: r?.id ? { region_id: r.id, moneda: r.currency_code } : {},
+      })
+      return mapCart(c)
     },
-    async addItem(cartId, variantId, quantity) {
-      const { cart } = await api(`/store/carts/${cartId}/line-items`, {
+    async addItem(cartId, variantId, quantity, personalizacion, pack) {
+      const { cart: c } = await api(rutaCarrito(cartId, "/lineas"), {
         method: "POST",
-        body: { variant_id: variantId, quantity },
+        body: {
+          variant_id: variantId,
+          quantity,
+          ...(personalizacion ? { personalizacion } : {}),
+          ...(pack ? { pack } : {}),
+        },
       })
-      return mapCart(cart)
+      return mapCart(c)
+    },
+    async consentirDigital(cartId, aceptado) {
+      const { cart: c } = await api(rutaCarrito(cartId, "/consentimiento-digital"), {
+        method: "POST",
+        body: { aceptado },
+      })
+      return mapCart(c)
     },
     async updateItem(cartId, lineId, quantity) {
       if (quantity <= 0) return cart.removeItem(cartId, lineId)
-      const { cart: c } = await api(`/store/carts/${cartId}/line-items/${lineId}`, {
+      const { cart: c } = await api(rutaCarrito(cartId, `/lineas/${encodeURIComponent(lineId)}`), {
         method: "POST",
         body: { quantity },
       })
       return mapCart(c)
     },
     async removeItem(cartId, lineId) {
-      await api(`/store/carts/${cartId}/line-items/${lineId}`, { method: "DELETE" })
-      return getCart(cartId)
+      const { cart: c } = await api(rutaCarrito(cartId, `/lineas/${encodeURIComponent(lineId)}`), { method: "DELETE" })
+      return mapCart(c)
     },
     async applyPromo(cartId, code) {
-      const actual = await getCart(cartId)
-      const { cart } = await api(`/store/carts/${cartId}`, {
-        method: "POST",
-        body: { promo_codes: [...new Set([...(actual?.promoCodes ?? []), code])] },
-      })
-      return mapCart(cart)
+      const r = await api(rutaCarrito(cartId, "/cupon"), { method: "POST", body: { codigo: code } })
+      if (!r.aplicado) {
+        const err = new Error(r.motivo ?? "Ese código no se puede usar.")
+        err.status = 400
+        err.detalle = r.motivo ?? ""
+        throw err
+      }
+      return mapCart(r.cart)
     },
     async removePromo(cartId, code) {
-      const actual = await getCart(cartId)
-      const { cart } = await api(`/store/carts/${cartId}`, {
-        method: "POST",
-        body: { promo_codes: (actual?.promoCodes ?? []).filter((c) => c !== code) },
-      })
-      return mapCart(cart)
+      const { cart: c } = await api(rutaCarrito(cartId, `/cupon/${encodeURIComponent(code)}`), { method: "DELETE" })
+      return mapCart(c)
     },
   }
 
-  // ── Checkout ────────────────────────────────────────────────────────────
-
   const checkout = {
+    async listCountries() {
+      const { regions = [] } = await api("/tienda/regiones")
+      return [...new Set(regions.flatMap((r) => (r.countries ?? []).map((c) => String(c.iso_2).toLowerCase())))].filter(Boolean)
+    },
+    async setVatNumber(cartId, vatNumber) {
+      const { cart: c } = await api(rutaCarrito(cartId, "/nif-iva"), {
+        method: "POST",
+        body: { vat_number: vatNumber ?? null },
+      })
+      return mapCart(c)
+    },
     async setEmail(cartId, email) {
-      const { cart } = await api(`/store/carts/${cartId}`, { method: "POST", body: { email } })
-      return mapCart(cart)
+      const { cart: c } = await api(rutaCarrito(cartId, "/datos"), { method: "POST", body: { email } })
+      return mapCart(c)
     },
     async setAddresses(cartId, shipping, billing) {
-      const { cart } = await api(`/store/carts/${cartId}`, {
+      const { cart: c } = await api(rutaCarrito(cartId, "/datos"), {
         method: "POST",
         body: {
           shipping_address: aDireccionApi(shipping),
           billing_address: aDireccionApi(billing ?? shipping),
         },
       })
-      return mapCart(cart)
+      return mapCart(c)
     },
     async listShippingOptions(cartId) {
-      const { shipping_options = [] } = await api(`/store/shipping-options?cart_id=${cartId}`)
-      return shipping_options.map((o) => ({
+      const { moneda = "eur", opciones = [] } = await api(rutaCarrito(cartId, "/envios"))
+      return opciones.map((o) => ({
         id: o.id,
-        name: o.name,
-        price: money(o.amount ?? o.calculated_price?.calculated_amount, o.calculated_price?.currency_code ?? "eur", true),
-        priceCalculated: o.price_type === "calculated",
-        description: o.data?.description ?? null,
+        name: o.nombre,
+        price: money(o.precio ?? 0, moneda, true),
+        priceCalculated: Boolean(o.esCalculada),
+        description: o.datos?.description ?? null,
+        deliveryTime: o.plazo ?? null,
+        pickup: Boolean(o.recogida),
       }))
     },
-    /**
-     * De cuántos sitios sale el carrito.
-     *
-     * Devuelve `null` si el backend no tiene marketplace montado: la ruta no
-     * existe y responde 404. El tema lo interpreta como «una tienda normal» y
-     * sigue con el selector de envío de siempre, sin enterarse de nada.
-     */
     async listShippingGroups(cartId) {
       try {
-        return await api(`/tienda/marketplace/envios?cart_id=${cartId}`)
+        return await api(`/tienda/marketplace/envios?cart_id=${encodeURIComponent(cartId)}`)
       } catch {
         return null
       }
     },
-    /**
-     * Los portes de todos los grupos, en UNA llamada.
-     *
-     * Mandarlos de uno en uno no vale: el segundo borra al primero.
-     * Lo impone la ruta del backend, que rechaza un conjunto incompleto en vez
-     * de cobrar de menos calladamente.
-     */
     async setShippingMethods(cartId, elecciones) {
       await api("/tienda/marketplace/envios", {
         method: "POST",
@@ -653,102 +388,118 @@ export function createCommerce({
       })
     },
     async setShippingMethod(cartId, optionId) {
-      const { cart } = await api(`/store/carts/${cartId}/shipping-methods`, {
+      const { cart: c } = await api(rutaCarrito(cartId, "/envios"), {
         method: "POST",
-        body: { option_id: optionId },
+        body: { opcion_id: optionId },
       })
-      return mapCart(cart)
+      return mapCart(c)
     },
     async listPaymentMethods(cartId) {
-      const c = await getCart(cartId)
-      const r = c?.regionId ?? (await region())?.id
-      if (!r) return []
-      const { payment_providers = [] } = await api(`/store/payment-providers?region_id=${r}`)
-      // El recargo configurado en la tienda, para poder enseñarlo junto al
-      // método. Si la ruta no existe (backend anterior), simplemente no hay.
-      let cfg = {}
-      try {
-        const r2 = await api("/payment-config")
-        cfg = r2?.methods ?? {}
-      } catch {}
-      return payment_providers.map((p) => ({
-        id: p.id,
-        provider: p.id,
-        name: cfg[p.id]?.name || p.id,
-        ...(cfg[p.id]?.surcharge ? { surcharge: Number(cfg[p.id].surcharge) } : {}),
+      const { metodos = [] } = await api(rutaCarrito(cartId, "/pagos"))
+      return metodos.map((m) => ({
+        id: m.id,
+        provider: m.provider ?? m.id,
+        name: m.name ?? m.id,
+        description: m.description ?? null,
+        instructions: m.instructions ?? null,
+        ...(m.surcharge ? { surcharge: Number(m.surcharge) } : {}),
       }))
     },
     async selectPaymentMethod(cartId, provider, datos) {
-      // El recargo de la forma de pago, ANTES de crear el cobro: el importe a
-      // cobrar sale del total del carrito. Al revés, el recargo entraría en el
-      // pedido pero no en lo que se le cobra al cliente.
-      //
-      // Si el backend no tiene la ruta (versión anterior), no hay recargos y se
-      // sigue igual que siempre.
-      try {
-        await api("/tienda/pagos/recargo", {
-          method: "POST",
-          body: { cart_id: cartId, provider_id: provider },
-        })
-      } catch {}
-
-      const { payment_collection } = await api("/store/payment-collections", {
-        method: "POST",
-        body: { cart_id: cartId },
-      })
-      await api(`/store/payment-collections/${payment_collection.id}/payment-sessions`, {
+      const { cart: c } = await api(rutaCarrito(cartId, "/pago"), {
         method: "POST",
-        // `data` lo lee el proveedor de pago del backend. Sirve para decirle
-        // cosas que solo sabe el escaparate — por ejemplo a qué RUTA debe
-        // volver el comprador, que cambia con el idioma de la página.
-        body: { provider_id: provider, ...(datos ? { data: datos } : {}) },
+        body: { proveedor: provider, ...(datos ? { datos } : {}) },
       })
-      return getCart(cartId)
+      return mapCart(c)
     },
     async complete(cartId) {
-      const r = await api(`/store/carts/${cartId}/complete`, { method: "POST" })
-      // El backend contesta con el pedido o, si algo falló al cobrar, con el carrito
-      // intacto y el motivo. Las dos son respuestas 200: el tema tiene que
-      // mirar el tipo, no el código HTTP.
-      if (r?.type === "order" && r.order) return { order: mapOrder(r.order) }
-      return { cart: mapCart(r?.cart), error: r?.error?.message ?? "No se pudo completar el pedido" }
+      try {
+        const r = await api(rutaCarrito(cartId, "/completar"), { method: "POST", body: {} })
+        const pedido = (await getOrder(r.order.id)) ?? {
+          id: r.order.id,
+          status: "pending",
+          items: [],
+          subtotal: money(0, r.order.currency_code ?? "eur", true),
+          shipping: money(0, r.order.currency_code ?? "eur", true),
+          discount: money(0, r.order.currency_code ?? "eur", true),
+          tax: money(0, r.order.currency_code ?? "eur", true),
+          total: money(r.order.total, r.order.currency_code ?? "eur", true),
+        }
+        return { order: pedido }
+      } catch (e) {
+        if (e.status !== 409 && e.status !== 400) throw e
+        return { cart: await getCart(cartId), error: e.detalle || "No se pudo completar el pedido" }
+      }
     },
   }
 
-  // ── Cuenta y contenido ──────────────────────────────────────────────────
-
   const account = {
-    async login(email, password) {
-      const r = await api("/auth/customer/emailpass", { method: "POST", body: { email, password } })
+    async login(email, password, cartId) {
+      const r = await api("/tienda/cuenta/entrar", {
+        method: "POST",
+        body: { email, password, ...(cartId ? { cart_id: cartId } : {}) },
+      })
       return { token: r.token }
     },
     async register({ email, password, firstName, lastName }) {
-      const { token } = await api("/auth/customer/emailpass/register", {
+      const r = await api("/tienda/cuenta/registrar", {
         method: "POST",
-        body: { email, password },
+        body: { email, password, first_name: firstName, last_name: lastName },
       })
-      const { customer } = await api("/store/customers", {
-        method: "POST",
-        token,
-        body: { email, first_name: firstName, last_name: lastName },
-      })
-      return { id: customer.id, email: customer.email, firstName: customer.first_name, lastName: customer.last_name }
+      return { id: r.customer_id, email, firstName: firstName ?? null, lastName: lastName ?? null }
     },
     async me(token) {
       try {
-        const { customer } = await api("/store/customers/me", { token })
-        return { id: customer.id, email: customer.email, firstName: customer.first_name, lastName: customer.last_name, phone: customer.phone }
+        const { customer } = await api("/tienda/cuenta", { token })
+        return customer
+          ? {
+              id: customer.id,
+              email: customer.email,
+              firstName: customer.first_name ?? null,
+              lastName: customer.last_name ?? null,
+              phone: customer.phone ?? null,
+            }
+          : null
       } catch (e) {
         if (e.status === 401) return null
         throw e
       }
     },
     async orders(token) {
-      const { orders = [] } = await api("/store/orders", { token })
-      return orders.map(mapOrder)
+      const { orders = [] } = await api("/tienda/cuenta/pedidos", { token })
+      return orders
+    },
+    async confirmEmail(sessionToken, token) {
+      try {
+        const r = await api("/tienda/cuenta/confirmar", { method: "POST", token: sessionToken, body: { token } })
+        return { adopted: r.pedidos_recuperados ?? 0 }
+      } catch (e) {
+        if (e.status === 400 || e.status === 401) return null
+        throw e
+      }
     },
   }
 
+  const mapPost = (p) => ({
+    id: p.id,
+    handle: p.handle,
+    title: p.title,
+    excerpt: p.excerpt ?? null,
+    content: p.content ?? p.body ?? null,
+    image: p.image ?? p.thumbnail ?? null,
+    publishedAt: p.published_at ?? p.created_at ?? null,
+    tags: p.tags ?? [],
+  })
+
+  const mapPagina = (p) => ({
+    handle: p.handle,
+    title: p.titulo ?? p.title ?? p.handle,
+    content: p.contenido ?? p.content ?? null,
+    order: p.orden ?? p.order ?? 0,
+    seoTitle: p.seo_titulo ?? p.seoTitle ?? null,
+    seoDescription: p.seo_descripcion ?? p.seoDescription ?? null,
+  })
+
   const content = {
     async listPosts(limit = 10) {
       try {
@@ -768,11 +519,9 @@ export function createCommerce({
     },
     async listPages() {
       try {
-        const { paginas = [] } = await api(`/tienda/paginas`)
+        const { paginas = [] } = await api("/tienda/paginas")
         return paginas.map(mapPagina)
       } catch {
-        // Sin páginas el pie se pinta sin enlaces, que es peor que con ellos y
-        // muchísimo mejor que una tienda que no carga.
         return []
       }
     },
@@ -781,33 +530,11 @@ export function createCommerce({
         const { pagina } = await api(`/tienda/paginas/${encodeURIComponent(handle)}`)
         return pagina ? mapPagina(pagina) : null
       } catch {
-        // Un borrador o una que no existe dan 404, y eso es «no hay página»,
-        // no un error de la tienda.
         return null
       }
     },
   }
 
-  const mapPost = (p) => ({
-    id: p.id,
-    handle: p.handle,
-    title: p.title,
-    excerpt: p.excerpt ?? null,
-    content: p.content ?? p.body ?? null,
-    image: p.image ?? p.thumbnail ?? null,
-    publishedAt: p.published_at ?? p.created_at ?? null,
-    tags: p.tags ?? [],
-  })
-
-  const mapPagina = (p) => ({
-    handle: p.handle,
-    title: p.titulo ?? p.title ?? p.handle,
-    content: p.contenido ?? p.content ?? null,
-    order: p.orden ?? p.order ?? 0,
-    seoTitle: p.seo_titulo ?? p.seoTitle ?? null,
-    seoDescription: p.seo_descripcion ?? p.seoDescription ?? null,
-  })
-
   return {
     adapter: "pcreative",
     listProducts,
@@ -817,9 +544,52 @@ export function createCommerce({
     getCategory,
     search,
     getOrder,
+    subirFichero: subirFicheroCliente,
+    async getWithdrawal(orderId) {
+      try {
+        const { desistimiento } = await api(`/tienda/pedidos/${encodeURIComponent(orderId)}/desistimiento`)
+        return desistimiento ?? null
+      } catch (e) {
+        if (e.status === 404) return null
+        throw e
+      }
+    },
+    async requestWithdrawal(orderId, datos = {}) {
+      return await api(`/tienda/pedidos/${encodeURIComponent(orderId)}/desistimiento`, { method: "POST", body: datos })
+    },
+    async getDownloads(orderId) {
+      try {
+        const { descargas } = await api(`/tienda/pedidos/${encodeURIComponent(orderId)}/descargas`)
+        return (descargas ?? []).map((d) => ({ ...d, url: d.url ? `${raiz}${d.url}` : null }))
+      } catch (e) {
+        if (e.status === 404) return []
+        throw e
+      }
+    },
     cart,
     checkout,
     account,
     content,
+    async getStore() {
+      try {
+        const { tienda, legal } = await api("/tienda/tienda")
+        if (!tienda) return null
+        return {
+          name: tienda.nombre ?? null,
+          legalName: tienda.razon_social ?? null,
+          taxId: tienda.nif ?? null,
+          address: tienda.direccion ?? null,
+          email: tienda.correo ?? null,
+          phone: tienda.telefono ?? null,
+          country: tienda.pais ?? null,
+          legal: legal ?? null,
+        }
+      } catch {
+        return null
+      }
+    },
+    async sendContact({ name, email, subject, message }) {
+      await api("/tienda/contact", { method: "POST", body: { name, email, subject, message } })
+    },
   }
 }