@genesislcap/mock-server 15.52.0 → 15.53.0

package/dist/db/schema.d.ts

@@ -1,4 +1,4 @@
-import type { FieldDef, MockServerConfig, QueryDef, RequestReplyDef, Row, TableDef } from '../types.ts';
+import type { CrudEventVerb, FieldDef, IndexDef, MockServerConfig, QueryDef, RequestReplyDef, Row, TableDef } from '../types.ts';
 import type { Store } from './store.ts';
 export interface ResolvedField {
     name: string;
@@ -18,18 +18,34 @@ export interface ResolvedSchema {
     fields: ResolvedField[];
     declared: boolean;
 }
+export declare function pkFieldsOf(def: TableDef): string[];
 export declare function generatedFieldsOf(def: TableDef): Set<string>;
+export declare function generatedFieldList(def: TableDef): string[];
+export declare function isDeclared(source: string, config: MockServerConfig, store: Store): boolean;
 export declare function resolveSourceSchema(source: string, config: MockServerConfig, store: Store): ResolvedSchema;
 export declare function withTypeOverrides(schema: ResolvedSchema, fieldTypes: Record<string, string> | undefined): ResolvedSchema;
 export declare function projectSchema(schema: ResolvedSchema, names: string[] | undefined): ResolvedSchema;
 export declare function querySchema(query: QueryDef, config: MockServerConfig, store: Store): ResolvedSchema;
 export declare function requestReplySchema(requestReply: RequestReplyDef, config: MockServerConfig, store: Store): ResolvedSchema;
 export declare const RECORD_IDENTITY_FIELDS: ResolvedField[];
+export declare function requestReplySourceSchema(requestReply: RequestReplyDef, config: MockServerConfig, store: Store): ResolvedSchema;
+export declare function requestReplyReplySchema(requestReply: RequestReplyDef, config: MockServerConfig, store: Store): ResolvedSchema;
+export declare function requestReplyFieldNames(requestReply: RequestReplyDef, config: MockServerConfig, store: Store): string[] | undefined;
 export declare function requestFieldsOf(requestReply: RequestReplyDef, store: Store): string[];
 export declare function knownValues(field: ResolvedField): string[] | undefined;
 export declare function eventDefaultOf(field: ResolvedField): unknown;
 export declare function queryFieldNames(query: QueryDef | undefined, config: MockServerConfig, store: Store): string[] | undefined;
 export declare function projectRow(row: Row, names: string[] | undefined): Row;
+export declare function defaultIndexName(table: string, fields: string[]): string;
+export declare function primaryKeyIndexName(table: string, def: TableDef): string;
+export declare function secondaryUniqueIndexes(def: TableDef): IndexDef[];
+export declare const CRUD_EVENT_VERBS: readonly CrudEventVerb[];
+export declare function crudEventName(table: string, verb: CrudEventVerb): string;
+export declare function crudEventOf(name: string | undefined, config: MockServerConfig): {
+    table: string;
+    verb: CrudEventVerb;
+} | undefined;
+export declare function crudEventNames(config: MockServerConfig): string[];
 export declare function isDeleteEventName(name: string): boolean;
 export declare function inferEventTable(eventName: string | undefined, tableNames: string[]): string | undefined;
 export interface EventTarget {

package/dist/db/schema.js

@@ -5,18 +5,29 @@
 // existed, so a config that declares nothing keeps working.
 import { isLegacyFidelity } from "../protocol/fidelity.js";
 import { daoClassOf, titleCase } from "../protocol/fieldTypes.js";
+import { RECORD_FIELDS, RECORD_ID, TIMESTAMP } from "./identity.js";
 import { deriveFields } from "./metadata.js";
-function pkFieldsOf(def) {
+export function pkFieldsOf(def) {
     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) {
-    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) {
     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(field, table, notNullByDefault, generated) {
     return {
@@ -105,7 +116,10 @@ function pick(fields, names) {
         return field ? [field] : [];
     });
 }
-function isDeclared(source, config, store) {
+// 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, config, store) {
     const table = config.tables?.[source];
     if (table)
         return !!table.fields;
@@ -180,11 +194,59 @@ export function requestReplySchema(requestReply, config, store) {
         };
     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 = [
-    { 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) => [
+    ...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, config, store) {
+    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, config, store) {
+    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, config, store) {
+    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, store) {
     if (requestReply.requestFields)
@@ -249,7 +311,56 @@ export function projectRow(row, names) {
         return 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, fields) {
+    const prefix = `${table}_`;
+    const names = fields.map((field) => (field.startsWith(prefix) && field.slice(prefix.length)) || field);
+    return `${prefix}BY_${names.join('_')}`;
+}
+const sameFields = (a, b) => 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, def) {
+    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) {
+    const pkFields = pkFieldsOf(def);
+    return (def.indexes ?? []).filter((index) => index.unique && !sameFields(index.fields, pkFields));
+}
 // --- events ------------------------------------------------------------------
+export const CRUD_EVENT_VERBS = ['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, verb) {
+    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, config) {
+    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) {
+    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) {
@@ -278,20 +389,24 @@ export function inferEventTable(eventName, tableNames) {
     candidates.sort((a, b) => b.length - a.length);
     return candidates[0];
 }
-// 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, config, { bareTable = false } = {}) {
     if (!name)
         return undefined;
     const override = config.eventSchemas?.[name];
-    if (name.startsWith('EVENT_') && !override && !config.eventHandlers?.[name])
+    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/dist/db/store.d.ts

@@ -4,22 +4,28 @@ export declare class Store {
     private tables;
     private tableConfig;
     private sequenceCounters;
+    private autoIncrementCounters;
     private clock;
     private seedRows;
     private removedRows;
     readonly views: Map<string, ViewDef>;
-    registerTable(tableName: string, { pkField, sequencePrefix, sequenceWidth, sequenceFormat, rows }: TableDef): this;
+    registerTable(tableName: string, definition: TableDef): this;
+    private counterOf;
+    private countersFor;
+    private generatedNumber;
     registerView(viewName: string, definition: ViewDef): this;
     private stampSeedRow;
     private stampNewRow;
     private noteRemoved;
-    private observeSequenceValue;
+    private observeGeneratedValues;
     nextSequenceValue(sequencePrefix: string, width: number): string;
     private generateSequenceValue;
+    private generateValues;
     getAllRows(tableName: string): Row[];
     getRow(tableName: string, pk: Pk): Row | undefined;
     rowKey(tableName: string, row: Row): Pk;
     findRow(tableName: string, criteria: Row): Row | undefined;
+    withGeneratedValues(tableName: string, record: Row): Row;
     insertRow(tableName: string, record: Row): Row;
     updateRow(tableName: string, pk: Pk, patch: Row): Row | undefined;
     deleteRow(tableName: string, pk: Pk): boolean;

package/dist/db/store.js

@@ -1,6 +1,28 @@
 // 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 { RECORD_ID, RecordClock, recordKey, TIMESTAMP, withoutRecordFields } from "./identity.js";
+// 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, { sequencePrefix, generated = [] }) {
+    const generators = [];
+    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) => 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.
@@ -24,12 +46,11 @@ function escapeRegExp(text) {
     return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 // The counter inside a generated value, or undefined when the value isn't
-// one this table's sequence could have produced.
-function sequenceNumber(config, value) {
-    const prefix = config.sequencePrefix;
-    if (!prefix || typeof value !== 'string')
+// one a sequence with this prefix and format could have produced.
+function sequenceNumber(prefix, format, value) {
+    if (typeof value !== 'string')
         return undefined;
-    const digits = config.sequenceFormat === 'genesis'
+    const digits = format === 'genesis'
         ? new RegExp(`^(\\d+)${escapeRegExp(prefix)}${GENESIS_LOCATION}${GENESIS_SYSTEM}$`).exec(value)?.[1]
         : value.startsWith(prefix)
             ? value.slice(prefix.length)
@@ -40,15 +61,16 @@ function sequenceNumber(config, value) {
     return Number.isFinite(n) ? n : undefined;
 }
 // Counters are shared by tables using the same prefix in the same format.
-function counterKey(config) {
-    return config.sequenceFormat === 'genesis'
-        ? `${config.sequencePrefix}\u0000genesis`
-        : config.sequencePrefix;
+function counterKey(prefix, format) {
+    return format === 'genesis' ? `${prefix}\u0000genesis` : prefix;
 }
+// An AUTO_INCREMENT counter belongs to its table's field.
+const autoIncrementKey = (tableName, field) => `${tableName}\u0000${field}`;
 export class Store {
     tables = new Map();
     tableConfig = new Map();
     sequenceCounters = new Map();
+    autoIncrementCounters = new Map();
     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
@@ -61,9 +83,16 @@ export class Store {
     // for handlers that delete without ever broadcasting.
     removedRows = new Map();
     views = new Map();
-    registerTable(tableName, { pkField, sequencePrefix, sequenceWidth = 3, sequenceFormat = 'prefix', rows = [] }) {
+    registerTable(tableName, definition) {
+        const { pkField, sequencePrefix, sequenceWidth = 3, sequenceFormat = 'prefix', rows = [], } = definition;
         const pkFields = normalizePkFields(pkField);
-        const config = { pkFields, sequencePrefix, sequenceWidth, sequenceFormat };
+        const config = {
+            pkFields,
+            sequencePrefix,
+            sequenceWidth,
+            sequenceFormat,
+            generators: generatorsOf(pkFields, definition),
+        };
         const table = new Map();
         const seenIds = new Set();
         let restamped = 0;
@@ -81,18 +110,41 @@ export class Store {
         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();
+        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;
     }
+    counterOf(tableName, config, generator) {
+        return generator.kind === 'SEQUENCE'
+            ? counterKey(generator.prefix, config.sequenceFormat)
+            : autoIncrementKey(tableName, generator.field);
+    }
+    countersFor(generator) {
+        return generator.kind === 'SEQUENCE' ? this.sequenceCounters : this.autoIncrementCounters;
+    }
+    // The counter inside a value a generator could have produced.
+    generatedNumber(config, generator, value) {
+        if (generator.kind === 'SEQUENCE') {
+            return sequenceNumber(generator.prefix, config.sequenceFormat, value);
+        }
+        return typeof value === 'number' && Number.isSafeInteger(value) ? value : undefined;
+    }
     registerView(viewName, definition) {
         this.views.set(viewName, definition);
         return this;
@@ -144,35 +196,50 @@ 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).
-    observeSequenceValue(config, row) {
-        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).
+    observeGeneratedValues(tableName, config, row) {
+        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, width) {
         const n = this.sequenceCounters.get(sequencePrefix) ?? 1;
         this.sequenceCounters.set(sequencePrefix, n + 1);
         return `${sequencePrefix}${String(n).padStart(width, '0')}`;
     }
-    generateSequenceValue(config) {
+    generateSequenceValue(config, prefix) {
         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).
+    generateValues(tableName, config, row) {
+        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) {
         const table = this.tables.get(tableName);
@@ -214,26 +281,35 @@ 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, record) {
+        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, record) {
         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/dist/handlers/commitEvent.js

@@ -1,18 +1,29 @@
-import { nackPayload, warningPayload } from "../protocol/errors.js";
+import { NackError, nackPayload, warningPayload } from "../protocol/errors.js";
 import { isLegacyFidelity } from "../protocol/fidelity.js";
 import { ERROR_CODE, MESSAGE_TYPE } from "../protocol/messageTypes.js";
 import { resourceNotMappedNack } from "../protocol/msgNack.js";
+import { crudEventHandler } from "./crudEvents.js";
+import { validateEventMessage } from "./eventValidation.js";
+// The handler serving an event: an eventHandlers entry, else the generic CRUD
+// handler a table registers through TableDef.events, else
+// defaultEventHandler.
+function resolveEventHandler(eventName, config) {
+    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, connection, config, store, ctx) {
     const eventName = message.MESSAGE_TYPE;
     // 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:
     // real consumers (foundation-comms' kv.service, entity-management) match
@@ -34,14 +45,27 @@ export function handleCommitEvent(message, connection, config, store, ctx) {
             : resourceNotMappedNack(eventName));
         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,

package/dist/handlers/crudEvents.d.ts

@@ -0,0 +1,2 @@
+import type { EventHandler, MockServerConfig } from '../types.ts';
+export declare function crudEventHandler(eventName: string, config: MockServerConfig): EventHandler | undefined;