@genesislcap/mock-server 15.60.0 → 15.62.0

package/dist/handlers/dataLogon.js

@@ -1,6 +1,8 @@
-import { compileCriteria, criteriaFields, filterByCriteria } from "../db/criteria.js";
-import { rowComparator } from "../db/ordering.js";
-import { queryFieldNames, querySchema } from "../db/schema.js";
+import { compileCriteria, criteriaCompileRefusal, criteriaFields, filterByCriteria, } from "../db/criteria.js";
+import { strictCriteriaRefusal } from "../db/criteriaDialect.js";
+import { byRecordId, rowComparator } from "../db/ordering.js";
+import { isDeclared, queryCriteriaTypes, queryFieldNames, querySchema } from "../db/schema.js";
+import { bigDecimalFields, encodeRow } from "../db/values.js";
 import { isLegacyFidelity } from "../protocol/fidelity.js";
 import { MESSAGE_TYPE, ERROR_CODE } from "../protocol/messageTypes.js";
 import { nonExistentSubscriptionNack, resourceNotMappedNack, subscriptionAlreadyExistsNack, } from "../protocol/msgNack.js";
@@ -87,6 +89,53 @@ function requestedFieldNames(details, query, exposed, config, store) {
 function indexComparator(index) {
     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, reverse) {
+    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, fields) {
+    let best;
+    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) {
+    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, config, store) {
+    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) => 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
@@ -121,27 +170,59 @@ export function handleDataLogon(message, connection, config, store) {
     // 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;
-    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 = 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;
+        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, logonNack('INVALID_CRITERIA', `GenericCriteriaValidationException : Criteria validation failed: Variable ${outside} is not allowed in criteria expression`));
             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
@@ -156,12 +237,9 @@ export function handleDataLogon(message, connection, config, store) {
     // 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 = filterByCriteria(rows, criteria, criteriaOptions);
+    if (compare)
         rows = [...rows].sort(compare);
-        if (reverse)
-            rows.reverse();
-    }
     // 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
@@ -172,25 +250,23 @@ export function handleDataLogon(message, connection, config, store) {
     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 = [];
-    // Each sent-or-waiting row as stored, by pending key, for ORDER_BY's live
-    // INSERT placement below.
-    const rawRows = new Map();
     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 = {
         resourceName,
         getRowRef,
-        predicate: compileCriteria(criteria),
+        predicate: compileCriteria(criteria, criteriaOptions),
         sequenceId: 1,
+        ...(encode ? { encode } : {}),
     };
     if (legacy) {
         connection.subscribe(sourceRef, subscription);
@@ -207,6 +283,11 @@ export function handleDataLogon(message, connection, config, store) {
     // 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,
@@ -216,30 +297,6 @@ export function handleDataLogon(message, connection, config, store) {
         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, b) => 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/dist/handlers/eventValidation.d.ts

@@ -1,5 +1,6 @@
 import type { Store } from '../db/store.ts';
 import type { Connection } from '../protocol/connection.ts';
 import type { NackErrorInput } from '../protocol/errors.ts';
-import type { GenesisMessage, MockServerConfig } from '../types.ts';
+import type { GenesisMessage, MockServerConfig, Row } from '../types.ts';
 export declare function validateEventMessage(message: GenesisMessage, connection: Connection, config: MockServerConfig, store: Store): NackErrorInput[];
+export declare function eventDetails(message: GenesisMessage, config: MockServerConfig, store: Store): Row;

package/dist/handlers/eventValidation.js

@@ -1,4 +1,5 @@
 import { eventFields, isDeclared, resolveEventTarget } from "../db/schema.js";
+import { eventValue } from "../db/values.js";
 import { schemaFieldErrors, validateSchema } from "../protocol/schemaValidation.js";
 import { eventInboundSchema } from "./jsonSchema.js";
 // The schema check every event goes through on the real server before its
@@ -14,16 +15,42 @@ import { eventInboundSchema } from "./jsonSchema.js";
 // real server accepts.
 export function validateEventMessage(message, connection, config, store) {
     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, config, store) {
+    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, config, store) {
+    const details = message.DETAILS ?? {};
+    const declared = declaredEvent(message.MESSAGE_TYPE, config, store);
+    if (!declared)
+        return details;
+    let converted;
+    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;
+}

package/dist/handlers/requestReply.js

@@ -14,10 +14,13 @@
 //   there are more rows.
 //
 // See the README's "Request servers" for every rule and its evidence.
-import { CriteriaSyntaxError, filterByCriteria, parseCriteria, parseGenesisDateTime, UnsupportedCriteriaError, } from "../db/criteria.js";
+import { criteriaCompileRefusal, CriteriaSyntaxError, filterByCriteria, parseCriteria, parseGenesisDateTime, UnsupportedCriteriaError, } from "../db/criteria.js";
+import { strictCriteriaRefusal } from "../db/criteriaDialect.js";
+import { checkGroovySyntax } from "../db/groovySyntax.js";
 import { withoutRecordFields } from "../db/identity.js";
 import { compareValues, parseOrderBy, rowComparator } from "../db/ordering.js";
 import { pkFieldsOf, primaryKeyIndexName, projectRow, requestReplyFieldNames, requestReplySourceSchema, } from "../db/schema.js";
+import { bigDecimalFields, decimalText, encodeRow } from "../db/values.js";
 import { ErrorCode, NackError, nackPayload } from "../protocol/errors.js";
 import { isLegacyFidelity } from "../protocol/fidelity.js";
 import { daoClassOf, viewEntityClassOf } from "../protocol/fieldTypes.js";
@@ -60,6 +63,9 @@ function sourceOf(requestReply, config, store) {
         name,
         fields: new Map(schema.fields.map((field) => [field.name, field])),
         pkFields: store.getPkFields(name),
+        ...(schema.declared
+            ? { types: new Map(schema.fields.map((field) => [field.name, field.type])) }
+            : {}),
     };
 }
 function isView(name, config, store) {
@@ -71,30 +77,48 @@ function parametricTypeOf(name, config, store) {
     return isView(name, config, store) ? viewEntityClassOf(name) : daoClassOf(name);
 }
 const byPrimaryKey = (source) => source.pkFields.map((field) => ({ field, descending: false }));
+// The REP_ rows as they go on the wire: each BigDecimal a string with its
+// column's scale, as GSF's serializer writes it (db/values.ts).
+function wireRows(rows, source) {
+    const fields = bigDecimalFields([...source.fields.values()]);
+    return fields ? rows.map((row) => encodeRow(row, fields)) : rows;
+}
 // CRITERIA_MATCH against the entity. A malformed one fails as `onSyntaxError`
-// says (the two server kinds differ). A criteria naming a field the entity
-// doesn't have matches nothing: GSF evaluates it outside the database, where
-// the unknown variable never compares true (recorded: REPLY: []). A call to a
-// function this grammar doesn't model may be valid Groovy, so it still fails
-// open (logged), as everywhere else in the engine.
+// says (the two server kinds differ): one Groovy refuses (db/groovySyntax.ts),
+// or one this grammar can't parse that the Groovy check can't vouch for
+// either. A criteria naming a field the entity doesn't have matches nothing:
+// GSF evaluates it outside the database, where the unknown variable never
+// compares true (recorded: REPLY: []). Valid Groovy this grammar doesn't model
+// (a bare boolean field, `in [...]`, a function it doesn't know) fails open
+// (logged), as everywhere else in the engine.
 function criteriaFilter(criteria, source, onSyntaxError) {
     if (criteria.trim() === '')
         return { kind: 'all' };
+    // What GSF can't compile: a syntax error Groovy reports, this engine's
+    // dialect (AND, OR, NOT, `<>`, `=`, a call off GSF's whitelist, ...), or a
+    // call no overload takes, with GSF's text.
+    const refusal = strictCriteriaRefusal(criteria, new Set(source.fields.keys()), source.types) ??
+        criteriaCompileRefusal(criteria, source.types);
+    if (refusal)
+        throw onSyntaxError(new CriteriaSyntaxError(refusal));
+    const groovy = checkGroovySyntax(criteria);
+    let parsed;
     try {
-        const { predicate, fields } = parseCriteria(criteria);
-        if (fields.some((field) => !source.fields.has(field)))
-            return { kind: 'none' };
-        return { kind: 'match', predicate };
+        parsed = parseCriteria(criteria, { types: source.types });
     }
     catch (error) {
-        if (error instanceof CriteriaSyntaxError)
+        if (error instanceof CriteriaSyntaxError && groovy.kind !== 'valid') {
             throw onSyntaxError(error);
-        if (error instanceof UnsupportedCriteriaError) {
+        }
+        if (error instanceof CriteriaSyntaxError || error instanceof UnsupportedCriteriaError) {
             console.warn(`[mock-server] Unsupported CRITERIA_MATCH syntax, ignoring filter: ${criteria}`, error);
             return { kind: 'all' };
         }
         throw error;
     }
+    if (parsed.fields.some((field) => !source.fields.has(field)))
+        return { kind: 'none' };
+    return { kind: 'match', predicate: parsed.predicate };
 }
 function applyCriteria(rows, filter) {
     if (filter.kind === 'all')
@@ -250,7 +274,7 @@ function criteriaOnlyReply(resourceName, requestReply, message, config, store, u
         page = pageOf(kept, maxRows, offset, readCount - 1, !byView);
     }
     return {
-        REPLY: page.rows,
+        REPLY: wireRows(page.rows, source),
         PARAMETRIC_TYPE: parametricTypeOf(source.name, config, store),
         MESSAGE_TYPE: `REP_${resourceName}`,
         ...(byView && page.rows.length > 0 ? { NEXT_VIEW: viewNumber + 1 } : {}),
@@ -300,10 +324,13 @@ function convertValue(value, field) {
     }
 }
 // What Kotlin's toString() makes of a row value, for wildcard matching: a
-// Double keeps its fraction ("2.0"), a date prints as ISO-8601, null is "null".
+// Double keeps its fraction ("2.0"), a BigDecimal its scale ("15.00000"), a
+// date prints as ISO-8601, null is "null".
 function kotlinString(value, field) {
     if (value === undefined || value === null)
         return 'null';
+    if (field?.type === 'BIGDECIMAL')
+        return decimalText(value, field.scale) ?? String(value);
     if (typeof value === 'number') {
         if ((field?.type === 'DATE' || field?.type === 'DATETIME') && Number.isFinite(value)) {
             return new Date(value).toISOString();
@@ -446,7 +473,7 @@ function plainReply(resourceName, requestReply, message, config, store, user) {
         MESSAGE_TYPE: `REP_${resourceName}`,
         SOURCE_REF: message.SOURCE_REF,
         PARAMETRIC_TYPE: parametricTypeOf(source.name, config, store),
-        REPLY: reply,
+        REPLY: wireRows(reply, source),
     };
 }
 // --- resolvers (custom request servers) -------------------------------------
@@ -548,7 +575,7 @@ function legacyRequestReply(resourceName, requestReply, message, connection, sto
             }
             const criteria = message.DETAILS?.CRITERIA_MATCH ?? message.CRITERIA_MATCH;
             if (criteria)
-                rows = filterByCriteria(rows, criteria);
+                rows = filterByCriteria(rows, criteria, { lenient: true });
             if (requestReply.filter)
                 rows = rows.filter(requestReply.filter);
         }

package/dist/index.d.ts

@@ -3,5 +3,5 @@ export { launchStack, type LaunchStackOptions, type LaunchedStack } from './laun
 export { Store } from './db/store.ts';
 export { RECORD_FIELDS, RECORD_ID, TIMESTAMP } from './db/identity.ts';
 export { ErrorCode, NackError, statusCodeFor, type ErrorCodeName, type GenesisErrorType, type NackErrorEntry, type NackErrorInput, type NackErrorOptions, } from './protocol/errors.ts';
-export { compileCriteria, filterByCriteria, type Predicate } from './db/criteria.ts';
+export { compileCriteria, type CriteriaOptions, filterByCriteria, type Predicate, } from './db/criteria.ts';
 export type { AntiJoinDef, AuthConfig, AuthUser, BroadcastFn, BroadcastTableChangeFn, CrudEventVerb, EventHandler, EventHandlerCtx, EventHandlerResult, EventSchemaOverride, FidelityMode, FieldDef, FieldMetadata, GeneratedFieldDef, GenesisFieldType, GenesisMessage, HttpRouteDef, IndexDef, JoinDef, JoinFieldLink, JoinLink, JoinType, JoinValueLink, MockServerConfig, OnMessageCtx, OnMessageHook, QueryDef, RequestingUser, RequestReplyDef, RequestReplyResolverCtx, ResourceAuthDef, ResourceItem, Row, SequenceFormat, SocketLike, SsoIdentityProvider, TableDef, ViewDef, ViewRowSources, } from './types.ts';

package/dist/index.js

@@ -3,4 +3,4 @@ export { launchStack } from "./launch.js";
 export { Store } from "./db/store.js";
 export { RECORD_FIELDS, RECORD_ID, TIMESTAMP } from "./db/identity.js";
 export { ErrorCode, NackError, statusCodeFor, } from "./protocol/errors.js";
-export { compileCriteria, filterByCriteria } from "./db/criteria.js";
+export { compileCriteria, filterByCriteria, } from "./db/criteria.js";

package/dist/protocol/connection.d.ts

@@ -10,7 +10,7 @@ export interface Subscription {
     maxRows?: number;
     maxView?: number;
     fieldNames?: string[];
-    queueInsert?: (key: string, stamped: Row, row: Row) => boolean;
+    encode?: (row: Row) => Row;
 }
 export declare class Connection {
     readonly ws: SocketLike;

package/dist/server.js

@@ -23,7 +23,9 @@ function sameValues(a, b) {
     return true;
 }
 export function createMockServer(config) {
-    const store = new Store();
+    // Declared columns are held by type (db/values.ts), except under
+    // fidelity: 'legacy', which keeps rows as given.
+    const store = new Store({ normalizeValues: () => !isLegacyFidelity(config) });
     for (const [tableName, tableDef] of Object.entries(config.tables ?? {})) {
         store.registerTable(tableName, tableDef);
     }
@@ -51,6 +53,12 @@ export function createMockServer(config) {
             return 'error';
         }
     }
+    // A row as one subscription sends it: its columns (dataserverRow), each
+    // BigDecimal a scaled string (Subscription.encode).
+    function wireRow(subscription, permitted, row) {
+        const sent = dataserverRow(permitted, row, config.queries?.[subscription.resourceName]?.fields);
+        return subscription.encode ? subscription.encode(sent) : sent;
+    }
     // The operation to push to one subscription, or null to skip it entirely.
     // A MODIFY that moved the row out of this subscription's CRITERIA_MATCH
     // becomes a DELETE so the client drops it rather than keeping a stale ghost
@@ -79,7 +87,10 @@ export function createMockServer(config) {
     // - A held row gets the MODIFY, or a DELETE when it is gone or out of scope.
     // - A row the client doesn't hold that is (now) in scope is pushed as an
     //   INSERT and becomes held: a brand-new row, or one a MODIFY brought back
-    //   into the criteria. Out of scope, the client is told nothing.
+    //   into the criteria. Out of scope, the client is told nothing. The
+    //   snapshot's order doesn't matter: a new row that sorts among the rows
+    //   still waiting is pushed now too, as GSF's client index does, and no
+    //   later page repeats it.
     // An INSERT is pushed even when the view already holds MAX_VIEW rows; the
     // real server would also evict the oldest row in the same frame (moving
     // view), which this engine doesn't, so the view can grow past MAX_VIEW.
@@ -97,7 +108,7 @@ export function createMockServer(config) {
             : permittedQueryRow(row, query?.auth, requestingUser(connection), subscription.fieldNames);
         if (pending.has(key)) {
             if (permitted)
-                pending.set(key, stampRow(dataserverRow(permitted, row, query?.fields), rowRef, 'INSERT'));
+                pending.set(key, stampRow(wireRow(subscription, permitted, row), rowRef, 'INSERT'));
             else
                 pending.delete(key);
             return null;
@@ -110,10 +121,6 @@ export function createMockServer(config) {
         }
         if (!permitted)
             return null;
-        // Under ORDER_BY, a new row that sorts among the waiting ones waits too,
-        // so MORE_ROWS pages stay in order.
-        if (subscription.queueInsert?.(key, stampRow(dataserverRow(permitted, row, query?.fields), rowRef, 'INSERT'), row))
-            return null;
         held.add(key);
         return 'INSERT';
     }
@@ -165,7 +172,7 @@ export function createMockServer(config) {
                     const permitted = permittedQueryRow(row, query?.auth, requestingUser(connection), subscription.fieldNames);
                     if (!permitted)
                         continue;
-                    outRow = dataserverRow(permitted, row, query?.fields);
+                    outRow = wireRow(subscription, permitted, row);
                 }
                 subscription.sequenceId += 1;
                 // A live push carries neither MORE_ROWS nor ROWS_COUNT on the real

package/dist/types.d.ts

@@ -16,6 +16,7 @@ export interface FieldDef {
     values?: string[];
     default?: unknown;
     maxSize?: number;
+    scale?: number;
     minLength?: number;
     description?: string;
     title?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genesislcap/mock-server",
-  "version": "15.60.0",
+  "version": "15.62.0",
   "description": "Reusable in-memory Genesis WebSocket protocol mock server for client automation/CI, without a JVM or database.",
   "type": "module",
   "main": "dist/index.js",