@open-mercato/core 0.8.1-develop.7296.1.2111d779db → 0.8.1-develop.7441.1.b42958b98c

package/src/modules/catalog/commands/products.ts

@@ -76,6 +76,16 @@ import {
   findWithDecryption,
   findOneWithDecryption,
 } from "@open-mercato/shared/lib/encryption/find";
+import {
+  buildProductDeleteChildrenRestorePhases,
+  captureProductDeleteChildren,
+  emitProductDeleteChildrenRestoreSideEffects,
+  isProductOwnedOptionSchemaTemplate,
+  planProductDeleteChildrenRestore,
+  restoreProductOptionSchemaTemplate,
+  type ProductDeleteChildrenSnapshot,
+  type ProductDeleteOwner,
+} from "./productDeleteChildren";
 import { canonicalizeUnitCode } from "../lib/unitCodes";
 import {
   resolveCanonicalUnitCode,
@@ -255,8 +265,22 @@ function resolveUnitPriceInput(
 type ProductUndoPayload = {
   before?: ProductSnapshot | null;
   after?: ProductSnapshot | null;
+  children?: ProductDeleteChildrenSnapshot | null;
+};
+
+type ProductDeleteSnapshots = {
+  before?: ProductSnapshot;
+  children?: ProductDeleteChildrenSnapshot;
 };
 
+const PRODUCT_DELETE_CACHE_ALIASES: readonly string[] = [
+  "catalog.product",
+  "catalog.variant",
+  "catalog.price",
+  "catalog.product.unit.conversion",
+  "catalog.optionschema",
+];
+
 const productCrudEvents: CrudEventsConfig<CatalogProduct> = {
   module: "catalog",
   entity: "product",
@@ -1055,16 +1079,6 @@ async function emitProductVariantCleanupSideEffects(opts: {
   }
 }
 
-function isProductOwnedOptionSchemaTemplate(
-  template: CatalogOptionSchemaTemplate | string | null | undefined,
-): template is CatalogOptionSchemaTemplate {
-  if (!template || typeof template === "string") return false;
-  const metadata = template.metadata;
-  if (!metadata || typeof metadata !== "object") return false;
-  const source = (metadata as Record<string, unknown>).source;
-  return source === "product";
-}
-
 async function resolveOptionSchemaTemplateForRemoval(
   em: EntityManager,
   product: CatalogProduct,
@@ -1372,12 +1386,16 @@ function applyProductSnapshot(
 }
 
 /**
- * Output contract for the product commands, consumed by the workflows context
- * ledger through `commandRegistry.outputSchemaOf`. All three commands return
- * the product id and nothing else — create and update from `record.id`, delete
- * from the resolved input id.
+ * Output contracts for the product commands, consumed by the workflows context
+ * ledger through `commandRegistry.outputSchemaOf`. Create and delete return the
+ * product id and nothing else — create from `record.id`, delete from the
+ * resolved input id. Update also returns the persisted `updatedAt`, so callers
+ * can carry the optimistic-lock version forward without re-fetching the product.
  */
 const productIdOutputSchema = z.object({ productId: z.string().uuid() });
+const productUpdateOutputSchema = productIdOutputSchema.extend({
+  updatedAt: z.string(),
+});
 
 const createProductCommand: CommandHandler<
   ProductCreateInput,
@@ -1656,10 +1674,10 @@ const createProductCommand: CommandHandler<
 
 const updateProductCommand: CommandHandler<
   ProductUpdateInput,
-  { productId: string }
+  { productId: string; updatedAt: string }
 > = {
   id: "catalog.products.update",
-  outputSchema: productIdOutputSchema,
+  outputSchema: productUpdateOutputSchema,
   async prepare(input, ctx) {
     const id = requireId(input, "Product id is required");
     const em = ctx.container.resolve("em") as EntityManager;
@@ -2021,7 +2039,7 @@ const updateProductCommand: CommandHandler<
       action: "updated",
       product: record,
     });
-    return { productId: record.id };
+    return { productId: record.id, updatedAt: record.updatedAt.toISOString() };
   },
   captureAfter: async (_input, result, ctx) => {
     const em = (ctx.container.resolve("em") as EntityManager).fork();
@@ -2196,11 +2214,14 @@ const deleteProductCommand: CommandHandler<
     const id = requireId(input, "Product id is required");
     const em = ctx.container.resolve("em") as EntityManager;
     const snapshot = await loadProductSnapshot(em, id);
-    if (snapshot) {
-      ensureTenantScope(ctx, snapshot.tenantId);
-      ensureOrganizationScope(ctx, snapshot.organizationId);
-    }
-    return snapshot ? { before: snapshot } : {};
+    if (!snapshot) return {};
+    ensureTenantScope(ctx, snapshot.tenantId);
+    ensureOrganizationScope(ctx, snapshot.organizationId);
+    const snapshots: ProductDeleteSnapshots = {
+      before: snapshot,
+      children: await captureProductDeleteChildren(em.fork(), snapshot),
+    };
+    return snapshots;
   },
   async execute(input, ctx) {
     const id = requireId(input, "Product id is required");
@@ -2294,16 +2315,34 @@ const deleteProductCommand: CommandHandler<
       payload: {
         undo: {
           before,
+          children: (snapshots as ProductDeleteSnapshots).children ?? null,
         } satisfies ProductUndoPayload,
       },
+      context: { cacheAliases: [...PRODUCT_DELETE_CACHE_ALIASES] },
     };
   },
   undo: async ({ logEntry, ctx }) => {
     const payload = extractUndoPayload<ProductUndoPayload>(logEntry);
     const before = payload?.before;
     if (!before) return;
+    ensureTenantScope(ctx, before.tenantId);
+    ensureOrganizationScope(ctx, before.organizationId);
     const em = (ctx.container.resolve("em") as EntityManager).fork();
+    const children = payload?.children ?? null;
+    const owner: ProductDeleteOwner = {
+      id: before.id,
+      organizationId: before.organizationId,
+      tenantId: before.tenantId,
+      optionSchemaId: before.optionSchemaId ?? null,
+      offerIds: (before.offers ?? []).map((offer) => offer.id),
+    };
     let record = await findOneWithDecryption(em, CatalogProduct, { id: before.id });
+    const childrenPlan = await planProductDeleteChildrenRestore(
+      em,
+      owner,
+      children,
+    );
+    restoreProductOptionSchemaTemplate(em, owner, childrenPlan);
     if (!record) {
       record = em.create(CatalogProduct, {
         id: before.id,
@@ -2342,8 +2381,6 @@ const deleteProductCommand: CommandHandler<
       });
       em.persist(record);
     }
-    ensureTenantScope(ctx, before.tenantId);
-    ensureOrganizationScope(ctx, before.organizationId);
     applyProductSnapshot(em, record, before);
     await withAtomicFlush(
       em,
@@ -2352,6 +2389,7 @@ const deleteProductCommand: CommandHandler<
         () => restoreOffersFromSnapshot(em, record, before.offers),
         () => syncCategoryAssignments(em, record, before.categoryIds),
         () => syncProductTags(em, record, before.tags),
+        ...buildProductDeleteChildrenRestorePhases(em, owner, childrenPlan),
       ],
       { transaction: true },
     );
@@ -2366,6 +2404,13 @@ const deleteProductCommand: CommandHandler<
         values: before.custom,
       });
     }
+    await emitProductDeleteChildrenRestoreSideEffects({
+      ctx,
+      dataEngine,
+      owner,
+      children,
+      plan: childrenPlan,
+    });
     await emitProductCrudUndoChange({
       dataEngine,
       action: "created",

package/src/modules/catalog/components/PriceKindSettings.tsx

@@ -25,8 +25,8 @@ import { useOrganizationScopeVersion } from '@open-mercato/shared/lib/frontend/u
 import { useT } from '@open-mercato/shared/lib/i18n/context'
 import { useConfirmDialog } from '@open-mercato/ui/backend/confirm-dialog'
 import { DictionaryEntrySelect } from '@open-mercato/core/modules/dictionaries/components/DictionaryEntrySelect'
-import { useCurrencyDictionary } from '@open-mercato/core/modules/customers/components/detail/hooks/useCurrencyDictionary'
 import type { DictionaryOption } from '@open-mercato/core/modules/dictionaries/components/DictionaryEntrySelect'
+import { loadCurrencyOptions } from '../lib/currencyOptions'
 import type { CatalogPriceDisplayMode } from '../data/types'
 import { createLogger } from '@open-mercato/shared/lib/logger'
 
@@ -124,25 +124,11 @@ export function PriceKindSettings() {
   const [form, setForm] = React.useState<PriceKindFormState>(DEFAULT_FORM)
   const [submitting, setSubmitting] = React.useState(false)
   const [error, setError] = React.useState<string | null>(null)
-  const { data: currencyDictionary, refetch: refetchCurrencyDictionary } = useCurrencyDictionary()
-
-  const currencyOptionsLoader = React.useCallback(async (): Promise<DictionaryOption[]> => {
-    if (currencyDictionary && Array.isArray(currencyDictionary.entries)) {
-      return currencyDictionary.entries.map((entry) => ({
-        value: entry.value,
-        label: entry.label,
-        color: entry.color ?? null,
-        icon: entry.icon ?? null,
-      }))
-    }
-    const payload = await refetchCurrencyDictionary()
-    return payload.entries.map((entry) => ({
-      value: entry.value,
-      label: entry.label,
-      color: entry.color ?? null,
-      icon: entry.icon ?? null,
-    }))
-  }, [currencyDictionary, refetchCurrencyDictionary])
+  const currencyOptionsLoader = React.useCallback(
+    (): Promise<DictionaryOption[]> =>
+      loadCurrencyOptions(t('catalog.priceKinds.form.currency.loadError', 'Unable to load currencies.')),
+    [t],
+  )
 
   const loadItems = React.useCallback(async () => {
     setLoading(true)

package/src/modules/catalog/components/products/ProductUomSection.tsx

@@ -22,6 +22,7 @@ import type {
   ProductUnitConversionDraft,
 } from "./productForm";
 import { createProductUnitConversionDraft } from "./productForm";
+import { translateCatalogUnitLabel } from "../../lib/unitLabels";
 import { REFERENCE_UNIT_CODES } from "@open-mercato/shared/lib/units/unitCodes";
 import { toTrimmedOrNull } from "./productFormUtils";
 import { useUnitPriceDisplayEnabled } from "./hooks/useUnitPriceDisplayEnabled";
@@ -73,10 +74,12 @@ function toSortValue(value: string): number {
   return Number.isFinite(numeric) ? numeric : Number.MAX_SAFE_INTEGER;
 }
 
-function formatPreviewNumber(value: number): string {
+function formatPreviewNumber(value: number, locale?: string): string {
   if (!Number.isFinite(value)) return "0";
-  const rounded = Math.round(value * 1_000_000) / 1_000_000;
-  return Number.isInteger(rounded) ? String(rounded) : rounded.toString();
+  return new Intl.NumberFormat(locale, {
+    maximumFractionDigits: 6,
+    useGrouping: false,
+  }).format(value);
 }
 
 function normalizeConversions(value: unknown): ProductUnitConversionDraft[] {
@@ -90,7 +93,7 @@ function normalizeConversions(value: unknown): ProductUnitConversionDraft[] {
         unitCode: toTrimmedOrNull(row.unitCode) ?? "",
         // Stays raw while editing (issue #5828) — re-serializing on every render would drop
         // an in-progress decimal separator the instant it's typed.
-        toBaseFactor: toTrimmedOrNull(row.toBaseFactor) ?? "",
+        toBaseFactor: row.toBaseFactor ?? "",
         sortOrder: toTrimmedOrNull(row.sortOrder) ?? "",
         isActive: row.isActive !== false,
       } satisfies ProductUnitConversionDraft;
@@ -109,7 +112,9 @@ function normalizeConversions(value: unknown): ProductUnitConversionDraft[] {
 }
 
 function buildUnitOptions(
-  entries: UnitDictionaryEntry[] | undefined,
+  entries: UnitDictionaryEntry[],
+  t: ReturnType<typeof useT>,
+  locale: string,
 ): UnitOption[] {
   const list = Array.isArray(entries) ? entries : [];
   const options = list
@@ -118,11 +123,11 @@ function buildUnitOptions(
       if (!value) return null;
       return {
         value,
-        label: toTrimmedOrNull(entry.label) ?? value,
+        label: translateCatalogUnitLabel(value, toTrimmedOrNull(entry.label) ?? value, t),
       } satisfies UnitOption;
     })
     .filter((entry): entry is UnitOption => Boolean(entry));
-  return options.sort((left, right) => left.label.localeCompare(right.label));
+  return options.sort((left, right) => left.label.localeCompare(right.label, locale));
 }
 
 export function ProductUomSection({
@@ -134,7 +139,11 @@ export function ProductUomSection({
   const t = useT();
   const locale = useLocale();
   const { enabled: unitPriceDisplayEnabled } = useUnitPriceDisplayEnabled();
-  const [unitOptions, setUnitOptions] = React.useState<UnitOption[]>([]);
+  const [unitEntries, setUnitEntries] = React.useState<UnitDictionaryEntry[]>([]);
+  const unitOptions = React.useMemo(
+    () => buildUnitOptions(unitEntries, t, locale),
+    [unitEntries, t, locale],
+  );
   const [loadingUnits, setLoadingUnits] = React.useState(false);
   const [errorLoadingUnits, setErrorLoadingUnits] = React.useState(false);
   const conversions = React.useMemo(
@@ -154,10 +163,10 @@ export function ProductUomSection({
           { fallback: { entries: [] } },
         );
         if (cancelled) return;
-        setUnitOptions(buildUnitOptions(response.result?.entries));
+        setUnitEntries(response.result?.entries ?? []);
       } catch {
         if (!cancelled) {
-          setUnitOptions([]);
+          setUnitEntries([]);
           setErrorLoadingUnits(true);
         }
       } finally {
@@ -235,12 +244,12 @@ export function ProductUomSection({
   const defaultUnit = toTrimmedOrNull(values.defaultUnit) ?? "";
   const defaultSalesUnit = toTrimmedOrNull(values.defaultSalesUnit) ?? "";
   const defaultSalesQuantity =
-    toTrimmedOrNull(values.defaultSalesUnitQuantity) ?? "1";
+    values.defaultSalesUnitQuantity ?? "1";
   const unitPriceEnabled = Boolean(values.unitPriceEnabled);
   const unitPriceReferenceUnit =
     toTrimmedOrNull(values.unitPriceReferenceUnit) ?? "";
   const unitPriceBaseQuantity =
-    toTrimmedOrNull(values.unitPriceBaseQuantity) ?? "";
+    values.unitPriceBaseQuantity ?? "";
 
   const baseUnitLabel = findUnitLabel(defaultUnit) ?? defaultUnit;
   const salesUnitLabel =
@@ -269,23 +278,6 @@ export function ProductUomSection({
       : null;
   const unitPriceBaseQuantityNumber = toPositiveNumber(unitPriceBaseQuantity, locale);
 
-  const validConversions = conversions.filter(
-    (entry) =>
-      toTrimmedOrNull(entry.unitCode) && toTrimmedOrNull(entry.toBaseFactor),
-  );
-  const conversionPreviewItems = validConversions
-    .slice(0, 3)
-    .map((entry) => {
-      const label = findUnitLabel(entry.unitCode) ?? entry.unitCode;
-      const baseLabel = findUnitLabel(defaultUnit) ?? defaultUnit;
-      const factor = toTrimmedOrNull(entry.toBaseFactor) ?? "1";
-      return `1 ${label} = ${factor} ${baseLabel || t("catalog.products.uom.baseUnit", "base unit")}`;
-    });
-  const conversionPreview =
-    validConversions.length > 3
-      ? `${conversionPreviewItems.join(" • ")} (+${validConversions.length - 3})`
-      : conversionPreviewItems.join(" • ");
-
   return (
     <div
       className={
@@ -399,10 +391,11 @@ export function ProductUomSection({
                     "catalog.products.uom.defaultSalesQuantityPreviewWithNormalization",
                     "Default line: {{quantity}} {{salesUnit}} (= {{normalized}} {{baseUnit}}).",
                     {
-                      quantity: formatPreviewNumber(defaultSalesQuantityNumber),
+                      quantity: formatPreviewNumber(defaultSalesQuantityNumber, locale),
                       salesUnit: salesUnitLabel,
                       normalized: formatPreviewNumber(
                         defaultSalesQuantityNormalized,
+                        locale,
                       ),
                       baseUnit: baseUnitLabel,
                     },
@@ -411,7 +404,7 @@ export function ProductUomSection({
                     "catalog.products.uom.defaultSalesQuantityPreview",
                     "Default line: {{quantity}} {{salesUnit}}.",
                     {
-                      quantity: formatPreviewNumber(defaultSalesQuantityNumber),
+                      quantity: formatPreviewNumber(defaultSalesQuantityNumber, locale),
                       salesUnit: salesUnitLabel,
                     },
                   )}
@@ -546,7 +539,7 @@ export function ProductUomSection({
                   "catalog.products.unitPrice.hintWithPreview",
                   "Show calculated price per {{quantity}} {{unit}}. For most products use 1 (for example: 1 kg, 1 l, 1 m²).",
                   {
-                    quantity: formatPreviewNumber(unitPriceBaseQuantityNumber),
+                    quantity: formatPreviewNumber(unitPriceBaseQuantityNumber, locale),
                     unit: unitPriceReferenceUnit,
                   },
                 )
@@ -593,7 +586,7 @@ export function ProductUomSection({
                       "1 {{fromUnit}} = {{factor}} {{baseUnit}}",
                       {
                         fromUnit: findUnitLabel(entry.unitCode) ?? entry.unitCode,
-                        factor: formatPreviewNumber(conversionFactor),
+                        factor: formatPreviewNumber(conversionFactor, locale),
                         baseUnit:
                           findUnitLabel(defaultUnit) ??
                           defaultUnit ??
@@ -731,10 +724,6 @@ export function ProductUomSection({
             )}
           </p>
         ) : null}
-
-        {conversionPreview ? (
-          <p className="text-xs text-muted-foreground">{conversionPreview}</p>
-        ) : null}
       </div>
     </div>
   );

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

@@ -186,11 +186,13 @@ export type ProductFormValues = {
   canonicalUrl: string;
 };
 
+const INVALID_NUMBER_MESSAGE = "catalog.products.validation.invalidNumber";
+
 const optionalPositiveNumberInput = z.preprocess((value) => {
   if (value === null || value === undefined) return undefined;
   if (typeof value === "string" && value.trim().length === 0) return undefined;
   return value;
-}, z.coerce.number().positive().optional());
+}, z.coerce.number({ error: INVALID_NUMBER_MESSAGE }).positive().optional());
 
 const optionalBoundedIntegerInput = (min: number, max: number) =>
   z.preprocess((value) => {
@@ -267,7 +269,7 @@ export const productFormSchema = z
         z.object({
           id: z.string().nullable().optional(),
           unitCode: z.string().trim().max(50),
-          toBaseFactor: z.coerce.number().positive(),
+          toBaseFactor: z.coerce.number({ error: INVALID_NUMBER_MESSAGE }).positive(),
           sortOrder: z.coerce.number().int().min(0).max(100000).optional(),
           isActive: z.boolean().optional(),
         }),
@@ -352,8 +354,8 @@ export const productFormSchema = z
 // The UoM fields below stay raw locale-typed text while the user is editing them
 // (`ProductUomSection`, issue #5828), so `z.coerce.number()` — which only accepts a dot
 // decimal separator — cannot parse them directly. Convert to a canonical dot-decimal string
-// right before validation; an unparseable value is left as-is so the schema's own "expected
-// number" error still fires.
+// right before validation; an unparseable value is left as-is so the schema rejects it with
+// the localized `catalog.products.validation.invalidNumber` message (issue #6311).
 function toCanonicalDecimalString(raw: string, locale?: string): string {
   if (!raw.trim()) return raw;
   const parsed = parseLocaleNumber(raw, locale);

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

@@ -328,6 +328,15 @@ export const productCreateSchema = productBaseSchema
   .superRefine(productUomCrossFieldRefinement)
   .superRefine(productComplianceCrossFieldRefinement)
 
+export const productBulkCreateRowSchema = productBaseSchema
+  .omit({ organizationId: true, tenantId: true })
+  .superRefine(productUomCrossFieldRefinement)
+  .superRefine(productComplianceCrossFieldRefinement)
+
+export const productsBulkCreateSchema = z.object({
+  items: z.array(productBulkCreateRowSchema).min(1).max(2000),
+})
+
 export const productUpdateSchema = z
   .object({
     id: uuid(),
@@ -542,6 +551,15 @@ export const categoryUpdateSchema = z
   })
   .merge(categoryCreateSchema.partial())
 
+export const categoryBulkCreateRowSchema = categoryCreateSchema.omit({
+  organizationId: true,
+  tenantId: true,
+})
+
+export const categoriesBulkCreateSchema = z.object({
+  items: z.array(categoryBulkCreateRowSchema).min(1).max(10000),
+})
+
 export const productUnitConversionCreateSchema = scoped.extend({
   productId: uuid(),
   unitCode: z.string().trim().min(1).max(50),
@@ -563,6 +581,8 @@ export const productUnitConversionDeleteSchema = scoped.extend({
 
 export type ProductCreateInput = z.infer<typeof productCreateSchema>
 export type ProductUpdateInput = z.infer<typeof productUpdateSchema>
+export type ProductBulkCreateRow = z.infer<typeof productBulkCreateRowSchema>
+export type ProductsBulkCreateInput = z.infer<typeof productsBulkCreateSchema>
 export type VariantCreateInput = z.infer<typeof variantCreateSchema>
 export type VariantUpdateInput = z.infer<typeof variantUpdateSchema>
 export type OptionSchemaTemplateCreateInput = z.infer<typeof optionSchemaTemplateCreateSchema>
@@ -573,6 +593,8 @@ export type PriceCreateInput = z.infer<typeof priceCreateSchema>
 export type PriceUpdateInput = z.infer<typeof priceUpdateSchema>
 export type CategoryCreateInput = z.infer<typeof categoryCreateSchema>
 export type CategoryUpdateInput = z.infer<typeof categoryUpdateSchema>
+export type CategoryBulkCreateRow = z.infer<typeof categoryBulkCreateRowSchema>
+export type CategoriesBulkCreateInput = z.infer<typeof categoriesBulkCreateSchema>
 export type OfferInput = z.infer<typeof offerInputSchema>
 export type OfferCreateInput = z.infer<typeof offerCreateSchema>
 export type OfferUpdateInput = z.infer<typeof offerUpdateSchema>

package/src/modules/catalog/di.ts

@@ -2,7 +2,7 @@ import { asFunction, asValue } from 'awilix'
 import type { EventBus } from '@open-mercato/events'
 import type { AppContainer } from '@open-mercato/shared/lib/di/container'
 import { DefaultCatalogPricingService } from './services/catalogPricingService'
-import { CatalogProduct, CatalogProductPrice } from './data/entities'
+import { CatalogProduct, CatalogProductPrice, CatalogProductVariant } from './data/entities'
 
 type AppCradle = AppContainer['cradle'] & {
   eventBus?: EventBus | null
@@ -17,5 +17,6 @@ export function register(container: AppContainer) {
       .proxy(),
     CatalogProduct: asValue(CatalogProduct),
     CatalogProductPrice: asValue(CatalogProductPrice),
+    CatalogProductVariant: asValue(CatalogProductVariant),
   })
 }

package/src/modules/catalog/events.ts

@@ -10,9 +10,15 @@ const events = [
   // bridge to the DataTable on /backend/catalog/catalog/products via the
   // DOM event bridge so confirmed mutations (AI or otherwise) auto-refresh
   // the list without a round-trip.
-  { id: 'catalog.product.created', label: 'Product Created', entity: 'product', category: 'crud', clientBroadcast: true },
-  { id: 'catalog.product.updated', label: 'Product Updated', entity: 'product', category: 'crud', clientBroadcast: true },
-  { id: 'catalog.product.deleted', label: 'Product Deleted', entity: 'product', category: 'crud', clientBroadcast: true },
+  //
+  // They coalesce their browser delivery (#5733): the consumer is a list that
+  // refetches, so it needs to know that products changed and to be correct when
+  // a burst ends — not to be told 2,000 times during a bulk import, which would
+  // cost a pg_notify roundtrip and a tenant-wide SSE fan-out per row. Subscribers,
+  // webhooks and the queue still see one event per record.
+  { id: 'catalog.product.created', label: 'Product Created', entity: 'product', category: 'crud', clientBroadcast: true, broadcastCoalescing: true },
+  { id: 'catalog.product.updated', label: 'Product Updated', entity: 'product', category: 'crud', clientBroadcast: true, broadcastCoalescing: true },
+  { id: 'catalog.product.deleted', label: 'Product Deleted', entity: 'product', category: 'crud', clientBroadcast: true, broadcastCoalescing: true },
   { id: 'catalog.product.stock_low', label: 'Product Stock Low', entity: 'product', category: 'lifecycle' },
   { id: 'catalog.product_unit_conversion.created', label: 'Product Unit Conversion Created', entity: 'product_unit_conversion', category: 'crud' },
   { id: 'catalog.product_unit_conversion.updated', label: 'Product Unit Conversion Updated', entity: 'product_unit_conversion', category: 'crud' },

package/src/modules/catalog/i18n/de.json

@@ -683,6 +683,7 @@
   "catalog.products.validation.canonicalUrlInvalid": "Die kanonische URL muss mit http:// oder https:// beginnen.",
   "catalog.products.validation.countryCodeInvalid": "Das Ursprungsland muss ein zweibuchstabiger ISO-Code sein.",
   "catalog.products.validation.handleFormat": "Handle darf nur Kleinbuchstaben, Ziffern, Bindestriche oder Unterstriche enthalten.",
+  "catalog.products.validation.invalidNumber": "Gib eine gültige Zahl ein.",
   "catalog.products.validation.lifecycleDateRange": "Das Auslaufdatum darf nicht vor dem Einführungsdatum liegen.",
   "catalog.products.validation.orderQtyRange": "Die maximale Bestellmenge darf nicht kleiner als die minimale sein.",
   "catalog.products.validation.referenceUnitRequired": "Referenzeinheit ist erforderlich, wenn die Grundpreisanzeige aktiviert ist.",
@@ -720,6 +721,45 @@
   "catalog.stats.snapshotAt": "Stand: {time}",
   "catalog.stats.tags": "Tags",
   "catalog.stats.title": "Katalogübersicht",
+  "catalog.units.box": "Schachtel (Stück)",
+  "catalog.units.cl": "Zentiliter (Volumen)",
+  "catalog.units.cm": "Zentimeter (Länge)",
+  "catalog.units.cm2": "Quadratzentimeter (Fläche)",
+  "catalog.units.day": "Tag (Zeit)",
+  "catalog.units.dozen": "Dutzend (Stück)",
+  "catalog.units.ft": "Fuß (Länge)",
+  "catalog.units.ft2": "Quadratfuß (Fläche)",
+  "catalog.units.g": "Gramm (Gewicht)",
+  "catalog.units.gb": "Gigabyte (digital)",
+  "catalog.units.hour": "Stunde (Zeit)",
+  "catalog.units.in": "Zoll (Länge)",
+  "catalog.units.kg": "Kilogramm (Gewicht)",
+  "catalog.units.km": "Kilometer (Länge)",
+  "catalog.units.kwh": "Kilowattstunde (Energie)",
+  "catalog.units.l": "Liter (Volumen)",
+  "catalog.units.lb": "Pfund (Gewicht)",
+  "catalog.units.license": "Lizenz (digital)",
+  "catalog.units.m": "Meter (Länge)",
+  "catalog.units.m2": "Quadratmeter (Fläche)",
+  "catalog.units.m3": "Kubikmeter (Volumen)",
+  "catalog.units.mb": "Megabyte (digital)",
+  "catalog.units.mg": "Milligramm (Gewicht)",
+  "catalog.units.min": "Minute (Zeit)",
+  "catalog.units.ml": "Milliliter (Volumen)",
+  "catalog.units.mm": "Millimeter (Länge)",
+  "catalog.units.month": "Monat (Zeit)",
+  "catalog.units.oz": "Unze (Gewicht)",
+  "catalog.units.pair": "Paar (Stück)",
+  "catalog.units.pc": "Stück (Stück)",
+  "catalog.units.pkg": "Packung (Stück)",
+  "catalog.units.roll": "Rolle (Stück)",
+  "catalog.units.seat": "Nutzerplatz (digital)",
+  "catalog.units.sec": "Sekunde (Zeit)",
+  "catalog.units.set": "Set (Stück)",
+  "catalog.units.tb": "Terabyte (digital)",
+  "catalog.units.unit": "Einheit (Stück)",
+  "catalog.units.week": "Woche (Zeit)",
+  "catalog.units.year": "Jahr (Zeit)",
   "catalog.variants.errors.gtinExists": "Eine andere Variante verwendet diesen Identifikator bereits.",
   "catalog.variants.errors.skuExists": "SKU wird bereits verwendet.",
   "catalog.variants.form.actions.backToProduct": "Zurück zu Produktvarianten",

package/src/modules/catalog/i18n/en.json

@@ -683,6 +683,7 @@
   "catalog.products.validation.canonicalUrlInvalid": "Canonical URL must start with http:// or https://.",
   "catalog.products.validation.countryCodeInvalid": "Country of origin must be a two-letter ISO code.",
   "catalog.products.validation.handleFormat": "Handle must include lowercase letters, digits, hyphen, or underscore.",
+  "catalog.products.validation.invalidNumber": "Enter a valid number.",
   "catalog.products.validation.lifecycleDateRange": "End of life cannot be before the launch date.",
   "catalog.products.validation.orderQtyRange": "Maximum order quantity cannot be lower than the minimum.",
   "catalog.products.validation.referenceUnitRequired": "Reference unit is required when unit price display is enabled.",
@@ -720,6 +721,45 @@
   "catalog.stats.snapshotAt": "Snapshot at {time}",
   "catalog.stats.tags": "Tags",
   "catalog.stats.title": "Catalog overview",
+  "catalog.units.box": "Box (piece)",
+  "catalog.units.cl": "Centiliter (volume)",
+  "catalog.units.cm": "Centimeter (length)",
+  "catalog.units.cm2": "Square Centimeter (area)",
+  "catalog.units.day": "Day (time)",
+  "catalog.units.dozen": "Dozen (piece)",
+  "catalog.units.ft": "Foot (length)",
+  "catalog.units.ft2": "Square Foot (area)",
+  "catalog.units.g": "Gram (weight)",
+  "catalog.units.gb": "Gigabyte (digital)",
+  "catalog.units.hour": "Hour (time)",
+  "catalog.units.in": "Inch (length)",
+  "catalog.units.kg": "Kilogram (weight)",
+  "catalog.units.km": "Kilometer (length)",
+  "catalog.units.kwh": "Kilowatt Hour (energy)",
+  "catalog.units.l": "Liter (volume)",
+  "catalog.units.lb": "Pound (weight)",
+  "catalog.units.license": "License (digital)",
+  "catalog.units.m": "Meter (length)",
+  "catalog.units.m2": "Square Meter (area)",
+  "catalog.units.m3": "Cubic Meter (volume)",
+  "catalog.units.mb": "Megabyte (digital)",
+  "catalog.units.mg": "Milligram (weight)",
+  "catalog.units.min": "Minute (time)",
+  "catalog.units.ml": "Milliliter (volume)",
+  "catalog.units.mm": "Millimeter (length)",
+  "catalog.units.month": "Month (time)",
+  "catalog.units.oz": "Ounce (weight)",
+  "catalog.units.pair": "Pair (piece)",
+  "catalog.units.pc": "Piece (piece)",
+  "catalog.units.pkg": "Package (piece)",
+  "catalog.units.roll": "Roll (piece)",
+  "catalog.units.seat": "Seat (digital)",
+  "catalog.units.sec": "Second (time)",
+  "catalog.units.set": "Set (piece)",
+  "catalog.units.tb": "Terabyte (digital)",
+  "catalog.units.unit": "Unit (piece)",
+  "catalog.units.week": "Week (time)",
+  "catalog.units.year": "Year (time)",
   "catalog.variants.errors.gtinExists": "Another variant already uses this identifier.",
   "catalog.variants.errors.skuExists": "SKU already in use.",
   "catalog.variants.form.actions.backToProduct": "Back to product variants",