@genesislcap/mock-server 15.51.1 → 15.52.0

package/dist/server.js

@@ -3,11 +3,11 @@ import { WebSocketServer } from 'ws';
 import { Store } from "./db/store.js";
 import { pendingKey } from "./handlers/dataLogon.js";
 import { createHttpRequestListener } from "./handlers/http.js";
-import { applyResourceAuth, requestingUser } from "./handlers/resourceAuth.js";
+import { permittedQueryRow, requestingUser } from "./handlers/resourceAuth.js";
 import { Connection } from "./protocol/connection.js";
 import { isLegacyFidelity } from "./protocol/fidelity.js";
 import { routeMessage } from "./protocol/router.js";
-import { stampRow } from "./protocol/rowUpdate.js";
+import { dataserverRow, stampRow } from "./protocol/rowUpdate.js";
 export function createMockServer(config) {
     const store = new Store();
     for (const [tableName, tableDef] of Object.entries(config.tables ?? {})) {
@@ -80,10 +80,10 @@ export function createMockServer(config) {
             return null;
         const permitted = operation === 'DELETE'
             ? undefined
-            : applyResourceAuth([row], query?.auth, requestingUser(connection))[0];
+            : permittedQueryRow(row, query?.auth, requestingUser(connection), subscription.fieldNames);
         if (pending.has(key)) {
             if (permitted)
-                pending.set(key, stampRow(permitted, rowRef, 'INSERT'));
+                pending.set(key, stampRow(dataserverRow(permitted, row, query?.fields), rowRef, 'INSERT'));
             else
                 pending.delete(key);
             return null;
@@ -96,10 +96,14 @@ 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';
     }
-    const broadcast = (resourceName, operation, row) => {
+    function pushChange(resourceName, operation, row) {
         const query = config.queries?.[resourceName];
         // The query's own filter (where-clause equivalent) applies to live pushes
         // too — a row the snapshot would exclude must not leak in via broadcast.
@@ -129,21 +133,25 @@ export function createMockServer(config) {
                     : resolved;
                 if (rowOperation === null)
                     continue;
+                const legacy = isLegacyFidelity(config);
                 let outRow = row;
                 if (rowOperation === 'DELETE') {
-                    // A change turned into a DELETE: send the row identity only — it is
-                    // all the client needs to drop the row, and the full row may carry
-                    // columns this user's hideFields strips. (A real DELETE's row is a
-                    // stub already.)
-                    if (operation !== 'DELETE') {
+                    // GSF's DELETE row is DETAILS {OPERATION, ROW_REF} and nothing else.
+                    // Legacy mode sent the pk fields: the stub it was given for a real
+                    // DELETE, or one rebuilt from the key for a change that left the
+                    // subscription (the full row may carry columns hideFields strips).
+                    if (!legacy)
+                        outRow = {};
+                    else if (operation !== 'DELETE') {
                         outRow = query ? store.rowStubFromKey(query.source, rowRef) : row;
                     }
                 }
-                else if (query?.auth) {
-                    const [permitted] = applyResourceAuth([row], query.auth, requestingUser(connection));
+                else {
+                    // Only the subscription's columns, minus the ones this user can't see.
+                    const permitted = permittedQueryRow(row, query?.auth, requestingUser(connection), subscription.fieldNames);
                     if (!permitted)
                         continue;
-                    outRow = permitted;
+                    outRow = dataserverRow(permitted, row, query?.fields);
                 }
                 subscription.sequenceId += 1;
                 // A live push carries neither MORE_ROWS nor ROWS_COUNT on the real
@@ -151,20 +159,62 @@ export function createMockServer(config) {
                 connection.send({
                     MESSAGE_TYPE: 'QUERY_UPDATE',
                     SOURCE_REF: sourceRef,
-                    ROW: [stampRow(outRow, rowRef, rowOperation)],
-                    ...(isLegacyFidelity(config) ? { ROWS_COUNT: 1 } : {}),
+                    ROW: [stampRow(outRow, rowRef, rowOperation, legacy)],
+                    ...(legacy ? { ROWS_COUNT: 1 } : {}),
                     SEQUENCE_ID: subscription.sequenceId,
                 });
             }
         }
+    }
+    // Pushes an unsolicited row update to every subscription on the resource
+    // (see pushChange). A DELETE given as a pk-only row is resolved to the
+    // record(s) removed from that key that no broadcast has announced yet —
+    // their RECORD_IDs are the ROW_REFs a client may hold — and those are
+    // consumed, so a later delete of a re-inserted key names its own record.
+    const broadcast = (resourceName, operation, row) => {
+        const source = config.queries?.[resourceName]?.source;
+        if (operation !== 'DELETE' || !source) {
+            pushChange(resourceName, operation, row);
+            return;
+        }
+        const removed = store.takeRemovedRecordsFor(source, row);
+        if (isLegacyFidelity(config)) {
+            pushChange(resourceName, operation, row);
+            return;
+        }
+        const records = row.RECORD_ID === undefined || row.RECORD_ID === null ? removed : [row];
+        if (records.length === 0)
+            records.push(row);
+        for (const record of records)
+            pushChange(resourceName, 'DELETE', record);
     };
     // Event handlers mutate one table (e.g. TRADE) but grids may be subscribed to
     // a view built on top of it (e.g. ALL_TRADES -> TRADE_VIEW). This finds every
     // query resource backed by that table — directly or via a view — and pushes
     // the (re-joined, for views) row to each one's subscribers. `pk` is the
     // store key: the single pk field's value, or store.rowKey(...) for
-    // composite-keyed tables.
+    // composite-keyed tables. ROW_REF is the record's RECORD_ID, so a DELETE is
+    // broadcast with every record the key lost that no broadcast announced yet
+    // (Store.takeRemovedRows; held-rows tracking drops the ones a client
+    // doesn't hold), and a record replaced under the same key (deleted, then
+    // re-inserted, before one broadcast) gets a DELETE of its old ROW_REF before
+    // the new one goes out. A view row is built from the changed base row
+    // alone, so it is found whatever the view's own pkField; a MODIFY that takes
+    // it out of the view (an anti-join) is pushed as a DELETE. Legacy ROW_REFs
+    // are the key itself, so there a DELETE is the pk stub and a replacement is
+    // the one INSERT/MODIFY, as before.
     const broadcastTableChange = (tableName, operation, pk) => {
+        const legacy = isLegacyFidelity(config);
+        const current = operation === 'DELETE' ? undefined : store.getRow(tableName, pk);
+        let removed = store
+            .takeRemovedRows(tableName, pk)
+            .filter((record) => record.RECORD_ID !== current?.RECORD_ID);
+        // A DELETE broadcast before the row is removed still names it.
+        const live = store.getRow(tableName, pk);
+        if (operation === 'DELETE' && removed.length === 0 && live)
+            removed = [live];
+        if (legacy)
+            removed = [];
         for (const [queryName, query] of Object.entries(config.queries ?? {})) {
             const isDirect = query.source === tableName;
             const view = store.views.get(query.source);
@@ -183,25 +233,37 @@ export function createMockServer(config) {
                 continue;
             if (isViewJoiningTable) {
                 for (const viewRow of store.getViewRows(query.source)) {
-                    broadcast(queryName, 'MODIFY', viewRow);
+                    pushChange(queryName, 'MODIFY', viewRow);
                 }
                 continue;
             }
-            let row;
+            // The removed base records carry the RECORD_ID a view row's ROW_REF
+            // comes from too; the DELETE body is DETAILS only either way.
+            for (const record of removed)
+                pushChange(queryName, 'DELETE', record);
             if (operation === 'DELETE') {
-                const stub = store.rowStubFromKey(query.source, pk);
-                row = Object.keys(stub).length > 0 ? stub : undefined;
+                if (legacy) {
+                    const stub = store.rowStubFromKey(query.source, pk);
+                    if (Object.keys(stub).length > 0)
+                        pushChange(queryName, 'DELETE', stub);
+                }
+                continue;
+            }
+            if (!current)
+                continue;
+            if (isDirect) {
+                pushChange(queryName, operation, current);
+                continue;
             }
-            else if (isDirect) {
-                row = store.getRow(tableName, pk);
+            const viewRow = store.getViewRows(query.source, { [tableName]: [current] })[0];
+            if (viewRow) {
+                pushChange(queryName, operation, viewRow);
             }
-            else {
-                row = store
-                    .getViewRows(query.source)
-                    .find((r) => String(store.getRowRef(query.source, r)) === String(pk));
+            else if (operation === 'MODIFY') {
+                pushChange(queryName, 'DELETE', legacy
+                    ? store.rowStubFromKey(query.source, store.getRowRef(query.source, current))
+                    : current);
             }
-            if (row)
-                broadcast(queryName, operation, row);
         }
     };
     const httpSessions = new Map(); // sessionId -> username, for the HTTP login transport (see handlers/http.ts)

package/dist/types.d.ts

@@ -1,5 +1,6 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { Store } from './db/store.ts';
+import type { NackErrorInput } from './protocol/errors.ts';
 export type Row = Record<string, any>;
 export interface GenesisMessage {
     MESSAGE_TYPE: string;
@@ -7,12 +8,40 @@ export interface GenesisMessage {
     DETAILS?: Row;
     [key: string]: any;
 }
+export type GenesisFieldType = 'STRING' | 'ENUM' | 'INT' | 'SHORT' | 'LONG' | 'DOUBLE' | 'BIGDECIMAL' | 'BOOLEAN' | 'DATE' | 'DATETIME' | 'NANO_TIMESTAMP' | 'RAW';
+export interface FieldDef {
+    name: string;
+    type: GenesisFieldType;
+    nullable?: boolean;
+    values?: string[];
+    default?: unknown;
+    maxSize?: number;
+    minLength?: number;
+    description?: string;
+    title?: string;
+    optional?: boolean;
+}
+export interface GeneratedFieldDef {
+    field: string;
+    kind: 'SEQUENCE' | 'AUTO_INCREMENT';
+    prefix?: string;
+}
+export interface IndexDef {
+    name: string;
+    fields: string[];
+    unique?: boolean;
+}
 export interface TableDef {
     pkField: string | string[];
     sequencePrefix?: string;
     sequenceWidth?: number;
+    sequenceFormat?: SequenceFormat;
     rows?: Row[];
+    fields?: FieldDef[];
+    generated?: GeneratedFieldDef[];
+    indexes?: IndexDef[];
 }
+export type SequenceFormat = 'prefix' | 'genesis';
 export interface JoinDef {
     table: string;
     on: [string, string];
@@ -30,6 +59,8 @@ export interface ViewDef {
     joins?: JoinDef[];
     antiJoins?: AntiJoinDef[];
     derived?: Record<string, (row: Row) => any>;
+    derivedTypes?: Record<string, GenesisFieldType | Omit<FieldDef, 'name'>>;
+    fields?: string[];
 }
 export interface RequestingUser {
     userName?: string;
@@ -43,6 +74,8 @@ export interface ResourceAuthDef {
 export interface QueryDef {
     source: string;
     fieldTypes?: Record<string, string>;
+    fields?: string[];
+    indexes?: IndexDef[];
     filter?: (row: Row) => boolean;
     auth?: ResourceAuthDef;
 }
@@ -59,11 +92,15 @@ export interface RequestReplyDef {
     fieldTypes?: Record<string, string>;
     filter?: (row: Row) => boolean;
     auth?: ResourceAuthDef;
+    criteriaOnly?: boolean;
+    requestFields?: string[];
 }
 export interface EventSchemaOverride {
     table?: string;
     pkOnly?: boolean;
     fieldTypes?: Record<string, string>;
+    fields?: FieldDef[];
+    className?: string;
 }
 export interface ResourceItem {
     RESOURCE_NAME: string;
@@ -104,6 +141,7 @@ export interface EventHandlerCtx {
 }
 export type EventHandlerResult = {
     generated?: Row[];
+    warnings?: NackErrorInput[];
 } | void;
 export type EventHandler = (details: Row, ctx: EventHandlerCtx) => EventHandlerResult;
 export interface HttpRouteDef {
@@ -133,10 +171,12 @@ export interface MockServerConfig {
     httpRoutes?: HttpRouteDef[];
     onMessage?: OnMessageHook;
     productName?: string;
+    appName?: string;
 }
 export interface FieldMetadata {
     NAME: string;
     TYPE: string;
+    VALID_VALUES?: string[];
 }
 export interface SocketLike {
     readyState: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genesislcap/mock-server",
-  "version": "15.51.1",
+  "version": "15.52.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",

package/src/db/criteria.ts

@@ -188,6 +188,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;
@@ -273,6 +276,8 @@ class Parser {
       throw new Error('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 +305,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;
@@ -331,6 +340,7 @@ class Parser {
     const handler = EXPR_FUNCTIONS[fnName];
     if (!handler) throw new Error(`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);
@@ -364,6 +374,22 @@ 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 {
+  if (!criteria || typeof criteria !== 'string' || criteria.trim() === '') return [];
+  try {
+    const tokens = tokenize(criteria.trim());
+    const parser = new Parser(tokens);
+    parser.parseExpression();
+    if (parser.position !== tokens.length) return undefined;
+    return [...parser.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);
+}