@ecomiq/storefront 2.1.4 → 3.0.0

package/src/cart-session.ts

@@ -1,239 +0,0 @@
-import {
-  ApiError,
-  type RemoveCartItemParams,
-  type StorefrontCart,
-  type StorefrontClient,
-  type UpdateCartItemQuantityParams,
-} from '@ecomiq/core'
-import { z } from 'zod'
-
-type CartClient = Pick<StorefrontClient, 'getCart' | 'createCart' | 'addCartItem'>
-
-export interface LoadActiveCartInput {
-  cartToken: string
-}
-
-export type ActiveCartLoadResult =
-  | { ok: true; value: StorefrontCart | null }
-  | {
-      ok: false
-      error: {
-        kind: 'failed'
-        message: string
-      }
-    }
-
-export type CartItemMutationResult =
-  | { ok: true; value: StorefrontCart }
-  | {
-      ok: false
-      error: {
-        kind: 'cart-unavailable' | 'unavailable' | 'failed'
-        message: string
-      }
-    }
-
-export interface AddProductToCartInput {
-  cartToken?: string
-  currencyCode: string
-  variantId: string
-  quantity: number
-}
-
-export interface AddProductToCartResult {
-  cartToken: string
-  cart: StorefrontCart
-  created: boolean
-}
-
-export type ProductCartMutationResult =
-  | { ok: true; value: AddProductToCartResult }
-  | {
-      ok: false
-      error: {
-        kind: 'unavailable' | 'failed'
-        message: string
-      }
-    }
-
-const StorefrontProblemSchema = z.object({
-  code: z.string().optional(),
-}).passthrough()
-
-function cartIsUnavailable(error: unknown) {
-  if (!(error instanceof ApiError)) return false
-  const problem = StorefrontProblemSchema.safeParse(error.body)
-  if (!problem.success) return false
-  if (error.status === 404 && problem.data.code === 'Carts.NotFound') return true
-  return error.status === 400 && problem.data.code === 'Carts.NotActive'
-}
-
-function cartIsActive(cart: StorefrontCart) {
-  return cart.status === 'inProgress' || cart.status === 'pending'
-}
-
-function cartItemMutationFailure(error: ApiError): CartItemMutationResult {
-  if (cartIsUnavailable(error)) {
-    return {
-      ok: false,
-      error: {
-        kind: 'cart-unavailable',
-        message: 'Este carrito ya no está disponible.',
-      },
-    }
-  }
-
-  const problem = StorefrontProblemSchema.safeParse(error.body)
-  if (problem.success && problem.data.code === 'Catalog.InsufficientStock') {
-    return {
-      ok: false,
-      error: {
-        kind: 'unavailable',
-        message: 'No hay stock suficiente para esa cantidad.',
-      },
-    }
-  }
-  if (problem.success && problem.data.code === 'Carts.ItemNotFound') {
-    return {
-      ok: false,
-      error: {
-        kind: 'unavailable',
-        message: 'Este producto ya no está en el carrito.',
-      },
-    }
-  }
-
-  return {
-    ok: false,
-    error: {
-      kind: 'failed',
-      message: 'No pudimos actualizar el carrito. Inténtalo nuevamente.',
-    },
-  }
-}
-
-export async function loadActiveCart(
-  client: Pick<StorefrontClient, 'getCart'>,
-  input: LoadActiveCartInput,
-): Promise<ActiveCartLoadResult> {
-  try {
-    const cart = await client.getCart({ cartToken: input.cartToken })
-    return { ok: true as const, value: cartIsActive(cart) ? cart : null }
-  } catch (error) {
-    if (cartIsUnavailable(error)) return { ok: true as const, value: null }
-    if (error instanceof ApiError) {
-      return {
-        ok: false,
-        error: {
-          kind: 'failed',
-          message: 'No pudimos cargar el carrito. Inténtalo nuevamente.',
-        },
-      }
-    }
-    throw error
-  }
-}
-
-export async function submitCartItemQuantity(
-  client: Pick<StorefrontClient, 'updateCartItemQuantity'>,
-  input: UpdateCartItemQuantityParams,
-): Promise<CartItemMutationResult> {
-  try {
-    const cart = await client.updateCartItemQuantity(input)
-    return { ok: true, value: cart }
-  } catch (error) {
-    if (!(error instanceof ApiError)) throw error
-    return cartItemMutationFailure(error)
-  }
-}
-
-export async function submitCartItemRemoval(
-  client: Pick<StorefrontClient, 'updateCartItemQuantity'>,
-  input: RemoveCartItemParams,
-): Promise<CartItemMutationResult> {
-  try {
-    const cart = await client.updateCartItemQuantity({ ...input, quantity: 0 })
-    return { ok: true, value: cart }
-  } catch (error) {
-    if (!(error instanceof ApiError)) throw error
-    return cartItemMutationFailure(error)
-  }
-}
-
-export async function addProductToCart(
-  client: CartClient,
-  input: AddProductToCartInput,
-): Promise<AddProductToCartResult> {
-  let current: StorefrontCart | undefined
-  let created = false
-
-  if (input.cartToken) {
-    try {
-      const persisted = await client.getCart({ cartToken: input.cartToken })
-      if (cartIsActive(persisted)) current = persisted
-    } catch (error) {
-      if (!cartIsUnavailable(error)) throw error
-    }
-  }
-
-  if (!current) {
-    current = await client.createCart({ currencyCode: input.currencyCode })
-    created = true
-  }
-
-  const add = (cartToken: string) => client.addCartItem({
-    cartToken,
-    variantId: input.variantId,
-    quantity: input.quantity,
-  })
-
-  try {
-    const cart = await add(current.token)
-    return { cartToken: cart.token, cart, created }
-  } catch (error) {
-    if (!cartIsUnavailable(error)) throw error
-    const replacement = await client.createCart({ currencyCode: input.currencyCode })
-    const cart = await add(replacement.token)
-    return { cartToken: cart.token, cart, created: true }
-  }
-}
-
-export async function submitProductToCart(
-  client: CartClient,
-  input: AddProductToCartInput,
-): Promise<ProductCartMutationResult> {
-  try {
-    return { ok: true, value: await addProductToCart(client, input) }
-  } catch (error) {
-    if (!(error instanceof ApiError)) throw error
-
-    const problem = StorefrontProblemSchema.safeParse(error.body)
-    const code = problem.success ? problem.data.code : undefined
-    if (code === 'Catalog.InsufficientStock') {
-      return {
-        ok: false,
-        error: {
-          kind: 'unavailable',
-          message: 'No hay stock suficiente para esa cantidad.',
-        },
-      }
-    }
-    if (code === 'Catalog.VariantNotFound') {
-      return {
-        ok: false,
-        error: {
-          kind: 'unavailable',
-          message: 'Esta variante ya no está disponible.',
-        },
-      }
-    }
-
-    return {
-      ok: false,
-      error: {
-        kind: 'failed',
-        message: 'No pudimos actualizar el carrito. Inténtalo nuevamente.',
-      },
-    }
-  }
-}

package/src/client.ts

@@ -1,48 +0,0 @@
-import {
-  createClient as createCoreClient,
-  type CreateApiOptions,
-  type StorefrontClient,
-} from '@ecomiq/core/client'
-import { getServerConfig } from './server-config-store'
-
-let sharedClient: StorefrontClient | null = null
-
-/** Cliente storefront compartido (cache de settings incluido). */
-export function getStorefrontClient(options: CreateApiOptions = {}): StorefrontClient {
-  if (!sharedClient) {
-    const config = getServerConfig()
-    const headers = {
-      ...config.api?.headers,
-      ...options.headers,
-    }
-    for (const key of Object.keys(headers)) {
-      const lower = key.toLowerCase()
-      if (lower === 'x-store-id' || lower === 'x-store-domain') delete headers[key]
-    }
-    sharedClient = createCoreClient({
-      domain: config.domain,
-      ...config.api,
-      ...options,
-      headers,
-    })
-  }
-  return sharedClient
-}
-
-/** Invalida el singleton (tests / hot reload). */
-export function resetStorefrontClient(): void {
-  sharedClient?.clearCache()
-  sharedClient = null
-}
-
-/**
- * Cliente storefront. Domain y defaults de API salen del config de la tienda.
- *
- * ```ts
- * export const api = createClient()
- * const collections = await api.getCollections()
- * ```
- */
-export function createClient(_options: CreateApiOptions = {}): StorefrontClient {
-  return getStorefrontClient(_options)
-}