@floristcloud/api-lib 1.2.160 → 1.2.162

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

@@ -1,83 +1,12 @@
-import { z } from 'zod';
-import { ProductExtendedForAdminSchema, ProductExtendedForClientSchema, ProductSchema } from '../product/product.schema';
-import { OrderSchema } from '../order/order.schema';
-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(),
-    productUUID: z.uuid(),
-    orderUUID: z.uuid(),
-    multiplicityOptionUUID: z.uuid().nullable().optional(),
-
-    quantity: z.number(),
-    price: MoneySchema,
-    amount: MoneySchema,
-    vatAmount: MoneySchema,
-    vat: z.number().nullable(),
-    checkAmount: MoneySchema,
-
-    comment: z.string().nullable(),
-    tag: z.string().nullable(),
-    isVerified: z.boolean(),
-    isEditable: z.boolean(),
-
-    product: ProductSchema,
-
-    createdByUserUUID: z.string(),
-    verifiedByUserUUID: z.string().nullable(),
-
-    createdAt: z.date(),
-    updatedAt: z.date(),
-});
-
-export const OrderProductForClientSchema = OrderProductSchema.omit({
-    isVerified: true,
-    verifiedByUserUUID: true,
-    createdByUserUUID: true,
-});
-
-export const OrderProductExtendedSchema = OrderProductSchema.extend({
-    product: ProductExtendedForAdminSchema,
-    order: OrderSchema,
-    multiplicityOption: OrderProductMultiplicityOptionSchema.nullable().optional(),
-});
-
-export const OrderProductForClientExtendedSchema = OrderProductForClientSchema.extend({
-    product: ProductExtendedForClientSchema,
-    multiplicityOptionUUID: z.uuid().nullable().optional(),
-});
-
-export const OrderProductForDistributeSchema = OrderProductSchema.extend({
-    order: OrderSchema,
-    client: ClientSchema,
-    branch: BranchSchema.nullable(),
-    distributionList: z.array(DistributionSchema),
-});
-
-export const OrderProductStepperPositionSchema = z.object({
-    uuid: z.string(),
-    orderUUID: z.string(),
-    productUUID: z.string(),
-    multiplicityOptionUUID: z.string().nullable().optional(),
-    multiplicityOptionTitle: z.string().nullable().optional(),
-    quantity: z.number(),
-    balance: z.number(),
-});
-
-export const ActiveStepperPositionsForOrderResponseSchema = z.object({
-    list: OrderProductStepperPositionSchema.array(),
-});
-
-export const SetOrderProductQuantityWebshopRequestSchema = z.object({
-    quantity: z.number().int().min(0),
-});
-
-export const SetOrderProductQuantityWebshopResponseSchema = z.object({
-    uuid: z.string().optional(),
-    quantity: z.number().optional(),
-    deleted: z.boolean().optional(),
-});
+export { OrderProductSchema } from './order-product-base.schema';
+export { OrderProductExtendedSchema } from './order-product-extended.schema';
+export { OrderProductForDistributeSchema } from './order-product-for-distribute.schema';
+export { OrderProductStepperPositionSchema } from './order-product-stepper-position.schema';
+export { ActiveStepperPositionsForOrderResponseSchema } from './active-stepper-positions-for-order-response.schema';
+export { SetOrderProductQuantityWebshopRequestSchema } from './set-order-product-quantity-webshop-request.schema';
+export { SetOrderProductQuantityWebshopResponseSchema } from './set-order-product-quantity-webshop-response.schema';
+export { OrderProductForClientSchema } from './order-product-for-client.schema';
+export {
+    /** @deprecated Используйте OrderProductExtendedForClientSchema. */
+    OrderProductExtendedForClientSchema as OrderProductForClientExtendedSchema,
+} from './order-product-extended-for-client.schema';

package/schemas/order-product/set-order-product-quantity-webshop-request.schema.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+export const SetOrderProductQuantityWebshopRequestSchema = z.object({
+    quantity: z.number().int().min(0),
+});

package/schemas/order-product/set-order-product-quantity-webshop-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+export const SetOrderProductQuantityWebshopResponseSchema = z.object({
+    uuid: z.string().optional(),
+    quantity: z.number().optional(),
+    deleted: z.boolean().optional(),
+});

package/schemas/pagination-request.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+// Общая пагинация страничных списков.
+export const PaginationRequestSchema = z.object({
+    page: z.coerce.number().optional().default(1),
+    count: z.coerce.number().optional().default(10),
+});

package/schemas/parser/check-ozexport-auth-s2s-request.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+
+// Непрозрачный идентификатор того, кто проверяет креды (API шлёт HMAC-SHA256 компании в hex, 64 символа).
+const OZEXPORT_REQUESTER_KEY_MAX_LENGTH = 128;
+
+export const CheckOzexportAuthS2SRequestSchema = z.object({
+    username: z.string(),
+    password: z.string(),
+    requesterKey: z.string().min(1).max(OZEXPORT_REQUESTER_KEY_MAX_LENGTH),
+});

package/schemas/parser/check-ozexport-auth-s2s-response-false.schema.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+export const CheckOzexportAuthS2SResponseFalseSchema = z.object({
+    isAuthorized: z.literal(false),
+});

package/schemas/parser/check-ozexport-auth-s2s-response-true.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { OzexportAccountUnitSchema } from '../integration/ozexport/ozexport-account-unit.schema';
+
+// Сколько юнитов покупателя разумно ждать у одного аккаунта (основной + подъюниты); больше — ответ сломан.
+const OZEXPORT_ACCOUNT_UNITS_MAX = 50;
+
+export const CheckOzexportAuthS2SResponseTrueSchema = z.object({
+    isAuthorized: z.literal(true),
+    units: z.array(OzexportAccountUnitSchema).min(1).max(OZEXPORT_ACCOUNT_UNITS_MAX),
+});

package/schemas/parser/check-ozexport-auth-s2s-response.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { CheckOzexportAuthS2SResponseFalseSchema } from './check-ozexport-auth-s2s-response-false.schema';
+import { CheckOzexportAuthS2SResponseTrueSchema } from './check-ozexport-auth-s2s-response-true.schema';
+
+export const CheckOzexportAuthS2SResponseSchema = z.discriminatedUnion('isAuthorized', [
+    CheckOzexportAuthS2SResponseFalseSchema,
+    CheckOzexportAuthS2SResponseTrueSchema,
+]);

package/schemas/parser/complete-parse-batch-s2s-request.schema.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+export const CompleteParseBatchS2SRequestSchema = z.object({
+    parseUUID: z.string().uuid(),
+});

package/schemas/parser/get-ozexport-job-status-s2s-request.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { OzexportJobAttemptSchema } from './ozexport-job-attempt.schema';
+
+export const GetOzexportJobStatusS2SRequestSchema = z.object({
+    jobId: z.uuid(),
+    attempt: z.coerce.number().pipe(OzexportJobAttemptSchema),
+});

package/schemas/parser/get-ozexport-job-status-s2s-response-finished.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { OzexportJobStateEnum } from '../../enum/ozexport-job-state.enum';
+import { OzexportJobResultSchema } from './ozexport-job-result.schema';
+
+export const GetOzexportJobStatusS2SResponseFinishedSchema = z.object({
+    state: z.literal(OzexportJobStateEnum.FINISHED),
+    result: OzexportJobResultSchema,
+});

package/schemas/parser/get-ozexport-job-status-s2s-response-running.schema.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { OzexportJobStateEnum } from '../../enum/ozexport-job-state.enum';
+
+export const GetOzexportJobStatusS2SResponseRunningSchema = z.object({ state: z.literal(OzexportJobStateEnum.RUNNING) });

package/schemas/parser/get-ozexport-job-status-s2s-response-unknown.schema.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { OzexportJobStateEnum } from '../../enum/ozexport-job-state.enum';
+
+export const GetOzexportJobStatusS2SResponseUnknownSchema = z.object({ state: z.literal(OzexportJobStateEnum.UNKNOWN) });

package/schemas/parser/get-ozexport-job-status-s2s-response.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { GetOzexportJobStatusS2SResponseFinishedSchema } from './get-ozexport-job-status-s2s-response-finished.schema';
+import { GetOzexportJobStatusS2SResponseRunningSchema } from './get-ozexport-job-status-s2s-response-running.schema';
+import { GetOzexportJobStatusS2SResponseUnknownSchema } from './get-ozexport-job-status-s2s-response-unknown.schema';
+
+// UNKNOWN означает потерю попытки парсером: повторный запуск требует attempt + 1, пока лимит попыток не исчерпан.
+export const GetOzexportJobStatusS2SResponseSchema = z.discriminatedUnion('state', [
+    GetOzexportJobStatusS2SResponseRunningSchema,
+    GetOzexportJobStatusS2SResponseFinishedSchema,
+    GetOzexportJobStatusS2SResponseUnknownSchema,
+]);

package/schemas/parser/index.ts

@@ -0,0 +1,50 @@
+export * from './check-ozexport-auth-s2s-request.schema';
+export * from './check-ozexport-auth-s2s-response-false.schema';
+export * from './check-ozexport-auth-s2s-response-true.schema';
+export * from './check-ozexport-auth-s2s-response.schema';
+export * from './complete-parse-batch-s2s-request.schema';
+export * from './get-ozexport-job-status-s2s-request.schema';
+export * from './get-ozexport-job-status-s2s-response-finished.schema';
+export * from './get-ozexport-job-status-s2s-response-running.schema';
+export * from './get-ozexport-job-status-s2s-response-unknown.schema';
+export * from './get-ozexport-job-status-s2s-response.schema';
+export * from './ozexport-job-attempt.schema';
+export * from './ozexport-job-counter.schema';
+export * from './ozexport-job-credentials.schema';
+export * from './ozexport-job-found-offer-observation.schema';
+export * from './ozexport-job-max-attempt.constant';
+export * from './ozexport-job-not-found-offer-observation.schema';
+export * from './ozexport-job-offer-observation.schema';
+export * from './ozexport-job-offer-observation.type';
+export * from './ozexport-job-offers-batch-s2s-request.schema';
+export * from './ozexport-job-offers-batch-s2s-response.schema';
+export * from './ozexport-job-price-tier.schema';
+export * from './ozexport-job-price-tiers.schema';
+export * from './ozexport-job-product-code.schema';
+export * from './ozexport-job-product-url.schema';
+export * from './ozexport-job-quantity.schema';
+export * from './ozexport-job-rejected-offer.schema';
+export * from './ozexport-job-result.schema';
+export * from './ozexport-job-result.type';
+export * from './ozexport-job-sort.schema';
+export * from './ozexport-job-sort.type';
+export * from './ozexport-job-stats.schema';
+export * from './ozexport-job-stock-line-id.schema';
+export * from './ozexport-job-stock-line-ids.schema';
+export * from './ozexport-job-stock-type.schema';
+export * from './ozexport-refresh-offer.schema';
+export * from './parse-batch-accepted-element.schema';
+export * from './parse-batch-element.schema';
+export * from './process-parse-batch-s2s-request.schema';
+export * from './process-parse-batch-s2s-response.schema';
+export * from './start-ozexport-job-base.shape';
+export * from './start-ozexport-job-s2s-request-account-crawl.schema';
+export * from './start-ozexport-job-s2s-request-offers-refresh.schema';
+export * from './start-ozexport-job-s2s-request.schema';
+export * from './start-ozexport-job-s2s-response-already-running.schema';
+export * from './start-ozexport-job-s2s-response-busy.schema';
+export * from './start-ozexport-job-s2s-response-finished.schema';
+export * from './start-ozexport-job-s2s-response-paused.schema';
+export * from './start-ozexport-job-s2s-response-shutting-down.schema';
+export * from './start-ozexport-job-s2s-response-started.schema';
+export * from './start-ozexport-job-s2s-response.schema';

package/schemas/parser/ozexport-job-attempt.schema.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { OZEXPORT_JOB_MAX_ATTEMPT } from './ozexport-job-max-attempt.constant';
+
+export const OzexportJobAttemptSchema = z.number().int().min(1).max(OZEXPORT_JOB_MAX_ATTEMPT);

package/schemas/parser/ozexport-job-counter.schema.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+
+export const OzexportJobCounterSchema = z.number().int().min(0);

package/schemas/parser/ozexport-job-credentials.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+
+const OZEXPORT_CREDENTIAL_MAX_LENGTH = 255;
+
+// Секреты существуют только в теле S2S-запроса и памяти парсера: не логировать, не сохранять с заданием.
+export const OzexportJobCredentialsSchema = z.object({
+    username: z.string().min(1).max(OZEXPORT_CREDENTIAL_MAX_LENGTH),
+    password: z.string().min(1).max(OZEXPORT_CREDENTIAL_MAX_LENGTH),
+});

package/schemas/parser/ozexport-job-found-offer-observation.schema.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { SupplierOfferPresenceEnum } from '../../enum/supplier-offer-presence.enum';
+import { PositiveDecimal4Schema } from '../positive-decimal4.schema';
+import { OzexportJobPriceTiersSchema } from './ozexport-job-price-tiers.schema';
+import { OzexportJobProductCodeSchema } from './ozexport-job-product-code.schema';
+import { OzexportJobProductUrlSchema } from './ozexport-job-product-url.schema';
+import { OzexportJobQuantitySchema } from './ozexport-job-quantity.schema';
+import { OzexportJobSortSchema } from './ozexport-job-sort.schema';
+import { OzexportJobStockLineIdsSchema } from './ozexport-job-stock-line-ids.schema';
+import { OzexportJobStockTypeSchema } from './ozexport-job-stock-type.schema';
+
+const OZEXPORT_LENGTH_MAX_LENGTH = 64;
+
+const OZEXPORT_CURRENCY = 'EUR';
+
+export const OzexportJobFoundOfferObservationSchema = z.object({
+    presence: z.literal(SupplierOfferPresenceEnum.FOUND),
+    productCode: OzexportJobProductCodeSchema,
+    stockType: OzexportJobStockTypeSchema,
+    // Необязательное обогащение: кривой адрес обнуляется, а не выбрасывает наблюдение.
+    productUrl: OzexportJobProductUrlSchema.nullable().catch(null),
+    sort: OzexportJobSortSchema,
+    length: z.string().max(OZEXPORT_LENGTH_MAX_LENGTH).nullable(),
+    // Stock lines плитки листинга (не stockLineIdList ответа: VMP схлопывает линии).
+    stockLineIds: OzexportJobStockLineIdsSchema,
+    // Стеблей в наличии всего (totalAvailableStockAmount), не упаковок: availableQuantity сайта считает целые упаковки.
+    availableQuantity: OzexportJobQuantitySchema.min(0).nullable(),
+    // Стеблей в упаковке (ведро/коробка) — piecesinUnit сайта.
+    piecesInUnit: OzexportJobQuantitySchema.min(1).nullable(),
+    // ЭФФЕКТИВНАЯ кратность заказа в стеблях: incrementalOrderQuantity сайта, если у предложения есть стеблевая цена
+    // (тир с порогом = incrementalOrderQuantity < piecesInUnit), иначе piecesInUnit — без стеблевой цены сайт продаёт
+    // только целые упаковки.
+    incrementalOrderQuantity: OzexportJobQuantitySchema.min(1).nullable(),
+    // Минимальный заказ в стеблях (minOrderQty сайта), если заполнен; иначе null.
+    minOrderQuantity: OzexportJobQuantitySchema.min(1).nullable(),
+    // Ближайшая дата отгрузки, если известна (startDate, дата у магазина, Europe/Amsterdam); цена может от неё зависеть.
+    // Прошедшие даты — дата партии, не отправляются (null).
+    departureDate: z.iso.date().nullable(),
+    currency: z.literal(OZEXPORT_CURRENCY),
+    // Закупка за стебель: b2bPrices тира erpResponse с порогом = эффективной кратности (incrementalOrderQuantity выше),
+    // а не нижнего порога. Строго > 0; null — такого тира нет (NO_PRICE; 0 не означает «нет цены»).
+    price: PositiveDecimal4Schema.nullable(),
+    // Тиры, которые показывает сайт: стеблевой (порог = кратность сайта, если она меньше упаковки) и за упаковку
+    // (порог = piecesInUnit). Прочие пороги erpResponse сайт не показывает и сюда не попадают.
+    priceTiers: OzexportJobPriceTiersSchema,
+});

package/schemas/parser/ozexport-job-max-attempt.constant.ts

@@ -0,0 +1,3 @@
+// Номер попытки задания — токен фенсинга: пачки и complete от устаревшей («зомби») попытки API отвергает.
+// Предел номера попытки: API не планирует попытку дальше него (и CHECK в supplier_sync_job).
+export const OZEXPORT_JOB_MAX_ATTEMPT = 10;

package/schemas/parser/ozexport-job-not-found-offer-observation.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { SupplierOfferPresenceEnum } from '../../enum/supplier-offer-presence.enum';
+import { OzexportJobProductCodeSchema } from './ozexport-job-product-code.schema';
+import { OzexportJobStockTypeSchema } from './ozexport-job-stock-type.schema';
+
+export const OzexportJobNotFoundOfferObservationSchema = z.object({
+    presence: z.literal(SupplierOfferPresenceEnum.NOT_FOUND),
+    productCode: OzexportJobProductCodeSchema,
+    stockType: OzexportJobStockTypeSchema,
+});

package/schemas/parser/ozexport-job-offer-observation.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { OzexportJobFoundOfferObservationSchema } from './ozexport-job-found-offer-observation.schema';
+import { OzexportJobNotFoundOfferObservationSchema } from './ozexport-job-not-found-offer-observation.schema';
+
+export const OzexportJobOfferObservationSchema = z.discriminatedUnion('presence', [
+    OzexportJobFoundOfferObservationSchema,
+    OzexportJobNotFoundOfferObservationSchema,
+]);

package/schemas/parser/ozexport-job-offer-observation.type.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { OzexportJobOfferObservationSchema } from './ozexport-job-offer-observation.schema';
+
+export type OzexportJobOfferObservation = z.infer<typeof OzexportJobOfferObservationSchema>;

package/schemas/parser/ozexport-job-offers-batch-s2s-request.schema.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { OzexportJobAttemptSchema } from './ozexport-job-attempt.schema';
+
+const INT4_MAX = 2147483647;
+
+// Пачка availability у ozexport — до 250 stock lines; пачка в API не больше.
+const OZEXPORT_OFFERS_BATCH_MAX = 250;
+
+// Идемпотентность по (jobId, attempt, seq): повтор возвращает сохранённый ответ; новая пачка требует нового seq.
+// Пачки попытки идут последовательно: seq задаёт порядок даже при одинаковом времени из-за сдвига часов.
+// API проверяет offers поштучно и ограничивает observedAt своим now(); неактивная/чужая попытка получает 409.
+export const OzexportJobOffersBatchS2SRequestSchema = z.object({
+    attempt: OzexportJobAttemptSchema,
+    // INTEGER в журнале пачек.
+    seq: z.number().int().min(0).max(INT4_MAX),
+    observedAt: z.iso.datetime(),
+    offers: z.array(z.unknown()).max(OZEXPORT_OFFERS_BATCH_MAX),
+});

package/schemas/parser/ozexport-job-offers-batch-s2s-response.schema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { OzexportJobRejectedOfferSchema } from './ozexport-job-rejected-offer.schema';
+
+export const OzexportJobOffersBatchS2SResponseSchema = z.object({
+    /**
+     * Принято к обработке: наблюдения, прошедшие проверку (не попавшие в rejected). Это не число изменённых строк —
+     * запоздавшее наблюдение принимается, но более свежую строку не перетирает; «не найдено» по неизвестному ключу
+     * принимается и ничего не меняет.
+     */
+    acceptedCount: z.number().int().min(0),
+    rejected: z.array(OzexportJobRejectedOfferSchema),
+});

package/schemas/parser/ozexport-job-price-tier.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { PositiveDecimal4Schema } from '../positive-decimal4.schema';
+import { OzexportJobQuantitySchema } from './ozexport-job-quantity.schema';
+
+export const OzexportJobPriceTierSchema = z.object({
+    minQuantity: OzexportJobQuantitySchema.min(1),
+    price: PositiveDecimal4Schema,
+});

package/schemas/parser/ozexport-job-price-tiers.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { OzexportJobPriceTierSchema } from './ozexport-job-price-tier.schema';
+
+const OZEXPORT_PRICE_TIERS_MAX = 10;
+
+export const OzexportJobPriceTiersSchema = z
+    .array(OzexportJobPriceTierSchema)
+    .max(OZEXPORT_PRICE_TIERS_MAX)
+    .refine(tiers => new Set(tiers.map(tier => tier.minQuantity)).size === tiers.length, {
+        message: 'Price tiers must have unique minQuantity',
+    });

package/schemas/parser/ozexport-job-product-code.schema.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+
+export const OzexportJobProductCodeSchema = z.string().trim().min(1).max(64);

package/schemas/parser/ozexport-job-product-url.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+
+// Страницы предложений ozexport — только https и только сайт каталога: адрес уходит в интерфейс и обратно в
+// парсер (pdpUrl), чужой хост недопустим.
+const OZEXPORT_SITE_HOST_PATTERN = /^www\.ozexport\.nl$/;
+
+const OZEXPORT_URL_MAX_LENGTH = 2048;
+
+export const OzexportJobProductUrlSchema = z
+    .url({ protocol: /^https$/, hostname: OZEXPORT_SITE_HOST_PATTERN })
+    .max(OZEXPORT_URL_MAX_LENGTH);

package/schemas/parser/ozexport-job-quantity.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+
+// Количества ложатся в INTEGER (int4) Postgres.
+const INT4_MAX = 2147483647;
+
+export const OzexportJobQuantitySchema = z.number().int().max(INT4_MAX);

package/schemas/parser/ozexport-job-rejected-offer.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+
+export const OzexportJobRejectedOfferSchema = z.object({
+    index: z.number().int().min(0),
+    reason: z.string(),
+});

package/schemas/parser/ozexport-job-result.schema.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { OzexportJobErrorCodeEnum } from '../../enum/ozexport-job-error-code.enum';
+import { OzexportJobResultStatusEnum } from '../../enum/ozexport-job-result-status.enum';
+import { OzexportAccountUnitSchema } from '../integration/ozexport/ozexport-account-unit.schema';
+import { OzexportJobAttemptSchema } from './ozexport-job-attempt.schema';
+import { OzexportJobStatsSchema } from './ozexport-job-stats.schema';
+
+// Сколько юнитов покупателя разумно ждать у одного аккаунта (как в check-auth); больше — ответ сломан.
+const OZEXPORT_ACCOUNT_UNITS_MAX = 50;
+
+export const OzexportJobResultSchema = z
+    .object({
+        attempt: OzexportJobAttemptSchema,
+        status: z.enum(OzexportJobResultStatusEnum),
+        errorCode: z.enum(OzexportJobErrorCodeEnum).nullable(),
+        // ACCOUNT_CRAWL: прочитаны все страницы, число страниц не плыло, <20% битых плиток, все пачки приняты.
+        // Только при true API снимает непросмотренные предложения (missedCrawls).
+        isListingComplete: z.boolean(),
+        // Юниты покупателя, увиденные после логина: попутно обновляют accountUnits интеграции. null — не читались.
+        units: z.array(OzexportAccountUnitSchema).max(OZEXPORT_ACCOUNT_UNITS_MAX).nullable(),
+        stats: OzexportJobStatsSchema,
+        // errorCode PAUSED: до какого момента лимитер выхода на паузе — API перепланирует попытку не раньше.
+        pausedUntil: z.iso.datetime().optional(),
+    })
+    .superRefine((result, ctx) => {
+        if (result.status === OzexportJobResultStatusEnum.SUCCESS && result.errorCode !== null) {
+            ctx.addIssue({ code: 'custom', path: ['errorCode'], message: 'SUCCESS must not carry an error code' });
+        }
+        if (result.status === OzexportJobResultStatusEnum.FAILED && result.errorCode === null) {
+            ctx.addIssue({ code: 'custom', path: ['errorCode'], message: 'FAILED must carry an error code' });
+        }
+    });

package/schemas/parser/ozexport-job-result.type.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { OzexportJobResultSchema } from './ozexport-job-result.schema';
+
+export type OzexportJobResult = z.infer<typeof OzexportJobResultSchema>;

package/schemas/parser/ozexport-job-sort.schema.ts

@@ -0,0 +1,5 @@
+import { ParseBatchElementSchema } from './parse-batch-element.schema';
+
+export const OzexportJobSortSchema = ParseBatchElementSchema.extend({
+    internalImageUrl: ParseBatchElementSchema.shape.internalImageUrl.nullable(),
+});

package/schemas/parser/ozexport-job-sort.type.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { OzexportJobSortSchema } from './ozexport-job-sort.schema';
+
+export type OzexportJobSort = z.infer<typeof OzexportJobSortSchema>;

package/schemas/parser/ozexport-job-stats.schema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { OzexportJobCounterSchema } from './ozexport-job-counter.schema';
+
+export const OzexportJobStatsSchema = z.object({
+    pagesTotal: OzexportJobCounterSchema,
+    pagesRead: OzexportJobCounterSchema,
+    offersSent: OzexportJobCounterSchema,
+    offersPriced: OzexportJobCounterSchema,
+    offersUnpriced: OzexportJobCounterSchema,
+    notFoundCount: OzexportJobCounterSchema,
+    skippedCount: OzexportJobCounterSchema,
+    loginCount: OzexportJobCounterSchema,
+    batchesFailed: OzexportJobCounterSchema,
+});

package/schemas/parser/ozexport-job-stock-line-id.schema.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+
+export const OzexportJobStockLineIdSchema = z.string().regex(/^\d{1,20}_\d{1,6}$/);

package/schemas/parser/ozexport-job-stock-line-ids.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { OzexportJobStockLineIdSchema } from './ozexport-job-stock-line-id.schema';
+
+// Stock lines одного предложения — с запасом: на практике их единицы.
+const OZEXPORT_STOCK_LINES_PER_OFFER_MAX = 50;
+
+export const OzexportJobStockLineIdsSchema = z.array(OzexportJobStockLineIdSchema).max(OZEXPORT_STOCK_LINES_PER_OFFER_MAX);

package/schemas/parser/ozexport-job-stock-type.schema.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+
+// Пустая строка — неизвестный тип плитки; это часть ключа предложения, не отсутствие поля.
+export const OzexportJobStockTypeSchema = z.string().trim().max(32);

package/schemas/parser/ozexport-refresh-offer.schema.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { OzexportJobProductCodeSchema } from './ozexport-job-product-code.schema';
+import { OzexportJobProductUrlSchema } from './ozexport-job-product-url.schema';
+import { OzexportJobSortSchema } from './ozexport-job-sort.schema';
+import { OzexportJobStockLineIdsSchema } from './ozexport-job-stock-line-ids.schema';
+import { OzexportJobStockTypeSchema } from './ozexport-job-stock-type.schema';
+
+export const OzexportRefreshOfferSchema = z.object({
+    productCode: OzexportJobProductCodeSchema,
+    // Тип плитки из ключа предложения ('' — неизвестен). Парсер возвращает его в наблюдениях этого кода эхом, как
+    // есть: NOT_FOUND и FOUND помечают ровно ключ (company, provider, productCode, stockType).
+    stockType: OzexportJobStockTypeSchema,
+    // Сохранённые stock lines — быстрый путь через availability; пусто — сразу PDP.
+    stockLineIds: OzexportJobStockLineIdsSchema,
+    // Адрес PDP (только https://www.ozexport.nl); парсер всё равно сверяет его со своим allowlist, прежде чем идти.
+    pdpUrl: OzexportJobProductUrlSchema.nullable(),
+    // Сорт предложения, как API его хранит (SupplierOffer: name, grower, color; картинки и VBN у предложения нет — null).
+    // Парсер отдаёт его в FOUND этого ключа; API для OFFERS_REFRESH сорт и шаблон предложения не меняет.
+    sort: OzexportJobSortSchema,
+});

package/schemas/parser/parse-batch-accepted-element.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+
+export const ParseBatchAcceptedElementSchema = z.object({
+    index: z.number().int().min(0),
+    sourceKey: z.string(),
+});

package/schemas/parser/parse-batch-element.schema.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+
+const PARSE_TEXT_MAX_LENGTH = 255;
+
+const PARSE_URL_MAX_LENGTH = 2048;
+
+// Ключ картинки в хранилище, который парсер кладёт при загрузке: files/parser/<имя>, только безопасные символы.
+const PARSER_IMAGE_KEY_PATTERN = /^files\/parser\/[A-Za-z0-9._-]+(\/[A-Za-z0-9._-]+)*$/;
+
+// Внешняя картинка сорта — только https и только хосты каталога ozexport (CDN картинок и прокси cloudinary).
+const EXTERNAL_IMAGE_HOST_PATTERN = /^(img\.ozexport\.nl|res\.cloudinary\.com)$/;
+
+const PARSE_VBN_MAX_LENGTH = 32;
+
+export const ParseBatchElementSchema = z.object({
+    // trim здесь только для проверки «не пусто»: String.prototype.trim режет тот же набор пробелов, что и
+    // каноническая нормализация текста источника в API (normalizeSourceText), которая и строит ключ сорта.
+    name: z.string().trim().min(1).max(PARSE_TEXT_MAX_LENGTH),
+    // Цвет — атрибут, не часть сорта: кривое значение обнуляется, элемент не выбрасывается.
+    color: z.string().max(PARSE_TEXT_MAX_LENGTH).nullable().catch(null),
+    grower: z.string().max(PARSE_TEXT_MAX_LENGTH).nullable(),
+    internalImageUrl: z
+        .string()
+        .max(PARSE_URL_MAX_LENGTH)
+        .regex(PARSER_IMAGE_KEY_PATTERN)
+        .refine(key => !key.split('/').some(segment => segment === '..' || segment === '.'), {
+            message: 'Image key must not contain dot segments',
+        }),
+    // Необязательное обогащение сорта: кривое значение превращается в null, а не выбрасывает элемент.
+    externalImageUrl: z
+        .url({ protocol: /^https$/, hostname: EXTERNAL_IMAGE_HOST_PATTERN })
+        .max(PARSE_URL_MAX_LENGTH)
+        .nullish()
+        .catch(null)
+        .transform(value => value ?? null),
+    vbn: z
+        .string()
+        .trim()
+        .min(1)
+        .max(PARSE_VBN_MAX_LENGTH)
+        .nullish()
+        .catch(null)
+        .transform(value => value ?? null),
+});

package/schemas/parser/parser-job-acknowledgement.schema.ts

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export const ParserJobAcknowledgementSchema = z.object({ isSuccess: z.boolean() });