@genesislcap/mock-server 15.51.0 → 15.52.0

package/src/handlers/jsonSchema.ts

@@ -1,26 +1,284 @@
-import { deriveFields } from '../db/metadata.ts';
+import {
+  eventDefaultOf,
+  eventFields,
+  inferEventTable,
+  knownValues,
+  isDeleteEventName,
+  querySchema,
+  RECORD_IDENTITY_FIELDS,
+  requestFieldsOf,
+  requestReplySchema,
+  resolveEventTarget,
+  resolveSourceSchema,
+  withTypeOverrides,
+  type EventTarget,
+  type ResolvedField,
+} from '../db/schema.ts';
 import type { Store } from '../db/store.ts';
 import type { Connection } from '../protocol/connection.ts';
 import { isLegacyFidelity } from '../protocol/fidelity.ts';
+import {
+  BIGDECIMAL_PATTERN,
+  enumClassOf,
+  jsonTypeOf,
+  jvmClassOf,
+  rangeOf,
+  titleCase,
+} from '../protocol/fieldTypes.ts';
+import {
+  dataLogonReplySchema,
+  dataLogonSchema,
+  eventInboundProperties,
+  eventReplySchema,
+  GENESIS_META_SCHEMA,
+  REQUEST_DETAILS_SCHEMA,
+} from '../protocol/gsfSchemas.ts';
 import { ERROR_CODE, MESSAGE_TYPE } from '../protocol/messageTypes.ts';
 import { resourceNotMappedNack } from '../protocol/msgNack.ts';
-import type { FieldMetadata, GenesisMessage, MockServerConfig, Row } from '../types.ts';
+import type {
+  FieldMetadata,
+  GenesisMessage,
+  MockServerConfig,
+  QueryDef,
+  RequestReplyDef,
+  Row,
+} from '../types.ts';
+
+// 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: string): string {
+// 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: ResolvedField, annotated: boolean, appName?: string): Row {
+  const type = field.type;
+  const property: Row = {};
+  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: ResolvedField): boolean {
+  return !field.optional;
+}
+
+function eventSchema(
+  eventName: string,
+  target: EventTarget,
+  fields: ResolvedField[],
+  appName: string | undefined,
+): { INBOUND: Row; OUTBOUND: Row } {
+  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: ResolvedField): Row {
+  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: ResolvedField, nullable: boolean): Row {
+  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: string,
+  query: QueryDef,
+  config: MockServerConfig,
+  store: Store,
+): { INBOUND: Row; OUTBOUND: Row } {
+  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: string,
+  requestReply: RequestReplyDef,
+  config: MockServerConfig,
+  store: Store,
+): { INBOUND: Row; OUTBOUND: Row } {
+  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: GenesisMessage,
+  connection: Connection,
+  config: MockServerConfig,
+  store: Store,
+): void {
+  const feature: string | undefined = 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: { INBOUND: Row; OUTBOUND: Row } | undefined;
+  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: string): string {
   switch (fieldType) {
     case 'LONG':
       return 'integer';
@@ -33,10 +291,10 @@ function jsonSchemaType(fieldType: string): string {
   }
 }
 
-function buildSchema(fields: FieldMetadata[], required: string[]): Row {
+function legacySchema(fields: FieldMetadata[], required: string[]): Row {
   const properties: Row = {};
   for (const field of fields) {
-    properties[field.NAME] = { type: jsonSchemaType(field.TYPE) };
+    properties[field.NAME] = { type: legacyJsonSchemaType(field.TYPE) };
   }
   return {
     type: 'object',
@@ -46,76 +304,39 @@ function buildSchema(fields: FieldMetadata[], required: string[]): Row {
   };
 }
 
-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: string | undefined,
-  tableNames: string[],
-): string | undefined {
-  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(
+function handleLegacyJsonSchemaRequest(
   message: GenesisMessage,
   connection: Connection,
   config: MockServerConfig,
   store: Store,
+  feature: string | undefined,
 ): void {
-  const eventName: string | undefined = 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)
+  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 ?? {}));
+    override?.table ?? resourceSource ?? inferEventTable(feature, Object.keys(config.tables ?? {}));
 
-  const legacy = isLegacyFidelity(config);
   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: FieldMetadata[] = 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/src/handlers/meta.ts

@@ -1,10 +1,37 @@
-import { deriveFields } from '../db/metadata.ts';
+import {
+  eventDefaultOf,
+  eventFields,
+  knownValues,
+  querySchema,
+  RECORD_IDENTITY_FIELDS,
+  requestFieldsOf,
+  requestReplySchema,
+  resolveEventTarget,
+  type EventTarget,
+  type ResolvedField,
+} from '../db/schema.ts';
 import type { Store } from '../db/store.ts';
 import type { Connection } from '../protocol/connection.ts';
 import { isLegacyFidelity } from '../protocol/fidelity.ts';
+import {
+  enumClassOf,
+  eventMetaTypeOf,
+  jsonTypeOf,
+  jvmClassOf,
+  rangeOf,
+  titleCase,
+} from '../protocol/fieldTypes.ts';
+import { eventReplyMeta } from '../protocol/gsfSchemas.ts';
 import { ERROR_CODE, MESSAGE_TYPE } from '../protocol/messageTypes.ts';
 import { resourceNotMappedNack } from '../protocol/msgNack.ts';
-import type { GenesisMessage, MockServerConfig, Row } from '../types.ts';
+import type {
+  FieldMetadata,
+  GenesisMessage,
+  MockServerConfig,
+  QueryDef,
+  RequestReplyDef,
+  Row,
+} from '../types.ts';
 import { hiddenFields, requestingUser } from './resourceAuth.ts';
 
 // createMetaRequestMessage (foundation-comms/src/connect/message.ts) puts the
@@ -16,13 +43,157 @@ function resolveResourceName(message: GenesisMessage): string {
   );
 }
 
+// A FIELD / REQUEST_FIELD / REPLY_FIELD entry: VALID_VALUES on ENUM fields
+// only (DataServerMetaData.kt, ReqRepMetaData.kt).
+function fieldMetadata(field: ResolvedField): FieldMetadata {
+  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: string,
+  query: QueryDef,
+  config: MockServerConfig,
+  store: Store,
+  hidden: Set<string>,
+): Row {
+  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: string,
+  requestReply: RequestReplyDef,
+  config: MockServerConfig,
+  store: Store,
+  hidden: Set<string>,
+): Row {
+  const visible = (field: ResolvedField) => !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: ResolvedField,
+  { annotated, appName }: { annotated: boolean; appName?: string },
+): Row {
+  const type = field.type;
+  const enumClass = () => enumClassOf(field.table, field.name, appName);
+  const values = knownValues(field);
+  const fieldDefault = eventDefaultOf(field);
+  const meta: Row = { 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: string,
+  target: EventTarget,
+  fields: ResolvedField[],
+  appName: string | undefined,
+): Row {
+  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: GenesisMessage,
   connection: Connection,
@@ -32,9 +203,11 @@ export function handleMetaRequest(
   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
@@ -49,21 +222,47 @@ export function handleMetaRequest(
     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: Row[] = 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));
+  if (legacy) {
+    connection.reply(message, {
+      MESSAGE_TYPE: message.MESSAGE_TYPE,
+      DETAILS: legacyMeta(resourceName, query, requestReply, connection, config, store),
+    });
+    return;
+  }
+
+  let details: Row;
+  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 });
+}
 
-  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 },
-  });
+// 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: string,
+  query: QueryDef | undefined,
+  requestReply: RequestReplyDef | undefined,
+  connection: Connection,
+  config: MockServerConfig,
+  store: Store,
+): Row {
+  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 };
 }