@floristcloud/api-lib 1.2.108 → 1.2.110

package/schemas/non-negative-money.schema.ts

@@ -0,0 +1,15 @@
+import { MoneySchema } from './money.schema';
+
+/**
+ * Денежная величина, которая не может быть отрицательной: цена, стоимость доставки, сумма позиции.
+ *
+ * На строковом формате знак проверяется по первому символу — это единственный признак
+ * отрицательности в `MoneySchema` (`^-?\d+(\.\d{1,2})?$`), поэтому приводить величину к числу ради
+ * сравнения не нужно и не следует.
+ *
+ * Разницу с [[PositiveMoneySchema]] стоит держать в голове: здесь ноль допустим (бесплатная доставка,
+ * позиция с нулевой ценой), а там — нет.
+ */
+export const NonNegativeMoneySchema = MoneySchema.refine(value => !value.startsWith('-'), {
+    message: 'validation.money.nonNegative',
+});

package/schemas/order/order.schema.ts

@@ -4,6 +4,7 @@ import { ClientSchema } from '../client';
 import { BranchSchema } from '../branch/branch.schema';
 import { OrderDeliverySchema } from '../order-delivery/order-delivery.schema';
 import { DeliveryRouteSchema } from '../delivery-route/delivery-route.schema';
+import { MoneySchema } from '../money.schema';
 
 export const OrderSchema = z.object({
     uuid: z.uuid(),
@@ -12,14 +13,14 @@ export const OrderSchema = z.object({
     branchUUID: z.uuid().nullable(),
     creatorUserUUID: z.uuid(),
 
-    totalCost: z.number(),
-    subtotal: z.number(),
-    deliveryCost: z.number(),
-    deliveryCheckAmount: z.number(),
-    deliveryVatAmount: z.number(),
+    totalCost: MoneySchema,
+    subtotal: MoneySchema,
+    deliveryCost: MoneySchema,
+    deliveryCheckAmount: MoneySchema,
+    deliveryVatAmount: MoneySchema,
     deliveryVat: z.number().nullable(),
-    vatAmount: z.number(),
-    discountAmount: z.number(),
+    vatAmount: MoneySchema,
+    discountAmount: MoneySchema,
     discount: z.number().nullable(),
 
     status: z.nativeEnum(OrderStatusEnum),
@@ -68,9 +69,9 @@ export const OrderExtendedForClientSchema = OrderForClientSchema.extend({
     client: ClientSchema,
     branch: BranchSchema.nullable(),
     delivery: OrderDeliverySchema.nullable(),
-    writeOffSum: z.number().nullable(),
+    writeOffSum: MoneySchema.nullable(),
     consignmentDeliveryDates: z.union([z.date(), z.literal('in-stock')]).array(),
     // Server-computed delivery cost for the current subtotal when the tier rule is on (null when off).
     // Convenience preview for the cart page; the storefront still recomputes locally on the delivery/pickup toggle.
-    deliveryCostPreview: z.number().nullable(),
+    deliveryCostPreview: MoneySchema.nullable(),
 });

package/schemas/order-product/order-product-multiplicity-optiom.schema.ts

@@ -1,8 +1,9 @@
 import { z } from 'zod';
+import { MoneySchema } from '../money.schema';
 
 export const OrderProductMultiplicityOptionSchema = z.object({
     uuid: z.uuid(),
     title: z.string().nullable(),
     optionMultiplicity: z.coerce.number(),
-    optionPrice: z.coerce.number().nullable(),
+    optionPrice: MoneySchema.nullable(),
 });

package/schemas/order-product/order-product.schema.ts

@@ -5,6 +5,7 @@ import { ClientSchema } from '../client';
 import { BranchSchema } from '../branch/branch.schema';
 import { DistributionSchema } from '../distribution/distribution.schema';
 import { OrderProductMultiplicityOptionSchema } from './order-product-multiplicity-optiom.schema';
+import { MoneySchema } from '../money.schema';
 
 export const OrderProductSchema = z.object({
     uuid: z.uuid(),
@@ -13,11 +14,11 @@ export const OrderProductSchema = z.object({
     multiplicityOptionUUID: z.uuid().nullable().optional(),
 
     quantity: z.number(),
-    price: z.number(),
-    amount: z.number(),
-    vatAmount: z.number(),
+    price: MoneySchema,
+    amount: MoneySchema,
+    vatAmount: MoneySchema,
     vat: z.number().nullable(),
-    checkAmount: z.number(),
+    checkAmount: MoneySchema,
 
     comment: z.string().nullable(),
     tag: z.string().nullable(),

package/schemas/order-product/price-correction-analyze-item.schema.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { OrderStatusEnum } from '../../enum';
 import { ErrorMessageSchema } from '../error-message.schema';
+import { MoneySchema } from '../money.schema';
 
 export const PriceCorrectionAnalyzeItemSchema = z.object({
     orderProductUUID: z.string(),
@@ -20,17 +21,18 @@ export const PriceCorrectionAnalyzeItemSchema = z.object({
     article: z.string().nullable(),
     color: z.string().nullable(),
 
-    currentPrice: z.number(),
-    currentAmount: z.number(),
+    currentPrice: MoneySchema,
+    currentAmount: MoneySchema,
     quantity: z.number(),
 
-    newPriceWithoutDiscount: z.number(),
-    newPriceWithDiscount: z.number(),
-    newAmountWithoutDiscount: z.number(),
-    newAmountWithDiscount: z.number(),
+    newPriceWithoutDiscount: MoneySchema,
+    newPriceWithDiscount: MoneySchema,
+    newAmountWithoutDiscount: MoneySchema,
+    newAmountWithDiscount: MoneySchema,
 
-    priceDifferenceWithoutDiscount: z.number(),
-    priceDifferenceWithDiscount: z.number(),
+    // Разницы могут быть отрицательными — цена корректируется в обе стороны, поэтому без ограничения знака.
+    priceDifferenceWithoutDiscount: MoneySchema,
+    priceDifferenceWithDiscount: MoneySchema,
 
     isSkipped: z.boolean(),
     skipReason: ErrorMessageSchema.optional(),

package/schemas/order-product/price-correction-execute-result-item.schema.ts

@@ -1,11 +1,12 @@
 import { z } from 'zod';
 import { ErrorMessageSchema } from '../error-message.schema';
+import { MoneySchema } from '../money.schema';
 
 export const PriceCorrectionExecuteResultItemSchema = z.object({
     orderProductUUID: z.string(),
     orderUUID: z.string(),
     isSuccess: z.boolean(),
     error: ErrorMessageSchema.optional(),
-    oldPrice: z.number().optional(),
-    newPrice: z.number().optional(),
+    oldPrice: MoneySchema.optional(),
+    newPrice: MoneySchema.optional(),
 });

package/schemas/order-service-line/order-service-line.schema.ts

@@ -1,16 +1,24 @@
 import { z } from 'zod';
 import { ServicePricingUnitEnum } from '../../enum/service-pricing-unit.enum';
+import { MoneySchema } from '../money.schema';
+import { NonNegativeMoneySchema } from '../non-negative-money.schema';
+
+// Цена строки услуги: неотрицательная и не больше миллиарда. Знак берём из самой строки,
+// потолок — из разобранного значения: до 1e9 с двумя знаками число представимо точно.
+const OrderServiceLinePriceSchema = NonNegativeMoneySchema.refine(value => Number(value) <= 1_000_000_000, {
+    message: 'validation.money.max',
+});
 
 export const OrderServiceLineSchema = z.object({
     uuid: z.uuid(),
     orderUUID: z.uuid(),
     serviceUUID: z.uuid().nullable(),
     name: z.string(),
-    price: z.number(),
+    price: MoneySchema,
     quantity: z.number(),
-    amount: z.number(),
+    amount: MoneySchema,
     vat: z.number().nullable(),
-    vatAmount: z.number(),
+    vatAmount: MoneySchema,
     unit: z.nativeEnum(ServicePricingUnitEnum),
     comment: z.string().nullable(),
     createdAt: z.date(),
@@ -22,7 +30,7 @@ export const CreateOrderServiceLineRequestSchema = z
         orderUUID: z.uuid(),
         serviceUUID: z.uuid().optional(),
         name: z.string().min(1).max(255).optional(),
-        price: z.number().min(0).max(1_000_000_000).optional(),
+        price: OrderServiceLinePriceSchema.optional(),
         quantity: z.number().int().min(1).max(1_000_000).optional().default(1),
         vat: z.number().int().min(0).max(100).optional(),
         comment: z.string().max(1000).optional(),
@@ -32,7 +40,7 @@ export const CreateOrderServiceLineRequestSchema = z
     });
 
 export const UpdateOrderServiceLineRequestSchema = z.object({
-    price: z.number().min(0).max(1_000_000_000).optional(),
+    price: OrderServiceLinePriceSchema.optional(),
     quantity: z.number().int().min(1).max(1_000_000).optional(),
     comment: z.string().max(1000).nullable().optional(),
 });

package/schemas/payment-invoice/payment-invoice.schema.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { PaymentInvoiceStatusEnum } from '../../enum/payment-invoice-status.enum';
+import { MoneySchema } from '../money.schema';
 
 // Строка счёта. Для счёта, собранного из заказов, каждая строка — снимок заказа на момент
 // выставления: заказ потом может измениться, а выставленный счёт обязан остаться прежним.
@@ -8,16 +9,16 @@ const PaymentInvoiceItemSchema = z.object({
     orderId: z.number().nullable(),
     orderDate: z.coerce.date().nullable(),
     description: z.string(),
-    amount: z.coerce.number(),
+    amount: MoneySchema,
 });
 
 export const PaymentInvoiceSchema = z.object({
     uuid: z.string(),
     number: z.string(),
     invoiceDate: z.coerce.date(),
-    amount: z.coerce.number(),
-    paidAmount: z.coerce.number(),
-    remainingAmount: z.coerce.number(),
+    amount: MoneySchema,
+    paidAmount: MoneySchema,
+    remainingAmount: MoneySchema,
     status: z.nativeEnum(PaymentInvoiceStatusEnum),
     clientUUID: z.string(),
     clientName: z.string(),

package/schemas/positive-money.schema.ts

@@ -0,0 +1,16 @@
+import { MoneySchema } from './money.schema';
+
+/**
+ * Денежная величина строго больше нуля: сумма платежа, фиксированная скидка.
+ *
+ * Отличается от `NonNegativeMoneySchema` тем, что отвергает ноль — платёж на 0 рублей или скидка
+ * в 0 рублей это не операция, а ошибка ввода.
+ *
+ * Обе проверки строковые: знак берётся по первому символу, а ноль опознаётся по форме записи —
+ * `MoneySchema` уже гарантировал формат `^-?\d+(\.\d{1,2})?$`, поэтому нулю соответствуют ровно
+ * `0`, `0.0` и `0.00`. Через `Number()` это не проверяется намеренно: приводить деньги к float
+ * ради сравнения — то, от чего ушли.
+ */
+export const PositiveMoneySchema = MoneySchema.refine(value => !value.startsWith('-') && !/^0+(\.0*)?$/.test(value), {
+    message: 'validation.money.positive',
+});

package/schemas/pre-order/pre-order.schema.ts

@@ -3,6 +3,7 @@ import { PreOrderStatusEnum } from '../../enum';
 import { ClientSchema } from '../client';
 import { BranchSchema } from '../branch/branch.schema';
 import { PreOrderCollectionSchema } from '../pre-order-collection/pre-order-collection.schema';
+import { MoneySchema } from '../money.schema';
 
 export const PreOrderSchema = z.object({
     uuid: z.string(),
@@ -21,7 +22,7 @@ export const PreOrderExtendedSchema = PreOrderSchema.extend({
     preOrderCollection: PreOrderCollectionSchema.nullable(),
     totalPositions: z.number(),
     totalQuantity: z.number(),
-    totalPrice: z.number(),
+    totalPrice: MoneySchema,
 });
 
 export const PreOrderWithClientSchema = PreOrderSchema.extend({

package/schemas/pre-order-collection-item/pre-order-collection-item-multiplicity-option.schema.ts

@@ -1,9 +1,11 @@
 import { z } from 'zod';
+import { MoneySchema } from '../money.schema';
+import { NonNegativeMoneySchema } from '../non-negative-money.schema';
 
 export const PreOrderCollectionItemMultiplicityOptionSchema = z.object({
     uuid: z.string(),
     title: z.string().max(100).nullable(),
     optionMultiplicity: z.number().int().min(1),
-    optionPrice: z.number().min(0).nullable(),
+    optionPrice: NonNegativeMoneySchema.nullable(),
     rank: z.number().int().min(0),
 });

package/schemas/pre-order-collection-item/pre-order-collection-item.schema.ts

@@ -6,6 +6,7 @@ import { ClientSchema } from '../client';
 import { PreOrderProductSchema } from '../pre-order-product/pre-order-product.schema';
 import { SalesUnitEnum } from '../../enum';
 import { PreOrderCollectionItemMultiplicityOptionSchema } from './pre-order-collection-item-multiplicity-option.schema';
+import { MoneySchema } from '../money.schema';
 
 export const PreOrderCollectionItemSchema = z.object({
     uuid: z.string(),
@@ -18,7 +19,7 @@ export const PreOrderCollectionItemSchema = z.object({
     quantity: z.number().nullable(),
     balance: z.number().nullable(),
     imageUUID: z.string().nullable(),
-    price: z.number(),
+    price: MoneySchema,
     advancedPrice: z.string().nullable(),
     grower: z.string().nullable(),
     size: z.string().nullable(),
@@ -47,7 +48,7 @@ export const CreatePreOrderCollectionItemSchema = z.object({
     quantity: z.coerce.number().nullable().optional(),
     balance: z.coerce.number().nullable().optional(),
     imageUUID: z.string().nullable().optional(),
-    price: z.coerce.number(),
+    price: MoneySchema,
     advancedPrice: z.string().nullable().optional(),
     grower: z.string().nullable().optional(),
     size: z.string().nullable().optional(),
@@ -76,7 +77,7 @@ export const UpdatePreOrderCollectionItemSchema = z
         quantity: z.coerce.number().nullable(),
         balance: z.coerce.number().nullable(),
         imageUUID: z.string().nullable(),
-        price: z.coerce.number(),
+        price: MoneySchema,
         advancedPrice: z.string().nullable(),
         grower: z.string().nullable(),
         size: z.string().nullable(),

package/schemas/pre-order-product/pre-order-product.schema.ts

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { PreOrderCollectionItemExtendedSchema } from '../pre-order-collection-item/pre-order-collection-item.schema';
 import { CategorySchema } from '../category/category.schema';
 import { PreOrderCollectionItemMultiplicityOptionSchema } from '../pre-order-collection-item/pre-order-collection-item-multiplicity-option.schema';
+import { MoneySchema } from '../money.schema';
 
 export const MatchingConfigSchema = z.object({
     matchByName: z.coerce.boolean(),
@@ -22,13 +23,13 @@ export const PreOrderProductSchema = z.object({
     tag: z.string().nullable(),
     isPurchased: z.boolean(),
     isReplaceable: z.boolean(),
-    stopPrice: z.number().nullable(),
+    stopPrice: MoneySchema.nullable(),
     highAttention: z.boolean(),
     categoryUUID: z.string().nullable(),
     name: z.string().nullable(),
     grower: z.string().nullable(),
     size: z.string().nullable(),
-    price: z.number().nullable(),
+    price: MoneySchema.nullable(),
     color: z.string().nullable(),
     parentPreOrderProductUUID: z.string().nullable(),
     matchingConfig: MatchingConfigSchema.optional().nullable(),
@@ -47,7 +48,7 @@ export const CreatePreOrderProductSchema = PreOrderProductSchema.omit({ uuid: tr
     name: z.string().nullable().optional(),
     grower: z.string().nullable().optional(),
     size: z.string().nullable().optional(),
-    price: z.number().nullable().optional(),
+    price: MoneySchema.nullable().optional(),
     color: z.string().nullable().optional(),
     parentPreOrderProductUUID: z.string().nullable().optional(),
     matchingConfig: MatchingConfigSchema.optional().nullable(),
@@ -63,7 +64,7 @@ export const UpdatePreOrderProductSchema = PreOrderProductSchema.omit({
         name: z.string().nullable().optional(),
         grower: z.string().nullable().optional(),
         size: z.string().nullable().optional(),
-        price: z.number().nullable().optional(),
+        price: MoneySchema.nullable().optional(),
         color: z.string().nullable().optional(),
         parentPreOrderProductUUID: z.string().nullable().optional(),
         matchingConfig: MatchingConfigSchema.optional().nullable(),

package/schemas/product/product-multiplicity-option.schema.ts

@@ -1,9 +1,10 @@
 import { z } from 'zod';
+import { MoneySchema } from '../money.schema';
 
 export const ProductMultiplicityOptionSchema = z.object({
     uuid: z.uuid(),
     title: z.string().nullable(),
     optionMultiplicity: z.number(),
-    optionPrice: z.number().nullable(),
+    optionPrice: MoneySchema.nullable(),
     rank: z.number(),
 });

package/schemas/product/product.schema.ts

@@ -6,6 +6,7 @@ import { ConsignmentSchema } from '../consignment/consignment.schema';
 import { DiscountRulesTypeEnum, ProductMarkEnum, SalesUnitEnum } from '../../enum';
 import { discountRulesModeSchema } from '../discount-rules/discount-rules.schema';
 import { ProductMultiplicityOptionSchema } from '../..';
+import { MoneySchema } from '../money.schema';
 
 export const ProductSchema = z.object({
     uuid: z.uuid(),
@@ -15,8 +16,8 @@ export const ProductSchema = z.object({
 
     balance: z.number(),
     quantity: z.number(),
-    price: z.number(),
-    costPrice: z.number(),
+    price: MoneySchema,
+    costPrice: MoneySchema,
     multiplicity: z.number(),
     isOpen: z.boolean(),
 
@@ -27,7 +28,7 @@ export const ProductSchema = z.object({
     size: z.string().nullable(),
     size2: z.string().nullable(),
     size3: z.string().nullable(),
-    invoicePrice: z.number().nullable(),
+    invoicePrice: MoneySchema.nullable(),
     invoiceNumber: z.string().nullable(),
     imageUUID: z.string().nullable(),
     country: z.string().nullable(),
@@ -56,7 +57,7 @@ export const ProductForClientSchema = z.object({
     uuid: z.uuid(),
     name: z.string(),
     balance: z.number(),
-    price: z.number(),
+    price: MoneySchema,
     multiplicity: z.number(),
     article: z.string().nullable(),
     barcode: z.string().nullable(),
@@ -101,7 +102,7 @@ export const ProductExtendedForClientSchema = ProductForClientSchema.merge(
                 discountRulesUUID: z.string(),
                 type: z.nativeEnum(DiscountRulesTypeEnum),
                 discountValueData: discountRulesModeSchema,
-                priceWithDiscount: z.number(),
+                priceWithDiscount: MoneySchema,
                 multipleQuantity: z.number().optional(),
             })
             .array()

package/schemas/report/client-by-weeks.schema.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { MoneySchema } from '../money.schema';
 
 export const ClientByWeeksSchema = z.object({
     weekStart: z.coerce.date(),
@@ -8,5 +9,5 @@ export const ClientByWeeksSchema = z.object({
     clientGroup: z.string().nullable(),
     hasOrders: z.boolean(),
     ordersCount: z.number(),
-    totalAmount: z.number(),
+    totalAmount: MoneySchema,
 });

package/schemas/report/client-statement.schema.ts

@@ -1,10 +1,11 @@
 import { z } from 'zod';
 import { ClientStatementTypeEnum, TransactionTypeEnum } from '../../enum';
+import { MoneySchema } from '../money.schema';
 
 export const ClientStatementItemSchema = z.object({
     date: z.coerce.date(),
     type: z.nativeEnum(ClientStatementTypeEnum),
-    amount: z.coerce.number(),
+    amount: MoneySchema,
     description: z.string(),
     documentNumber: z.string().nullable(),
     transactionType: z.nativeEnum(TransactionTypeEnum).nullable(),

package/schemas/report/inventory-turnover-category-item.schema.ts

@@ -7,7 +7,7 @@ export const InventoryTurnoverCategoryItemSchema = z.object({
     initialBalance: z.number(), // начальный остаток
     receipts: z.number(), // приходы
     sales: z.number(), // продажи
-    currentBalance: z.number(), // текущий остаток
+    currentBalance: z.number(), // товарный остаток (SUM по product.balance, Int), не деньги
     daysInStock: z.number(), // дни в наличии на складе
     turnoverRate: z.number(), // коэффициент оборачиваемости
 });

package/schemas/report/inventory-turnover-detailed-item.schema.ts

@@ -11,7 +11,7 @@ export const InventoryTurnoverDetailedItemSchema = z.object({
     initialBalance: z.number(), // начальный остаток
     receipts: z.number(), // приходы
     sales: z.number(), // продажи
-    currentBalance: z.number(), // текущий остаток
+    currentBalance: z.number(), // товарный остаток (SUM по product.balance, Int), не деньги
     daysInStock: z.number(), // дни в наличии на складе
     turnoverRate: z.number(), // коэффициент оборачиваемости
 });

package/schemas/report/report-order-filter.schema.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { ReportOrderDateBasisEnum } from '../../enum';
+import { REPORT_EXCLUDE_CLIENT_LIMIT } from '../../constant/report.constant';
+
+/**
+ * Общие фильтры отчётов, построенных на заказах: по какой дате заказ попадает в период и каких
+ * клиентов из него выкинуть. Схема одна на все такие отчёты — иначе `sales/summary` и
+ * `group-client` на одном экране разошлись бы в семантике при первой же правке.
+ *
+ * `excludeClientUUID` — типовой случай «отгружаем по себестоимости, в прибыли не учитываем».
+ * Принимается и CSV (`?excludeClientUUID=uuid1,uuid2`, как в get-notifications-status), и повтор
+ * параметра (`?excludeClientUUID=uuid1&excludeClientUUID=uuid2`) — Express отдаёт второй вариант
+ * массивом, и требовать от фронта именно CSV незачем.
+ */
+export const ReportOrderFilterSchema = z.object({
+    dateBasis: z
+        .nativeEnum(ReportOrderDateBasisEnum)
+        .default(ReportOrderDateBasisEnum.CREATED_AT)
+        .describe('Which order date puts the order into the period. Defaults to the order creation date.'),
+    excludeClientUUID: z
+        .union([z.string(), z.array(z.string())])
+        .transform(value => (Array.isArray(value) ? value : value.split(',')).map(item => item.trim()).filter(Boolean))
+        .pipe(z.array(z.string().uuid()).max(REPORT_EXCLUDE_CLIENT_LIMIT))
+        .optional()
+        .describe('Clients to drop from the report entirely — their orders, revenue and cost.'),
+});

package/schemas/report/sales-by-client-row.schema.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { SalesByClientTopItemSchema } from './sales-by-client-top-item.schema';
+import { MoneySchema } from '../money.schema';
 
 /**
  * Строка отчёта «продажи по клиентам» — те же данные, что уходят в Excel из `export/sales/clients`.
@@ -16,18 +17,18 @@ export const SalesByClientRowSchema = z.object({
         PACK: z.number(),
         BOX: z.number(),
     }),
-    totalSales: z.number(),
-    avgCheck: z.number(),
-    totalWriteOff: z.number(),
-    grossProfit: z.number(),
+    totalSales: MoneySchema,
+    avgCheck: MoneySchema,
+    totalWriteOff: MoneySchema,
+    grossProfit: MoneySchema,
     marginality: z.number(),
     // Оплаты (INCOME) и предоплаты (PREPAYMENT) клиента за период
-    totalPayments: z.number(),
-    totalPrepayments: z.number(),
+    totalPayments: MoneySchema,
+    totalPrepayments: MoneySchema,
     // Сумма услуг (order_service_line) за период — отдельно, вне товарных sales/margin
-    totalServiceAmount: z.number(),
+    totalServiceAmount: MoneySchema,
     // Текущий баланс клиента (на момент формирования отчёта)
-    balance: z.number(),
+    balance: MoneySchema,
     lastOrderDate: z.coerce.date().optional(),
     // Топ-5 по сумме выручки за период
     topCategories: z.array(SalesByClientTopItemSchema),

package/schemas/report/sales-by-client-top-item.schema.ts

@@ -1,7 +1,8 @@
 import { z } from 'zod';
+import { MoneySchema } from '../money.schema';
 
 /** Элемент топа (категория или товар) внутри строки отчёта «продажи по клиентам». */
 export const SalesByClientTopItemSchema = z.object({
     name: z.string(),
-    amount: z.number(),
+    amount: MoneySchema,
 });

package/schemas/service/service.schema.ts

@@ -1,11 +1,17 @@
 import { z } from 'zod';
 import { ServicePricingUnitEnum } from '../../enum/service-pricing-unit.enum';
 import { ServiceStatusEnum } from '../../enum/service-status.enum';
+import { MoneySchema } from '../money.schema';
+import { NonNegativeMoneySchema } from '../non-negative-money.schema';
+
+// Цена услуги: неотрицательная и не больше миллиарда. Знак берём из самой строки,
+// потолок — из разобранного значения: до 1e9 с двумя знаками число представимо точно.
+const ServicePriceSchema = NonNegativeMoneySchema.refine(value => Number(value) <= 1_000_000_000, { message: 'validation.money.max' });
 
 export const ServiceSchema = z.object({
     uuid: z.uuid(),
     name: z.string(),
-    price: z.number(),
+    price: MoneySchema,
     vat: z.number().nullable(),
     unit: z.nativeEnum(ServicePricingUnitEnum),
     status: z.nativeEnum(ServiceStatusEnum),
@@ -15,14 +21,14 @@ export const ServiceSchema = z.object({
 
 export const CreateServiceRequestSchema = z.object({
     name: z.string().min(1).max(255),
-    price: z.number().min(0).max(1_000_000_000),
+    price: ServicePriceSchema,
     vat: z.number().int().min(0).max(100).nullable().optional(),
     unit: z.nativeEnum(ServicePricingUnitEnum).optional().default(ServicePricingUnitEnum.FIXED),
 });
 
 export const UpdateServiceRequestSchema = z.object({
     name: z.string().min(1).max(255).optional(),
-    price: z.number().min(0).max(1_000_000_000).optional(),
+    price: ServicePriceSchema.optional(),
     vat: z.number().int().min(0).max(100).nullable().optional(),
     unit: z.nativeEnum(ServicePricingUnitEnum).optional(),
     status: z.nativeEnum(ServiceStatusEnum).optional(),

package/schemas/settings/settings.schema.ts

@@ -2,6 +2,8 @@ import { z } from 'zod';
 import { ChatHasManagerModeEnum, ChatNoManagerModeEnum, DiscountPriceRoundingEnum, LanguageEnum, WebshopModeEnum } from '../../enum';
 import { WebshopMainDisplayModeEnum } from '../../enum/webshop-main-display-mode.enum';
 import { MenuItemsUrlEnum } from '../../enum/menu-items-url.enum';
+import { MoneySchema } from '../money.schema';
+import { NonNegativeMoneySchema } from '../non-negative-money.schema';
 
 export const SettingsWorkingHoursSchema = z.object({
     uuid: z.string(),
@@ -20,9 +22,12 @@ export const ImportantMessageSchema = z.object({
     isActive: z.boolean(),
 });
 
+// Обе величины — деньги: `minSubtotal` сравнивается с суммой заказа, `cost` попадает в
+// `order.delivery_cost`. Живут они внутри JSON-колонки, куда ALTER TABLE не достаёт, поэтому
+// точность здесь держит не тип колонки, а формат значения — та же десятичная строка, что и на проводе.
 export const DeliveryPricingTierSchema = z.object({
-    minSubtotal: z.number().nonnegative(),
-    cost: z.number().nonnegative(),
+    minSubtotal: NonNegativeMoneySchema,
+    cost: NonNegativeMoneySchema,
 });
 
 export const SettingsSchema = z.object({

package/schemas/transaction/transaction.schema.ts

@@ -3,12 +3,13 @@ import { TransactionTypeEnum } from '../../enum';
 import { MoneyAccountSchema } from '../money-account/money-account.schema';
 import { ClientSchema } from '../client';
 import { OrderForClientSchema, OrderSchema } from '../order/order.schema';
+import { MoneySchema } from '../money.schema';
 
 export const TransactionSchema = z.object({
     uuid: z.uuid(),
     moneyAccountUUID: z.uuid(),
 
-    amount: z.number(),
+    amount: MoneySchema,
     comment: z.string(),
 
     clientUUID: z.string().nullable(),