@open-mercato/core 0.6.6-develop.6094.1.28b081ea16 → 0.6.6-develop.6121.1.5797a901b3

package/src/modules/catalog/components/products/productForm.ts

@@ -157,6 +157,32 @@ export type ProductFormValues = {
   tags: string[];
   optionSchemaId?: string | null;
   updatedAt?: string | null;
+  countryOfOriginCode: string;
+  pkwiuCode: string;
+  cnCode: string;
+  hsCode: string;
+  taxClassificationCode: string;
+  gtuCodes: string[];
+  ageMin: string;
+  isExciseGood: boolean;
+  exciseCategory: string | null;
+  requiresPrescription: boolean;
+  hazmatClass: string;
+  unNumber: string;
+  hazmatPackingGroup: string | null;
+  containsLithiumBattery: boolean;
+  launchAt: string;
+  endOfLifeAt: string;
+  availableFrom: string;
+  availableUntil: string;
+  minOrderQty: string;
+  maxOrderQty: string;
+  orderQtyIncrement: string;
+  requiresShipping: boolean;
+  isQuoteOnly: boolean;
+  seoTitle: string;
+  seoDescription: string;
+  canonicalUrl: string;
 };
 
 const optionalPositiveNumberInput = z.preprocess((value) => {
@@ -251,6 +277,45 @@ export const productFormSchema = z
     channelIds: z.array(z.string().uuid()).optional(),
     tags: z.array(z.string().trim().min(1).max(100)).optional(),
     optionSchemaId: z.string().uuid().nullable().optional(),
+    countryOfOriginCode: z
+      .string()
+      .trim()
+      .regex(/^([A-Za-z]{2})?$/, 'catalog.products.validation.countryCodeInvalid')
+      .optional(),
+    pkwiuCode: z.string().trim().max(32).optional(),
+    cnCode: z.string().trim().max(32).optional(),
+    hsCode: z.string().trim().max(32).optional(),
+    taxClassificationCode: z.string().trim().max(64).optional(),
+    gtuCodes: z.array(z.string()).optional(),
+    ageMin: optionalBoundedIntegerInput(0, 120),
+    isExciseGood: z.boolean().optional(),
+    exciseCategory: z.string().nullable().optional(),
+    requiresPrescription: z.boolean().optional(),
+    hazmatClass: z.string().trim().max(32).optional(),
+    unNumber: z
+      .string()
+      .trim()
+      .regex(/^((?:UN)?[0-9]{4})?$/i, 'catalog.products.validation.unNumberInvalid')
+      .optional(),
+    hazmatPackingGroup: z.string().nullable().optional(),
+    containsLithiumBattery: z.boolean().optional(),
+    launchAt: z.string().optional(),
+    endOfLifeAt: z.string().optional(),
+    availableFrom: z.string().optional(),
+    availableUntil: z.string().optional(),
+    minOrderQty: optionalBoundedIntegerInput(1, 100000000),
+    maxOrderQty: optionalBoundedIntegerInput(1, 100000000),
+    orderQtyIncrement: optionalBoundedIntegerInput(1, 100000000),
+    requiresShipping: z.boolean().optional(),
+    isQuoteOnly: z.boolean().optional(),
+    seoTitle: z.string().trim().max(255).optional(),
+    seoDescription: z.string().trim().max(1000).optional(),
+    canonicalUrl: z
+      .string()
+      .trim()
+      .max(500)
+      .regex(/^(https?:\/\/\S+)?$/, 'catalog.products.validation.canonicalUrlInvalid')
+      .optional(),
   })
   .passthrough()
   .refine(
@@ -260,12 +325,34 @@ export const productFormSchema = z
   .refine(
     (data) => !data.defaultSalesUnit || (data.defaultUnit != null && data.defaultUnit.length > 0),
     { message: 'catalog.products.validation.baseUnitRequired', path: ['defaultUnit'] }
+  )
+  .refine(
+    (data) =>
+      data.minOrderQty === undefined ||
+      data.maxOrderQty === undefined ||
+      data.maxOrderQty >= data.minOrderQty,
+    { message: 'catalog.products.validation.orderQtyRange', path: ['maxOrderQty'] }
+  )
+  .refine(
+    (data) =>
+      !data.launchAt ||
+      !data.endOfLifeAt ||
+      new Date(data.endOfLifeAt) >= new Date(data.launchAt),
+    { message: 'catalog.products.validation.lifecycleDateRange', path: ['endOfLifeAt'] }
+  )
+  .refine(
+    (data) =>
+      !data.availableFrom ||
+      !data.availableUntil ||
+      new Date(data.availableUntil) >= new Date(data.availableFrom),
+    { message: 'catalog.products.validation.availabilityDateRange', path: ['availableUntil'] }
   );
 
 export const PRODUCT_FORM_STEPS = [
   "general",
   "organize",
   "uom",
+  "compliance",
   "variants",
 ] as const;
 
@@ -302,11 +389,186 @@ export const BASE_INITIAL_VALUES: ProductFormValues = {
   channelIds: [],
   tags: [],
   optionSchemaId: null,
+  countryOfOriginCode: "",
+  pkwiuCode: "",
+  cnCode: "",
+  hsCode: "",
+  taxClassificationCode: "",
+  gtuCodes: [],
+  ageMin: "",
+  isExciseGood: false,
+  exciseCategory: null,
+  requiresPrescription: false,
+  hazmatClass: "",
+  unNumber: "",
+  hazmatPackingGroup: null,
+  containsLithiumBattery: false,
+  launchAt: "",
+  endOfLifeAt: "",
+  availableFrom: "",
+  availableUntil: "",
+  minOrderQty: "",
+  maxOrderQty: "",
+  orderQtyIncrement: "",
+  requiresShipping: true,
+  isQuoteOnly: false,
+  seoTitle: "",
+  seoDescription: "",
+  canonicalUrl: "",
 };
 
 export const isConfigurableProductType = (type: string): boolean =>
   (CATALOG_CONFIGURABLE_PRODUCT_TYPES as readonly string[]).includes(type);
 
+const complianceTrimOrNull = (value: string | null | undefined): string | null => {
+  const trimmed = typeof value === "string" ? value.trim() : "";
+  return trimmed.length ? trimmed : null;
+};
+
+const compliancePositiveIntOrNull = (
+  value: string | number | null | undefined,
+): number | null => {
+  if (typeof value === "number") {
+    return Number.isFinite(value) && Number.isInteger(value) ? value : null;
+  }
+  const trimmed = typeof value === "string" ? value.trim() : "";
+  if (!trimmed.length) return null;
+  const numeric = Number(trimmed);
+  return Number.isFinite(numeric) && Number.isInteger(numeric) ? numeric : null;
+};
+
+const complianceDateOrNull = (value: string | null | undefined): string | null => {
+  const trimmed = typeof value === "string" ? value.trim() : "";
+  if (!trimmed.length) return null;
+  const parsed = new Date(trimmed);
+  return Number.isNaN(parsed.getTime()) ? null : parsed.toISOString();
+};
+
+export const buildComplianceProductPayload = (
+  values: ProductFormValues,
+): Record<string, unknown> => ({
+  countryOfOriginCode: complianceTrimOrNull(values.countryOfOriginCode),
+  pkwiuCode: complianceTrimOrNull(values.pkwiuCode),
+  cnCode: complianceTrimOrNull(values.cnCode),
+  hsCode: complianceTrimOrNull(values.hsCode),
+  taxClassificationCode: complianceTrimOrNull(values.taxClassificationCode),
+  gtuCodes:
+    Array.isArray(values.gtuCodes) && values.gtuCodes.length
+      ? values.gtuCodes
+      : null,
+  ageMin: compliancePositiveIntOrNull(values.ageMin),
+  isExciseGood: values.isExciseGood === true,
+  exciseCategory: complianceTrimOrNull(values.exciseCategory),
+  requiresPrescription: values.requiresPrescription === true,
+  hazmatClass: complianceTrimOrNull(values.hazmatClass),
+  unNumber: complianceTrimOrNull(values.unNumber),
+  hazmatPackingGroup: complianceTrimOrNull(values.hazmatPackingGroup),
+  containsLithiumBattery: values.containsLithiumBattery === true,
+  launchAt: complianceDateOrNull(values.launchAt),
+  endOfLifeAt: complianceDateOrNull(values.endOfLifeAt),
+  availableFrom: complianceDateOrNull(values.availableFrom),
+  availableUntil: complianceDateOrNull(values.availableUntil),
+  minOrderQty: compliancePositiveIntOrNull(values.minOrderQty),
+  maxOrderQty: compliancePositiveIntOrNull(values.maxOrderQty),
+  orderQtyIncrement: compliancePositiveIntOrNull(values.orderQtyIncrement),
+  requiresShipping: values.requiresShipping !== false,
+  isQuoteOnly: values.isQuoteOnly === true,
+  seoTitle: complianceTrimOrNull(values.seoTitle),
+  seoDescription: complianceTrimOrNull(values.seoDescription),
+  canonicalUrl: complianceTrimOrNull(values.canonicalUrl),
+});
+
+export type ComplianceFormValues = Pick<
+  ProductFormValues,
+  | "countryOfOriginCode"
+  | "pkwiuCode"
+  | "cnCode"
+  | "hsCode"
+  | "taxClassificationCode"
+  | "gtuCodes"
+  | "ageMin"
+  | "isExciseGood"
+  | "exciseCategory"
+  | "requiresPrescription"
+  | "hazmatClass"
+  | "unNumber"
+  | "hazmatPackingGroup"
+  | "containsLithiumBattery"
+  | "launchAt"
+  | "endOfLifeAt"
+  | "availableFrom"
+  | "availableUntil"
+  | "minOrderQty"
+  | "maxOrderQty"
+  | "orderQtyIncrement"
+  | "requiresShipping"
+  | "isQuoteOnly"
+  | "seoTitle"
+  | "seoDescription"
+  | "canonicalUrl"
+>;
+
+export const complianceFormValuesFromApiRecord = (
+  record: Record<string, unknown>,
+): ComplianceFormValues => {
+  const pick = (...keys: string[]): unknown => {
+    for (const key of keys) {
+      if (record[key] !== undefined && record[key] !== null) return record[key];
+    }
+    return null;
+  };
+  const str = (value: unknown): string => (typeof value === "string" ? value : "");
+  const strOrNull = (value: unknown): string | null =>
+    typeof value === "string" && value.length ? value : null;
+  const numStr = (value: unknown): string =>
+    typeof value === "number" && Number.isFinite(value) ? String(value) : "";
+  const boolWithDefault = (value: unknown, fallback: boolean): boolean =>
+    typeof value === "boolean" ? value : fallback;
+  const dateInput = (value: unknown): string =>
+    typeof value === "string" && value.length >= 10 ? value.slice(0, 10) : "";
+  const stringArray = (value: unknown): string[] =>
+    Array.isArray(value)
+      ? value.filter((entry): entry is string => typeof entry === "string")
+      : [];
+  return {
+    countryOfOriginCode: str(pick("country_of_origin_code", "countryOfOriginCode")),
+    pkwiuCode: str(pick("pkwiu_code", "pkwiuCode")),
+    cnCode: str(pick("cn_code", "cnCode")),
+    hsCode: str(pick("hs_code", "hsCode")),
+    taxClassificationCode: str(pick("tax_classification_code", "taxClassificationCode")),
+    gtuCodes: stringArray(pick("gtu_codes", "gtuCodes")),
+    ageMin: numStr(pick("age_min", "ageMin")),
+    isExciseGood: boolWithDefault(pick("is_excise_good", "isExciseGood"), false),
+    exciseCategory: strOrNull(pick("excise_category", "exciseCategory")),
+    requiresPrescription: boolWithDefault(
+      pick("requires_prescription", "requiresPrescription"),
+      false,
+    ),
+    hazmatClass: str(pick("hazmat_class", "hazmatClass")),
+    unNumber: str(pick("un_number", "unNumber")),
+    hazmatPackingGroup: strOrNull(pick("hazmat_packing_group", "hazmatPackingGroup")),
+    containsLithiumBattery: boolWithDefault(
+      pick("contains_lithium_battery", "containsLithiumBattery"),
+      false,
+    ),
+    launchAt: dateInput(pick("launch_at", "launchAt")),
+    endOfLifeAt: dateInput(pick("end_of_life_at", "endOfLifeAt")),
+    availableFrom: dateInput(pick("available_from", "availableFrom")),
+    availableUntil: dateInput(pick("available_until", "availableUntil")),
+    minOrderQty: numStr(pick("min_order_qty", "minOrderQty")),
+    maxOrderQty: numStr(pick("max_order_qty", "maxOrderQty")),
+    orderQtyIncrement: numStr(pick("order_qty_increment", "orderQtyIncrement")),
+    requiresShipping: boolWithDefault(
+      pick("requires_shipping", "requiresShipping"),
+      true,
+    ),
+    isQuoteOnly: boolWithDefault(pick("is_quote_only", "isQuoteOnly"), false),
+    seoTitle: str(pick("seo_title", "seoTitle")),
+    seoDescription: str(pick("seo_description", "seoDescription")),
+    canonicalUrl: str(pick("canonical_url", "canonicalUrl")),
+  };
+};
+
 export const createInitialProductFormValues = (): ProductFormValues => ({
   ...BASE_INITIAL_VALUES,
   mediaDraftId: createLocalId(),

package/src/modules/catalog/components/products/variantForm.ts

@@ -26,6 +26,8 @@ export type VariantFormValues = {
   name: string
   sku: string
   barcode: string
+  gtinType: string | null
+  hsCode: string
   isDefault: boolean
   isActive: boolean
   optionValues: Record<string, string>
@@ -44,6 +46,8 @@ export const VARIANT_BASE_VALUES: VariantFormValues = {
   name: '',
   sku: '',
   barcode: '',
+  gtinType: null,
+  hsCode: '',
   isDefault: false,
   isActive: true,
   optionValues: {},

package/src/modules/catalog/data/entities.ts

@@ -1,6 +1,9 @@
 import { Collection, OptionalProps } from '@mikro-orm/core'
 import { Entity, Index, ManyToOne, OneToMany, PrimaryKey, Property, Unique } from '@mikro-orm/decorators/legacy'
 import type {
+  CatalogExciseCategory,
+  CatalogGtinType,
+  CatalogHazmatPackingGroup,
   CatalogPriceDisplayMode,
   CatalogProductOptionSchema,
   CatalogProductRelationType,
@@ -70,6 +73,11 @@ export class CatalogProduct {
     | 'uomRoundingScale'
     | 'uomRoundingMode'
     | 'unitPriceEnabled'
+    | 'isExciseGood'
+    | 'requiresPrescription'
+    | 'containsLithiumBattery'
+    | 'requiresShipping'
+    | 'isQuoteOnly'
 
   @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
   id!: string
@@ -154,6 +162,84 @@ export class CatalogProduct {
     unit?: string | null
   } | null
 
+  @Property({ name: 'country_of_origin_code', type: 'text', nullable: true })
+  countryOfOriginCode?: string | null
+
+  @Property({ name: 'pkwiu_code', type: 'text', nullable: true })
+  pkwiuCode?: string | null
+
+  @Property({ name: 'cn_code', type: 'text', nullable: true })
+  cnCode?: string | null
+
+  @Property({ name: 'hs_code', type: 'text', nullable: true })
+  hsCode?: string | null
+
+  @Property({ name: 'tax_classification_code', type: 'text', nullable: true })
+  taxClassificationCode?: string | null
+
+  @Property({ name: 'gtu_codes', type: 'text[]', nullable: true })
+  gtuCodes?: string[] | null
+
+  @Property({ name: 'age_min', type: 'smallint', nullable: true })
+  ageMin?: number | null
+
+  @Property({ name: 'is_excise_good', type: 'boolean', default: false })
+  isExciseGood: boolean = false
+
+  @Property({ name: 'excise_category', type: 'text', nullable: true })
+  exciseCategory?: CatalogExciseCategory | null
+
+  @Property({ name: 'requires_prescription', type: 'boolean', default: false })
+  requiresPrescription: boolean = false
+
+  @Property({ name: 'hazmat_class', type: 'text', nullable: true })
+  hazmatClass?: string | null
+
+  @Property({ name: 'un_number', type: 'text', nullable: true })
+  unNumber?: string | null
+
+  @Property({ name: 'hazmat_packing_group', type: 'text', nullable: true })
+  hazmatPackingGroup?: CatalogHazmatPackingGroup | null
+
+  @Property({ name: 'contains_lithium_battery', type: 'boolean', default: false })
+  containsLithiumBattery: boolean = false
+
+  @Property({ name: 'launch_at', type: Date, nullable: true })
+  launchAt?: Date | null
+
+  @Property({ name: 'end_of_life_at', type: Date, nullable: true })
+  endOfLifeAt?: Date | null
+
+  @Property({ name: 'available_from', type: Date, nullable: true })
+  availableFrom?: Date | null
+
+  @Property({ name: 'available_until', type: Date, nullable: true })
+  availableUntil?: Date | null
+
+  @Property({ name: 'min_order_qty', type: 'integer', nullable: true })
+  minOrderQty?: number | null
+
+  @Property({ name: 'max_order_qty', type: 'integer', nullable: true })
+  maxOrderQty?: number | null
+
+  @Property({ name: 'order_qty_increment', type: 'integer', nullable: true })
+  orderQtyIncrement?: number | null
+
+  @Property({ name: 'requires_shipping', type: 'boolean', default: true })
+  requiresShipping: boolean = true
+
+  @Property({ name: 'is_quote_only', type: 'boolean', default: false })
+  isQuoteOnly: boolean = false
+
+  @Property({ name: 'seo_title', type: 'text', nullable: true })
+  seoTitle?: string | null
+
+  @Property({ name: 'seo_description', type: 'text', nullable: true })
+  seoDescription?: string | null
+
+  @Property({ name: 'canonical_url', type: 'text', nullable: true })
+  canonicalUrl?: string | null
+
   @Property({ name: 'metadata', type: 'jsonb', nullable: true })
   metadata?: Record<string, unknown> | null
 
@@ -468,6 +554,11 @@ export class CatalogOffer {
   name: 'catalog_product_variants_sku_unique',
   properties: ['organizationId', 'tenantId', 'sku'],
 })
+@Index({
+  name: 'catalog_product_variants_gtin_scope_unique',
+  expression:
+    `create unique index "catalog_product_variants_gtin_scope_unique" on "catalog_product_variants" ("tenant_id", "organization_id", "gtin_type", "barcode") where deleted_at is null and gtin_type is not null and barcode is not null`,
+})
 export class CatalogProductVariant {
   [OptionalProps]?: 'createdAt' | 'updatedAt' | 'deletedAt'
 
@@ -492,6 +583,12 @@ export class CatalogProductVariant {
   @Property({ type: 'text', nullable: true })
   barcode?: string | null
 
+  @Property({ name: 'gtin_type', type: 'text', nullable: true })
+  gtinType?: CatalogGtinType | null
+
+  @Property({ name: 'hs_code', type: 'text', nullable: true })
+  hsCode?: string | null
+
   @Property({ type: 'text', nullable: true })
   statusEntryId?: string | null
 

package/src/modules/catalog/data/types.ts

@@ -19,6 +19,42 @@ export const CATALOG_PRODUCT_RELATION_TYPES = ['bundle', 'grouped'] as const
 
 export type CatalogProductRelationType = (typeof CATALOG_PRODUCT_RELATION_TYPES)[number]
 
+export const CATALOG_GTU_CODES = [
+  'GTU_01',
+  'GTU_02',
+  'GTU_03',
+  'GTU_04',
+  'GTU_05',
+  'GTU_06',
+  'GTU_07',
+  'GTU_08',
+  'GTU_09',
+  'GTU_10',
+  'GTU_11',
+  'GTU_12',
+  'GTU_13',
+] as const
+
+export type CatalogGtuCode = (typeof CATALOG_GTU_CODES)[number]
+
+export const CATALOG_EXCISE_CATEGORIES = [
+  'alcohol',
+  'tobacco',
+  'energy_drink',
+  'fuel',
+  'other',
+] as const
+
+export type CatalogExciseCategory = (typeof CATALOG_EXCISE_CATEGORIES)[number]
+
+export const CATALOG_HAZMAT_PACKING_GROUPS = ['I', 'II', 'III'] as const
+
+export type CatalogHazmatPackingGroup = (typeof CATALOG_HAZMAT_PACKING_GROUPS)[number]
+
+export const CATALOG_GTIN_TYPES = ['ean13', 'ean8', 'upc', 'isbn', 'asin', 'mpn'] as const
+
+export type CatalogGtinType = (typeof CATALOG_GTIN_TYPES)[number]
+
 export type CatalogProductOptionChoice = {
   code: string
   label?: string | null

package/src/modules/catalog/data/validators.ts

@@ -1,5 +1,13 @@
 import { z } from 'zod'
-import { CATALOG_PRICE_DISPLAY_MODES, CATALOG_PRODUCT_TYPES } from './types'
+import {
+  CATALOG_EXCISE_CATEGORIES,
+  CATALOG_GTIN_TYPES,
+  CATALOG_GTU_CODES,
+  CATALOG_HAZMAT_PACKING_GROUPS,
+  CATALOG_PRICE_DISPLAY_MODES,
+  CATALOG_PRODUCT_TYPES,
+} from './types'
+import { isValidGtin, normalizeGtinValue } from '../lib/gtin'
 import { REFERENCE_UNIT_CODES } from '../lib/unitCodes'
 import {
   getCatalogPriceAmountValidationMessage,
@@ -214,14 +222,111 @@ const productBaseSchema = scoped.extend({
   customFieldsetCode: slugSchema.nullable().optional(),
   isConfigurable: z.boolean().optional(),
   isActive: z.boolean().optional(),
+  countryOfOriginCode: z
+    .string()
+    .trim()
+    .toUpperCase()
+    .regex(/^[A-Z]{2}$/, 'catalog.products.validation.countryCodeInvalid')
+    .nullable()
+    .optional(),
+  pkwiuCode: z.string().trim().min(1).max(32).nullable().optional(),
+  cnCode: z.string().trim().min(1).max(32).nullable().optional(),
+  hsCode: z.string().trim().min(1).max(32).nullable().optional(),
+  taxClassificationCode: z.string().trim().min(1).max(64).nullable().optional(),
+  gtuCodes: z
+    .array(z.enum(CATALOG_GTU_CODES))
+    .max(13)
+    .transform((codes) => Array.from(new Set(codes)).sort())
+    .nullable()
+    .optional(),
+  ageMin: z.coerce.number().int().min(0).max(120).nullable().optional(),
+  isExciseGood: z.boolean().optional(),
+  exciseCategory: z.enum(CATALOG_EXCISE_CATEGORIES).nullable().optional(),
+  requiresPrescription: z.boolean().optional(),
+  hazmatClass: z.string().trim().min(1).max(32).nullable().optional(),
+  unNumber: z
+    .string()
+    .trim()
+    .regex(/^(?:UN)?[0-9]{4}$/i, 'catalog.products.validation.unNumberInvalid')
+    .transform((value) => {
+      const upper = value.toUpperCase()
+      return upper.startsWith('UN') ? upper : `UN${upper}`
+    })
+    .nullable()
+    .optional(),
+  hazmatPackingGroup: z.enum(CATALOG_HAZMAT_PACKING_GROUPS).nullable().optional(),
+  containsLithiumBattery: z.boolean().optional(),
+  launchAt: z.coerce.date().nullable().optional(),
+  endOfLifeAt: z.coerce.date().nullable().optional(),
+  availableFrom: z.coerce.date().nullable().optional(),
+  availableUntil: z.coerce.date().nullable().optional(),
+  minOrderQty: z.coerce.number().int().min(1).nullable().optional(),
+  maxOrderQty: z.coerce.number().int().min(1).nullable().optional(),
+  orderQtyIncrement: z.coerce.number().int().min(1).nullable().optional(),
+  requiresShipping: z.boolean().optional(),
+  isQuoteOnly: z.boolean().optional(),
+  seoTitle: z.string().trim().min(1).max(255).nullable().optional(),
+  seoDescription: z.string().trim().min(1).max(1000).nullable().optional(),
+  canonicalUrl: z
+    .string()
+    .trim()
+    .max(500)
+    .regex(/^https?:\/\/\S+$/, 'catalog.products.validation.canonicalUrlInvalid')
+    .nullable()
+    .optional(),
   metadata: metadataSchema,
   offers: z.array(offerInputSchema.omit({ id: true })).optional(),
   categoryIds: z.array(uuid()).max(100).optional(),
   tags: z.array(tagLabelSchema).max(100).optional(),
 })
 
+// Cross-field checks chained on the exported schemas only — refining the base
+// schema itself would break `.partial()` in the update schema.
+const productComplianceCrossFieldRefinement = (
+  input: {
+    minOrderQty?: number | null
+    maxOrderQty?: number | null
+    launchAt?: Date | null
+    endOfLifeAt?: Date | null
+    availableFrom?: Date | null
+    availableUntil?: Date | null
+  },
+  ctx: z.RefinementCtx,
+) => {
+  if (
+    input.minOrderQty != null &&
+    input.maxOrderQty != null &&
+    input.maxOrderQty < input.minOrderQty
+  ) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['maxOrderQty'],
+      message: 'catalog.products.validation.orderQtyRange',
+    })
+  }
+  if (input.launchAt && input.endOfLifeAt && input.endOfLifeAt < input.launchAt) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['endOfLifeAt'],
+      message: 'catalog.products.validation.lifecycleDateRange',
+    })
+  }
+  if (
+    input.availableFrom &&
+    input.availableUntil &&
+    input.availableUntil < input.availableFrom
+  ) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['availableUntil'],
+      message: 'catalog.products.validation.availabilityDateRange',
+    })
+  }
+}
+
 export const productCreateSchema = productBaseSchema
   .superRefine(productUomCrossFieldRefinement)
+  .superRefine(productComplianceCrossFieldRefinement)
 
 export const productUpdateSchema = z
   .object({
@@ -232,8 +337,10 @@ export const productUpdateSchema = z
     productType: productTypeSchema.optional(),
   })
   .superRefine(productUomCrossFieldRefinement)
+  .superRefine(productComplianceCrossFieldRefinement)
 
-export const variantCreateSchema = scoped.extend({
+// Base schema without refinements (used for .partial() in update schema)
+const variantBaseSchema = scoped.extend({
   productId: uuid(),
   name: z.string().trim().max(255).optional(),
   sku: z
@@ -243,6 +350,8 @@ export const variantCreateSchema = scoped.extend({
     .max(191)
     .optional(),
   barcode: z.string().trim().max(191).optional(),
+  gtinType: z.enum(CATALOG_GTIN_TYPES).nullable().optional(),
+  hsCode: z.string().trim().min(1).max(32).nullable().optional(),
   statusEntryId: uuid().optional(),
   isDefault: z.boolean().optional(),
   isActive: z.boolean().optional(),
@@ -265,11 +374,58 @@ export const variantCreateSchema = scoped.extend({
   customFieldsetCode: slugSchema.nullable().optional(),
 })
 
+// Payload-level GTIN check. Partial updates carrying only one of
+// (gtinType, barcode) are re-validated against the merged record state in the
+// catalog.variants.update command — zod cannot see the stored half here.
+const variantGtinRefinement =
+  (mode: 'create' | 'update') =>
+  (
+    input: {
+      gtinType?: (typeof CATALOG_GTIN_TYPES)[number] | null
+      barcode?: string
+    },
+    ctx: z.RefinementCtx,
+  ) => {
+    const gtinType = input.gtinType
+    if (!gtinType) return
+    const barcode = input.barcode
+    if (barcode === undefined) {
+      if (mode === 'create') {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ['barcode'],
+          message: 'catalog.variants.validation.gtinBarcodeRequired',
+        })
+      }
+      return
+    }
+    if (!barcode.trim().length) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['barcode'],
+        message: 'catalog.variants.validation.gtinBarcodeRequired',
+      })
+      return
+    }
+    if (!isValidGtin(gtinType, normalizeGtinValue(gtinType, barcode))) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['barcode'],
+        message: 'catalog.variants.validation.gtinChecksum',
+      })
+    }
+  }
+
+export const variantCreateSchema = variantBaseSchema.superRefine(
+  variantGtinRefinement('create'),
+)
+
 export const variantUpdateSchema = z
   .object({
     id: uuid(),
   })
-  .merge(variantCreateSchema.partial())
+  .merge(variantBaseSchema.partial())
+  .superRefine(variantGtinRefinement('update'))
 
 export const optionSchemaTemplateCreateSchema = scoped.extend({
   name: z.string().trim().min(1).max(255),