@genesislcap/mock-server 15.52.0 → 15.53.0

package/dist/handlers/crudEvents.js

@@ -0,0 +1,138 @@
+// 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.js";
+import { crudEventOf, generatedFieldList, pkFieldsOf, primaryKeyIndexName, secondaryUniqueIndexes, } from "../db/schema.js";
+import { NackError } from "../protocol/errors.js";
+const isMissing = (value) => 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, row) {
+    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, def, row, store, self) {
+    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) => 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, details, fieldNames) {
+    const generated = new Set(generatedFieldList(def));
+    const pkFields = pkFieldsOf(def);
+    const record = { ...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, def, details, ctx) {
+    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, def, details, ctx) {
+    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, _def, details, ctx) {
+    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 = { 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, config) {
+    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/dist/handlers/dataLogon.js

@@ -1,5 +1,5 @@
 import { compileCriteria, criteriaFields, filterByCriteria } from "../db/criteria.js";
-import { RECORD_ID } from "../db/identity.js";
+import { rowComparator } from "../db/ordering.js";
 import { queryFieldNames, querySchema } from "../db/schema.js";
 import { isLegacyFidelity } from "../protocol/fidelity.js";
 import { MESSAGE_TYPE, ERROR_CODE } from "../protocol/messageTypes.js";
@@ -85,28 +85,7 @@ function requestedFieldNames(details, query, exposed, config, store) {
 // as the real index breaks them, so REVERSE, which flips the whole order,
 // puts the newest of equal rows first.
 function indexComparator(index) {
-    const compareValues = (a, b) => {
-        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
 // LOGON_ACK and the first page of the snapshot, then keep the SOURCE_REF

package/dist/handlers/eventValidation.d.ts

@@ -0,0 +1,5 @@
+import type { Store } from '../db/store.ts';
+import type { Connection } from '../protocol/connection.ts';
+import type { NackErrorInput } from '../protocol/errors.ts';
+import type { GenesisMessage, MockServerConfig } from '../types.ts';
+export declare function validateEventMessage(message: GenesisMessage, connection: Connection, config: MockServerConfig, store: Store): NackErrorInput[];

package/dist/handlers/eventValidation.js

@@ -0,0 +1,29 @@
+import { eventFields, isDeclared, resolveEventTarget } from "../db/schema.js";
+import { schemaFieldErrors, validateSchema } from "../protocol/schemaValidation.js";
+import { eventInboundSchema } from "./jsonSchema.js";
+// 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, connection, config, store) {
+    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/dist/handlers/jsonSchema.d.ts

@@ -1,6 +1,7 @@
-import { inferEventTable } from '../db/schema.ts';
+import { inferEventTable, type EventTarget, type ResolvedField } from '../db/schema.ts';
 import type { Store } from '../db/store.ts';
 import type { Connection } from '../protocol/connection.ts';
-import type { GenesisMessage, MockServerConfig } from '../types.ts';
+import type { GenesisMessage, MockServerConfig, Row } from '../types.ts';
 export { inferEventTable };
+export declare function eventInboundSchema(eventName: string, target: EventTarget, fields: ResolvedField[], appName: string | undefined): Row;
 export declare function handleJsonSchemaRequest(message: GenesisMessage, connection: Connection, config: MockServerConfig, store: Store): void;

package/dist/handlers/jsonSchema.js

@@ -1,4 +1,4 @@
-import { eventDefaultOf, eventFields, inferEventTable, knownValues, isDeleteEventName, querySchema, RECORD_IDENTITY_FIELDS, requestFieldsOf, requestReplySchema, resolveEventTarget, resolveSourceSchema, withTypeOverrides, } from "../db/schema.js";
+import { eventDefaultOf, eventFields, inferEventTable, knownValues, isDeleteEventName, querySchema, requestFieldsOf, requestReplyReplySchema, requestReplySourceSchema, resolveEventTarget, resolveSourceSchema, withTypeOverrides, } from "../db/schema.js";
 import { isLegacyFidelity } from "../protocol/fidelity.js";
 import { BIGDECIMAL_PATTERN, enumClassOf, jsonTypeOf, jvmClassOf, rangeOf, titleCase, } from "../protocol/fieldTypes.js";
 import { dataLogonReplySchema, dataLogonSchema, eventInboundProperties, eventReplySchema, GENESIS_META_SCHEMA, REQUEST_DETAILS_SCHEMA, } from "../protocol/gsfSchemas.js";
@@ -64,7 +64,10 @@ function eventProperty(field, annotated, appName) {
 function isRequired(field) {
     return !field.optional;
 }
-function eventSchema(eventName, target, fields, appName) {
+// 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, target, fields, appName) {
     const annotated = target.kind === 'table';
     const details = {
         properties: Object.fromEntries(fields.map((field) => [field.name, eventProperty(field, annotated, appName)])),
@@ -73,16 +76,19 @@ function eventSchema(eventName, target, fields, appName) {
         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, target, fields, appName) {
+    return {
+        INBOUND: eventInboundSchema(eventName, target, fields, appName),
         OUTBOUND: eventReplySchema(),
     };
 }
@@ -110,9 +116,9 @@ function dataserverSchema(queryName, query, config, store) {
     };
 }
 function requestServerSchema(name, requestReply, config, store) {
-    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,
@@ -126,9 +132,9 @@ function requestServerSchema(name, requestReply, config, store) {
         ];
     }));
     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/dist/handlers/meta.js

@@ -1,4 +1,4 @@
-import { eventDefaultOf, eventFields, knownValues, querySchema, RECORD_IDENTITY_FIELDS, requestFieldsOf, requestReplySchema, resolveEventTarget, } from "../db/schema.js";
+import { eventDefaultOf, eventFields, knownValues, querySchema, requestFieldsOf, requestReplyReplySchema, requestReplySchema, requestReplySourceSchema, resolveEventTarget, } from "../db/schema.js";
 import { isLegacyFidelity } from "../protocol/fidelity.js";
 import { enumClassOf, eventMetaTypeOf, jsonTypeOf, jvmClassOf, rangeOf, titleCase, } from "../protocol/fieldTypes.js";
 import { eventReplyMeta } from "../protocol/gsfSchemas.js";
@@ -35,26 +35,30 @@ function dataserverMeta(name, query, config, store, hidden) {
     };
 }
 // 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, requestReply, config, store, hidden) {
     const visible = (field) => !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) ?? {
+    const requestFields = requestFieldsOf(requestReply, store).map((fieldName) => entityFields.find((field) => field.name === fieldName) ?? {
         name: fieldName,
         type: 'STRING',
         nullable: false,