@genesislcap/mock-server 15.52.0 → 15.53.0

package/dist/protocol/schemaValidation.d.ts

@@ -0,0 +1,11 @@
+import type { NackErrorInput } from './errors.ts';
+type Schema = Record<string, any>;
+export interface SchemaError {
+    keyword: string;
+    instanceLocation: string;
+    property?: string;
+    message: string;
+}
+export declare function validateSchema(schema: Schema, value: unknown, location?: string): SchemaError[];
+export declare function schemaFieldErrors(errors: SchemaError[]): NackErrorInput[];
+export {};

package/dist/protocol/schemaValidation.js

@@ -0,0 +1,186 @@
+// Inbound schema validation, as GSF runs it on every event before any handler
+// sees it: GenesisMessageDecoder validates the whole message against the
+// event's JSON schema (the INBOUND that JSON_SCHEMA_REQUEST serves) and
+// answers each failure with a FieldError VALIDATION_ERROR. GSF 8.15.29 uses
+// networknt json-schema-validator 2.0.1, configured by
+// GenesisJsonSchemaFactory (draft 2019-09, PathType.LEGACY,
+// losslessNarrowing). This is the subset of that validator the engine's own
+// event schemas need: type, const, enum, oneOf, properties, required,
+// additionalProperties, minLength / maxLength, minimum / maximum and pattern.
+// Texts, locations and their order follow networknt's output, checked by
+// running the real validator on the recorded showcase schemas
+// (test/schemaValidation.test.ts pins the cases).
+//
+// Order: at each schema, `type` and then `properties` are checked first and
+// every other keyword after them in the schema's key order; `properties` in
+// their key order; unknown properties in the instance's order. A failed
+// `type` doesn't stop the rest (an enum still reports its own error).
+// `oneOf` with no valid branch reports itself, then every branch's errors.
+// networknt's JsonType names. With losslessNarrowing a number with no
+// fraction is an integer (1.0 included, which JSON.parse makes 1 anyway).
+function jsonTypeOf(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    if (typeof value === 'number')
+        return Number.isInteger(value) ? 'integer' : 'number';
+    return typeof value;
+}
+function matchesType(value, type) {
+    const actual = jsonTypeOf(value);
+    return actual === type || (type === 'number' && actual === 'integer');
+}
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.length === b.length && a.every((item, index) => deepEqual(item, b[index]));
+    }
+    if (isObject(a) && isObject(b)) {
+        const keys = Object.keys(a);
+        return (keys.length === Object.keys(b).length &&
+            keys.every((key) => Object.hasOwn(b, key) && deepEqual(a[key], b[key])));
+    }
+    return false;
+}
+// networknt evaluates these before a schema's other keywords, whatever their
+// position; the rest go in key order.
+const FIRST_KEYWORDS = ['type', 'properties'];
+// String lengths count code points, as Java's codePointCount does.
+const codePoints = (text) => [...text].length;
+const NOT_DEFINED = 'is not defined in the schema and the schema does not allow additional properties';
+// One check per keyword, each a no-op on values it doesn't apply to (string
+// keywords on non-strings, object keywords on non-objects, ...).
+const KEYWORDS = {
+    type({ arg, value, fail }) {
+        if (typeof arg === 'string' && !matchesType(value, arg)) {
+            fail(`${jsonTypeOf(value)} found, ${arg} expected`);
+        }
+    },
+    const({ arg, value, fail }) {
+        if (!deepEqual(value, arg))
+            fail(`must be the constant value '${String(arg)}'`);
+    },
+    enum({ arg, value, fail }) {
+        if (Array.isArray(arg) && !arg.some((candidate) => deepEqual(value, candidate))) {
+            const values = arg.map((item) => JSON.stringify(item)).join(', ');
+            fail(`does not have a value in the enumeration [${values}]`);
+        }
+    },
+    minLength({ arg, value, fail }) {
+        if (typeof value === 'string' && codePoints(value) < arg) {
+            fail(`must be at least ${arg} characters long`);
+        }
+    },
+    maxLength({ arg, value, fail }) {
+        if (typeof value === 'string' && codePoints(value) > arg) {
+            fail(`must be at most ${arg} characters long`);
+        }
+    },
+    minimum({ arg, value, fail }) {
+        if (typeof value === 'number' && value < arg)
+            fail(`must have a minimum value of ${arg}`);
+    },
+    maximum({ arg, value, fail }) {
+        if (typeof value === 'number' && value > arg)
+            fail(`must have a maximum value of ${arg}`);
+    },
+    // JSON Schema patterns are unanchored: '[0-9]+' accepts 'x1y'.
+    pattern({ arg, value, fail }) {
+        if (typeof value === 'string' && !new RegExp(arg, 'u').test(value)) {
+            fail(`does not match the regex pattern ${arg}`);
+        }
+    },
+    oneOf({ arg, value, location, errors, fail }) {
+        if (!Array.isArray(arg))
+            return;
+        const results = arg.map((branch) => validateSchema(branch, value, location));
+        const valid = results.flatMap((result, index) => (result.length === 0 ? [index] : []));
+        if (valid.length === 1)
+            return;
+        if (valid.length > 1) {
+            fail(`must be valid to one and only one schema, but ${valid.length} are valid with indexes '${valid.join(', ')}'`);
+            return;
+        }
+        fail('must be valid to one and only one schema, but 0 are valid');
+        errors.push(...results.flat());
+    },
+    properties({ arg, value, location, errors }) {
+        if (!isObject(value) || !isObject(arg))
+            return;
+        for (const [name, propertySchema] of Object.entries(arg)) {
+            if (!Object.hasOwn(value, name))
+                continue;
+            errors.push(...validateSchema(propertySchema, value[name], `${location}.${name}`));
+        }
+    },
+    required({ arg, value, fail }) {
+        if (!isObject(value) || !Array.isArray(arg))
+            return;
+        for (const name of arg) {
+            if (!Object.hasOwn(value, name))
+                fail(`required property '${name}' not found`, name);
+        }
+    },
+    additionalProperties({ arg, schema, value, location, errors, fail }) {
+        if (!isObject(value) || (arg !== false && !isObject(arg)))
+            return;
+        const known = isObject(schema.properties) ? schema.properties : {};
+        for (const name of Object.keys(value)) {
+            if (Object.hasOwn(known, name))
+                continue;
+            if (arg === false)
+                fail(`property '${name}' ${NOT_DEFINED}`, name);
+            else
+                errors.push(...validateSchema(arg, value[name], `${location}.${name}`));
+        }
+    },
+    // Anything else is an annotation (description, title, default, readOnly,
+    // genesisType, $schema, $defs, ...) and validates nothing; networknt
+    // doesn't enforce readOnly unless asked to.
+};
+export function validateSchema(schema, value, location = '$') {
+    const errors = [];
+    if (!isObject(schema))
+        return errors;
+    const keywords = Object.keys(schema);
+    const ordered = [
+        ...FIRST_KEYWORDS.filter((keyword) => keywords.includes(keyword)),
+        ...keywords.filter((keyword) => !FIRST_KEYWORDS.includes(keyword)),
+    ];
+    for (const keyword of ordered) {
+        if (!Object.hasOwn(KEYWORDS, keyword))
+            continue;
+        KEYWORDS[keyword]({
+            arg: schema[keyword],
+            schema,
+            value,
+            location,
+            errors,
+            fail: (message, property) => errors.push({
+                keyword,
+                instanceLocation: location,
+                ...(property !== undefined ? { property } : {}),
+                message,
+            }),
+        });
+    }
+    return errors;
+}
+// GenesisMessageDecoder's FieldError for each failure: TEXT is the error's
+// toString() ("<location>: <message>"), FIELD the missing property for
+// `required` and otherwise the last segment of the location (so an unknown
+// DETAILS property names 'DETAILS'), PATH the location.
+export function schemaFieldErrors(errors) {
+    return errors.map((error) => ({
+        '@type': 'FieldError',
+        CODE: 'VALIDATION_ERROR',
+        TEXT: `${error.instanceLocation}: ${error.message}`,
+        FIELD: error.keyword === 'required'
+            ? error.property
+            : error.instanceLocation.slice(error.instanceLocation.lastIndexOf('.') + 1),
+        PATH: error.instanceLocation,
+    }));
+}

package/dist/server.js

@@ -1,6 +1,7 @@
 import http from 'node:http';
 import { WebSocketServer } from 'ws';
 import { Store } from "./db/store.js";
+import { crudEventHandler } from "./handlers/crudEvents.js";
 import { pendingKey } from "./handlers/dataLogon.js";
 import { createHttpRequestListener } from "./handlers/http.js";
 import { permittedQueryRow, requestingUser } from "./handlers/resourceAuth.js";
@@ -306,8 +307,11 @@ export function createMockServer(config) {
     function getRequestReply(resourceName) {
         return config.requestReplies?.[resourceName];
     }
+    // An eventHandlers entry, else the generic CRUD handler a table registers
+    // (TableDef.events) — so extendEventHandler can wrap a generic event; the
+    // wrapper is then an explicit handler, which wins.
     function getEventHandler(eventName) {
-        return config.eventHandlers?.[eventName];
+        return config.eventHandlers?.[eventName] ?? crudEventHandler(eventName, config);
     }
     // augment(current) => replacement. `current` is undefined if nothing was
     // registered under that name yet, so augment can also be used to define a

package/dist/types.d.ts

@@ -26,6 +26,7 @@ export interface GeneratedFieldDef {
     kind: 'SEQUENCE' | 'AUTO_INCREMENT';
     prefix?: string;
 }
+export type CrudEventVerb = 'INSERT' | 'MODIFY' | 'DELETE';
 export interface IndexDef {
     name: string;
     fields: string[];
@@ -40,6 +41,7 @@ export interface TableDef {
     fields?: FieldDef[];
     generated?: GeneratedFieldDef[];
     indexes?: IndexDef[];
+    events?: CrudEventVerb[];
 }
 export type SequenceFormat = 'prefix' | 'genesis';
 export interface JoinDef {
@@ -94,6 +96,8 @@ export interface RequestReplyDef {
     auth?: ResourceAuthDef;
     criteriaOnly?: boolean;
     requestFields?: string[];
+    fields?: string[];
+    rowLimit?: number;
 }
 export interface EventSchemaOverride {
     table?: string;
@@ -138,6 +142,7 @@ export interface EventHandlerCtx {
     message: GenesisMessage;
     broadcast: BroadcastFn;
     broadcastTableChange: BroadcastTableChangeFn;
+    validate: boolean;
 }
 export type EventHandlerResult = {
     generated?: Row[];

package/package.json

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

@@ -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}))?)?$/);
@@ -250,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 '(':
@@ -268,12 +282,12 @@ 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);
@@ -320,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
@@ -338,7 +355,7 @@ 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);
 
@@ -347,24 +364,37 @@ class Parser {
   }
 }
 
-/** 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}`,
@@ -378,13 +408,8 @@ export function compileCriteria(criteria?: string | null): Predicate {
 // (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];
+    return parseCriteria(criteria).fields;
   } catch {
     return undefined;
   }

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' };
+  });
+}