@genesislcap/mock-server 15.51.1 → 15.52.0

package/dist/handlers/jsonSchema.js

@@ -1,21 +1,211 @@
-import { deriveFields } from "../db/metadata.js";
+import { eventDefaultOf, eventFields, inferEventTable, knownValues, isDeleteEventName, querySchema, RECORD_IDENTITY_FIELDS, requestFieldsOf, requestReplySchema, 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;
+}
+function eventSchema(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 {
+        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',
+        },
+        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 replyFields = requestReplySchema(requestReply, config, store).fields;
+    const requestProperties = Object.fromEntries(requestFieldsOf(requestReply, store).map((fieldName) => {
+        const field = replyFields.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' };
+    const fields = requestReply.criteriaOnly
+        ? [...replyFields, ...RECORD_IDENTITY_FIELDS]
+        : replyFields;
+    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 +217,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 +229,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,
     });

package/dist/handlers/meta.d.ts

@@ -1,4 +1,9 @@
+import { 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 declare function eventMetaField(field: ResolvedField, { annotated, appName }: {
+    annotated: boolean;
+    appName?: string;
+}): Row;
 export declare function handleMetaRequest(message: GenesisMessage, connection: Connection, config: MockServerConfig, store: Store): void;

package/dist/handlers/meta.js

@@ -1,5 +1,7 @@
-import { deriveFields } from "../db/metadata.js";
+import { eventDefaultOf, eventFields, knownValues, querySchema, RECORD_IDENTITY_FIELDS, requestFieldsOf, requestReplySchema, 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";
 import { ERROR_CODE, MESSAGE_TYPE } from "../protocol/messageTypes.js";
 import { resourceNotMappedNack } from "../protocol/msgNack.js";
 import { hiddenFields, requestingUser } from "./resourceAuth.js";
@@ -9,19 +11,141 @@ import { hiddenFields, requestingUser } from "./resourceAuth.js";
 function resolveResourceName(message) {
     return (message.DETAILS?.FEATURE ?? message.DETAILS?.DATASOURCE_NAME ?? message.DETAILS?.RESOURCE_NAME);
 }
+// A FIELD / REQUEST_FIELD / REPLY_FIELD entry: VALID_VALUES on ENUM fields
+// only (DataServerMetaData.kt, ReqRepMetaData.kt).
+function fieldMetadata(field) {
+    return {
+        NAME: field.name,
+        TYPE: field.type,
+        ...(field.type === 'ENUM' && knownValues(field) ? { VALID_VALUES: knownValues(field) } : {}),
+    };
+}
+// Index-less queries report the unnamed RECORD_ID index the real dataserver
+// adds (QueryDefinition.DEFAULT_RECORD_ID_INDEX).
+const DEFAULT_INDEXES = [{ NAME: null, FIELDS: 'RECORD_ID' }];
+function dataserverMeta(name, query, config, store, hidden) {
+    const fields = querySchema(query, config, store).fields.filter((field) => !hidden.has(field.name));
+    return {
+        TYPE: 'DATASERVER',
+        NAME: name,
+        FIELD: fields.map(fieldMetadata),
+        INDEXES: query.indexes?.length
+            ? query.indexes.map((index) => ({ NAME: index.name, FIELDS: index.fields.join(' ') }))
+            : DEFAULT_INDEXES,
+    };
+}
+// 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).
+function requestServerMeta(name, requestReply, config, store, hidden) {
+    const visible = (field) => !hidden.has(field.name);
+    const replyFields = requestReplySchema(requestReply, config, store).fields.filter(visible);
+    if (requestReply.criteriaOnly) {
+        const fields = [...replyFields, ...RECORD_IDENTITY_FIELDS.filter(visible)];
+        const names = fields.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),
+            NAME: name,
+        };
+    }
+    const requestFields = requestFieldsOf(requestReply, store).map((fieldName) => replyFields.find((field) => field.name === fieldName) ?? {
+        name: fieldName,
+        type: 'STRING',
+        nullable: false,
+        generated: false,
+    });
+    return {
+        TYPE: 'REQUEST_SERVER',
+        REQUEST_FIELD: requestFields.map(fieldMetadata),
+        INDICES: [],
+        CRITERIA_ONLY_REQUEST: false,
+        REPLY_FIELD: replyFields.map(fieldMetadata),
+        NAME: name,
+    };
+}
+// One FIELD entry of an event's META (EventMeta's MetaField, flattened as the
+// real server serializes it). Only a table event's class (a generated DAO)
+// carries the dictionary's annotations: TITLE, MIN_LENGTH / MAX_LENGTH,
+// MIN / MAX and GENESIS_TYPE. A delete's <Table>.ById and a custom DTO have
+// none of them (GENESIS_TYPE null). An ENUM always names its values, its
+// class and a DEFAULT_VALUE (the class's first value when the field has no
+// default); DEFAULT appears only when the field has a default.
+export function eventMetaField(field, { annotated, appName }) {
+    const type = field.type;
+    const enumClass = () => enumClassOf(field.table, field.name, appName);
+    const values = knownValues(field);
+    const fieldDefault = eventDefaultOf(field);
+    const meta = { NAME: field.name };
+    if (annotated)
+        meta.TITLE = field.title ?? titleCase(field.name);
+    meta.DESCRIPTION = field.description ?? jvmClassOf(type, enumClass);
+    meta.NULLABLE = field.nullable;
+    if (annotated && type === 'STRING') {
+        if (field.minLength !== undefined)
+            meta.MIN_LENGTH = field.minLength;
+        if (field.maxSize !== undefined)
+            meta.MAX_LENGTH = field.maxSize;
+    }
+    const range = annotated ? rangeOf(type) : undefined;
+    if (range)
+        [meta.MIN, meta.MAX] = range;
+    if (type === 'ENUM') {
+        // The enum class's own default: the declared one, else its first value.
+        if (values)
+            meta.VALID_VALUES = values;
+        const typeDefault = field.default ?? values?.[0];
+        if (typeDefault !== undefined)
+            meta.DEFAULT_VALUE = typeDefault;
+        meta.ENUM_CLASS = enumClass();
+    }
+    meta.TYPE = eventMetaTypeOf(type);
+    meta.JSON_TYPE = jsonTypeOf(type);
+    if (type !== 'ENUM' && field.default !== undefined)
+        meta.DEFAULT_VALUE = field.default;
+    // OPTIONAL is about the payload, resolved by eventFields (schema.ts).
+    meta.OPTIONAL = field.optional ?? false;
+    meta.READ_ONLY = false;
+    if (fieldDefault !== undefined)
+        meta.DEFAULT = fieldDefault;
+    meta.GENESIS_TYPE = annotated ? type : null;
+    return meta;
+}
+function eventMeta(name, target, fields, appName) {
+    const annotated = target.kind === 'table';
+    return {
+        NAME: name,
+        ...(target.title ? { TITLE: target.title } : {}),
+        DESCRIPTION: target.className,
+        FIELD: fields.map((field) => eventMetaField(field, { annotated, appName })),
+        DEFINITIONS: {},
+        REPLY: eventReplyMeta(),
+        REQUIRES_APPROVAL: false,
+        SCHEDULABLE: false,
+        TYPE: 'EVENT_HANDLER',
+    };
+}
 // Connect.getMetadata reads metaResponse.DETAILS (not the top-level message)
 // and extractFieldDefinitions (metadata.utils.ts) branches on DETAILS.TYPE:
 // DATASERVER resources need DETAILS.FIELD, REQUEST_SERVER ones need
 // DETAILS.REPLY_FIELD. Get either wrong and every grid silently reports
-// "Metadata Fetch failed" / "Unsupported resource type: undefined".
-// The real reply is FEATURE_ACK (getMetadata reads only DETAILS, so the type
-// is for fidelity; legacy mode echoed META_REQUEST).
+// "Metadata Fetch failed" / "Unsupported resource type: undefined". Event
+// META is what the AI assistant builds its write tools from
+// (ai-assistant/src/genesis/event-fields.ts): no event META, no write tools.
+// Request servers answer by resource name (TRADE); REQ_TRADE is not a
+// resource name and gets the router's 404, as on the real server.
 export function handleMetaRequest(message, connection, config, store) {
     const resourceName = resolveResourceName(message);
     const query = config.queries?.[resourceName];
     const requestReply = config.requestReplies?.[resourceName];
     const legacy = isLegacyFidelity(config);
-    if (!query && !requestReply) {
+    const event = query || requestReply || legacy ? undefined : resolveEventTarget(resourceName, config);
+    if (!query && !requestReply && !event) {
         connection.reply(message, legacy
             ? {
                 MESSAGE_TYPE: message.MESSAGE_TYPE,
@@ -32,20 +156,39 @@ export function handleMetaRequest(message, connection, config, store) {
             : resourceNotMappedNack(resourceName));
         return;
     }
-    const resolved = (query ?? requestReply);
-    // Resolver-only request-replies have no backing table/view — their field
-    // metadata comes from the def's own metadataRows sample (plus fieldTypes).
-    const rows = resolved.source
-        ? store.getMetadataRows(resolved.source)
-        : (requestReply?.metadataRows ?? []);
-    // Hidden fields disappear from the metadata too — a column the user can't
-    // see must not be offered to the grid at all.
-    const hidden = hiddenFields(resolved.auth, requestingUser(connection));
-    const fields = deriveFields(rows, resolved.fieldTypes).filter((field) => !hidden.has(field.NAME));
-    connection.reply(message, {
-        MESSAGE_TYPE: legacy ? message.MESSAGE_TYPE : MESSAGE_TYPE.FEATURE_ACK,
-        DETAILS: query
-            ? { NAME: resourceName, TYPE: 'DATASERVER', FIELD: fields, KEY: [] }
-            : { NAME: resourceName, TYPE: 'REQUEST_SERVER', REPLY_FIELD: fields },
-    });
+    if (legacy) {
+        connection.reply(message, {
+            MESSAGE_TYPE: message.MESSAGE_TYPE,
+            DETAILS: legacyMeta(resourceName, query, requestReply, connection, config, store),
+        });
+        return;
+    }
+    let details;
+    if (event) {
+        details = eventMeta(resourceName, event, eventFields(event, config, store), config.appName);
+    }
+    else {
+        // Hidden fields disappear from the metadata too — a column the user can't
+        // see must not be offered to the grid at all.
+        const hidden = hiddenFields((query ?? requestReply).auth, requestingUser(connection));
+        details = query
+            ? dataserverMeta(resourceName, query, config, store, hidden)
+            : requestServerMeta(resourceName, requestReply, config, store, hidden);
+    }
+    connection.reply(message, { MESSAGE_TYPE: MESSAGE_TYPE.FEATURE_ACK, DETAILS: details });
+}
+// What this engine answered up to 15.47: {NAME, TYPE} fields only, KEY: []
+// on dataservers, REPLY_FIELD alone on request servers, and no event META.
+// Declared types (and query fields blocks) still apply.
+function legacyMeta(resourceName, query, requestReply, connection, config, store) {
+    const hidden = hiddenFields((query ?? requestReply).auth, requestingUser(connection));
+    const schema = query
+        ? querySchema(query, config, store)
+        : requestReplySchema(requestReply, config, store);
+    const fields = schema.fields
+        .filter((field) => !hidden.has(field.name))
+        .map((field) => ({ NAME: field.name, TYPE: field.type }));
+    return query
+        ? { NAME: resourceName, TYPE: 'DATASERVER', FIELD: fields, KEY: [] }
+        : { NAME: resourceName, TYPE: 'REQUEST_SERVER', REPLY_FIELD: fields };
 }

package/dist/handlers/requestReply.js

@@ -1,5 +1,6 @@
 import { filterByCriteria } from "../db/criteria.js";
-import { NackError } from "../protocol/errors.js";
+import { withoutRecordFields } from "../db/identity.js";
+import { nackPayload } from "../protocol/errors.js";
 import { isLegacyFidelity } from "../protocol/fidelity.js";
 import { ERROR_CODE } from "../protocol/messageTypes.js";
 import { resourceNotMappedNack } from "../protocol/msgNack.js";
@@ -35,6 +36,7 @@ export function handleRequestReply(message, connection, config, store) {
             : resourceNotMappedNack(resourceName));
         return;
     }
+    const legacy = isLegacyFidelity(config);
     const user = requestingUser(connection);
     const request = (typeof message.REQUEST === 'object' && message.REQUEST) || message.DETAILS?.REQUEST || {};
     try {
@@ -58,15 +60,24 @@ export function handleRequestReply(message, connection, config, store) {
                 rows = rows.filter(requestReply.filter);
         }
         rows = applyResourceAuth(rows, requestReply.auth, user);
+        // Rows read from a table or view carry their RECORD_ID and TIMESTAMP, as
+        // a criteria-only request server's do on GSF. Deliberately on every
+        // source-backed server, criteriaOnly or not (README: a deviation until
+        // OFFSET paging, item 1.9): grid-pro's client-side REQUEST_SERVER
+        // datasource keys rows by RECORD_ID and gives up without it. A
+        // resolver's rows go out exactly as returned. Legacy mode sent none, a
+        // resolver's included (one returning stored rows would now have them).
+        if (legacy)
+            rows = rows.map(withoutRecordFields);
         connection.reply(message, {
             MESSAGE_TYPE: `REP_${resourceName}`,
             REPLY: rows,
         });
     }
     catch (error) {
-        const errors = error instanceof NackError
-            ? error.errors
-            : [{ CODE: ERROR_CODE.VALIDATION_ERROR, TEXT: error.message }];
-        connection.reply(message, { MESSAGE_TYPE: `REP_${resourceName}`, ERROR: errors });
+        connection.reply(message, {
+            MESSAGE_TYPE: `REP_${resourceName}`,
+            ...nackPayload(error, legacy),
+        });
     }
 }

package/dist/handlers/resourceAuth.d.ts

@@ -3,3 +3,4 @@ import type { ResourceAuthDef, RequestingUser, Row } from '../types.ts';
 export declare function requestingUser(connection: Connection): RequestingUser;
 export declare function hiddenFields(auth: ResourceAuthDef | undefined, user: RequestingUser): Set<string>;
 export declare function applyResourceAuth(rows: Row[], auth: ResourceAuthDef | undefined, user: RequestingUser): Row[];
+export declare function permittedQueryRow(row: Row, auth: ResourceAuthDef | undefined, user: RequestingUser, fieldNames: string[] | undefined): Row | undefined;

package/dist/handlers/resourceAuth.js

@@ -1,3 +1,4 @@
+import { projectRow } from "../db/schema.js";
 // The identity a resource-level auth hook (rowFilter/hideFields) sees for the
 // requesting connection. userName is undefined for unauthenticated
 // connections — possible when requireAuth is off, or pre-login.
@@ -25,3 +26,16 @@ export function applyResourceAuth(rows, auth, user) {
     }
     return result;
 }
+// One dataserver row as this user sees it: undefined when rowFilter rejects
+// it, else only the query's columns (projectRow: fieldNames from
+// queryFieldNames) minus the hidden ones. rowFilter sees the whole row, so a
+// filter may read a column the query doesn't expose.
+export function permittedQueryRow(row, auth, user, fieldNames) {
+    if (auth?.rowFilter && !auth.rowFilter(row, user))
+        return undefined;
+    const projected = projectRow(row, fieldNames);
+    const hidden = hiddenFields(auth, user);
+    if (hidden.size === 0)
+        return projected;
+    return Object.fromEntries(Object.entries(projected).filter(([field]) => !hidden.has(field)));
+}

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { createMockServer, type MockServer } from './server.ts';
 export { launchStack, type LaunchStackOptions, type LaunchedStack } from './launch.ts';
 export { Store } from './db/store.ts';
-export { NackError, type NackErrorInput, type NackErrorEntry } from './protocol/errors.ts';
+export { RECORD_FIELDS, RECORD_ID, TIMESTAMP } from './db/identity.ts';
+export { ErrorCode, NackError, statusCodeFor, type ErrorCodeName, type GenesisErrorType, type NackErrorEntry, type NackErrorInput, type NackErrorOptions, } from './protocol/errors.ts';
 export { compileCriteria, filterByCriteria, type Predicate } from './db/criteria.ts';
-export type { AntiJoinDef, AuthConfig, AuthUser, BroadcastFn, BroadcastTableChangeFn, EventHandler, EventHandlerCtx, EventHandlerResult, EventSchemaOverride, FidelityMode, FieldMetadata, GenesisMessage, HttpRouteDef, JoinDef, MockServerConfig, OnMessageCtx, OnMessageHook, QueryDef, RequestingUser, RequestReplyDef, RequestReplyResolverCtx, ResourceAuthDef, ResourceItem, Row, SocketLike, SsoIdentityProvider, TableDef, ViewDef, } from './types.ts';
+export type { AntiJoinDef, AuthConfig, AuthUser, BroadcastFn, BroadcastTableChangeFn, EventHandler, EventHandlerCtx, EventHandlerResult, EventSchemaOverride, FidelityMode, FieldDef, FieldMetadata, GeneratedFieldDef, GenesisFieldType, GenesisMessage, HttpRouteDef, IndexDef, JoinDef, MockServerConfig, OnMessageCtx, OnMessageHook, QueryDef, RequestingUser, RequestReplyDef, RequestReplyResolverCtx, ResourceAuthDef, ResourceItem, Row, SequenceFormat, SocketLike, SsoIdentityProvider, TableDef, ViewDef, } from './types.ts';

package/dist/index.js

@@ -1,5 +1,6 @@
 export { createMockServer } from "./server.js";
 export { launchStack } from "./launch.js";
 export { Store } from "./db/store.js";
-export { NackError } from "./protocol/errors.js";
+export { RECORD_FIELDS, RECORD_ID, TIMESTAMP } from "./db/identity.js";
+export { ErrorCode, NackError, statusCodeFor, } from "./protocol/errors.js";
 export { compileCriteria, filterByCriteria } from "./db/criteria.js";

package/dist/protocol/connection.d.ts

@@ -9,6 +9,8 @@ export interface Subscription {
     held?: Set<string>;
     maxRows?: number;
     maxView?: number;
+    fieldNames?: string[];
+    queueInsert?: (key: string, stamped: Row, row: Row) => boolean;
 }
 export declare class Connection {
     readonly ws: SocketLike;