@genesislcap/mock-server 15.51.1 → 15.53.0

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, requestFieldsOf, requestReplyReplySchema, requestReplySchema, requestReplySourceSchema, resolveEventTarget, } from "../db/schema.js";
 import { isLegacyFidelity } from "../protocol/fidelity.js";
+import { enumClassOf, eventMetaTypeOf, jsonTypeOf, jvmClassOf, rangeOf, titleCase, } from "../protocol/fieldTypes.js";
+import { eventReplyMeta } from "../protocol/gsfSchemas.js";
 import { ERROR_CODE, MESSAGE_TYPE } from "../protocol/messageTypes.js";
 import { resourceNotMappedNack } from "../protocol/msgNack.js";
 import { hiddenFields, requestingUser } from "./resourceAuth.js";
@@ -9,19 +11,145 @@ 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, no INDICES) and plain
+// (REQUEST_FIELD from the request block, INDICES: [],
+// CRITERIA_ONLY_REQUEST: false). REPLY_FIELD is the reply block, else the
+// source's fields then RECORD_ID and TIMESTAMP, for either
+// (requestReplyReplySchema). SORTABLE_FIELDS and CRITERIA_FIELDS are the
+// entity's fields whatever the reply block says (the dictionary entry's
+// nativeQueryFields, RequestReplyServer.kt).
+function requestServerMeta(name, requestReply, config, store, hidden) {
+    const visible = (field) => !hidden.has(field.name);
+    const replyFields = requestReplyReplySchema(requestReply, config, store).fields.filter(visible);
+    const entityFields = requestReplySourceSchema(requestReply, config, store).fields;
+    if (requestReply.criteriaOnly) {
+        const names = entityFields.filter(visible).map((field) => field.name);
+        return {
+            TYPE: 'REQUEST_SERVER',
+            REQUEST_FIELD: [],
+            CRITERIA_ONLY_REQUEST: true,
+            SORTABLE_FIELDS: names,
+            CRITERIA_FIELDS: names,
+            REPLY_FIELD: replyFields.map(fieldMetadata),
+            NAME: name,
+        };
+    }
+    const requestFields = requestFieldsOf(requestReply, store).map((fieldName) => entityFields.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 +160,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 };
 }