@genesislcap/mock-server 15.60.0 → 15.61.0

package/src/db/values.ts

@@ -0,0 +1,247 @@
+// 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.
+
+import type { GenesisFieldType } from '../types.ts';
+
+// 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: { type: string; scale?: number }): number | undefined {
+  return field.type === 'BIGDECIMAL' ? (field.scale ?? DEFAULT_BIGDECIMAL_SCALE) : undefined;
+}
+
+// What a value needs to be normalized or encoded: its type, and for a
+// BIGDECIMAL the scale (undefined: as many decimals as the value has).
+export interface ValueField {
+  name: string;
+  type: GenesisFieldType | string;
+  scale?: number;
+  values?: string[];
+}
+
+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: string): string {
+  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: unknown, scale?: number): string | undefined {
+  let text: string;
+  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: Array<string | undefined>): number | undefined {
+  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: string | undefined): number {
+  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: unknown): number | undefined {
+  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: string | undefined): number | undefined {
+  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: ValueField, value: unknown): unknown {
+  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: ValueField, value: unknown): unknown {
+  if (field.type !== 'ENUM' || !field.values?.length) return undefined;
+  if (value === undefined || value === null) return undefined;
+  return field.values.includes(value as string) ? 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: ValueField, value: unknown): unknown {
+  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: Record<string, any>, fields: ValueField[]): Record<string, any> {
+  let encoded: Record<string, any> | undefined;
+  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: ValueField[]): ValueField[] | undefined {
+  const found = fields.filter((field) => field.type === 'BIGDECIMAL');
+  return found.length > 0 ? found : undefined;
+}

package/src/handlers/commitEvent.ts

@@ -12,7 +12,7 @@ import type {
   MockServerConfig,
 } from '../types.ts';
 import { crudEventHandler } from './crudEvents.ts';
-import { validateEventMessage } from './eventValidation.ts';
+import { eventDetails, validateEventMessage } from './eventValidation.ts';
 
 export interface CommitEventCtx {
   broadcast: BroadcastFn;
@@ -173,8 +173,9 @@ export function handleCommitEvent(
     if (!legacy) transaction = openTransaction(store, ctx);
     const schemaErrors = legacy ? [] : validateEventMessage(message, connection, config, store);
     if (schemaErrors.length > 0) throw new NackError(schemaErrors);
+    const details = legacy ? (message.DETAILS ?? {}) : eventDetails(message, config, store);
     const result =
-      handler(message.DETAILS ?? {}, {
+      handler(details, {
         connection,
         store,
         message,

package/src/handlers/dataLogon.ts

@@ -1,7 +1,15 @@
-import { compileCriteria, criteriaFields, filterByCriteria } from '../db/criteria.ts';
-import { rowComparator } from '../db/ordering.ts';
-import { queryFieldNames, querySchema } from '../db/schema.ts';
+import {
+  compileCriteria,
+  criteriaCompileRefusal,
+  criteriaFields,
+  type CriteriaOptions,
+  filterByCriteria,
+} from '../db/criteria.ts';
+import { strictCriteriaRefusal } from '../db/criteriaDialect.ts';
+import { byRecordId, rowComparator } from '../db/ordering.ts';
+import { isDeclared, queryCriteriaTypes, queryFieldNames, querySchema } from '../db/schema.ts';
 import type { Store } from '../db/store.ts';
+import { bigDecimalFields, encodeRow } from '../db/values.ts';
 import type { Connection, Subscription } from '../protocol/connection.ts';
 import { isLegacyFidelity } from '../protocol/fidelity.ts';
 import { MESSAGE_TYPE, ERROR_CODE } from '../protocol/messageTypes.ts';
@@ -115,6 +123,62 @@ function indexComparator(index: IndexDef): (a: Row, b: Row) => number {
   return rowComparator(index.fields.map((field) => ({ field, descending: false })));
 }
 
+// The order a snapshot and its MORE_ROWS pages come in. With ORDER_BY, the
+// index ascending, and REVERSE flips it. Without one the dataserver reads its
+// primary index, RECORD_ID, newest first, and REVERSE alone gives oldest
+// first — the order the rows were written in (PrimaryKeyDispenser.kt
+// buildPrimaryRange: `if (reverse) Order.ASC else Order.DESC`, GSF v8.15.29).
+function snapshotOrder(index: IndexDef | undefined, reverse: boolean): (a: Row, b: Row) => number {
+  const ascending = index ? indexComparator(index) : byRecordId;
+  const flipped = index ? reverse : !reverse;
+  return flipped ? (a, b) => ascending(b, a) : ascending;
+}
+
+// Without ORDER_BY, the index a criteria makes the dataserver read through:
+// the query index whose leading fields the criteria uses most (the first such
+// one on a tie), or none (CriteriaFilterBuilder.findBestMatchingIndex with no
+// default index; QueryClientFactory.build adopts it as the client's index,
+// GSF v8.15.29). The rows then come in that index's order, as under ORDER_BY.
+function criteriaIndex(query: QueryDef, fields: string[]): IndexDef | undefined {
+  let best: IndexDef | undefined;
+  let bestCount = 0;
+  for (const index of query.indexes ?? []) {
+    const unmatched = index.fields.findIndex((field) => !fields.includes(field));
+    const count = unmatched < 0 ? index.fields.length : unmatched;
+    if (count > bestCount) [best, bestCount] = [index, count];
+  }
+  return best;
+}
+
+// A flag as GenesisSet.getBoolean reads it: true, or anything whose text is
+// "true" in any case (obj.toString().toBoolean()).
+function readBoolean(value: unknown): boolean {
+  return value === true || (value !== undefined && value !== null && /^true$/i.test(String(value)));
+}
+
+// How a query's rows go on the wire: each BIGDECIMAL column as a string with
+// its scale, as GSF's serializer writes a BigDecimal (db/values.ts).
+// undefined when the query has none — known without resolving the schema
+// for an undeclared source with no BIGDECIMAL fieldTypes or derived types.
+export function rowEncoder(
+  query: QueryDef,
+  config: MockServerConfig,
+  store: Store,
+): ((row: Row) => Row) | undefined {
+  const view = store.views.get(query.source) ?? config.views?.[query.source];
+  const overridden = [
+    ...Object.values(query.fieldTypes ?? {}),
+    ...Object.values(view?.derivedTypes ?? {}).map((entry) =>
+      typeof entry === 'string' ? entry : entry.type,
+    ),
+  ];
+  if (!isDeclared(query.source, config, store) && !overridden.includes('BIGDECIMAL')) {
+    return undefined;
+  }
+  const fields = bigDecimalFields(querySchema(query, config, store).fields);
+  return fields && ((row: Row) => encodeRow(row, fields));
+}
+
 // DATA_LOGON opens a persistent subscription keyed by SOURCE_REF: reply with
 // LOGON_ACK and the first page of the snapshot, then keep the SOURCE_REF
 // registered so MORE_ROWS can page the rest and later inserts/amends/deletes
@@ -160,13 +224,52 @@ export function handleDataLogon(
   // criteria may name and all a row carries; DETAILS.FIELDS narrows the rows.
   // Legacy subscriptions ignore all of it, and ORDER_BY, as 15.47 did.
   const exposed = queryFieldNames(query, config, store);
+  // Legacy subscriptions keep the store's insertion order.
   let compare: ((a: Row, b: Row) => number) | undefined;
-  let reverse = false;
+  // How the criteria reads the rows: by the fields' declared types, as GSF
+  // compiles it against its entity; legacy as up to 15.47.
+  const criteriaOptions: CriteriaOptions = legacy
+    ? { lenient: true }
+    : { types: queryCriteriaTypes(query, config, store) };
   if (!legacy) {
+    // ORDER_BY names one of the query's own indexes (QueryDef.indexes). GSF
+    // checks it before it looks at the criteria
+    // (ConnectionManager.verifyClientOptions, v8.15.29).
+    let index: IndexDef | undefined;
+    if (details.ORDER_BY) {
+      index = query.indexes?.find((candidate) => candidate.name === details.ORDER_BY);
+      if (!index) {
+        connection.reply(
+          message,
+          logonNack(
+            'INVALID_INDEX',
+            `No such index ${details.ORDER_BY} for dataserver query ${resourceName}`,
+          ),
+        );
+        return;
+      }
+    }
+    // GSF parses the criteria as Groovy first, validates it and compiles it,
+    // refusing one that fails with the message (CriteriaFilterBuilder
+    // getCriteriaFilter, v8.15.29): no subscription opens. Refused here: the
+    // syntax errors Groovy would report too, and this engine's own dialect —
+    // AND / OR / NOT, `<>`, a single `=`, dotted names, `$` in double quotes,
+    // calls off GSF's whitelists (db/criteriaDialect.ts). A criteria outside
+    // this engine's grammar that
+    // may well be valid Groovy still fails open below.
+    const refusal =
+      typeof criteria === 'string'
+        ? strictCriteriaRefusal(criteria, exposed && new Set(exposed), criteriaOptions.types)
+        : undefined;
+    if (refusal) {
+      connection.reply(message, logonNack('INVALID_CRITERIA', refusal));
+      return;
+    }
+    const parsedFields = criteriaFields(criteria);
     // The real dataserver lets a criteria read only the query's own fields
     // (QueryClientFactory.kt). Unknown columns are only checked when the
     // query's fields are known; an inferred query fails open as before.
-    const outside = exposed && criteriaFields(criteria)?.find((field) => !exposed.includes(field));
+    const outside = exposed && parsedFields?.find((field) => !exposed.includes(field));
     if (outside) {
       connection.reply(
         message,
@@ -177,22 +280,20 @@ export function handleDataLogon(
       );
       return;
     }
-    // ORDER_BY names one of the query's own indexes (QueryDef.indexes).
-    if (details.ORDER_BY) {
-      const index = query.indexes?.find((candidate) => candidate.name === details.ORDER_BY);
-      if (!index) {
-        connection.reply(
-          message,
-          logonNack(
-            'INVALID_INDEX',
-            `No such index ${details.ORDER_BY} for dataserver query ${resourceName}`,
-          ),
-        );
-        return;
-      }
-      compare = indexComparator(index);
-      reverse = details.REVERSE === true;
+    // Then GSF compiles it, refusing a call no overload of the function
+    // takes (db/criteria.ts criteriaCompileRefusal).
+    const uncompiled =
+      typeof criteria === 'string'
+        ? criteriaCompileRefusal(criteria, criteriaOptions.types)
+        : undefined;
+    if (uncompiled) {
+      connection.reply(message, logonNack('INVALID_CRITERIA', uncompiled));
+      return;
     }
+    compare = snapshotOrder(
+      index ?? criteriaIndex(query, parsedFields ?? []),
+      readBoolean(details.REVERSE),
+    );
   }
   // Order matters: the query's own filter (the where-clause equivalent) and
   // the user's row permissioning narrow the set BEFORE the client's
@@ -206,11 +307,8 @@ export function handleDataLogon(
   // The query's own filter is the where clause the index is built over, so
   // the count is taken after it — an assumption, as no recording covers it.
   const rowsCount = rows.length;
-  rows = filterByCriteria(rows, criteria);
-  if (compare) {
-    rows = [...rows].sort(compare);
-    if (reverse) rows.reverse();
-  }
+  rows = filterByCriteria(rows, criteria, criteriaOptions);
+  if (compare) rows = [...rows].sort(compare);
   // Permissioning is applied per row so the ROW_REF can still be computed from
   // the UNSTRIPPED row — pk fields may themselves be hidden from this user,
   // and a snapshot row with no ROW_REF can never be matched to the later
@@ -222,26 +320,23 @@ export function handleDataLogon(
   const fieldNames = legacy
     ? undefined
     : requestedFieldNames(details, query, exposed, config, store);
+  // A BigDecimal goes out as a string with its column's scale (db/values.ts).
+  const encode = legacy ? undefined : rowEncoder(query, config, store);
   const stampedRows: Row[] = [];
-  // Each sent-or-waiting row as stored, by pending key, for ORDER_BY's live
-  // INSERT placement below.
-  const rawRows = new Map<string, Row>();
   for (const row of rows) {
     const permitted = permittedQueryRow(row, query.auth, user, fieldNames);
     if (!permitted) continue;
     const rowRef = getRowRef(row);
-    const key = pendingKey(rowRef);
-    if (key !== undefined) rawRows.set(key, row);
-    stampedRows.push(
-      stampRow(dataserverRow(permitted, row, query.fields), rowRef, 'INSERT', legacy),
-    );
+    const sent = dataserverRow(permitted, row, query.fields);
+    stampedRows.push(stampRow(encode ? encode(sent) : sent, rowRef, 'INSERT', legacy));
   }
 
   const subscription: Subscription = {
     resourceName,
     getRowRef,
-    predicate: compileCriteria(criteria),
+    predicate: compileCriteria(criteria, criteriaOptions),
     sequenceId: 1,
+    ...(encode ? { encode } : {}),
   };
 
   if (legacy) {
@@ -260,6 +355,11 @@ export function handleDataLogon(
   // MAX_ROWS of them into `held`. Rows the view has no room for (past
   // MAX_VIEW) keep waiting, so MORE_ROWS stays true — as on the real server,
   // which then answers every MORE_ROWS with an empty {MORE_ROWS: true} page.
+  // A live INSERT is pushed straight away whatever the order, even when it
+  // sorts among the rows still waiting, and a later page doesn't repeat it:
+  // the real ClientIndex.processInsertUpdate sends it as soon as it arrives,
+  // and NextRowsStrategy skips rows the client index already holds (GSF
+  // v8.15.29). See server.ts trackClientView.
   const { maxRows, maxView } = pagingOptions(details);
   const tracked: Subscription = {
     ...subscription,
@@ -269,28 +369,6 @@ export function handleDataLogon(
     maxView,
     fieldNames,
   };
-  // Under ORDER_BY a live INSERT that sorts among the rows still waiting for
-  // MORE_ROWS joins them in order rather than being pushed out of order; one
-  // that sorts before them lands in what the client has, and is pushed. (A
-  // MODIFY of a waiting row keeps its place.)
-  if (compare) {
-    const ascending = compare;
-    const sortCompare = reverse ? (a: Row, b: Row) => ascending(b, a) : ascending;
-    tracked.queueInsert = (key, stamped, row) => {
-      const waiting = [...tracked.pending!];
-      const first = waiting[0] && rawRows.get(waiting[0][0]);
-      if (!first || sortCompare(row, first) < 0) return false;
-      const at = waiting.findIndex(([waitingKey]) => {
-        const other = rawRows.get(waitingKey);
-        return other !== undefined && sortCompare(row, other) < 0;
-      });
-      waiting.splice(at < 0 ? waiting.length : at, 0, [key, stamped]);
-      tracked.pending!.clear();
-      for (const [waitingKey, waitingRow] of waiting) tracked.pending!.set(waitingKey, waitingRow);
-      rawRows.set(key, row);
-      return true;
-    };
-  }
   const firstPage = takePage(tracked);
   const pending = tracked.pending!;
   connection.subscribe(sourceRef, tracked);

package/src/handlers/eventValidation.ts

@@ -1,9 +1,10 @@
-import { eventFields, isDeclared, resolveEventTarget } from '../db/schema.ts';
+import { eventFields, isDeclared, resolveEventTarget, type ResolvedField } from '../db/schema.ts';
 import type { Store } from '../db/store.ts';
+import { eventValue } from '../db/values.ts';
 import type { Connection } from '../protocol/connection.ts';
 import type { NackErrorInput } from '../protocol/errors.ts';
 import { schemaFieldErrors, validateSchema } from '../protocol/schemaValidation.ts';
-import type { GenesisMessage, MockServerConfig } from '../types.ts';
+import type { GenesisMessage, MockServerConfig, Row } from '../types.ts';
 import { eventInboundSchema } from './jsonSchema.ts';
 
 // The schema check every event goes through on the real server before its
@@ -24,20 +25,46 @@ export function validateEventMessage(
   store: Store,
 ): NackErrorInput[] {
   const name = message.MESSAGE_TYPE;
-  const target = resolveEventTarget(name, config);
-  if (!target) return [];
-  const declared =
-    target.kind === 'dto' ||
-    (target.table !== undefined && isDeclared(target.table, config, store));
+  const declared = declaredEvent(name, config, store);
   if (!declared) return [];
-  const inbound = eventInboundSchema(
-    name,
-    target,
-    eventFields(target, config, store),
-    config.appName,
-  );
+  const inbound = eventInboundSchema(name, declared.target, declared.fields, config.appName);
   // The router stamps the session's user on everything it forwards, so the
   // schema's required USER_NAME is always there by the time it is checked.
   const forwarded = { ...message, USER_NAME: connection.userName ?? '' };
   return schemaFieldErrors(validateSchema(inbound, forwarded));
 }
+
+// The event's target and DETAILS fields, when its DETAILS class is declared.
+function declaredEvent(
+  name: string,
+  config: MockServerConfig,
+  store: Store,
+):
+  | { target: NonNullable<ReturnType<typeof resolveEventTarget>>; fields: ResolvedField[] }
+  | undefined {
+  const target = resolveEventTarget(name, config);
+  if (!target) return undefined;
+  const declared =
+    target.kind === 'dto' ||
+    (target.table !== undefined && isDeclared(target.table, config, store));
+  return declared ? { target, fields: eventFields(target, config, store) } : undefined;
+}
+
+// DETAILS as the handler gets them, after the schema check: a declared
+// BigDecimal field's string is a number, as GSF hands its handler a
+// deserialized BigDecimal (db/values.ts eventValue). Anything else, and any
+// undeclared event's DETAILS, as sent.
+export function eventDetails(message: GenesisMessage, config: MockServerConfig, store: Store): Row {
+  const details: Row = message.DETAILS ?? {};
+  const declared = declaredEvent(message.MESSAGE_TYPE, config, store);
+  if (!declared) return details;
+  let converted: Row | undefined;
+  for (const field of declared.fields) {
+    if (!Object.hasOwn(details, field.name)) continue;
+    const value = eventValue(field, details[field.name]);
+    if (value === details[field.name]) continue;
+    converted ??= { ...details };
+    converted[field.name] = value;
+  }
+  return converted ?? details;
+}