simplycms 0.4.0

package/src/storefront/loaders/modification-values.ts

@@ -0,0 +1,113 @@
+import { eq, inArray } from 'drizzle-orm';
+import {
+  modificationPropertyValues,
+  productModifications,
+  propertyOptions,
+  sectionProperties,
+} from 'simplycms/schema';
+import type { ActorDb } from './db';
+import { toNumericValue } from './entities/catalog-product';
+import type { CatalogPropertyValueRow } from './entities/catalog-product';
+import type { ProductPropertyValueViewModel } from 'simplycms/contracts/views';
+import { toPropertyValueViewModel } from './property-values';
+
+/** Плоскі значення характеристик модифікацій: `modificationId → значення`. */
+export async function loadModificationValues(
+  db: ActorDb,
+  modificationIds: string[],
+): Promise<Record<string, CatalogPropertyValueRow[]>> {
+  const grouped: Record<string, CatalogPropertyValueRow[]> = {};
+  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;
+}
+
+/**
+ * Значення характеристик модифікацій ОДНОГО товару разом з опцією й самою
+ * характеристикою — форма, яку читає таблиця характеристик на картці.
+ *
+ * 🔴 Вхід — `productId`, а не список id модифікацій із браузера. Список,
+ * присланий клієнтом, довелося б або довіряти, або звіряти зайвим запитом;
+ * тут же вибірка за побудовою не виходить за межі одного товару.
+ */
+export async function loadProductModificationValues(
+  db: ActorDb,
+  productId: string,
+): Promise<Record<string, ProductPropertyValueViewModel[]>> {
+  const grouped: Record<string, ProductPropertyValueViewModel[]> = {};
+
+  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;
+}
+
+/**
+ * Id модифікацій товару.
+ *
+ * 🔴 Потрібен ОКРЕМО від значень характеристик: модифікація без жодної
+ * характеристики в мапі значень не зʼявляється, і залишки для неї тихо
+ * не порахувались би — селектор показав би «немає в наявності» рівно там,
+ * де адмінка нічого не заповнила.
+ */
+export async function loadModificationIds(
+  db: ActorDb,
+  productId: string,
+): Promise<string[]> {
+  const rows = await db
+    .select({ id: productModifications.id })
+    .from(productModifications)
+    .where(eq(productModifications.productId, productId));
+
+  return rows.map((row) => row.id);
+}

package/src/storefront/loaders/order-create.ts

@@ -0,0 +1,134 @@
+import { randomUUID } from 'node:crypto';
+import { eq } from 'drizzle-orm';
+import { orderItems, orders, shippingMethods } from 'simplycms/schema';
+import type { JsonValue } from './entities/property';
+import type { ActorDb } from './db';
+import { loadDefaultStatusId } from './order-statuses';
+
+/** Позиція кошика в тому вигляді, в якому вона лягає в замовлення. */
+export interface NewOrderItem {
+  productId: string | null;
+  modificationId: string | null;
+  name: string;
+  price: number;
+  quantity: number;
+  basePrice: number | null;
+  discountData: JsonValue | null;
+}
+
+/** Контактні й доставкові дані оформлення. */
+export interface NewOrderInput {
+  firstName: string;
+  lastName: string;
+  email: string;
+  phone: string;
+  shippingMethodId: string;
+  deliveryCity: string | null;
+  deliveryAddress: string | null;
+  pickupPointId: string | null;
+  paymentMethod: string;
+  notes: string | null;
+  subtotal: number;
+  shippingCost: number;
+  total: number;
+  hasDifferentRecipient: boolean;
+  recipientFirstName: string | null;
+  recipientLastName: string | null;
+  recipientPhone: string | null;
+  recipientEmail: string | null;
+  savedRecipientId: string | null;
+  savedAddressId: string | null;
+  items: NewOrderItem[];
+}
+
+/** Що повертається клієнту після оформлення. */
+export interface CreatedOrder {
+  id: string;
+  orderNumber: string;
+  /** Токен гостьового замовлення; для залогіненого — `null`. */
+  accessToken: string | null;
+}
+
+/**
+ * Номер замовлення.
+ *
+ * 🔴 Генерується в TS, бо тригера `generate_order_number` у схемі v2 НЕМАЄ:
+ * baseline B13 не везе жодної plpgsql-функції, крім читача актора. Формат —
+ * дата плюс випадковий хвіст; унікальність тримає ключ `orders_order_number_key`,
+ * а не надія на послідовність.
+ */
+function generateOrderNumber(now: Date): string {
+  const stamp = now.toISOString().slice(2, 10).replace(/-/g, '');
+  const tail = randomUUID().replace(/-/g, '').slice(0, 6).toUpperCase();
+  return `${stamp}-${tail}`;
+}
+
+/**
+ * Створює замовлення разом із позиціями — однією транзакцією актора.
+ *
+ * 🔴 `userId` — з серверної сесії або `null` для гостя; політика
+ * `orders_insert_own` приймає рівно ці два випадки. Гостю одразу видається
+ * `access_token`, і саме він має бути в GUC `app.order_token` ЦІЄЇ транзакції:
+ * без нього `insert … returning` впав би на власній же SELECT-політиці.
+ */
+export async function createOrder(
+  db: ActorDb,
+  userId: string | null,
+  accessToken: string | null,
+  input: NewOrderInput,
+): Promise<CreatedOrder> {
+  const [method] = await db
+    .select({ code: shippingMethods.code })
+    .from(shippingMethods)
+    .where(eq(shippingMethods.id, input.shippingMethodId))
+    .limit(1);
+
+  const orderNumber = generateOrderNumber(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 };
+}

package/src/storefront/loaders/order-statuses.ts

@@ -0,0 +1,39 @@
+import { asc, eq } from 'drizzle-orm';
+import { orderStatuses } from 'simplycms/schema';
+import type { ActorDb } from './db';
+import { orderStatusColumns, type OrderStatusRow } from './entities/order';
+
+/** Довідник статусів — публічний (грант `select` для `app_user`). */
+export async function loadOrderStatuses(
+  db: ActorDb,
+): Promise<OrderStatusRow[]> {
+  return db
+    .select(orderStatusColumns)
+    .from(orderStatuses)
+    .orderBy(asc(orderStatuses.sortOrder));
+}
+
+/** Статус за кодом — потрібен скасуванню замовлення. */
+export async function loadStatusByCode(
+  db: ActorDb,
+  code: string,
+): Promise<OrderStatusRow | null> {
+  const [row] = await db
+    .select(orderStatusColumns)
+    .from(orderStatuses)
+    .where(eq(orderStatuses.code, code))
+    .limit(1);
+
+  return row ?? null;
+}
+
+/** Статус за замовчуванням — з ним створюється нове замовлення. */
+export async function loadDefaultStatusId(db: ActorDb): Promise<string | null> {
+  const [row] = await db
+    .select({ id: orderStatuses.id })
+    .from(orderStatuses)
+    .where(eq(orderStatuses.isDefault, true))
+    .limit(1);
+
+  return row?.id ?? null;
+}

package/src/storefront/loaders/orders.ts

@@ -0,0 +1,113 @@
+import { and, desc, eq, inArray } from 'drizzle-orm';
+import { orderItems, orderStatuses, orders } from 'simplycms/schema';
+import type { ActorDb } from './db';
+import {
+  groupItemsByOrder,
+  orderColumns,
+  orderItemColumns,
+  orderStatusColumns,
+  toOrderItem,
+  type OrderDetailRow,
+  type OrderListRow,
+} from './entities/order';
+
+/**
+ * Замовлення покупця, опційно звужені статусом.
+ *
+ * 🔴 `user_id` у предикаті — з СЕРВЕРНОЇ сесії (актор транзакції). Політика
+ * `orders_select_own_or_token` звужує таблицю тим самим id, тож підставити
+ * чужий тут нема звідки: параметра з цим значенням у клієнта не існує.
+ */
+export async function loadUserOrders(
+  db: ActorDb,
+  userId: string,
+  statusId?: string,
+): Promise<OrderListRow[]> {
+  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] ?? [],
+  }));
+}
+
+/**
+ * Одне замовлення цілком.
+ *
+ * Права доводить АКТОР транзакції: `withCustomerDb` — власника,
+ * `withOrderTokenDb` — гостя з токеном. Сам запит різниці не знає, тож
+ * зайвого предиката тут немає навмисно: він створив би ілюзію, що саме код
+ * вирішує питання доступу.
+ */
+export async function loadOrderDetail(
+  db: ActorDb,
+  orderId: string,
+): Promise<OrderDetailRow | null> {
+  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),
+  };
+}
+
+/**
+ * Перевести замовлення в статус — виконується під `app_admin`.
+ *
+ * 🔴 Ownership тут НЕ перевіряється й перевірятись не може: під `app_admin`
+ * RLS віддає все. Право мусить бути доведене ДО виклику окремим читанням
+ * під актором покупця (`server/profile-orders.ts`).
+ */
+export async function setOrderStatus(
+  db: ActorDb,
+  orderId: string,
+  statusId: string,
+): Promise<void> {
+  await db
+    .update(orders)
+    .set({ statusId, updatedAt: new Date().toISOString() })
+    .where(eq(orders.id, orderId));
+}

package/src/storefront/loaders/pickup-points.ts

@@ -0,0 +1,36 @@
+import { asc, eq } from 'drizzle-orm';
+import { pickupPoints } from 'simplycms/schema';
+import type {
+  Coordinates,
+  PickupPoint,
+  WorkingHours,
+} from 'simplycms/contracts';
+import type { ActorDb } from './db';
+
+/** Точка видачі без опційної вкладеної зони — зона їде окремим списком. */
+export type PickupPointRow = Omit<PickupPoint, 'zone'>;
+
+/** Активні точки видачі — вибір самовивозу в чекауті. */
+export async function loadPickupPoints(db: ActorDb): Promise<PickupPointRow[]> {
+  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 ?? {}) as WorkingHours,
+    phone: row.phone,
+    is_active: row.isActive,
+    is_system: row.isSystem,
+    sort_order: row.sortOrder,
+    coordinates: (row.coordinates ?? null) as Coordinates | null,
+    created_at: row.createdAt,
+  }));
+}

package/src/storefront/loaders/pricing.ts

@@ -0,0 +1,23 @@
+import { eq } from 'drizzle-orm';
+import { priceTypes } from 'simplycms/schema';
+import type { ActorDb } from './db';
+
+/**
+ * ID типу ціни «за замовчуванням». Потрібен серверному резолву цін у списках
+ * каталогу: SSR рендериться анонімно, тож ціни рахуються саме за цим типом,
+ * а персональний тип покупця доклеює клієнт.
+ *
+ * Унікальний частковий індекс `idx_price_types_single_default` гарантує не
+ * більше одного рядка, тож `limit(1)` тут — не «беремо перший-ліпший».
+ */
+export async function loadDefaultPriceTypeId(
+  db: ActorDb,
+): Promise<string | null> {
+  const [row] = await db
+    .select({ id: priceTypes.id })
+    .from(priceTypes)
+    .where(eq(priceTypes.isDefault, true))
+    .limit(1);
+
+  return row?.id ?? null;
+}

package/src/storefront/loaders/product-detail.ts

@@ -0,0 +1,90 @@
+import { and, eq } from 'drizzle-orm';
+import {
+  productModifications,
+  productPrices,
+  productPropertyValues,
+  products,
+  propertyOptions,
+  sectionProperties,
+  sections,
+} from 'simplycms/schema';
+import type { PriceEntry } from 'simplycms/contracts';
+import type { ActorDb } from './db';
+import {
+  productColumns,
+  toImageList,
+  type ProductRow,
+} from './entities/product';
+import {
+  modificationColumns,
+  toModificationRow,
+  type ModificationRow,
+} from './entities/modification';
+import { priceColumns, toPriceEntry } from './entities/price';
+import { sectionRefColumns, type SectionRef } from './entities/section';
+import { propertyValueColumns, toPropertyValueRow } from './property-values';
+import type { ProductPropertyValueRow } from './property-values';
+
+/** Товар сторінки картки разом з усіма приєднаними гілками. */
+export type ProductDetailRow = ProductRow & {
+  sections: SectionRef | null;
+  product_modifications: ModificationRow[];
+  product_prices: PriceEntry[];
+  product_property_values: ProductPropertyValueRow[];
+};
+
+/**
+ * Товар за slug — з розділом, модифікаціями, цінами й характеристиками.
+ *
+ * 🔴 `is_active = true` тут ОБОВʼЯЗКОВИЙ, хоч у старому коді його не було:
+ * без нього чернетка товару відкривалася прямим посиланням і потрапляла в
+ * JSON-LD. Клієнтський запит картки цей предикат мав завжди — тобто SSR і
+ * гідрація давали різний результат на тому самому URL.
+ */
+export async function loadProduct(
+  db: ActorDb,
+  slug: string,
+): Promise<ProductDetailRow | null> {
+  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;
+
+  // Послідовно — причина та сама, що в `./products`: одне зʼєднання.
+  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),
+  };
+}

package/src/storefront/loaders/products.ts

@@ -0,0 +1,106 @@
+import { and, desc, eq, inArray } from 'drizzle-orm';
+import {
+  productModifications,
+  productPrices,
+  products,
+  sections,
+} from 'simplycms/schema';
+import type { PriceEntry } from 'simplycms/contracts';
+import type { ActorDb } from './db';
+import { toImageList } from './entities/product';
+import { listModificationColumns } from './entities/modification';
+import { groupPricesByProduct, priceColumns } from './entities/price';
+
+/** Модифікація в рядку списку — рівно те, чим обирається ціна за замовчуванням. */
+export interface ProductListModification {
+  id: string;
+  is_default: boolean;
+  sort_order: number;
+}
+
+/**
+ * Рядок списку каталогу. Вузький навмисно: назовні їде вже DTO
+ * (`toProductListItem`), тож повний товар тут був би трафіком у нікуди.
+ */
+export interface ProductListRow {
+  id: string;
+  slug: string;
+  name: string;
+  images: string[];
+  has_modifications: boolean | null;
+  sections: { slug: string } | null;
+  product_modifications: ProductListModification[];
+  product_prices: PriceEntry[];
+}
+
+/**
+ * Список товарів каталогу — цілком або звужений розділом.
+ *
+ * 🔴 Три запити, а не запит на товар: модифікації й ціни тягнуться одним
+ * `inArray` по всіх знайдених товарах. Так само свідомо НЕ один запит із
+ * join-ом: join на дві колекції розмножив би рядки товару m×n, і збирати їх
+ * назад довелося б у памʼяті — тобто той самий обсяг роботи, але з дублями
+ * у відповіді БД.
+ *
+ * 🔴 `is_active = true` — обовʼязковий предикат видимості (пояснення — у
+ * `./sections`). Розділ у фільтрі не робить його зайвим: неактивний товар
+ * лишається в активному розділі.
+ */
+export async function loadProductList(
+  db: ActorDb,
+  sectionId?: string,
+): Promise<ProductListRow[]> {
+  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 [];
+
+  // 🔴 Запити ПОСЛІДОВНІ, а не `Promise.all`. Транзакція живе на ОДНОМУ
+  // зʼєднанні, тож паралелити нічого: драйвер усе одно вишикує їх у чергу,
+  // а `pg` таке використання вже позначив застарілим (прибирається в pg@9).
+  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: Record<string, ProductListModification[]> = {};
+  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] ?? [],
+  }));
+}