@genesislcap/mock-server 15.51.1 → 15.53.0

package/src/handlers/jsonSchema.ts

@@ -1,26 +1,296 @@
-import { deriveFields } from '../db/metadata.ts';
+import {
+  eventDefaultOf,
+  eventFields,
+  inferEventTable,
+  knownValues,
+  isDeleteEventName,
+  querySchema,
+  requestFieldsOf,
+  requestReplyReplySchema,
+  requestReplySourceSchema,
+  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;
+}
+
+// An event's INBOUND schema: the message, with DETAILS as the event's class.
+// It is also what an inbound event is validated against
+// (handlers/eventValidation.ts), as on the real server.
+export function eventInboundSchema(
+  eventName: string,
+  target: EventTarget,
+  fields: ResolvedField[],
+  appName: string | undefined,
+): 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 {
+    properties: eventInboundProperties(eventName, details),
+    required: ['MESSAGE_TYPE', 'SOURCE_REF', 'USER_NAME', 'DETAILS'],
+    additionalProperties: true,
+    description: target.className,
+    ...(target.title ? { title: target.title } : {}),
+    $defs: {},
+    $schema: GENESIS_META_SCHEMA,
+    type: 'object',
+  };
+}
+
+function eventSchema(
+  eventName: string,
+  target: EventTarget,
+  fields: ResolvedField[],
+  appName: string | undefined,
+): { INBOUND: Row; OUTBOUND: Row } {
+  return {
+    INBOUND: eventInboundSchema(eventName, target, fields, appName),
+    OUTBOUND: eventReplySchema(),
+  };
+}
+
+// --- 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 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: 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 +303,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 +316,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,
   });