@genesislcap/mock-server 15.51.1 → 15.53.0

package/src/protocol/schemaValidation.ts

@@ -0,0 +1,208 @@
+// 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.
+
+import type { NackErrorInput } from './errors.ts';
+
+type Schema = Record<string, any>;
+
+export interface SchemaError {
+  keyword: string;
+  // PathType.LEGACY: '$', '$.DETAILS', '$.DETAILS.NAME'.
+  instanceLocation: string;
+  // The missing property, for `required`; the unknown one, for
+  // `additionalProperties`.
+  property?: string;
+  message: string;
+}
+
+// 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: unknown): string {
+  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: unknown, type: string): boolean {
+  const actual = jsonTypeOf(value);
+  return actual === type || (type === 'number' && actual === 'integer');
+}
+
+const isObject = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value);
+
+function deepEqual(a: unknown, b: unknown): boolean {
+  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: string) => [...text].length;
+
+interface KeywordCheck {
+  arg: any;
+  schema: Schema;
+  value: unknown;
+  location: string;
+  errors: SchemaError[];
+  fail(message: string, property?: string): void;
+}
+
+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: Record<string, (check: KeywordCheck) => void> = {
+  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: Schema) => 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 as Schema, 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: Schema, value: unknown, location = '$'): SchemaError[] {
+  const errors: SchemaError[] = [];
+  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: SchemaError[]): NackErrorInput[] {
+  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/src/server.ts

@@ -1,13 +1,14 @@
 import http from 'node:http';
 import { WebSocketServer, type WebSocket } from 'ws';
 import { Store } from './db/store.ts';
+import { crudEventHandler } from './handlers/crudEvents.ts';
 import { pendingKey } from './handlers/dataLogon.ts';
 import { createHttpRequestListener } from './handlers/http.ts';
-import { applyResourceAuth, requestingUser } from './handlers/resourceAuth.ts';
+import { permittedQueryRow, requestingUser } from './handlers/resourceAuth.ts';
 import { Connection, type Subscription } from './protocol/connection.ts';
 import { isLegacyFidelity } from './protocol/fidelity.ts';
 import { routeMessage } from './protocol/router.ts';
-import { stampRow, type RowOperation } from './protocol/rowUpdate.ts';
+import { dataserverRow, stampRow, type RowOperation } from './protocol/rowUpdate.ts';
 import type {
   BroadcastFn,
   BroadcastTableChangeFn,
@@ -141,9 +142,10 @@ export function createMockServer(config: MockServerConfig): MockServer {
     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'));
+      if (permitted)
+        pending.set(key, stampRow(dataserverRow(permitted, row, query?.fields), rowRef, 'INSERT'));
       else pending.delete(key);
       return null;
     }
@@ -153,11 +155,22 @@ export function createMockServer(config: MockServerConfig): MockServer {
       return 'DELETE';
     }
     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: BroadcastFn = (resourceName, operation, row) => {
+  function pushChange(resourceName: string, operation: RowOperation, row: Row): void {
     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.
@@ -188,19 +201,27 @@ export function createMockServer(config: MockServerConfig): MockServer {
           ? trackClientView(subscription, connection, query, resolved, row, rowRef)
           : 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 as string) : 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
@@ -208,12 +229,33 @@ export function createMockServer(config: MockServerConfig): MockServer {
         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: BroadcastFn = (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
@@ -221,8 +263,26 @@ export function createMockServer(config: MockServerConfig): MockServer {
   // 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: BroadcastTableChangeFn = (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);
@@ -242,23 +302,38 @@ export function createMockServer(config: MockServerConfig): MockServer {
 
       if (isViewJoiningTable) {
         for (const viewRow of store.getViewRows(query.source)) {
-          broadcast(queryName, 'MODIFY', viewRow);
+          pushChange(queryName, 'MODIFY', viewRow);
         }
         continue;
       }
 
-      let row: Row | undefined;
+      // 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;
-      } else if (isDirect) {
-        row = store.getRow(tableName, pk);
-      } else {
-        row = store
-          .getViewRows(query.source)
-          .find((r) => String(store.getRowRef(query.source, r)) === String(pk));
+        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;
+      }
+      const viewRow = store.getViewRows(query.source, { [tableName]: [current] })[0];
+      if (viewRow) {
+        pushChange(queryName, operation, viewRow);
+      } else if (operation === 'MODIFY') {
+        pushChange(
+          queryName,
+          'DELETE',
+          legacy
+            ? store.rowStubFromKey(query.source, store.getRowRef(query.source, current) as string)
+            : current,
+        );
       }
-      if (row) broadcast(queryName, operation, row);
     }
   };
 
@@ -310,8 +385,11 @@ export function createMockServer(config: MockServerConfig): MockServer {
     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: string): EventHandler | undefined {
-    return config.eventHandlers?.[eventName];
+    return config.eventHandlers?.[eventName] ?? crudEventHandler(eventName, config);
   }
 
   // augment(current) => replacement. `current` is undefined if nothing was