@floristcloud/api-lib 1.2.160 → 1.2.161

package/commands/discount-rules/get-product-discount-price.query.ts

@@ -1,73 +1,5 @@
 import { z } from 'zod';
-import { DiscountRulesTypeEnum } from '../../enum';
-import { discountPriceOutcomeSchema } from '../../schemas';
-import { MoneySchema } from '../../schemas/money.schema';
-
-const GetProductDiscountPriceRequestSchema = z.object({
-    productUUID: z.uuid(),
-    clientUUID: z.preprocess(val => {
-        return val === 'null' ? null : val;
-    }, z.uuid().nullable().optional()),
-});
-
-/**
- * Цена товара по одному правилу — для показа вариантов.
- *
- * `discountValueData` описывает, чем правило обернулось для этого товара, а не как оно настроено:
- * у правила от себестоимости это готовая цена, и самой наценки здесь нет.
- *
- * В списки попадают только варианты, которые действительно снижают цену: правило, оставляющее базу
- * как есть, выбором не является.
- */
-const ProductDiscountPriceItemSchema = z.object({
-    discountRulesUUID: z.string(),
-    type: z.nativeEnum(DiscountRulesTypeEnum),
-    discountValueData: discountPriceOutcomeSchema,
-    priceWithDiscount: MoneySchema,
-});
-
-/**
- * Готовые цены товара для клиента: то, что нужно при работе с товаром, а не при настройке правил.
- *
- * Считает бэк тем же движком, что и для витрины, — панель формулу скидок не повторяет и
- * себестоимость не получает. Настройка правил живёт отдельно, в `GetDiscountRulesAllContractQuery`.
- *
- * `null` в ценах со скидкой означает «скидка неприменима», а не «ноль».
- */
-const GetProductDiscountPriceResponseSchema = z.object({
-    message: z.string().optional(),
-    data: z.object({
-        productUUID: z.string(),
-        price: MoneySchema,
-        priceWithBestDiscount: MoneySchema.nullable(),
-        multiplicityOptions: z
-            .object({
-                uuid: z.string(),
-                optionPrice: MoneySchema.nullable(),
-                optionPriceWithDiscount: MoneySchema.nullable(),
-                isDiscountApplicable: z.boolean(),
-                /**
-                 * Варианты по этой фасовке: те же правила, но посчитанные от её цены.
-                 *
-                 * Список свой у каждой кратности, потому что база у них разная — у правила нет
-                 * одной цены на товар, пока не выбрана форма отгрузки. Пустой список означает
-                 * «выбирать нечего»: скидки к этой кратности запрещены продавцом либо ни одно
-                 * правило её цену не снижает.
-                 *
-                 * Порядок элементов не отсортирован по цене — он унаследован от сортировки правил
-                 * товара, а база у фасовки другая. Лучшую цену берите из `optionPriceWithDiscount`,
-                 * а не из первого элемента.
-                 */
-                discountDataList: ProductDiscountPriceItemSchema.array(),
-            })
-            .array(),
-        /**
-         * Варианты по базовой цене товара. Как и у фасовок, порядок не гарантирован: лучшую цену
-         * отдаёт `priceWithBestDiscount`.
-         */
-        discountDataList: ProductDiscountPriceItemSchema.array(),
-    }),
-});
+import { GetProductDiscountPriceRequestSchema, GetProductDiscountPriceResponseSchema } from '../../schemas';
 
 export namespace GetProductDiscountPriceContractQuery {
     export const RequestSchema = GetProductDiscountPriceRequestSchema;

package/commands/order/webshop/create-cart.command.ts

@@ -1,12 +1,5 @@
 import { z } from 'zod';
-import { OrderForClientSchema } from '../../../schemas';
-
-const CreateCartRequestSchema = z.object({});
-
-const CreateCartResponseSchema = z.object({
-    message: z.string().optional(),
-    data: OrderForClientSchema,
-});
+import { CreateCartRequestSchema, CreateCartResponseSchema } from '../../../schemas';
 
 export namespace CreateCartContractCommand {
     export const RequestSchema = CreateCartRequestSchema;

package/commands/order/webshop/get-order-for-client.query.ts

@@ -1,12 +1,5 @@
 import { z } from 'zod';
-import { OrderExtendedForClientSchema } from '../../../schemas';
-
-const GetOrderForClientRequestSchema = z.object({});
-
-const GetOrderForClientResponseSchema = z.object({
-    message: z.string().optional(),
-    data: OrderExtendedForClientSchema.nullable(),
-});
+import { GetOrderForClientRequestSchema, GetOrderForClientResponseSchema } from '../../../schemas';
 
 export namespace GetOrderForClientContractQuery {
     export const RequestSchema = GetOrderForClientRequestSchema;

package/commands/order/webshop/get-order-list-for-client.query.ts

@@ -1,53 +1,5 @@
 import { z } from 'zod';
-import { OrderExtendedForClientSchema } from '../../../schemas';
-import { dateRangeCheck, setEndDay, setStartDay } from '../../../helpers/date.helper';
-import { OrderStatusEnum } from '../../../enum/order-status.enum';
-import { OrderWebshopAvailableStatusList } from '../../../enum';
-
-const GetOrderForClientListRequestSchema = z
-    .object({
-        page: z.coerce.number().default(1),
-        count: z.coerce.number().default(10),
-        startDate: z.coerce
-            .date()
-            .optional()
-            .transform(val => (val ? setStartDay(val) : val)),
-        endDate: z.coerce
-            .date()
-            .optional()
-            .transform(val => (val ? setEndDay(val) : val)),
-        isPaid: z.coerce.boolean().optional(),
-        statuses: z
-            .nativeEnum(OrderStatusEnum)
-            .array()
-            .optional()
-            .transform(arr => (arr && arr.length === 0 ? OrderWebshopAvailableStatusList : (arr ?? OrderWebshopAvailableStatusList)))
-            .default(OrderWebshopAvailableStatusList)
-            .refine(arr => arr.every(s => OrderWebshopAvailableStatusList.includes(s)), {
-                message: 'validation.statusNotAllowedWebshop',
-            }),
-    })
-    .refine(
-        value => {
-            const { startDate, endDate } = value;
-            if (startDate && endDate) {
-                return dateRangeCheck(startDate, endDate);
-            }
-            return true;
-        },
-        {
-            message: 'validation.dateRange',
-            path: ['endDate', 'startDate'],
-        },
-    );
-
-const GetOrderForClientListResponseSchema = z.object({
-    message: z.string().optional(),
-    data: z.object({
-        orderList: OrderExtendedForClientSchema.array(),
-        total: z.number(),
-    }),
-});
+import { GetOrderForClientListRequestSchema, GetOrderForClientListResponseSchema } from '../../../schemas';
 
 export namespace GetOrderForClientListContractQuery {
     export const RequestSchema = GetOrderForClientListRequestSchema;

package/commands/order/webshop/update-cart.command.ts

@@ -1,29 +1,5 @@
 import { z } from 'zod';
-import { CalendarDaySchema, OrderForClientSchema } from '../../../schemas';
-
-const UpdateCartRequestSchema = z.object({
-    clientComment: z.string().nullable().optional().default(null),
-    branchUUID: z.uuid().optional().nullable().default(null),
-    // Дата выдачи/доставки заказа — одна для самовывоза и доставки. Относится к товару в наличии:
-    // заказы с товаром в пути после оформления получают дату прихода. Имеет приоритет над
-    // устаревшим `delivery.deliveryDate`.
-    plannedShipmentDate: CalendarDaySchema.nullable().optional(),
-    delivery: z
-        .object({
-            /** @deprecated Используйте `plannedShipmentDate` — единую дату для самовывоза и доставки. */
-            deliveryDate: z.coerce.date().optional().nullable().default(null),
-            address: z.string().nullable().optional().default(null),
-            time: z.string().nullable().optional().default(null),
-        })
-        .optional()
-        .nullable()
-        .default(null),
-});
-
-const UpdateCartResponseSchema = z.object({
-    message: z.string().optional(),
-    data: OrderForClientSchema,
-});
+import { UpdateCartRequestSchema, UpdateCartResponseSchema } from '../../../schemas';
 
 export namespace UpdateCartContractCommand {
     export const RequestSchema = UpdateCartRequestSchema;

package/commands/order-product/webshop/get-order-product-for-client-list.query.ts

@@ -1,12 +1,5 @@
 import { z } from 'zod';
-import { OrderProductForClientListSchema } from '../../../schemas';
-
-const GetOrderProductForClientListRequestSchema = z.object({});
-
-const GetOrderProductForClientListResponseSchema = z.object({
-    message: z.string().optional(),
-    data: OrderProductForClientListSchema,
-});
+import { GetOrderProductForClientListRequestSchema, GetOrderProductForClientListResponseSchema } from '../../../schemas';
 
 export namespace GetOrderProductForClientListContractQuery {
     export const RequestSchema = GetOrderProductForClientListRequestSchema;

package/commands/pre-order/webshop/get-pre-order-list-webshop.command.ts

@@ -1,21 +1 @@
-import { z } from 'zod';
-import { PreOrderStatusEnum } from '../../../enum';
-import { PreOrderListSchema } from '../../../schemas';
-
-const GetPreOrderListWebshopRequestSchema = z.object({
-    page: z.coerce.number().optional().default(1),
-    count: z.coerce.number().optional().default(10),
-    statuses: z.array(z.nativeEnum(PreOrderStatusEnum)).optional(),
-});
-
-const GetPreOrderListResponseSchema = z.object({
-    data: PreOrderListSchema,
-});
-
-export namespace GetPreOrderListWebshopContractCommand {
-    export const RequestSchema = GetPreOrderListWebshopRequestSchema;
-    export type Request = z.infer<typeof RequestSchema>;
-
-    export const ResponseSchema = GetPreOrderListResponseSchema;
-    export type Response = z.infer<typeof ResponseSchema>;
-}
+export { GetPreOrderListWebshopContractCommand } from './get-pre-order-list-webshop.query';

package/commands/pre-order/webshop/get-pre-order-list-webshop.query.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { GetPreOrderListWebshopRequestSchema, GetPreOrderListWebshopResponseSchema } from '../../../schemas';
+
+export namespace GetPreOrderListWebshopContractCommand {
+    export const RequestSchema = GetPreOrderListWebshopRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = GetPreOrderListWebshopResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/pre-order/webshop/get-pre-order-webshop.query.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { GetPreOrderWebshopResponseSchema } from '../../../schemas';
+
+export namespace GetPreOrderWebshopContractQuery {
+    export const ResponseSchema = GetPreOrderWebshopResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/pre-order/webshop/index.ts

@@ -1,5 +1,6 @@
 export * from './update-pre-order-webshop.command';
 export * from './create-pre-order-webshop.command';
-export * from './get-pre-order-list-webshop.command';
+export * from './get-pre-order-list-webshop.query';
 export * from './delete-pre-order-webshop.command';
 export * from './checkout-pre-order-webshop.command';
+export * from './get-pre-order-webshop.query';

package/commands/pre-order-collection-item/delete-group-pre-order-collection-item.command.ts

@@ -1,16 +1,5 @@
 import { z } from 'zod';
-
-const DeleteGroupPreOrderCollectionItemRequestSchema = z.object({
-    preOrderCollectionItemUUIDs: z.array(z.string()),
-});
-
-const DeleteGroupPreOrderCollectionItemResponseSchema = z.object({
-    message: z.string().optional(),
-    data: z.object({
-        success: z.boolean(),
-        missedItems: z.array(z.string()).optional(),
-    }),
-});
+import { DeleteGroupPreOrderCollectionItemRequestSchema, DeleteGroupPreOrderCollectionItemResponseSchema } from '../../schemas';
 
 export namespace DeleteGroupPreOrderCollectionItemContractCommand {
     export const RequestSchema = DeleteGroupPreOrderCollectionItemRequestSchema;

package/commands/pre-order-collection-item/get-pre-order-collection-item-grouped-list-for-client.query.ts

@@ -1,25 +1,11 @@
 import { z } from 'zod';
-import { PreOrderCollectionItemGroupedListSchema } from '../../schemas';
-
-const GetPreOrderCollectionItemGroupedListForClientRequestSchema = z.object({
-    sizes: z.array(z.string()).optional(),
-    colors: z.array(z.string()).optional(),
-    preOrderCollectionsUUID: z.array(z.string()).optional(),
-    categoriesUUID: z.array(z.string()).optional(),
-    growers: z.array(z.string()).optional(),
-    countries: z.array(z.string()).optional(),
-    searchQuery: z.string().optional(),
-    page: z.coerce.number().optional().default(1),
-    count: z.coerce.number().optional().default(10),
-});
-
-const GetPreOrderCollectionItemGroupedListForClientResponseSchema = z.object({
-    message: z.string().optional(),
-    data: PreOrderCollectionItemGroupedListSchema,
-});
+import {
+    PreOrderCollectionItemCatalogFilterForClientRequestSchema,
+    GetPreOrderCollectionItemGroupedListForClientResponseSchema,
+} from '../../schemas';
 
 export namespace GetPreOrderCollectionItemGroupedListForClientContractQuery {
-    export const RequestSchema = GetPreOrderCollectionItemGroupedListForClientRequestSchema;
+    export const RequestSchema = PreOrderCollectionItemCatalogFilterForClientRequestSchema;
     export type Request = z.infer<typeof RequestSchema>;
 
     export const ResponseSchema = GetPreOrderCollectionItemGroupedListForClientResponseSchema;

package/commands/pre-order-collection-item/get-pre-order-collection-item-list-for-client.query.ts

@@ -1,25 +1,11 @@
 import { z } from 'zod';
-import { PreOrderCollectionItemExtendedWithPreOrderCollectionListSchema } from '../../schemas';
-
-const GetPreOrderCollectionItemListForClientRequestSchema = z.object({
-    sizes: z.array(z.string()).optional(),
-    colors: z.array(z.string()).optional(),
-    preOrderCollectionsUUID: z.array(z.string()).optional(),
-    categoriesUUID: z.array(z.string()).optional(),
-    growers: z.array(z.string()).optional(),
-    countries: z.array(z.string()).optional(),
-    searchQuery: z.string().optional(),
-    page: z.coerce.number().optional().default(1),
-    count: z.coerce.number().optional().default(10),
-});
-
-const GetPreOrderCollectionItemListForClientResponseSchema = z.object({
-    message: z.string().optional(),
-    data: PreOrderCollectionItemExtendedWithPreOrderCollectionListSchema,
-});
+import {
+    PreOrderCollectionItemCatalogFilterForClientRequestSchema,
+    GetPreOrderCollectionItemListForClientResponseSchema,
+} from '../../schemas';
 
 export namespace GetPreOrderCollectionItemListForClientContractQuery {
-    export const RequestSchema = GetPreOrderCollectionItemListForClientRequestSchema;
+    export const RequestSchema = PreOrderCollectionItemCatalogFilterForClientRequestSchema;
     export type Request = z.infer<typeof RequestSchema>;
 
     export const ResponseSchema = GetPreOrderCollectionItemListForClientResponseSchema;

package/commands/pre-order-product/create-pre-order-product-webshop.command.ts

@@ -1,13 +1,8 @@
 import { z } from 'zod';
-import { CreatePreOrderProductWebshopSchema, PreOrderProductSchema } from '../../schemas';
-
-const CreatePreOrderProductWebshopResponseSchema = z.object({
-    message: z.string().optional(),
-    data: PreOrderProductSchema,
-});
+import { CreatePreOrderProductWebshopRequestSchema, CreatePreOrderProductWebshopResponseSchema } from '../../schemas';
 
 export namespace CreatePreOrderProductWebshopContractCommand {
-    export const RequestSchema = CreatePreOrderProductWebshopSchema;
+    export const RequestSchema = CreatePreOrderProductWebshopRequestSchema;
     export type Request = z.infer<typeof RequestSchema>;
 
     export const ResponseSchema = CreatePreOrderProductWebshopResponseSchema;

package/commands/pre-order-product/get-pre-order-product-extended-list-webshop.query.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { PaginationRequestSchema, GetPreOrderProductExtendedListWebshopResponseSchema } from '../../schemas';
+
+export namespace GetPreOrderProductExtendedListWebshopContractQuery {
+    export const RequestSchema = PaginationRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = GetPreOrderProductExtendedListWebshopResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/pre-order-product/index.ts

@@ -11,6 +11,7 @@ export * from './delete-pre-order-product-webshop.command';
 export * from './update-pre-order-product-webshop.command';
 export * from './get-pre-order-product-list.query';
 export * from './get-pre-order-product-extended-list.query';
+export * from './get-pre-order-product-extended-list-webshop.query';
 export * from './get-active-stepper-positions.query';
 export * from './create-manually-pre-order-product-for-standing-order.command';
 export * from './get-pre-order-products-by-pre-order-list.command';

package/commands/pre-order-product/update-pre-order-product-webshop.command.ts

@@ -1,13 +1,8 @@
 import { z } from 'zod';
-import { PreOrderProductSchema, UpdatePreOrderProductWebshopSchema } from '../../schemas';
-
-const UpdatePreOrderProductWebshopResponseSchema = z.object({
-    message: z.string().optional(),
-    data: PreOrderProductSchema,
-});
+import { UpdatePreOrderProductWebshopRequestSchema, UpdatePreOrderProductWebshopResponseSchema } from '../../schemas';
 
 export namespace UpdatePreOrderProductWebshopContractCommand {
-    export const RequestSchema = UpdatePreOrderProductWebshopSchema;
+    export const RequestSchema = UpdatePreOrderProductWebshopRequestSchema;
     export type Request = z.infer<typeof RequestSchema>;
 
     export const ResponseSchema = UpdatePreOrderProductWebshopResponseSchema;

package/commands/product/webshop/get-product-list-for-client.query.ts

@@ -1,35 +1,5 @@
 import { z } from 'zod';
-import { OrderByEnum, ProductClientSortByEnum, ProductMarkEnum } from '../../../enum';
-import { ProductListExtendedForClientSchema } from '../../../schemas';
-
-const GetProductListForClientRequestSchema = z.object({
-    page: z.string().transform(val => Number(val) || 1),
-    count: z.string().transform(val => Number(val) || 10),
-    stock: z
-        .string()
-        .transform(val => (val === 'true' ? true : val === 'false' ? false : undefined))
-        .optional(),
-    deliveryDates: z.coerce.date().array().optional(),
-    sizes: z.string().array().optional(),
-    colors: z.string().array().optional(),
-    growers: z.string().array().optional(),
-    countries: z.string().array().optional(),
-    categoryUUID: z.string().optional(),
-    typeUUID: z.string().optional(),
-    searchQuery: z.string().optional(),
-    marks: z.nativeEnum(ProductMarkEnum).array().optional(),
-    // Без `sortBy` порядок остаётся прежним — по категории, названию и размеру. Сортировка по цене
-    // идёт по базовому прайсу, скидки клиента её не двигают: см. ProductClientSortByEnum.
-    sortBy: z.nativeEnum(ProductClientSortByEnum).optional(),
-    // Без `.default()`: он уезжает в `_output`, а значит и в опубликованный `Request`, делая поле
-    // обязательным для клиентов. Отсутствующее направление билдер и так читает как ASC.
-    sortOrder: z.nativeEnum(OrderByEnum).optional(),
-});
-
-const GetProductListForClientResponseSchema = z.object({
-    message: z.string().optional(),
-    data: ProductListExtendedForClientSchema,
-});
+import { GetProductListForClientRequestSchema, GetProductListForClientResponseSchema } from '../../../schemas';
 
 export namespace GetProductListForClientContractQuery {
     export const RequestSchema = GetProductListForClientRequestSchema;

package/commands/transaction/webshop/get-transaction-list-for-client.query.ts

@@ -1,37 +1,5 @@
 import { z } from 'zod';
-import { TransactionListForClientSchema } from '../../../schemas';
-import { dateRangeCheck } from '../../../helpers/date.helper';
-import { TransactionTypeEnum } from '../../../enum';
-
-const GetTransactionListForClientRequestSchema = z
-    .object({
-        page: z.coerce.number().optional().default(1),
-        count: z.coerce.number().optional().default(10),
-        startDate: z.coerce.date().optional(),
-        endDate: z.coerce.date().optional(),
-        transactionType: z.nativeEnum(TransactionTypeEnum).optional(),
-        moneyAccountUUID: z.string().optional(),
-        orderUUID: z.string().optional(),
-        searchQuery: z.string().optional(),
-    })
-    .refine(
-        value => {
-            const { startDate, endDate } = value;
-            if (startDate && endDate) {
-                return dateRangeCheck(startDate, endDate);
-            }
-            return true;
-        },
-        {
-            message: 'validation.dateRange',
-            path: ['endDate', 'startDate'],
-        },
-    );
-
-const GetTransactionListForClientResponseSchema = z.object({
-    message: z.string().optional(),
-    data: TransactionListForClientSchema,
-});
+import { GetTransactionListForClientRequestSchema, GetTransactionListForClientResponseSchema } from '../../../schemas';
 
 export namespace GetTransactionListForClientContractQuery {
     export const RequestSchema = GetTransactionListForClientRequestSchema;

package/commands/write-off/webshop/create-write-off-from-order-for-client.command.ts

@@ -1,18 +1,5 @@
 import { z } from 'zod';
-import { WriteOffSchema } from '../../../schemas';
-
-const CreateWriteOffFromOrderForClientRequestSchema = z.object({
-    // Колонка `WriteOff.quantity` — Int: дробное значение доходило до Prisma и падало общей ошибкой.
-    quantity: z.coerce.number().int().positive(),
-    comment: z.string().nullable(),
-    productUUID: z.string(),
-    orderProductUUID: z.string(),
-});
-
-const CreateWriteOffFromOrderForClientResponseSchema = z.object({
-    message: z.string().optional(),
-    data: WriteOffSchema.nullable(),
-});
+import { CreateWriteOffFromOrderForClientRequestSchema, CreateWriteOffFromOrderForClientResponseSchema } from '../../../schemas';
 
 export namespace CreateWriteOffFromOrderForClientContractCommand {
     export const RequestSchema = CreateWriteOffFromOrderForClientRequestSchema;

package/commands/write-off/webshop/get-write-off-list-by-order.query.ts

@@ -1,12 +1,5 @@
 import { z } from 'zod';
-import { WriteOffSchema } from '../../../schemas';
-
-const GetWriteOffListByOrderForClientRequestSchema = z.object({});
-
-const GetWriteOffListByOrderForClientResponseSchema = z.object({
-    message: z.string().optional(),
-    data: WriteOffSchema.array(),
-});
+import { GetWriteOffListByOrderForClientRequestSchema, GetWriteOffListByOrderForClientResponseSchema } from '../../../schemas';
 
 export namespace GetWriteOffListByOrderForClientContractQuery {
     export const RequestSchema = GetWriteOffListByOrderForClientRequestSchema;

package/constant/error.ts

@@ -405,6 +405,12 @@ export const ERRORS = {
         message: 'An active write-off for this order product already exists',
         httpCode: 409,
     },
+    WRITE_OFF_ORDER_PRODUCT_MISMATCH: {
+        code: 'W019',
+        message: 'The order product does not belong to the order or has another product',
+        httpCode: 400,
+    },
+    WRITE_OFF_NOT_PENDING: { code: 'W020', message: 'Only a pending write-off can be deleted by the client', httpCode: 400 },
 
     //ORDER
     ORDER_NOT_CREATED: { code: 'O001', message: 'Failed to create order', httpCode: 500 },
@@ -629,6 +635,7 @@ export const ERRORS = {
         message: 'Cannot guarantee exclusive price correction right now, try again later',
         httpCode: 503,
     },
+    ORDER_PRODUCT_CART_NOT_EDITABLE: { code: 'OP029', message: 'Only an open cart can be changed by the client', httpCode: 400 },
 
     //TRANSACTION
     TRANSACTION_NOT_CREATED: { code: 'TR001', message: 'Failed to transaction product', httpCode: 500 },
@@ -1240,6 +1247,11 @@ export const ERRORS = {
         message: 'Pre-orders changed during the move, retry the operation',
         httpCode: 409,
     },
+    PRE_ORDER_COLLECTION_ITEM_MULTIPLICITY_OPTION_NOT_FOUND: {
+        code: 'POCI040',
+        message: 'Multiplicity option of the pre order collection item not found',
+        httpCode: 404,
+    },
 
     // EMPLOYEE SCHEDULE
     EMPLOYEE_SCHEDULE_NOT_CREATED: { code: 'ES001', message: 'Failed to create employee schedule', httpCode: 500 },
@@ -1263,6 +1275,7 @@ export const ERRORS = {
         message: 'Too many products for a single consignment discount operation',
         httpCode: 400,
     },
+    DISCOUNT_RULES_NOT_FOUND: { code: 'DR010', message: 'Discount-rules not found', httpCode: 404 },
 
     // ACTION LOG
     ACTION_LOG_NOT_CREATED: { code: 'ALG001', message: 'Failed to create action-log', httpCode: 500 },

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@floristcloud/api-lib",
-    "version": "1.2.160",
+    "version": "1.2.161",
     "description": "",
     "main": "./build/index.js",
     "scripts": {

package/schemas/category/category-name.schema.ts

@@ -0,0 +1,4 @@
+import { CategorySchema } from './category.schema';
+
+// Категория только по идентификатору и названию — для ссылок из чужой карточки.
+export const CategoryNameSchema = CategorySchema.pick({ uuid: true, name: true });

package/schemas/category/index.ts

@@ -0,0 +1,7 @@
+export * from './category-create.schema';
+export * from './category-filter-value.schema';
+export * from './category-update.schema';
+export * from './category-list-filter.schema';
+export * from './category-list.schema';
+export * from './category.schema';
+export * from './category-name.schema';

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

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { ClientStatusEnum } from '../../enum/client-status.enum';
+import { ClientContractStatusEnum } from '../../enum/client-contract-status.enum';
+import { ClientTypeEnum } from '../../enum/client-type.enum';
+import { MoneySchema } from '../money.schema';
+
+export const ClientSchema = z.object({
+    uuid: z.uuid(),
+    name: z.string(),
+    contactName: z.string().nullable(),
+    phone: z.string().nullable(),
+    email: z.string().nullable(),
+    status: z.nativeEnum(ClientStatusEnum),
+    isCommon: z.boolean(),
+    contractNumber: z.string().nullable(),
+    contractDate: z.date().nullable(),
+    contractStatus: z.nativeEnum(ClientContractStatusEnum),
+    address: z.string().nullable(),
+    city: z.string().nullable(),
+    code: z.string().nullable(),
+    group: z.string().nullable(),
+    marking: z.string().nullable(),
+    alwaysRequiresDelivery: z.boolean(),
+    additionalPhone: z.string().nullable(),
+    comment: z.string().nullable(),
+    paymentGraceDaysAfterCompletion: z.number().nullable(),
+
+    balance: MoneySchema,
+
+    deletedAt: z.date().nullable(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    companyUUID: z.uuid(),
+
+    clientType: z.nativeEnum(ClientTypeEnum),
+    responsibleUserUUID: z.uuid().nullable(),
+    responsibleSince: z.date().nullable(),
+});

package/schemas/client/client-extended-for-client.schema.ts

@@ -0,0 +1,15 @@
+import { ClientForClientSchema } from './client-for-client.schema';
+import { ClientIndividualProfileSchema } from './client-individual-profile.schema';
+import { ClientLegalProfileSchema } from './client-legal-profile.schema';
+import { UserContactForClientSchema } from '../user/user-contact-for-client.schema';
+import { UserNameSchema } from '../user/user-name.schema';
+import { DiscountRulesForClientSchema } from '../discount-rules/discount-rules-for-client.schema';
+
+// Карточка клиента для `GET webshop/client/me`: менеджер — только имя, учётная запись — контакты входа.
+export const ClientExtendedForClientSchema = ClientForClientSchema.extend({
+    user: UserContactForClientSchema.nullable(),
+    responsibleUser: UserNameSchema.nullable(),
+    clientIndividualProfile: ClientIndividualProfileSchema.nullable(),
+    clientLegalProfile: ClientLegalProfileSchema.nullable(),
+    discountRulesList: DiscountRulesForClientSchema.array(),
+});

package/schemas/client/client-extended-list.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { ClientExtendedSchema } from './client-extended.schema';
+
+export const ClientExtendedListSchema = z.object({
+    clientList: ClientExtendedSchema.array(),
+    total: z.number(),
+});