@genesislcap/mock-server 15.51.1 → 15.53.0

package/dist/db/store.js

@@ -1,9 +1,39 @@
 // 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.
 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) {
     return Array.isArray(pkField) ? pkField : [pkField];
 }
@@ -12,66 +42,205 @@ function keyFor(pkFields, row) {
         return row[pkFields[0]];
     return pkFields.map((field) => String(row[field])).join(COMPOSITE_KEY_SEPARATOR);
 }
+function escapeRegExp(text) {
+    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, format, value) {
+    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, 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
     // collapse a resource's schema to zero fields.
     seedRows = new Map();
+    // 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.
+    removedRows = new Map();
     views = new Map();
-    registerTable(tableName, { pkField, sequencePrefix, sequenceWidth = 3, rows = [] }) {
+    registerTable(tableName, definition) {
+        const { pkField, sequencePrefix, sequenceWidth = 3, sequenceFormat = 'prefix', rows = [], } = definition;
         const pkFields = normalizePkFields(pkField);
+        const config = {
+            pkFields,
+            sequencePrefix,
+            sequenceWidth,
+            sequenceFormat,
+            generators: generatorsOf(pkFields, definition),
+        };
         const table = new Map();
+        const seenIds = new Set();
+        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();
+        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;
     }
+    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;
     }
-    // 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 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.
+    stampSeedRow(row, seenIds) {
+        const given = row[RECORD_ID];
+        const usable = (value) => (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.
+    stampNewRow(row) {
+        delete row[RECORD_ID];
+        delete row[TIMESTAMP];
+        const stamp = this.clock.next();
+        row[RECORD_ID] = stamp;
+        row[TIMESTAMP] = stamp;
+        return row;
+    }
+    noteRemoved(tableName, key, row) {
+        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).
+    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, prefix) {
+        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).
+    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);
         if (!table)
@@ -112,56 +281,105 @@ 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, 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 &&
-            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, pk, patch) {
         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)
+        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, pk) {
         const table = this.tables.get(tableName);
-        if (!table)
+        const existing = table?.get(pk);
+        if (!table || !existing)
             return false;
-        return table.delete(pk);
+        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, key) {
+        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, 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) {
+    // 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, tables = {}) {
         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));
     }
     materializeView(view, getRows) {
         let rows = getRows(view.base).map((row) => ({ ...row }));
@@ -214,14 +432,17 @@ 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) {
         const live = this.getResourceRows(resourceName);
         if (live.length > 0)
-            return live;
+            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.
     getPkFields(resourceName) {
@@ -233,17 +454,46 @@ 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, row) {
         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, row) {
+        const id = recordKey(row) ?? recordKey(this.findStoredRecord(resourceName, row));
+        return id ?? this.getRowRef(resourceName, row);
+    }
+    locateRecord(resourceName, row) {
+        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.
+    findStoredRecord(resourceName, row) {
+        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, key) {
         const pkFields = this.getPkFields(resourceName);
         if (pkFields.length <= 1)

package/dist/handlers/commitEvent.js

@@ -1,17 +1,29 @@
-import { NackError } 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, 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
@@ -33,17 +45,43 @@ 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 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.message }];
-        connection.reply(message, { MESSAGE_TYPE: MESSAGE_TYPE.EVENT_NACK, ERROR: errors });
+        connection.reply(message, {
+            MESSAGE_TYPE: MESSAGE_TYPE.EVENT_NACK,
+            ...nackPayload(error, legacy),
+        });
     }
 }

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;