@genesislcap/mock-server 15.51.1 → 15.53.0

package/dist/db/criteria.js

@@ -15,6 +15,17 @@
 // Deliberately NOT eval()/new Function() — this parses a small typed grammar
 // so a malformed or hostile criteria string can only fail to parse, never
 // execute arbitrary JS.
+// 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 {
+    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 {
+    name = 'UnsupportedCriteriaError';
+}
 const TOKEN_RE = /\s*(&&|\|\||<=|>=|!=|<>|==|=|<|>|!|\(|\)|,|'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|-?\d+(?:\.\d+)?|[A-Za-z_][A-Za-z0-9_.]*)/g;
 function tokenize(input) {
     const tokens = [];
@@ -23,13 +34,13 @@ function tokenize(input) {
     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;
 }
@@ -53,7 +64,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) {
+export function parseGenesisDateTime(value) {
     if (typeof value === 'number')
         return value;
     if (typeof value !== 'string')
@@ -154,6 +165,9 @@ function compareByTime(record, args, resolve, cmp) {
 class Parser {
     tokens;
     pos = 0;
+    // Every field the expression reads: bare identifiers in comparisons, and
+    // function-call arguments and receivers.
+    fields = new Set();
     constructor(tokens) {
         this.tokens = tokens;
     }
@@ -205,12 +219,12 @@ class Parser {
             this.next();
             const inner = this.parseExpression();
             if (this.next() !== ')')
-                throw new Error('Missing closing parenthesis in criteria');
+                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 '(':
         // 'Expr.containsIgnoreCase' (foundation-criteria) or
@@ -220,13 +234,15 @@ 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) => this.resolveValue(leftToken, record);
         const resolveRight = (record) => this.resolveValue(rightToken, record);
         return (record) => {
@@ -252,6 +268,10 @@ class Parser {
             }
         };
     }
+    noteField(token) {
+        if (parseLiteral(token) === undefined)
+            this.fields.add(token);
+    }
     resolveValue(token, record) {
         const literal = parseLiteral(token);
         if (literal !== undefined)
@@ -264,18 +284,18 @@ class Parser {
         if (this.peek() !== ')') {
             const arg = this.next();
             if (arg === undefined)
-                throw new Error(`Unterminated argument list in ${name}(...)`);
+                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}(...)`);
+                    throw new CriteriaSyntaxError(`Unterminated argument list in ${name}(...)`);
                 args.push(nextArg);
             }
         }
         if (this.next() !== ')')
-            throw new Error(`Missing closing parenthesis in ${name}(...)`);
+            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
         // argument, so both dialects share EXPR_FUNCTIONS.
@@ -284,36 +304,55 @@ class Parser {
         const fnName = name.slice(dotIndex + 1);
         const handler = EXPR_FUNCTIONS[fnName];
         if (!handler)
-            throw new Error(`Unsupported criteria function: ${name}`);
+            throw new UnsupportedCriteriaError(`Unsupported criteria function: ${name}`);
         const allArgs = receiver === 'Expr' ? args : [receiver, ...args];
+        for (const arg of allArgs)
+            this.noteField(arg);
         const resolve = (token, record) => this.resolveValue(token, record);
         return (record) => handler(record, allArgs, resolve);
     }
 }
-/** Compiles a CRITERIA_MATCH string into a predicate function(record) => boolean. */
-export function compileCriteria(criteria) {
+// 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) {
     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) {
     // 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}`, error);
         return () => true;
     }
 }
+// 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) {
+    try {
+        return parseCriteria(criteria).fields;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function filterByCriteria(rows, criteria) {
     const predicate = compileCriteria(criteria);
     return rows.filter((row) => {

package/dist/db/identity.d.ts

@@ -0,0 +1,11 @@
+import type { Row } from '../types.ts';
+export declare const RECORD_ID = "RECORD_ID";
+export declare const TIMESTAMP = "TIMESTAMP";
+export declare const RECORD_FIELDS: readonly string[];
+export declare class RecordClock {
+    private last;
+    next(): number;
+    observe(value: unknown): void;
+}
+export declare function withoutRecordFields(row: Row): Row;
+export declare function recordKey(row: Row | undefined | null): string | undefined;

package/dist/db/identity.js

@@ -0,0 +1,46 @@
+// 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.
+export const RECORD_ID = 'RECORD_ID';
+export const TIMESTAMP = 'TIMESTAMP';
+export const RECORD_FIELDS = [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 {
+    last = 0;
+    next() {
+        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) {
+        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) {
+    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) {
+    const id = row?.[RECORD_ID];
+    return id === undefined || id === null ? undefined : String(id);
+}

package/dist/db/ordering.d.ts

@@ -0,0 +1,8 @@
+import type { Row } from '../types.ts';
+export declare function compareValues(a: unknown, b: unknown): number;
+export interface OrderedField {
+    field: string;
+    descending: boolean;
+}
+export declare function rowComparator(fields: OrderedField[]): (a: Row, b: Row) => number;
+export declare function parseOrderBy(orderBy: string): OrderedField[];

package/dist/db/ordering.js

@@ -0,0 +1,49 @@
+// 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 { 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
+// else by its string form (UTF-16 order, as Java's String.compareTo).
+export function compareValues(a, b) {
+    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;
+}
+// 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) {
+    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) {
+    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' };
+    });
+}

package/dist/db/schema.d.ts

@@ -0,0 +1,62 @@
+import type { CrudEventVerb, FieldDef, IndexDef, MockServerConfig, QueryDef, RequestReplyDef, Row, TableDef } from '../types.ts';
+import type { Store } from './store.ts';
+export interface ResolvedField {
+    name: string;
+    type: string;
+    nullable: boolean;
+    generated: boolean;
+    values?: string[];
+    default?: unknown;
+    maxSize?: number;
+    minLength?: number;
+    description?: string;
+    title?: string;
+    optional?: boolean;
+    table?: string;
+}
+export interface ResolvedSchema {
+    fields: ResolvedField[];
+    declared: boolean;
+}
+export declare function pkFieldsOf(def: TableDef): string[];
+export declare function generatedFieldsOf(def: TableDef): Set<string>;
+export declare function generatedFieldList(def: TableDef): string[];
+export declare function isDeclared(source: string, config: MockServerConfig, store: Store): boolean;
+export declare function resolveSourceSchema(source: string, config: MockServerConfig, store: Store): ResolvedSchema;
+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 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;
+export declare function requestReplyReplySchema(requestReply: RequestReplyDef, config: MockServerConfig, store: Store): ResolvedSchema;
+export declare function requestReplyFieldNames(requestReply: RequestReplyDef, config: MockServerConfig, store: Store): string[] | undefined;
+export declare function requestFieldsOf(requestReply: RequestReplyDef, store: Store): string[];
+export declare function knownValues(field: ResolvedField): string[] | undefined;
+export declare function eventDefaultOf(field: ResolvedField): unknown;
+export declare function queryFieldNames(query: QueryDef | undefined, config: MockServerConfig, store: Store): string[] | undefined;
+export declare function projectRow(row: Row, names: string[] | undefined): Row;
+export declare function defaultIndexName(table: string, fields: string[]): string;
+export declare function primaryKeyIndexName(table: string, def: TableDef): string;
+export declare function secondaryUniqueIndexes(def: TableDef): IndexDef[];
+export declare const CRUD_EVENT_VERBS: readonly CrudEventVerb[];
+export declare function crudEventName(table: string, verb: CrudEventVerb): string;
+export declare function crudEventOf(name: string | undefined, config: MockServerConfig): {
+    table: string;
+    verb: CrudEventVerb;
+} | undefined;
+export declare function crudEventNames(config: MockServerConfig): string[];
+export declare function isDeleteEventName(name: string): boolean;
+export declare function inferEventTable(eventName: string | undefined, tableNames: string[]): string | undefined;
+export interface EventTarget {
+    kind: 'table' | 'byId' | 'dto';
+    table?: string;
+    className: string;
+    title?: string;
+    fieldTypes?: Record<string, string>;
+    fields?: FieldDef[];
+}
+export declare function resolveEventTarget(name: string | undefined, config: MockServerConfig, { bareTable }?: {
+    bareTable?: boolean;
+}): EventTarget | undefined;
+export declare function eventFields(target: EventTarget, config: MockServerConfig, store: Store): ResolvedField[];