@genesislcap/mock-server 15.51.1 → 15.53.0

package/src/db/criteria.ts

@@ -20,6 +20,19 @@ import type { Row } from '../types.ts';
 
 export type Predicate = (record: Row) => boolean;
 
+// A criteria this grammar can't parse: unbalanced parentheses, a missing
+// operand, text it can't tokenize. GSF fails to compile those too.
+export class CriteriaSyntaxError extends Error {
+  override name = 'CriteriaSyntaxError';
+}
+
+// A well-formed call to a function EXPR_FUNCTIONS doesn't have. It may well be
+// valid Groovy, so callers that refuse malformed criteria still fail open on
+// this one.
+export class UnsupportedCriteriaError extends Error {
+  override name = 'UnsupportedCriteriaError';
+}
+
 const TOKEN_RE =
   /\s*(&&|\|\||<=|>=|!=|<>|==|=|<|>|!|\(|\)|,|'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|-?\d+(?:\.\d+)?|[A-Za-z_][A-Za-z0-9_.]*)/g;
 
@@ -30,13 +43,13 @@ function tokenize(input: string): string[] {
   TOKEN_RE.lastIndex = 0;
   while ((match = TOKEN_RE.exec(input))) {
     if (match.index !== lastIndex) {
-      throw new Error(`Unable to tokenize criteria near: ${input.slice(lastIndex)}`);
+      throw new CriteriaSyntaxError(`Unable to tokenize criteria near: ${input.slice(lastIndex)}`);
     }
     tokens.push(match[1]);
     lastIndex = TOKEN_RE.lastIndex;
   }
   if (lastIndex !== input.length) {
-    throw new Error(`Unable to tokenize criteria near: ${input.slice(lastIndex)}`);
+    throw new CriteriaSyntaxError(`Unable to tokenize criteria near: ${input.slice(lastIndex)}`);
   }
   return tokens;
 }
@@ -58,7 +71,7 @@ const COMPARATORS = new Set(['==', '=', '!=', '<>', '<', '<=', '>', '>=']);
 // them makes every Expr.dateTimeIs* comparison silently false (date-filtered
 // grids render zero rows with no warning). Row values may already be epoch
 // millis (number) or an ISO string. Returns null if unparseable.
-function parseGenesisDateTime(value: unknown): number | null {
+export function parseGenesisDateTime(value: unknown): number | null {
   if (typeof value === 'number') return value;
   if (typeof value !== 'string') return null;
   const match = value.match(/^(\d{4})(\d{2})(\d{2})-(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?$/);
@@ -188,6 +201,9 @@ function compareByTime(
 class Parser {
   private tokens: string[];
   private pos = 0;
+  // Every field the expression reads: bare identifiers in comparisons, and
+  // function-call arguments and receivers.
+  readonly fields = new Set<string>();
 
   constructor(tokens: string[]) {
     this.tokens = tokens;
@@ -247,13 +263,14 @@ class Parser {
     if (this.peek() === '(') {
       this.next();
       const inner = this.parseExpression();
-      if (this.next() !== ')') throw new Error('Missing closing parenthesis in criteria');
+      if (this.next() !== ')')
+        throw new CriteriaSyntaxError('Missing closing parenthesis in criteria');
       return inner;
     }
 
     const leftToken = this.next();
     if (leftToken === undefined) {
-      throw new Error('Expected operand on the left side of comparison');
+      throw new CriteriaSyntaxError('Expected operand on the left side of comparison');
     }
 
     // Both function-call dialects arrive as one dotted token followed by '(':
@@ -265,14 +282,16 @@ class Parser {
 
     const op = this.peek();
     if (!op || !COMPARATORS.has(op)) {
-      throw new Error(`Expected comparator, got: ${op}`);
+      throw new CriteriaSyntaxError(`Expected comparator, got: ${op}`);
     }
     this.next();
     const rightToken = this.next();
     if (rightToken === undefined) {
-      throw new Error('Expected operand on the right side of comparison');
+      throw new CriteriaSyntaxError('Expected operand on the right side of comparison');
     }
 
+    this.noteField(leftToken);
+    this.noteField(rightToken);
     const resolveLeft = (record: Row) => this.resolveValue(leftToken, record);
     const resolveRight = (record: Row) => this.resolveValue(rightToken, record);
 
@@ -300,6 +319,10 @@ class Parser {
     };
   }
 
+  noteField(token: string): void {
+    if (parseLiteral(token) === undefined) this.fields.add(token);
+  }
+
   resolveValue(token: string, record: Row): unknown {
     const literal = parseLiteral(token);
     if (literal !== undefined) return literal;
@@ -311,16 +334,19 @@ class Parser {
     const args: string[] = [];
     if (this.peek() !== ')') {
       const arg = this.next();
-      if (arg === undefined) throw new Error(`Unterminated argument list in ${name}(...)`);
+      if (arg === undefined)
+        throw new CriteriaSyntaxError(`Unterminated argument list in ${name}(...)`);
       args.push(arg);
       while (this.peek() === ',') {
         this.next();
         const nextArg = this.next();
-        if (nextArg === undefined) throw new Error(`Unterminated argument list in ${name}(...)`);
+        if (nextArg === undefined)
+          throw new CriteriaSyntaxError(`Unterminated argument list in ${name}(...)`);
         args.push(nextArg);
       }
     }
-    if (this.next() !== ')') throw new Error(`Missing closing parenthesis in ${name}(...)`);
+    if (this.next() !== ')')
+      throw new CriteriaSyntaxError(`Missing closing parenthesis in ${name}(...)`);
 
     // 'Expr.<fn>(field, value)' passes args through as-is; the method-call
     // form '<FIELD>.<fn>(value)' makes the receiver field the implicit first
@@ -329,32 +355,46 @@ class Parser {
     const receiver = name.slice(0, dotIndex);
     const fnName = name.slice(dotIndex + 1);
     const handler = EXPR_FUNCTIONS[fnName];
-    if (!handler) throw new Error(`Unsupported criteria function: ${name}`);
+    if (!handler) throw new UnsupportedCriteriaError(`Unsupported criteria function: ${name}`);
     const allArgs = receiver === 'Expr' ? args : [receiver, ...args];
+    for (const arg of allArgs) this.noteField(arg);
 
     const resolve: ExprResolver = (token, record) => this.resolveValue(token, record);
     return (record: Row) => handler(record, allArgs, resolve);
   }
 }
 
-/** Compiles a CRITERIA_MATCH string into a predicate function(record) => boolean. */
-export function compileCriteria(criteria?: string | null): Predicate {
+export interface ParsedCriteria {
+  predicate: Predicate;
+  // Every field the expression reads.
+  fields: string[];
+}
+
+// Parses a CRITERIA_MATCH without failing open: throws CriteriaSyntaxError for
+// a malformed one and UnsupportedCriteriaError for a call to a function the
+// grammar doesn't have. A blank criteria matches everything.
+export function parseCriteria(criteria?: string | null): ParsedCriteria {
   if (!criteria || typeof criteria !== 'string' || criteria.trim() === '') {
-    return () => true;
+    return { predicate: () => true, fields: [] };
   }
+  const tokens = tokenize(criteria.trim());
+  const parser = new Parser(tokens);
+  const predicate = parser.parseExpression();
+  if (parser.position !== tokens.length) {
+    throw new CriteriaSyntaxError(`Unexpected trailing tokens in criteria: ${criteria}`);
+  }
+  return { predicate, fields: [...parser.fields] };
+}
+
+/** Compiles a CRITERIA_MATCH string into a predicate function(record) => boolean. */
+export function compileCriteria(criteria?: string | null): Predicate {
   // Real Genesis clients can emit CRITERIA_MATCH syntax this grammar doesn't
   // cover yet (e.g. function-call criteria like Expr.dateTimeIsGreaterEqual(...)
   // from date-range filters). Failing open — matching everything and logging —
   // keeps DATA_LOGON/broadcast working (unfiltered) instead of crashing the
   // handler and leaving the client's grid stuck on "Loading...".
   try {
-    const tokens = tokenize(criteria.trim());
-    const parser = new Parser(tokens);
-    const predicate = parser.parseExpression();
-    if (parser.position !== tokens.length) {
-      throw new Error(`Unexpected trailing tokens in criteria: ${criteria}`);
-    }
-    return predicate;
+    return parseCriteria(criteria).predicate;
   } catch (error) {
     console.warn(
       `[mock-server] Unsupported CRITERIA_MATCH syntax, ignoring filter: ${criteria}`,
@@ -364,6 +404,17 @@ export function compileCriteria(criteria?: string | null): Predicate {
   }
 }
 
+// The fields a CRITERIA_MATCH reads, or undefined when it doesn't parse
+// (compileCriteria then fails open). The real dataserver refuses a criteria
+// naming a field its query doesn't expose (INVALID_CRITERIA).
+export function criteriaFields(criteria?: string | null): string[] | undefined {
+  try {
+    return parseCriteria(criteria).fields;
+  } catch {
+    return undefined;
+  }
+}
+
 export function filterByCriteria(rows: Row[], criteria?: string | null): Row[] {
   const predicate = compileCriteria(criteria);
   return rows.filter((row) => {

package/src/db/identity.ts

@@ -0,0 +1,53 @@
+// Record identity: the RECORD_ID and TIMESTAMP every Genesis table row carries.
+//
+// GSF sets TIMESTAMP from a high-resolution clock on every write and
+// RECORD_ID = TIMESTAMP on insert (genesis-db InsertOperation.kt); a modify
+// moves TIMESTAMP on and keeps RECORD_ID. The real values are around 7.5e18:
+// epoch millis shifted left 22 bits, plus a counter. That is far above 2^53,
+// so a JavaScript client's JSON.parse rounds neighbouring rows onto the same
+// number. The mock deliberately stays below that: its stamps are a counter
+// seeded from epoch millis that only goes up, so they stay exact, strictly
+// increasing safe integers, and a client that reads TIMESTAMP as a date (the
+// AI assistant shows a NANO_TIMESTAMP as epoch millis) still gets roughly the
+// write time. The same order, a different magnitude.
+
+import type { Row } from '../types.ts';
+
+export const RECORD_ID = 'RECORD_ID';
+export const TIMESTAMP = 'TIMESTAMP';
+export const RECORD_FIELDS: readonly string[] = [RECORD_ID, TIMESTAMP];
+
+// Hands out RECORD_ID/TIMESTAMP values: the current epoch millis, or one more
+// than the last value when that is not ahead of it (seeding a thousand rows
+// runs the counter a second or so ahead of the clock).
+export class RecordClock {
+  private last = 0;
+
+  next(): number {
+    this.last = Math.max(Date.now(), this.last + 1);
+    return this.last;
+  }
+
+  // Keeps later stamps above a value a seed row brought with it.
+  observe(value: unknown): void {
+    if (typeof value === 'number' && Number.isSafeInteger(value) && value > this.last) {
+      this.last = value;
+    }
+  }
+}
+
+// A row without its record identity — what a dataserver sends (the real
+// dataserver never puts RECORD_ID or TIMESTAMP in a row, only
+// DETAILS.ROW_REF) and what field metadata is derived from.
+export function withoutRecordFields(row: Row): Row {
+  if (!(RECORD_ID in row) && !(TIMESTAMP in row)) return row;
+  const { [RECORD_ID]: _recordId, [TIMESTAMP]: _timestamp, ...rest } = row;
+  return rest;
+}
+
+// The Map key a record is tracked under. RECORD_IDs are numbers here, but a
+// seed may bring a recorded string, so they are compared as strings.
+export function recordKey(row: Row | undefined | null): string | undefined {
+  const id = row?.[RECORD_ID];
+  return id === undefined || id === null ? undefined : String(id);
+}

package/src/db/ordering.ts

@@ -0,0 +1,56 @@
+// Row ordering shared by the dataserver (DATA_LOGON ORDER_BY, an index name)
+// and request servers (REQ_ DETAILS.ORDER_BY, fields with a direction).
+
+import type { Row } from '../types.ts';
+import { RECORD_ID } from './identity.ts';
+
+// Nulls sort low (first ascending, last descending), as H2's default null
+// ordering does; numbers numerically, booleans false before true, anything
+// else by its string form (UTF-16 order, as Java's String.compareTo).
+export function compareValues(a: unknown, b: unknown): number {
+  if (a === b) return 0;
+  if (a === undefined || a === null) return -1;
+  if (b === undefined || b === null) return 1;
+  if (typeof a === 'number' && typeof b === 'number') return a - b;
+  if (typeof a === 'boolean' && typeof b === 'boolean') return a ? 1 : -1;
+  const [left, right] = [String(a), String(b)];
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+export interface OrderedField {
+  field: string;
+  descending: boolean;
+}
+
+// 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.
+export function rowComparator(fields: OrderedField[]): (a: Row, b: Row) => number {
+  return (a, b) => {
+    for (const { field, descending } of fields) {
+      const result = compareValues(a[field], b[field]);
+      if (result !== 0) return descending ? -result : result;
+    }
+    return compareValues(a[RECORD_ID], b[RECORD_ID]);
+  };
+}
+
+const ORDER_SEPARATOR = /\s*,\s*/;
+const ORDER_FIELD = /^([A-Za-z]\w+)(?:\s+(ASC|DESC))?$/i;
+
+// DETAILS.ORDER_BY as a request server reads it (OrderSpec.kt OrderedString,
+// GSF v8.15.29): comma-separated fields, each with an optional ASC or DESC in
+// any case. Throws GSF's IllegalArgumentException text for anything else,
+// which the request server answers as REQUEST_FAILED.
+export function parseOrderBy(orderBy: string): OrderedField[] {
+  return orderBy.split(ORDER_SEPARATOR).map((part) => {
+    const match = ORDER_FIELD.exec(part);
+    if (!match) {
+      throw new Error(
+        `${orderBy} is not a valid ORDER string, Fields should be comma separated, with followed ` +
+          "by an optional ASC or DESC. E.g. 'TRADER, TRADE_DATE DESC'",
+      );
+    }
+    return { field: match[1], descending: match[2]?.toUpperCase() === 'DESC' };
+  });
+}