@ecomiq/storefront 2.0.22 → 2.1.3

package/src/server.ts

@@ -58,8 +58,8 @@ import {
   type RemoveCartItemParams,
   type UpdateCartItemQuantityParams,
   type UploadPaymentReceiptParams,
+  CartTokenSchema,
   EntityIdSchema,
-  OptionalEntityIdSchema,
 } from '@ecomiq/core'
 import { z } from 'zod'
 import { getStorefrontClient } from './client'
@@ -71,7 +71,10 @@ import {
   type AddProductToCartInput,
 } from './cart-session'
 import { submitProductReview } from './review-submission'
-import { loadActiveStorefrontHome } from './storefront-runtime'
+import {
+  loadActiveStorefrontHome,
+  loadActiveStorefrontPage,
+} from './storefront-runtime'
 
 const getSettingsFn = createServerFn({ method: 'GET' }).handler(() =>
   getStorefrontClient().getSettings(),
@@ -81,6 +84,10 @@ const getActiveStorefrontHomeFn = createServerFn({ method: 'GET' }).handler(
   () => loadActiveStorefrontHome(),
 )
 
+const getActiveStorefrontPageFn = createServerFn({ method: 'GET' })
+  .validator(z.object({ pathname: z.string().min(1).max(2_048) }))
+  .handler(({ data }) => loadActiveStorefrontPage(data.pathname))
+
 const getStoreIdFn = createServerFn({ method: 'GET' }).handler(() =>
   getStorefrontClient().getStoreId(),
 )
@@ -140,9 +147,9 @@ const removeCartItemFn = createServerFn({ method: 'POST' })
   .handler(({ data }) => submitCartItemRemoval(getStorefrontClient(), data))
 
 const AddProductToCartServerSchema = z.object({
-  cartId: OptionalEntityIdSchema,
+  cartToken: CartTokenSchema.optional(),
   currencyCode: z.string().length(3),
-  variantId: z.string().regex(/^[1-9]\d*$/),
+  variantId: EntityIdSchema,
   quantity: z.number().int().positive(),
 })
 
@@ -179,7 +186,7 @@ const checkoutCartFn = createServerFn({ method: 'POST' })
   .handler(({ data }) => getStorefrontClient().checkoutCart(data))
 
 const CartPaymentReceiptServerSchema = z.object({
-  cartId: EntityIdSchema,
+  cartToken: CartTokenSchema,
   fileBase64: z.string().min(1),
   fileName: z.string().min(1),
   mimeType: z.string().min(1).optional(),
@@ -191,7 +198,7 @@ const uploadPaymentReceiptFn = createServerFn({ method: 'POST' })
     const binary = Uint8Array.from(atob(data.fileBase64), (c) => c.charCodeAt(0))
     const file = new Blob([binary], { type: data.mimeType ?? 'application/octet-stream' })
     return getStorefrontClient().uploadPaymentReceipt({
-      cartId: data.cartId,
+      cartToken: data.cartToken,
       file,
       fileName: data.fileName,
     })
@@ -228,6 +235,8 @@ const getDistrictsFn = createServerFn({ method: 'GET' })
 export const serverApi = {
   getSettings: () => getSettingsFn(),
   getActiveStorefrontHome: () => getActiveStorefrontHomeFn(),
+  getActiveStorefrontPage: (pathname: string) =>
+    getActiveStorefrontPageFn({ data: { pathname } }),
   getStoreId: () => getStoreIdFn(),
   getCollections: () => getCollectionsFn(),
   getCollectionBySlug: (slug: string) => getCollectionBySlugFn({ data: { slug } }),
@@ -271,7 +280,7 @@ export const serverApi = {
     for (const byte of bytes) binary += String.fromCharCode(byte)
     return uploadPaymentReceiptFn({
       data: {
-        cartId: params.cartId,
+        cartToken: params.cartToken,
         fileBase64: btoa(binary),
         fileName:
           params.fileName ??

package/src/storefront-definition/data.ts

@@ -0,0 +1,188 @@
+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
+}