@genesislcap/mock-server 15.52.0 → 15.53.0

package/src/db/schema.ts

@@ -7,8 +7,10 @@
 import { isLegacyFidelity } from '../protocol/fidelity.ts';
 import { daoClassOf, titleCase } from '../protocol/fieldTypes.ts';
 import type {
+  CrudEventVerb,
   FieldDef,
   GenesisFieldType,
+  IndexDef,
   MockServerConfig,
   QueryDef,
   RequestReplyDef,
@@ -16,6 +18,7 @@ import type {
   TableDef,
   ViewDef,
 } from '../types.ts';
+import { RECORD_FIELDS, RECORD_ID, TIMESTAMP } from './identity.ts';
 import { deriveFields } from './metadata.ts';
 import type { Store } from './store.ts';
 
@@ -46,17 +49,29 @@ export interface ResolvedSchema {
   declared: boolean;
 }
 
-function pkFieldsOf(def: TableDef): string[] {
+export function pkFieldsOf(def: TableDef): string[] {
   return Array.isArray(def.pkField) ? def.pkField : [def.pkField];
 }
 
 // The declared generated fields, plus the key of a table that mints its own
 // keys through sequencePrefix.
 export function generatedFieldsOf(def: TableDef): Set<string> {
-  const generated = new Set((def.generated ?? []).map((entry) => entry.field));
+  return new Set(generatedFieldList(def));
+}
+
+// The same fields in the order GSF lists a table's generated fields
+// (EventHandlerUtils.kt generatedFields: the id sequences, then the
+// auto-increment fields): the sequencePrefix key first, then the declared
+// SEQUENCE fields, then the AUTO_INCREMENT ones.
+export function generatedFieldList(def: TableDef): string[] {
   const pkFields = pkFieldsOf(def);
-  if (def.sequencePrefix && pkFields.length === 1) generated.add(pkFields[0]);
-  return generated;
+  const declared = def.generated ?? [];
+  const fields = [
+    ...(def.sequencePrefix && pkFields.length === 1 ? [pkFields[0]] : []),
+    ...declared.filter((entry) => entry.kind === 'SEQUENCE').map((entry) => entry.field),
+    ...declared.filter((entry) => entry.kind === 'AUTO_INCREMENT').map((entry) => entry.field),
+  ];
+  return [...new Set(fields)];
 }
 
 function fromFieldDef(
@@ -184,7 +199,10 @@ function pick(fields: Map<string, ResolvedField>, names: string[]): ResolvedFiel
   });
 }
 
-function isDeclared(source: string, config: MockServerConfig, store: Store): boolean {
+// Whether a table (or a view, through its base table) declares its fields.
+// Checked without resolving the schema, so it costs nothing for a big
+// undeclared table.
+export function isDeclared(source: string, config: MockServerConfig, store: Store): boolean {
   const table = config.tables?.[source];
   if (table) return !!table.fields;
   const view = viewOf(source, config, store);
@@ -285,12 +303,72 @@ export function requestReplySchema(
   return withTypeOverrides(schema, requestReply.fieldTypes);
 }
 
-// The record identity a criteria-only request server adds to every reply row.
+// The record identity every table entity carries after its own columns: what
+// a request server with no reply block sends in each row and lists in
+// REPLY_FIELD, and what a criteria-only one can sort and filter by.
 export const RECORD_IDENTITY_FIELDS: ResolvedField[] = [
-  { name: 'RECORD_ID', type: 'LONG', nullable: false, generated: true },
-  { name: 'TIMESTAMP', type: 'NANO_TIMESTAMP', nullable: false, generated: true },
+  { name: RECORD_ID, type: 'LONG', nullable: false, generated: true },
+  { name: TIMESTAMP, type: 'NANO_TIMESTAMP', nullable: false, generated: true },
+];
+
+const withIdentity = (fields: ResolvedField[]): ResolvedField[] => [
+  ...fields.filter((field) => !RECORD_FIELDS.includes(field.name)),
+  ...RECORD_IDENTITY_FIELDS,
 ];
 
+// What a request server's database entity has: its source's fields, then
+// RECORD_ID and TIMESTAMP (a resolver's: its metadataRows). A criteria-only
+// server sorts and filters by these (SORTABLE_FIELDS, CRITERIA_FIELDS), and
+// REQUEST may name any of them, whatever the reply block says.
+export function requestReplySourceSchema(
+  requestReply: RequestReplyDef,
+  config: MockServerConfig,
+  store: Store,
+): ResolvedSchema {
+  const schema = requestReplySchema(requestReply, config, store);
+  return requestReply.source && !requestReply.resolver
+    ? { ...schema, fields: withIdentity(schema.fields) }
+    : schema;
+}
+
+// What a request server's REP_ rows carry (getReplyFields in
+// RequestReplyServer.kt, GSF v8.15.29): the reply block (`fields`), else the
+// source's fields followed by RECORD_ID and TIMESTAMP — a table entity's own
+// field list, which the real server sends whether or not the server is
+// criteria-only (auth's RIGHT sends no RECORD_ID only because its reply block
+// names CODE and DESCRIPTION). REPLY_FIELD and the JSON schema's REPLY come
+// from here. A resolver's fields are its metadataRows'; under fidelity:
+// 'legacy' everything is the source schema, as up to 15.47.
+export function requestReplyReplySchema(
+  requestReply: RequestReplyDef,
+  config: MockServerConfig,
+  store: Store,
+): ResolvedSchema {
+  if (isLegacyFidelity(config)) return requestReplySchema(requestReply, config, store);
+  const schema = requestReplySourceSchema(requestReply, config, store);
+  if (!requestReply.fields || !requestReply.source || requestReply.resolver) return schema;
+  return projectSchema(schema, requestReply.fields);
+}
+
+// The columns a source-backed request server's REP_ rows carry, in order (see
+// requestReplyReplySchema). undefined — rows as stored, which already end
+// with their RECORD_ID and TIMESTAMP — for an undeclared source with no reply
+// block, for a resolver, and under fidelity: 'legacy'.
+export function requestReplyFieldNames(
+  requestReply: RequestReplyDef,
+  config: MockServerConfig,
+  store: Store,
+): string[] | undefined {
+  if (isLegacyFidelity(config) || !requestReply.source || requestReply.resolver) return undefined;
+  const declared = sourceFieldNames(requestReply.source, config, store);
+  const names = declared && [
+    ...declared.filter((name) => !RECORD_FIELDS.includes(name)),
+    ...RECORD_FIELDS,
+  ];
+  if (!requestReply.fields) return names;
+  return names ? requestReply.fields.filter((name) => names.includes(name)) : requestReply.fields;
+}
+
 // The request block's fields: requestFields, else the source's key.
 export function requestFieldsOf(requestReply: RequestReplyDef, store: Store): string[] {
   if (requestReply.requestFields) return requestReply.requestFields;
@@ -359,8 +437,74 @@ export function projectRow(row: Row, names: string[] | undefined): Row {
   return Object.fromEntries(names.map((name) => [name, row[name] ?? null]));
 }
 
+// --- indexes -----------------------------------------------------------------
+
+// The name the dictionary gives an index declared without one
+// (DslFieldContext.kt generateIndexName, GSF v8.15.29): '<TABLE>_BY_' and the
+// fields, each without a leading '<TABLE>_', joined with '_' — so
+// primaryKey("COUNTERPARTY_ID") is COUNTERPARTY_BY_ID and
+// unique("INSTRUMENT_ID") on POSITION is POSITION_BY_INSTRUMENT_ID.
+export function defaultIndexName(table: string, fields: string[]): string {
+  const prefix = `${table}_`;
+  const names = fields.map(
+    (field) => (field.startsWith(prefix) && field.slice(prefix.length)) || field,
+  );
+  return `${prefix}BY_${names.join('_')}`;
+}
+
+const sameFields = (a: string[], b: string[]) =>
+  a.length === b.length && a.every((field, index) => field === b[index]);
+
+// The primary key's index name: a declared unique index over exactly the key
+// fields names it, else the dictionary default. NACKs name it in FIELD.
+export function primaryKeyIndexName(table: string, def: TableDef): string {
+  const pkFields = pkFieldsOf(def);
+  const declared = def.indexes?.find((index) => index.unique && sameFields(index.fields, pkFields));
+  return declared?.name ?? defaultIndexName(table, pkFields);
+}
+
+// The table's other unique indexes, each a constraint an insert or modify
+// must not break.
+export function secondaryUniqueIndexes(def: TableDef): IndexDef[] {
+  const pkFields = pkFieldsOf(def);
+  return (def.indexes ?? []).filter((index) => index.unique && !sameFields(index.fields, pkFields));
+}
+
 // --- events ------------------------------------------------------------------
 
+export const CRUD_EVENT_VERBS: readonly CrudEventVerb[] = ['INSERT', 'MODIFY', 'DELETE'];
+
+// A generic event's name: Create names the handler '<TABLE>_<VERB>'
+// (as GSF's GenericInsertEventHandler.messageType() does too) and the event
+// handler serves it as EVENT_<TABLE>_<VERB>.
+export function crudEventName(table: string, verb: CrudEventVerb): string {
+  return `EVENT_${table}_${verb}`;
+}
+
+// The table and verb of a generic CRUD event a table registers through
+// TableDef.events, or undefined.
+export function crudEventOf(
+  name: string | undefined,
+  config: MockServerConfig,
+): { table: string; verb: CrudEventVerb } | undefined {
+  if (!name?.startsWith('EVENT_')) return undefined;
+  for (const [table, def] of Object.entries(config.tables ?? {})) {
+    for (const verb of def.events ?? []) {
+      if (crudEventName(table, verb) === name) return { table, verb };
+    }
+  }
+  return undefined;
+}
+
+// Every generic CRUD event the tables register, in table then verb order.
+export function crudEventNames(config: MockServerConfig): string[] {
+  return Object.entries(config.tables ?? {}).flatMap(([table, def]) =>
+    CRUD_EVENT_VERBS.filter((verb) => def.events?.includes(verb)).map((verb) =>
+      crudEventName(table, verb),
+    ),
+  );
+}
+
 // Any event named .../_DELETE(_...)? takes only the key fields, which is what
 // entity-management's delete confirmation copies from the selected row.
 export function isDeleteEventName(name: string): boolean {
@@ -409,12 +553,13 @@ export interface EventTarget {
   fields?: FieldDef[];
 }
 
-// The table an event writes: config.eventSchemas first, then the
-// EVENT_<TABLE>_<VERB> convention. Only a registered event (an eventHandlers
-// or eventSchemas entry) has metadata, as only a deployed event handler has
-// on the real server; anything else is the router's 404. `bareTable` also
-// accepts a plain table name, which only JSON_SCHEMA_REQUEST does (see the
-// README).
+// The table an event writes: config.eventSchemas first, then the table that
+// registers it as a generic CRUD event, then the EVENT_<TABLE>_<VERB>
+// convention. Only a registered event (an eventHandlers or eventSchemas
+// entry, or a TableDef.events verb) has metadata, as only a deployed event
+// handler has on the real server; anything else is the router's 404.
+// `bareTable` also accepts a plain table name, which only JSON_SCHEMA_REQUEST
+// does (see the README).
 export function resolveEventTarget(
   name: string | undefined,
   config: MockServerConfig,
@@ -422,10 +567,14 @@ export function resolveEventTarget(
 ): EventTarget | undefined {
   if (!name) return undefined;
   const override = config.eventSchemas?.[name];
-  if (name.startsWith('EVENT_') && !override && !config.eventHandlers?.[name]) return undefined;
+  const crud = crudEventOf(name, config);
+  if (name.startsWith('EVENT_') && !override && !config.eventHandlers?.[name] && !crud) {
+    return undefined;
+  }
   const tableNames = Object.keys(config.tables ?? {});
   const table =
     override?.table ??
+    crud?.table ??
     (bareTable || name.startsWith('EVENT_') ? inferEventTable(name, tableNames) : undefined);
   const fieldTypes = override?.fieldTypes ? { fieldTypes: override.fieldTypes } : {};
   if (override?.fields) {

package/src/db/store.ts

@@ -6,13 +6,45 @@ import { RECORD_ID, RecordClock, recordKey, TIMESTAMP, withoutRecordFields } fro
 
 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.
@@ -41,12 +73,15 @@ function escapeRegExp(text: string): string {
 }
 
 // The counter inside a generated value, or undefined when the value isn't
-// one this table's sequence could have produced.
-function sequenceNumber(config: TableConfig, value: unknown): number | undefined {
-  const prefix = config.sequencePrefix;
-  if (!prefix || typeof value !== 'string') return undefined;
+// 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 =
-    config.sequenceFormat === 'genesis'
+    format === 'genesis'
       ? new RegExp(`^(\\d+)${escapeRegExp(prefix)}${GENESIS_LOCATION}${GENESIS_SYSTEM}$`).exec(
           value,
         )?.[1]
@@ -59,16 +94,18 @@ function sequenceNumber(config: TableConfig, value: unknown): number | undefined
 }
 
 // Counters are shared by tables using the same prefix in the same format.
-function counterKey(config: TableConfig): string {
-  return config.sequenceFormat === 'genesis'
-    ? `${config.sequencePrefix}\u0000genesis`
-    : config.sequencePrefix!;
+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
@@ -82,12 +119,22 @@ export class Store {
   private removedRows = new Map<string, Map<Pk, Row[]>>();
   readonly views = new Map<string, ViewDef>();
 
-  registerTable(
-    tableName: string,
-    { pkField, sequencePrefix, sequenceWidth = 3, sequenceFormat = 'prefix', 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 };
+    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;
@@ -110,18 +157,48 @@ export class Store {
       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 n = sequenceNumber(config, row[pkFields[0]]);
+        const n = this.generatedNumber(config, generator, row[generator.field]);
         if (n !== undefined) maxN = Math.max(maxN, n);
       }
-      this.sequenceCounters.set(counterKey(config), 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;
@@ -175,18 +252,19 @@ export class Store {
     if (removed.size > MAX_REMOVED_KEYS) removed.delete(removed.keys().next().value!);
   }
 
-  // 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 n = sequenceNumber(config, row[config.pkFields[0]]);
-    if (n === undefined) return;
-    const key = counterKey(config);
-    const next = this.sequenceCounters.get(key) ?? 1;
-    if (n + 1 > next) this.sequenceCounters.set(key, n + 1);
+  // 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 {
@@ -195,14 +273,29 @@ export class Store {
     return `${sequencePrefix}${String(n).padStart(width, '0')}`;
   }
 
-  private generateSequenceValue(config: TableConfig): string {
+  private generateSequenceValue(config: TableConfig, prefix: string): string {
     if (config.sequenceFormat !== 'genesis') {
-      return this.nextSequenceValue(config.sequencePrefix!, config.sequenceWidth);
+      return this.nextSequenceValue(prefix, config.sequenceWidth);
     }
-    const key = counterKey(config);
+    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')}${config.sequencePrefix}${GENESIS_LOCATION}${GENESIS_SYSTEM}`;
+    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[] {
@@ -248,30 +341,37 @@ export class Store {
     return rows.find(matchesAllCriteria);
   }
 
-  // Generates a missing (undefined or null) sequence pk 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).
+  // 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 || row[config.pkFields[0]] === null) &&
-      config.sequencePrefix
-    ) {
-      row[config.pkFields[0]] = this.generateSequenceValue(config);
-    }
+    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);
+    this.observeGeneratedValues(tableName, config, row);
     this.stampNewRow(row);
     const key = keyFor(config.pkFields, row);
     const displaced = table.get(key);

package/src/handlers/commitEvent.ts

@@ -1,26 +1,44 @@
 import type { Store } from '../db/store.ts';
 import type { Connection } from '../protocol/connection.ts';
-import { nackPayload, warningPayload } 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, { warnings: [...] } to NACK with warnings
-// only, 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,
@@ -32,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:
@@ -59,14 +77,27 @@ 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/VALIDATE flow that would let them through is
-  // not modelled yet.
+  // 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,