@ecomiq/storefront 2.1.3 → 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)
-}

package/src/cloud-runtime-client.ts

@@ -1,378 +0,0 @@
-import { z } from 'zod'
-import { StorefrontDefinitionSchema } from '@ecomiq/storefront-definition'
-
-export const CloudRuntimeStoreSlugSchema = z
-  .string()
-  .trim()
-  .min(2)
-  .max(100)
-  .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/)
-
-export const ActiveStorefrontRuntimeSchema = z
-  .object({
-    schemaVersion: z.literal(1),
-    store: z
-      .object({
-        slug: CloudRuntimeStoreSlugSchema,
-      })
-      .strict(),
-    environment: z
-      .object({
-        name: z.literal('production'),
-        status: z.literal('ready'),
-      })
-      .strict(),
-    publication: z
-      .object({
-        sequence: z.number().int().nonnegative(),
-        releaseSequence: z.number().int().nonnegative(),
-        publishedAt: z.string().datetime({ offset: true }),
-        runtimeReleaseId: z.string().optional(),
-        artifactDigest: z.string().optional(),
-      })
-      .strict(),
-    definition: StorefrontDefinitionSchema,
-  })
-  .strict()
-
-export type ActiveStorefrontRuntime = z.infer<
-  typeof ActiveStorefrontRuntimeSchema
->
-
-export const EnvironmentPointerSchema = z
-  .object({
-    schemaVersion: z.literal(1),
-    storeSlug: CloudRuntimeStoreSlugSchema,
-    projectId: z.string().min(1),
-    environmentId: z.string().min(1),
-    generation: z.number().int().nonnegative(),
-    releaseSequence: z.number().int().nonnegative(),
-    deploymentSequence: z.number().int().nonnegative(),
-    artifactDigest: z.string().min(1),
-    artifactKey: z.string().min(1),
-    manifestDigest: z.string().min(1),
-    manifestKey: z.string().min(1),
-    runtimeReleaseId: z.string().min(1),
-    publishedAt: z.string().datetime({ offset: true }),
-    cachePolicy: z
-      .object({
-        pointerMaxAgeSeconds: z.number().int().nonnegative(),
-        staleIfErrorSeconds: z.number().int().nonnegative(),
-      })
-      .strict(),
-  })
-  .strict()
-
-export type EnvironmentPointer = z.infer<typeof EnvironmentPointerSchema>
-
-export type CloudRuntimeFetch = (
-  input: RequestInfo | URL,
-  init?: RequestInit,
-) => Promise<Response>
-
-export interface CloudRuntimeClientOptions {
-  baseUrl: string
-  artifactBaseUrl?: string
-  timeoutMs?: number
-  cacheTtlMs?: number
-  fetch?: CloudRuntimeFetch
-  now?: () => number
-}
-
-interface RuntimeCacheEntry {
-  value: ActiveStorefrontRuntime | null
-  etag?: string
-  expiresAt: number
-}
-
-export class CloudRuntimeResponseError extends Error {
-  readonly status: number
-
-  constructor(status: number) {
-    super(`Cloud runtime respondió HTTP ${status}`)
-    this.name = 'CloudRuntimeResponseError'
-    this.status = status
-  }
-}
-
-const DEFAULT_TIMEOUT_MS = 3_000
-const DEFAULT_CACHE_TTL_MS = 15_000
-const MAX_CACHE_ENTRIES = 100
-
-interface LastKnownGood {
-  runtime: ActiveStorefrontRuntime
-  generation: number
-}
-
-export class CloudRuntimeClient {
-  readonly baseUrl: string
-  readonly artifactBaseUrl: string | null
-  readonly timeoutMs: number
-  readonly cacheTtlMs: number
-
-  private readonly fetchRuntime: CloudRuntimeFetch
-  private readonly now: () => number
-  private readonly cache = new Map<string, RuntimeCacheEntry>()
-  private readonly lastKnownGood = new Map<string, LastKnownGood>()
-  private readonly artifactCache = new Map<string, ActiveStorefrontRuntime>()
-  private readonly inFlight = new Map<
-    string,
-    Promise<ActiveStorefrontRuntime | null>
-  >()
-
-  constructor(options: CloudRuntimeClientOptions) {
-    this.baseUrl = new URL(options.baseUrl).toString().replace(/\/$/, '')
-    this.artifactBaseUrl = options.artifactBaseUrl
-      ? new URL(options.artifactBaseUrl).toString().replace(/\/$/, '')
-      : null
-    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS
-    this.cacheTtlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS
-    this.fetchRuntime = options.fetch ?? globalThis.fetch
-    this.now = options.now ?? Date.now
-  }
-
-  async resolveActiveStorefront(
-    storeSlugInput: string,
-  ): Promise<ActiveStorefrontRuntime | null> {
-    const storeSlug = CloudRuntimeStoreSlugSchema.parse(storeSlugInput)
-    const cached = this.cache.get(storeSlug)
-    if (cached && cached.expiresAt > this.now()) {
-      return cached.value
-    }
-
-    const activeRequest = this.inFlight.get(storeSlug)
-    if (activeRequest) return activeRequest
-
-    const request = (
-      this.artifactBaseUrl
-        ? this.requestFromArtifactStore(storeSlug)
-        : this.requestActiveStorefront(storeSlug, cached)
-    ).finally(() => {
-      this.inFlight.delete(storeSlug)
-    })
-    this.inFlight.set(storeSlug, request)
-    return request
-  }
-
-  clearCache(): void {
-    this.cache.clear()
-    this.lastKnownGood.clear()
-    this.artifactCache.clear()
-    this.inFlight.clear()
-  }
-
-  private async requestFromArtifactStore(
-    storeSlug: string,
-  ): Promise<ActiveStorefrontRuntime | null> {
-    const survivor = this.lastKnownGood.get(storeSlug)
-    let pointer: EnvironmentPointer | null
-    try {
-      pointer = await this.fetchPointer(storeSlug)
-    } catch {
-      if (survivor) return survivor.runtime
-      throw new CloudRuntimeResponseError(503)
-    }
-
-    if (pointer === null) {
-      if (survivor) return survivor.runtime
-      this.setCache(storeSlug, {
-        value: null,
-        expiresAt: this.now() + this.cacheTtlMs,
-      })
-      return null
-    }
-
-    if (survivor && pointer.generation < survivor.generation) {
-      this.setCache(storeSlug, {
-        value: survivor.runtime,
-        expiresAt: this.now() + this.cacheTtlMs,
-      })
-      return survivor.runtime
-    }
-
-    let runtime: ActiveStorefrontRuntime
-    try {
-      runtime = await this.fetchArtifactRuntime(pointer)
-    } catch {
-      if (survivor) return survivor.runtime
-      throw new CloudRuntimeResponseError(503)
-    }
-
-    if (runtime.store.slug !== storeSlug) {
-      throw new Error(
-        `El pointer de ${storeSlug} apunta a un artifact de ${runtime.store.slug}`,
-      )
-    }
-
-    const ttlMs = pointer.cachePolicy.pointerMaxAgeSeconds * 1_000
-    this.setCache(storeSlug, {
-      value: runtime,
-      expiresAt: this.now() + (ttlMs > 0 ? ttlMs : this.cacheTtlMs),
-    })
-    this.lastKnownGood.set(storeSlug, {
-      runtime,
-      generation: pointer.generation,
-    })
-    return runtime
-  }
-
-  private async fetchPointer(
-    storeSlug: string,
-  ): Promise<EnvironmentPointer | null> {
-    const response = await this.fetchWithTimeout(
-      `${this.artifactBaseUrl}/stores/${encodeURIComponent(storeSlug)}/pointer.json`,
-    )
-    if (response.status === 404) return null
-    if (!response.ok) throw new CloudRuntimeResponseError(response.status)
-    return EnvironmentPointerSchema.parse(await response.json())
-  }
-
-  private async fetchArtifactRuntime(
-    pointer: EnvironmentPointer,
-  ): Promise<ActiveStorefrontRuntime> {
-    const cached = this.artifactCache.get(pointer.artifactKey)
-    const base =
-      cached ?? (await this.requestArtifactBody(pointer.artifactKey))
-    if (!cached) {
-      if (this.artifactCache.size >= MAX_CACHE_ENTRIES) {
-        const oldestKey = this.artifactCache.keys().next().value
-        if (oldestKey !== undefined) this.artifactCache.delete(oldestKey)
-      }
-      this.artifactCache.set(pointer.artifactKey, base)
-    }
-    return {
-      ...base,
-      publication: {
-        sequence: pointer.deploymentSequence,
-        releaseSequence: pointer.releaseSequence,
-        publishedAt: pointer.publishedAt,
-        runtimeReleaseId: pointer.runtimeReleaseId,
-        artifactDigest: pointer.artifactDigest,
-      },
-    }
-  }
-
-  private async requestArtifactBody(
-    artifactKey: string,
-  ): Promise<ActiveStorefrontRuntime> {
-    const response = await this.fetchWithTimeout(
-      `${this.artifactBaseUrl}/${artifactKey}`,
-    )
-    if (!response.ok) throw new CloudRuntimeResponseError(response.status)
-    return ActiveStorefrontRuntimeSchema.parse(await response.json())
-  }
-
-  private async fetchWithTimeout(url: string): Promise<Response> {
-    const controller = new AbortController()
-    const timeout = setTimeout(() => controller.abort(), this.timeoutMs)
-    try {
-      return await this.fetchRuntime(url, {
-        method: 'GET',
-        headers: { accept: 'application/json' },
-        signal: controller.signal,
-      })
-    } finally {
-      clearTimeout(timeout)
-    }
-  }
-
-  private setCache(storeSlug: string, entry: RuntimeCacheEntry): void {
-    if (!this.cache.has(storeSlug) && this.cache.size >= MAX_CACHE_ENTRIES) {
-      const oldestKey = this.cache.keys().next().value
-      if (oldestKey !== undefined) this.cache.delete(oldestKey)
-    }
-    this.cache.set(storeSlug, entry)
-  }
-
-  private async requestActiveStorefront(
-    storeSlug: string,
-    cached?: RuntimeCacheEntry,
-  ): Promise<ActiveStorefrontRuntime | null> {
-    const controller = new AbortController()
-    const timeout = setTimeout(() => controller.abort(), this.timeoutMs)
-    const headers = new Headers({ accept: 'application/json' })
-    if (cached?.etag) headers.set('if-none-match', cached.etag)
-
-    try {
-      const response = await this.fetchRuntime(
-        new URL(
-          `/v1/runtime/storefronts/${encodeURIComponent(storeSlug)}`,
-          this.baseUrl,
-        ),
-        {
-          method: 'GET',
-          headers,
-          signal: controller.signal,
-        },
-      )
-
-      if (response.status === 304) {
-        if (!cached) throw new CloudRuntimeResponseError(304)
-        this.setCache(storeSlug, {
-          ...cached,
-          expiresAt: this.now() + this.cacheTtlMs,
-        })
-        return cached.value
-      }
-
-      if (response.status === 404) {
-        this.setCache(storeSlug, {
-          value: null,
-          etag: response.headers.get('etag') ?? undefined,
-          expiresAt: this.now() + this.cacheTtlMs,
-        })
-        return null
-      }
-
-      if (!response.ok) {
-        throw new CloudRuntimeResponseError(response.status)
-      }
-
-      const runtime = ActiveStorefrontRuntimeSchema.parse(
-        await response.json(),
-      )
-      if (runtime.store.slug !== storeSlug) {
-        throw new Error(
-          `Cloud runtime devolvió el store slug ${runtime.store.slug} para ${storeSlug}`,
-        )
-      }
-
-      this.setCache(storeSlug, {
-        value: runtime,
-        etag: response.headers.get('etag') ?? undefined,
-        expiresAt: this.now() + this.cacheTtlMs,
-      })
-      return runtime
-    } finally {
-      clearTimeout(timeout)
-    }
-  }
-}
-
-const sharedClients = new Map<string, CloudRuntimeClient>()
-
-export function getCloudRuntimeClient(
-  options: Omit<CloudRuntimeClientOptions, 'fetch' | 'now'>,
-): CloudRuntimeClient {
-  const key = [
-    new URL(options.baseUrl).toString(),
-    options.artifactBaseUrl ? new URL(options.artifactBaseUrl).toString() : '',
-    options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-    options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS,
-  ].join('|')
-  const current = sharedClients.get(key)
-  if (current) return current
-
-  const client = new CloudRuntimeClient(options)
-  if (sharedClients.size >= 8) {
-    const oldestKey = sharedClients.keys().next().value
-    if (oldestKey !== undefined) sharedClients.delete(oldestKey)
-  }
-  sharedClients.set(key, client)
-  return client
-}
-
-export function resetCloudRuntimeClients(): void {
-  for (const client of sharedClients.values()) client.clearCache()
-  sharedClients.clear()
-}