@fayz-ai/shop 0.9.0 → 0.10.0

package/src/mock-provider.ts

@@ -1,480 +0,0 @@
-import type { ShopProvider } from './provider'
-import type {
-  Product, ProductImage, Category, Order, ShopCustomer, Discount, ProductEnquiry,
-  CreateProductInput, UpdateProductInput, ListProductsOptions,
-  CreateProductEnquiryInput, ListProductEnquiriesOptions,
-  CreateCategoryInput, UpdateCategoryInput,
-  CreateOrderInput, UpdateOrderInput, ListOrdersOptions, PlaceOrderInput,
-  CreateCustomerInput, UpdateCustomerInput, ListCustomersOptions, ResolveCustomerInput,
-  CreateDiscountInput, UpdateDiscountInput, ListDiscountsOptions,
-  SalesChannel, CreateSalesChannelInput, UpdateSalesChannelInput,
-} from './types'
-import { MOCK_PRODUCTS, MOCK_CATEGORIES, MOCK_DISCOUNTS } from './mock-catalog'
-
-function uid() { return Math.random().toString(36).slice(2) }
-function now() { return new Date().toISOString() }
-
-// Orders/customers persist to localStorage so "my purchases" survives a page
-// reload. Products/categories/discounts always reseed from the catalog —
-// the storefront sees a deterministic catalog on every load.
-const ORDERS_KEY = 'fayz.shop.mock.orders.v1'
-const CUSTOMERS_KEY = 'fayz.shop.mock.customers.v1'
-const ENQUIRIES_KEY = 'fayz.shop.mock.enquiries.v1'
-const CHANNELS_KEY = 'fayz.shop.mock.channels.v1'
-
-const DEFAULT_CHANNELS: SalesChannel[] = [
-  { id: 'online-store', tenantId: 'mock', kind: 'online_store', label: 'Loja Online', url: null, enabled: true, position: 0, createdAt: now(), updatedAt: now() },
-]
-
-function loadStored<T>(key: string): T[] {
-  try {
-    if (typeof localStorage === 'undefined') return []
-    const raw = localStorage.getItem(key)
-    return raw ? (JSON.parse(raw) as T[]) : []
-  } catch {
-    return []
-  }
-}
-
-function store<T>(key: string, value: T[]): void {
-  try {
-    if (typeof localStorage === 'undefined') return
-    localStorage.setItem(key, JSON.stringify(value))
-  } catch {
-    /* quota/serialization failures are non-fatal in mock mode */
-  }
-}
-
-export interface MockShopSeed {
-  products?: Product[]
-  categories?: Category[]
-  discounts?: Discount[]
-}
-
-export class MockShopProvider implements ShopProvider {
-  private products: Product[]
-  private categories: Category[]
-  private discounts: Discount[]
-  private orders: Order[] = loadStored<Order>(ORDERS_KEY)
-  private customers: ShopCustomer[] = loadStored<ShopCustomer>(CUSTOMERS_KEY)
-  private enquiries: ProductEnquiry[] = loadStored<ProductEnquiry>(ENQUIRIES_KEY)
-  private channels: SalesChannel[] = (() => {
-    const stored = loadStored<SalesChannel>(CHANNELS_KEY)
-    return stored.length ? stored : DEFAULT_CHANNELS.map(c => ({ ...c }))
-  })()
-
-  constructor(seed?: MockShopSeed) {
-    this.products = (seed?.products ?? MOCK_PRODUCTS).map(p => ({ ...p }))
-    this.categories = (seed?.categories ?? MOCK_CATEGORIES).map(c => ({ ...c }))
-    this.discounts = (seed?.discounts ?? MOCK_DISCOUNTS).map(d => ({ ...d }))
-  }
-
-  // Re-read before mutating: HMR can re-instantiate the provider mid-session
-  // and a stale in-memory copy must not clobber persisted records.
-  private syncOrders() { this.orders = loadStored<Order>(ORDERS_KEY) }
-  private syncCustomers() { this.customers = loadStored<ShopCustomer>(CUSTOMERS_KEY) }
-  private syncEnquiries() { this.enquiries = loadStored<ProductEnquiry>(ENQUIRIES_KEY) }
-  private syncChannels() {
-    const stored = loadStored<SalesChannel>(CHANNELS_KEY)
-    if (stored.length) this.channels = stored
-  }
-  private persistOrders() { store(ORDERS_KEY, this.orders) }
-  private persistCustomers() { store(CUSTOMERS_KEY, this.customers) }
-  private persistEnquiries() { store(ENQUIRIES_KEY, this.enquiries) }
-  private persistChannels() { store(CHANNELS_KEY, this.channels) }
-
-  // ---------------------------------------------------------------------------
-  // Products
-  // ---------------------------------------------------------------------------
-
-  async listProducts(opts?: ListProductsOptions): Promise<Product[]> {
-    let list = [...this.products]
-    if (opts?.status) list = list.filter(p => p.status === opts.status)
-    if (opts?.categoryId) list = list.filter(p => p.categoryId === opts.categoryId)
-    if (opts?.slug) list = list.filter(p => p.slug === opts.slug)
-    if (opts?.search) {
-      const q = opts.search.toLowerCase()
-      list = list.filter(p =>
-        p.name.toLowerCase().includes(q) ||
-        (p.description ?? '').toLowerCase().includes(q) ||
-        (p.sku ?? '').toLowerCase().includes(q),
-      )
-    }
-    const orderBy = opts?.orderBy ?? 'sort_order'
-    const dir = opts?.order === 'desc' ? -1 : 1
-    list.sort((a, b) => {
-      switch (orderBy) {
-        case 'name': return a.name.localeCompare(b.name) * dir
-        case 'price': return (a.price - b.price) * dir
-        case 'created_at': return a.createdAt.localeCompare(b.createdAt) * dir
-        default: return (a.sortOrder - b.sortOrder) * dir
-      }
-    })
-    const offset = opts?.offset ?? 0
-    if (offset || opts?.limit) list = list.slice(offset, opts?.limit ? offset + opts.limit : undefined)
-    return list
-  }
-
-  async getProduct(id: string) { return this.products.find(p => p.id === id) ?? null }
-
-  async createProduct(input: CreateProductInput): Promise<Product> {
-    const p: Product = { id: uid(), tenantId: 'mock', name: input.name, slug: input.slug ?? input.name.toLowerCase().replace(/\s+/g, '-'), description: input.description ?? null, price: input.price, compareAtPrice: input.compareAtPrice ?? null, currency: input.currency ?? 'BRL', status: input.status ?? 'active', inventoryCount: input.inventoryCount ?? 0, sku: input.sku ?? null, sortOrder: input.sortOrder ?? 0, metadata: input.metadata ?? {}, images: [], categoryId: input.categoryId ?? null, categoryName: null, isPhysical: input.isPhysical ?? true, weight: input.weight ?? null, weightUnit: input.weightUnit ?? 'kg', createdAt: now(), updatedAt: now() }
-    this.products.push(p); return p
-  }
-
-  async updateProduct(id: string, input: UpdateProductInput): Promise<Product> {
-    const i = this.products.findIndex(p => p.id === id)
-    if (i < 0) throw new Error('Product not found')
-    this.products[i] = { ...this.products[i], ...input, updatedAt: now() }
-    return this.products[i]
-  }
-
-  async deleteProduct(id: string) { this.products = this.products.filter(p => p.id !== id) }
-  async uploadProductImage(_productId: string, _file: File): Promise<ProductImage> { throw new Error('Image upload not available in mock mode') }
-  async deleteProductImage(_imageId: string) {}
-
-  async createProductEnquiry(input: CreateProductEnquiryInput): Promise<ProductEnquiry> {
-    this.syncEnquiries()
-    const ts = now()
-    const enquiry: ProductEnquiry = {
-      id: uid(),
-      tenantId: 'mock',
-      productId: input.productId ?? null,
-      productName: input.productName,
-      productSlug: input.productSlug ?? null,
-      customerName: input.customerName,
-      customerEmail: input.customerEmail,
-      customerPhone: input.customerPhone ?? null,
-      subject: input.subject ?? null,
-      message: input.message,
-      sourceUrl: input.sourceUrl ?? null,
-      status: 'new',
-      metadata: input.metadata ?? {},
-      createdAt: ts,
-      updatedAt: ts,
-    }
-    this.enquiries.unshift(enquiry)
-    this.persistEnquiries()
-    return enquiry
-  }
-
-  async listProductEnquiries(opts?: ListProductEnquiriesOptions): Promise<ProductEnquiry[]> {
-    this.syncEnquiries()
-    let list = [...this.enquiries]
-    if (opts?.productId) list = list.filter((e) => e.productId === opts.productId)
-    if (opts?.customerEmail) {
-      const email = opts.customerEmail.toLowerCase()
-      list = list.filter((e) => e.customerEmail.toLowerCase() === email)
-    }
-    if (opts?.status) list = list.filter((e) => e.status === opts.status)
-    list.sort((a, b) => b.createdAt.localeCompare(a.createdAt))
-    const offset = opts?.offset ?? 0
-    if (offset || opts?.limit) list = list.slice(offset, opts?.limit ? offset + opts.limit : undefined)
-    return list
-  }
-
-  // ---------------------------------------------------------------------------
-  // Categories
-  // ---------------------------------------------------------------------------
-
-  async listCategories() { return [...this.categories].sort((a, b) => a.sortOrder - b.sortOrder) }
-
-  async createCategory(input: CreateCategoryInput): Promise<Category> {
-    const c: Category = { id: uid(), tenantId: 'mock', name: input.name, slug: input.slug ?? input.name.toLowerCase().replace(/\s+/g, '-'), description: input.description ?? null, parentId: input.parentId ?? null, sortOrder: input.sortOrder ?? 0, createdAt: now() }
-    this.categories.push(c); return c
-  }
-
-  async updateCategory(id: string, input: UpdateCategoryInput): Promise<Category> {
-    const i = this.categories.findIndex(c => c.id === id)
-    if (i < 0) throw new Error('Category not found')
-    this.categories[i] = { ...this.categories[i], ...input }
-    return this.categories[i]
-  }
-
-  async deleteCategory(id: string) { this.categories = this.categories.filter(c => c.id !== id) }
-
-  // ---------------------------------------------------------------------------
-  // Orders
-  // ---------------------------------------------------------------------------
-
-  async listOrders(opts?: ListOrdersOptions): Promise<Order[]> {
-    this.syncOrders()
-    let list = [...this.orders]
-    if (opts?.status) list = list.filter(o => o.status === opts.status)
-    if (opts?.financialStatus) list = list.filter(o => o.financialStatus === opts.financialStatus)
-    if (opts?.fulfillmentStatus) list = list.filter(o => o.fulfillmentStatus === opts.fulfillmentStatus)
-    if (opts?.customerId) list = list.filter(o => o.customerId === opts.customerId)
-    if (opts?.customerEmail) {
-      const email = opts.customerEmail.toLowerCase()
-      list = list.filter(o => (o.customerEmail ?? '').toLowerCase() === email)
-    }
-    if (opts?.search) {
-      const q = opts.search.toLowerCase()
-      list = list.filter(o =>
-        (o.customerName ?? '').toLowerCase().includes(q) ||
-        (o.customerEmail ?? '').toLowerCase().includes(q) ||
-        String(o.orderNumber).includes(q),
-      )
-    }
-    list.sort((a, b) => b.createdAt.localeCompare(a.createdAt))
-    if (opts?.limit) list = list.slice(0, opts.limit)
-    return list
-  }
-
-  async getOrder(id: string) {
-    this.syncOrders()
-    return this.orders.find(o => o.id === id) ?? null
-  }
-
-  async createOrder(input: CreateOrderInput): Promise<Order> {
-    this.syncOrders()
-    const subtotal = input.items.reduce((s, i) => s + i.quantity * i.unitPrice, 0)
-    const discountTotal = input.discountTotal ?? 0
-    const shippingTotal = input.shippingTotal ?? 0
-    const total = Math.round((subtotal - discountTotal + shippingTotal) * 100) / 100
-    const orderId = uid()
-    const maxNumber = this.orders.reduce((m, o) => Math.max(m, o.orderNumber), 1000)
-    const o: Order = {
-      id: orderId,
-      tenantId: 'mock',
-      orderNumber: maxNumber + 1,
-      status: 'open',
-      financialStatus: 'pending',
-      fulfillmentStatus: 'unfulfilled',
-      currency: input.currency ?? 'BRL',
-      subtotal: Math.round(subtotal * 100) / 100,
-      taxTotal: 0,
-      discountTotal,
-      shippingTotal,
-      total,
-      customerId: input.customerId ?? null,
-      customerName: input.customerName ?? null,
-      customerEmail: input.customerEmail ?? null,
-      discountCode: input.discountCode ?? null,
-      notes: input.notes ?? null,
-      shippingAddress: null,
-      // CreateOrderInput has no payment method — that is a PlaceOrderInput
-      // concern; the mock records none rather than inventing one.
-      paymentMethodKind: null,
-      paidAt: null,
-      items: input.items.map(i => ({ id: uid(), orderId, productId: i.productId ?? null, name: i.name, sku: i.sku ?? null, quantity: i.quantity, unitPrice: i.unitPrice, total: Math.round(i.quantity * i.unitPrice * 100) / 100, imageUrl: i.imageUrl ?? null })),
-      createdAt: now(),
-      updatedAt: now(),
-    }
-    this.orders.push(o)
-    this.persistOrders()
-    return o
-  }
-
-  async updateOrder(id: string, input: UpdateOrderInput): Promise<Order> {
-    this.syncOrders()
-    const i = this.orders.findIndex(o => o.id === id)
-    if (i < 0) throw new Error('Order not found')
-    this.orders[i] = { ...this.orders[i], ...input, updatedAt: now() }
-    this.persistOrders()
-    return this.orders[i]
-  }
-
-  // Trusted placement (mock parity with the shop_place_order RPC): re-reads
-  // prices + stock from the catalog, validates the discount, decrements
-  // inventory. The browser-supplied prices are never used.
-  async placeOrder(input: PlaceOrderInput): Promise<Order> {
-    this.syncOrders()
-    this.syncCustomers()
-
-    // Resolve / create the customer (find-or-create by email).
-    let customerId = input.customerId ?? null
-    let customerName = input.customer?.name?.trim() || null
-    const email = input.customer?.email?.trim().toLowerCase() || null
-    if (!customerId && email) {
-      const existing = this.customers.find(c => (c.email ?? '').toLowerCase() === email)
-      if (existing) {
-        customerId = existing.id
-        customerName = customerName ?? `${existing.firstName} ${existing.lastName}`.trim()
-      } else {
-        const [first, ...rest] = (customerName ?? email).split(' ')
-        const created = await this.createCustomer({ firstName: first || email, lastName: rest.join(' '), email })
-        customerId = created.id
-      }
-    }
-
-    // Re-read price + guard stock from the catalog (never trust the client).
-    const items: CreateOrderInput['items'] = []
-    // Per-line facts for coupon scoping (productId, categoryId, line total).
-    const lineDetails: Array<{ productId: string; categoryId: string | null; lineTotal: number }> = []
-    let subtotal = 0
-    for (const line of input.items) {
-      const product = this.products.find(p => p.id === line.productId)
-      if (!product || product.status !== 'active') throw new Error(`Product unavailable: ${line.productId}`)
-      if (product.inventoryCount < line.quantity) throw new Error(`Insufficient stock for ${product.name}`)
-      const name = line.optionsLabel ? `${product.name} (${line.optionsLabel})` : product.name
-      const lineTotal = product.price * line.quantity
-      subtotal += lineTotal
-      lineDetails.push({ productId: product.id, categoryId: product.categoryId, lineTotal })
-      items.push({ productId: product.id, name, sku: product.sku ?? undefined, quantity: line.quantity, unitPrice: product.price, imageUrl: product.images[0]?.url })
-    }
-    subtotal = Math.round(subtotal * 100) / 100
-
-    // Validate + apply the discount server-side.
-    let shippingTotal = Math.max(input.shippingTotal ?? 0, 0)
-    let discountTotal = 0
-    let appliedCode: string | null = null
-    if (input.discountCode) {
-      const code = input.discountCode.trim().toLowerCase()
-      const d = this.discounts.find(x => (x.code ?? '').toLowerCase() === code)
-      const ts = now()
-      const meetsMin = !d?.minSubtotal || subtotal >= d.minSubtotal
-      const valid = !!d && d.status === 'active' && d.startsAt <= ts && (!d.endsAt || d.endsAt >= ts) && (d.usageLimit == null || d.timesUsed < d.usageLimit) && meetsMin
-      if (valid && d) {
-        appliedCode = d.code
-        // Eligible subtotal = the part of the cart the coupon is scoped to.
-        // applies_to='all' → whole subtotal (unchanged for legacy coupons).
-        let eligible = subtotal
-        if (d.appliesTo === 'products') {
-          eligible = lineDetails.filter(l => d.productIds.includes(l.productId)).reduce((s, l) => s + l.lineTotal, 0)
-        } else if (d.appliesTo === 'categories') {
-          eligible = lineDetails.filter(l => l.categoryId && d.categoryIds.includes(l.categoryId)).reduce((s, l) => s + l.lineTotal, 0)
-        }
-        eligible = Math.round(eligible * 100) / 100
-        if (d.type === 'percentage') discountTotal = Math.round(eligible * d.value) / 100
-        else if (d.type === 'fixed_amount') discountTotal = Math.min(d.value, eligible)
-        else if (d.type === 'free_shipping') shippingTotal = 0
-        // buy_x_get_y unsupported in v1: code recorded, no monetary effect
-        d.timesUsed += 1
-      }
-    }
-    discountTotal = Math.round(Math.min(Math.max(discountTotal, 0), subtotal) * 100) / 100
-
-    // Persist via createOrder (recomputes total from these trusted values).
-    const order = await this.createOrder({
-      customerId: customerId ?? undefined,
-      customerName: customerName ?? undefined,
-      customerEmail: input.customer?.email ?? undefined,
-      currency: input.currency,
-      notes: input.notes,
-      discountCode: appliedCode ?? undefined,
-      discountTotal,
-      shippingTotal,
-      items,
-    })
-
-    // Decrement inventory (in-memory; the mock catalog reseeds on reload).
-    for (const line of input.items) {
-      const product = this.products.find(p => p.id === line.productId)
-      if (product) product.inventoryCount = Math.max(0, product.inventoryCount - line.quantity)
-    }
-
-    return order
-  }
-
-  // ---------------------------------------------------------------------------
-  // Customers
-  // ---------------------------------------------------------------------------
-
-  async listCustomers(opts?: ListCustomersOptions) {
-    this.syncCustomers()
-    let list = [...this.customers]
-    if (opts?.search) list = list.filter(c => `${c.firstName} ${c.lastName} ${c.email}`.toLowerCase().includes(opts.search!.toLowerCase()))
-    if (opts?.limit) list = list.slice(0, opts.limit)
-    return list
-  }
-
-  async getCustomer(id: string) {
-    this.syncCustomers()
-    return this.customers.find(c => c.id === id) ?? null
-  }
-
-  async createCustomer(input: CreateCustomerInput): Promise<ShopCustomer> {
-    this.syncCustomers()
-    const c: ShopCustomer = { id: uid(), tenantId: 'mock', firstName: input.firstName, lastName: input.lastName ?? '', email: input.email ?? null, phone: input.phone ?? null, notes: input.notes ?? null, ordersCount: 0, totalSpent: 0, createdAt: now(), updatedAt: now() }
-    this.customers.push(c)
-    this.persistCustomers()
-    return c
-  }
-
-  async updateCustomer(id: string, input: UpdateCustomerInput): Promise<ShopCustomer> {
-    this.syncCustomers()
-    const i = this.customers.findIndex(c => c.id === id)
-    if (i < 0) throw new Error('Customer not found')
-    this.customers[i] = { ...this.customers[i], ...input, updatedAt: now() }
-    this.persistCustomers()
-    return this.customers[i]
-  }
-
-  async deleteCustomer(id: string) {
-    this.syncCustomers()
-    this.customers = this.customers.filter(c => c.id !== id)
-    this.persistCustomers()
-  }
-
-  async resolveCustomer(input: ResolveCustomerInput): Promise<ShopCustomer> {
-    this.syncCustomers()
-    const email = input.email.trim().toLowerCase()
-    const existing = this.customers.find(c => (c.email ?? '').toLowerCase() === email)
-    if (existing) return existing
-    const [first, ...rest] = (input.name?.trim() || email).split(/\s+/)
-    return this.createCustomer({ firstName: first || email, lastName: rest.join(' '), email })
-  }
-
-  // ---------------------------------------------------------------------------
-  // Discounts
-  // ---------------------------------------------------------------------------
-
-  async listDiscounts(opts?: ListDiscountsOptions) {
-    let list = [...this.discounts]
-    if (opts?.status) list = list.filter(d => d.status === opts.status)
-    if (opts?.type) list = list.filter(d => d.type === opts.type)
-    if (opts?.search) list = list.filter(d => d.title.toLowerCase().includes(opts.search!.toLowerCase()))
-    if (opts?.limit) list = list.slice(0, opts.limit)
-    return list
-  }
-
-  async getDiscount(id: string) { return this.discounts.find(d => d.id === id) ?? null }
-
-  async createDiscount(input: CreateDiscountInput): Promise<Discount> {
-    const d: Discount = { id: uid(), tenantId: 'mock', title: input.title, code: input.code ?? null, type: input.type, method: input.method ?? 'code', value: input.value, usageLimit: input.usageLimit ?? null, oncePerCustomer: input.oncePerCustomer ?? false, minSubtotal: input.minSubtotal ?? null, appliesTo: input.appliesTo ?? 'all', productIds: input.productIds ?? [], categoryIds: input.categoryIds ?? [], startsAt: input.startsAt ?? now(), endsAt: input.endsAt ?? null, status: input.status ?? 'active', timesUsed: 0, createdAt: now(), updatedAt: now() }
-    this.discounts.push(d); return d
-  }
-
-  async updateDiscount(id: string, input: UpdateDiscountInput): Promise<Discount> {
-    const i = this.discounts.findIndex(d => d.id === id)
-    if (i < 0) throw new Error('Discount not found')
-    this.discounts[i] = { ...this.discounts[i], ...input, updatedAt: now() }
-    return this.discounts[i]
-  }
-
-  async deleteDiscount(id: string) { this.discounts = this.discounts.filter(d => d.id !== id) }
-
-  // ---------------------------------------------------------------------------
-  // Sales channels
-  // ---------------------------------------------------------------------------
-
-  async listSalesChannels(): Promise<SalesChannel[]> {
-    this.syncChannels()
-    return [...this.channels].sort((a, b) => a.position - b.position)
-  }
-
-  async createSalesChannel(input: CreateSalesChannelInput): Promise<SalesChannel> {
-    this.syncChannels()
-    const c: SalesChannel = { id: uid(), tenantId: 'mock', kind: input.kind, label: input.label, url: input.url ?? null, enabled: input.enabled ?? true, position: input.position ?? this.channels.length, createdAt: now(), updatedAt: now() }
-    this.channels.push(c); this.persistChannels(); return c
-  }
-
-  async updateSalesChannel(id: string, input: UpdateSalesChannelInput): Promise<SalesChannel> {
-    this.syncChannels()
-    const i = this.channels.findIndex(c => c.id === id)
-    if (i < 0) throw new Error('Sales channel not found')
-    this.channels[i] = { ...this.channels[i], ...input, updatedAt: now() }
-    this.persistChannels(); return this.channels[i]
-  }
-
-  async deleteSalesChannel(id: string): Promise<void> {
-    this.syncChannels()
-    this.channels = this.channels.filter(c => c.id !== id)
-    this.persistChannels()
-  }
-}
-
-export function createMockShopProvider(seed?: MockShopSeed): ShopProvider {
-  return new MockShopProvider(seed)
-}

package/src/mock.ts

@@ -1,2 +0,0 @@
-export { MockShopProvider, createMockShopProvider } from './mock-provider'
-export type { MockShopSeed } from './mock-provider'

package/src/provider.ts

@@ -1,117 +0,0 @@
-import type {
-  Product, ProductImage, Category,
-  Order, ShopCustomer, Discount, ProductEnquiry,
-  CreateProductInput, UpdateProductInput, ListProductsOptions,
-  CreateProductEnquiryInput, ListProductEnquiriesOptions,
-  CreateCategoryInput, UpdateCategoryInput,
-  CreateOrderInput, UpdateOrderInput, ListOrdersOptions, PlaceOrderInput,
-  CreateCustomerInput, UpdateCustomerInput, ListCustomersOptions, ResolveCustomerInput,
-  CustomerAddress, ShippingQuoteOption,
-  ShippingZone, CreateShippingZoneInput, UpdateShippingZoneInput,
-  CreateDiscountInput, UpdateDiscountInput, ListDiscountsOptions,
-  SalesChannel, CreateSalesChannelInput, UpdateSalesChannelInput,
-} from './types'
-
-export interface ShopProvider {
-  // Products
-  listProducts(options?: ListProductsOptions): Promise<Product[]>
-  getProduct(id: string): Promise<Product | null>
-  createProduct(input: CreateProductInput): Promise<Product>
-  updateProduct(id: string, input: UpdateProductInput): Promise<Product>
-  deleteProduct(id: string): Promise<void>
-  uploadProductImage(productId: string, file: File): Promise<ProductImage>
-  deleteProductImage(imageId: string): Promise<void>
-  /**
-   * Reorder a gallery or promote a photo to primary. Optional so a provider
-   * that only ever holds one image per product need not implement it.
-   *
-   * Setting `isPrimary` is exclusive: the previous primary is demoted in the
-   * same call, because two primaries make "the product photo" ambiguous
-   * everywhere it is read (card, cart line, order item, admin table).
-   */
-  updateProductImage?(
-    imageId: string,
-    input: { isPrimary?: boolean; sortOrder?: number; altText?: string | null },
-  ): Promise<ProductImage>
-
-  // Product enquiries
-  createProductEnquiry?(input: CreateProductEnquiryInput): Promise<ProductEnquiry>
-  listProductEnquiries?(options?: ListProductEnquiriesOptions): Promise<ProductEnquiry[]>
-
-  // Categories
-  listCategories(): Promise<Category[]>
-  createCategory(input: CreateCategoryInput): Promise<Category>
-  updateCategory(id: string, input: UpdateCategoryInput): Promise<Category>
-  deleteCategory(id: string): Promise<void>
-
-  // Orders
-  listOrders(options?: ListOrdersOptions): Promise<Order[]>
-  getOrder(id: string): Promise<Order | null>
-  createOrder(input: CreateOrderInput): Promise<Order>
-  updateOrder(id: string, input: UpdateOrderInput): Promise<Order>
-  /**
-   * Mock/dev payment seam: pending->paid transition via a whitelisted RPC
-   * (anon storefronts have no UPDATE grant on the orders table). Real PSPs
-   * confirm via webhook with service_role instead.
-   */
-  confirmPayment?(id: string, reference?: string): Promise<Order | null>
-  /**
-   * Trusted order placement: the server re-reads product prices + stock,
-   * validates the discount, computes totals, and decrements inventory
-   * atomically. Storefront checkout MUST use this instead of createOrder so the
-   * browser cannot tamper with prices. createOrder remains for trusted admin entry.
-   */
-  placeOrder(input: PlaceOrderInput): Promise<Order>
-
-  // Customers
-  listCustomers(options?: ListCustomersOptions): Promise<ShopCustomer[]>
-  getCustomer(id: string): Promise<ShopCustomer | null>
-  createCustomer(input: CreateCustomerInput): Promise<ShopCustomer>
-  updateCustomer(id: string, input: UpdateCustomerInput): Promise<ShopCustomer>
-  deleteCustomer(id: string): Promise<void>
-  /**
-   * Find-or-create the customer for a storefront shopper and (on Supabase) link
-   * it to auth.uid server-side, so order reads can be scoped to the owner by RLS.
-   * Optional: providers without it fall back to listCustomers+createCustomer.
-   */
-  resolveCustomer?(input: ResolveCustomerInput): Promise<ShopCustomer>
-  /**
-   * The signed-in shopper's saved delivery addresses, so checkout can offer
-   * them instead of inventing a placeholder. Optional: a provider without it
-   * (or an anonymous request) yields an empty book and a blank form.
-   */
-  listCustomerAddresses?(customerId: string): Promise<CustomerAddress[]>
-
-  // Delivery
-  /**
-   * Delivery options for a postal code at a given subtotal. An empty array
-   * means the store does not deliver there — shown before the buyer commits to
-   * a cart, which is the whole point of quoting on the product page.
-   *
-   * This is for DISPLAY. shop_place_order recomputes the freight from the same
-   * zones and ignores whatever the client sends, so a tampered quote changes
-   * what the shopper sees and nothing about what they are charged.
-   */
-  quoteShipping?(postalCode: string, subtotal: number): Promise<ShippingQuoteOption[]>
-
-  /** Delivery zones the merchant maintains. Admin-only: the storefront reads
-   *  quotes, never the ranges themselves. */
-  listShippingZones?(): Promise<ShippingZone[]>
-  createShippingZone?(input: CreateShippingZoneInput): Promise<ShippingZone>
-  updateShippingZone?(id: string, input: UpdateShippingZoneInput): Promise<ShippingZone>
-  deleteShippingZone?(id: string): Promise<void>
-
-  // Discounts
-  listDiscounts(options?: ListDiscountsOptions): Promise<Discount[]>
-  getDiscount(id: string): Promise<Discount | null>
-  createDiscount(input: CreateDiscountInput): Promise<Discount>
-  updateDiscount(id: string, input: UpdateDiscountInput): Promise<Discount>
-  deleteDiscount(id: string): Promise<void>
-
-  // Sales channels — the store's points of sale (Loja Online, WhatsApp, …).
-  // Optional: a provider without them yields no "Canais de venda" section.
-  listSalesChannels?(): Promise<SalesChannel[]>
-  createSalesChannel?(input: CreateSalesChannelInput): Promise<SalesChannel>
-  updateSalesChannel?(id: string, input: UpdateSalesChannelInput): Promise<SalesChannel>
-  deleteSalesChannel?(id: string): Promise<void>
-}

package/src/runtime.ts

@@ -1,20 +0,0 @@
-import type { ShopProvider } from './provider'
-import { createMockShopProvider } from './mock-provider'
-
-let provider: ShopProvider | null = null
-let mockFallback: ShopProvider | null = null
-
-export function getShopProvider(): ShopProvider {
-  if (provider) return provider
-  if (!mockFallback) mockFallback = createMockShopProvider()
-  return mockFallback
-}
-
-export function setShopProvider(nextProvider: ShopProvider): void {
-  provider = nextProvider
-}
-
-export function resetShopProvider(): void {
-  provider = null
-  mockFallback = null
-}