simplycms 0.4.0

package/src/domain/discounts.ts

@@ -0,0 +1,435 @@
+// Discount Engine — pure-логіка обчислення дерева знижок.
+// Перенесено з core/lib/discountEngine; типи — з simplycms/contracts.
+
+import type {
+  Discount,
+  DiscountGroup,
+  DiscountContext,
+  DiscountCondition,
+  DiscountTarget,
+  DiscountResult,
+  AppliedDiscount,
+  RejectedDiscount,
+} from 'simplycms/contracts';
+
+export type {
+  DiscountType,
+  GroupOperator,
+  TargetType,
+  DiscountTarget,
+  DiscountCondition,
+  Discount,
+  DiscountGroup,
+  DiscountContext,
+  AppliedDiscount,
+  RejectedDiscount,
+  DiscountResult,
+} from 'simplycms/contracts';
+
+// --- Date check ---
+function isWithinDateRange(
+  startsAt: string | null,
+  endsAt: string | null,
+  now: Date,
+): boolean {
+  if (startsAt && new Date(startsAt) > now) return false;
+  if (endsAt && new Date(endsAt) < now) return false;
+  return true;
+}
+
+// --- Target matching ---
+function matchesTarget(
+  targets: DiscountTarget[],
+  ctx: DiscountContext,
+): boolean {
+  if (!targets.length) return true; // no targets = applies to all
+  return targets.some((t) => {
+    if (t.target_type === 'all') return true;
+    if (t.target_type === 'product') return t.target_id === ctx.productId;
+    if (t.target_type === 'modification')
+      return t.target_id === ctx.modificationId;
+    if (t.target_type === 'section') return t.target_id === ctx.sectionId;
+    return false;
+  });
+}
+
+// --- Condition evaluation ---
+function evaluateCondition(
+  cond: DiscountCondition,
+  ctx: DiscountContext,
+): { met: boolean; reason: string } {
+  const { condition_type, operator, value } = cond;
+
+  switch (condition_type) {
+    case 'user_category': {
+      if (!ctx.userCategoryId)
+        return { met: false, reason: 'Користувач без категорії' };
+      const ids: string[] = (
+        Array.isArray(value) ? value : [value]
+      ) as string[];
+      const met =
+        operator === 'in'
+          ? ids.includes(ctx.userCategoryId)
+          : !ids.includes(ctx.userCategoryId);
+      return {
+        met,
+        reason: met ? '' : `Категорія користувача не входить у список`,
+      };
+    }
+    case 'min_quantity': {
+      const met = compareNumeric(ctx.quantity, operator, Number(value));
+      return {
+        met,
+        reason: met
+          ? ''
+          : `Кількість ${ctx.quantity} не відповідає умові ${operator} ${value}`,
+      };
+    }
+    case 'min_order_amount': {
+      const met = compareNumeric(ctx.cartTotal, operator, Number(value));
+      return {
+        met,
+        reason: met
+          ? ''
+          : `Сума кошика ${ctx.cartTotal} не відповідає умові ${operator} ${value}`,
+      };
+    }
+    case 'user_logged_in': {
+      const expected = value === true || value === 'true';
+      const met = ctx.isLoggedIn === expected;
+      return {
+        met,
+        reason: met
+          ? ''
+          : expected
+            ? 'Потрібна авторизація'
+            : 'Тільки для гостей',
+      };
+    }
+    default:
+      return { met: false, reason: `Невідомий тип умови: ${condition_type}` };
+  }
+}
+
+function compareNumeric(
+  actual: number,
+  operator: string,
+  expected: number,
+): boolean {
+  switch (operator) {
+    case '>=':
+      return actual >= expected;
+    case '>':
+      return actual > expected;
+    case '<=':
+      return actual <= expected;
+    case '<':
+      return actual < expected;
+    case '=':
+      return actual === expected;
+    default:
+      return false;
+  }
+}
+
+// --- Single discount calculation ---
+function calculateDiscountAmount(
+  basePrice: number,
+  discount: Discount,
+): number {
+  switch (discount.discount_type) {
+    case 'percent':
+      return basePrice * (discount.discount_value / 100);
+    case 'fixed_amount':
+      return Math.min(discount.discount_value, basePrice);
+    case 'fixed_price':
+      return Math.max(0, basePrice - discount.discount_value);
+    default:
+      return 0;
+  }
+}
+
+// --- Evaluate a single discount against context ---
+interface EvalResult {
+  applicable: boolean;
+  amount: number;
+  discount: Discount;
+  rejectionReasons: string[];
+}
+
+function evaluateDiscount(
+  discount: Discount,
+  basePrice: number,
+  ctx: DiscountContext,
+  now: Date,
+): EvalResult {
+  const reasons: string[] = [];
+
+  if (!discount.is_active) {
+    return {
+      applicable: false,
+      amount: 0,
+      discount,
+      rejectionReasons: ['Скидка неактивна'],
+    };
+  }
+  if (!isWithinDateRange(discount.starts_at, discount.ends_at, now)) {
+    return {
+      applicable: false,
+      amount: 0,
+      discount,
+      rejectionReasons: ['Скидка поза терміном дії'],
+    };
+  }
+  if (!matchesTarget(discount.targets, ctx)) {
+    return {
+      applicable: false,
+      amount: 0,
+      discount,
+      rejectionReasons: ['Товар не входить у цілі скидки'],
+    };
+  }
+
+  // Evaluate all conditions
+  for (const cond of discount.conditions) {
+    const { met, reason } = evaluateCondition(cond, ctx);
+    if (!met) reasons.push(reason);
+  }
+
+  if (reasons.length > 0) {
+    return {
+      applicable: false,
+      amount: 0,
+      discount,
+      rejectionReasons: reasons,
+    };
+  }
+
+  const amount = calculateDiscountAmount(basePrice, discount);
+  return { applicable: true, amount, discount, rejectionReasons: [] };
+}
+
+// --- Group evaluation (recursive) ---
+interface GroupResult {
+  totalAmount: number;
+  applied: AppliedDiscount[];
+  rejected: RejectedDiscount[];
+}
+
+function evaluateGroup(
+  group: DiscountGroup,
+  basePrice: number,
+  ctx: DiscountContext,
+  now: Date,
+): GroupResult {
+  const applied: AppliedDiscount[] = [];
+  const rejected: RejectedDiscount[] = [];
+
+  if (!group.is_active) return { totalAmount: 0, applied, rejected };
+  if (!isWithinDateRange(group.starts_at, group.ends_at, now))
+    return { totalAmount: 0, applied, rejected };
+
+  // Evaluate all direct discounts in this group (sorted by priority)
+  const sortedDiscounts = [...group.discounts].sort(
+    (a, b) => a.priority - b.priority,
+  );
+  const evalResults: EvalResult[] = sortedDiscounts.map((d) =>
+    evaluateDiscount(d, basePrice, ctx, now),
+  );
+
+  // Evaluate child groups recursively
+  const sortedChildren = [...group.children].sort(
+    (a, b) => a.priority - b.priority,
+  );
+  const childResults: GroupResult[] = sortedChildren.map((child) =>
+    evaluateGroup(child, basePrice, ctx, now),
+  );
+
+  // Collect all amounts (from both discounts and child groups)
+  const allAmounts: { amount: number; source: AppliedDiscount | null }[] = [];
+
+  for (const res of evalResults) {
+    if (res.applicable) {
+      const entry: AppliedDiscount = {
+        id: res.discount.id,
+        name: res.discount.name,
+        type: res.discount.discount_type,
+        value: res.discount.discount_value,
+        calculatedAmount: res.amount,
+        groupName: group.name,
+      };
+      allAmounts.push({ amount: res.amount, source: entry });
+    } else {
+      rejected.push({
+        id: res.discount.id,
+        name: res.discount.name,
+        reason: res.rejectionReasons.join('; '),
+        groupName: group.name,
+      });
+    }
+  }
+
+  for (const cr of childResults) {
+    applied.push(...cr.applied);
+    rejected.push(...cr.rejected);
+    if (cr.totalAmount > 0) {
+      allAmounts.push({ amount: cr.totalAmount, source: null });
+    }
+  }
+
+  // Apply group operator
+  let totalAmount = 0;
+
+  switch (group.operator) {
+    case 'and': {
+      // Sum all applicable
+      for (const a of allAmounts) {
+        totalAmount += a.amount;
+        if (a.source) applied.push(a.source);
+      }
+      break;
+    }
+    case 'or': {
+      // First applicable by priority
+      const first = allAmounts[0];
+      if (first) {
+        totalAmount = first.amount;
+        if (first.source) applied.push(first.source);
+        // Reject the rest
+        for (let i = 1; i < allAmounts.length; i++) {
+          const s = allAmounts[i].source;
+          if (s) {
+            rejected.push({
+              id: s.id,
+              name: s.name,
+              reason: 'Оператор OR: обрано скидку з вищим пріоритетом',
+              groupName: group.name,
+            });
+          }
+        }
+      }
+      break;
+    }
+    case 'not': {
+      // If any discount is applicable, NONE apply (inversion)
+      if (allAmounts.length > 0) {
+        for (const a of allAmounts) {
+          if (a.source) {
+            rejected.push({
+              id: a.source.id,
+              name: a.source.name,
+              reason: 'Оператор NOT: умови виконані, скидка інвертована',
+              groupName: group.name,
+            });
+          }
+        }
+        totalAmount = 0;
+      }
+      break;
+    }
+    case 'min': {
+      // Pick minimum discount
+      if (allAmounts.length > 0) {
+        let minIdx = 0;
+        for (let i = 1; i < allAmounts.length; i++) {
+          if (allAmounts[i].amount < allAmounts[minIdx].amount) minIdx = i;
+        }
+        totalAmount = allAmounts[minIdx].amount;
+        for (let i = 0; i < allAmounts.length; i++) {
+          const s = allAmounts[i].source;
+          if (i === minIdx) {
+            if (s) applied.push(s);
+          } else if (s) {
+            rejected.push({
+              id: s.id,
+              name: s.name,
+              reason: 'Оператор MIN: обрано меншу скидку',
+              groupName: group.name,
+            });
+          }
+        }
+      }
+      break;
+    }
+    case 'max': {
+      // Pick maximum discount
+      if (allAmounts.length > 0) {
+        let maxIdx = 0;
+        for (let i = 1; i < allAmounts.length; i++) {
+          if (allAmounts[i].amount > allAmounts[maxIdx].amount) maxIdx = i;
+        }
+        totalAmount = allAmounts[maxIdx].amount;
+        for (let i = 0; i < allAmounts.length; i++) {
+          const s = allAmounts[i].source;
+          if (i === maxIdx) {
+            if (s) applied.push(s);
+          } else if (s) {
+            rejected.push({
+              id: s.id,
+              name: s.name,
+              reason: 'Оператор MAX: обрано більшу скидку',
+              groupName: group.name,
+            });
+          }
+        }
+      }
+      break;
+    }
+  }
+
+  // Handle fixed_price conflict in AND groups: fixed_price wins
+  if (group.operator === 'and') {
+    const fixedPriceDiscount = applied.find((a) => a.type === 'fixed_price');
+    if (fixedPriceDiscount) {
+      // fixed_price overrides everything else
+      const others = applied.filter((a) => a.id !== fixedPriceDiscount.id);
+      for (const o of others) {
+        rejected.push({
+          id: o.id,
+          name: o.name,
+          reason: 'Фіксована ціна має пріоритет в групі AND',
+          groupName: group.name,
+        });
+      }
+      return {
+        totalAmount: fixedPriceDiscount.calculatedAmount,
+        applied: [fixedPriceDiscount],
+        rejected,
+      };
+    }
+  }
+
+  return { totalAmount, applied, rejected };
+}
+
+// --- Main export ---
+export function resolveDiscount(
+  basePrice: number,
+  groups: DiscountGroup[],
+  context: DiscountContext,
+): DiscountResult {
+  const now = context.now || new Date();
+  let totalDiscount = 0;
+  const allApplied: AppliedDiscount[] = [];
+  const allRejected: RejectedDiscount[] = [];
+
+  // Evaluate all root-level groups, sorted by priority
+  const sorted = [...groups].sort((a, b) => a.priority - b.priority);
+
+  for (const group of sorted) {
+    const result = evaluateGroup(group, basePrice, context, now);
+    totalDiscount += result.totalAmount;
+    allApplied.push(...result.applied);
+    allRejected.push(...result.rejected);
+  }
+
+  // Ensure discount doesn't exceed base price
+  totalDiscount = Math.min(totalDiscount, basePrice);
+
+  return {
+    finalPrice: Math.max(0, basePrice - totalDiscount),
+    totalDiscount,
+    appliedDiscounts: allApplied,
+    rejectedDiscounts: allRejected,
+  };
+}

package/src/domain/index.ts

@@ -0,0 +1,10 @@
+// simplycms/domain — Tier 1 pure commerce logic.
+// Subpath-exports: ./pricing, ./discounts, ./inventory, ./shipping, ./money,
+// ./user-categories.
+
+export * from './pricing';
+export * from './discounts';
+export * from './inventory';
+export * from './shipping';
+export * from './money';
+export * from './user-categories';

package/src/domain/inventory.ts

@@ -0,0 +1,54 @@
+// Pure-розрахунок наявності товару. Перенесено з core/hooks/useProductsWithStock
+// (тільки чисті функції; data-fetch лишається у data-шарі).
+
+import type { StockData, ProductAvailabilityInput } from 'simplycms/contracts';
+
+export type { StockData, ProductAvailabilityInput } from 'simplycms/contracts';
+
+/**
+ * Обчислює доступність товару тією ж логікою, що й RPC get_stock_info:
+ * is_available = total_quantity > 0 OR stock_status = 'on_order'
+ */
+export function calculateProductAvailability(
+  product: ProductAvailabilityInput,
+  stockData: StockData,
+): boolean {
+  const mods = product.product_modifications || [];
+  const hasModifications = product.has_modifications ?? true;
+
+  if (hasModifications && mods.length > 0) {
+    // Для товарів з модифікаціями: доступний, якщо доступна БУДЬ-ЯКА модифікація
+    return mods.some((m) => {
+      const modQty = stockData.modificationStock[m.id] || 0;
+      return modQty > 0 || m.stock_status === 'on_order';
+    });
+  } else {
+    // Для простих товарів: перевіряємо склад з inline-даних або stockData
+    const inlineStock = (product.stock_by_pickup_point || []).reduce(
+      (sum, s) => sum + (s.quantity || 0),
+      0,
+    );
+    const productQty = stockData.productStock[product.id] || inlineStock;
+    return productQty > 0 || product.stock_status === 'on_order';
+  }
+}
+
+/**
+ * Збагачує товари полем isAvailable на основі даних про склад.
+ */
+export function enrichProductsWithAvailability<
+  T extends ProductAvailabilityInput,
+>(
+  products: T[],
+  modStockData: Record<string, number>,
+): (T & { isAvailable: boolean })[] {
+  const stockData: StockData = {
+    modificationStock: modStockData,
+    productStock: {},
+  };
+
+  return products.map((product) => ({
+    ...product,
+    isAvailable: calculateProductAvailability(product, stockData),
+  }));
+}

package/src/domain/money.ts

@@ -0,0 +1,80 @@
+// Детерміноване форматування ціни — не залежить від версії CLDR рушія.
+// ДЕФЕКТ, який лагодить цей модуль: `new Intl.NumberFormat(locale, { style:
+// 'currency', currency }).format(n)` бере символ валюти з ICU-даних, вшитих у
+// рушій, а вони різняться між Node (SSR) і Chromium (клієнт) — той самий
+// виклик на uk-UA/UAH віддає "₴" на сервері й "грн" у браузері. Наслідок —
+// гідраційний мисматч на кожній картці товару. Групування розрядів (напр.
+// "4 200") в обох рантаймах ІДЕНТИЧНЕ (перевірено побайтово), тому число й
+// далі форматуємо через Intl (`style: 'decimal'` — без символу валюти), а сам
+// символ беремо з явної мапи нижче, яку рушій змінити не може.
+//
+// Живе в simplycms/domain (T1, pure-логіка, 0 IO), а не в simplycms/contracts
+// (T0, лише типи) — це виконуваний код, і не в react-query (T2) — форматування
+// ціни потрібне й поза React (напр. SSR-генератори SEO/метатегів).
+
+import type { ConfigProvider } from 'simplycms/contracts';
+
+/**
+ * Символи валют, які фактично використовує вітрина. Явна мапа замість
+ * `Intl.NumberFormat({ style: 'currency' })` — саме останній рушій-залежний,
+ * звідси й дефект (див. коментар вище). Невідома валюта — фолбек на її ISO-код
+ * (напр. "PLN"), а не на порожній рядок: краще видимий код, ніж мовчазна втрата
+ * інформації про валюту.
+ */
+const CURRENCY_SYMBOLS: Readonly<Record<string, string>> = {
+  UAH: '₴',
+  USD: '$',
+  EUR: '€',
+};
+
+/**
+ * Кількість знаків після коми.
+ *
+ * 🔴 Дефолт саме **0/2**, і це не смак. Тринадцять із чотирнадцяти кол-сайтів,
+ * які цей модуль заміщає, передавали рівно `minimumFractionDigits: 0` — і
+ * НІЧОГО більше. Для `style: 'currency'` невказаний `maximumFractionDigits`
+ * дорівнює розрядності валюти, тобто 2. Тому:
+ *   0/2 → "4 200 ₴" і "4 200,5 ₴"   (побайтово те саме, що було);
+ *   2/2 → "4 200,00 ₴"               (зайві нулі там, де їх не було);
+ *   0/0 → "4 201 ₴"                  (🔴 копійки ОКРУГЛЮЮТЬСЯ ГЕТЬ — це вже
+ *                                     неправильна сума, а не косметика).
+ * Перевірено прогоном на 4200 / 4200.5 / 4200.55 / 4200.555 / 0 / 99.9.
+ * Єдиний кол-сайт, що покладався на валютний дефолт 2/2
+ * (`admin/components/ProductModifications.tsx`), передає `2` явно.
+ */
+export interface FormatPriceOptions {
+  minimumFractionDigits?: number;
+  maximumFractionDigits?: number;
+}
+
+/**
+ * Форматує ціну як "<число><NBSP><символ>" — саме такий порядок і роздільник
+ * (U+00A0, не звичайний пробіл) віддає `Intl.NumberFormat('uk-UA', { style:
+ * 'currency', ... })` для гривні, і його явно збережено, бо валютний хвіст
+ * тепер формуємо самі, а не Intl. 🔴 Порядок "число-символ" зафіксований під
+ * поточну вітрину (лише uk-UA в експлуатації, `simplycms.config.ts`) —
+ * per-locale розташування символу (напр. "$100" в en-US) поза межами цього
+ * фікса: воно б знову зажадало `style: 'currency'` з тими самими CLDR-ризиками.
+ */
+export function formatPrice(
+  value: number,
+  config: Pick<ConfigProvider, 'locale' | 'currency'>,
+  options: FormatPriceOptions = {},
+): string {
+  const { minimumFractionDigits = 0, maximumFractionDigits = 2 } = options;
+
+  const number = new Intl.NumberFormat(config.locale, {
+    style: 'decimal',
+    minimumFractionDigits,
+    maximumFractionDigits,
+  }).format(value);
+
+  const code = config.currency.toUpperCase();
+  const symbol = CURRENCY_SYMBOLS[code] ?? config.currency;
+
+  // Роздільник \u00a0 (NBSP) -- саме такий байт (не звичайний пробіл, U+0020)
+  // Intl.NumberFormat('uk-UA', { style: 'currency' }) ставить між числом і
+  // символом валюти (перевірено побайтово). Escape-літерал у джерелі, а не
+  // сирий символ, -- щоб NBSP не загубився під час майбутнього редагування.
+  return `${number}\u00a0${symbol}`;
+}

package/src/domain/pricing.ts

@@ -0,0 +1,40 @@
+// Pure-логіка ціноутворення. Перенесено з core/lib/priceUtils.
+// Залежить лише від типів simplycms/contracts.
+
+import type { PriceEntry, ResolvedPrice } from 'simplycms/contracts';
+
+export type { PriceEntry, ResolvedPrice } from 'simplycms/contracts';
+
+/**
+ * Обирає ціну для товару/модифікації за типом ціни користувача,
+ * з відкатом до типу ціни за замовчуванням.
+ */
+export function resolvePrice(
+  prices: PriceEntry[],
+  priceTypeId: string | null,
+  defaultPriceTypeId: string | null,
+  modificationId: string | null = null,
+): ResolvedPrice {
+  if (!prices?.length) return { price: null, oldPrice: null };
+
+  const match = (typeId: string) =>
+    prices.find(
+      (p) =>
+        p.price_type_id === typeId &&
+        (modificationId
+          ? p.modification_id === modificationId
+          : !p.modification_id),
+    );
+
+  if (priceTypeId) {
+    const entry = match(priceTypeId);
+    if (entry) return { price: entry.price, oldPrice: entry.old_price };
+  }
+
+  if (defaultPriceTypeId && defaultPriceTypeId !== priceTypeId) {
+    const entry = match(defaultPriceTypeId);
+    if (entry) return { price: entry.price, oldPrice: entry.old_price };
+  }
+
+  return { price: null, oldPrice: null };
+}