@genesislcap/mock-server 15.59.0 → 15.61.0

package/dist/db/ordering.js

@@ -1,5 +1,6 @@
-// Row ordering shared by the dataserver (DATA_LOGON ORDER_BY, an index name)
-// and request servers (REQ_ DETAILS.ORDER_BY, fields with a direction).
+// Row ordering shared by the dataserver (DATA_LOGON ORDER_BY, an index name;
+// without one, RECORD_ID) and request servers (REQ_ DETAILS.ORDER_BY, fields
+// with a direction).
 import { RECORD_ID } from "./identity.js";
 // Nulls sort low (first ascending, last descending), as H2's default null
 // ordering does; numbers numerically, booleans false before true, anything
@@ -18,6 +19,26 @@ export function compareValues(a, b) {
     const [left, right] = [String(a), String(b)];
     return left < right ? -1 : left > right ? 1 : 0;
 }
+const INTEGER_TEXT = /^-?\d+$/;
+// RECORD_IDs compared as the integers they are: the engine's own stamps are
+// numbers, but a seed may bring the real server's ~7.5e18 ids as strings,
+// which neither a string nor a float comparison orders correctly. Anything
+// that isn't an integer falls back to compareValues.
+export function compareRecordIds(a, b) {
+    const asInteger = (value) => typeof value === 'number' && Number.isSafeInteger(value)
+        ? BigInt(value)
+        : typeof value === 'string' && INTEGER_TEXT.test(value)
+            ? BigInt(value)
+            : undefined;
+    const [left, right] = [asInteger(a), asInteger(b)];
+    if (left === undefined || right === undefined)
+        return compareValues(a, b);
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+// Oldest first: RECORD_ID ascending, the order rows were written in.
+export function byRecordId(a, b) {
+    return compareRecordIds(a[RECORD_ID], b[RECORD_ID]);
+}
 // Sorts by the fields in turn, then by RECORD_ID ascending: the tie-breaker
 // column GSF's SQL ordering always appends (GetByCriteriaOperation.kt,
 // tieBreakerColumn = "RECORD_ID", v8.15.29), whatever the direction.
@@ -28,7 +49,7 @@ export function rowComparator(fields) {
             if (result !== 0)
                 return descending ? -result : result;
         }
-        return compareValues(a[RECORD_ID], b[RECORD_ID]);
+        return byRecordId(a, b);
     };
 }
 const ORDER_SEPARATOR = /\s*,\s*/;

package/dist/db/schema.d.ts

@@ -9,6 +9,7 @@ export interface ResolvedField {
     default?: unknown;
     maxSize?: number;
     minLength?: number;
+    scale?: number;
     description?: string;
     title?: string;
     optional?: boolean;
@@ -26,6 +27,7 @@ export declare function resolveSourceSchema(source: string, config: MockServerCo
 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 queryCriteriaTypes(query: QueryDef, config: MockServerConfig, store: Store): Map<string, string>;
 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;

package/dist/db/schema.js

@@ -7,6 +7,7 @@ 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";
+import { columnScale } from "./values.js";
 import { planView } from "./views.js";
 export function pkFieldsOf(def) {
     return Array.isArray(def.pkField) ? def.pkField : [def.pkField];
@@ -40,6 +41,7 @@ function fromFieldDef(field, table, notNullByDefault, generated) {
         ...(field.default !== undefined ? { default: field.default } : {}),
         ...(field.maxSize !== undefined ? { maxSize: field.maxSize } : {}),
         ...(field.minLength !== undefined ? { minLength: field.minLength } : {}),
+        ...(field.scale !== undefined ? { scale: field.scale } : {}),
         ...(field.description !== undefined ? { description: field.description } : {}),
         ...(field.title !== undefined ? { title: field.title } : {}),
         ...(field.optional !== undefined ? { optional: field.optional } : {}),
@@ -49,7 +51,11 @@ function fromFieldDef(field, table, notNullByDefault, generated) {
 function declaredTableFields(tableName, def) {
     const pkFields = pkFieldsOf(def);
     const generated = generatedFieldsOf(def);
-    return (def.fields ?? []).map((field) => fromFieldDef(field, tableName, pkFields.includes(field.name) || generated.has(field.name), generated.has(field.name)));
+    return (def.fields ?? []).map((field) => {
+        const resolved = fromFieldDef(field, tableName, pkFields.includes(field.name) || generated.has(field.name), generated.has(field.name));
+        const scale = columnScale(field);
+        return scale === undefined ? resolved : { ...resolved, scale };
+    });
 }
 // Inference from rows: a type per column (metadata.ts), nothing nullable but
 // the key, no defaults or enum values (rows can't say).
@@ -170,13 +176,21 @@ export function resolveSourceSchema(source, config, store) {
         fields = pick(new Map(fields.map((field) => [field.name, field])), view.fields);
     return { fields, declared: false };
 }
-// fieldTypes overrides the TYPE of the named fields, declared or inferred.
+// fieldTypes overrides the TYPE of the named fields, declared or inferred. A
+// table column made a BIGDECIMAL takes the default scale, as every column of
+// that type has one (see db/values.ts).
 export function withTypeOverrides(schema, fieldTypes) {
     if (!fieldTypes)
         return schema;
     return {
         ...schema,
-        fields: schema.fields.map((field) => fieldTypes[field.name] ? { ...field, type: fieldTypes[field.name] } : field),
+        fields: schema.fields.map((field) => {
+            const type = fieldTypes[field.name];
+            if (!type)
+                return field;
+            const scale = field.table ? columnScale({ type, scale: field.scale }) : field.scale;
+            return { ...field, type, ...(scale !== undefined ? { scale } : {}) };
+        }),
     };
 }
 // A query's fields block: those fields only, in its order. Names the source
@@ -196,6 +210,23 @@ export function projectSchema(schema, names) {
 export function querySchema(query, config, store) {
     return projectSchema(withTypeOverrides(resolveSourceSchema(query.source, config, store), query.fieldTypes), isLegacyFidelity(config) ? undefined : query.fields);
 }
+// The Genesis type of each field a query's criteria may read, where it is
+// known — what GSF compiles a criteria against (criteria.ts): every column of
+// a declared source, else only the fields its fieldTypes, or its view's
+// derivedTypes, name. A type inferred from the rows is only a guess.
+export function queryCriteriaTypes(query, config, store) {
+    if (isDeclared(query.source, config, store)) {
+        return new Map(querySchema(query, config, store).fields.map((field) => [field.name, field.type]));
+    }
+    const types = new Map();
+    const derived = viewOf(query.source, config, store)?.derivedTypes ?? {};
+    for (const [name, entry] of Object.entries(derived)) {
+        types.set(name, typeof entry === 'string' ? entry : entry.type);
+    }
+    for (const [name, type] of Object.entries(query.fieldTypes ?? {}))
+        types.set(name, type);
+    return types;
+}
 // A resolver-only request server has no table: its fields come from the
 // def's metadataRows sample.
 export function requestReplySchema(requestReply, config, store) {

package/dist/db/store.d.ts

@@ -5,6 +5,9 @@ export interface ViewRowsSource {
     rowsOf?: (entry: PlannedJoin | PlannedAntiJoin) => Row[] | undefined;
 }
 type Pk = string;
+export interface StoreOptions {
+    normalizeValues?: () => boolean;
+}
 export declare class Store {
     private tables;
     private tableConfig;
@@ -16,6 +19,9 @@ export declare class Store {
     private previousRows;
     private savepoint;
     readonly views: Map<string, ViewDef>;
+    private readonly normalizeValues;
+    private readonly unlistedWarned;
+    constructor({ normalizeValues }?: StoreOptions);
     begin(): void;
     commit(): void;
     rollback(): void;
@@ -27,6 +33,7 @@ export declare class Store {
     private generatedNumber;
     registerView(viewName: string, definition: ViewDef): this;
     private stampSeedRow;
+    private withStoredValues;
     private stampNewRow;
     private noteRemoved;
     private notePrevious;

package/dist/db/store.js

@@ -1,6 +1,7 @@
 // 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";
+import { columnScale, storedValue, unlistedEnumValue } from "./values.js";
 import { materializeEntries, planView, } from "./views.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
@@ -97,6 +98,12 @@ export class Store {
     // as it was before.
     savepoint;
     views = new Map();
+    normalizeValues;
+    // ENUM values already warned about, as 'TABLE.FIELD=value'.
+    unlistedWarned = new Set();
+    constructor({ normalizeValues = () => true } = {}) {
+        this.normalizeValues = normalizeValues;
+    }
     // Opens a transaction: the commit-event path wraps every handler in one
     // (handlers/commitEvent.ts), so an event that NACKs leaves the tables as
     // they were, as a GSF event whose onValidate NACKs never reaches its
@@ -152,11 +159,26 @@ export class Store {
             sequenceWidth,
             sequenceFormat,
             generators: generatorsOf(pkFields, definition),
+            ...(definition.fields
+                ? {
+                    // Key columns stay as given: every lookup (getRow, updateRow,
+                    // broadcastTableChange) names a row by the key the caller has.
+                    columns: definition.fields
+                        .filter((field) => !pkFields.includes(field.name))
+                        .map((field) => ({
+                        name: field.name,
+                        type: field.type,
+                        scale: columnScale(field),
+                        values: field.values,
+                    })),
+                }
+                : {}),
         };
+        const seeded = rows.map((row) => this.withStoredValues(tableName, config, { ...row }));
         const table = new Map();
         const seenIds = new Set();
         let restamped = 0;
-        for (const row of rows) {
+        for (const row of seeded) {
             const stamped = this.stampSeedRow({ ...row }, seenIds);
             if (stamped.restamped)
                 restamped += 1;
@@ -172,14 +194,14 @@ export class Store {
         this.savepoint?.delete(tableName);
         this.removedRows.delete(tableName);
         this.previousRows.delete(tableName);
-        this.seedRows.set(tableName, rows.map((row) => ({ ...row })));
+        this.seedRows.set(tableName, seeded.map((row) => ({ ...row })));
         // 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) {
+            for (const row of seeded) {
                 const n = this.generatedNumber(config, generator, row[generator.field]);
                 if (n !== undefined)
                     maxN = Math.max(maxN, n);
@@ -206,7 +228,10 @@ export class Store {
         if (generator.kind === 'SEQUENCE') {
             return sequenceNumber(generator.prefix, config.sequenceFormat, value);
         }
-        return typeof value === 'number' && Number.isSafeInteger(value) ? value : undefined;
+        // A key column keeps a seeded '2' as given, but the counter still has to
+        // start after it.
+        const number = typeof value === 'string' && /^\d+$/.test(value) ? Number(value) : value;
+        return typeof number === 'number' && Number.isSafeInteger(number) ? number : undefined;
     }
     // Throws on a join model GSF would refuse to compile (see planView).
     registerView(viewName, definition) {
@@ -238,6 +263,28 @@ export class Store {
         this.clock.observe(row[TIMESTAMP]);
         return { row, restamped: !missing && !keep };
     }
+    // Each declared column's value as the store holds it (db/values.ts
+    // storedValue): dates as epoch millis, BigDecimals rounded to their scale,
+    // numbers and booleans given as strings read as such. An ENUM value its
+    // field doesn't list is kept, with a warning (once per value): the real
+    // table could never hold it. Changes `row` in place and returns it.
+    withStoredValues(tableName, config, row) {
+        if (!config.columns || !this.normalizeValues())
+            return row;
+        for (const column of config.columns) {
+            if (!Object.hasOwn(row, column.name))
+                continue;
+            row[column.name] = storedValue(column, row[column.name]);
+            const unlisted = unlistedEnumValue(column, row[column.name]);
+            const warning = `${tableName}.${column.name}=${String(unlisted)}`;
+            if (unlisted === undefined || this.unlistedWarned.has(warning))
+                continue;
+            this.unlistedWarned.add(warning);
+            console.warn(`[mock-server] ${tableName}.${column.name}: ${JSON.stringify(unlisted)} is not one of ` +
+                `its ENUM values (${column.values.join(', ')})`);
+        }
+        return row;
+    }
     // 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) {
@@ -374,7 +421,8 @@ export class Store {
     }
     // 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
+    // supplied one, as GSF does; stamps RECORD_ID/TIMESTAMP. Declared columns
+    // are held by type (withStoredValues), as updateRow's patch is. 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).
@@ -384,7 +432,7 @@ export class Store {
         if (!table || !config)
             throw new Error(`Unknown table: ${tableName}`);
         this.save(tableName);
-        const row = { ...record };
+        const row = this.withStoredValues(tableName, config, { ...record });
         this.generateValues(tableName, config, row);
         const missing = config.pkFields.filter((field) => row[field] === undefined);
         if (missing.length > 0) {
@@ -409,7 +457,7 @@ export class Store {
         this.save(tableName);
         const existing = table.get(pk);
         this.notePrevious(tableName, existing);
-        const updated = { ...existing, ...patch };
+        const updated = { ...existing, ...this.withStoredValues(tableName, config, { ...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

package/dist/db/values.d.ts

@@ -0,0 +1,19 @@
+import type { GenesisFieldType } from '../types.ts';
+export declare const DEFAULT_BIGDECIMAL_SCALE = 5;
+export declare function columnScale(field: {
+    type: string;
+    scale?: number;
+}): number | undefined;
+export interface ValueField {
+    name: string;
+    type: GenesisFieldType | string;
+    scale?: number;
+    values?: string[];
+}
+export declare function decimalText(value: unknown, scale?: number): string | undefined;
+export declare function epochMillis(value: unknown): number | undefined;
+export declare function storedValue(field: ValueField, value: unknown): unknown;
+export declare function unlistedEnumValue(field: ValueField, value: unknown): unknown;
+export declare function eventValue(field: ValueField, value: unknown): unknown;
+export declare function encodeRow(row: Record<string, any>, fields: ValueField[]): Record<string, any>;
+export declare function bigDecimalFields(fields: ValueField[]): ValueField[] | undefined;

package/dist/db/values.js

@@ -0,0 +1,243 @@
+// Values by declared field type: what the store holds, and what goes on the
+// wire.
+//
+// GSF holds typed values (DateTime, BigDecimal, enums) and its serializer
+// writes a DateTime as epoch millis and a BigDecimal as a string,
+// `value.toPlainString()` (GenesisSetMaskingJsonSerializer.kt, GSF v8.15.29;
+// recorded: COMMISSION "15.00000"). On a SQL database a BIGDECIMAL column is
+// NUMERIC(precision, scale), (20, 5) unless the dictionary says otherwise
+// (BigDecimalSqlPrecisionConfig, SQLBaseTableGenerator.kt), so a value comes
+// back with exactly that many decimals; SendIt rounds a seed value to it
+// HALF_UP before writing (BigDecimalCsvTransformer.kt).
+//
+// The store holds a declared column's value the way JavaScript can compare
+// and compute with it: dates as epoch millis, BigDecimals as numbers rounded
+// to the column scale, numbers and booleans as such (a seed or a handler may
+// give them as strings). Criteria, ORDER_BY and derived fields therefore see
+// numbers, as GSF's typed values compare. A BigDecimal becomes the scaled
+// string only on the wire (encodeRow). Precision is a JavaScript number's:
+// about 15 significant digits.
+// BigDecimalSqlPrecisionConfig's default scale.
+export const DEFAULT_BIGDECIMAL_SCALE = 5;
+// The scale a table column's values are written with: a BIGDECIMAL's own,
+// else the default; undefined for any other type.
+export function columnScale(field) {
+    return field.type === 'BIGDECIMAL' ? (field.scale ?? DEFAULT_BIGDECIMAL_SCALE) : undefined;
+}
+const DECIMAL = /^([+-])?(\d*)(?:\.(\d*))?(?:[eE]([+-]?\d+))?$/;
+// Exponents past this are no number JavaScript holds; such a value is left
+// as given rather than spelled out digit by digit.
+const MAX_EXPONENT = 1000;
+// A decimal digit string plus one, carrying ('199' -> '200', '99' -> '100').
+function incremented(digits) {
+    const chars = digits.split('');
+    for (let at = chars.length - 1; at >= 0; at -= 1) {
+        if (chars[at] !== '9') {
+            chars[at] = String(Number(chars[at]) + 1);
+            return chars.join('');
+        }
+        chars[at] = '0';
+    }
+    return `1${chars.join('')}`;
+}
+// A number or numeric string as BigDecimal.toPlainString() writes it: no
+// exponent, and with `scale`, exactly that many decimals, rounded HALF_UP
+// (half away from zero) as setScale does. A number is read as its shortest
+// decimal form (String(n)), so 1.005 rounds to "1.01" as its literal would.
+// undefined for anything that isn't a finite decimal.
+export function decimalText(value, scale) {
+    let text;
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            return undefined;
+        text = String(value);
+    }
+    else if (typeof value === 'bigint') {
+        text = value.toString();
+    }
+    else if (typeof value === 'string') {
+        text = value.trim();
+    }
+    else {
+        return undefined;
+    }
+    const match = DECIMAL.exec(text);
+    if (!match)
+        return undefined;
+    const [, sign = '', whole = '', fraction = '', exponent = '0'] = match;
+    if (whole === '' && fraction === '')
+        return undefined;
+    if (Math.abs(Number(exponent)) > MAX_EXPONENT)
+        return undefined;
+    const digits = whole + fraction;
+    const point = whole.length + Number(exponent);
+    let integerPart = point <= 0
+        ? '0'
+        : digits
+            .slice(0, point)
+            .padEnd(point, '0')
+            .replace(/^0+(?=\d)/, '');
+    let fractionPart = point <= 0 ? '0'.repeat(-point) + digits : digits.slice(point);
+    if (integerPart === '')
+        integerPart = '0';
+    if (scale !== undefined) {
+        const roundUp = fractionPart.length > scale && fractionPart[scale] >= '5';
+        fractionPart = fractionPart.slice(0, scale).padEnd(scale, '0');
+        if (roundUp) {
+            const rounded = incremented(integerPart + fractionPart);
+            integerPart = rounded.slice(0, rounded.length - scale) || '0';
+            fractionPart = rounded.slice(rounded.length - scale);
+        }
+    }
+    const zero = /^0*$/.test(integerPart + fractionPart);
+    return `${sign === '-' && !zero ? '-' : ''}${integerPart}${fractionPart ? `.${fractionPart}` : ''}`;
+}
+const NUMERIC = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
+const INTEGER = /^[+-]?\d+$/;
+// yyyyMMdd; Genesis's yyyyMMdd-HH:mm[:ss[.SSS]]; ISO-8601 (a space for the T
+// too), the offset optional: without one it is UTC, not the machine's zone.
+const DAY = /^(\d{4})(\d{2})(\d{2})$/;
+const GENESIS_DATE_TIME = /^(\d{4})(\d{2})(\d{2})-(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?$/;
+const ISO_DATE_TIME = /^(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?)?(Z|[+-]\d{2}(?::?\d{2})?)?$/i;
+const MS_DIGITS = 3;
+// The matched parts utcMillis takes: year, month, day, hour, minute, second,
+// then the fraction; an ISO match has the offset after them.
+const FRACTION_PART = 6;
+const OFFSET_PART = FRACTION_PART + 2;
+const MINUTES_PER_HOUR = 60;
+const MS_PER_MINUTE = 60_000;
+// Epoch millis of a UTC date and time given as matched digits, or undefined
+// when a part is out of range (month 13, 30 February, 25:00 ...).
+function utcMillis(parts) {
+    const [year, month, day, hour = 0, minute = 0, second = 0] = parts
+        .slice(0, FRACTION_PART)
+        .map((part) => (part === undefined ? undefined : Number(part)));
+    const ms = Number((parts[FRACTION_PART] ?? '0').padEnd(MS_DIGITS, '0').slice(0, MS_DIGITS));
+    const time = Date.UTC(year, month - 1, day, hour, minute, second, ms);
+    const date = new Date(time);
+    const exact = date.getUTCFullYear() === year &&
+        date.getUTCMonth() === month - 1 &&
+        date.getUTCDate() === day &&
+        date.getUTCHours() === hour &&
+        date.getUTCMinutes() === minute &&
+        date.getUTCSeconds() === second;
+    return exact ? time : undefined;
+}
+// An ISO offset ('Z', '+01:00', '-0530', '+02') in minutes east of UTC.
+function offsetMinutes(offset) {
+    if (!offset || offset.toUpperCase() === 'Z')
+        return 0;
+    const digits = offset.slice(1).replace(':', '');
+    const minutes = Number(digits.slice(0, 2)) * MINUTES_PER_HOUR + Number(digits.slice(2) || '0');
+    return offset.startsWith('-') ? -minutes : minutes;
+}
+// A date as epoch millis: a number, a Date, an integer, yyyyMMdd, Genesis's
+// yyyyMMdd-HH:mm[:ss[.SSS]] or ISO-8601. undefined for anything else, or a
+// date that doesn't exist; nothing is guessed (no Date.parse).
+export function epochMillis(value) {
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : undefined;
+    if (value instanceof Date) {
+        const time = value.getTime();
+        return Number.isNaN(time) ? undefined : time;
+    }
+    if (typeof value !== 'string')
+        return undefined;
+    const text = value.trim();
+    // Eight digits are a day (yyyyMMdd), not a moment in January 1970.
+    const day = DAY.exec(text);
+    if (day)
+        return utcMillis(day.slice(1));
+    if (INTEGER.test(text)) {
+        const millis = Number(text);
+        return Number.isSafeInteger(millis) ? millis : undefined;
+    }
+    const genesis = GENESIS_DATE_TIME.exec(text);
+    if (genesis)
+        return utcMillis(genesis.slice(1));
+    const iso = ISO_DATE_TIME.exec(text);
+    if (!iso)
+        return undefined;
+    const time = utcMillis(iso.slice(1, OFFSET_PART));
+    return time === undefined ? undefined : time - offsetMinutes(iso[OFFSET_PART]) * MS_PER_MINUTE;
+}
+const INTEGER_TYPES = new Set(['INT', 'SHORT', 'LONG', 'NANO_TIMESTAMP']);
+const DATE_TYPES = new Set(['DATE', 'DATETIME']);
+// A finite number from decimal text, or undefined.
+function finite(text) {
+    if (text === undefined)
+        return undefined;
+    const number = Number(text);
+    return Number.isFinite(number) ? number : undefined;
+}
+// A value written to a declared column, as the store holds it (see the
+// header). A value that can't be read as its type is kept as given; an empty
+// string in a non-text column is null, as SendIt reads an empty cell.
+export function storedValue(field, value) {
+    if (value === undefined || value === null)
+        return value;
+    const { type } = field;
+    const textual = type === 'STRING' || type === 'ENUM' || type === 'RAW';
+    if (!textual && value === '')
+        return null;
+    if (type === 'BIGDECIMAL')
+        return finite(decimalText(value, field.scale)) ?? value;
+    if (DATE_TYPES.has(type))
+        return epochMillis(value) ?? value;
+    if (typeof value !== 'string')
+        return value;
+    // An integer beyond 2^53 has no exact number: it stays the string it was.
+    if (INTEGER_TYPES.has(type)) {
+        const number = INTEGER.test(value.trim()) ? Number(value) : undefined;
+        return number !== undefined && Number.isSafeInteger(number) ? number : value;
+    }
+    if (type === 'DOUBLE') {
+        return NUMERIC.test(value.trim()) ? (finite(value.trim()) ?? value) : value;
+    }
+    if (type === 'BOOLEAN') {
+        const lower = value.trim().toLowerCase();
+        return lower === 'true' ? true : lower === 'false' ? false : value;
+    }
+    return value;
+}
+// An ENUM value its field doesn't list, or undefined. A field with no
+// values accepts anything.
+export function unlistedEnumValue(field, value) {
+    if (field.type !== 'ENUM' || !field.values?.length)
+        return undefined;
+    if (value === undefined || value === null)
+        return undefined;
+    return field.values.includes(value) ? undefined : value;
+}
+// An event's BigDecimal DETAILS as the handler gets them: a number, as GSF
+// deserializes the schema's string into a BigDecimal (not rounded: the
+// column's scale applies when it is written).
+export function eventValue(field, value) {
+    if (field.type !== 'BIGDECIMAL' || typeof value !== 'string')
+        return value;
+    return finite(decimalText(value)) ?? value;
+}
+// A row as it goes on the wire: each BIGDECIMAL a string with its scale. The
+// row itself when nothing changes.
+export function encodeRow(row, fields) {
+    let encoded;
+    for (const field of fields) {
+        if (field.type !== 'BIGDECIMAL')
+            continue;
+        const value = row[field.name];
+        if (value === undefined || value === null)
+            continue;
+        const text = decimalText(value, field.scale);
+        if (text === undefined || text === value)
+            continue;
+        encoded ??= { ...row };
+        encoded[field.name] = text;
+    }
+    return encoded ?? row;
+}
+// The BIGDECIMAL fields among these, for encodeRow; undefined when there are
+// none, so a caller can skip encoding altogether.
+export function bigDecimalFields(fields) {
+    const found = fields.filter((field) => field.type === 'BIGDECIMAL');
+    return found.length > 0 ? found : undefined;
+}

package/dist/handlers/commitEvent.js

@@ -3,7 +3,7 @@ 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";
+import { eventDetails, 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.
@@ -123,7 +123,8 @@ export function handleCommitEvent(message, connection, config, store, ctx) {
         const schemaErrors = legacy ? [] : validateEventMessage(message, connection, config, store);
         if (schemaErrors.length > 0)
             throw new NackError(schemaErrors);
-        const result = handler(message.DETAILS ?? {}, {
+        const details = legacy ? (message.DETAILS ?? {}) : eventDetails(message, config, store);
+        const result = handler(details, {
             connection,
             store,
             message,

package/dist/handlers/dataLogon.d.ts

@@ -1,11 +1,12 @@
 import type { Store } from '../db/store.ts';
 import type { Connection } from '../protocol/connection.ts';
-import type { GenesisMessage, MockServerConfig, Row } from '../types.ts';
+import type { GenesisMessage, MockServerConfig, QueryDef, Row } from '../types.ts';
 export declare function pagingOptions(details: Row): {
     maxRows: number;
     maxView: number;
 };
 export declare function pendingKey(rowRef: unknown): string | undefined;
+export declare function rowEncoder(query: QueryDef, config: MockServerConfig, store: Store): ((row: Row) => Row) | undefined;
 export declare function handleDataLogon(message: GenesisMessage, connection: Connection, config: MockServerConfig, store: Store): void;
 export declare function handleMoreRows(message: GenesisMessage, connection: Connection, config: MockServerConfig): void;
 export declare function handleDataLogoff(message: GenesisMessage, connection: Connection, config: MockServerConfig): void;