@floristcloud/api-lib 1.2.134 → 1.2.136

package/commands/attribute-normalization/analyze-attribute-normalization.query.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { AttributeNormalizationScopeSchema } from '../../schemas/attribute-normalization/attribute-normalization-scope.schema';
+import { NormalizationValueSchema } from '../../schemas/attribute-normalization/normalization-value.schema';
+import { NormalizationSummarySchema } from '../../schemas/attribute-normalization/normalization-summary.schema';
+
+const AnalyzeAttributeNormalizationRequestSchema = AttributeNormalizationScopeSchema;
+
+const AnalyzeAttributeNormalizationResponseSchema = z.object({
+    data: z.object({
+        values: z.array(NormalizationValueSchema),
+        summary: NormalizationSummarySchema,
+    }),
+});
+
+export namespace AnalyzeAttributeNormalizationContractQuery {
+    export const RequestSchema = AnalyzeAttributeNormalizationRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = AnalyzeAttributeNormalizationResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+
+    export type Value = z.infer<typeof NormalizationValueSchema>;
+    export type Summary = z.infer<typeof NormalizationSummarySchema>;
+}

package/commands/attribute-normalization/execute-attribute-normalization.command.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { AttributeNormalizationScopeSchema } from '../../schemas/attribute-normalization/attribute-normalization-scope.schema';
+import { NormalizationDecisionSchema } from '../../schemas/attribute-normalization/normalization-decision.schema';
+import { NormalizationRowCountSchema } from '../../schemas/attribute-normalization/normalization-row-count.schema';
+
+const ExecuteAttributeNormalizationRequestSchema = AttributeNormalizationScopeSchema.extend({
+    // Верхней границы нет намеренно: анализ отдаёт все написания компании, и применение обязано
+    // принять их целиком — иначе прогон пришлось бы дробить, а разбиение на части снова открывает
+    // цепочки A→B и B→C, которые валидатор ловит только внутри одного запроса.
+    // Объём ограничен размером тела запроса, а стоимость — чанкованием при записи.
+    decisions: z.array(NormalizationDecisionSchema).min(1),
+});
+
+const ExecuteAttributeNormalizationResponseSchema = z.object({
+    data: z.object({
+        // Фактически изменённых строк по каждой таблице — считается по результату UPDATE,
+        // а не по предсказанию анализа: охват мог измениться.
+        updatedRows: NormalizationRowCountSchema,
+        appliedDecisions: z.number(),
+        actionLogUUID: z.string().nullable(),
+    }),
+});
+
+export namespace ExecuteAttributeNormalizationContractCommand {
+    export const RequestSchema = ExecuteAttributeNormalizationRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ExecuteAttributeNormalizationResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+
+    export type Decision = z.infer<typeof NormalizationDecisionSchema>;
+}

package/commands/attribute-normalization/get-grower-suggestions.query.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { ATTRIBUTE_NORMALIZATION_LIMITS } from '../../constant/attribute-normalization.constant';
+
+// Автокомплит производителя на фронте: union уникальных написаний по товарам, карточкам
+// и позициям коллекций. Справочника Grower нет и мы его не заводим.
+const GetGrowerSuggestionsRequestSchema = z.object({
+    search: z.string().trim().min(1).max(ATTRIBUTE_NORMALIZATION_LIMITS.MAX_VALUE_LENGTH).optional(),
+    count: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(ATTRIBUTE_NORMALIZATION_LIMITS.MAX_GROWER_SUGGESTIONS)
+        .default(ATTRIBUTE_NORMALIZATION_LIMITS.MAX_GROWER_SUGGESTIONS),
+});
+
+const GetGrowerSuggestionsResponseSchema = z.object({
+    data: z.object({
+        growers: z.array(z.string()),
+    }),
+});
+
+export namespace GetGrowerSuggestionsContractQuery {
+    export const RequestSchema = GetGrowerSuggestionsRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = GetGrowerSuggestionsResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/attribute-normalization/index.ts

@@ -0,0 +1,3 @@
+export { AnalyzeAttributeNormalizationContractQuery } from './analyze-attribute-normalization.query';
+export { ExecuteAttributeNormalizationContractCommand } from './execute-attribute-normalization.command';
+export { GetGrowerSuggestionsContractQuery } from './get-grower-suggestions.query';

package/commands/index.ts

@@ -61,3 +61,4 @@ export { CreateWsTicketContractCommand } from './session/create-ws-ticket.comman
 export { ValidateWsTicketS2SContractQuery } from './session/validate-ws-ticket-s2s.query';
 export * from './consignment-transfer';
 export * from './transfer-document';
+export * from './attribute-normalization';

package/commands/product-image/analyze-product-image-merge.query.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { ProductImageDuplicateModeEnum } from '../../enum/product-image-duplicate-mode.enum';
+import { ProductImageMergeGroupSchema } from '../../schemas/product-image/product-image-merge-group.schema';
+import { ProductImageMergeCandidateSchema } from '../../schemas/product-image/product-image-merge-candidate.schema';
+
+const AnalyzeProductImageMergeRequestSchema = z.object({
+    mode: z.nativeEnum(ProductImageDuplicateModeEnum).default(ProductImageDuplicateModeEnum.CURRENT),
+});
+
+const AnalyzeProductImageMergeResponseSchema = z.object({
+    data: z.object({
+        groups: z.array(ProductImageMergeGroupSchema),
+        // Живых карточек у компании всего — чтобы фронт показал масштаб.
+        totalImages: z.number(),
+        duplicateImages: z.number(),
+    }),
+});
+
+export namespace AnalyzeProductImageMergeContractQuery {
+    export const RequestSchema = AnalyzeProductImageMergeRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = AnalyzeProductImageMergeResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+
+    export type Group = z.infer<typeof ProductImageMergeGroupSchema>;
+    export type Candidate = z.infer<typeof ProductImageMergeCandidateSchema>;
+}

package/commands/product-image/execute-product-image-merge.command.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { PRODUCT_IMAGE_MERGE_LIMITS } from '../../constant/product-image-merge.constant';
+
+const ExecuteProductImageMergeRequestSchema = z.object({
+    primaryUUID: z.string().uuid(),
+    // Верхняя граница на группу: склейка идёт одной транзакцией, и неограниченный список
+    // упёрся бы в её таймаут. Реальные группы дублей — единицы карточек.
+    mergedUUIDList: z.array(z.string().uuid()).min(1).max(PRODUCT_IMAGE_MERGE_LIMITS.MAX_MERGED_PER_REQUEST),
+});
+
+const ExecuteProductImageMergeResponseSchema = z.object({
+    data: z.object({
+        relinkedProducts: z.number(),
+        relinkedPreOrderCollectionItems: z.number(),
+        movedAliases: z.number(),
+        droppedAliases: z.number(),
+        mergedImages: z.number(),
+    }),
+});
+
+export namespace ExecuteProductImageMergeContractCommand {
+    export const RequestSchema = ExecuteProductImageMergeRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ExecuteProductImageMergeResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/product-image/index.ts

@@ -14,3 +14,5 @@ export * from './alias/update-product-image-alias.command';
 export * from './alias/delete-product-image-alias.command';
 export * from './alias/bulk-create-product-image-alias.command';
 export * from './alias/bulk-create-product-image-alias-from-pre-order-collection-item.command';
+export { AnalyzeProductImageMergeContractQuery } from './analyze-product-image-merge.query';
+export { ExecuteProductImageMergeContractCommand } from './execute-product-image-merge.command';

package/constant/attribute-normalization.constant.ts

@@ -0,0 +1,9 @@
+export const ATTRIBUTE_NORMALIZATION_LIMITS = {
+    // Размер чанка для UPDATE ... WHERE поле IN (...).
+    UPDATE_CHUNK_SIZE: 200,
+    // Сколько уникальных написаний производителя отдавать в автокомплит.
+    MAX_GROWER_SUGGESTIONS: 500,
+    // Колонки атрибутов — text без ограничения; без границы одно решение раскатало бы
+    // многомегабайтную строку по всей истории компании и осело бы в журнале действий.
+    MAX_VALUE_LENGTH: 255,
+} as const;

package/constant/error.ts

@@ -1579,4 +1579,54 @@ export const ERRORS = {
         message: 'Transfer document number start cannot be decreased',
         httpCode: 400,
     },
+    ATTRIBUTE_NORMALIZATION_ANALYZE_FAILED: {
+        code: 'ANORM001',
+        message: 'Error when analyzing attribute normalization',
+        httpCode: 500,
+    },
+    ATTRIBUTE_NORMALIZATION_EXECUTE_FAILED: {
+        code: 'ANORM002',
+        message: 'Error when applying attribute normalization',
+        httpCode: 500,
+    },
+    ATTRIBUTE_NORMALIZATION_EMPTY_SCOPE: {
+        code: 'ANORM003',
+        message: 'None of the selected targets stores the selected attributes',
+        httpCode: 400,
+    },
+    PRODUCT_IMAGE_MERGE_TOO_MANY_IMAGES: {
+        code: 'PI015',
+        message: 'Too many product images to analyze duplicates in one pass',
+        httpCode: 400,
+    },
+    ATTRIBUTE_NORMALIZATION_INVALID_DECISIONS: {
+        code: 'ANORM006',
+        message: 'Normalization decisions are inconsistent',
+        httpCode: 400,
+    },
+    CATALOG_BULK_REWRITE_LOCK_UNAVAILABLE: {
+        code: 'ANORM007',
+        message: 'Cannot guarantee exclusive execution right now, try again later',
+        httpCode: 503,
+    },
+    ATTRIBUTE_NORMALIZATION_ALREADY_RUNNING: {
+        code: 'ANORM005',
+        message: 'Another attribute normalization run is already in progress for this company',
+        httpCode: 409,
+    },
+    PRODUCT_IMAGE_MERGE_NOT_DUPLICATES: {
+        code: 'PI017',
+        message: 'Selected product images are not duplicates of the primary one',
+        httpCode: 409,
+    },
+    PRODUCT_IMAGE_MERGE_ALREADY_RUNNING: {
+        code: 'PI016',
+        message: 'Another product image merge is already in progress for this company',
+        httpCode: 409,
+    },
+    GROWER_SUGGESTIONS_FETCH_FAILED: {
+        code: 'ANORM004',
+        message: 'Error when retrieving grower suggestions',
+        httpCode: 500,
+    },
 } as const;

package/constant/index.ts

@@ -10,3 +10,5 @@ export * from './okei';
 export * from './contact-phone.constant';
 export * from './settings.constant';
 export * from './consignment-product-enrichment.constant';
+export * from './attribute-normalization.constant';
+export * from './product-image-merge.constant';

package/constant/product-image-merge.constant.ts

@@ -0,0 +1,8 @@
+export const PRODUCT_IMAGE_MERGE_LIMITS = {
+    // Поиск дублей группирует карточки в приложении, а не в SQL: канон цвета живёт в словаре
+    // на стороне кода. Значит все карточки компании оказываются в памяти, и объём надо ограничить
+    // явно — иначе на очень крупной компании анализ молча съест память процесса.
+    MAX_ANALYZED_IMAGES: 100_000,
+    // Сколько карточек можно поглотить за один запрос: всё идёт одной транзакцией.
+    MAX_MERGED_PER_REQUEST: 200,
+} as const;

package/enum/action-log-type.enum.ts

@@ -19,4 +19,6 @@ export enum ActionLogTypeEnum {
     DELETE_CONSIGNMENT_ITEMS = 'DELETE_CONSIGNMENT_ITEMS',
     GROUP_UPDATE_CONSIGNMENT_ITEMS = 'GROUP_UPDATE_CONSIGNMENT_ITEMS',
     TRANSFER_CONSIGNMENT_ITEMS = 'TRANSFER_CONSIGNMENT_ITEMS',
+    NORMALIZE_ATTRIBUTES = 'NORMALIZE_ATTRIBUTES',
+    MERGE_PRODUCT_IMAGES = 'MERGE_PRODUCT_IMAGES',
 }

package/enum/index.ts

@@ -108,3 +108,8 @@ export * from './transfer-document-item-kind.enum';
 export * from './write-off-report-date-basis.enum';
 export * from './product-enrichment-field.enum';
 export * from './product-enrichment-field-state.enum';
+export * from './normalized-attribute.enum';
+export * from './normalization-target.enum';
+export * from './normalization-value-state.enum';
+export * from './normalization-decision-action.enum';
+export * from './product-image-duplicate-mode.enum';

package/enum/normalization-decision-action.enum.ts

@@ -0,0 +1,9 @@
+// Решение человека по одному написанию. Правила в БД не сохраняются — решение живёт один прогон.
+export enum NormalizationDecisionActionEnum {
+    // Переписать на указанное значение.
+    MAP = 'MAP',
+    // Очистить поле (значение — мусор).
+    CLEAR = 'CLEAR',
+    // Оставить как есть.
+    KEEP = 'KEEP',
+}

package/enum/normalization-target.enum.ts

@@ -0,0 +1,8 @@
+// Таблицы, попадающие в охват нормализации. PRODUCT_CONFIGURATION сужается только компанией:
+// правила кратности нормализуются целиком, иначе они разъедутся с товарами.
+export enum NormalizationTargetEnum {
+    PRODUCT = 'PRODUCT',
+    PRODUCT_IMAGE = 'PRODUCT_IMAGE',
+    PRE_ORDER_COLLECTION_ITEM = 'PRE_ORDER_COLLECTION_ITEM',
+    PRODUCT_CONFIGURATION = 'PRODUCT_CONFIGURATION',
+}

package/enum/normalization-value-state.enum.ts

@@ -0,0 +1,9 @@
+// Что анализ знает про конкретное написание атрибута.
+export enum NormalizationValueStateEnum {
+    // Словарь (или кластеризация для производителя) предложил другое написание.
+    SUGGESTED = 'SUGGESTED',
+    // Значение уже каноничное, менять нечего.
+    CANONICAL = 'CANONICAL',
+    // Словарь значение не узнал — решение принимает человек в рамках прогона.
+    UNRECOGNIZED = 'UNRECOGNIZED',
+}

package/enum/normalized-attribute.enum.ts

@@ -0,0 +1,6 @@
+// Справочные атрибуты, которые умеет приводить к единому написанию операция нормализации.
+export enum NormalizedAttributeEnum {
+    COLOR = 'COLOR',
+    COUNTRY = 'COUNTRY',
+    GROWER = 'GROWER',
+}

package/enum/permission-key.enum.ts

@@ -17,6 +17,16 @@ export enum PermissionKeyEnum {
     PAGE_PRE_ORDERS_VIEW = 'page.pre_orders.view',
     PAGE_REPORT_VIEW = 'page.report.view',
     PAGE_STAFF_VIEW = 'page.staff.view',
+    ORDER_CREATE = 'order.create',
+    ORDER_EDIT = 'order.edit',
+    ORDER_DELETE = 'order.delete',
+    // Order-level money edits: discount and delivery cost (скидка и стоимость доставки).
+    ORDER_PRICE_EDIT = 'order.price.edit',
+    ORDER_STATUS_CHANGE = 'order.status.change',
+    WRITE_OFF_CREATE = 'write_off.create',
+    WRITE_OFF_DELETE = 'write_off.delete',
+    // Moving a write-off out of PENDING (принятие / отклонение списания).
+    WRITE_OFF_APPROVE = 'write_off.approve',
 }
 
 export const PERMISSION_KEY_LIST: PermissionKeyEnum[] = [
@@ -36,4 +46,12 @@ export const PERMISSION_KEY_LIST: PermissionKeyEnum[] = [
     PermissionKeyEnum.PAGE_PRE_ORDERS_VIEW,
     PermissionKeyEnum.PAGE_REPORT_VIEW,
     PermissionKeyEnum.PAGE_STAFF_VIEW,
+    PermissionKeyEnum.ORDER_CREATE,
+    PermissionKeyEnum.ORDER_EDIT,
+    PermissionKeyEnum.ORDER_DELETE,
+    PermissionKeyEnum.ORDER_PRICE_EDIT,
+    PermissionKeyEnum.ORDER_STATUS_CHANGE,
+    PermissionKeyEnum.WRITE_OFF_CREATE,
+    PermissionKeyEnum.WRITE_OFF_DELETE,
+    PermissionKeyEnum.WRITE_OFF_APPROVE,
 ];

package/enum/product-image-duplicate-mode.enum.ts

@@ -0,0 +1,7 @@
+// В каком виде искать дубли карточек.
+export enum ProductImageDuplicateModeEnum {
+    // По значениям как они лежат сейчас.
+    CURRENT = 'CURRENT',
+    // По значениям, приведённым к канону — превью того, что слипнется после нормализации.
+    AFTER_NORMALIZATION = 'AFTER_NORMALIZATION',
+}

package/package.json

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

package/schemas/action-log/action-log-payload.schema.ts

@@ -17,6 +17,8 @@ import { ConsignmentItemsCreateActionLogSchema } from './consignment-items-creat
 import { ConsignmentItemsDeleteActionLogSchema } from './consignment-items-delete-action-log.schema';
 import { GroupUpdateConsignmentItemsActionLogSchema } from './group-update-consignment-items-action-log.schema';
 import { TransferConsignmentItemsActionLogSchema } from './transfer-consignment-items-action-log.schema';
+import { NormalizeAttributesActionLogSchema } from './normalize-attributes-action-log.schema';
+import { MergeProductImagesActionLogSchema } from './merge-product-images-action-log.schema';
 
 export const ActionLogPayloadSchema = z.union([
     OrderDeleteActionLogPayloadSchema,
@@ -37,5 +39,7 @@ export const ActionLogPayloadSchema = z.union([
     ConsignmentItemsDeleteActionLogSchema,
     GroupUpdateConsignmentItemsActionLogSchema,
     TransferConsignmentItemsActionLogSchema,
+    NormalizeAttributesActionLogSchema,
+    MergeProductImagesActionLogSchema,
     z.null(),
 ]);

package/schemas/action-log/merge-product-images-action-log.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+
+export const MergeProductImagesActionLogSchema = z.object({
+    primaryImageUUID: z.string(),
+    mergedImageUUIDList: z.array(z.string()),
+    relinkedProducts: z.number(),
+    relinkedPreOrderCollectionItems: z.number(),
+    movedAliases: z.number(),
+});

package/schemas/action-log/normalize-attributes-action-log.schema.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { NormalizedAttributeEnum } from '../../enum/normalized-attribute.enum';
+import { NormalizationTargetEnum } from '../../enum/normalization-target.enum';
+import { NormalizationDecisionActionEnum } from '../../enum/normalization-decision-action.enum';
+
+// Одна агрегатная запись на прогон: построчный лог тут не нужен, операция работает
+// на уникальных значениях, а не на строках.
+export const NormalizeAttributesActionLogSchema = z.object({
+    attributes: z.array(z.nativeEnum(NormalizedAttributeEnum)),
+    targets: z.array(z.nativeEnum(NormalizationTargetEnum)),
+    decisions: z.array(
+        z.object({
+            attribute: z.nativeEnum(NormalizedAttributeEnum),
+            raw: z.string(),
+            action: z.nativeEnum(NormalizationDecisionActionEnum),
+            value: z.string().nullable(),
+        }),
+    ),
+    updatedRows: z.partialRecord(z.nativeEnum(NormalizationTargetEnum), z.number()),
+    totalUpdatedRows: z.number(),
+});

package/schemas/attribute-normalization/attribute-normalization-scope.schema.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { NormalizedAttributeEnum } from '../../enum/normalized-attribute.enum';
+import { NormalizationTargetEnum } from '../../enum/normalization-target.enum';
+
+/**
+ * Охват прогона. Общий для анализа и применения: execute перепроверяет его заново, потому что
+ * между анализом и применением в таблицы могли приехать новые строки.
+ *
+ * Ограничения охвата, которые нельзя выразить схемой и которые проверяет сервис:
+ *  - consignmentUUIDList сужает только PRODUCT — у карточек и позиций коллекций нет поставки;
+ *  - preOrderCollectionUUIDList сужает только PRE_ORDER_COLLECTION_ITEM;
+ *  - PRODUCT_CONFIGURATION не сужается ничем, кроме компании: правила нормализуются целиком,
+ *    иначе часть из них разъедется с товарами.
+ */
+// Дедупликация в схеме, а не в сервисе: списки читают и analyze, и execute, и запись в журнал —
+// повтор «PRODUCT» тысячу раз означал бы тысячу полных проходов по таблице товаров.
+const dedupe = <T>(list: T[]): T[] => Array.from(new Set(list));
+
+export const AttributeNormalizationScopeSchema = z.object({
+    attributes: z.array(z.nativeEnum(NormalizedAttributeEnum)).min(1).max(Object.keys(NormalizedAttributeEnum).length).transform(dedupe),
+    targets: z.array(z.nativeEnum(NormalizationTargetEnum)).min(1).max(Object.keys(NormalizationTargetEnum).length).transform(dedupe),
+    // Без верхней границы: списки уходят в запрос одним параметром-массивом, длина упирается
+    // только в размер тела запроса.
+    consignmentUUIDList: z.array(z.string().uuid()).optional(),
+    preOrderCollectionUUIDList: z.array(z.string().uuid()).optional(),
+    createdFrom: z.coerce.date().optional(),
+    createdTo: z.coerce.date().optional(),
+    // У поставки нет признака закрытости — закрытость живёт на товаре (Product.isOpen).
+    // По умолчанию закрытые товары не трогаем: это распроданная история.
+    isIncludingClosedProducts: z.boolean().default(false),
+});

package/schemas/attribute-normalization/normalization-decision.schema.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { NormalizedAttributeEnum } from '../../enum/normalized-attribute.enum';
+import { NormalizationDecisionActionEnum } from '../../enum/normalization-decision-action.enum';
+import { ATTRIBUTE_NORMALIZATION_LIMITS } from '../../constant/attribute-normalization.constant';
+
+// Решение человека по одному написанию. Правила в БД не сохраняются — решение живёт один прогон.
+export const NormalizationDecisionSchema = z
+    .object({
+        attribute: z.nativeEnum(NormalizedAttributeEnum),
+        raw: z.string().min(1).max(ATTRIBUTE_NORMALIZATION_LIMITS.MAX_VALUE_LENGTH),
+        action: z.nativeEnum(NormalizationDecisionActionEnum),
+        // Целевое написание — обязательно и только для MAP.
+        value: z.string().min(1).max(ATTRIBUTE_NORMALIZATION_LIMITS.MAX_VALUE_LENGTH).optional(),
+    })
+    .refine(decision => (decision.action === NormalizationDecisionActionEnum.MAP) === (decision.value !== undefined), {
+        message: 'value is required for MAP and forbidden otherwise',
+        path: ['value'],
+    });

package/schemas/attribute-normalization/normalization-row-count.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { NormalizationTargetEnum } from '../../enum/normalization-target.enum';
+
+// Сколько строк приходится на каждую таблицу охвата. Ключи неполные: значение живёт
+// не во всех таблицах сразу, а таблица может не хранить нужный атрибут.
+export const NormalizationRowCountSchema = z.partialRecord(z.nativeEnum(NormalizationTargetEnum), z.number());

package/schemas/attribute-normalization/normalization-summary.schema.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { NormalizedAttributeEnum } from '../../enum/normalized-attribute.enum';
+import { NormalizationTargetEnum } from '../../enum/normalization-target.enum';
+import { NormalizationRowCountSchema } from './normalization-row-count.schema';
+import { ProductImageDuplicateForecastSchema } from './product-image-duplicate-forecast.schema';
+
+// Итоги анализа: всё, что фронт показывает перед запуском необратимой операции.
+export const NormalizationSummarySchema = z.object({
+    // Уникальных написаний по каждому атрибуту.
+    uniqueValues: z.partialRecord(z.nativeEnum(NormalizedAttributeEnum), z.number()),
+    // Строк к изменению по каждой таблице, если принять все предложения. Считается по строкам:
+    // строка, у которой меняются и цвет, и страна, — это одна строка, а не две.
+    affectedRows: NormalizationRowCountSchema,
+    // Строк, которые прогон пропустит из-за того, что позиция закрыта. Нужно фронту, чтобы
+    // предложить включить их флагом: по умолчанию закрытая история не трогается.
+    // null означает «пропускать нечего»: либо флаг уже включён, либо ни одна таблица охвата
+    // не различает открытые и закрытые позиции.
+    skippedClosedRows: NormalizationRowCountSchema.nullable(),
+    // Строк заказов, отображающих затрагиваемые товары. Нужно фронту для предупреждения:
+    // операция необратима, а в заказах видно старое написание.
+    affectedOrderProductRows: z.number(),
+    // Таблицы, которых не касается сужение по выбранным поставкам и коллекциям: у карточки
+    // номенклатуры нет поставки, у товара нет коллекции. Для них охват остаётся широким —
+    // фронт обязан предупредить, иначе админ будет думать, что тронет одну поставку,
+    // а прогон перепишет всю компанию.
+    targetsIgnoringUuidScope: z.array(z.nativeEnum(NormalizationTargetEnum)),
+    // null означает, что карточки в охват не входят и прогон их не трогает.
+    productImageDuplicatesAfterRun: ProductImageDuplicateForecastSchema.nullable(),
+});

package/schemas/attribute-normalization/normalization-value.schema.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { NormalizedAttributeEnum } from '../../enum/normalized-attribute.enum';
+import { NormalizationValueStateEnum } from '../../enum/normalization-value-state.enum';
+import { NormalizationRowCountSchema } from './normalization-row-count.schema';
+
+// Одно написание атрибута в истории компании и то, что операция про него знает.
+export const NormalizationValueSchema = z.object({
+    attribute: z.nativeEnum(NormalizedAttributeEnum),
+    // Написание как оно лежит в базе — оно же ключ решения в execute.
+    raw: z.string(),
+    // Что предлагает словарь (для производителя — кластеризация). null, если предложить нечего.
+    suggested: z.string().nullable(),
+    state: z.nativeEnum(NormalizationValueStateEnum),
+    rowCount: NormalizationRowCountSchema,
+    // Другие написания того же кластера — только для производителя, у цвета и страны словарь.
+    clusterRaw: z.array(z.string()),
+});

package/schemas/attribute-normalization/product-image-duplicate-forecast.schema.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+// Прогноз по дублям карточек номенклатуры после прогона. Уникального ключа по идентичности
+// у карточек нет, поэтому прогон может сделать две карточки неразличимыми, и резолвер начнёт
+// выбирать между ними произвольно. Апдейт при этом не упадёт — предупредить можно только заранее.
+export const ProductImageDuplicateForecastSchema = z.object({
+    // false — посчитать не удалось (карточек больше предела). Это НЕ то же самое,
+    // что «дублей не будет»: при false числа ниже не значат ничего.
+    isCounted: z.boolean(),
+    total: z.number(),
+    // Из них те, что сегодня ещё различимы: именно их создаст этот прогон.
+    new: z.number(),
+});

package/schemas/index.ts

@@ -84,3 +84,11 @@ export * from './positive-money.schema';
 export * from './report/report-order-filter.schema';
 export * from './transfer-document/transfer-document.schema';
 export * from './transfer-document/transfer-document-detailed.schema';
+export * from './attribute-normalization/attribute-normalization-scope.schema';
+export * from './product-image/product-image-merge-candidate.schema';
+export * from './product-image/product-image-merge-group.schema';
+export * from './attribute-normalization/normalization-row-count.schema';
+export * from './attribute-normalization/normalization-value.schema';
+export * from './attribute-normalization/normalization-summary.schema';
+export * from './attribute-normalization/normalization-decision.schema';
+export * from './attribute-normalization/product-image-duplicate-forecast.schema';

package/schemas/product-image/product-image-merge-candidate.schema.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+
+// Карточка — участник группы дублей, с числом ссылок на неё.
+export const ProductImageMergeCandidateSchema = z.object({
+    uuid: z.string(),
+    name: z.string(),
+    // Ключ файла в хранилище: без него нечем показать превью фото группы, а основную
+    // карточку админ выбирает в том числе по картинке.
+    productImageUrl: z.string(),
+    categoryUUID: z.string().nullable(),
+    grower: z.string().nullable(),
+    country: z.string().nullable(),
+    color: z.string().nullable(),
+    productCount: z.number(),
+    preOrderCollectionItemCount: z.number(),
+    aliasCount: z.number(),
+    // Карточка, которую операция предлагает оставить: больше всего ссылок, при равенстве —
+    // меньший uuid, чтобы повторный анализ давал тот же ответ.
+    isPrimary: z.boolean(),
+});

package/schemas/product-image/product-image-merge-group.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { ProductImageMergeCandidateSchema } from './product-image-merge-candidate.schema';
+
+// Группа карточек, неразличимых по идентичности.
+export const ProductImageMergeGroupSchema = z.object({
+    // Ключ группы — нормализованная идентичность, по которой карточки признаны одинаковыми.
+    key: z.string(),
+    candidates: z.array(ProductImageMergeCandidateSchema),
+});