@feedmepos/mf-inventory-portal 1.6.0-dev.7 → 1.6.1-dev.0

package/dist/views/integration/helper/binding-import/core.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Generic menu-binding importer core. See `types.ts` for the design notes.
+ *
+ * All functions are pure (except `exportTemplate`, which downloads a file) and operate over any
+ * binding type via a `BindingImportConfig`. Codemax and Food Market Hub each supply a config in
+ * `./configs/*` and mount the same parser/classifier/preview.
+ */
+import type { FdoMenuV4Item, FdoMenuV4VariantGroup } from '@feedmepos/menu/entity';
+import type { WorkSheet } from 'xlsx';
+import type { BindingBase, BindingImportConfig, ImportResult, ImportRow, ImportSummary, MenuIndex, TemplateResult } from './types';
+/** stable key for a binding — null/undefined/empty combinationKey all collapse to "" */
+export declare function bindingKey(productId: string, combinationKey?: string | null): string;
+export declare function worksheetToImportRows<TBinding extends BindingBase>(sheet: WorkSheet, config: BindingImportConfig<TBinding>): ImportRow[];
+/**
+ * Build the resolution indexes from the live menu: `byProductId` (authoritative, every item),
+ * `byCode` (product `code` only), `byName` (normalized product name). Every match is product-level
+ * and carries the set of valid `combinationKeys`; a specific variant is selected later by Variant
+ * Key, never by a variant's own code. Integration-agnostic.
+ */
+export declare function buildMenuCodeIndex(menus: FdoMenuV4Item[], variantGroups?: FdoMenuV4VariantGroup[]): MenuIndex;
+export declare function classifyImport<TBinding extends BindingBase>(rows: ImportRow[], menuIndex: MenuIndex, existingBindings: TBinding[], config: BindingImportConfig<TBinding>): ImportResult<TBinding>;
+/** Parse + classify in one call, converting parse errors into an `invalidExcel` result. */
+export declare function parseAndClassify<TBinding extends BindingBase>(sheet: WorkSheet, menus: FdoMenuV4Item[], existingBindings: TBinding[], variantGroups: FdoMenuV4VariantGroup[], config: BindingImportConfig<TBinding>): ImportResult<TBinding>;
+/** Bindings to actually apply — NEW/OVERRIDE rows that resolved cleanly (no errors). */
+export declare function resolvedBindings<TBinding extends BindingBase>(result: ImportResult<TBinding>): TBinding[];
+export declare function summarize<TBinding extends BindingBase>(result: ImportResult<TBinding>): ImportSummary;
+/**
+ * Merge imported bindings into the existing set (keyed by productId + combinationKey):
+ * existing bindings not present in the import are kept untouched; imported items override
+ * matching existing ones and new bindings are appended.
+ */
+export declare function mergeBindings<TBinding extends BindingBase>(existing: TBinding[], imported: TBinding[]): TBinding[];
+type TemplateCategory = {
+    _id?: string | null;
+    name?: string | null;
+};
+export declare function buildTemplateRows<TBinding extends BindingBase>(menus: FdoMenuV4Item[], categories: TemplateCategory[], bindings: TBinding[], variantGroups: FdoMenuV4VariantGroup[], config: BindingImportConfig<TBinding>): TemplateResult;
+/** Build and download the binding template as an .xlsx file. Returns the row count + filename. */
+export declare function exportTemplate<TBinding extends BindingBase>(menus: FdoMenuV4Item[], categories: TemplateCategory[], bindings: TBinding[], variantGroups: FdoMenuV4VariantGroup[], config: BindingImportConfig<TBinding>, businessName?: string): {
+    filename: string;
+    itemCount: number;
+};
+export {};

package/dist/views/integration/helper/binding-import/types.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Generic, integration-agnostic types for the menu-binding importer.
+ *
+ * A binding always has the identity `productId` + `combinationKey?` (a menu item, optionally a
+ * specific variant combination). What differs per integration is the set of *value* fields carried
+ * on the binding (Codemax: `itemCode` + `unit`; Food Market Hub: `code`). Each integration supplies a
+ * `BindingImportConfig` describing those value columns and how to build/read a binding; everything
+ * else (menu indexing, duplicate detection, variant resolution, classification, merge, template) is
+ * shared in `core.ts`.
+ */
+/** A binding shape the generic importer can operate on. */
+export interface BindingBase {
+    productId: string;
+    combinationKey?: string | null;
+}
+/** One integration-specific value column appended after the fixed menu columns. */
+export interface BindingValueColumn {
+    /** stable field key on the binding object, e.g. 'itemCode' | 'unit' | 'code' */
+    field: string;
+    /** header text written to the template and shown in the preview, e.g. 'CodeMax Code' | 'FMH Code' */
+    header: string;
+    /** tolerant header aliases (already normalized: lowercase, alphanumeric-only) accepted on import */
+    aliases: string[];
+    /** when true, a blank cell on an otherwise-resolved row contributes to SKIPPED / partial-error logic */
+    required: boolean;
+}
+export interface BindingImportConfig<TBinding extends BindingBase> {
+    /** integration key — used for the template filename, e.g. 'codemax' | 'foodMarketHub' */
+    key: string;
+    /** value columns, in display/template order, appended after the fixed menu columns */
+    valueColumns: BindingValueColumn[];
+    /** assemble a binding from a resolved menu match + the row's value cells (field → cell value) */
+    buildBinding(args: {
+        productId: string;
+        combinationKey?: string;
+        values: Record<string, string>;
+    }): TBinding;
+    /** read the value cells back off an existing binding (for template prefilling + preview display) */
+    readValues(binding: TBinding): Record<string, string>;
+}
+export type ImportStatus = 'NEW' | 'OVERRIDE' | 'SKIPPED' | 'DUPLICATE' | 'NOT_FOUND' | 'AMBIGUOUS';
+/**
+ * A parsed spreadsheet row. Identity is `productId` (authoritative) → `menuItemCode` → `menuItemName`
+ * (normalized fallback); the variant dimension is `variantKey` (combinationKey). `category` /
+ * `variantName` are display-only. Mirrors the menu export's column conventions (reference only — the
+ * raw menu export is not parsed).
+ */
+export interface ImportRow {
+    productId: string;
+    menuItemCode: string;
+    menuItemName: string;
+    category: string;
+    variantName: string;
+    variantKey: string;
+    /** value-column field → trimmed cell value */
+    values: Record<string, string>;
+}
+export interface MenuMatch {
+    productId: string;
+    name: string;
+    isAddon: boolean;
+    /** the valid combinationKeys the product owns (empty for a product without variants) */
+    combinationKeys?: Set<string>;
+    combinationNames?: Map<string, string>;
+}
+/** Resolution indexes built from the live menu: productId (authoritative), code, normalized name. */
+export interface MenuIndex {
+    byProductId: Map<string, MenuMatch>;
+    byCode: Map<string, MenuMatch[]>;
+    byName: Map<string, MenuMatch[]>;
+}
+export interface ImportResultRow<TBinding extends BindingBase> {
+    excelRowNumber: number;
+    status: ImportStatus;
+    row: ImportRow;
+    binding?: TBinding;
+    resolvedName?: string;
+    variantName?: string;
+    isAddon?: boolean;
+    warnings: string[];
+    errors: string[];
+}
+export interface ImportResult<TBinding extends BindingBase> {
+    invalidExcel: boolean;
+    invalidExcelMessage?: string;
+    rows: ImportResultRow<TBinding>[];
+}
+export interface ImportSummary {
+    new: number;
+    override: number;
+    skipped: number;
+    duplicate: number;
+    notFound: number;
+    ambiguous: number;
+    withErrors: number;
+}
+export interface TemplateResult {
+    /** header + data rows, ready for `toSheet` */
+    rows: string[][];
+}