simplycms 0.4.0

package/dist/chunk-BDKJ3ITL.js

@@ -0,0 +1,1311 @@
+import { withActor } from 'simplycms/db';
+import { getRequest } from '@tanstack/react-start/server';
+import { readSessionSubject } from 'simplycms/auth';
+import { and, eq, asc, inArray, sql, lte, isNull, desc, or, count, exists } from 'drizzle-orm';
+import { banners, products, sections, productModifications, productPrices, sectionProperties, propertyOptions, productPropertyValues, orderStatuses, orderItems, orders, profiles, userCategories, discounts, discountTargets, discountConditions, discountGroups, priceTypes, sectionPropertyAssignments, modificationPropertyValues, stockByPickupPoint, shippingMethods, userAddresses, pickupPoints, userRecipients, productReviews, shippingZones, shippingRates } from 'simplycms/schema';
+import { calculateProductAvailability } from 'simplycms/domain/inventory';
+import { randomUUID } from 'crypto';
+
+// src/storefront/loaders/db.ts
+function withStorefrontDb(fn) {
+  return withActor({ role: "app_user" }, (db) => fn(db));
+}
+function withCustomerDb(userId, fn) {
+  return withActor({ role: "app_user", userId }, (db) => fn(db));
+}
+function withOrderTokenDb(orderToken, fn) {
+  return withActor({ role: "app_user", orderToken }, (db) => fn(db));
+}
+function withStoreOperatorDb(fn) {
+  return withActor({ role: "app_admin" }, (db) => fn(db));
+}
+async function withSessionDb(fn) {
+  const userId = await requireSessionUserId();
+  return withCustomerDb(userId, (db) => fn(db, userId));
+}
+async function requireSessionUserId() {
+  const subject = await readSessionSubject(getRequest().headers);
+  if (!subject) {
+    throw new Error(
+      "[simplycms] Sign-in required: no session for this request."
+    );
+  }
+  return subject.userId;
+}
+async function optionalSessionUserId() {
+  const subject = await readSessionSubject(getRequest().headers);
+  return subject?.userId ?? null;
+}
+var bannerColumns = {
+  id: banners.id,
+  title: banners.title,
+  subtitle: banners.subtitle,
+  image_url: banners.imageUrl,
+  desktop_image_url: banners.desktopImageUrl,
+  mobile_image_url: banners.mobileImageUrl,
+  buttons: banners.buttons,
+  placement: banners.placement,
+  section_id: banners.sectionId,
+  sort_order: banners.sortOrder,
+  is_active: banners.isActive,
+  date_from: banners.dateFrom,
+  date_to: banners.dateTo,
+  schedule_days: banners.scheduleDays,
+  schedule_time_from: banners.scheduleTimeFrom,
+  schedule_time_to: banners.scheduleTimeTo,
+  slide_duration: banners.slideDuration,
+  animation_type: banners.animationType,
+  animation_duration: banners.animationDuration,
+  overlay_color: banners.overlayColor,
+  text_position: banners.textPosition,
+  created_at: banners.createdAt,
+  updated_at: banners.updatedAt
+};
+function toBanner(row) {
+  return {
+    ...row,
+    buttons: Array.isArray(row.buttons) ? row.buttons.filter(isBannerButton) : [],
+    schedule_days: Array.isArray(row.schedule_days) ? row.schedule_days : null
+  };
+}
+function isBannerButton(item) {
+  if (typeof item !== "object" || item === null) return false;
+  const obj = item;
+  return typeof obj.text === "string" && typeof obj.url === "string" && typeof obj.target === "string" && typeof obj.variant === "string";
+}
+function isBannerVisible(banner, now) {
+  if (banner.date_from && new Date(banner.date_from) > now) return false;
+  if (banner.date_to && new Date(banner.date_to) < now) return false;
+  if (banner.schedule_days?.length && !banner.schedule_days.includes(now.getDay()))
+    return false;
+  if (banner.schedule_time_from && banner.schedule_time_to) {
+    const hh = String(now.getHours()).padStart(2, "0");
+    const mm = String(now.getMinutes()).padStart(2, "0");
+    const current = `${hh}:${mm}`;
+    if (current < banner.schedule_time_from || current > banner.schedule_time_to)
+      return false;
+  }
+  return true;
+}
+
+// src/storefront/loaders/banners.ts
+async function loadBanners(db, query) {
+  const scoped = query.sectionId ? and(
+    eq(banners.isActive, true),
+    eq(banners.placement, query.placement),
+    eq(banners.sectionId, query.sectionId)
+  ) : and(eq(banners.isActive, true), eq(banners.placement, query.placement));
+  const rows = await db.select(bannerColumns).from(banners).where(scoped).orderBy(asc(banners.sortOrder));
+  const now = /* @__PURE__ */ new Date();
+  return rows.map(toBanner).filter((banner) => isBannerVisible(banner, now));
+}
+async function loadUserCategoryId(db, userId) {
+  const [row] = await db.select({ category_id: profiles.categoryId }).from(profiles).where(eq(profiles.userId, userId)).limit(1);
+  return row?.category_id ?? null;
+}
+async function loadDefaultUserCategoryId(db) {
+  const [row] = await db.select({ id: userCategories.id }).from(userCategories).where(eq(userCategories.isDefault, true)).limit(1);
+  return row?.id ?? null;
+}
+
+// src/storefront/loaders/entities/discount.ts
+function toDiscountGroupNode(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    operator: row.operator,
+    is_active: row.isActive,
+    priority: row.priority,
+    starts_at: row.startsAt,
+    ends_at: row.endsAt,
+    discounts: [],
+    children: []
+  };
+}
+function toDiscount(row, targets, conditions) {
+  return {
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    discount_type: row.discountType,
+    discount_value: Number(row.discountValue),
+    priority: row.priority,
+    is_active: row.isActive,
+    starts_at: row.startsAt,
+    ends_at: row.endsAt,
+    targets: targets.filter((target) => target.discountId === row.id).map((target) => ({
+      id: target.id,
+      target_type: target.targetType,
+      target_id: target.targetId
+    })),
+    conditions: conditions.filter((condition) => condition.discountId === row.id).map(toDiscountCondition)
+  };
+}
+function toDiscountCondition(row) {
+  return {
+    id: row.id,
+    condition_type: row.conditionType,
+    operator: row.operator,
+    value: row.value
+  };
+}
+
+// src/storefront/loaders/discounts.ts
+var PARENT_DEPTH_LIMIT = 8;
+async function loadDiscountGroups(db, priceTypeId) {
+  const rows = await db.select().from(discounts).where(
+    and(eq(discounts.priceTypeId, priceTypeId), eq(discounts.isActive, true))
+  );
+  if (rows.length === 0) return [];
+  const ids = rows.map((row) => row.id);
+  const targets = await db.select().from(discountTargets).where(inArray(discountTargets.discountId, ids));
+  const conditions = await db.select().from(discountConditions).where(inArray(discountConditions.discountId, ids));
+  const groups = await loadGroupClosure(
+    db,
+    Array.from(new Set(rows.map((row) => row.groupId)))
+  );
+  const nodes = new Map(
+    groups.map((row) => [row.id, toDiscountGroupNode(row)])
+  );
+  for (const row of rows) {
+    nodes.get(row.groupId)?.discounts.push(toDiscount(row, targets, conditions));
+  }
+  const roots = [];
+  for (const row of groups) {
+    const node = nodes.get(row.id);
+    if (!node) continue;
+    const parent = row.parentGroupId ? nodes.get(row.parentGroupId) : void 0;
+    if (parent) parent.children.push(node);
+    else roots.push(node);
+  }
+  return roots;
+}
+async function loadGroupClosure(db, seedIds) {
+  const collected = /* @__PURE__ */ new Map();
+  let pending = seedIds;
+  for (let depth = 0; depth < PARENT_DEPTH_LIMIT; depth++) {
+    if (pending.length === 0) break;
+    const rows = await db.select().from(discountGroups).where(
+      and(
+        inArray(discountGroups.id, pending),
+        eq(discountGroups.isActive, true)
+      )
+    );
+    for (const row of rows) collected.set(row.id, row);
+    pending = rows.map((row) => row.parentGroupId).filter((id) => id !== null && !collected.has(id));
+  }
+  return [...collected.values()];
+}
+var productColumns = {
+  id: products.id,
+  section_id: products.sectionId,
+  slug: products.slug,
+  name: products.name,
+  short_description: products.shortDescription,
+  description: products.description,
+  is_active: products.isActive,
+  is_featured: products.isFeatured,
+  meta_title: products.metaTitle,
+  meta_description: products.metaDescription,
+  created_at: products.createdAt,
+  updated_at: products.updatedAt,
+  images: products.images,
+  has_modifications: products.hasModifications,
+  sku: products.sku,
+  stock_status: products.stockStatus
+};
+function toImageList(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => typeof item === "string");
+}
+
+// src/storefront/loaders/entities/home-product.ts
+var homeProductColumns = {
+  id: products.id,
+  name: products.name,
+  slug: products.slug,
+  images: products.images,
+  short_description: products.shortDescription,
+  stock_status: products.stockStatus
+};
+function toHomeProduct(row, sectionSlug) {
+  return {
+    id: row.id,
+    name: row.name,
+    slug: row.slug,
+    images: toImageList(row.images),
+    short_description: row.short_description,
+    stock_status: row.stock_status,
+    section: sectionSlug === null ? null : { slug: sectionSlug }
+  };
+}
+var PER_SECTION_LIMIT = 8;
+async function loadSectionProducts(db, sections8) {
+  const bySection = {};
+  for (const section of sections8) bySection[section.id] = [];
+  const sectionIds = sections8.map((section) => section.id);
+  if (sectionIds.length === 0) return bySection;
+  const ranked = db.select({
+    ...homeProductColumns,
+    section_id: products.sectionId,
+    position: sql`
+        row_number() over (
+          partition by ${products.sectionId} order by ${products.createdAt} desc
+        )
+      `.as("position")
+  }).from(products).where(
+    and(eq(products.isActive, true), inArray(products.sectionId, sectionIds))
+  ).as("ranked");
+  const rows = await db.select().from(ranked).where(lte(ranked.position, PER_SECTION_LIMIT)).orderBy(ranked.section_id, ranked.position);
+  const slugById = new Map(sections8.map((s) => [s.id, s.slug]));
+  for (const row of rows) {
+    if (row.section_id === null) continue;
+    const bucket = bySection[row.section_id];
+    if (!bucket) continue;
+    bucket.push(toHomeProduct(row, slugById.get(row.section_id) ?? null));
+  }
+  return bySection;
+}
+async function loadOneSectionProducts(db, section) {
+  const bySection = await loadSectionProducts(db, [section]);
+  return bySection[section.id] ?? [];
+}
+var sectionColumns = {
+  id: sections.id,
+  slug: sections.slug,
+  name: sections.name,
+  description: sections.description,
+  image_url: sections.imageUrl,
+  parent_id: sections.parentId,
+  sort_order: sections.sortOrder,
+  is_active: sections.isActive,
+  meta_title: sections.metaTitle,
+  meta_description: sections.metaDescription,
+  created_at: sections.createdAt,
+  updated_at: sections.updatedAt
+};
+var sectionRefColumns = {
+  id: sections.id,
+  name: sections.name,
+  slug: sections.slug
+};
+
+// src/storefront/loaders/sections.ts
+async function loadSections(db) {
+  return db.select(sectionColumns).from(sections).where(eq(sections.isActive, true)).orderBy(asc(sections.sortOrder));
+}
+async function loadSectionBySlug(db, slug) {
+  const [row] = await db.select(sectionColumns).from(sections).where(and(eq(sections.slug, slug), eq(sections.isActive, true))).limit(1);
+  return row ?? null;
+}
+async function loadRootSections(db) {
+  return db.select(sectionRefColumns).from(sections).where(and(eq(sections.isActive, true), isNull(sections.parentId))).orderBy(asc(sections.sortOrder));
+}
+
+// src/storefront/loaders/home.ts
+var FEATURED_LIMIT = 12;
+async function loadHomePageData(db) {
+  const bannerRows = await db.select(bannerColumns).from(banners).where(eq(banners.isActive, true)).orderBy(asc(banners.sortOrder));
+  const featured = await loadHomeProducts(db, true);
+  const newProducts = await loadHomeProducts(db, false);
+  const rootSections = await loadRootSections(db);
+  return {
+    banners: bannerRows.map(toBanner),
+    featuredProducts: featured,
+    newProducts,
+    sections: rootSections,
+    sectionProducts: await loadSectionProducts(db, rootSections)
+  };
+}
+async function loadHomeProducts(db, featuredOnly) {
+  const visible = featuredOnly ? and(eq(products.isActive, true), eq(products.isFeatured, true)) : eq(products.isActive, true);
+  const rows = await db.select({ ...homeProductColumns, section_slug: sections.slug }).from(products).leftJoin(sections, eq(products.sectionId, sections.id)).where(visible).orderBy(desc(products.createdAt)).limit(FEATURED_LIMIT);
+  return rows.map((row) => toHomeProduct(row, row.section_slug));
+}
+async function loadDefaultPriceTypeId(db) {
+  const [row] = await db.select({ id: priceTypes.id }).from(priceTypes).where(eq(priceTypes.isDefault, true)).limit(1);
+  return row?.id ?? null;
+}
+async function loadSectionNumericProperties(db, sectionId) {
+  return db.select({
+    id: sectionProperties.id,
+    slug: sectionProperties.slug,
+    property_type: sectionProperties.propertyType,
+    is_filterable: sectionProperties.isFilterable
+  }).from(sectionPropertyAssignments).innerJoin(
+    sectionProperties,
+    eq(sectionPropertyAssignments.propertyId, sectionProperties.id)
+  ).where(
+    and(
+      eq(sectionPropertyAssignments.sectionId, sectionId),
+      eq(sectionProperties.isFilterable, true),
+      or(
+        eq(sectionProperties.propertyType, "number"),
+        eq(sectionProperties.propertyType, "range")
+      )
+    )
+  ).orderBy(asc(sectionPropertyAssignments.sortOrder));
+}
+async function loadFilterOptions(db) {
+  const rows = await db.select({
+    id: propertyOptions.id,
+    name: propertyOptions.name,
+    property_id: propertyOptions.propertyId,
+    property: { name: sectionProperties.name, slug: sectionProperties.slug }
+  }).from(propertyOptions).leftJoin(
+    sectionProperties,
+    eq(propertyOptions.propertyId, sectionProperties.id)
+  ).orderBy(asc(propertyOptions.sortOrder));
+  return rows.map((row) => ({
+    id: row.id,
+    name: row.name,
+    property_id: row.property_id,
+    section_properties: row.property?.slug ? row.property : null
+  }));
+}
+var OPTION_TYPES = ["select", "multiselect"];
+async function loadSectionFilters(db, sectionId) {
+  const rows = await db.select({
+    id: sectionProperties.id,
+    name: sectionProperties.name,
+    slug: sectionProperties.slug,
+    property_type: sectionProperties.propertyType,
+    is_filterable: sectionProperties.isFilterable
+  }).from(sectionPropertyAssignments).innerJoin(
+    sectionProperties,
+    eq(sectionPropertyAssignments.propertyId, sectionProperties.id)
+  ).where(
+    and(
+      eq(sectionPropertyAssignments.sectionId, sectionId),
+      eq(sectionProperties.isFilterable, true)
+    )
+  ).orderBy(asc(sectionPropertyAssignments.sortOrder));
+  const byId = /* @__PURE__ */ new Map();
+  for (const row of rows) if (!byId.has(row.id)) byId.set(row.id, row);
+  const properties = [...byId.values()];
+  const optionIds = properties.filter((row) => OPTION_TYPES.includes(row.property_type)).map((row) => row.id);
+  const optionsByProperty = {};
+  if (optionIds.length === 0) return { properties, optionsByProperty };
+  const options = await db.select({
+    id: propertyOptions.id,
+    name: propertyOptions.name,
+    property_id: propertyOptions.propertyId,
+    slug: propertyOptions.slug,
+    sort_order: propertyOptions.sortOrder
+  }).from(propertyOptions).where(inArray(propertyOptions.propertyId, optionIds)).orderBy(asc(propertyOptions.sortOrder));
+  for (const option of options) {
+    (optionsByProperty[option.property_id] ??= []).push({
+      ...option,
+      section_properties: null
+    });
+  }
+  return { properties, optionsByProperty };
+}
+var catalogModificationColumns = {
+  id: productModifications.id,
+  product_id: productModifications.productId,
+  stock_status: productModifications.stockStatus,
+  is_default: productModifications.isDefault,
+  sort_order: productModifications.sortOrder
+};
+function pickDefaultModification(mods) {
+  if (mods.length === 0) return null;
+  return mods.find((mod) => mod.is_default) ?? [...mods].sort((a, b) => a.sort_order - b.sort_order)[0];
+}
+function toNumericValue(value) {
+  return value === null ? null : Number(value);
+}
+var priceColumns = {
+  product_id: productPrices.productId,
+  price_type_id: productPrices.priceTypeId,
+  price: productPrices.price,
+  old_price: productPrices.oldPrice,
+  modification_id: productPrices.modificationId
+};
+function toPriceEntry(row) {
+  return {
+    price_type_id: row.price_type_id,
+    price: Number(row.price),
+    old_price: row.old_price === null ? null : Number(row.old_price),
+    modification_id: row.modification_id
+  };
+}
+function groupPricesByProduct(rows) {
+  const byProduct = {};
+  for (const row of rows) {
+    (byProduct[row.product_id] ??= []).push(toPriceEntry(row));
+  }
+  return byProduct;
+}
+var propertyValueColumns = {
+  property_id: productPropertyValues.propertyId,
+  value: productPropertyValues.value,
+  numeric_value: productPropertyValues.numericValue,
+  option_id: productPropertyValues.optionId,
+  option: { id: propertyOptions.id, slug: propertyOptions.slug },
+  property: {
+    id: sectionProperties.id,
+    name: sectionProperties.name,
+    slug: sectionProperties.slug,
+    property_type: sectionProperties.propertyType,
+    has_page: sectionProperties.hasPage
+  }
+};
+function toPropertyValueRow(row) {
+  return {
+    property_id: row.property_id,
+    value: row.value,
+    numeric_value: row.numeric_value === null ? null : Number(row.numeric_value),
+    option_id: row.option_id,
+    property_options: row.option?.id ? row.option : null,
+    section_properties: row.property?.id ? row.property : null
+  };
+}
+function toPropertyValueViewModel(row) {
+  const normalized = toPropertyValueRow(row);
+  return {
+    property_id: normalized.property_id,
+    value: normalized.value,
+    numeric_value: normalized.numeric_value,
+    option_id: normalized.option_id,
+    option: normalized.property_options,
+    property: normalized.section_properties
+  };
+}
+
+// src/storefront/loaders/modification-values.ts
+async function loadModificationValues(db, modificationIds) {
+  const grouped = {};
+  if (modificationIds.length === 0) return grouped;
+  const rows = await db.select({
+    modification_id: modificationPropertyValues.modificationId,
+    property_id: modificationPropertyValues.propertyId,
+    value: modificationPropertyValues.value,
+    numeric_value: modificationPropertyValues.numericValue,
+    option_id: modificationPropertyValues.optionId
+  }).from(modificationPropertyValues).where(inArray(modificationPropertyValues.modificationId, modificationIds));
+  for (const row of rows) {
+    (grouped[row.modification_id] ??= []).push({
+      property_id: row.property_id,
+      value: row.value,
+      numeric_value: toNumericValue(row.numeric_value),
+      option_id: row.option_id
+    });
+  }
+  return grouped;
+}
+async function loadProductModificationValues(db, productId) {
+  const grouped = {};
+  const rows = await db.select({
+    modification_id: modificationPropertyValues.modificationId,
+    property_id: modificationPropertyValues.propertyId,
+    value: modificationPropertyValues.value,
+    numeric_value: modificationPropertyValues.numericValue,
+    option_id: modificationPropertyValues.optionId,
+    option: { id: propertyOptions.id, slug: propertyOptions.slug },
+    property: {
+      id: sectionProperties.id,
+      name: sectionProperties.name,
+      slug: sectionProperties.slug,
+      property_type: sectionProperties.propertyType,
+      has_page: sectionProperties.hasPage
+    }
+  }).from(modificationPropertyValues).innerJoin(
+    productModifications,
+    eq(modificationPropertyValues.modificationId, productModifications.id)
+  ).leftJoin(
+    propertyOptions,
+    eq(modificationPropertyValues.optionId, propertyOptions.id)
+  ).leftJoin(
+    sectionProperties,
+    eq(modificationPropertyValues.propertyId, sectionProperties.id)
+  ).where(eq(productModifications.productId, productId));
+  for (const row of rows) {
+    (grouped[row.modification_id] ??= []).push(toPropertyValueViewModel(row));
+  }
+  return grouped;
+}
+async function loadModificationIds(db, productId) {
+  const rows = await db.select({ id: productModifications.id }).from(productModifications).where(eq(productModifications.productId, productId));
+  return rows.map((row) => row.id);
+}
+async function loadStockByModification(db, modificationIds) {
+  const byModification = {};
+  if (modificationIds.length === 0) return byModification;
+  const rows = await db.select({
+    modification_id: stockByPickupPoint.modificationId,
+    quantity: sql`sum(${stockByPickupPoint.quantity})`
+  }).from(stockByPickupPoint).where(inArray(stockByPickupPoint.modificationId, modificationIds)).groupBy(stockByPickupPoint.modificationId);
+  for (const row of rows) {
+    if (row.modification_id === null) continue;
+    byModification[row.modification_id] = Number(row.quantity);
+  }
+  return byModification;
+}
+async function loadStockByProduct(db, productIds) {
+  const byProduct = {};
+  if (productIds.length === 0) return byProduct;
+  const rows = await db.select({
+    product_id: stockByPickupPoint.productId,
+    quantity: sql`sum(${stockByPickupPoint.quantity})`
+  }).from(stockByPickupPoint).where(
+    and(
+      inArray(stockByPickupPoint.productId, productIds),
+      isNull(stockByPickupPoint.modificationId)
+    )
+  ).groupBy(stockByPickupPoint.productId);
+  for (const row of rows) {
+    if (row.product_id === null) continue;
+    byProduct[row.product_id] = Number(row.quantity);
+  }
+  return byProduct;
+}
+async function loadModificationStock(db, modificationIds) {
+  const stock = {};
+  if (modificationIds.length === 0) return stock;
+  const quantities = await loadStockByModification(db, modificationIds);
+  const rows = await db.select({
+    id: productModifications.id,
+    stock_status: productModifications.stockStatus
+  }).from(productModifications).where(inArray(productModifications.id, modificationIds));
+  for (const row of rows) {
+    const totalQuantity = quantities[row.id] ?? 0;
+    stock[row.id] = {
+      totalQuantity,
+      isAvailable: totalQuantity > 0 || row.stock_status === "on_order"
+    };
+  }
+  return stock;
+}
+
+// src/storefront/loaders/catalog-products.ts
+async function loadCatalogProducts(db, sectionId) {
+  return loadCatalogProductsWhere(
+    db,
+    sectionId ? eq(products.sectionId, sectionId) : void 0
+  );
+}
+async function loadCatalogProductsWhere(db, extra) {
+  const visible = extra ? and(eq(products.isActive, true), extra) : eq(products.isActive, true);
+  const rows = await db.select({ product: productColumns, section: sectionRefColumns }).from(products).leftJoin(sections, eq(products.sectionId, sections.id)).where(visible).orderBy(desc(products.createdAt));
+  if (rows.length === 0) return [];
+  const ids = rows.map((row) => row.product.id);
+  const modificationRows = await db.select(catalogModificationColumns).from(productModifications).where(inArray(productModifications.productId, ids));
+  const priceRows = await db.select(priceColumns).from(productPrices).where(inArray(productPrices.productId, ids));
+  const valueRows = await db.select({
+    product_id: productPropertyValues.productId,
+    property_id: productPropertyValues.propertyId,
+    value: productPropertyValues.value,
+    numeric_value: productPropertyValues.numericValue,
+    option_id: productPropertyValues.optionId
+  }).from(productPropertyValues).where(inArray(productPropertyValues.productId, ids));
+  const modsByProduct = {};
+  const modIds = [];
+  for (const { product_id, ...mod } of modificationRows) {
+    (modsByProduct[product_id] ??= []).push(mod);
+    modIds.push(mod.id);
+  }
+  const valuesByModification = await loadModificationValues(db, modIds);
+  const modificationStock = await loadStockByModification(db, modIds);
+  const productStock = await loadStockByProduct(db, ids);
+  const pricesByProduct = groupPricesByProduct(priceRows);
+  const valuesByProduct = {};
+  for (const row of valueRows) {
+    (valuesByProduct[row.product_id] ??= []).push({
+      property_id: row.property_id,
+      value: row.value,
+      numeric_value: toNumericValue(row.numeric_value),
+      option_id: row.option_id
+    });
+  }
+  return rows.map(({ product, section }) => {
+    const mods = modsByProduct[product.id] ?? [];
+    const defaultMod = pickDefaultModification(mods);
+    return {
+      ...product,
+      images: toImageList(product.images),
+      has_modifications: product.has_modifications ?? true,
+      // `leftJoin` без збігу дає рядок із порожнім `id` (див. `./product-detail`).
+      section: section?.id ? section : null,
+      product_modifications: mods,
+      modifications: defaultMod ? [defaultMod] : [],
+      product_prices: pricesByProduct[product.id] ?? [],
+      propertyValues: [
+        ...valuesByProduct[product.id] ?? [],
+        ...mods.flatMap((mod) => valuesByModification[mod.id] ?? [])
+      ],
+      isAvailable: calculateProductAvailability(
+        {
+          id: product.id,
+          has_modifications: product.has_modifications,
+          stock_status: product.stock_status,
+          product_modifications: mods,
+          stock_by_pickup_point: []
+        },
+        { modificationStock, productStock }
+      )
+    };
+  });
+}
+var orderStatusColumns = {
+  id: orderStatuses.id,
+  name: orderStatuses.name,
+  code: orderStatuses.code,
+  color: orderStatuses.color
+};
+var orderItemColumns = {
+  id: orderItems.id,
+  order_id: orderItems.orderId,
+  name: orderItems.name,
+  price: orderItems.price,
+  base_price: orderItems.basePrice,
+  discount_data: orderItems.discountData,
+  quantity: orderItems.quantity,
+  total: orderItems.total
+};
+var orderColumns = {
+  id: orders.id,
+  order_number: orders.orderNumber,
+  total: orders.total,
+  subtotal: orders.subtotal,
+  created_at: orders.createdAt,
+  status_id: orders.statusId,
+  first_name: orders.firstName,
+  last_name: orders.lastName,
+  email: orders.email,
+  phone: orders.phone,
+  delivery_method: orders.deliveryMethod,
+  delivery_city: orders.deliveryCity,
+  delivery_address: orders.deliveryAddress,
+  payment_method: orders.paymentMethod,
+  notes: orders.notes,
+  has_different_recipient: orders.hasDifferentRecipient,
+  recipient_first_name: orders.recipientFirstName,
+  recipient_last_name: orders.recipientLastName,
+  recipient_phone: orders.recipientPhone,
+  recipient_email: orders.recipientEmail
+};
+function toOrderItem(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    price: Number(row.price),
+    base_price: row.base_price === null ? null : Number(row.base_price),
+    discount_data: row.discount_data ?? null,
+    quantity: row.quantity,
+    total: Number(row.total)
+  };
+}
+function groupItemsByOrder(rows) {
+  const byOrder = {};
+  for (const row of rows) (byOrder[row.order_id] ??= []).push(toOrderItem(row));
+  return byOrder;
+}
+
+// src/storefront/loaders/order-statuses.ts
+async function loadOrderStatuses(db) {
+  return db.select(orderStatusColumns).from(orderStatuses).orderBy(asc(orderStatuses.sortOrder));
+}
+async function loadStatusByCode(db, code) {
+  const [row] = await db.select(orderStatusColumns).from(orderStatuses).where(eq(orderStatuses.code, code)).limit(1);
+  return row ?? null;
+}
+async function loadDefaultStatusId(db) {
+  const [row] = await db.select({ id: orderStatuses.id }).from(orderStatuses).where(eq(orderStatuses.isDefault, true)).limit(1);
+  return row?.id ?? null;
+}
+
+// src/storefront/loaders/order-create.ts
+function generateOrderNumber(now) {
+  const stamp = now.toISOString().slice(2, 10).replace(/-/g, "");
+  const tail = randomUUID().replace(/-/g, "").slice(0, 6).toUpperCase();
+  return `${stamp}-${tail}`;
+}
+async function createOrder(db, userId, accessToken, input) {
+  const [method] = await db.select({ code: shippingMethods.code }).from(shippingMethods).where(eq(shippingMethods.id, input.shippingMethodId)).limit(1);
+  const orderNumber = generateOrderNumber(/* @__PURE__ */ new Date());
+  const [row] = await db.insert(orders).values({
+    userId,
+    accessToken,
+    orderNumber,
+    statusId: await loadDefaultStatusId(db),
+    firstName: input.firstName,
+    lastName: input.lastName,
+    email: input.email,
+    phone: input.phone,
+    deliveryMethod: method?.code ?? null,
+    deliveryCity: input.deliveryCity,
+    deliveryAddress: input.deliveryAddress,
+    paymentMethod: input.paymentMethod,
+    notes: input.notes,
+    subtotal: input.subtotal.toFixed(2),
+    total: input.total.toFixed(2),
+    shippingMethodId: input.shippingMethodId,
+    shippingCost: input.shippingCost.toFixed(2),
+    pickupPointId: input.pickupPointId,
+    shippingData: {},
+    hasDifferentRecipient: input.hasDifferentRecipient,
+    recipientFirstName: input.recipientFirstName,
+    recipientLastName: input.recipientLastName,
+    recipientPhone: input.recipientPhone,
+    recipientEmail: input.recipientEmail,
+    savedRecipientId: input.savedRecipientId,
+    savedAddressId: input.savedAddressId
+  }).returning({ id: orders.id, orderNumber: orders.orderNumber });
+  await db.insert(orderItems).values(
+    input.items.map((item) => ({
+      orderId: row.id,
+      productId: item.productId,
+      modificationId: item.modificationId,
+      name: item.name,
+      price: item.price.toFixed(2),
+      quantity: item.quantity,
+      total: (item.price * item.quantity).toFixed(2),
+      basePrice: item.basePrice === null ? null : item.basePrice.toFixed(2),
+      discountData: item.discountData ?? null
+    }))
+  );
+  return { id: row.id, orderNumber: row.orderNumber, accessToken };
+}
+async function loadUserOrders(db, userId, statusId) {
+  const scope = statusId ? and(eq(orders.userId, userId), eq(orders.statusId, statusId)) : eq(orders.userId, userId);
+  const rows = await db.select({ order: orderColumns, status: orderStatusColumns }).from(orders).leftJoin(orderStatuses, eq(orders.statusId, orderStatuses.id)).where(scope).orderBy(desc(orders.createdAt));
+  if (rows.length === 0) return [];
+  const itemRows = await db.select(orderItemColumns).from(orderItems).where(
+    inArray(
+      orderItems.orderId,
+      rows.map((row) => row.order.id)
+    )
+  );
+  const itemsByOrder = groupItemsByOrder(itemRows);
+  return rows.map(({ order, status }) => ({
+    id: order.id,
+    order_number: order.order_number,
+    total: Number(order.total),
+    created_at: order.created_at,
+    status_id: order.status_id,
+    status: status?.id ? status : null,
+    items: itemsByOrder[order.id] ?? []
+  }));
+}
+async function loadOrderDetail(db, orderId) {
+  const [row] = await db.select({ order: orderColumns, status: orderStatusColumns }).from(orders).leftJoin(orderStatuses, eq(orders.statusId, orderStatuses.id)).where(eq(orders.id, orderId)).limit(1);
+  if (!row) return null;
+  const itemRows = await db.select(orderItemColumns).from(orderItems).where(eq(orderItems.orderId, orderId));
+  const { order, status } = row;
+  return {
+    ...order,
+    total: Number(order.total),
+    subtotal: Number(order.subtotal),
+    status: status?.id ? status : null,
+    items: itemRows.map(toOrderItem)
+  };
+}
+async function setOrderStatus(db, orderId, statusId) {
+  await db.update(orders).set({ statusId, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq(orders.id, orderId));
+}
+async function loadAddresses(db, userId) {
+  const rows = await db.select({
+    id: userAddresses.id,
+    name: userAddresses.name,
+    city: userAddresses.city,
+    address: userAddresses.address,
+    is_default: userAddresses.isDefault,
+    created_at: userAddresses.createdAt,
+    usage_count: count(orders.id)
+  }).from(userAddresses).leftJoin(orders, eq(orders.savedAddressId, userAddresses.id)).where(eq(userAddresses.userId, userId)).groupBy(userAddresses.id).orderBy(desc(userAddresses.isDefault), desc(userAddresses.createdAt));
+  return rows.map(({ created_at: _createdAt, ...row }) => row);
+}
+async function createAddress(db, userId, input) {
+  const [row] = await db.insert(userAddresses).values({
+    userId,
+    name: input.name,
+    city: input.city,
+    address: input.address,
+    isDefault: input.isDefault
+  }).returning({ id: userAddresses.id });
+  return row.id;
+}
+async function updateAddress(db, userId, id, input) {
+  const updated = await db.update(userAddresses).set({
+    name: input.name,
+    city: input.city,
+    address: input.address,
+    isDefault: input.isDefault
+  }).where(and(eq(userAddresses.id, id), eq(userAddresses.userId, userId))).returning({ id: userAddresses.id });
+  return updated.length > 0;
+}
+async function deleteAddress(db, userId, id) {
+  const deleted = await db.delete(userAddresses).where(and(eq(userAddresses.id, id), eq(userAddresses.userId, userId))).returning({ id: userAddresses.id });
+  return deleted.length > 0;
+}
+async function clearDefaultAddresses(db, userId) {
+  await db.update(userAddresses).set({ isDefault: false }).where(eq(userAddresses.userId, userId));
+}
+async function loadPickupPoints(db) {
+  const rows = await db.select().from(pickupPoints).where(eq(pickupPoints.isActive, true)).orderBy(asc(pickupPoints.sortOrder));
+  return rows.map((row) => ({
+    id: row.id,
+    method_id: row.methodId,
+    name: row.name,
+    address: row.address,
+    city: row.city,
+    zone_id: row.zoneId,
+    working_hours: row.workingHours ?? {},
+    phone: row.phone,
+    is_active: row.isActive,
+    is_system: row.isSystem,
+    sort_order: row.sortOrder,
+    coordinates: row.coordinates ?? null,
+    created_at: row.createdAt
+  }));
+}
+async function loadProfile(db, userId) {
+  const [row] = await db.select({
+    first_name: profiles.firstName,
+    last_name: profiles.lastName,
+    email: profiles.email,
+    phone: profiles.phone,
+    avatar_url: profiles.avatarUrl,
+    category_name: userCategories.name
+  }).from(profiles).leftJoin(userCategories, eq(profiles.categoryId, userCategories.id)).where(eq(profiles.userId, userId)).limit(1);
+  if (!row) return null;
+  return {
+    first_name: row.first_name,
+    last_name: row.last_name,
+    email: row.email,
+    phone: row.phone,
+    avatar_url: row.avatar_url,
+    category: row.category_name === null ? null : { name: row.category_name }
+  };
+}
+async function updateProfile(db, userId, update) {
+  await db.update(profiles).set({
+    firstName: update.firstName,
+    lastName: update.lastName,
+    phone: update.phone,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }).where(eq(profiles.userId, userId));
+}
+async function loadUserPriceTypeId(db, userId) {
+  const [row] = await db.select({ price_type_id: userCategories.priceTypeId }).from(profiles).innerJoin(userCategories, eq(profiles.categoryId, userCategories.id)).where(eq(profiles.userId, userId)).limit(1);
+  return row?.price_type_id ?? null;
+}
+async function loadRecipients(db, userId) {
+  const rows = await db.select({
+    id: userRecipients.id,
+    first_name: userRecipients.firstName,
+    last_name: userRecipients.lastName,
+    phone: userRecipients.phone,
+    email: userRecipients.email,
+    city: userRecipients.city,
+    address: userRecipients.address,
+    notes: userRecipients.notes,
+    is_default: userRecipients.isDefault,
+    created_at: userRecipients.createdAt,
+    usage_count: count(orders.id)
+  }).from(userRecipients).leftJoin(orders, eq(orders.savedRecipientId, userRecipients.id)).where(eq(userRecipients.userId, userId)).groupBy(userRecipients.id).orderBy(desc(userRecipients.isDefault), desc(userRecipients.createdAt));
+  return rows.map(({ created_at: _createdAt, ...row }) => row);
+}
+async function createRecipient(db, userId, input) {
+  const [row] = await db.insert(userRecipients).values({
+    userId,
+    ...toColumns(input),
+    isDefault: input.isDefault ?? false
+  }).returning({ id: userRecipients.id });
+  return row.id;
+}
+async function updateRecipient(db, userId, id, input) {
+  const updated = await db.update(userRecipients).set({ ...toColumns(input), isDefault: input.isDefault }).where(and(eq(userRecipients.id, id), eq(userRecipients.userId, userId))).returning({ id: userRecipients.id });
+  return updated.length > 0;
+}
+async function deleteRecipient(db, userId, id) {
+  const deleted = await db.delete(userRecipients).where(and(eq(userRecipients.id, id), eq(userRecipients.userId, userId))).returning({ id: userRecipients.id });
+  return deleted.length > 0;
+}
+async function clearDefaultRecipients(db, userId) {
+  await db.update(userRecipients).set({ isDefault: false }).where(eq(userRecipients.userId, userId));
+}
+function toColumns(input) {
+  return {
+    firstName: input.firstName,
+    lastName: input.lastName,
+    phone: input.phone,
+    email: input.email,
+    city: input.city,
+    address: input.address,
+    notes: input.notes
+  };
+}
+async function loadProductReviews(db, productId) {
+  const rows = await db.select().from(productReviews).where(eq(productReviews.productId, productId)).orderBy(desc(productReviews.createdAt));
+  return rows.map((row) => ({
+    id: row.id,
+    product_id: row.productId,
+    user_id: row.userId,
+    rating: row.rating,
+    title: row.title,
+    content: row.content,
+    images: Array.isArray(row.images) ? row.images : [],
+    status: row.status,
+    admin_comment: row.adminComment,
+    created_at: row.createdAt,
+    updated_at: row.updatedAt
+  }));
+}
+async function loadReviewAuthors(db, userIds) {
+  const authors = {};
+  if (userIds.length === 0) return authors;
+  const rows = await db.select({
+    user_id: profiles.userId,
+    first_name: profiles.firstName,
+    last_name: profiles.lastName,
+    avatar_url: profiles.avatarUrl
+  }).from(profiles).where(inArray(profiles.userId, userIds));
+  for (const row of rows) {
+    authors[row.user_id] = {
+      first_name: row.first_name,
+      last_name: row.last_name,
+      avatar_url: row.avatar_url
+    };
+  }
+  return authors;
+}
+async function loadProductRatings(db, productIds) {
+  const ratings = {};
+  if (productIds.length === 0) return ratings;
+  const rows = await db.select({
+    product_id: productReviews.productId,
+    avg_rating: sql`avg(${productReviews.rating})`,
+    review_count: count()
+  }).from(productReviews).where(
+    and(
+      inArray(productReviews.productId, productIds),
+      eq(productReviews.status, "approved")
+    )
+  ).groupBy(productReviews.productId);
+  for (const row of rows) {
+    ratings[row.product_id] = {
+      avgRating: Math.round(Number(row.avg_rating) * 10) / 10,
+      reviewCount: Number(row.review_count)
+    };
+  }
+  return ratings;
+}
+async function insertProductReview(db, userId, input) {
+  await db.insert(productReviews).values({
+    productId: input.productId,
+    userId,
+    rating: input.rating,
+    title: input.title,
+    content: input.content,
+    images: input.images,
+    status: "pending"
+  });
+}
+async function deleteProductReview(db, userId, reviewId) {
+  const deleted = await db.delete(productReviews).where(
+    and(eq(productReviews.id, reviewId), eq(productReviews.userId, userId))
+  ).returning({ id: productReviews.id });
+  return deleted.length > 0;
+}
+var EMPTY = {
+  totalQuantity: 0,
+  isAvailable: false,
+  stockStatus: null,
+  byPoint: []
+};
+async function loadStockInfo(db, target) {
+  const stockStatus = await loadStockStatus(db, target);
+  if (stockStatus === void 0) return EMPTY;
+  const scope = target.modificationId ? eq(stockByPickupPoint.modificationId, target.modificationId) : and(
+    eq(stockByPickupPoint.productId, target.productId ?? ""),
+    isNull(stockByPickupPoint.modificationId)
+  );
+  const rows = await db.select({
+    point_id: pickupPoints.id,
+    point_name: pickupPoints.name,
+    quantity: stockByPickupPoint.quantity
+  }).from(stockByPickupPoint).innerJoin(
+    pickupPoints,
+    eq(pickupPoints.id, stockByPickupPoint.pickupPointId)
+  ).where(and(scope, eq(pickupPoints.isActive, true))).orderBy(asc(pickupPoints.sortOrder));
+  const totalQuantity = rows.reduce((sum, row) => sum + row.quantity, 0);
+  return {
+    totalQuantity,
+    isAvailable: totalQuantity > 0 || stockStatus === "on_order",
+    stockStatus,
+    byPoint: rows
+  };
+}
+async function loadStockStatus(db, target) {
+  if (target.modificationId) {
+    const [row2] = await db.select({ status: productModifications.stockStatus }).from(productModifications).where(eq(productModifications.id, target.modificationId)).limit(1);
+    return row2 === void 0 ? void 0 : row2.status;
+  }
+  if (!target.productId) return void 0;
+  const [row] = await db.select({ status: products.stockStatus }).from(products).where(eq(products.id, target.productId)).limit(1);
+  return row === void 0 ? void 0 : row.status;
+}
+async function loadActivePickupPointsCount(db) {
+  const [row] = await db.select({ total: count() }).from(pickupPoints).where(eq(pickupPoints.isActive, true));
+  return Number(row?.total ?? 0);
+}
+var modificationColumns = {
+  id: productModifications.id,
+  product_id: productModifications.productId,
+  slug: productModifications.slug,
+  name: productModifications.name,
+  sku: productModifications.sku,
+  is_default: productModifications.isDefault,
+  sort_order: productModifications.sortOrder,
+  stock_status: productModifications.stockStatus,
+  images: productModifications.images
+};
+function toModificationRow(row) {
+  return { ...row, images: toImageList(row.images) };
+}
+var listModificationColumns = {
+  id: productModifications.id,
+  product_id: productModifications.productId,
+  is_default: productModifications.isDefault,
+  sort_order: productModifications.sortOrder
+};
+
+// src/storefront/loaders/product-detail.ts
+async function loadProduct(db, slug) {
+  const [row] = await db.select({ product: productColumns, section: sectionRefColumns }).from(products).leftJoin(sections, eq(products.sectionId, sections.id)).where(and(eq(products.slug, slug), eq(products.isActive, true))).limit(1);
+  if (!row) return null;
+  const productId = row.product.id;
+  const modificationRows = await db.select(modificationColumns).from(productModifications).where(eq(productModifications.productId, productId));
+  const priceRows = await db.select(priceColumns).from(productPrices).where(eq(productPrices.productId, productId));
+  const propertyValueRows = await db.select(propertyValueColumns).from(productPropertyValues).leftJoin(
+    propertyOptions,
+    eq(productPropertyValues.optionId, propertyOptions.id)
+  ).leftJoin(
+    sectionProperties,
+    eq(productPropertyValues.propertyId, sectionProperties.id)
+  ).where(eq(productPropertyValues.productId, productId));
+  return {
+    ...row.product,
+    images: toImageList(row.product.images),
+    // `leftJoin` без збігу дає рядок із порожнім `id` — розділ у товару
+    // необовʼязковий (FK `on delete set null`), тож перевіряємо явно.
+    sections: row.section?.id ? row.section : null,
+    product_modifications: modificationRows.map(toModificationRow),
+    product_prices: priceRows.map(toPriceEntry),
+    product_property_values: propertyValueRows.map(toPropertyValueRow)
+  };
+}
+async function loadProductList(db, sectionId) {
+  const visible = sectionId ? and(eq(products.isActive, true), eq(products.sectionId, sectionId)) : eq(products.isActive, true);
+  const rows = await db.select({
+    id: products.id,
+    slug: products.slug,
+    name: products.name,
+    images: products.images,
+    has_modifications: products.hasModifications,
+    section_slug: sections.slug
+  }).from(products).leftJoin(sections, eq(products.sectionId, sections.id)).where(visible).orderBy(desc(products.createdAt));
+  if (rows.length === 0) return [];
+  const ids = rows.map((row) => row.id);
+  const modificationRows = await db.select(listModificationColumns).from(productModifications).where(inArray(productModifications.productId, ids));
+  const priceRows = await db.select(priceColumns).from(productPrices).where(inArray(productPrices.productId, ids));
+  const modificationsByProduct = {};
+  for (const modification of modificationRows) {
+    (modificationsByProduct[modification.product_id] ??= []).push({
+      id: modification.id,
+      is_default: modification.is_default,
+      sort_order: modification.sort_order
+    });
+  }
+  const pricesByProduct = groupPricesByProduct(priceRows);
+  return rows.map((row) => ({
+    id: row.id,
+    slug: row.slug,
+    name: row.name,
+    images: toImageList(row.images),
+    has_modifications: row.has_modifications,
+    sections: row.section_slug === null ? null : { slug: row.section_slug },
+    product_modifications: modificationsByProduct[row.id] ?? [],
+    product_prices: pricesByProduct[row.id] ?? []
+  }));
+}
+var propertyColumns = {
+  id: sectionProperties.id,
+  section_id: sectionProperties.sectionId,
+  name: sectionProperties.name,
+  slug: sectionProperties.slug,
+  property_type: sectionProperties.propertyType,
+  is_required: sectionProperties.isRequired,
+  is_filterable: sectionProperties.isFilterable,
+  has_page: sectionProperties.hasPage,
+  sort_order: sectionProperties.sortOrder,
+  options: sectionProperties.options,
+  created_at: sectionProperties.createdAt
+};
+function toPropertyRow(row) {
+  return { ...row, options: row.options ?? null };
+}
+var optionColumns = {
+  id: propertyOptions.id,
+  property_id: propertyOptions.propertyId,
+  name: propertyOptions.name,
+  slug: propertyOptions.slug,
+  sort_order: propertyOptions.sortOrder,
+  description: propertyOptions.description,
+  image_url: propertyOptions.imageUrl,
+  meta_title: propertyOptions.metaTitle,
+  meta_description: propertyOptions.metaDescription,
+  created_at: propertyOptions.createdAt
+};
+
+// src/storefront/loaders/properties.ts
+async function loadProperties(db) {
+  const rows = await db.select(propertyColumns).from(sectionProperties).where(eq(sectionProperties.hasPage, true)).orderBy(asc(sectionProperties.sortOrder), asc(sectionProperties.name));
+  return withOptions(db, rows.map(toPropertyRow));
+}
+async function loadPropertyBySlug(db, slug) {
+  const [row] = await db.select(propertyColumns).from(sectionProperties).where(
+    and(
+      eq(sectionProperties.slug, slug),
+      eq(sectionProperties.hasPage, true)
+    )
+  ).limit(1);
+  if (!row) return null;
+  const [withAll] = await withOptions(db, [toPropertyRow(row)]);
+  return withAll;
+}
+async function withOptions(db, rows) {
+  if (rows.length === 0) return [];
+  const optionRows = await db.select(optionColumns).from(propertyOptions).where(
+    inArray(
+      propertyOptions.propertyId,
+      rows.map((row) => row.id)
+    )
+  ).orderBy(asc(propertyOptions.sortOrder));
+  const byProperty = {};
+  for (const option of optionRows) {
+    (byProperty[option.property_id] ??= []).push(option);
+  }
+  return rows.map((row) => ({
+    ...row,
+    property_options: byProperty[row.id] ?? []
+  }));
+}
+async function loadPropertyOption(db, propertySlug, optionSlug) {
+  const [row] = await db.select({ property: propertyColumns, option: optionColumns }).from(sectionProperties).innerJoin(
+    propertyOptions,
+    eq(propertyOptions.propertyId, sectionProperties.id)
+  ).where(
+    and(
+      eq(sectionProperties.slug, propertySlug),
+      // Предикат видимості — див. `./properties`.
+      eq(sectionProperties.hasPage, true),
+      eq(propertyOptions.slug, optionSlug)
+    )
+  ).limit(1);
+  if (!row) return null;
+  return {
+    property: toPropertyRow(row.property),
+    option: row.option,
+    products: await loadProductsByOption(db, row.option.id)
+  };
+}
+async function loadProductsByOption(db, optionId) {
+  const onProduct = db.select({ marker: sql`1` }).from(productPropertyValues).where(
+    and(
+      eq(productPropertyValues.productId, products.id),
+      eq(productPropertyValues.optionId, optionId)
+    )
+  );
+  const onModification = db.select({ marker: sql`1` }).from(modificationPropertyValues).innerJoin(
+    productModifications,
+    eq(modificationPropertyValues.modificationId, productModifications.id)
+  ).where(
+    and(
+      eq(productModifications.productId, products.id),
+      eq(modificationPropertyValues.optionId, optionId)
+    )
+  );
+  return loadCatalogProductsWhere(
+    db,
+    or(exists(onProduct), exists(onModification))
+  );
+}
+async function loadShippingDirectory(db) {
+  const methods = await loadShippingMethods(db);
+  const zones = await loadShippingZones(db);
+  const rates = await loadShippingRates(db);
+  const points = await loadPickupPoints(db);
+  return { methods, zones, rates, pickupPoints: points };
+}
+async function loadShippingMethods(db) {
+  const rows = await db.select().from(shippingMethods).where(eq(shippingMethods.isActive, true)).orderBy(asc(shippingMethods.sortOrder));
+  return rows.map((row) => ({
+    id: row.id,
+    code: row.code,
+    name: row.name,
+    description: row.description,
+    type: row.type,
+    plugin_name: row.pluginName,
+    is_active: row.isActive,
+    sort_order: row.sortOrder,
+    config: row.config ?? {},
+    icon: row.icon,
+    created_at: row.createdAt,
+    updated_at: row.updatedAt
+  }));
+}
+async function loadShippingZones(db) {
+  const rows = await db.select().from(shippingZones).where(eq(shippingZones.isActive, true)).orderBy(asc(shippingZones.sortOrder));
+  return rows.map((row) => ({
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    cities: row.cities ?? [],
+    regions: row.regions ?? [],
+    is_active: row.isActive,
+    is_default: row.isDefault,
+    sort_order: row.sortOrder,
+    created_at: row.createdAt
+  }));
+}
+async function loadShippingRates(db) {
+  const rows = await db.select().from(shippingRates).where(eq(shippingRates.isActive, true)).orderBy(asc(shippingRates.sortOrder));
+  return rows.map((row) => ({
+    id: row.id,
+    method_id: row.methodId,
+    zone_id: row.zoneId,
+    name: row.name,
+    calculation_type: row.calculationType,
+    base_cost: Number(row.baseCost),
+    per_kg_cost: toNumberOrNull(row.perKgCost),
+    min_weight: toNumberOrNull(row.minWeight),
+    free_from_amount: toNumberOrNull(row.freeFromAmount),
+    min_order_amount: toNumberOrNull(row.minOrderAmount),
+    max_order_amount: toNumberOrNull(row.maxOrderAmount),
+    estimated_days: row.estimatedDays,
+    is_active: row.isActive,
+    sort_order: row.sortOrder,
+    config: row.config ?? {},
+    created_at: row.createdAt
+  }));
+}
+function toNumberOrNull(value) {
+  return value === null ? null : Number(value);
+}
+async function loadSitemapData(db) {
+  const sectionRows = await db.select({ slug: sections.slug, updated_at: sections.updatedAt }).from(sections).where(eq(sections.isActive, true)).orderBy(asc(sections.sortOrder));
+  const productRows = await db.select({
+    slug: products.slug,
+    updated_at: products.updatedAt,
+    section_slug: sections.slug
+  }).from(products).leftJoin(sections, eq(products.sectionId, sections.id)).where(eq(products.isActive, true)).orderBy(desc(products.updatedAt));
+  return { sections: sectionRows, products: productRows };
+}
+
+export { clearDefaultAddresses, clearDefaultRecipients, createAddress, createOrder, createRecipient, deleteAddress, deleteProductReview, deleteRecipient, groupItemsByOrder, groupPricesByProduct, insertProductReview, isBannerVisible, loadActivePickupPointsCount, loadAddresses, loadBanners, loadCatalogProducts, loadCatalogProductsWhere, loadDefaultPriceTypeId, loadDefaultStatusId, loadDefaultUserCategoryId, loadDiscountGroups, loadFilterOptions, loadHomePageData, loadHomeProducts, loadModificationIds, loadModificationStock, loadModificationValues, loadOneSectionProducts, loadOrderDetail, loadOrderStatuses, loadPickupPoints, loadProduct, loadProductList, loadProductModificationValues, loadProductRatings, loadProductReviews, loadProfile, loadProperties, loadPropertyBySlug, loadPropertyOption, loadRecipients, loadReviewAuthors, loadRootSections, loadSectionBySlug, loadSectionFilters, loadSectionNumericProperties, loadSectionProducts, loadSections, loadShippingDirectory, loadShippingMethods, loadShippingRates, loadShippingZones, loadSitemapData, loadStatusByCode, loadStockByModification, loadStockByProduct, loadStockInfo, loadUserCategoryId, loadUserOrders, loadUserPriceTypeId, optionalSessionUserId, pickDefaultModification, propertyValueColumns, requireSessionUserId, setOrderStatus, toBanner, toDiscount, toDiscountGroupNode, toHomeProduct, toImageList, toModificationRow, toNumericValue, toOrderItem, toPriceEntry, toPropertyRow, toPropertyValueRow, toPropertyValueViewModel, updateAddress, updateProfile, updateRecipient, withCustomerDb, withOrderTokenDb, withSessionDb, withStoreOperatorDb, withStorefrontDb };
+//# sourceMappingURL=chunk-BDKJ3ITL.js.map
+//# sourceMappingURL=chunk-BDKJ3ITL.js.map