@genesislcap/mock-server 15.51.1 → 15.53.0

package/src/handlers/crudEvents.ts

@@ -0,0 +1,181 @@
+// The CRUD event handlers a table registers through TableDef.events: the
+// ones Genesis Create generates for a table's `crud` event handlers
+// (codegen-service JsonToKtsEventHandlersGenerator) — eventHandler<Table>
+// "<TABLE>_INSERT" / "_MODIFY" calling entityDb.insert / modify, and
+// eventHandler<Table.ById> "<TABLE>_DELETE" calling entityDb.delete, with no
+// onValidate. They are what the showcase server runs (its recordings come
+// from them) and what Create's real tier deploys. genesis-eventhandler's own
+// GenericInsert/Modify/DeleteEventHandler (EventHandlerBuilder
+// .registerCUDEvents) differ in GENERATED and VALIDATE; see the README. The
+// inbound schema check runs before them, as for any event
+// (eventValidation.ts).
+
+import { RECORD_ID, TIMESTAMP } from '../db/identity.ts';
+import {
+  crudEventOf,
+  generatedFieldList,
+  pkFieldsOf,
+  primaryKeyIndexName,
+  secondaryUniqueIndexes,
+} from '../db/schema.ts';
+import type { Store } from '../db/store.ts';
+import { NackError } from '../protocol/errors.ts';
+import type {
+  CrudEventVerb,
+  EventHandler,
+  EventHandlerCtx,
+  EventHandlerResult,
+  MockServerConfig,
+  Row,
+  TableDef,
+} from '../types.ts';
+
+const isMissing = (value: unknown) => value === undefined || value === null;
+
+// What DUPLICATE_KEY's FIELD shows after '<INDEX> -> ': the index's values,
+// nulls left out, joined with ' | ' (DbUtil.CREATE_DUPLICATE_KEY_ERROR_MESSAGE).
+function indexValueText(fields: string[], row: Row): string {
+  return fields
+    .map((field) => row[field])
+    .filter((value) => !isMissing(value))
+    .map(String)
+    .join(' | ');
+}
+
+// The database's unique constraints: the primary key (unless `self` is the
+// record being modified, whose key can't change) and every other unique
+// index. A null in an index's fields never clashes, as in SQL.
+function checkUnique(table: string, def: TableDef, row: Row, store: Store, self?: string): void {
+  const pkFields = pkFieldsOf(def);
+  if (self === undefined && pkFields.every((field) => !isMissing(row[field]))) {
+    if (store.getRow(table, store.rowKey(table, row))) {
+      throw NackError.duplicateKey(
+        table,
+        primaryKeyIndexName(table, def),
+        indexValueText(pkFields, row),
+      );
+    }
+  }
+  for (const index of secondaryUniqueIndexes(def)) {
+    if (index.fields.some((field) => isMissing(row[field]))) continue;
+    const clash = store
+      .getAllRows(table)
+      .some(
+        (other) =>
+          store.rowKey(table, other) !== self &&
+          index.fields.every((field) => other[field] === row[field]),
+      );
+    if (clash) throw NackError.duplicateKey(table, index.name, indexValueText(index.fields, row));
+  }
+}
+
+const declaredNames = (def: TableDef) => def.fields?.map((field) => field.name);
+
+// The record an event's DETAILS deserialize into: a declared table's
+// generated DAO gives every field the DETAILS leave out its default, or null
+// (a missing not-null field without one never gets here: the schema check
+// NACKs it). Generated fields stay unset for the database to fill — or, on a
+// modify, to keep. An undeclared table has no DAO to go by: an insert takes
+// DETAILS as they are, and a modify resets the record's other stored columns.
+function defaultsFor(def: TableDef, details: Row, fieldNames: string[]): Row {
+  const generated = new Set(generatedFieldList(def));
+  const pkFields = pkFieldsOf(def);
+  const record: Row = { ...details };
+  for (const name of fieldNames) {
+    if (Object.hasOwn(details, name) || generated.has(name) || pkFields.includes(name)) continue;
+    if (name === RECORD_ID || name === TIMESTAMP) continue;
+    const declared = def.fields?.find((field) => field.name === name);
+    record[name] = declared?.default !== undefined ? declared.default : null;
+  }
+  return record;
+}
+
+// entityDb.insert(details), then ack(listOf(mapOf(<each generated field,
+// sorted by name> to insertedRow.record.<field>))): every generated field's
+// stored value, supplied or generated — [] for a table with none. With no
+// onValidate, VALIDATE acks without touching the database.
+function insert(
+  table: string,
+  def: TableDef,
+  details: Row,
+  ctx: EventHandlerCtx,
+): EventHandlerResult {
+  if (ctx.validate) return {};
+  const { store } = ctx;
+  const record = defaultsFor(def, details, declaredNames(def) ?? []);
+  const row = store.withGeneratedValues(table, record);
+  checkUnique(table, def, row, store);
+  const inserted = store.insertRow(table, row);
+  ctx.broadcastTableChange(table, 'INSERT', store.rowKey(table, inserted));
+  const generatedFields = generatedFieldList(def).sort();
+  if (generatedFields.length === 0) return {};
+  return {
+    generated: [
+      Object.fromEntries(generatedFields.map((field) => [field, inserted[field] ?? null])),
+    ],
+  };
+}
+
+// entityDb.modify(details): the record is found by its primary key
+// (RECORD_NOT_FOUND naming the key's index, recorded) and DETAILS are written
+// over it. DETAILS are the whole record: a field they leave out is reset to
+// its default or null, as the deserialized DAO's value overwrites the stored
+// one (recorded: a TRADE modify without CREATED_AT, ENTERED_BY and
+// TRADE_STATUS nulls them). Generated fields left out keep their values;
+// RECORD_ID stays, TIMESTAMP moves on. VALIDATE acks without a lookup.
+function modify(
+  table: string,
+  def: TableDef,
+  details: Row,
+  ctx: EventHandlerCtx,
+): EventHandlerResult {
+  if (ctx.validate) return {};
+  const { store } = ctx;
+  const key = store.rowKey(table, details);
+  const found = store.getRow(table, key);
+  if (!found) throw NackError.recordNotFound(table, primaryKeyIndexName(table, def));
+  const patch = defaultsFor(def, details, declaredNames(def) ?? Object.keys(found));
+  checkUnique(table, def, { ...found, ...patch }, store, key);
+  store.updateRow(table, key, patch);
+  ctx.broadcastTableChange(table, 'MODIFY', key);
+  return {};
+}
+
+// entityDb.delete(<Table>.ById): a missing record is RECORD_NOT_FOUND with
+// FIELD '' (recorded). VALIDATE acks without a lookup.
+function remove(
+  table: string,
+  _def: TableDef,
+  details: Row,
+  ctx: EventHandlerCtx,
+): EventHandlerResult {
+  if (ctx.validate) return {};
+  const { store } = ctx;
+  const key = store.rowKey(table, details);
+  if (!store.getRow(table, key)) throw NackError.recordNotFound(table);
+  store.deleteRow(table, key);
+  ctx.broadcastTableChange(table, 'DELETE', key);
+  return {};
+}
+
+const VERBS: Record<
+  CrudEventVerb,
+  (table: string, def: TableDef, details: Row, ctx: EventHandlerCtx) => EventHandlerResult
+> = { INSERT: insert, MODIFY: modify, DELETE: remove };
+
+// The generic handler for an event a table registers through
+// TableDef.events, or undefined. It reads the table's definition on every
+// call, so setTable() takes effect straight away.
+export function crudEventHandler(
+  eventName: string,
+  config: MockServerConfig,
+): EventHandler | undefined {
+  const crud = crudEventOf(eventName, config);
+  if (!crud) return undefined;
+  const { table, verb } = crud;
+  return (details, ctx) => {
+    const def = config.tables?.[table];
+    if (!def) throw new Error(`Unknown table: ${table}`);
+    return VERBS[verb](table, def, details, ctx);
+  };
+}

package/src/handlers/dataLogon.ts

@@ -1,4 +1,6 @@
-import { compileCriteria, filterByCriteria } from '../db/criteria.ts';
+import { compileCriteria, criteriaFields, filterByCriteria } from '../db/criteria.ts';
+import { rowComparator } from '../db/ordering.ts';
+import { queryFieldNames, querySchema } from '../db/schema.ts';
 import type { Store } from '../db/store.ts';
 import type { Connection, Subscription } from '../protocol/connection.ts';
 import { isLegacyFidelity } from '../protocol/fidelity.ts';
@@ -8,9 +10,10 @@ import {
   resourceNotMappedNack,
   subscriptionAlreadyExistsNack,
 } from '../protocol/msgNack.ts';
-import { stampRow } from '../protocol/rowUpdate.ts';
-import type { GenesisMessage, MockServerConfig, Row } from '../types.ts';
-import { applyResourceAuth, requestingUser } from './resourceAuth.ts';
+import { dataserverRow, rowRefFor, stampRow } from '../protocol/rowUpdate.ts';
+
+import type { GenesisMessage, IndexDef, MockServerConfig, QueryDef, Row } from '../types.ts';
+import { permittedQueryRow, requestingUser } from './resourceAuth.ts';
 
 // The real dataserver's defaults (genesis-pal-dataserver ClientOptions,
 // GSF 8.15.x) — also what foundation-comms' DatasourceDefaults send.
@@ -75,6 +78,43 @@ function takePage(subscription: Subscription): Row[] {
   return page;
 }
 
+// The dataserver's own refusal of a logon (genesis-pal-dataserver): a
+// LOGON_NACK with a StandardError, sent instead of LOGON_ACK. No subscription
+// is opened, so a later DATA_LOGOFF on it gets the router's 404.
+function logonNack(code: 'INVALID_CRITERIA' | 'INVALID_INDEX', text: string): Row {
+  return {
+    MESSAGE_TYPE: MESSAGE_TYPE.LOGON_NACK,
+    ERROR: [{ '@type': 'StandardError', CODE: code, TEXT: text, STATUS_CODE: '400 Bad Request' }],
+    WARNING: [],
+  };
+}
+
+// DETAILS.FIELDS: a space-separated projection of the query's columns, in the
+// query's order. Names it doesn't expose are dropped, as the real dataserver
+// drops them.
+function requestedFieldNames(
+  details: Row,
+  query: QueryDef,
+  exposed: string[] | undefined,
+  config: MockServerConfig,
+  store: Store,
+): string[] | undefined {
+  const requested =
+    typeof details.FIELDS === 'string' && details.FIELDS.trim() !== ''
+      ? details.FIELDS.trim().split(/\s+/)
+      : undefined;
+  if (!requested) return exposed;
+  const available = exposed ?? querySchema(query, config, store).fields.map((field) => field.name);
+  return available.filter((name) => requested.includes(name));
+}
+
+// Ascending by the index's fields, nulls first. Ties are broken by RECORD_ID,
+// as the real index breaks them, so REVERSE, which flips the whole order,
+// puts the newest of equal rows first.
+function indexComparator(index: IndexDef): (a: Row, b: Row) => number {
+  return rowComparator(index.fields.map((field) => ({ field, descending: false })));
+}
+
 // DATA_LOGON opens a persistent subscription keyed by SOURCE_REF: reply with
 // LOGON_ACK and the first page of the snapshot, then keep the SOURCE_REF
 // registered so MORE_ROWS can page the rest and later inserts/amends/deletes
@@ -116,6 +156,44 @@ export function handleDataLogon(
 
   const criteria = details.CRITERIA_MATCH;
   const user = requestingUser(connection);
+  // The query's fields block (or the source's declared columns) is all a
+  // criteria may name and all a row carries; DETAILS.FIELDS narrows the rows.
+  // Legacy subscriptions ignore all of it, and ORDER_BY, as 15.47 did.
+  const exposed = queryFieldNames(query, config, store);
+  let compare: ((a: Row, b: Row) => number) | undefined;
+  let reverse = false;
+  if (!legacy) {
+    // The real dataserver lets a criteria read only the query's own fields
+    // (QueryClientFactory.kt). Unknown columns are only checked when the
+    // query's fields are known; an inferred query fails open as before.
+    const outside = exposed && criteriaFields(criteria)?.find((field) => !exposed.includes(field));
+    if (outside) {
+      connection.reply(
+        message,
+        logonNack(
+          'INVALID_CRITERIA',
+          `GenericCriteriaValidationException : Criteria validation failed: Variable ${outside} is not allowed in criteria expression`,
+        ),
+      );
+      return;
+    }
+    // ORDER_BY names one of the query's own indexes (QueryDef.indexes).
+    if (details.ORDER_BY) {
+      const index = query.indexes?.find((candidate) => candidate.name === details.ORDER_BY);
+      if (!index) {
+        connection.reply(
+          message,
+          logonNack(
+            'INVALID_INDEX',
+            `No such index ${details.ORDER_BY} for dataserver query ${resourceName}`,
+          ),
+        );
+        return;
+      }
+      compare = indexComparator(index);
+      reverse = details.REVERSE === true;
+    }
+  }
   // Order matters: the query's own filter (the where-clause equivalent) and
   // the user's row permissioning narrow the set BEFORE the client's
   // CRITERIA_MATCH; hidden fields are stripped last, off the final rows.
@@ -129,20 +207,39 @@ export function handleDataLogon(
   // the count is taken after it — an assumption, as no recording covers it.
   const rowsCount = rows.length;
   rows = filterByCriteria(rows, criteria);
+  if (compare) {
+    rows = [...rows].sort(compare);
+    if (reverse) rows.reverse();
+  }
   // Permissioning is applied per row so the ROW_REF can still be computed from
   // the UNSTRIPPED row — pk fields may themselves be hidden from this user,
   // and a snapshot row with no ROW_REF can never be matched to the later
   // INSERT/MODIFY/DELETE pushes (which stamp the real ref, see server.ts).
+  // RECORD_ID (or, in legacy mode, the pk fields) is never sent unless the
+  // query's fields block names it.
+  const getRowRef = (row: Row) => rowRefFor(config, store, query.source, row);
+
+  const fieldNames = legacy
+    ? undefined
+    : requestedFieldNames(details, query, exposed, config, store);
   const stampedRows: Row[] = [];
+  // Each sent-or-waiting row as stored, by pending key, for ORDER_BY's live
+  // INSERT placement below.
+  const rawRows = new Map<string, Row>();
   for (const row of rows) {
-    const [permitted] = applyResourceAuth([row], query.auth, user);
+    const permitted = permittedQueryRow(row, query.auth, user, fieldNames);
     if (!permitted) continue;
-    stampedRows.push(stampRow(permitted, store.getRowRef(query.source, row), 'INSERT'));
+    const rowRef = getRowRef(row);
+    const key = pendingKey(rowRef);
+    if (key !== undefined) rawRows.set(key, row);
+    stampedRows.push(
+      stampRow(dataserverRow(permitted, row, query.fields), rowRef, 'INSERT', legacy),
+    );
   }
 
   const subscription: Subscription = {
     resourceName,
-    getRowRef: (row) => store.getRowRef(query.source, row),
+    getRowRef,
     predicate: compileCriteria(criteria),
     sequenceId: 1,
   };
@@ -170,7 +267,30 @@ export function handleDataLogon(
     held: new Set<string>(),
     maxRows,
     maxView,
+    fieldNames,
   };
+  // Under ORDER_BY a live INSERT that sorts among the rows still waiting for
+  // MORE_ROWS joins them in order rather than being pushed out of order; one
+  // that sorts before them lands in what the client has, and is pushed. (A
+  // MODIFY of a waiting row keeps its place.)
+  if (compare) {
+    const ascending = compare;
+    const sortCompare = reverse ? (a: Row, b: Row) => ascending(b, a) : ascending;
+    tracked.queueInsert = (key, stamped, row) => {
+      const waiting = [...tracked.pending!];
+      const first = waiting[0] && rawRows.get(waiting[0][0]);
+      if (!first || sortCompare(row, first) < 0) return false;
+      const at = waiting.findIndex(([waitingKey]) => {
+        const other = rawRows.get(waitingKey);
+        return other !== undefined && sortCompare(row, other) < 0;
+      });
+      waiting.splice(at < 0 ? waiting.length : at, 0, [key, stamped]);
+      tracked.pending!.clear();
+      for (const [waitingKey, waitingRow] of waiting) tracked.pending!.set(waitingKey, waitingRow);
+      rawRows.set(key, row);
+      return true;
+    };
+  }
   const firstPage = takePage(tracked);
   const pending = tracked.pending!;
   connection.subscribe(sourceRef, tracked);

package/src/handlers/eventValidation.ts

@@ -0,0 +1,43 @@
+import { eventFields, isDeclared, resolveEventTarget } from '../db/schema.ts';
+import type { Store } from '../db/store.ts';
+import type { Connection } from '../protocol/connection.ts';
+import type { NackErrorInput } from '../protocol/errors.ts';
+import { schemaFieldErrors, validateSchema } from '../protocol/schemaValidation.ts';
+import type { GenesisMessage, MockServerConfig } from '../types.ts';
+import { eventInboundSchema } from './jsonSchema.ts';
+
+// The schema check every event goes through on the real server before its
+// handler runs (GenesisMessageDecoder, GSF v8.15.29): the whole message
+// against the event's INBOUND JSON schema — the one JSON_SCHEMA_REQUEST
+// serves — each failure a FieldError VALIDATION_ERROR (see
+// protocol/schemaValidation.ts). An empty list means it passed.
+//
+// Only an event whose DETAILS class is declared is checked: a table event on
+// a table with TableDef.fields, or an eventSchemas entry with `fields`. An
+// inferred schema is a guess from the seed rows (a column every row leaves
+// empty isn't in it at all), and checking against it would NACK payloads the
+// real server accepts.
+export function validateEventMessage(
+  message: GenesisMessage,
+  connection: Connection,
+  config: MockServerConfig,
+  store: Store,
+): NackErrorInput[] {
+  const name = message.MESSAGE_TYPE;
+  const target = resolveEventTarget(name, config);
+  if (!target) return [];
+  const declared =
+    target.kind === 'dto' ||
+    (target.table !== undefined && isDeclared(target.table, config, store));
+  if (!declared) return [];
+  const inbound = eventInboundSchema(
+    name,
+    target,
+    eventFields(target, config, store),
+    config.appName,
+  );
+  // The router stamps the session's user on everything it forwards, so the
+  // schema's required USER_NAME is always there by the time it is checked.
+  const forwarded = { ...message, USER_NAME: connection.userName ?? '' };
+  return schemaFieldErrors(validateSchema(inbound, forwarded));
+}