@floristcloud/api-lib 1.2.109 → 1.2.110

package/schemas/action-log/order-info.schema.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { ActionLogMoneySchema } from './action-log-money.schema';
 
 export const OrderInfoSchema = z.object({
     orderUUID: z.string(),
@@ -6,7 +7,7 @@ export const OrderInfoSchema = z.object({
     clientUUID: z.string(),
     clientName: z.string(),
     createdAt: z.coerce.date(),
-    totalCost: z.coerce.number(),
+    totalCost: ActionLogMoneySchema,
     deliveryAddress: z.string().nullable().optional(),
-    deliveryCost: z.coerce.number().nullable().optional(),
+    deliveryCost: ActionLogMoneySchema.nullable().optional(),
 });

package/schemas/action-log/order-product-info.schema.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { ActionLogMoneySchema } from './action-log-money.schema';
 
 export const OrderProductInfoSchema = z.object({
     orderUUID: z.string(),
@@ -8,7 +9,7 @@ export const OrderProductInfoSchema = z.object({
     categoryUUID: z.string().nullable(),
     categoryName: z.string().nullable(),
     quantity: z.coerce.number(),
-    price: z.coerce.number(),
+    price: ActionLogMoneySchema,
     consignmentUUID: z.string().nullable(),
     consignmentDeliveryDate: z.coerce.date().nullable(),
 });

package/schemas/action-log/order-product-update-action-log.schema.ts

@@ -1,8 +1,9 @@
 import { z } from 'zod';
 import { OrderProductInfoSchema } from './order-product-info.schema';
+import { ActionLogMoneySchema } from './action-log-money.schema';
 
 export const OrderProductUpdateActionLogSchema = z.object({
     orderProduct: OrderProductInfoSchema,
     newQuantity: z.coerce.number(),
-    newPrice: z.coerce.number(),
+    newPrice: ActionLogMoneySchema,
 });

package/schemas/action-log/pre-order-product-info.schema.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { ActionLogMoneySchema } from './action-log-money.schema';
 
 export const PreOrderProductInfoSchema = z.object({
     preOrderUUID: z.string(),
@@ -6,6 +7,6 @@ export const PreOrderProductInfoSchema = z.object({
     name: z.string(),
     categoryName: z.string().nullable(),
     quantity: z.coerce.number(),
-    price: z.coerce.number(),
+    price: ActionLogMoneySchema,
     comment: z.string().nullable(),
 });

package/schemas/action-log/pre-order-product-update-action-log.schema.ts

@@ -1,9 +1,10 @@
 import { z } from 'zod';
 import { PreOrderProductInfoSchema } from './pre-order-product-info.schema';
+import { ActionLogMoneySchema } from './action-log-money.schema';
 
 export const PreOrderProductUpdateActionLogSchema = z.object({
     preOrderProduct: PreOrderProductInfoSchema,
     newQuantity: z.coerce.number(),
-    newPrice: z.coerce.number(),
+    newPrice: ActionLogMoneySchema,
     newComment: z.string().nullable(),
 });

package/schemas/action-log/transaction-info.schema.ts

@@ -1,10 +1,11 @@
 import { z } from 'zod';
 import { TransactionTypeEnum } from '../../enum';
+import { ActionLogMoneySchema } from './action-log-money.schema';
 
 export const TransactionInfoSchema = z.object({
     transactionUUID: z.string(),
     createdAt: z.coerce.date(),
-    amount: z.coerce.number(),
+    amount: ActionLogMoneySchema,
     moneyAccountName: z.string(),
     type: z.nativeEnum(TransactionTypeEnum),
     clientName: z.string().nullable(),

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

@@ -1,13 +1,14 @@
 import { z } from 'zod';
 import { BankProviderEnum } from '../../enum/bank-provider.enum';
 import { BankPaymentEventStatusEnum } from '../../enum/bank-payment-event-status.enum';
+import { MoneySchema } from '../money.schema';
 
 export const BankPaymentSchema = z.object({
     uuid: z.uuid(),
     provider: z.nativeEnum(BankProviderEnum),
     externalEventId: z.string(),
     accountNumber: z.string(),
-    amount: z.coerce.number(),
+    amount: MoneySchema,
     currency: z.string(),
     purpose: z.string(),
     status: z.nativeEnum(BankPaymentEventStatusEnum),

package/schemas/client/client-debt.schema.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { MoneySchema } from '../money.schema';
 
 export const ClientDebtItemSchema = z.object({
     clientUUID: z.uuid(),
@@ -7,11 +8,13 @@ export const ClientDebtItemSchema = z.object({
     group: z.string().nullable(),
     city: z.string().nullable(),
     responsibleUserName: z.string().nullable(),
-    currentBalance: z.number(),
-    transactionNet: z.number(),
-    completedOrdersBalance: z.number(),
-    completedOrdersBalanceWithDelay: z.number(),
-    nonCompletedBalance: z.number(),
+    currentBalance: MoneySchema,
+    // Знаковые величины: сальдо транзакций и остатки по заказам законно уходят в минус
+    // (переплата клиента, возврат), поэтому ограничения на знак здесь нет и быть не должно.
+    transactionNet: MoneySchema,
+    completedOrdersBalance: MoneySchema,
+    completedOrdersBalanceWithDelay: MoneySchema,
+    nonCompletedBalance: MoneySchema,
     hasOverdueDebt: z.boolean().nullable(),
 });
 

package/schemas/client/client.schema.ts

@@ -7,6 +7,7 @@ import { ClientIndividualProfileSchema } from './client-individual-profile.schem
 import { ClientLegalProfileSchema } from './client-legal-profile.schema';
 import { DiscountRulesSchema } from '../discount-rules/discount-rules.schema';
 import { ClientMarkingSchema } from './client-marking.schema';
+import { MoneySchema } from '../money.schema';
 
 export const ClientSchema = z.object({
     uuid: z.uuid(),
@@ -29,7 +30,7 @@ export const ClientSchema = z.object({
     comment: z.string().nullable(),
     paymentGraceDaysAfterCompletion: z.number().nullable(),
 
-    balance: z.number(),
+    balance: MoneySchema,
 
     deletedAt: z.date().nullable(),
     createdAt: z.date(),

package/schemas/consignment/consignment.schema.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { ConsignmentImportSchemaRelationEntityPropertyEnum, ConsignmentStatusEnum, ConsingmentImportErrorsEnum } from '../../enum';
 import { ClientSchema } from '../client';
+import { MoneySchema } from '../money.schema';
 
 export const ConsignmentSchema = z.object({
     uuid: z.uuid(),
@@ -20,25 +21,25 @@ export const ConsignmentSchema = z.object({
 
 export const ConsignmentWithStatisticForListSchema = ConsignmentSchema.extend({
     statistic: z.object({
-        totalCostPrice: z.number(),
+        totalCostPrice: MoneySchema,
         currentProductBalance: z.number(),
-        currentCostPrice: z.number(),
+        currentCostPrice: MoneySchema,
         totalProductQuantity: z.number(),
-        totalSellings: z.number(),
-        totalApprovedWriteOffSellings: z.number(),
+        totalSellings: MoneySchema,
+        totalApprovedWriteOffSellings: MoneySchema,
     }),
 });
 
 export const ConsignmentWithStatisticSchema = ConsignmentSchema.extend({
     statistic: z.object({
-        totalCostPrice: z.number(),
+        totalCostPrice: MoneySchema,
         currentProductBalance: z.number(),
-        currentCostPrice: z.number(),
+        currentCostPrice: MoneySchema,
         totalProductQuantity: z.number(),
-        totalSellings: z.number(),
+        totalSellings: MoneySchema,
         writeOffQuantity: z.number(),
-        writeOffCostPrice: z.number(),
-        writeOffCostPriceByOrderProduct: z.number(),
+        writeOffCostPrice: MoneySchema,
+        writeOffCostPriceByOrderProduct: MoneySchema,
     }),
 });
 

package/schemas/consignment-transfer/accept-consignment-transfer.schema.ts

@@ -1,5 +1,7 @@
 import { z } from 'zod';
 import { ConsignmentTransferRequestSchema } from './consignment-transfer-request.schema';
+import { MoneySchema } from '../money.schema';
+import { NonNegativeMoneySchema } from '../non-negative-money.schema';
 
 export const AcceptConsignmentTransferRequestSchema = z
     .object({
@@ -17,7 +19,8 @@ export const AcceptConsignmentTransferRequestSchema = z
                 z.object({
                     itemUUID: z.uuid(),
                     categoryUUID: z.uuid(),
-                    price: z.number().min(0).optional(),
+                    // Отрицательную цену отсекаем по знаку строки — минус и есть признак отрицательности.
+                    price: NonNegativeMoneySchema.optional(),
                 }),
             )
             .min(1),

package/schemas/consignment-transfer/consignment-transfer-request-item.schema.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { MoneySchema } from '../money.schema';
 
 export const ConsignmentTransferRequestItemSchema = z.object({
     uuid: z.uuid(),
@@ -6,7 +7,7 @@ export const ConsignmentTransferRequestItemSchema = z.object({
     targetProductUUID: z.uuid().nullable(),
     name: z.string(),
     quantity: z.number().int(),
-    transferPrice: z.number(),
+    transferPrice: MoneySchema,
     categoryName: z.string().nullable(),
     multiplicity: z.number().int(),
     grower: z.string().nullable(),

package/schemas/delivery-route/delivery-route.schema.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { DeliveryRouteStatusEnum, OrderDeliveryStatusEnum, OrderStatusEnum } from '../../enum';
+import { MoneySchema } from '../money.schema';
 
 export const DeliveryRouteSchema = z.object({
     uuid: z.uuid(),
@@ -34,7 +35,7 @@ export const DeliveryRouteWithOrdersSchema = DeliveryRouteSchema.extend({
             orderNumber: z.number(),
             orderStatus: z.nativeEnum(OrderStatusEnum),
             orderCreatedAt: z.coerce.date(),
-            totalCost: z.number(),
+            totalCost: MoneySchema,
             clientName: z.string(),
             clientCity: z.string().nullable(),
             clientAddress: z.string().nullable(),

package/schemas/discount-rules/discount-rules.schema.ts

@@ -2,10 +2,17 @@ import { z } from 'zod';
 import { DiscountRulesTypeEnum, DiscountRulesApplyTypeEnum, DiscountRulesStatusEnum, DiscountRulesModeTypeEnum } from '../../enum';
 import { ClientSchema } from '../client';
 import { ProductSchema } from '../product/product.schema';
+import { MoneySchema } from '../money.schema';
+import { PositiveMoneySchema } from '../positive-money.schema';
 
+// PERCENT — это процент, а не деньги: остаётся числом 0..100. FIXED — денежная величина, едет строкой.
 export const discountRulesModeSchema = z.discriminatedUnion('typeDiscount', [
     z.object({ typeDiscount: z.literal(DiscountRulesModeTypeEnum.PERCENT), discountValue: z.number().min(0).max(100) }),
-    z.object({ typeDiscount: z.literal(DiscountRulesModeTypeEnum.FIXED), discountValue: z.number().positive() }),
+    z.object({
+        typeDiscount: z.literal(DiscountRulesModeTypeEnum.FIXED),
+        // Строго положительная сумма: минус отсекаем по знаку строки, нули вида "0" / "0.00" — сравнением.
+        discountValue: PositiveMoneySchema,
+    }),
 ]);
 
 // Rules schemas other data
@@ -113,7 +120,7 @@ export const DiscountRulesSplitQuantityResponseSchema = z.object({
             productUUID: z.string(),
             quantity: z.number(),
             withDiscount: z.boolean(),
-            price: z.number(),
+            price: MoneySchema,
         })
         .array()
         .nullable(),

package/schemas/index.ts

@@ -77,4 +77,7 @@ export * from './account-deletion-request/account-deletion-request.schema';
 export * from './consignment-transfer';
 export * from './api-error.schema';
 export * from './access-policy';
+export * from './money.schema';
+export * from './non-negative-money.schema';
+export * from './positive-money.schema';
 export * from './report/report-order-filter.schema';

package/schemas/money-account/money-account-with-balance.schema.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { MoneyAccountSchema } from './money-account.schema';
+import { MoneySchema } from '../money.schema';
 
 /**
  * Денежный счёт в ответах списков. `balance` — текущий остаток счёта (приход минус расход),
@@ -7,5 +8,5 @@ import { MoneyAccountSchema } from './money-account.schema';
  * получают ровно прежнюю форму ответа.
  */
 export const MoneyAccountWithBalanceSchema = MoneyAccountSchema.extend({
-    balance: z.number().optional(),
+    balance: MoneySchema.optional(),
 });

package/schemas/money.schema.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+
+/**
+ * Единственное описание денежной величины в контрактах.
+ *
+ * Деньги пересекают границу строкой — точным десятичным представлением, а не float64.
+ * `"8755.48"` доезжает до получателя ровно таким, каким его отправили: ни JSON.parse, ни
+ * арифметика на `number` больше не участвуют в передаче, поэтому двоичный мусор вида
+ * `8755.479000000001` физически неоткуда взяться. Каждая сторона разбирает строку своей
+ * реализацией Decimal: сервер — Prisma.Decimal, клиент — своей библиотекой.
+ *
+ * В `libs/contracts` намеренно НЕТ зависимости от decimal-библиотеки: пакет публикуется как
+ * `@floristcloud/api-lib` и ставится в браузерные бандлы, где лишняя зависимость — это лишние
+ * килобайты и риск конфликта версий с той Decimal-реализацией, которую уже выбрал клиент.
+ * Контракт описывает формат провода, а не арифметику.
+ *
+ * Формат: необязательный минус, целая часть, до двух знаков после точки. Знак минуса —
+ * единственный признак отрицательной величины.
+ *
+ * Сама по себе схема знак не ограничивает: разницы, сальдо и балансы клиентов законно уходят
+ * в минус. Там, где величина не может быть отрицательной или нулевой, берите готовые
+ * `NonNegativeMoneySchema` и `PositiveMoneySchema` — не повторяйте `refine` по месту.
+ * Модификаторы `.optional()` и `.nullable()` работают напрямую.
+ */
+export const MoneySchema = z.string().regex(/^-?\d+(\.\d{1,2})?$/);

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(),