@genesislcap/mock-server 15.51.1 → 15.53.0

package/src/db/store.ts

@@ -1,21 +1,64 @@
 // In-memory tables + views + sequence generation. No persistence, no external deps.
 // This is the "database" — disposable and rebuilt from seed data on every server start.
 
-import type { Row, TableDef, ViewDef } from '../types.ts';
+import type { Row, SequenceFormat, TableDef, ViewDef } from '../types.ts';
+import { RECORD_ID, RecordClock, recordKey, TIMESTAMP, withoutRecordFields } from './identity.ts';
 
 type Pk = string;
 
+// A field the store fills on insert when the record leaves it out: the
+// sequencePrefix key, and every TableDef.generated entry it can mint.
+type Generator =
+  | { field: string; kind: 'SEQUENCE'; prefix: string }
+  | { field: string; kind: 'AUTO_INCREMENT' };
+
 interface TableConfig {
   pkFields: string[];
   sequencePrefix?: string;
   sequenceWidth: number;
+  sequenceFormat: SequenceFormat;
+  generators: Generator[];
 }
 
+// The generators of a table, the key's own sequence first. A SEQUENCE with
+// neither its own prefix nor the table's can't mint anything and is left to
+// the caller.
+function generatorsOf(
+  pkFields: string[],
+  { sequencePrefix, generated = [] }: TableDef,
+): Generator[] {
+  const generators: Generator[] = [];
+  if (sequencePrefix && pkFields.length === 1) {
+    generators.push({ field: pkFields[0], kind: 'SEQUENCE', prefix: sequencePrefix });
+  }
+  for (const entry of generated) {
+    if (generators.some((generator) => generator.field === entry.field)) continue;
+    if (entry.kind === 'AUTO_INCREMENT') {
+      generators.push({ field: entry.field, kind: 'AUTO_INCREMENT' });
+      continue;
+    }
+    const prefix = entry.prefix ?? sequencePrefix;
+    if (prefix) generators.push({ field: entry.field, kind: 'SEQUENCE', prefix });
+  }
+  return generators;
+}
+
+const isMissing = (value: unknown) => value === undefined || value === null;
+
 // Composite keys join the pk fields' values with '|' (so values must not
 // contain '|'). Single-field keys stay the raw value, preserving
 // getRow('TABLE', 'TR001')-style lookups.
 const COMPOSITE_KEY_SEPARATOR = '|';
 
+const MAX_REMOVED_PER_KEY = 16;
+const MAX_REMOVED_KEYS = 10_000;
+
+// IdStrategy.java: a 15-digit counter, the sequence id, the location
+// (DbConfig's default 'LO') and the system id (always 1).
+const GENESIS_SEQUENCE_DIGITS = 15;
+const GENESIS_LOCATION = 'LO';
+const GENESIS_SYSTEM = '1';
+
 function normalizePkFields(pkField: string | string[]): string[] {
   return Array.isArray(pkField) ? pkField : [pkField];
 }
@@ -25,65 +68,203 @@ function keyFor(pkFields: string[], row: Row): Pk {
   return pkFields.map((field) => String(row[field])).join(COMPOSITE_KEY_SEPARATOR);
 }
 
+function escapeRegExp(text: string): string {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+// The counter inside a generated value, or undefined when the value isn't
+// one a sequence with this prefix and format could have produced.
+function sequenceNumber(
+  prefix: string,
+  format: SequenceFormat,
+  value: unknown,
+): number | undefined {
+  if (typeof value !== 'string') return undefined;
+  const digits =
+    format === 'genesis'
+      ? new RegExp(`^(\\d+)${escapeRegExp(prefix)}${GENESIS_LOCATION}${GENESIS_SYSTEM}$`).exec(
+          value,
+        )?.[1]
+      : value.startsWith(prefix)
+        ? value.slice(prefix.length)
+        : undefined;
+  if (digits === undefined) return undefined;
+  const n = parseInt(digits, 10);
+  return Number.isFinite(n) ? n : undefined;
+}
+
+// Counters are shared by tables using the same prefix in the same format.
+function counterKey(prefix: string, format: SequenceFormat): string {
+  return format === 'genesis' ? `${prefix}\u0000genesis` : prefix;
+}
+
+// An AUTO_INCREMENT counter belongs to its table's field.
+const autoIncrementKey = (tableName: string, field: string) => `${tableName}\u0000${field}`;
+
 export class Store {
   private tables = new Map<string, Map<Pk, Row>>();
   private tableConfig = new Map<string, TableConfig>();
   private sequenceCounters = new Map<string, number>();
+  private autoIncrementCounters = new Map<string, number>();
+  private clock = new RecordClock();
   // Immutable snapshot of each table's rows as registered, used only for field
   // metadata derivation (see getMetadataRows) so deleting every live row can't
   // collapse a resource's schema to zero fields.
   private seedRows = new Map<string, Row[]>();
+  // Per table and key, every record the key lost (deleted, or displaced by
+  // an insert or a key change landing on it) and no broadcast has announced
+  // yet, oldest first — see takeRemovedRows. Bounded: a key keeps its last
+  // MAX_REMOVED_PER_KEY records and a table its last MAX_REMOVED_KEYS keys,
+  // for handlers that delete without ever broadcasting.
+  private removedRows = new Map<string, Map<Pk, Row[]>>();
   readonly views = new Map<string, ViewDef>();
 
-  registerTable(
-    tableName: string,
-    { pkField, sequencePrefix, sequenceWidth = 3, rows = [] }: TableDef,
-  ): this {
+  registerTable(tableName: string, definition: TableDef): this {
+    const {
+      pkField,
+      sequencePrefix,
+      sequenceWidth = 3,
+      sequenceFormat = 'prefix',
+      rows = [],
+    } = definition;
     const pkFields = normalizePkFields(pkField);
+    const config: TableConfig = {
+      pkFields,
+      sequencePrefix,
+      sequenceWidth,
+      sequenceFormat,
+      generators: generatorsOf(pkFields, definition),
+    };
     const table = new Map<Pk, Row>();
+    const seenIds = new Set<string>();
+    let restamped = 0;
     for (const row of rows) {
-      table.set(keyFor(pkFields, row), { ...row });
+      const stamped = this.stampSeedRow({ ...row }, seenIds);
+      if (stamped.restamped) restamped += 1;
+      table.set(keyFor(pkFields, row), stamped.row);
+    }
+    if (restamped > 0) {
+      console.warn(
+        `[mock-server] ${tableName}: re-stamped ${restamped} seed row(s) whose RECORD_ID was ` +
+          'not a safe integer or a string, or repeated another row, so every ROW_REF stays unique',
+      );
     }
     this.tables.set(tableName, table);
-    this.tableConfig.set(tableName, { pkFields, sequencePrefix, sequenceWidth });
+    this.tableConfig.set(tableName, config);
+    this.removedRows.delete(tableName);
     this.seedRows.set(
       tableName,
       rows.map((row) => ({ ...row })),
     );
 
-    // Sequence generation only makes sense for a single-field pk.
-    if (sequencePrefix && pkFields.length === 1) {
+    // Each counter starts after the highest value the seed rows carry (two
+    // fields of one table sharing a prefix share the counter). The key's
+    // sequence only exists for a single-field pk.
+    const starts = new Map<string, number>();
+    for (const generator of config.generators) {
       let maxN = 0;
       for (const row of rows) {
-        const pk = String(row[pkFields[0]] ?? '');
-        if (pk.startsWith(sequencePrefix)) {
-          const n = parseInt(pk.slice(sequencePrefix.length), 10);
-          if (Number.isFinite(n)) maxN = Math.max(maxN, n);
-        }
+        const n = this.generatedNumber(config, generator, row[generator.field]);
+        if (n !== undefined) maxN = Math.max(maxN, n);
       }
-      this.sequenceCounters.set(sequencePrefix, maxN + 1);
+      const counter = this.counterOf(tableName, config, generator);
+      starts.set(counter, Math.max(starts.get(counter) ?? 1, maxN + 1));
+    }
+    for (const generator of config.generators) {
+      const counter = this.counterOf(tableName, config, generator);
+      this.countersFor(generator).set(counter, starts.get(counter)!);
     }
     return this;
   }
 
+  private counterOf(tableName: string, config: TableConfig, generator: Generator): string {
+    return generator.kind === 'SEQUENCE'
+      ? counterKey(generator.prefix, config.sequenceFormat)
+      : autoIncrementKey(tableName, generator.field);
+  }
+
+  private countersFor(generator: Generator): Map<string, number> {
+    return generator.kind === 'SEQUENCE' ? this.sequenceCounters : this.autoIncrementCounters;
+  }
+
+  // The counter inside a value a generator could have produced.
+  private generatedNumber(
+    config: TableConfig,
+    generator: Generator,
+    value: unknown,
+  ): number | undefined {
+    if (generator.kind === 'SEQUENCE') {
+      return sequenceNumber(generator.prefix, config.sequenceFormat, value);
+    }
+    return typeof value === 'number' && Number.isSafeInteger(value) ? value : undefined;
+  }
+
   registerView(viewName: string, definition: ViewDef): this {
     this.views.set(viewName, definition);
     return this;
   }
 
-  // An explicitly-supplied pk inside the sequence's own range must advance the
-  // counter too. Without this, inserting e.g. 'TR002' by hand leaves the
-  // counter at 2, and the next auto-generated insert mints 'TR002' again and
-  // silently overwrites the hand-keyed row (Map.set, no error, event still
-  // acks success).
-  private observeSequenceValue(config: TableConfig, row: Row): void {
-    if (!config.sequencePrefix || config.pkFields.length !== 1) return;
-    const pk = String(row[config.pkFields[0]] ?? '');
-    if (!pk.startsWith(config.sequencePrefix)) return;
-    const n = parseInt(pk.slice(config.sequencePrefix.length), 10);
-    if (!Number.isFinite(n)) return;
-    const next = this.sequenceCounters.get(config.sequencePrefix) ?? 1;
-    if (n + 1 > next) this.sequenceCounters.set(config.sequencePrefix, n + 1);
+  // Seed rows keep a RECORD_ID they bring (e.g. rows copied from a real
+  // server) when it is usable: a safe integer, or a string, not used by an
+  // earlier seed row. Anything else — a missing id, a number above 2^53 that
+  // JSON.parse already rounded onto its neighbour's, a repeat — gets a fresh
+  // stamp, in seed order, so no two rows share a ROW_REF. A missing or
+  // unusable TIMESTAMP becomes the RECORD_ID.
+  private stampSeedRow(row: Row, seenIds: Set<string>): { row: Row; restamped: boolean } {
+    const given = row[RECORD_ID];
+    const usable = (value: unknown) =>
+      (typeof value === 'number' && Number.isSafeInteger(value)) ||
+      (typeof value === 'string' && value !== '');
+    const missing = given === undefined || given === null;
+    const keep = !missing && usable(given) && !seenIds.has(String(given));
+    if (keep) {
+      this.clock.observe(given);
+    } else {
+      row[RECORD_ID] = this.clock.next();
+    }
+    seenIds.add(String(row[RECORD_ID]));
+    if (!usable(row[TIMESTAMP])) row[TIMESTAMP] = row[RECORD_ID];
+    this.clock.observe(row[TIMESTAMP]);
+    return { row, restamped: !missing && !keep };
+  }
+
+  // A newly inserted row gets RECORD_ID = TIMESTAMP = a fresh stamp, whatever
+  // it was given — as on the real server — appended after its own fields.
+  private stampNewRow(row: Row): Row {
+    delete row[RECORD_ID];
+    delete row[TIMESTAMP];
+    const stamp = this.clock.next();
+    row[RECORD_ID] = stamp;
+    row[TIMESTAMP] = stamp;
+    return row;
+  }
+
+  private noteRemoved(tableName: string, key: Pk, row: Row): void {
+    let removed = this.removedRows.get(tableName);
+    if (!removed) {
+      removed = new Map();
+      this.removedRows.set(tableName, removed);
+    }
+    const records = removed.get(key) ?? [];
+    // Re-set so the key moves to the end: the oldest keys are dropped first.
+    removed.delete(key);
+    removed.set(key, [...records, row].slice(-MAX_REMOVED_PER_KEY));
+    if (removed.size > MAX_REMOVED_KEYS) removed.delete(removed.keys().next().value!);
+  }
+
+  // A supplied value inside a generator's own range must advance its counter
+  // too. Without this, inserting e.g. 'TR002' by hand leaves the counter at
+  // 2, and the next generated insert mints 'TR002' again and silently
+  // overwrites the hand-keyed row (Map.set, no error, event still acks
+  // success).
+  private observeGeneratedValues(tableName: string, config: TableConfig, row: Row): void {
+    for (const generator of config.generators) {
+      const n = this.generatedNumber(config, generator, row[generator.field]);
+      if (n === undefined) continue;
+      const counters = this.countersFor(generator);
+      const counter = this.counterOf(tableName, config, generator);
+      if (n + 1 > (counters.get(counter) ?? 1)) counters.set(counter, n + 1);
+    }
   }
 
   nextSequenceValue(sequencePrefix: string, width: number): string {
@@ -92,6 +273,31 @@ export class Store {
     return `${sequencePrefix}${String(n).padStart(width, '0')}`;
   }
 
+  private generateSequenceValue(config: TableConfig, prefix: string): string {
+    if (config.sequenceFormat !== 'genesis') {
+      return this.nextSequenceValue(prefix, config.sequenceWidth);
+    }
+    const key = counterKey(prefix, 'genesis');
+    const n = this.sequenceCounters.get(key) ?? 1;
+    this.sequenceCounters.set(key, n + 1);
+    return `${String(n).padStart(GENESIS_SEQUENCE_DIGITS, '0')}${prefix}${GENESIS_LOCATION}${GENESIS_SYSTEM}`;
+  }
+
+  // Fills every generated field the record leaves out (undefined or null).
+  private generateValues(tableName: string, config: TableConfig, row: Row): void {
+    for (const generator of config.generators) {
+      if (!isMissing(row[generator.field])) continue;
+      if (generator.kind === 'SEQUENCE') {
+        row[generator.field] = this.generateSequenceValue(config, generator.prefix);
+        continue;
+      }
+      const counter = autoIncrementKey(tableName, generator.field);
+      const n = this.autoIncrementCounters.get(counter) ?? 1;
+      this.autoIncrementCounters.set(counter, n + 1);
+      row[generator.field] = n;
+    }
+  }
+
   getAllRows(tableName: string): Row[] {
     const table = this.tables.get(tableName);
     if (!table) return [];
@@ -135,59 +341,109 @@ export class Store {
     return rows.find(matchesAllCriteria);
   }
 
+  // A copy of the record with its missing generated fields filled in, as the
+  // database does before checking its unique indexes. Each value used is
+  // gone even if the record is then rejected, as a real sequence's is.
+  withGeneratedValues(tableName: string, record: Row): Row {
+    const config = this.tableConfig.get(tableName);
+    if (!config) throw new Error(`Unknown table: ${tableName}`);
+    const row = { ...record };
+    this.generateValues(tableName, config, row);
+    return row;
+  }
+
+  // Generates every missing (undefined or null) sequence and auto-increment
+  // field — the sequencePrefix key and TableDef.generated — and keeps a
+  // supplied one, as GSF does; stamps RECORD_ID/TIMESTAMP. A row already
+  // stored under the same key is replaced (the real database would reject the
+  // insert with DUPLICATE_KEY — check first and throw NackError.duplicateKey
+  // for that, as the generic CRUD events do).
   insertRow(tableName: string, record: Row): Row {
     const table = this.tables.get(tableName);
     const config = this.tableConfig.get(tableName);
     if (!table || !config) throw new Error(`Unknown table: ${tableName}`);
 
     const row = { ...record };
-    if (
-      config.pkFields.length === 1 &&
-      row[config.pkFields[0]] === undefined &&
-      config.sequencePrefix
-    ) {
-      row[config.pkFields[0]] = this.nextSequenceValue(config.sequencePrefix, config.sequenceWidth);
-    }
+    this.generateValues(tableName, config, row);
     const missing = config.pkFields.filter((field) => row[field] === undefined);
     if (missing.length > 0) {
       throw new Error(
         `Primary key field(s) '${missing.join("', '")}' are required for inserting into table '${tableName}'`,
       );
     }
-    this.observeSequenceValue(config, row);
-    table.set(keyFor(config.pkFields, row), row);
+    this.observeGeneratedValues(tableName, config, row);
+    this.stampNewRow(row);
+    const key = keyFor(config.pkFields, row);
+    const displaced = table.get(key);
+    if (displaced) this.noteRemoved(tableName, key, displaced);
+    table.set(key, row);
     return row;
   }
 
+  // Merges the patch, moves TIMESTAMP on and keeps RECORD_ID (a patch can't
+  // change a row's identity).
   updateRow(tableName: string, pk: Pk, patch: Row): Row | undefined {
     const table = this.tables.get(tableName);
     const config = this.tableConfig.get(tableName);
     if (!table || !config || !table.has(pk)) return undefined;
-    const updated = { ...table.get(pk), ...patch };
+    const existing = table.get(pk)!;
+    const updated = { ...existing, ...patch };
+    updated[RECORD_ID] = existing[RECORD_ID];
+    updated[TIMESTAMP] = this.clock.next();
     // A patch that changes a pk field (e.g. an entity-management form posting
     // its full DETAILS after the user edited the key column) must move the row
     // to its new key. Leaving it under the old one makes the index disagree
     // with the row itself: getRow(newKey) misses, while rowKey()/getRowRef()
     // report the new key, so the matching broadcast finds nothing to push.
     const nextKey = keyFor(config.pkFields, updated);
-    if (nextKey !== pk) table.delete(pk);
+    if (nextKey !== pk) {
+      table.delete(pk);
+      const displaced = table.get(nextKey);
+      if (displaced) this.noteRemoved(tableName, nextKey, displaced);
+    }
     table.set(nextKey, updated);
     return updated;
   }
 
   deleteRow(tableName: string, pk: Pk): boolean {
     const table = this.tables.get(tableName);
-    if (!table) return false;
-    return table.delete(pk);
+    const existing = table?.get(pk);
+    if (!table || !existing) return false;
+    table.delete(pk);
+    this.noteRemoved(tableName, pk, existing);
+    return true;
+  }
+
+  // Reads and clears every record a key lost that no broadcast announced
+  // yet, oldest first: what a DELETE broadcast names (their RECORD_IDs are
+  // the ROW_REFs a client may hold — held-rows tracking drops the ones it
+  // doesn't), including the old record when a key's row was replaced before
+  // one broadcast.
+  takeRemovedRows(tableName: string, key: Pk): Row[] {
+    const removed = this.removedRows.get(tableName);
+    const records = removed?.get(key) ?? [];
+    removed?.delete(key);
+    return records;
+  }
+
+  // The same, for a row of a table or view given by its (base) pk fields —
+  // what a public broadcast(resource, 'DELETE', pkStub) names.
+  takeRemovedRecordsFor(resourceName: string, row: Row): Row[] {
+    const located = this.locateRecord(resourceName, row);
+    return located ? this.takeRemovedRows(located.tableName, located.key) : [];
   }
 
   // Materializes a view: base table left-joined to related tables (optionally
   // narrowed by per-join `where` predicates), minus anti-joined rows, plus
-  // derived fields.
-  getViewRows(viewName: string): Row[] {
+  // derived fields. `tables` substitutes the rows of any table the view reads
+  // (its base or a joined one) — e.g. one base row, to build that row's view
+  // row, or a table's earlier state, to rebuild the view as it was.
+  getViewRows(viewName: string, tables: Record<string, Row[]> = {}): Row[] {
     const view = this.views.get(viewName);
     if (!view) throw new Error(`Unknown view: ${viewName}`);
-    return this.materializeView(view, (tableName) => this.getAllRows(tableName));
+    return this.materializeView(view, (tableName) =>
+      Object.hasOwn(tables, tableName) ? tables[tableName] : this.getAllRows(tableName),
+    );
   }
 
   private materializeView(view: ViewDef, getRows: (tableName: string) => Row[]): Row[] {
@@ -254,12 +510,16 @@ export class Store {
   // deleting a table's last row would make the next metadata reply say the
   // resource has zero fields — which entity-management renders as a form with
   // no inputs and a delete button that can't build a payload, silently.
+  // RECORD_ID and TIMESTAMP are left out: they are not fields a dataserver
+  // row or an event's DETAILS carry.
   getMetadataRows(resourceName: string): Row[] {
     const live = this.getResourceRows(resourceName);
-    if (live.length > 0) return live;
+    if (live.length > 0) return live.map(withoutRecordFields);
     const view = this.views.get(resourceName);
-    if (view) return this.materializeView(view, (tableName) => this.seedRows.get(tableName) ?? []);
-    return this.seedRows.get(resourceName) ?? [];
+    const seed = view
+      ? this.materializeView(view, (tableName) => this.seedRows.get(tableName) ?? [])
+      : (this.seedRows.get(resourceName) ?? []);
+    return seed.map(withoutRecordFields);
   }
 
   // Row-identity fields for a table or view; empty when unknown.
@@ -272,17 +532,50 @@ export class Store {
     return this.tableConfig.get(resourceName)?.pkFields ?? [];
   }
 
-  // The DETAILS.ROW_REF value stamped on QUERY_UPDATE rows (see
-  // protocol/rowUpdate.ts): the pk field's value, or the composite key. The
-  // client's dataServerResultFilter keys inserts/amends/deletes off this.
+  // The pk-based row reference: the pk field's value, or the composite key.
+  // This was DETAILS.ROW_REF up to 15.47 and still is under
+  // fidelity: 'legacy'; by default ROW_REF is getRecordRef's.
   getRowRef(resourceName: string, row: Row): unknown {
     const pkFields = this.getPkFields(resourceName);
     if (pkFields.length === 0) return undefined;
     return keyFor(pkFields, row);
   }
 
+  // The DETAILS.ROW_REF GSF stamps on dataserver rows: the row's RECORD_ID as
+  // a string (GenesisSetMaskingJsonSerializer: value.toString()). A view row
+  // carries its base row's RECORD_ID. A row passed without one (a hand-built
+  // row, or a pk-only stub) is matched to the stored record by its pk — a
+  // just-deleted record included — and only when that fails too does this
+  // fall back to the pk-based reference.
+  getRecordRef(resourceName: string, row: Row): unknown {
+    const id = recordKey(row) ?? recordKey(this.findStoredRecord(resourceName, row));
+    return id ?? this.getRowRef(resourceName, row);
+  }
+
+  private locateRecord(resourceName: string, row: Row): { tableName: string; key: Pk } | undefined {
+    const view = this.views.get(resourceName);
+    const tableName = view ? view.base : resourceName;
+    const pkFields = this.tableConfig.get(tableName)?.pkFields ?? [];
+    if (pkFields.length === 0 || pkFields.some((field) => row[field] === undefined)) {
+      return undefined;
+    }
+    return { tableName, key: keyFor(pkFields, row) };
+  }
+
+  // The stored record a pk-only row names: the live one, else the newest
+  // record removed from that key and not yet broadcast.
+  private findStoredRecord(resourceName: string, row: Row): Row | undefined {
+    const located = this.locateRecord(resourceName, row);
+    if (!located) return undefined;
+    const { tableName, key } = located;
+    return (
+      this.tables.get(tableName)?.get(key) ?? this.removedRows.get(tableName)?.get(key)?.at(-1)
+    );
+  }
+
   // Rebuilds a DELETE stub row carrying the pk field(s) from a stored key, so
   // subscribers can be told which row to drop after it's already gone.
+  // (The DELETE body under fidelity: 'legacy'; GSF sends DETAILS only.)
   rowStubFromKey(resourceName: string, key: Pk): Row {
     const pkFields = this.getPkFields(resourceName);
     if (pkFields.length <= 1) return pkFields.length ? { [pkFields[0]]: key } : {};

package/src/handlers/commitEvent.ts

@@ -1,25 +1,44 @@
 import type { Store } from '../db/store.ts';
 import type { Connection } from '../protocol/connection.ts';
-import { NackError } from '../protocol/errors.ts';
+import { NackError, nackPayload, warningPayload } from '../protocol/errors.ts';
 import { isLegacyFidelity } from '../protocol/fidelity.ts';
 import { ERROR_CODE, MESSAGE_TYPE } from '../protocol/messageTypes.ts';
 import { resourceNotMappedNack } from '../protocol/msgNack.ts';
 import type {
   BroadcastFn,
   BroadcastTableChangeFn,
+  EventHandler,
   GenesisMessage,
   MockServerConfig,
 } from '../types.ts';
+import { crudEventHandler } from './crudEvents.ts';
+import { validateEventMessage } from './eventValidation.ts';
 
 export interface CommitEventCtx {
   broadcast: BroadcastFn;
   broadcastTableChange: BroadcastTableChangeFn;
 }
 
+// The handler serving an event: an eventHandlers entry, else the generic CRUD
+// handler a table registers through TableDef.events, else
+// defaultEventHandler.
+function resolveEventHandler(
+  eventName: string,
+  config: MockServerConfig,
+): EventHandler | undefined {
+  return (
+    config.eventHandlers?.[eventName] ??
+    crudEventHandler(eventName, config) ??
+    config.defaultEventHandler
+  );
+}
+
 // Commit events (EVENT_<ENTITY>_INSERT/_AMEND/_DELETE, or whatever suffix
 // convention your project uses) are looked up by exact MESSAGE_TYPE against
-// config.eventHandlers. A handler receives (details, ctx) and either returns
-// { generated?: [...] } on success, or throws NackError(errors) on failure.
+// config.eventHandlers, then the tables' generic CRUD events. A handler
+// receives (details, ctx) and either returns { generated?: [...] } on
+// success, { warnings: [...] } to NACK with warnings only, or throws
+// NackError(errors) on failure.
 export function handleCommitEvent(
   message: GenesisMessage,
   connection: Connection,
@@ -31,7 +50,7 @@ export function handleCommitEvent(
   // defaultEventHandler catches anything unregistered — lets projects with
   // dozens of commit events adopt incrementally (e.g. `() => ({})` to ack
   // everything unhandled) instead of enumerating ack-only handlers.
-  const handler = config.eventHandlers?.[eventName] ?? config.defaultEventHandler;
+  const handler = resolveEventHandler(eventName, config);
 
   // Replies use the GENERIC EVENT_ACK/EVENT_NACK — correlation is purely via
   // SOURCE_REF. See the note on MESSAGE_TYPE in protocol/messageTypes.ts:
@@ -58,17 +77,42 @@ export function handleCommitEvent(
     return;
   }
 
+  // Before any handler runs, the message is checked against the event's
+  // declared schema (eventValidation.ts), as GSF's decoder does; each failure
+  // is a FieldError in one EVENT_NACK. Legacy fidelity never checked.
+  // A handler's failure is an EVENT_NACK with GSF's error items (see
+  // protocol/errors.ts): a thrown NackError gives its own, anything else is
+  // StandardError INTERNAL_ERROR. Returned warnings NACK too, with an empty
+  // ERROR — the IGNORE_WARNINGS flow that would let them through is not
+  // modelled yet. VALIDATE: true reaches the handler as ctx.validate; a
+  // handler that honours it acks without writing.
+  const legacy = isLegacyFidelity(config);
   try {
-    const result = handler(message.DETAILS ?? {}, { connection, store, message, ...ctx }) ?? {};
+    const schemaErrors = legacy ? [] : validateEventMessage(message, connection, config, store);
+    if (schemaErrors.length > 0) throw new NackError(schemaErrors);
+    const result =
+      handler(message.DETAILS ?? {}, {
+        connection,
+        store,
+        message,
+        ...ctx,
+        validate: message.VALIDATE === true,
+      }) ?? {};
+    if (result.warnings?.length) {
+      connection.reply(message, {
+        MESSAGE_TYPE: MESSAGE_TYPE.EVENT_NACK,
+        ...warningPayload(result.warnings, legacy),
+      });
+      return;
+    }
     connection.reply(message, {
       MESSAGE_TYPE: MESSAGE_TYPE.EVENT_ACK,
       GENERATED: result.generated ?? [],
     });
   } catch (error) {
-    const errors =
-      error instanceof NackError
-        ? error.errors
-        : [{ CODE: ERROR_CODE.VALIDATION_ERROR, TEXT: (error as Error).message }];
-    connection.reply(message, { MESSAGE_TYPE: MESSAGE_TYPE.EVENT_NACK, ERROR: errors });
+    connection.reply(message, {
+      MESSAGE_TYPE: MESSAGE_TYPE.EVENT_NACK,
+      ...nackPayload(error, legacy),
+    });
   }
 }