@ecomiq/storefront 2.1.3 → 2.1.4

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()
-}

package/src/storefront-definition/contract.ts

@@ -1 +0,0 @@
-export * from '@ecomiq/storefront-definition'

package/src/storefront-definition/data.ts

@@ -1,188 +0,0 @@
-import type {
-  Collection,
-  Collections,
-  ProductsParamsInput,
-  ProductsResponse,
-  ProductSummary,
-} from '@ecomiq/core'
-import {
-  type CollectionGridStorefrontSection,
-  type ProductGridStorefrontSection,
-  type StorefrontDefinition,
-} from '@ecomiq/storefront-definition'
-import { storefrontPageFor } from './renderer'
-import type { DefinitionData } from './renderer'
-
-const MAX_UNIQUE_PRODUCT_SOURCES = 12
-const MANUAL_PRODUCT_PAGE_SIZE = 100
-const MAX_MANUAL_PRODUCT_SCAN_PAGES = 5
-
-export interface StorefrontRuntimeCatalogClient {
-  getProducts(params?: ProductsParamsInput): Promise<ProductsResponse>
-  getCollections(): Promise<Collections>
-}
-
-export interface ResolvedStorefrontDefinitionData
-  extends DefinitionData {
-  productsBySectionId: Record<string, ProductSummary[]>
-  collectionsBySectionId: Record<string, Collection[]>
-}
-
-export function emptyRendererData(): ResolvedStorefrontDefinitionData {
-  return {
-    productsBySectionId: {},
-    collectionsBySectionId: {},
-  }
-}
-
-function productSourceKey(
-  section: ProductGridStorefrontSection,
-): string | null {
-  if (section.source.kind === 'manual') return null
-  if (section.source.kind === 'collection') {
-    return `collection:${section.source.slug}`
-  }
-  return 'all'
-}
-
-async function loadProductSource(
-  section: ProductGridStorefrontSection,
-  client: StorefrontRuntimeCatalogClient,
-): Promise<ProductSummary[]> {
-  const params: ProductsParamsInput = {
-    page: 1,
-    pageSize: section.limit,
-    sort: 'newest',
-  }
-  if (section.source.kind === 'collection') {
-    params.collection = section.source.slug
-  }
-  const response = await client.getProducts(params)
-  return response.products.slice(0, section.limit)
-}
-
-async function scanManualProducts(
-  productIds: ReadonlySet<string>,
-  client: StorefrontRuntimeCatalogClient,
-): Promise<Map<string, ProductSummary>> {
-  const found = new Map<string, ProductSummary>()
-
-  for (let page = 1; page <= MAX_MANUAL_PRODUCT_SCAN_PAGES; page += 1) {
-    const response = await client.getProducts({
-      page,
-      pageSize: MANUAL_PRODUCT_PAGE_SIZE,
-      sort: 'newest',
-    })
-    for (const product of response.products) {
-      if (productIds.has(product.id)) found.set(product.id, product)
-    }
-
-    if (
-      found.size === productIds.size ||
-      page >= response.totalPages ||
-      response.products.length === 0
-    ) {
-      break
-    }
-  }
-
-  return found
-}
-
-export async function resolveStorefrontDefinitionData(
-  definition: StorefrontDefinition,
-  client: StorefrontRuntimeCatalogClient,
-  pageId?: string,
-): Promise<ResolvedStorefrontDefinitionData> {
-  const data = emptyRendererData()
-  const page = storefrontPageFor(definition, pageId)
-  const sections = page?.sections ?? []
-  const productSections = sections.filter(
-    (section): section is ProductGridStorefrontSection =>
-      section.enabled && section.type === 'product-grid',
-  )
-  const collectionSections = sections.filter(
-    (section): section is CollectionGridStorefrontSection =>
-      section.enabled && section.type === 'collection-grid',
-  )
-
-  const sourceSections = new Map<string, ProductGridStorefrontSection>()
-  for (const section of productSections) {
-    const sourceKey = productSourceKey(section)
-    if (!sourceKey) continue
-    const current = sourceSections.get(sourceKey)
-    if (current) {
-      if (section.limit > current.limit) sourceSections.set(sourceKey, section)
-      continue
-    }
-    if (sourceSections.size >= MAX_UNIQUE_PRODUCT_SOURCES) continue
-    sourceSections.set(sourceKey, section)
-  }
-
-  const sourceRequests = new Map<string, Promise<ProductSummary[]>>()
-  for (const [sourceKey, section] of sourceSections) {
-    sourceRequests.set(
-      sourceKey,
-      loadProductSource(section, client).catch(() => []),
-    )
-  }
-
-  const manualIds = new Set(
-    productSections.flatMap((section) =>
-      section.source.kind === 'manual' ? section.source.productIds : [],
-    ),
-  )
-  const manualProducts =
-    manualIds.size > 0
-      ? scanManualProducts(manualIds, client).catch(
-          () => new Map<string, ProductSummary>(),
-        )
-      : Promise.resolve(new Map<string, ProductSummary>())
-
-  await Promise.all(
-    productSections.map(async (section) => {
-      if (section.source.kind === 'manual') {
-        const productsById = await manualProducts
-        data.productsBySectionId[section.id] = section.source.productIds
-          .map((productId) => productsById.get(productId))
-          .filter(
-            (product): product is ProductSummary => product !== undefined,
-          )
-          .slice(0, section.limit)
-        return
-      }
-
-      const sourceKey = productSourceKey(section)
-      const products = sourceKey
-        ? await (sourceRequests.get(sourceKey) ?? Promise.resolve([]))
-        : []
-      data.productsBySectionId[section.id] = products.slice(0, section.limit)
-    }),
-  )
-
-  if (collectionSections.length > 0) {
-    const collections = await client.getCollections().catch(() => [])
-    const collectionsBySlug = new Map(
-      collections.map((collection) => [collection.slug, collection]),
-    )
-
-    for (const section of collectionSections) {
-      if (section.source.kind === 'manual') {
-        data.collectionsBySectionId[section.id] = section.source.slugs
-          .map((slug) => collectionsBySlug.get(slug))
-          .filter(
-            (collection): collection is Collection =>
-              collection !== undefined,
-          )
-          .slice(0, section.limit)
-        continue
-      }
-      data.collectionsBySectionId[section.id] = collections.slice(
-        0,
-        section.limit,
-      )
-    }
-  }
-
-  return data
-}

package/src/storefront-definition/index.ts

@@ -1,2 +0,0 @@
-export * from './contract'
-export * from './renderer'