@open-mercato/core 0.9.1-develop.7473.1.de5b22888f → 0.9.1-develop.7475.1.28ca93ed97

package/dist/modules/ecommerce/lib/storefrontProducts.js

@@ -0,0 +1,670 @@
+import { findWithDecryption } from "@open-mercato/shared/lib/encryption/find";
+import { sanitizeSearchTerm } from "@open-mercato/shared/lib/query/sanitizeSearchTerm";
+import { SortDir } from "@open-mercato/shared/lib/query/types";
+import { E } from "../../../generated/entities.ids.generated.js";
+import {
+  CatalogProductCategory,
+  CatalogProductCategoryAssignment,
+  CatalogProductPrice,
+  CatalogProductTag,
+  CatalogProductTagAssignment,
+  CatalogProductVariant
+} from "@open-mercato/core/modules/catalog/data/entities";
+import {
+  buildProductFilters,
+  scoreProductSearchRelevance
+} from "@open-mercato/core/modules/catalog/lib/productFilters";
+import {
+  STOREFRONT_FACET_UNIVERSE_CAP,
+  countStorefrontFacets,
+  labelStorefrontCountFacets,
+  loadStorefrontFacetSource,
+  loadStorefrontProductTypeLabeler,
+  readCachedStorefrontCountFacets,
+  storefrontAvailabilityFacet,
+  storefrontFacetTranslationRequests,
+  storefrontFacetVariantIndex,
+  storefrontPriceRangeFacet,
+  writeCachedStorefrontCountFacets
+} from "./storefrontFacets.js";
+import { buildStorefrontProductScope, composeStorefrontProductFilters } from "./storefrontProductScope.js";
+import { resolveStorefrontPrices } from "./storefrontPricing.js";
+import { queryStorefrontOptionProductIds } from "./storefrontOptionFilter.js";
+import {
+  STOREFRONT_CATEGORY_ENTITY_TYPE,
+  STOREFRONT_PRODUCT_ENTITY_TYPE,
+  STOREFRONT_TAG_ENTITY_TYPE,
+  buildStorefrontListItem,
+  isCategoryInAssortment,
+  selectCategoriesWithActiveAncestors,
+  loadStorefrontTranslations,
+  localeChain,
+  nonEmptyString,
+  referenceId,
+  resolvePublicDefaultMediaUrls,
+  resolveStorefrontAvailability,
+  storefrontAvailabilityKey,
+  stringList,
+  toStorefrontAvailability,
+  tryResolve
+} from "./storefrontCatalogSupport.js";
+import { isCategoryInAssortment as isCategoryInAssortment2 } from "./storefrontCatalogSupport.js";
+const STOREFRONT_PRICE_SORT_CAP = 5e3;
+const STOREFRONT_APPROXIMATE_SORT_CEILING = 5e4;
+const APPROXIMATE_PRICE_CHUNK = 1e3;
+const NO_MATCH_ID = "00000000-0000-0000-0000-000000000000";
+const LIST_FIELDS = [
+  "id",
+  "title",
+  "subtitle",
+  "handle",
+  "sku",
+  "product_type",
+  "is_configurable",
+  "default_media_id",
+  "default_media_url",
+  "created_at"
+];
+const CANDIDATE_FIELDS = ["id", "title", "sku"];
+const SORT_ORDER = [
+  "relevance",
+  "price_asc",
+  "price_desc",
+  "title_asc",
+  "title_desc",
+  "newest",
+  "featured"
+];
+const EMPTY_COUNT_FACETS = { categories: [], tags: [], options: [], productTypes: [] };
+function isPriceSort(sort) {
+  return sort === "price_asc" || sort === "price_desc";
+}
+function sqlSortFor(sort) {
+  switch (sort) {
+    case "title_desc":
+      return [{ field: "title", dir: SortDir.Desc }];
+    case "newest":
+    case "featured":
+      return [{ field: "created_at", dir: SortDir.Desc }];
+    default:
+      return [{ field: "title", dir: SortDir.Asc }];
+  }
+}
+async function resolveCategoryFilter(runtime, query) {
+  if (!query.categoryId && !query.categorySlug) return null;
+  const { ctx } = runtime;
+  const where = {
+    tenantId: ctx.tenantId,
+    organizationId: ctx.organizationId,
+    deletedAt: null,
+    isActive: true,
+    ...query.categoryId ? { id: query.categoryId } : { slug: query.categorySlug }
+  };
+  const [category] = await findWithDecryption(
+    runtime.em,
+    CatalogProductCategory,
+    where,
+    { fields: ["id", "slug", "ancestorIds", "descendantIds"], limit: 1 },
+    runtime.decryptionScope
+  );
+  if (!category) return null;
+  const lineage = {
+    id: category.id,
+    ancestorIds: stringList(category.ancestorIds),
+    descendantIds: stringList(category.descendantIds)
+  };
+  if (!isCategoryInAssortment(lineage, ctx.buyer.assortmentScope)) return null;
+  const { visibleIds } = await selectCategoriesWithActiveAncestors(runtime.em, ctx, [lineage]);
+  if (!visibleIds.has(category.id)) return null;
+  return { id: category.id, slug: category.slug ?? null };
+}
+async function resolveTagFilter(runtime, slugs) {
+  if (!slugs?.length) return [];
+  const { ctx } = runtime;
+  const tags = await findWithDecryption(
+    runtime.em,
+    CatalogProductTag,
+    { tenantId: ctx.tenantId, organizationId: ctx.organizationId, slug: { $in: slugs } },
+    { fields: ["id", "slug"] },
+    runtime.decryptionScope
+  );
+  const bySlug = new Map(tags.map((tag) => [tag.slug, tag.id]));
+  return slugs.flatMap((slug) => {
+    const id = bySlug.get(slug);
+    return id ? [{ id, slug }] : [];
+  });
+}
+const OPTION_FILTER_OVER_CAP = "over_cap";
+async function resolveOptionProductIds(runtime, options) {
+  if (!options) return null;
+  const ids = await queryStorefrontOptionProductIds(
+    runtime.em,
+    runtime.decryptionScope,
+    options,
+    runtime.facetUniverseCap ?? STOREFRONT_FACET_UNIVERSE_CAP
+  );
+  return ids ?? OPTION_FILTER_OVER_CAP;
+}
+async function productFilterClause(runtime, filterQuery) {
+  return buildStorefrontProductFilterClause(runtime.container, runtime.ctx, filterQuery);
+}
+async function buildStorefrontProductFilterClause(container, ctx, filterQuery) {
+  const crudCtx = {
+    container,
+    auth: { sub: "ecommerce:storefront", tenantId: ctx.tenantId, orgId: ctx.organizationId },
+    organizationScope: null,
+    selectedOrganizationId: ctx.organizationId,
+    organizationIds: [ctx.organizationId]
+  };
+  const productFilters = await buildProductFilters({ page: 1, pageSize: 1, ...filterQuery }, crudCtx, {
+    includeCategoryDescendants: true
+  });
+  return Object.keys(productFilters).length ? productFilters : null;
+}
+function andClauses(clauses) {
+  const present = clauses.filter((clause) => clause !== null);
+  if (present.length === 0) return null;
+  return present.length === 1 ? present[0] : { $and: present };
+}
+async function resolveListFilters(runtime, query) {
+  const applied = {};
+  const searchTerm = sanitizeSearchTerm(query.search);
+  const [category, resolvedTags, optionProductIds] = await Promise.all([
+    resolveCategoryFilter(runtime, query),
+    resolveTagFilter(runtime, query.tagSlugs),
+    resolveOptionProductIds(runtime, query.options)
+  ]);
+  if (searchTerm) applied.search = searchTerm;
+  if (category) applied.category = { id: category.id, slug: category.slug, includesDescendants: true };
+  if (resolvedTags.length) applied.tagSlugs = resolvedTags.map((tag) => tag.slug);
+  if (query.productType) applied.productType = query.productType;
+  const optionsApplied = Array.isArray(optionProductIds);
+  if (optionsApplied && query.options) applied.options = query.options;
+  const [searchClause, facetClause] = await Promise.all([
+    searchTerm ? productFilterClause(runtime, { search: searchTerm }) : Promise.resolve(null),
+    category || resolvedTags.length || query.productType ? productFilterClause(runtime, {
+      categoryIds: category?.id,
+      tagIds: resolvedTags.length ? resolvedTags.map((tag) => tag.id).join(",") : void 0,
+      productType: query.productType
+    }) : Promise.resolve(null)
+  ]);
+  const optionClause = Array.isArray(optionProductIds) ? optionProductIds.length ? { id: { $in: optionProductIds } } : { id: { $eq: NO_MATCH_ID } } : null;
+  return {
+    extra: andClauses([searchClause, facetClause, optionClause]),
+    universe: searchClause,
+    selection: {
+      categoryId: category?.id ?? null,
+      tagIds: resolvedTags.map((tag) => tag.id),
+      productType: query.productType ?? null,
+      options: optionsApplied ? query.options ?? {} : {}
+    },
+    applied,
+    searchTerm: searchTerm || null
+  };
+}
+async function queryCandidates(runtime, filters, sort, pageSize) {
+  const result = await runtime.queryEngine.query(E.catalog.catalog_product, {
+    tenantId: runtime.scope.tenantId,
+    organizationId: runtime.scope.organizationId,
+    withDeleted: runtime.scope.withDeleted,
+    filters,
+    fields: CANDIDATE_FIELDS,
+    sort,
+    page: { page: 1, pageSize: Math.max(1, pageSize) }
+  });
+  const items = result.items.filter((item) => typeof item.id === "string").map((item) => ({ id: item.id, title: nonEmptyString(item.title) ?? "", sku: nonEmptyString(item.sku) }));
+  return { items, total: result.total };
+}
+async function queryProductsByIds(runtime, ids) {
+  if (!ids.length) return [];
+  const result = await runtime.queryEngine.query(E.catalog.catalog_product, {
+    tenantId: runtime.scope.tenantId,
+    organizationId: runtime.scope.organizationId,
+    withDeleted: runtime.scope.withDeleted,
+    filters: composeStorefrontProductFilters(runtime.scope, { id: { $in: ids } }),
+    fields: LIST_FIELDS,
+    page: { page: 1, pageSize: ids.length }
+  });
+  const byId = new Map(result.items.map((item) => [item.id, item]));
+  return ids.map((id) => byId.get(id)).filter((item) => !!item);
+}
+async function loadVariantIds(runtime, productIds) {
+  const byProduct = /* @__PURE__ */ new Map();
+  if (!productIds.length) return byProduct;
+  const { ctx } = runtime;
+  const variants = await findWithDecryption(
+    runtime.em,
+    CatalogProductVariant,
+    {
+      tenantId: ctx.tenantId,
+      organizationId: ctx.organizationId,
+      deletedAt: null,
+      isActive: true,
+      product: { $in: productIds }
+    },
+    { fields: ["id", "product"] },
+    runtime.decryptionScope
+  );
+  for (const variant of variants) {
+    const productId = referenceId(variant.product);
+    if (!productId) continue;
+    const bucket = byProduct.get(productId) ?? [];
+    bucket.push(variant.id);
+    byProduct.set(productId, bucket);
+  }
+  return byProduct;
+}
+async function loadCategories(runtime, productIds) {
+  const candidates = /* @__PURE__ */ new Map();
+  const { ctx } = runtime;
+  const assignments = await findWithDecryption(
+    runtime.em,
+    CatalogProductCategoryAssignment,
+    { tenantId: ctx.tenantId, organizationId: ctx.organizationId, product: { $in: productIds } },
+    { populate: ["category"], orderBy: { position: "asc" } },
+    runtime.decryptionScope
+  );
+  const categoryIds = /* @__PURE__ */ new Set();
+  for (const assignment of assignments) {
+    const productId = referenceId(assignment.product);
+    const category = typeof assignment.category === "object" ? assignment.category : null;
+    if (!productId || !category || category.deletedAt || category.isActive === false) continue;
+    const lineage = {
+      id: category.id,
+      ancestorIds: stringList(category.ancestorIds),
+      descendantIds: stringList(category.descendantIds)
+    };
+    if (!isCategoryInAssortment(lineage, ctx.buyer.assortmentScope)) continue;
+    const bucket = candidates.get(productId) ?? [];
+    if (bucket.some((entry) => entry.id === category.id)) continue;
+    bucket.push({ id: category.id, name: category.name, slug: category.slug ?? null, ancestorIds: lineage.ancestorIds });
+    candidates.set(productId, bucket);
+    categoryIds.add(category.id);
+  }
+  const allCandidates = Array.from(candidates.values()).flat();
+  const { visibleIds: visible } = await selectCategoriesWithActiveAncestors(runtime.em, ctx, allCandidates, {
+    activeIds: categoryIds
+  });
+  const byProduct = /* @__PURE__ */ new Map();
+  for (const [productId, bucket] of candidates) {
+    const refs = bucket.filter((entry) => visible.has(entry.id)).map(({ id, name, slug }) => ({ id, name, slug }));
+    if (refs.length > 0) byProduct.set(productId, refs);
+  }
+  return { byProduct, categoryIds: Array.from(categoryIds).filter((id) => visible.has(id)) };
+}
+async function loadTags(runtime, productIds) {
+  const byProduct = /* @__PURE__ */ new Map();
+  const { ctx } = runtime;
+  const assignments = await findWithDecryption(
+    runtime.em,
+    CatalogProductTagAssignment,
+    { tenantId: ctx.tenantId, organizationId: ctx.organizationId, product: { $in: productIds } },
+    { populate: ["tag"] },
+    runtime.decryptionScope
+  );
+  const tagIds = /* @__PURE__ */ new Set();
+  for (const assignment of assignments) {
+    const productId = referenceId(assignment.product);
+    const tag = typeof assignment.tag === "object" ? assignment.tag : null;
+    if (!productId || !tag) continue;
+    const bucket = byProduct.get(productId) ?? [];
+    if (bucket.some((entry) => entry.id === tag.id)) continue;
+    bucket.push({ id: tag.id, label: tag.label });
+    byProduct.set(productId, bucket);
+    tagIds.add(tag.id);
+  }
+  return { byProduct, tagIds: Array.from(tagIds) };
+}
+async function resolvePageAvailability(runtime, productIds) {
+  const results = /* @__PURE__ */ new Map();
+  if (!productIds.length) return results;
+  const targets = productIds.map((productId) => ({ productId, variantId: null }));
+  const resolved = await resolveStorefrontAvailability(runtime.container, runtime.ctx, runtime.em, targets);
+  for (const target of targets) {
+    const entry = resolved.get(storefrontAvailabilityKey(target));
+    results.set(target.productId, {
+      result: entry?.result ?? null,
+      hideWhenOutOfStock: entry?.policy?.hideWhenOutOfStock?.value === true
+    });
+  }
+  return results;
+}
+const IN_STOCK_STATES = /* @__PURE__ */ new Set(["in_stock", "low_stock", "not_tracked"]);
+function matchesAvailabilityFilter(availability, filter) {
+  if (filter === "in_stock") return IN_STOCK_STATES.has(availability.state) && availability.canFulfil;
+  if (filter === "available") return availability.state !== "out_of_stock" && availability.canFulfil;
+  return true;
+}
+async function hydratePage(runtime, records, query, prefetch, extraTranslations) {
+  const { ctx, container } = runtime;
+  if (!records.length) {
+    const translations2 = extraTranslations.length ? await loadStorefrontTranslations(runtime.em, ctx, extraTranslations) : /* @__PURE__ */ new Map();
+    return { items: [], availabilityStates: [], translations: translations2 };
+  }
+  const productIds = records.map((record) => record.id);
+  const [variantsByProduct, categories, tags] = await Promise.all([
+    prefetch.variants ?? loadVariantIds(runtime, productIds),
+    loadCategories(runtime, productIds),
+    loadTags(runtime, productIds)
+  ]);
+  const [pricing, translations, availability, mediaUrls] = await Promise.all([
+    prefetch.pricing ?? resolveStorefrontPrices(
+      container,
+      ctx,
+      productIds.map((productId) => ({ productId, variantIds: variantsByProduct.get(productId) ?? [] })),
+      { date: runtime.date }
+    ),
+    loadStorefrontTranslations(runtime.em, ctx, [
+      { entityType: STOREFRONT_PRODUCT_ENTITY_TYPE, ids: productIds },
+      { entityType: STOREFRONT_CATEGORY_ENTITY_TYPE, ids: categories.categoryIds },
+      { entityType: STOREFRONT_TAG_ENTITY_TYPE, ids: tags.tagIds },
+      ...extraTranslations
+    ]),
+    resolvePageAvailability(runtime, productIds),
+    resolvePublicDefaultMediaUrls(
+      runtime.em,
+      ctx,
+      records.map((record) => ({
+        id: record.id,
+        defaultMediaId: record.default_media_id,
+        defaultMediaUrl: record.default_media_url
+      }))
+    )
+  ]);
+  const locales = localeChain(ctx);
+  const productTranslations = translations.get(STOREFRONT_PRODUCT_ENTITY_TYPE);
+  const categoryTranslations = translations.get(STOREFRONT_CATEGORY_ENTITY_TYPE);
+  const tagTranslations = translations.get(STOREFRONT_TAG_ENTITY_TYPE);
+  const items = [];
+  const availabilityStates = [];
+  for (const record of records) {
+    const productAvailability = availability.get(record.id);
+    const storefrontAvailability = toStorefrontAvailability(productAvailability?.result ?? null);
+    if (productAvailability?.hideWhenOutOfStock && storefrontAvailability.state === "out_of_stock") continue;
+    availabilityStates.push(storefrontAvailability.state);
+    if (!matchesAvailabilityFilter(storefrontAvailability, query.availability)) continue;
+    items.push(
+      buildStorefrontListItem(
+        {
+          id: record.id,
+          handle: record.handle,
+          title: record.title,
+          subtitle: record.subtitle,
+          defaultMediaUrl: mediaUrls.get(record.id) ?? null,
+          productType: record.product_type,
+          isConfigurable: record.is_configurable
+        },
+        {
+          locales,
+          overlay: productTranslations?.get(record.id),
+          variantCount: variantsByProduct.get(record.id)?.length ?? 0,
+          categories: categories.byProduct.get(record.id) ?? [],
+          categoryTranslations,
+          tags: tags.byProduct.get(record.id) ?? [],
+          tagTranslations,
+          pricing: pricing.get(record.id),
+          availability: storefrontAvailability
+        }
+      )
+    );
+  }
+  return { items, availabilityStates, translations };
+}
+function pricingAmount(pricing) {
+  if (!pricing) return null;
+  return pricing.price?.amount ?? pricing.priceRange?.min ?? null;
+}
+function parseAmount(value) {
+  if (value === null || value === void 0 || value === "") return null;
+  const numeric = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(numeric) ? numeric : null;
+}
+function chunk(values, size) {
+  const chunks = [];
+  for (let index = 0; index < values.length; index += size) chunks.push(values.slice(index, index + size));
+  return chunks;
+}
+async function loadApproximateAmounts(runtime, productIds) {
+  const { ctx } = runtime;
+  const amounts = /* @__PURE__ */ new Map();
+  const priceKindId = ctx.channel?.priceKindId ?? null;
+  if (!priceKindId || !productIds.length) return amounts;
+  const rows = [];
+  for (const ids of chunk(productIds, APPROXIMATE_PRICE_CHUNK)) {
+    rows.push(
+      ...await findWithDecryption(
+        runtime.em,
+        CatalogProductPrice,
+        {
+          tenantId: ctx.tenantId,
+          organizationId: ctx.organizationId,
+          priceKind: priceKindId,
+          currencyCode: ctx.currencyCode,
+          customerId: null,
+          customerGroupId: null,
+          userId: null,
+          userGroupId: null,
+          $or: [{ product: { $in: ids } }, { variant: { product: { $in: ids } } }]
+        },
+        { populate: ["variant"] },
+        runtime.decryptionScope
+      )
+    );
+  }
+  const wantedIds = new Set(productIds);
+  const channelId = ctx.channel?.salesChannelId ?? null;
+  const now = runtime.date;
+  for (const row of rows) {
+    if (row.channelId && row.channelId !== channelId) continue;
+    if ((row.minQuantity ?? 1) > 1) continue;
+    if (row.startsAt && row.startsAt > now) continue;
+    if (row.endsAt && row.endsAt < now) continue;
+    const productId = referenceId(row.product) ?? (row.variant && typeof row.variant === "object" ? referenceId(row.variant.product) : null);
+    if (!productId || !wantedIds.has(productId)) continue;
+    const wanted = parseAmount(ctx.buyer.taxMode === "gross" ? row.unitPriceGross : row.unitPriceNet);
+    const amount = wanted ?? parseAmount(ctx.buyer.taxMode === "gross" ? row.unitPriceNet : row.unitPriceGross);
+    if (amount === null) continue;
+    const current = amounts.get(productId);
+    if (current === void 0 || amount < current) amounts.set(productId, amount);
+  }
+  return amounts;
+}
+function compareAmounts(left, right, direction) {
+  if (left === null && right === null) return 0;
+  if (left === null) return 1;
+  if (right === null) return -1;
+  return (left - right) * direction;
+}
+function rankByRelevance(items, searchTerm) {
+  const needle = searchTerm.toLowerCase();
+  return items.map((item, index) => ({ item, index, score: scoreProductSearchRelevance(needle, item.title, item.sku) })).sort((left, right) => left.score - right.score || left.item.title.localeCompare(right.item.title) || left.index - right.index).map((entry) => entry.item);
+}
+function matchesPriceFilter(amount, query) {
+  if (amount === null) return false;
+  if (query.priceMin !== void 0 && amount < query.priceMin) return false;
+  if (query.priceMax !== void 0 && amount > query.priceMax) return false;
+  return true;
+}
+function availableSortsFor(searchTerm, priceSortsOffered) {
+  return SORT_ORDER.filter((sort) => {
+    if (sort === "relevance") return !!searchTerm;
+    if (isPriceSort(sort)) return priceSortsOffered;
+    return true;
+  });
+}
+async function resolveCountFacetState(runtime, selection, searchTerm, universe) {
+  const cached = await readCachedStorefrontCountFacets(runtime.container, runtime.ctx, selection, searchTerm);
+  if (cached) return { cached, source: null, overCap: false };
+  const source = await loadStorefrontFacetSource(
+    runtime,
+    composeStorefrontProductFilters(runtime.scope, universe),
+    runtime.facetUniverseCap
+  );
+  return { cached: null, source, overCap: source === null };
+}
+async function listStorefrontProducts(container, ctx, query, options = {}) {
+  const em = tryResolve(container, "em");
+  const queryEngine = tryResolve(container, "queryEngine");
+  if (!em || !queryEngine) throw new Error("[internal] ecommerce storefront listing requires em and queryEngine");
+  const scope = buildStorefrontProductScope(ctx);
+  const runtime = {
+    container,
+    ctx,
+    em,
+    queryEngine,
+    scope,
+    decryptionScope: { tenantId: ctx.tenantId, organizationId: ctx.organizationId },
+    date: options.date ?? /* @__PURE__ */ new Date(),
+    facetUniverseCap: options.facetUniverseCap
+  };
+  const cap = Math.max(1, options.priceSortCap ?? STOREFRONT_PRICE_SORT_CAP);
+  const approximateCeiling = Math.max(cap, options.approximateSortCeiling ?? STOREFRONT_APPROXIMATE_SORT_CEILING);
+  const channelFallback = ctx.channel?.priceSortFallback ?? "approximate";
+  const { page, pageSize } = query;
+  const { extra, universe, selection, applied, searchTerm } = await resolveListFilters(runtime, query);
+  const filters = composeStorefrontProductFilters(scope, extra);
+  if (query.availability === "in_stock" || query.availability === "available") {
+    applied.availability = { value: query.availability, scope: "page" };
+  }
+  const defaultSort = searchTerm ? "relevance" : "featured";
+  const requestedSort = query.sort ?? defaultSort;
+  const priceSortRequested = isPriceSort(requestedSort);
+  const priceFilterRequested = query.priceMin !== void 0 || query.priceMax !== void 0;
+  const baseSort = priceSortRequested || requestedSort === "relevance" ? "title_asc" : requestedSort;
+  const [countFacetState, first] = await Promise.all([
+    resolveCountFacetState(runtime, selection, searchTerm, universe),
+    queryCandidates(runtime, filters, sqlSortFor(baseSort), cap)
+  ]);
+  const facetVariants = countFacetState.source ? storefrontFacetVariantIndex(countFacetState.source) : null;
+  const capExceeded = first.total > cap;
+  const fallback = capExceeded && first.total > approximateCeiling ? "unavailable" : channelFallback;
+  const priceOnOffer = !capExceeded || fallback === "approximate";
+  let sortApproximate = false;
+  let sortUnavailable = false;
+  let appliedSort = requestedSort === "relevance" && !searchTerm ? defaultSort : requestedSort;
+  let total = 0;
+  let records = [];
+  let prefetch = {};
+  let candidates = null;
+  let amounts = null;
+  if (!capExceeded) {
+    candidates = first.items;
+    const candidateIds = candidates.map((candidate) => candidate.id);
+    const variants = facetVariants ? new Map(candidateIds.map((id) => [id, facetVariants.get(id) ?? []])) : await loadVariantIds(runtime, candidateIds);
+    const pricing = await resolveStorefrontPrices(
+      container,
+      ctx,
+      candidateIds.map((id) => ({ productId: id, variantIds: variants.get(id) ?? [] })),
+      { date: runtime.date }
+    );
+    prefetch = { variants, pricing };
+    amounts = new Map(candidateIds.map((id) => [id, pricingAmount(pricing.get(id))]));
+  } else if (priceOnOffer && (priceSortRequested || priceFilterRequested)) {
+    const all = await queryCandidates(runtime, filters, sqlSortFor(baseSort), first.total);
+    const approximate = await loadApproximateAmounts(runtime, all.items.map((candidate) => candidate.id));
+    amounts = new Map(all.items.map((candidate) => [candidate.id, approximate.get(candidate.id) ?? null]));
+    candidates = all.items;
+  }
+  const priceRange = amounts ? storefrontPriceRangeFacet(amounts.values(), ctx.currencyCode) : null;
+  if (priceFilterRequested && priceOnOffer) {
+    applied.price = { min: query.priceMin ?? null, max: query.priceMax ?? null, approximate: capExceeded };
+  }
+  if (priceSortRequested && !priceOnOffer) {
+    sortUnavailable = true;
+    appliedSort = defaultSort;
+  }
+  if (candidates) {
+    let ordered = priceFilterRequested && priceOnOffer ? candidates.filter((candidate) => matchesPriceFilter(amounts?.get(candidate.id) ?? null, query)) : candidates;
+    if (appliedSort === "relevance" && searchTerm) {
+      ordered = rankByRelevance(ordered, searchTerm);
+    } else if (isPriceSort(appliedSort)) {
+      const direction = appliedSort === "price_asc" ? 1 : -1;
+      ordered = ordered.map((candidate, index) => ({ candidate, index })).sort(
+        (left, right) => compareAmounts(amounts?.get(left.candidate.id) ?? null, amounts?.get(right.candidate.id) ?? null, direction) || left.index - right.index
+      ).map((entry) => entry.candidate);
+      sortApproximate = capExceeded;
+    }
+    total = ordered.length;
+    const pageIds = ordered.slice((page - 1) * pageSize, page * pageSize).map((candidate) => candidate.id);
+    records = await queryProductsByIds(runtime, pageIds);
+  } else {
+    const sqlOrder = appliedSort === "relevance" ? "title_asc" : appliedSort;
+    const result = await runtime.queryEngine.query(E.catalog.catalog_product, {
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId,
+      withDeleted: scope.withDeleted,
+      filters,
+      fields: LIST_FIELDS,
+      sort: sqlSortFor(sqlOrder),
+      page: { page, pageSize }
+    });
+    total = result.total;
+    records = result.items.filter((item) => typeof item.id === "string");
+    if (appliedSort === "relevance" && searchTerm) {
+      records = rankByRelevance(
+        records.map((record) => ({ record, title: nonEmptyString(record.title) ?? "", sku: nonEmptyString(record.sku) })),
+        searchTerm
+      ).map((entry) => entry.record);
+      sortApproximate = true;
+    }
+    if (facetVariants) prefetch = { variants: new Map(records.map((record) => [record.id, facetVariants.get(record.id) ?? []])) };
+  }
+  const availableSorts = availableSortsFor(searchTerm, !(capExceeded && fallback === "unavailable"));
+  const { source, cached, overCap } = countFacetState;
+  const rawCounts = source ? countStorefrontFacets(source, selection) : null;
+  const hydrated = await hydratePage(
+    runtime,
+    records,
+    query,
+    prefetch,
+    source && rawCounts ? storefrontFacetTranslationRequests(source, rawCounts) : []
+  );
+  let countFacets = cached ?? EMPTY_COUNT_FACETS;
+  if (source && rawCounts) {
+    countFacets = labelStorefrontCountFacets(source, rawCounts, {
+      locales: localeChain(ctx),
+      translations: hydrated.translations,
+      assortmentScope: ctx.buyer.assortmentScope,
+      productTypeLabel: await loadStorefrontProductTypeLabeler(ctx.effectiveLocale)
+    });
+    await writeCachedStorefrontCountFacets(container, ctx, selection, searchTerm, countFacets);
+  } else if (overCap) {
+    await writeCachedStorefrontCountFacets(container, ctx, selection, searchTerm, EMPTY_COUNT_FACETS);
+  }
+  const facets = {
+    categories: countFacets.categories,
+    tags: countFacets.tags,
+    priceRange,
+    options: countFacets.options,
+    productTypes: countFacets.productTypes,
+    availability: storefrontAvailabilityFacet(hydrated.availabilityStates),
+    availabilityScope: "page",
+    total
+  };
+  return {
+    items: hydrated.items,
+    total,
+    page,
+    pageSize,
+    totalPages: Math.ceil(total / pageSize),
+    facets,
+    effectiveLocale: ctx.effectiveLocale,
+    requestedLocale: ctx.requestedLocale,
+    currencyCode: ctx.currencyCode,
+    taxMode: ctx.buyer.taxMode,
+    appliedFilters: applied,
+    availableSorts,
+    appliedSort,
+    priceSort: { cap, fallback, capExceeded },
+    sortApproximate,
+    sortUnavailable
+  };
+}
+export {
+  STOREFRONT_APPROXIMATE_SORT_CEILING,
+  STOREFRONT_PRICE_SORT_CAP,
+  buildStorefrontProductFilterClause,
+  isCategoryInAssortment2 as isCategoryInAssortment,
+  listStorefrontProducts
+};
+//# sourceMappingURL=storefrontProducts.js.map