@ecomiq/storefront 2.1.4 → 3.0.1

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

package/src/review-submission.ts

@@ -1,89 +0,0 @@
-import type {
-  CreateProductReviewParams,
-  StorefrontReview,
-} from '@ecomiq/core'
-import { ApiError } from '@ecomiq/core'
-import { z } from 'zod'
-
-const ReviewProblemSchema = z.object({
-  code: z.string().max(120).regex(/^[A-Za-z0-9._-]+$/).optional(),
-})
-
-interface ProductReviewClient {
-  createProductReview(
-    params: CreateProductReviewParams,
-  ): Promise<StorefrontReview>
-}
-
-export interface ProductReviewSubmissionError {
-  status: 400 | 409 | 429 | 500
-  code?: string
-  message: string
-}
-
-export type ProductReviewSubmissionResult =
-  | {
-      ok: true
-      review: StorefrontReview
-    }
-  | {
-      ok: false
-      error: ProductReviewSubmissionError
-    }
-
-export async function submitProductReview(
-  client: ProductReviewClient,
-  input: CreateProductReviewParams,
-): Promise<ProductReviewSubmissionResult> {
-  try {
-    const review = await client.createProductReview(input)
-    return { ok: true, review }
-  } catch (error) {
-    if (!(error instanceof ApiError)) throw error
-
-    let code: string | undefined
-    const problem = ReviewProblemSchema.safeParse(error.body)
-    if (problem.success) code = problem.data.code
-
-    if (error.status === 400) {
-      let message = 'Revisa los datos de la reseña e inténtalo nuevamente.'
-      if (
-        code === 'ProductReview.OrderInvalid' ||
-        code === 'ProductReview.OrderOwnerMismatch' ||
-        code === 'ProductReview.ProductNotPurchased'
-      ) {
-        message = 'No pudimos verificar la compra con los datos ingresados.'
-      }
-      return { ok: false, error: { status: 400, code, message } }
-    }
-
-    if (error.status === 409) {
-      let message = 'No pudimos registrar esta reseña porque ya existe una similar.'
-      if (code === 'ProductReview.AlreadyExists') {
-        message = 'Ya enviaste una reseña para este producto.'
-      }
-      return { ok: false, error: { status: 409, code, message } }
-    }
-
-    if (error.status === 429) {
-      return {
-        ok: false,
-        error: {
-          status: 429,
-          code,
-          message:
-            'Enviaste varias reseñas en poco tiempo. Espera un momento e inténtalo nuevamente.',
-        },
-      }
-    }
-
-    return {
-      ok: false,
-      error: {
-        status: 500,
-        code,
-        message: 'No pudimos enviar la reseña. Inténtalo nuevamente.',
-      },
-    }
-  }
-}

package/src/runtime/context.ts

@@ -1,2 +0,0 @@
-export { AppEcomiqContext, AppEcomiqProvider, type AppEcomiqValue } from '../providers/ecomiq'
-export { AuthProvider } from '../providers/auth'