@genesislcap/mock-server 15.59.0 → 15.61.0

package/src/handlers/requestReply.ts

@@ -16,13 +16,17 @@
 // See the README's "Request servers" for every rule and its evidence.
 
 import {
+  criteriaCompileRefusal,
   CriteriaSyntaxError,
   filterByCriteria,
   parseCriteria,
   parseGenesisDateTime,
   UnsupportedCriteriaError,
+  type ParsedCriteria,
   type Predicate,
 } from '../db/criteria.ts';
+import { strictCriteriaRefusal } from '../db/criteriaDialect.ts';
+import { checkGroovySyntax } from '../db/groovySyntax.ts';
 import { withoutRecordFields } from '../db/identity.ts';
 import { compareValues, parseOrderBy, rowComparator, type OrderedField } from '../db/ordering.ts';
 import {
@@ -34,6 +38,7 @@ import {
   type ResolvedField,
 } from '../db/schema.ts';
 import type { Store } from '../db/store.ts';
+import { bigDecimalFields, decimalText, encodeRow } from '../db/values.ts';
 import type { Connection } from '../protocol/connection.ts';
 import { ErrorCode, NackError, nackPayload } from '../protocol/errors.ts';
 import { isLegacyFidelity } from '../protocol/fidelity.ts';
@@ -92,6 +97,9 @@ interface Source {
   // Every field the entity has (its columns, RECORD_ID and TIMESTAMP), by name.
   fields: Map<string, ResolvedField>;
   pkFields: string[];
+  // Each field's Genesis type when the source declares its fields: what GSF
+  // compiles a criteria against (db/criteria.ts).
+  types?: Map<string, string>;
 }
 
 function sourceOf(requestReply: RequestReplyDef, config: MockServerConfig, store: Store): Source {
@@ -101,6 +109,9 @@ function sourceOf(requestReply: RequestReplyDef, config: MockServerConfig, 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])) }
+      : {}),
   };
 }
 
@@ -117,29 +128,47 @@ function parametricTypeOf(name: string, config: MockServerConfig, store: Store):
 const byPrimaryKey = (source: Source): OrderedField[] =>
   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: Row[], source: Source): Row[] {
+  const fields = bigDecimalFields([...source.fields.values()]);
+  return fields ? rows.map((row) => encodeRow(row, fields)) : rows;
+}
+
 // --- criteria ----------------------------------------------------------------
 
 type CriteriaFilter = { kind: 'all' } | { kind: 'none' } | { kind: 'match'; predicate: Predicate };
 
 // 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: string,
   source: Source,
   onSyntaxError: (error: CriteriaSyntaxError) => Error,
 ): CriteriaFilter {
   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: ParsedCriteria;
   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) throw onSyntaxError(error);
-    if (error instanceof UnsupportedCriteriaError) {
+    if (error instanceof CriteriaSyntaxError && groovy.kind !== 'valid') {
+      throw onSyntaxError(error);
+    }
+    if (error instanceof CriteriaSyntaxError || error instanceof UnsupportedCriteriaError) {
       console.warn(
         `[mock-server] Unsupported CRITERIA_MATCH syntax, ignoring filter: ${criteria}`,
         error,
@@ -148,6 +177,8 @@ function criteriaFilter(
     }
     throw error;
   }
+  if (parsed.fields.some((field) => !source.fields.has(field))) return { kind: 'none' };
+  return { kind: 'match', predicate: parsed.predicate };
 }
 
 function applyCriteria(rows: Row[], filter: CriteriaFilter): Row[] {
@@ -338,7 +369,7 @@ function criteriaOnlyReply(
   }
 
   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 } : {}),
@@ -389,9 +420,11 @@ function convertValue(value: unknown, field: ResolvedField): unknown {
 }
 
 // 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: unknown, field: ResolvedField | undefined): string {
   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();
@@ -538,7 +571,7 @@ function plainReply(
     MESSAGE_TYPE: `REP_${resourceName}`,
     SOURCE_REF: message.SOURCE_REF,
     PARAMETRIC_TYPE: parametricTypeOf(source.name, config, store),
-    REPLY: reply,
+    REPLY: wireRows(reply, source),
   };
 }
 
@@ -667,7 +700,7 @@ function legacyRequestReply(
         rows = rows.filter((row) => matchesLegacyRequestFields(row, request));
       }
       const criteria = message.DETAILS?.CRITERIA_MATCH ?? message.CRITERIA_MATCH;
-      if (criteria) rows = filterByCriteria(rows, criteria);
+      if (criteria) rows = filterByCriteria(rows, criteria, { lenient: true });
       if (requestReply.filter) rows = rows.filter(requestReply.filter);
     }
     rows = applyResourceAuth(rows, requestReply.auth, user).map(withoutRecordFields);

package/src/index.ts

@@ -12,7 +12,12 @@ export {
   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,

package/src/protocol/connection.ts

@@ -31,10 +31,9 @@ export interface Subscription {
   // The columns this subscription's rows carry (the query's fields block or
   // declared columns, narrowed by DETAILS.FIELDS); undefined: rows as stored.
   fieldNames?: string[];
-  // Set under ORDER_BY: offered every live INSERT (stamped, and the raw
-  // row). Returns true when the row sorts among the rows still waiting for
-  // MORE_ROWS, and so was queued there in order instead of being pushed.
-  queueInsert?: (key: string, stamped: Row, row: Row) => boolean;
+  // Turns a row into its wire form (BigDecimals as scaled strings); unset
+  // when the query has nothing to encode, and under fidelity: 'legacy'.
+  encode?: (row: Row) => Row;
 }
 
 // Wraps one WebSocket client connection: auth state and its live DATA_LOGON

package/src/server.ts

@@ -82,7 +82,9 @@ export interface MockServer {
 }
 
 export function createMockServer(config: MockServerConfig): MockServer {
-  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);
   }
@@ -119,6 +121,13 @@ export function createMockServer(config: MockServerConfig): MockServer {
     }
   }
 
+  // A row as one subscription sends it: its columns (dataserverRow), each
+  // BigDecimal a scaled string (Subscription.encode).
+  function wireRow(subscription: Subscription, permitted: Row, row: Row): 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
@@ -150,7 +159,10 @@ export function createMockServer(config: MockServerConfig): MockServer {
   // - 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.
@@ -175,7 +187,7 @@ export function createMockServer(config: MockServerConfig): MockServer {
         : 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;
     }
@@ -185,17 +197,6 @@ export function createMockServer(config: MockServerConfig): MockServer {
       return 'DELETE';
     }
     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';
   }
@@ -251,7 +252,7 @@ export function createMockServer(config: MockServerConfig): MockServer {
             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/src/types.ts

@@ -47,6 +47,13 @@ export interface FieldDef {
   default?: unknown;
   // STRING column size (`STRING(100)`): MAX_LENGTH / maxLength.
   maxSize?: number;
+  // A BIGDECIMAL column's scale (`BIGDECIMAL(20, 2)` in the dictionary):
+  // values are rounded HALF_UP to it when written and sent as strings with
+  // exactly that many decimals ("15.00000"). Default 5, GSF's SQL default
+  // (BigDecimalSqlPrecisionConfig). A view's derived BIGDECIMAL has no column
+  // and goes out with its own decimals unless this says otherwise. See the
+  // README's "Value encoding".
+  scale?: number;
   // `metadata { minLength = 0 }`: MIN_LENGTH / minLength.
   minLength?: number;
   // Replaces the DESCRIPTION / description the real server fills with the