@ecomiq/storefront 2.1.3 → 3.0.0

package/src/pages/thank-you.tsx

@@ -1,53 +0,0 @@
-/**
- * Página de agradecimiento cerrada (`/thank-you`).
- * Tras un checkout exitoso (sin redirect del provider).
- */
-import { CheckCircle2 } from 'lucide-react'
-import { z } from 'zod'
-import { definePage, Link } from '../index'
-import { buttonVariants, cn } from '../ui'
-
-const ThankYouSearchSchema = z.object({
-  cartToken: z.string().optional(),
-  transactionId: z.string().optional(),
-})
-
-type ThankYouSearch = z.infer<typeof ThankYouSearchSchema>
-
-export default definePage<undefined, Record<string, never>, ThankYouSearch>({
-  meta: () => ({
-    title: 'Gracias por tu compra',
-    description: 'Tu pedido fue recibido correctamente',
-    noIndex: true,
-  }),
-  validateSearch: (raw) => ThankYouSearchSchema.parse(raw),
-  component: ThankYouPage,
-})
-
-function ThankYouPage({ search }: { search: ThankYouSearch }) {
-  return (
-    <section className="mx-auto flex min-h-[55vh] w-full max-w-lg flex-col items-center justify-center px-4 py-16 text-center">
-      <div className="mb-5 flex size-14 items-center justify-center rounded-full bg-emerald-500/10 text-emerald-600">
-        <CheckCircle2 className="size-7" aria-hidden="true" />
-      </div>
-      <h1 className="text-3xl font-semibold tracking-tight">¡Gracias por tu compra!</h1>
-      <p className="mt-3 text-sm leading-6 text-muted-foreground">
-        Recibimos tu pedido y lo estamos procesando. Te enviaremos una confirmación por
-        correo cuando esté listo.
-      </p>
-      {search.transactionId ? (
-        <p className="mt-4 rounded-md bg-muted px-3 py-2 font-mono text-xs text-muted-foreground">
-          Ref. {search.transactionId}
-        </p>
-      ) : null}
-      <div className="mt-8 flex flex-wrap justify-center gap-3">
-        <Link to="/" className={cn(buttonVariants({ size: 'lg' }))}>
-          Volver a la tienda
-        </Link>
-        <Link to="/products" className={cn(buttonVariants({ size: 'lg', variant: 'outline' }))}>
-          Seguir comprando
-        </Link>
-      </div>
-    </section>
-  )
-}

package/src/providers/auth.tsx

@@ -1,96 +0,0 @@
-/**
- * Auth storefront: Better Auth client + sesión via context.
- *
- * El framework monta `<AuthProvider>` en `__root` (cliente por defecto).
- * Puedes pasar un `client` propio si necesitas opciones custom.
- *
- * ```tsx
- * const { session, signIn, signOut } = useAuth()
- * ```
- */
-import { createContext, useContext, type ReactNode } from 'react'
-import { createAuthClient } from 'better-auth/react'
-import { ecomiqOAuthPasswordClient } from '../auth/ecomiq-oauth-password-client'
-import {
-  signInWithEcomiqCredentials,
-  type EcomiqSignInCredentials,
-} from '../auth/ecomiq-storefront-sign-in'
-import { AppEcomiqContext } from './ecomiq'
-
-export type CreateStorefrontAuthClientOptions = {
-  baseURL?: string
-  basePath?: string
-}
-
-export function createStorefrontAuthClient(
-  options: CreateStorefrontAuthClientOptions = {},
-) {
-  return createAuthClient({
-    ...options,
-    plugins: [ecomiqOAuthPasswordClient()],
-  })
-}
-
-export type StorefrontAuthClientInstance = ReturnType<typeof createStorefrontAuthClient>
-/** Sesión tipada de Better Auth (`{ user, session }`). */
-export type StorefrontSession = StorefrontAuthClientInstance['$Infer']['Session']
-
-const AuthContext = createContext<StorefrontAuthClientInstance | null>(null)
-
-/** Cliente por defecto del framework (una instancia por bundle). */
-let defaultAuthClient: StorefrontAuthClientInstance | null = null
-
-function getDefaultAuthClient(): StorefrontAuthClientInstance {
-  if (!defaultAuthClient) {
-    defaultAuthClient = createStorefrontAuthClient()
-  }
-  return defaultAuthClient
-}
-
-export function AuthProvider({
-  client,
-  children,
-}: {
-  /** Si se omite, usa el cliente por defecto del storefront. */
-  client?: StorefrontAuthClientInstance
-  children: ReactNode
-}) {
-  return (
-    <AuthContext.Provider value={client ?? getDefaultAuthClient()}>
-      {children}
-    </AuthContext.Provider>
-  )
-}
-
-/** Acceso a sesión y acciones de auth. Requiere `<AuthProvider>` + `<AppEcomiqProvider>`. */
-export function useAuth() {
-  const client = useContext(AuthContext)
-  if (!client) throw new Error('useAuth debe usarse dentro de AuthProvider')
-
-  const sessionQuery = client.useSession()
-  // Mismo módulo que AppEcomiqProvider (no useSettings del barrel) + soft read
-  // para no tumbar el árbol si hay re-render concurrente post-sesión.
-  const ecomiq = useContext(AppEcomiqContext)
-
-  return {
-    client,
-    session: sessionQuery.data,
-    isPending: sessionQuery.isPending,
-    error: sessionQuery.error,
-    signIn: async (credentials: EcomiqSignInCredentials) => {
-      if (!ecomiq) {
-        throw new Error('signIn requiere AppEcomiqProvider')
-      }
-      await signInWithEcomiqCredentials(client, ecomiq.settings, credentials)
-      const result = await client.getSession()
-      const session = (result as { data?: StorefrontSession | null })?.data ?? null
-      if (!session?.user) {
-        throw new Error(
-          'No se pudo establecer la sesión. Revisa cookies / certificado HTTPS e inténtalo de nuevo.',
-        )
-      }
-      return session
-    },
-    signOut: () => client.signOut(),
-  }
-}

package/src/providers/cart.tsx

@@ -1,275 +0,0 @@
-/**
- * Estado de carrito storefront: sesión en localStorage + mutaciones vía serverApi.
- *
- * ```tsx
- * <CartProvider storeId={settings.store.id} currencyCode={settings.store.currency}>
- *   <App />
- * </CartProvider>
- *
- * const { cart, addItem } = useCart()
- * ```
- */
-import {
-  createContext,
-  useContext,
-  useEffect,
-  useRef,
-  useState,
-  type ReactNode,
-} from 'react'
-import { CartTokenSchema, type StorefrontCart } from '@ecomiq/core'
-import { z } from 'zod'
-import { serverApi } from '../server'
-
-const CartSessionSchema = z.object({
-  version: z.literal(1),
-  storeId: z.string().min(1),
-  cartToken: CartTokenSchema,
-})
-
-export type CartLoadStatus = 'loading' | 'ready' | 'error'
-
-export type CartMutation = {
-  kind: 'adding' | 'updating' | 'removing'
-  itemId?: string
-}
-
-export interface CartContextValue {
-  cart: StorefrontCart | null
-  cartToken: string | undefined
-  itemCount: number
-  loadStatus: CartLoadStatus
-  mutation: CartMutation | null
-  error: string | undefined
-  addItem: (input: { variantId: string; quantity: number }) => Promise<StorefrontCart>
-  setItemQuantity: (itemId: string, quantity: number) => Promise<void>
-  removeItem: (itemId: string) => Promise<void>
-  reload: () => Promise<void>
-  clearCart: () => void
-}
-
-const CartContext = createContext<CartContextValue | null>(null)
-
-function sessionKey(storeId: string) {
-  return `ecomiq:cart:v1:${storeId}`
-}
-
-function readCartSession(key: string) {
-  if (typeof localStorage === 'undefined') return undefined
-  const raw = localStorage.getItem(key)
-  if (!raw) return undefined
-  try {
-    const result = CartSessionSchema.safeParse(JSON.parse(raw))
-    return result.success ? result.data : undefined
-  } catch {
-    return undefined
-  }
-}
-
-export function CartProvider({
-  storeId,
-  currencyCode,
-  children,
-}: {
-  storeId: string
-  currencyCode: string
-  children: ReactNode
-}) {
-  const key = sessionKey(storeId)
-  const [cart, setCart] = useState<StorefrontCart | null>(null)
-  const [cartToken, setCartToken] = useState<string>()
-  const [loadStatus, setLoadStatus] = useState<CartLoadStatus>('loading')
-  const [mutation, setMutation] = useState<CartMutation | null>(null)
-  const [error, setError] = useState<string>()
-  const mutationInFlight = useRef(false)
-
-  const persist = (nextCartToken: string) => {
-    setCartToken(nextCartToken)
-    localStorage.setItem(key, JSON.stringify({ version: 1, storeId, cartToken: nextCartToken }))
-  }
-
-  const clear = () => {
-    setCart(null)
-    setCartToken(undefined)
-    localStorage.removeItem(key)
-  }
-
-  const reload = async () => {
-    setLoadStatus('loading')
-    setError(undefined)
-    const stored = readCartSession(key)
-    if (!stored || stored.storeId !== storeId) {
-      clear()
-      setLoadStatus('ready')
-      return
-    }
-
-    setCartToken(stored.cartToken)
-    try {
-      const result = await serverApi.loadCart({ cartToken: stored.cartToken })
-      if (!result.ok) {
-        setError(result.error.message)
-        setLoadStatus('error')
-        return
-      }
-      if (!result.value) {
-        clear()
-      } else {
-        setCart(result.value)
-      }
-      setLoadStatus('ready')
-    } catch {
-      setError('No pudimos cargar el carrito. Inténtalo nuevamente.')
-      setLoadStatus('error')
-    }
-  }
-
-  useEffect(() => {
-    void reload()
-    const sync = (event: StorageEvent) => {
-      if (event.key === key) void reload()
-    }
-    window.addEventListener('storage', sync)
-    return () => window.removeEventListener('storage', sync)
-  }, [key])
-
-  const addItem = async (input: { variantId: string; quantity: number }) => {
-    if (mutationInFlight.current) {
-      const message = 'El carrito se está actualizando. Inténtalo nuevamente.'
-      setError(message)
-      throw new Error(message)
-    }
-
-    mutationInFlight.current = true
-    setMutation({ kind: 'adding' })
-    setError(undefined)
-    try {
-      let result
-      try {
-        result = await serverApi.addProductToCart({
-          cartToken,
-          currencyCode,
-          variantId: input.variantId,
-          quantity: input.quantity,
-        })
-      } catch {
-        const message = 'No pudimos actualizar el carrito. Inténtalo nuevamente.'
-        setError(message)
-        throw new Error(message)
-      }
-
-      if (!result.ok) {
-        setError(result.error.message)
-        throw new Error(result.error.message)
-      }
-
-      setError(undefined)
-      persist(result.value.cartToken)
-      setCart(result.value.cart)
-      return result.value.cart
-    } finally {
-      mutationInFlight.current = false
-      setMutation(null)
-    }
-  }
-
-  const setItemQuantity = async (itemId: string, quantity: number) => {
-    if (!cartToken) {
-      setError('No hay un carrito activo.')
-      return
-    }
-    if (mutationInFlight.current) {
-      setError('El carrito se está actualizando. Inténtalo nuevamente.')
-      return
-    }
-
-    mutationInFlight.current = true
-    setMutation({ kind: 'updating', itemId })
-    setError(undefined)
-    try {
-      let result
-      try {
-        result = await serverApi.setCartItemQuantity({
-          cartToken,
-          cartItemId: itemId,
-          quantity,
-        })
-      } catch {
-        setError('No pudimos actualizar el carrito. Inténtalo nuevamente.')
-        return
-      }
-
-      if (!result.ok) {
-        if (result.error.kind === 'cart-unavailable') clear()
-        setError(result.error.message)
-        return
-      }
-
-      setCart(result.value)
-    } finally {
-      mutationInFlight.current = false
-      setMutation(null)
-    }
-  }
-
-  const removeItem = async (itemId: string) => {
-    if (!cartToken) {
-      setError('No hay un carrito activo.')
-      return
-    }
-    if (mutationInFlight.current) {
-      setError('El carrito se está actualizando. Inténtalo nuevamente.')
-      return
-    }
-
-    mutationInFlight.current = true
-    setMutation({ kind: 'removing', itemId })
-    setError(undefined)
-    try {
-      let result
-      try {
-        result = await serverApi.removeCartItem({
-          cartToken,
-          cartItemId: itemId,
-        })
-      } catch {
-        setError('No pudimos actualizar el carrito. Inténtalo nuevamente.')
-        return
-      }
-
-      if (!result.ok) {
-        if (result.error.kind === 'cart-unavailable') clear()
-        setError(result.error.message)
-        return
-      }
-
-      setCart(result.value)
-    } finally {
-      mutationInFlight.current = false
-      setMutation(null)
-    }
-  }
-
-  const value: CartContextValue = {
-    cart,
-    cartToken,
-    itemCount: cart?.items.reduce((sum, item) => sum + item.quantity, 0) ?? 0,
-    loadStatus,
-    mutation,
-    error,
-    addItem,
-    setItemQuantity,
-    removeItem,
-    reload,
-    clearCart: clear,
-  }
-
-  return <CartContext.Provider value={value}>{children}</CartContext.Provider>
-}
-
-/** Acceso al carrito. Requiere `<CartProvider>` en el layout. */
-export function useCart() {
-  const value = useContext(CartContext)
-  if (!value) throw new Error('useCart debe usarse dentro de CartProvider')
-  return value
-}

package/src/providers/ecomiq.ts

@@ -1,137 +0,0 @@
-/**
- * Provider + hooks públicos de Ecomiq (settings, config, queries).
- */
-import {
-  createContext,
-  createElement,
-  useContext,
-  type ReactNode,
-} from 'react'
-import { hashKey, keepPreviousData, useQuery } from '@tanstack/react-query'
-import { useNavigate } from '@tanstack/react-router'
-import {
-  getMenuItems,
-  type StorefrontMenuItem,
-  type StorefrontSettings,
-} from '@ecomiq/core'
-import type { PublicEcomiqConfig } from '../public-config'
-
-export interface ApiQueryOptions<T> {
-  /** Datos iniciales (ej. los del loader SSR) para render inmediato. */
-  initialData?: T
-  /** Tiempo en ms que los datos se consideran frescos. Default 30s. */
-  freshForMs?: number
-  /** Habilita/deshabilita la consulta. */
-  enabled?: boolean
-  /** Reintentos ante error. Default 1. */
-  retry?: number
-  keepPreviousData?: boolean
-  seed?: { key: readonly unknown[]; data: T }
-}
-
-export interface ApiQueryResult<T> {
-  data: T | undefined
-  isLoading: boolean
-  isRefreshing: boolean
-  error: Error | null
-  refresh: () => void
-}
-
-/**
- * Consulta datos en el cliente con caché y deduplicación automáticas.
- *
- * ```ts
- * const { data, isLoading } = useApiQuery(['products'], () => api.get('/products', schema))
- * ```
- */
-export function useApiQuery<T>(
-  key: readonly unknown[],
-  fetcher: (context: { signal: AbortSignal }) => Promise<T>,
-  options: ApiQueryOptions<T> = {},
-): ApiQueryResult<T> {
-  let initialData = options.initialData
-  if (options.seed && hashKey(options.seed.key) === hashKey(key)) {
-    initialData = options.seed.data
-  }
-  const query = useQuery({
-    queryKey: key,
-    queryFn: ({ signal }) => fetcher({ signal }),
-    initialData,
-    placeholderData: options.keepPreviousData ? keepPreviousData : undefined,
-    staleTime: options.freshForMs ?? 30_000,
-    enabled: options.enabled,
-    retry: options.retry ?? 1,
-  })
-  return {
-    data: query.data,
-    isLoading: query.isPending,
-    isRefreshing: query.isFetching && !query.isPending,
-    error: query.error,
-    refresh: () => void query.refetch(),
-  }
-}
-
-/** Valor único del shell: config local + settings storefront. */
-export interface AppEcomiqValue {
-  config: PublicEcomiqConfig
-  settings: StorefrontSettings
-}
-
-/** Contexto único de la app Ecomiq (lo provee el root generado). */
-export const AppEcomiqContext = createContext<AppEcomiqValue | null>(null)
-
-/**
- * Provider del shell storefront (config + settings).
- *
- * ```tsx
- * <AppEcomiqProvider config={publicConfig} settings={settings}>
- *   <App />
- * </AppEcomiqProvider>
- * ```
- */
-export function AppEcomiqProvider({
-  config,
-  settings,
-  children,
-}: AppEcomiqValue & { children: ReactNode }) {
-  return createElement(
-    AppEcomiqContext.Provider,
-    { value: { config, settings } },
-    children,
-  )
-}
-
-function useAppEcomiq(): AppEcomiqValue {
-  const value = useContext(AppEcomiqContext)
-  if (!value) {
-    throw new Error('Hooks de Ecomiq deben usarse dentro de AppEcomiqProvider')
-  }
-  return value
-}
-
-/** Acceso al ecomiq.config.js resuelto. */
-export function useAppConfig(): PublicEcomiqConfig {
-  return useAppEcomiq().config
-}
-
-/** Acceso a /v1/settings (CMS, store, menus). */
-export function useSettings(): StorefrontSettings {
-  return useAppEcomiq().settings
-}
-
-/** Items de un menú CMS (`main`, `footer`, `account`, …). */
-export function useMenu(key: string): StorefrontMenuItem[] {
-  return getMenuItems(useSettings(), key)
-}
-
-/**
- * Navegación cliente a una ruta con query params (sin full page reload).
- *
- * ```ts
- * const go = useSearchNavigate()
- * go('/products', { sort: 'price_asc', page: 1 })
- * ```
- */
-export function useSearchNavigate() {
-  return useNavigate()
-}

package/src/providers/index.ts

@@ -1,26 +0,0 @@
-export {
-  AppEcomiqContext,
-  AppEcomiqProvider,
-  useApiQuery,
-  useAppConfig,
-  useSettings,
-  useMenu,
-  useSearchNavigate,
-  type AppEcomiqValue,
-  type ApiQueryOptions,
-  type ApiQueryResult,
-} from './ecomiq'
-export {
-  CartProvider,
-  useCart,
-  type CartContextValue,
-  type CartLoadStatus,
-  type CartMutation,
-} from './cart'
-export {
-  AuthProvider,
-  createStorefrontAuthClient,
-  useAuth,
-  type StorefrontAuthClientInstance,
-  type StorefrontSession,
-} from './auth'

package/src/proxy-api.ts

@@ -1,20 +0,0 @@
-import { createApi, type Api } from '@ecomiq/core'
-
-/**
- * Cliente HTTP hacia el BFF same-origin (`/api/*`).
- * El proxy inyecta `x-Store-Id` y el Bearer desde la cookie OAuth
- * (`ecomiq_sf_oauth_at`, path `/api`).
- *
- * Usar con los services de `@ecomiq/core` (p. ej. `getCustomerAddresses(api)`).
- * `version` vacío: el path del proxy ya es `/api/...` (el upstream añade `/v1`).
- */
-export function createStorefrontProxyApi(): Api {
-  const origin =
-    typeof window !== 'undefined' && window.location?.origin
-      ? window.location.origin
-      : 'http://localhost'
-  return createApi({
-    baseUrl: `${origin}/api`,
-    version: '',
-  })
-}

package/src/public-config.ts

@@ -1,24 +0,0 @@
-export interface EcomiqThemeConfig {
-  primary?: string
-  primaryForeground?: string
-  background?: string
-  foreground?: string
-  accent?: string
-  radius?: string
-}
-
-/**
- * Proyección pública de ecomiq.config.js (seguro para el bundle cliente).
- * Nombre, SEO, analytics y menús viven en `/v1/settings`.
- */
-export interface PublicEcomiqConfig {
-  /**
-   * Identidad de tienda para `x-Store-Domain`.
-   * Acepta slug corto o dominio completo, p. ej. `marketplace`,
-   * `marketplace.ecomiq.app` o `marketplace.pe`.
-   */
-  domain: string
-  theme?: EcomiqThemeConfig
-}
-
-export type EcomiqConfig = PublicEcomiqConfig