@fayz-ai/plugin-shop 0.9.0 → 0.9.1

package/src/views/OrderDetailView.tsx

@@ -1,319 +0,0 @@
-import React, { useEffect, useState } from 'react'
-import {
-  adminNavigateTo, PersonLink,
-  OrderDetailView as SharedOrderDetailView, OrderDetailSkeleton, OrderDetailBlock, OrderDetailRow,
-  type OrderDetailData, type OrderDetailInstallment, type OrderDetailTone,
-} from '@fayz-ai/saas'
-import { shopCustomerLookup } from './customerLookup'
-import type { Order, ShopProvider } from '@fayz-ai/shop'
-import { getSupabaseClientOptional } from '@fayz-ai/core'
-
-/** A shipment as stored in public.fulfillments (0018). */
-type Fulfillment = {
-  id: string
-  status: string
-  carrier: string | null
-  service: string | null
-  tracking_code: string | null
-  tracking_url: string | null
-  shipped_at: string | null
-  estimated_delivery_at: string | null
-  delivered_at: string | null
-}
-
-type Bill = {
-  id: string
-  amount: number
-  paid_amount: number | null
-  status: string
-  due_date: string
-  installment_number: number | null
-}
-type Receivable = {
-  balance: { amount: number; paid: number; balance: number; status: string; reference_number: string | null }
-  bills: Bill[]
-}
-
-const money = (v: number, currency = 'BRL') =>
-  new Intl.NumberFormat('pt-BR', { style: 'currency', currency }).format(Number(v) || 0)
-const dateTime = (iso: string) =>
-  new Intl.DateTimeFormat('pt-BR', { day: '2-digit', month: '2-digit', year: 'numeric', hour: '2-digit', minute: '2-digit' }).format(new Date(iso))
-const dateOnly = (iso: string) => new Date(iso).toLocaleDateString('pt-BR')
-
-const PAYMENT_LABEL: Record<string, string> = {
-  pix: 'Pix', credit_card: 'Cartão de crédito', debit_card: 'Cartão de débito',
-  boleto: 'Boleto', cash: 'Dinheiro', other: 'Outro',
-}
-const LABEL: Record<string, string> = {
-  paid: 'Pago', pending: 'Aguardando pagamento', refunded: 'Estornado',
-  partially_refunded: 'Estorno parcial', voided: 'Cancelado',
-  fulfilled: 'Enviado', unfulfilled: 'Não enviado', partially_fulfilled: 'Envio parcial',
-  open: 'Aberto', cancelled: 'Cancelado', archived: 'Arquivado',
-}
-const RECEIVABLE_LABEL: Record<string, string> = {
-  open: 'Em aberto', partial: 'Parcialmente recebido', paid: 'Recebido', overdue: 'Vencido', cancelled: 'Cancelado',
-}
-const SHIPMENT_LABEL: Record<string, string> = {
-  pending: 'Aguardando coleta', in_transit: 'Em trânsito', delivered: 'Entregue',
-  failed: 'Falhou', returned: 'Devolvido', cancelled: 'Cancelado',
-}
-
-/** Map a shop/receivable status string to the shared component's tone. */
-function toneOf(value: string): OrderDetailTone {
-  switch (value) {
-    case 'paid': case 'fulfilled': case 'delivered': return 'success'
-    case 'pending': case 'partial': case 'partially_fulfilled': case 'open': case 'in_transit': return 'warning'
-    case 'refunded': case 'partially_refunded': case 'voided': case 'cancelled': case 'overdue': case 'failed': case 'returned': return 'destructive'
-    default: return 'muted'
-  }
-}
-
-/** Small inline badge for the shop-specific blocks (Entrega/Histórico). */
-function InlineBadge({ value }: { value: string }) {
-  const tone = toneOf(value)
-  const cls: Record<OrderDetailTone, string> = {
-    success: 'bg-emerald-100 text-emerald-800', warning: 'bg-amber-100 text-amber-800',
-    destructive: 'bg-red-100 text-red-700', info: 'bg-sky-100 text-sky-800', muted: 'bg-muted text-muted-foreground',
-  }
-  return <span className={`inline-flex items-center rounded-full px-2 py-0.5 text-xs font-medium ${cls[tone]}`}>{LABEL[value] ?? value}</span>
-}
-
-function deliveryFromNotes(notes: string | null): string | null {
-  if (!notes) return null
-  const match = notes.match(/entrega:\s*(.+)/i)
-  return (match?.[1] ?? '').trim() || null
-}
-
-// Cache por id (fora do componente) — trocar de aba remonta a view; sem cache
-// isso refaz o getOrder (skeleton + request) toda vez. Cache-first evita o refetch;
-// "Registrar recebimento" atualiza o cache.
-const shopOrderCache = new Map<string, Order>()
-const shopShipmentsCache = new Map<string, Fulfillment[]>()
-const shopReceivableCache = new Map<string, Receivable | null>()
-
-export function OrderDetailView({ orderId, provider, onBack }: {
-  orderId: string
-  provider: () => ShopProvider
-  onBack: () => void
-}) {
-  const [order, setOrder] = useState<Order | null>(() => shopOrderCache.get(orderId) ?? null)
-  const [shipments, setShipments] = useState<Fulfillment[]>(() => shopShipmentsCache.get(orderId) ?? [])
-  const [loading, setLoading] = useState(() => !shopOrderCache.has(orderId))
-  const [error, setError] = useState<string | null>(null)
-  const [confirming, setConfirming] = useState(false)
-  const [confirmError, setConfirmError] = useState<string | null>(null)
-  const [receivable, setReceivable] = useState<Receivable | null>(() => shopReceivableCache.get(orderId) ?? null)
-
-  useEffect(() => {
-    let cancelled = false
-    const cached = shopOrderCache.get(orderId)
-    if (cached) { setOrder(cached); setLoading(false); return () => { cancelled = true } } // cache hit → sem request
-    setLoading(true); setError(null)
-    provider().getOrder(orderId)
-      .then((o) => { if (!cancelled) { if (o) shopOrderCache.set(orderId, o); setOrder(o) } })
-      .catch((err: unknown) => { if (!cancelled) setError(err instanceof Error ? err.message : String(err)) })
-      .finally(() => { if (!cancelled) setLoading(false) })
-    return () => { cancelled = true }
-  }, [orderId, provider])
-
-  useEffect(() => {
-    let cancelled = false
-    const db = getSupabaseClientOptional() as unknown as { from: (t: string) => any } | null
-    if (!db) return
-    if (shopShipmentsCache.has(orderId)) return () => { cancelled = true } // cache hit → sem request
-    db.from('fulfillments').select('*').eq('order_id', orderId).order('created_at', { ascending: false })
-      .then(({ data }: { data: Fulfillment[] | null }) => { if (!cancelled) { shopShipmentsCache.set(orderId, data ?? []); setShipments(data ?? []) } })
-    return () => { cancelled = true }
-  }, [orderId])
-
-  // The order does not decide whether it was paid — the receivable does. Keep this
-  // hook ABOVE the early returns (hook order must be stable).
-  useEffect(() => {
-    let cancelled = false
-    const db = getSupabaseClientOptional() as unknown as { from: (t: string) => any } | null
-    if (!db) return
-    if (shopReceivableCache.has(orderId)) { setReceivable(shopReceivableCache.get(orderId) ?? null); return () => { cancelled = true } } // cache hit → sem request
-    void (async () => {
-      const [balance, bills] = await Promise.all([
-        db.from('v_invoice_balances').select('*').eq('invoice_id', orderId).maybeSingle(),
-        db.from('plg_financial_movements').select('*').eq('invoice_id', orderId).eq('movement_kind', 'bill').order('installment_number', { ascending: true }),
-      ])
-      if (cancelled || !balance?.data) return
-      const rec = { balance: balance.data, bills: bills?.data ?? [] }
-      shopReceivableCache.set(orderId, rec)
-      setReceivable(rec)
-    })()
-    return () => { cancelled = true }
-  }, [orderId, confirming])
-
-  if (loading) return <OrderDetailSkeleton />
-  if (error) {
-    return (
-      <div className="rounded-lg border border-red-200 bg-red-50 px-4 py-3 text-sm text-red-800">
-        <p className="font-medium">Não foi possível carregar o pedido.</p>
-        <p className="mt-1 text-red-700">{error}</p>
-      </div>
-    )
-  }
-  if (!order) return <div className="py-12 text-center text-sm text-muted-foreground">Pedido não encontrado.</div>
-
-  const cur = order.currency
-  const delivery = deliveryFromNotes(order.notes)
-  const addr = order.shippingAddress
-
-  async function registerReceipt() {
-    if (!order) return
-    shopReceivableCache.delete(order.id) // pagamento muda o recebível → força refetch
-    setConfirming(true); setConfirmError(null)
-    try {
-      const fresh = (await provider().confirmPayment?.(order.id)) ?? (await provider().getOrder(order.id))
-      if (fresh) { shopOrderCache.set(order.id, fresh); setOrder(fresh) } // atualiza o cache
-    } catch (err: unknown) {
-      setConfirmError(err instanceof Error ? err.message : String(err))
-    } finally { setConfirming(false) }
-  }
-
-  const installments: OrderDetailInstallment[] = (receivable && receivable.bills.length > 1)
-    ? receivable.bills.map((b) => ({
-        number: b.installment_number ?? 0,
-        amount: `${money(Number(b.paid_amount ?? 0), cur)} / ${money(Number(b.amount), cur)}`,
-        status: RECEIVABLE_LABEL[b.status] ?? b.status,
-        statusTone: toneOf(b.status),
-        dueDate: `vence ${dateOnly(b.due_date)}`,
-      }))
-    : []
-
-  const data: OrderDetailData = {
-    title: `Pedido #${order.orderNumber}`,
-    subtitle: dateTime(order.createdAt),
-    badges: [
-      { label: LABEL[order.financialStatus] ?? order.financialStatus, tone: toneOf(order.financialStatus) },
-      { label: LABEL[order.fulfillmentStatus] ?? order.fulfillmentStatus, tone: toneOf(order.fulfillmentStatus) },
-    ],
-    customer: { name: order.customerName, email: order.customerEmail },
-    customerNode: (
-      <div className="space-y-1 text-sm">
-        {order.customerId ? (
-          <PersonLink
-            personId={order.customerId}
-            name={order.customerName ?? order.customerEmail ?? 'Cliente'}
-            lookup={shopCustomerLookup(provider)}
-            profileHref={`#/customers/${order.customerId}`}
-            className="font-medium"
-          />
-        ) : (
-          <p className="font-medium">{order.customerName ?? '—'}</p>
-        )}
-        {order.customerEmail && <p className="text-muted-foreground">{order.customerEmail}</p>}
-        {!order.customerId && <p className="text-xs text-muted-foreground">Compra sem cadastro — não há ficha de cliente para abrir.</p>}
-      </div>
-    ),
-    items: order.items.map((it) => ({
-      id: it.id, name: it.name, description: it.sku, imageUrl: it.imageUrl,
-      quantity: it.quantity, unitPrice: money(it.unitPrice, cur), total: money(it.total, cur),
-    })),
-    totals: [
-      { label: 'Subtotal', value: money(order.subtotal, cur) },
-      ...(order.discountTotal > 0 ? [{ label: `Desconto${order.discountCode ? ` (${order.discountCode})` : ''}`, value: `− ${money(order.discountTotal, cur)}`, muted: true }] : []),
-      { label: 'Entrega', value: money(order.shippingTotal, cur) },
-      { label: 'Impostos', value: money(order.taxTotal, cur) },
-      { label: 'Total', value: money(order.total, cur), strong: true },
-    ],
-    paymentMethod: order.paymentMethodKind ? (PAYMENT_LABEL[order.paymentMethodKind] ?? order.paymentMethodKind) : undefined,
-    paidAt: order.paidAt ? dateTime(order.paidAt) : undefined,
-    receivable: receivable ? {
-      referenceNumber: receivable.balance.reference_number ?? undefined,
-      statusBadge: { label: RECEIVABLE_LABEL[receivable.balance.status] ?? receivable.balance.status, tone: toneOf(receivable.balance.status) },
-      rows: [
-        { label: 'Faturado', value: money(receivable.balance.amount, cur) },
-        { label: 'Recebido', value: money(receivable.balance.paid, cur) },
-        { label: 'Saldo', value: money(receivable.balance.balance, cur), strong: true },
-      ],
-      installments,
-      actions: (
-        <>
-          {receivable.balance.balance > 0 && receivable.balance.status !== 'cancelled' && (
-            <button type="button" onClick={registerReceipt} disabled={confirming} data-testid="order-register-receipt"
-              className="rounded-md bg-primary px-3 py-1.5 text-sm font-medium text-primary-foreground transition hover:opacity-90 disabled:opacity-60">
-              {confirming ? 'Registrando…' : 'Registrar recebimento'}
-            </button>
-          )}
-          <button type="button" onClick={() => adminNavigateTo('/financial')}
-            className="rounded-md border px-3 py-1.5 text-sm font-medium transition hover:bg-muted">
-            Abrir no Financeiro
-          </button>
-          {confirmError && <p className="mt-2 w-full rounded-md border border-red-200 bg-red-50 px-3 py-2 text-xs text-red-800">{confirmError}</p>}
-        </>
-      ),
-      emptyLabel: 'Sem conta a receber para este pedido.',
-    } : { rows: [], installments: [], emptyLabel: 'Sem conta a receber para este pedido.' },
-    extraSections: (
-      <>
-        <OrderDetailBlock title="Entrega" hint="O que a logística precisa">
-          <div className="space-y-2 text-sm">
-            {addr ? (
-              <div className="space-y-0.5">
-                <p>{[addr.street, addr.number].filter(Boolean).join(', ')}{addr.complement ? ` — ${addr.complement}` : ''}</p>
-                {addr.district && <p className="text-muted-foreground">{addr.district}</p>}
-                <p className="text-muted-foreground">
-                  {[addr.city, addr.state].filter((v) => v && v !== '—').join('/')}{addr.postal_code ? ` · ${addr.postal_code}` : ''}
-                </p>
-                {(addr.recipient || addr.phone) && <p className="text-xs text-muted-foreground">{[addr.recipient, addr.phone].filter(Boolean).join(' · ')}</p>}
-              </div>
-            ) : (
-              <p className={delivery ? '' : 'text-muted-foreground'}>{delivery ?? 'Nenhum endereço registrado neste pedido.'}</p>
-            )}
-            <div className="border-t pt-2">
-              <OrderDetailRow label="Status" value={<InlineBadge value={order.fulfillmentStatus} />} />
-              {shipments.length === 0 ? (
-                <p className="mt-1 text-xs text-muted-foreground">Nenhum envio registrado.</p>
-              ) : (
-                <div className="mt-2 space-y-2">
-                  {shipments.map((s) => (
-                    <div key={s.id} className="rounded-md border px-2 py-1.5">
-                      <div className="flex items-center justify-between gap-2">
-                        <span className="text-sm font-medium">{[s.carrier, s.service].filter(Boolean).join(' · ') || 'Envio'}</span>
-                        <span className="text-[10px] text-muted-foreground">{SHIPMENT_LABEL[s.status] ?? s.status}</span>
-                      </div>
-                      {s.tracking_code && (
-                        <p className="mt-0.5 font-mono text-xs">
-                          {s.tracking_url ? <a href={s.tracking_url} target="_blank" rel="noreferrer" className="text-primary hover:underline">{s.tracking_code}</a> : s.tracking_code}
-                        </p>
-                      )}
-                      <div className="mt-1 space-y-0.5 text-[11px] text-muted-foreground">
-                        {s.shipped_at && <p>Despachado em {dateTime(s.shipped_at)}</p>}
-                        {s.estimated_delivery_at && <p>Previsão: {dateTime(s.estimated_delivery_at)}</p>}
-                        {s.delivered_at && <p>Entregue em {dateTime(s.delivered_at)}</p>}
-                      </div>
-                    </div>
-                  ))}
-                </div>
-              )}
-            </div>
-          </div>
-        </OrderDetailBlock>
-
-        <OrderDetailBlock title="Histórico">
-          <div className="space-y-1 text-sm">
-            <OrderDetailRow label="Criado" value={dateTime(order.createdAt)} />
-            <OrderDetailRow label="Atualizado" value={dateTime(order.updatedAt)} />
-            <OrderDetailRow label="Situação" value={<InlineBadge value={order.status} />} />
-          </div>
-        </OrderDetailBlock>
-
-        {order.notes && (
-          <OrderDetailBlock title="Observações">
-            <p className="whitespace-pre-wrap text-sm text-muted-foreground">{order.notes}</p>
-          </OrderDetailBlock>
-        )}
-      </>
-    ),
-    onBack,
-    backLabel: 'Pedidos',
-  }
-
-  return <SharedOrderDetailView {...data} />
-}
-
-export const orderDetailPath = (id: string) => `/shop/orders/${id}`
-export const goToOrder = (id: string) => adminNavigateTo(orderDetailPath(id))

package/src/views/ProductImagesTab.tsx

@@ -1,183 +0,0 @@
-import React, { useEffect, useRef, useState } from 'react'
-import type { Product, ProductImage, ShopProvider } from '@fayz-ai/shop'
-
-/**
- * The product's whole gallery, not just its cover.
- *
- * plg_shop_product_images has always been a collection — sort_order, is_primary
- * — but the admin only ever exposed the single `EntityImageConfig` slot on the
- * form, so a merchant could set one photo and no more, and the storefront had
- * nothing to build a carousel from. This is the missing half.
- *
- * Deliberately not drag-and-drop: ordering is done with arrows because a
- * keyboard and a screen reader can use them, and because reordering four
- * photos of a rib is not worth a drag library.
- */
-export function ProductImagesTab({ item, getProvider }: {
-  item: unknown
-  getProvider: () => ShopProvider
-}) {
-  const product = item as Product
-  const [images, setImages] = useState<ProductImage[]>([])
-  const [busy, setBusy] = useState(false)
-  const [error, setError] = useState<string | null>(null)
-  const fileRef = useRef<HTMLInputElement>(null)
-
-  async function reload() {
-    const fresh = await getProvider().getProduct(product.id)
-    setImages(sortImages(fresh?.images ?? []))
-  }
-
-  useEffect(() => { void reload().catch(() => {}) }, [product.id])
-
-  async function run(action: () => Promise<unknown>) {
-    setBusy(true)
-    setError(null)
-    try {
-      await action()
-      await reload()
-    } catch (err: unknown) {
-      setError(err instanceof Error ? err.message : String(err))
-    } finally {
-      setBusy(false)
-    }
-  }
-
-  async function upload(files: FileList | null) {
-    if (!files?.length) return
-    // Sequential, not Promise.all: each upload reads the current max sort_order
-    // to place itself last, and running them together makes them all read the
-    // same value and land on the same position.
-    await run(async () => {
-      for (const file of Array.from(files)) {
-        await getProvider().uploadProductImage(product.id, file)
-      }
-      if (fileRef.current) fileRef.current.value = ''
-    })
-  }
-
-  function move(index: number, delta: number) {
-    const target = index + delta
-    if (target < 0 || target >= images.length) return
-    const a = images[index]!
-    const b = images[target]!
-    // Swap the two positions rather than renumbering the list: fewer writes, and
-    // a failure halfway leaves an order that is still coherent.
-    void run(async () => {
-      const update = getProvider().updateProductImage
-      if (!update) throw new Error('Este provider não suporta reordenar imagens.')
-      await update(a.id, { sortOrder: b.sortOrder ?? target })
-      await update(b.id, { sortOrder: a.sortOrder ?? index })
-    })
-  }
-
-  const update = getProvider().updateProductImage
-
-  return (
-    <div className="space-y-4">
-      <div className="flex flex-wrap items-center justify-between gap-3">
-        <div>
-          <h3 className="text-sm font-semibold">Fotos do produto</h3>
-          <p className="text-xs text-muted-foreground">
-            A primeira foto é a capa — aparece no catálogo, no carrinho e no pedido.
-            As demais viram o carrossel na página do produto.
-          </p>
-        </div>
-        <label className="inline-flex cursor-pointer items-center rounded-md bg-primary px-3 py-1.5 text-sm font-medium text-primary-foreground transition hover:opacity-90">
-          {busy ? 'Enviando…' : 'Adicionar fotos'}
-          <input
-            ref={fileRef}
-            type="file"
-            accept="image/*"
-            multiple
-            disabled={busy}
-            className="hidden"
-            onChange={(event) => void upload(event.target.files)}
-          />
-        </label>
-      </div>
-
-      {error && (
-        <p className="rounded-md border border-red-200 bg-red-50 px-3 py-2 text-sm text-red-800">{error}</p>
-      )}
-
-      {images.length === 0 ? (
-        <p className="rounded-lg border border-dashed px-4 py-10 text-center text-sm text-muted-foreground">
-          Nenhuma foto ainda. Produtos com mais de uma foto vendem melhor — mostre a
-          embalagem, o produto pronto e uma referência de tamanho.
-        </p>
-      ) : (
-        <ul className="grid grid-cols-2 gap-3 sm:grid-cols-3 lg:grid-cols-4">
-          {images.map((image, index) => (
-            <li key={image.id} className="overflow-hidden rounded-lg border">
-              <div className="relative aspect-square bg-muted">
-                <img src={image.url} alt={image.altText ?? ''} className="h-full w-full object-cover" />
-                {image.isPrimary && (
-                  <span className="absolute left-2 top-2 rounded-full bg-primary px-2 py-0.5 text-[11px] font-bold text-primary-foreground">
-                    Capa
-                  </span>
-                )}
-              </div>
-              <div className="flex items-center justify-between gap-1 px-2 py-1.5">
-                <div className="flex gap-1">
-                  <IconButton label="Mover para trás" disabled={busy || index === 0}
-                    onClick={() => move(index, -1)}>←</IconButton>
-                  <IconButton label="Mover para frente" disabled={busy || index === images.length - 1}
-                    onClick={() => move(index, 1)}>→</IconButton>
-                </div>
-                <div className="flex gap-1">
-                  {!image.isPrimary && update && (
-                    <button
-                      type="button"
-                      disabled={busy}
-                      onClick={() => void run(() => update(image.id, { isPrimary: true }))}
-                      className="rounded px-1.5 py-0.5 text-xs text-muted-foreground hover:bg-muted hover:text-foreground disabled:opacity-50"
-                    >
-                      Usar como capa
-                    </button>
-                  )}
-                  <button
-                    type="button"
-                    disabled={busy}
-                    onClick={() => void run(() => getProvider().deleteProductImage(image.id))}
-                    className="rounded px-1.5 py-0.5 text-xs text-red-600 hover:bg-red-50 disabled:opacity-50"
-                  >
-                    Excluir
-                  </button>
-                </div>
-              </div>
-            </li>
-          ))}
-        </ul>
-      )}
-    </div>
-  )
-}
-
-function IconButton({ label, disabled, onClick, children }: {
-  label: string
-  disabled?: boolean
-  onClick: () => void
-  children: React.ReactNode
-}) {
-  return (
-    <button
-      type="button"
-      aria-label={label}
-      title={label}
-      disabled={disabled}
-      onClick={onClick}
-      className="rounded border px-1.5 py-0.5 text-xs text-muted-foreground transition hover:bg-muted hover:text-foreground disabled:opacity-40"
-    >
-      {children}
-    </button>
-  )
-}
-
-/** Cover first, then the merchant's order — the same rule the storefront uses. */
-function sortImages(images: ProductImage[]): ProductImage[] {
-  return [...images].sort((a, b) => {
-    if (a.isPrimary !== b.isPrimary) return a.isPrimary ? -1 : 1
-    return (a.sortOrder ?? 0) - (b.sortOrder ?? 0)
-  })
-}

package/src/views/customerEntity.tsx

@@ -1,110 +0,0 @@
-import React from 'react'
-import type { EntityDef, FieldDef } from '@fayz-ai/core'
-import type { ShopCustomer } from '@fayz-ai/shop'
-import { ClientOrdersTab, createClientOrdersProvider, adminNavigateTo } from '@fayz-ai/saas'
-import type { ClientDocument } from '@fayz-ai/saas'
-
-// ---------------------------------------------------------------------------
-// Shop customer — same declarative contract as the product entity, so the list
-// and the form both come from createCrudPage instead of a hand-rolled table.
-//
-// ordersCount / totalSpent are read-only: they are maintained server-side by the
-// shop_refresh_customer_stats trigger on every order insert/update/delete, so
-// putting them in the form would offer an edit the database would overwrite.
-// ---------------------------------------------------------------------------
-
-function money(value: unknown) {
-  const n = Number(value)
-  if (!Number.isFinite(n)) return 'R$ 0,00'
-  return new Intl.NumberFormat('pt-BR', { style: 'currency', currency: 'BRL' }).format(n)
-}
-
-export function buildShopCustomerEntity(): EntityDef<ShopCustomer> {
-  const fields: FieldDef[] = [
-    // — Contato —
-    {
-      key: 'firstName', label: 'Nome', type: 'text', required: true,
-      group: 'contact', placeholder: 'Maria', searchable: true,
-      showInTable: true, sortable: true,
-      renderCell: (_v, row: any) => (
-        <div className="min-w-0">
-          <p className="truncate font-medium">{[row.firstName, row.lastName].filter(Boolean).join(' ')}</p>
-          {row.email && <p className="truncate text-xs text-muted-foreground">{row.email}</p>}
-        </div>
-      ),
-    },
-    { key: 'lastName', label: 'Sobrenome', type: 'text', group: 'contact', placeholder: 'Silva', searchable: true, showInTable: false },
-    {
-      key: 'email', label: 'E-mail', type: 'text', group: 'contact',
-      placeholder: 'maria@exemplo.com', searchable: true,
-      hint: 'É por ele que o pedido é vinculado ao cliente no checkout.',
-      showInTable: false,
-    },
-    {
-      key: 'phone', label: 'Telefone', type: 'text', group: 'contact',
-      placeholder: '(21) 99999-0000', searchable: true,
-      showInTable: true, sortable: false,
-      renderCell: (v) => <span className="text-muted-foreground">{(v as string) || '—'}</span>,
-    },
-
-    // — Histórico (somente leitura) —
-    {
-      key: 'ordersCount', label: 'Pedidos', type: 'number',
-      showInForm: false, showInTable: true, sortable: true,
-      renderCell: (v) => <span className="block text-right">{Number(v) || 0}</span>,
-    },
-    {
-      key: 'totalSpent', label: 'Total gasto', type: 'number',
-      showInForm: false, showInTable: true, sortable: true,
-      renderCell: (v) => <span className="block text-right font-medium">{money(v)}</span>,
-    },
-
-    // — Interno —
-    {
-      key: 'notes', label: 'Observações', type: 'textarea', group: 'internal', span: 2,
-      placeholder: 'Preferências, restrições, combinados de entrega…',
-      hint: 'Visível só no admin. O cliente nunca vê.',
-      showInTable: false,
-    },
-  ]
-
-  return {
-    name: 'Cliente',
-    namePlural: 'Clientes',
-    icon: 'Users',
-    displayField: 'firstName',
-    // `person` layout brings the shared archetype tabs — including Endereços,
-    // which reads the core addresses table and therefore works in every app.
-    layout: 'person',
-    // Without archetypeKind the shell shows every person tab, including the
-    // staff-only Agenda (its visibleFor filter only runs when a kind is set).
-    data: { table: 'plg_shop_customers', archetypeKind: 'customer' },
-    fields,
-    // The SAME tab and the SAME provider beauty-saas uses. Since the shop's
-    // orders now live in public.orders with party_id set, the canonical provider
-    // already returns them — a shop-specific adapter would be a second
-    // implementation of "list this person's orders", which is how two apps end
-    // up with two different answers to the same question.
-    detailTabs: [{
-      id: 'orders',
-      label: 'Pedidos',
-      icon: 'ShoppingBag',
-      aliases: ['appointments', 'quotes'],
-      component: ClientOrdersTab as never,
-      props: {
-        provider: createClientOrdersProvider(),
-        currency: { code: 'BRL', locale: 'pt-BR' },
-        // The one part that legitimately differs per app: where a document
-        // leads. Beauty sends a booking to the agenda and an invoice to
-        // receivables; a shop order goes to the order screen.
-        navigator: {
-          onNavigate: (doc: ClientDocument) => adminNavigateTo(`/shop/orders/${doc.id}`),
-        },
-      },
-    }],
-    fieldGroups: [
-      { id: 'contact', label: 'Contato', columns: 2 },
-      { id: 'internal', label: 'Notas internas', columns: 1 },
-    ],
-  } as EntityDef<ShopCustomer>
-}

package/src/views/customerLookup.ts

@@ -1,31 +0,0 @@
-import type { ShopProvider } from '@fayz-ai/shop'
-
-/**
- * Feeds the shared PersonLink popover from the shop's own customer table.
- * The default lookup reads the `person` archetype (`people`), where a shop
- * customer does not exist — so without this the card would come up empty.
- */
-export function shopCustomerLookup(provider: () => ShopProvider) {
-  return {
-    async getById(id: string) {
-      const c = await provider().getCustomer(id)
-      if (!c) return null
-      const name = [c.firstName, c.lastName].filter(Boolean).join(' ')
-      return {
-        id: c.id,
-        label: name || c.email || 'Cliente',
-        subtitle: c.email ?? undefined,
-        group: 'shop_customer',
-        // PersonLink reads contact fields off `data`, so the keys must match the
-        // shape it expects (email/phone), not our camelCase type.
-        data: {
-          email: c.email ?? undefined,
-          phone: c.phone ?? undefined,
-          kind: 'shop_customer',
-          orders_count: c.ordersCount,
-          total_spent: c.totalSpent,
-        },
-      }
-    },
-  }
-}