@genesislcap/mock-server 15.52.0 → 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,6 +1,5 @@
 import { compileCriteria, criteriaFields, filterByCriteria } from '../db/criteria.ts';
-import { RECORD_ID } from '../db/identity.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';
@@ -112,24 +111,8 @@ function requestedFieldNames(
 // 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 {
-  const 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;
-  };
-  return (a, b) => {
-    for (const field of index.fields) {
-      const result = compareValues(a[field], b[field]);
-      if (result !== 0) return result;
-    }
-    return compareValues(a[RECORD_ID], b[RECORD_ID]);
-  };
+  return rowComparator(index.fields.map((field) => ({ field, descending: false })));
 }
 
 // DATA_LOGON opens a persistent subscription keyed by SOURCE_REF: reply with

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

package/src/handlers/jsonSchema.ts

@@ -5,9 +5,9 @@ import {
   knownValues,
   isDeleteEventName,
   querySchema,
-  RECORD_IDENTITY_FIELDS,
   requestFieldsOf,
-  requestReplySchema,
+  requestReplyReplySchema,
+  requestReplySourceSchema,
   resolveEventTarget,
   resolveSourceSchema,
   withTypeOverrides,
@@ -101,12 +101,15 @@ function isRequired(field: ResolvedField): boolean {
   return !field.optional;
 }
 
-function eventSchema(
+// An event's INBOUND schema: the message, with DETAILS as the event's class.
+// It is also what an inbound event is validated against
+// (handlers/eventValidation.ts), as on the real server.
+export function eventInboundSchema(
   eventName: string,
   target: EventTarget,
   fields: ResolvedField[],
   appName: string | undefined,
-): { INBOUND: Row; OUTBOUND: Row } {
+): Row {
   const annotated = target.kind === 'table';
   const details = {
     properties: Object.fromEntries(
@@ -117,16 +120,25 @@ function eventSchema(
     type: 'object',
   };
   return {
-    INBOUND: {
-      properties: eventInboundProperties(eventName, details),
-      required: ['MESSAGE_TYPE', 'SOURCE_REF', 'USER_NAME', 'DETAILS'],
-      additionalProperties: true,
-      description: target.className,
-      ...(target.title ? { title: target.title } : {}),
-      $defs: {},
-      $schema: GENESIS_META_SCHEMA,
-      type: 'object',
-    },
+    properties: eventInboundProperties(eventName, details),
+    required: ['MESSAGE_TYPE', 'SOURCE_REF', 'USER_NAME', 'DETAILS'],
+    additionalProperties: true,
+    description: target.className,
+    ...(target.title ? { title: target.title } : {}),
+    $defs: {},
+    $schema: GENESIS_META_SCHEMA,
+    type: 'object',
+  };
+}
+
+function eventSchema(
+  eventName: string,
+  target: EventTarget,
+  fields: ResolvedField[],
+  appName: string | undefined,
+): { INBOUND: Row; OUTBOUND: Row } {
+  return {
+    INBOUND: eventInboundSchema(eventName, target, fields, appName),
     OUTBOUND: eventReplySchema(),
   };
 }
@@ -171,10 +183,10 @@ function requestServerSchema(
   config: MockServerConfig,
   store: Store,
 ): { INBOUND: Row; OUTBOUND: Row } {
-  const replyFields = requestReplySchema(requestReply, config, store).fields;
+  const entityFields = requestReplySourceSchema(requestReply, config, store).fields;
   const requestProperties = Object.fromEntries(
     requestFieldsOf(requestReply, store).map((fieldName) => {
-      const field = replyFields.find((candidate) => candidate.name === fieldName);
+      const field = entityFields.find((candidate) => candidate.name === fieldName);
       const type = field?.type ?? 'STRING';
       return [
         fieldName,
@@ -189,9 +201,9 @@ function requestServerSchema(
     }),
   );
   const request = { properties: requestProperties, additionalProperties: false, type: 'object' };
-  const fields = requestReply.criteriaOnly
-    ? [...replyFields, ...RECORD_IDENTITY_FIELDS]
-    : replyFields;
+  // The reply block, else the source's fields then RECORD_ID and TIMESTAMP,
+  // as REPLY_FIELD (see requestReplyReplySchema).
+  const fields = requestReplyReplySchema(requestReply, config, store).fields;
   return {
     INBOUND: {
       properties: {

package/src/handlers/meta.ts

@@ -3,9 +3,10 @@ import {
   eventFields,
   knownValues,
   querySchema,
-  RECORD_IDENTITY_FIELDS,
   requestFieldsOf,
+  requestReplyReplySchema,
   requestReplySchema,
+  requestReplySourceSchema,
   resolveEventTarget,
   type EventTarget,
   type ResolvedField,
@@ -78,9 +79,13 @@ function dataserverMeta(
 }
 
 // The two request-server shapes of ReqRepMetaData.kt: criteria-only
-// (REQUEST_FIELD: [], SORTABLE_FIELDS, CRITERIA_FIELDS, RECORD_ID and
-// TIMESTAMP in REPLY_FIELD, no INDICES) and plain (REQUEST_FIELD from the
-// request block, INDICES: [], CRITERIA_ONLY_REQUEST: false).
+// (REQUEST_FIELD: [], SORTABLE_FIELDS, CRITERIA_FIELDS, no INDICES) and plain
+// (REQUEST_FIELD from the request block, INDICES: [],
+// CRITERIA_ONLY_REQUEST: false). REPLY_FIELD is the reply block, else the
+// source's fields then RECORD_ID and TIMESTAMP, for either
+// (requestReplyReplySchema). SORTABLE_FIELDS and CRITERIA_FIELDS are the
+// entity's fields whatever the reply block says (the dictionary entry's
+// nativeQueryFields, RequestReplyServer.kt).
 function requestServerMeta(
   name: string,
   requestReply: RequestReplyDef,
@@ -89,23 +94,23 @@ function requestServerMeta(
   hidden: Set<string>,
 ): Row {
   const visible = (field: ResolvedField) => !hidden.has(field.name);
-  const replyFields = requestReplySchema(requestReply, config, store).fields.filter(visible);
+  const replyFields = requestReplyReplySchema(requestReply, config, store).fields.filter(visible);
+  const entityFields = requestReplySourceSchema(requestReply, config, store).fields;
   if (requestReply.criteriaOnly) {
-    const fields = [...replyFields, ...RECORD_IDENTITY_FIELDS.filter(visible)];
-    const names = fields.map((field) => field.name);
+    const names = entityFields.filter(visible).map((field) => field.name);
     return {
       TYPE: 'REQUEST_SERVER',
       REQUEST_FIELD: [],
       CRITERIA_ONLY_REQUEST: true,
       SORTABLE_FIELDS: names,
       CRITERIA_FIELDS: names,
-      REPLY_FIELD: fields.map(fieldMetadata),
+      REPLY_FIELD: replyFields.map(fieldMetadata),
       NAME: name,
     };
   }
   const requestFields = requestFieldsOf(requestReply, store).map(
     (fieldName) =>
-      replyFields.find((field) => field.name === fieldName) ?? {
+      entityFields.find((field) => field.name === fieldName) ?? {
         name: fieldName,
         type: 'STRING',
         nullable: false,