@genesislcap/mock-server 15.51.1 → 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,9 +1,11 @@
-import { compileCriteria, filterByCriteria } from "../db/criteria.js";
+import { compileCriteria, criteriaFields, filterByCriteria } from "../db/criteria.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";
 import { nonExistentSubscriptionNack, resourceNotMappedNack, subscriptionAlreadyExistsNack, } from "../protocol/msgNack.js";
-import { stampRow } from "../protocol/rowUpdate.js";
-import { applyResourceAuth, requestingUser } from "./resourceAuth.js";
+import { dataserverRow, rowRefFor, stampRow } from "../protocol/rowUpdate.js";
+import { permittedQueryRow, requestingUser } from "./resourceAuth.js";
 // The real dataserver's defaults (genesis-pal-dataserver ClientOptions,
 // GSF 8.15.x) — also what foundation-comms' DatasourceDefaults send.
 const DEFAULT_MAX_ROWS = 250;
@@ -57,6 +59,34 @@ function takePage(subscription) {
     }
     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, text) {
+    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, query, exposed, config, store) {
+    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) {
+    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
@@ -87,6 +117,32 @@ export function handleDataLogon(message, connection, config, store) {
     }
     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;
+    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.
@@ -101,20 +157,38 @@ export function handleDataLogon(message, connection, config, store) {
     // 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) => rowRefFor(config, store, query.source, row);
+    const fieldNames = legacy
+        ? undefined
+        : requestedFieldNames(details, query, exposed, config, store);
     const stampedRows = [];
+    // Each sent-or-waiting row as stored, by pending key, for ORDER_BY's live
+    // INSERT placement below.
+    const rawRows = new Map();
     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 = {
         resourceName,
-        getRowRef: (row) => store.getRowRef(query.source, row),
+        getRowRef,
         predicate: compileCriteria(criteria),
         sequenceId: 1,
     };
@@ -140,7 +214,32 @@ export function handleDataLogon(message, connection, config, store) {
         held: new Set(),
         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, b) => 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/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,5 +1,7 @@
+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';
-export declare function inferEventTable(eventName: string | undefined, tableNames: string[]): string | undefined;
+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,21 +1,217 @@
-import { deriveFields } from "../db/metadata.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";
 import { ERROR_CODE, MESSAGE_TYPE } from "../protocol/messageTypes.js";
 import { resourceNotMappedNack } from "../protocol/msgNack.js";
+// Kept here for existing importers; the resolver lives in db/schema.ts.
+export { inferEventTable };
 // JSON_SCHEMA_REQUEST shares its request envelope with META_REQUEST (same
 // DETAILS.FEATURE resource-name field) but its reply is a completely
 // different shape: Connect.getJSONSchema doesn't read response.DETAILS at
 // all — the response *is* the SchemaResponse ({ INBOUND, OUTBOUND }, each a
-// draft-07 JSON Schema). @genesislcap/foundation-entity-management's
-// <entity-management> calls this for every create/update form (fields come
-// from INBOUND.properties.DETAILS.properties) and for delete confirmation
-// (it reads Object.keys(...properties) to know which fields to copy from the
-// selected row into the commit DETAILS). Route this to handleMetaRequest by
-// mistake and forms silently render with zero fields, and delete can never
-// build a payload — no error, just a dead button. The real success reply is
-// JSON_SCHEMA_FEATURE_ACK with INBOUND/OUTBOUND at the top level (legacy mode
-// echoed JSON_SCHEMA_REQUEST).
-function jsonSchemaType(fieldType) {
+// JSON Schema). Who reads what:
+// - foundation-forms' <foundation-form> (and so entity-management's create
+//   and update forms) renders INBOUND.properties.DETAILS of an EVENT: its
+//   properties, required, enum, default, title, and genesisType / the
+//   org.joda.time.DateTime description for date pickers.
+// - entity-management's delete copies Object.keys(INBOUND...DETAILS
+//   .properties) from the selected row into the commit DETAILS.
+// - foundation-forms' <foundation-filters> renders a QUERY's or REQUEST
+//   SERVER's rows: OUTBOUND.properties.REPLY.items, else
+//   OUTBOUND.$defs[...QueryRow].
+// Route this to handleMetaRequest by mistake and forms silently render with
+// zero fields, and delete can never build a payload — no error, just a dead
+// button.
+// --- events -----------------------------------------------------------------
+// One DETAILS property of an event's INBOUND schema. Nullable fields are
+// oneOf [schema, null]; BigDecimal is a string with a pattern and no
+// genesisType; dates are integers (epoch millis) described as DateTime. Only
+// a table event's DAO class has titles, lengths, ranges and genesisTypes
+// (see meta.ts eventMetaField).
+function eventProperty(field, annotated, appName) {
+    const type = field.type;
+    const property = {};
+    if (annotated && type === 'STRING') {
+        if (field.minLength !== undefined)
+            property.minLength = field.minLength;
+        if (field.maxSize !== undefined)
+            property.maxLength = field.maxSize;
+    }
+    if (type === 'BIGDECIMAL')
+        property.pattern = BIGDECIMAL_PATTERN;
+    const range = annotated ? rangeOf(type) : undefined;
+    if (range)
+        [property.minimum, property.maximum] = range;
+    property.readOnly = false;
+    if (type === 'ENUM' && knownValues(field))
+        property.enum = knownValues(field);
+    property.description =
+        field.description ?? jvmClassOf(type, () => enumClassOf(field.table, field.name, appName));
+    const fieldDefault = eventDefaultOf(field);
+    if (fieldDefault !== undefined)
+        property.default = fieldDefault;
+    if (annotated)
+        property.title = field.title ?? titleCase(field.name);
+    if (annotated && type !== 'BIGDECIMAL')
+        property.genesisType = type;
+    property.type = jsonTypeOf(type);
+    return field.nullable ? { oneOf: [property, { type: 'null' }] } : property;
+}
+// required: the fields that aren't optional (JsonSchema.kt:478), as
+// eventFields resolved them. A sequence key is optional: the database fills
+// it in; a nullable DTO field with no default is still required.
+function isRequired(field) {
+    return !field.optional;
+}
+// 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)])),
+        required: fields.filter(isRequired).map((field) => field.name),
+        additionalProperties: false,
+        type: 'object',
+    };
+    return {
+        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(),
+    };
+}
+// --- dataservers and request servers ---------------------------------------
+function typeSchema(field) {
+    return {
+        type: jsonTypeOf(field.type),
+        ...(field.type === 'ENUM' && knownValues(field) ? { enum: knownValues(field) } : {}),
+    };
+}
+// A row property in a reply schema: nullable as oneOf [null, schema], with
+// an empty description and the Genesis type (BigDecimal included).
+function rowProperty(field, nullable) {
+    return nullable
+        ? { oneOf: [{ type: 'null' }, typeSchema(field)], description: '', genesisType: field.type }
+        : { ...typeSchema(field), description: '', genesisType: field.type };
+}
+// Every QueryRow property is nullable: a live MODIFY carries only the fields
+// that changed.
+function dataserverSchema(queryName, query, config, store) {
+    const fields = querySchema(query, config, store).fields;
+    return {
+        INBOUND: dataLogonSchema(queryName),
+        OUTBOUND: dataLogonReplySchema(Object.fromEntries(fields.map((field) => [field.name, rowProperty(field, true)]))),
+    };
+}
+function requestServerSchema(name, requestReply, config, store) {
+    const entityFields = requestReplySourceSchema(requestReply, config, store).fields;
+    const requestProperties = Object.fromEntries(requestFieldsOf(requestReply, store).map((fieldName) => {
+        const field = entityFields.find((candidate) => candidate.name === fieldName);
+        const type = field?.type ?? 'STRING';
+        return [
+            fieldName,
+            {
+                readOnly: false,
+                ...(type === 'ENUM' && field && knownValues(field) ? { enum: knownValues(field) } : {}),
+                description: '',
+                genesisType: type,
+                type: jsonTypeOf(type),
+            },
+        ];
+    }));
+    const request = { properties: requestProperties, additionalProperties: false, type: 'object' };
+    // 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: {
+                MESSAGE_TYPE: { const: `REQ_${name}`, description: 'Message type', type: 'string' },
+                SOURCE_REF: { description: 'Source reference', type: 'string' },
+                USER_NAME: { description: 'User name', type: 'string' },
+                REQUEST: { oneOf: [request, { items: request, type: 'array' }] },
+                DETAILS: REQUEST_DETAILS_SCHEMA,
+            },
+            required: ['MESSAGE_TYPE', 'SOURCE_REF', 'USER_NAME', 'REQUEST'],
+            additionalProperties: false,
+            description: `GPAL Request definition for ${name}`,
+            $defs: {},
+            type: 'object',
+        },
+        OUTBOUND: {
+            description: `GPAL Reply definition for ${name}`,
+            type: 'object',
+            properties: {
+                MESSAGE_TYPE: { const: `REP_${name}` },
+                SOURCE_REF: { type: 'string' },
+                REPLY: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: Object.fromEntries(fields.map((field) => [field.name, rowProperty(field, field.nullable)])),
+                        additionalProperties: false,
+                        required: [],
+                    },
+                },
+                NEXT_VIEW: { type: 'number' },
+            },
+            required: ['MESSAGE_TYPE', 'SOURCE_REF'],
+            additionalProperties: false,
+        },
+    };
+}
+// The FEATURE resolves, in order, as: an entry in config.eventSchemas, a
+// dataserver query, a request server (by resource name, without REQ_), an
+// EVENT_<TABLE>_<VERB> event, and finally a bare table name — the last is
+// this engine's own fallback for clients that ask by table (the real server
+// answers 404 there). Anything else gets the router's 404.
+export function handleJsonSchemaRequest(message, connection, config, store) {
+    const feature = message.DETAILS?.FEATURE;
+    if (isLegacyFidelity(config)) {
+        handleLegacyJsonSchemaRequest(message, connection, config, store, feature);
+        return;
+    }
+    const overridden = feature !== undefined && !!config.eventSchemas?.[feature];
+    const query = !overridden && feature ? config.queries?.[feature] : undefined;
+    const requestReply = !overridden && feature ? config.requestReplies?.[feature] : undefined;
+    let schema;
+    if (query) {
+        schema = dataserverSchema(feature, query, config, store);
+    }
+    else if (requestReply) {
+        schema = requestServerSchema(feature, requestReply, config, store);
+    }
+    else {
+        const event = resolveEventTarget(feature, config, { bareTable: true });
+        if (event) {
+            schema = eventSchema(feature, event, eventFields(event, config, store), config.appName);
+        }
+    }
+    if (!schema) {
+        connection.reply(message, resourceNotMappedNack(feature));
+        return;
+    }
+    connection.reply(message, { MESSAGE_TYPE: MESSAGE_TYPE.JSON_SCHEMA_FEATURE_ACK, ...schema });
+}
+// --- fidelity: 'legacy' -----------------------------------------------------
+// Up to 15.47 every FEATURE resolved to a table (or view) and got the same
+// minimal schema as INBOUND and OUTBOUND: {type, properties: {DETAILS:
+// {type, properties: {<field>: {type}}, required}}}, `required` being the key
+// on deletes and empty otherwise. A query or request-server name resolved
+// through its `source`. The reply echoed JSON_SCHEMA_REQUEST.
+function legacyJsonSchemaType(fieldType) {
     switch (fieldType) {
         case 'LONG':
             return 'integer';
@@ -27,10 +223,10 @@ function jsonSchemaType(fieldType) {
             return 'string';
     }
 }
-function buildSchema(fields, required) {
+function legacySchema(fields, required) {
     const properties = {};
     for (const field of fields) {
-        properties[field.NAME] = { type: jsonSchemaType(field.TYPE) };
+        properties[field.NAME] = { type: legacyJsonSchemaType(field.TYPE) };
     }
     return {
         type: 'object',
@@ -39,62 +235,27 @@ function buildSchema(fields, required) {
         },
     };
 }
-const DELETE_EVENT_RE = /_DELETE(_|$)/;
-// Zero-config default: EVENT_<TABLE>_<VERB...> maps to <TABLE> if it's a
-// registered table name (longest match wins, so e.g. a hypothetical
-// COUNTERPARTY_AUTH table can't shadow COUNTERPARTY). Covers every event
-// naming pattern in this codebase (INSERT, MODIFY, DELETE, plus suffixed
-// variants like INSERT_WITH_APPROVAL, DEMO_INSERT, MODIFY_PRICE, INSERT_FAIL)
-// without hand-maintaining a table per event. Override via
-// config.eventSchemas for names that don't follow this convention.
-// Exported for unit tests only.
-export function inferEventTable(eventName, tableNames) {
-    if (!eventName)
-        return undefined;
-    // Not every caller asks by event name: entity-management resolves a grid's
-    // schema from the bare resource/table name (FEATURE: 'TRADE'), so accept an
-    // exact table match before requiring the EVENT_ prefix. Without this the
-    // request errors with UNKNOWN_RESOURCE and the form renders no fields.
-    if (tableNames.includes(eventName))
-        return eventName;
-    if (!eventName.startsWith('EVENT_'))
-        return undefined;
-    const rest = eventName.slice('EVENT_'.length);
-    const candidates = tableNames.filter((name) => rest === name || rest.startsWith(`${name}_`));
-    candidates.sort((a, b) => b.length - a.length);
-    return candidates[0];
-}
-export function handleJsonSchemaRequest(message, connection, config, store) {
-    const eventName = message.DETAILS?.FEATURE;
-    const override = eventName ? config.eventSchemas?.[eventName] : undefined;
-    // A DATASERVER/REQUEST_SERVER resource name (e.g. 'ALL_USERS') resolves
-    // through its own definition to the backing table/view. The FAST-Element
-    // showcase's entity-management grids ask by query name, not by table or
-    // event name, so without this their create/update forms render empty.
-    const resourceSource = eventName
-        ? (config.queries?.[eventName]?.source ?? config.requestReplies?.[eventName]?.source)
+function handleLegacyJsonSchemaRequest(message, connection, config, store, feature) {
+    const override = feature ? config.eventSchemas?.[feature] : undefined;
+    const resourceSource = feature
+        ? (config.queries?.[feature]?.source ?? config.requestReplies?.[feature]?.source)
         : undefined;
-    const table = override?.table ??
-        resourceSource ??
-        inferEventTable(eventName, Object.keys(config.tables ?? {}));
-    const legacy = isLegacyFidelity(config);
+    const table = override?.table ?? resourceSource ?? inferEventTable(feature, Object.keys(config.tables ?? {}));
     if (!table) {
-        connection.reply(message, legacy
-            ? {
-                MESSAGE_TYPE: message.MESSAGE_TYPE,
-                ERROR: [{ CODE: ERROR_CODE.UNKNOWN_RESOURCE, TEXT: `Unknown resource: ${eventName}` }],
-            }
-            : resourceNotMappedNack(eventName));
+        connection.reply(message, {
+            MESSAGE_TYPE: message.MESSAGE_TYPE,
+            ERROR: [{ CODE: ERROR_CODE.UNKNOWN_RESOURCE, TEXT: `Unknown resource: ${feature}` }],
+        });
         return;
     }
-    const pkOnly = override?.pkOnly ?? DELETE_EVENT_RE.test(eventName);
+    const pkOnly = override?.pkOnly ?? isDeleteEventName(feature);
     const pkFields = store.getPkFields(table);
-    let fields = deriveFields(store.getMetadataRows(table), override?.fieldTypes);
+    let fields = withTypeOverrides(resolveSourceSchema(table, config, store), override?.fieldTypes).fields.map((field) => ({ NAME: field.name, TYPE: field.type }));
     if (pkOnly)
         fields = fields.filter((field) => pkFields.includes(field.NAME));
-    const schema = buildSchema(fields, pkOnly ? pkFields : []);
+    const schema = legacySchema(fields, pkOnly ? pkFields : []);
     connection.reply(message, {
-        MESSAGE_TYPE: legacy ? message.MESSAGE_TYPE : MESSAGE_TYPE.JSON_SCHEMA_FEATURE_ACK,
+        MESSAGE_TYPE: message.MESSAGE_TYPE,
         INBOUND: schema,
         OUTBOUND: schema,
     });