@genesislcap/mock-server 15.51.1 → 15.53.0

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,13 +1,14 @@
 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 { 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 +81,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 +97,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 +134,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 +160,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 +234,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)
@@ -244,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

@@ -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,42 @@ 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 type CrudEventVerb = 'INSERT' | 'MODIFY' | 'DELETE';
+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[];
+    events?: CrudEventVerb[];
 }
+export type SequenceFormat = 'prefix' | 'genesis';
 export interface JoinDef {
     table: string;
     on: [string, string];
@@ -30,6 +61,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 +76,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 +94,17 @@ export interface RequestReplyDef {
     fieldTypes?: Record<string, string>;
     filter?: (row: Row) => boolean;
     auth?: ResourceAuthDef;
+    criteriaOnly?: boolean;
+    requestFields?: string[];
+    fields?: string[];
+    rowLimit?: number;
 }
 export interface EventSchemaOverride {
     table?: string;
     pkOnly?: boolean;
     fieldTypes?: Record<string, string>;
+    fields?: FieldDef[];
+    className?: string;
 }
 export interface ResourceItem {
     RESOURCE_NAME: string;
@@ -101,9 +142,11 @@ export interface EventHandlerCtx {
     message: GenesisMessage;
     broadcast: BroadcastFn;
     broadcastTableChange: BroadcastTableChangeFn;
+    validate: boolean;
 }
 export type EventHandlerResult = {
     generated?: Row[];
+    warnings?: NackErrorInput[];
 } | void;
 export type EventHandler = (details: Row, ctx: EventHandlerCtx) => EventHandlerResult;
 export interface HttpRouteDef {
@@ -133,10 +176,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.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",