@genesislcap/event-type-codegen 15.17.0 → 15.18.0

package/src/parse-metadata.ts

@@ -0,0 +1,327 @@
+import { eventNameToEventClassName } from './naming';
+
+/** Wire-named DETAILS property from live event metadata / JSON Schema. */
+export type MetadataField = {
+  /** Already UPPER_SNAKE wire name (e.g. ADDRESS_LINE_1). */
+  name: string;
+  /** Emitted TypeScript type (e.g. string, number, Side). */
+  tsType: string;
+  optional: boolean;
+};
+
+export type MetadataEventContract = {
+  eventName: string;
+  detailsInterface: string;
+  fields: MetadataField[];
+};
+
+export type MetadataEnumDef = {
+  name: string;
+  values: string[];
+};
+
+/**
+ * Dump shape produced by foundation-header dev capture (FUI-2608).
+ * Prefer `schema.INBOUND` DETAILS; fall back to `metadata.FIELD`.
+ */
+export type EventMetadataDump = {
+  capturedAt?: string;
+  source?: string;
+  events: Record<
+    string,
+    {
+      metadata?: {
+        FIELD?: Array<{
+          NAME: string;
+          TYPE?: string;
+          JSON_TYPE?: string;
+          OPTIONAL?: boolean;
+          VALID_VALUES?: string;
+        }>;
+        NAME?: string;
+      };
+      schema?: {
+        INBOUND?: {
+          properties?: Record<string, unknown>;
+          required?: string[];
+        };
+        MESSAGE_TYPE?: string;
+      };
+    }
+  >;
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value != null && !Array.isArray(value);
+
+/** Quote a string for safe emission as a TS string literal / object key. */
+export const quoteTsString = (s: string): string =>
+  `'${s.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+
+/** Bare identifier when legal; otherwise a quoted string key. */
+const tsPropertyKey = (name: string): string =>
+  /^[A-Za-z_$][\w$]*$/.test(name) ? name : quoteTsString(name);
+
+/** EVENT_BROKER_INSERT → BrokerInsertDetails */
+export const eventNameToDetailsInterfaceName = (eventName: string): string => {
+  const base = eventName.startsWith('EVENT_') ? eventName.slice('EVENT_'.length) : eventName;
+  const pascal = base
+    .toLowerCase()
+    .split('_')
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join('');
+  return `${pascal}Details`;
+};
+
+/** Build a valid PascalCase TypeScript identifier from an enum name hint. */
+const toSafeEnumIdentifier = (enumNameHint: string): string => {
+  const enumName = enumNameHint
+    .split(/[^A-Za-z0-9]+/)
+    .filter(Boolean)
+    .map((p) => p.charAt(0).toUpperCase() + p.slice(1).toLowerCase())
+    .join('');
+  if (!enumName) return 'GeneratedEnum';
+  return /^[A-Za-z]/.test(enumName) ? enumName : `E${enumName}`;
+};
+
+const valuesKey = (values: string[]): string => values.join('\0');
+
+/**
+ * Register an enum under a collision-safe name. Same values → reuse; different values →
+ * disambiguate (`Foo`, `Foo2`, …) and report via `unmapped`.
+ */
+const registerEnum = (
+  enums: Map<string, string[]>,
+  preferredName: string,
+  values: string[],
+  unmapped: string[],
+  context: string,
+): string => {
+  const existing = enums.get(preferredName);
+  if (!existing) {
+    enums.set(preferredName, values);
+    return preferredName;
+  }
+  if (valuesKey(existing) === valuesKey(values)) {
+    return preferredName;
+  }
+
+  let n = 2;
+  let candidate = `${preferredName}${n}`;
+  while (enums.has(candidate) && valuesKey(enums.get(candidate)!) !== valuesKey(values)) {
+    n += 1;
+    candidate = `${preferredName}${n}`;
+  }
+  if (!enums.has(candidate)) {
+    enums.set(candidate, values);
+    unmapped.push(`${context}: enum name collision for ${preferredName}; emitted as ${candidate}`);
+  }
+  return candidate;
+};
+
+const jsonSchemaTypeToTs = (
+  propSchema: Record<string, unknown>,
+  enums: Map<string, string[]>,
+  enumNameHint: string,
+  unmapped: string[],
+  context: string,
+): string => {
+  if (Array.isArray(propSchema.enum) && propSchema.enum.every((v) => typeof v === 'string')) {
+    const values = propSchema.enum as string[];
+    const safeName = toSafeEnumIdentifier(enumNameHint);
+    return registerEnum(enums, safeName, values, unmapped, context);
+  }
+
+  if (Array.isArray(propSchema.oneOf)) {
+    const nonNull = (propSchema.oneOf as unknown[]).find(
+      (branch) => isRecord(branch) && branch.type !== 'null',
+    );
+    if (isRecord(nonNull)) {
+      return jsonSchemaTypeToTs(nonNull, enums, enumNameHint, unmapped, context);
+    }
+  }
+
+  const type = propSchema.type;
+  if (type === 'integer' || type === 'number') return 'number';
+  if (type === 'boolean') return 'boolean';
+  if (type === 'array') {
+    const items = isRecord(propSchema.items) ? propSchema.items : {};
+    return `${jsonSchemaTypeToTs(items, enums, enumNameHint, unmapped, context)}[]`;
+  }
+  if (type === 'object') return 'Record<string, unknown>';
+  return 'string';
+};
+
+const metadataJsonTypeToTs = (jsonType?: string, fieldType?: string): string => {
+  const jt = (jsonType ?? '').toLowerCase();
+  if (jt === 'integer' || jt === 'number') return 'number';
+  if (jt === 'boolean') return 'boolean';
+  if (
+    (fieldType ?? '').toUpperCase() === 'DATETIME' ||
+    (fieldType ?? '').toUpperCase() === 'DATE'
+  ) {
+    return 'number';
+  }
+  return 'string';
+};
+
+const extractDetailsSchema = (
+  inbound: Record<string, unknown> | undefined,
+): { properties: Record<string, unknown>; required: Set<string> } | null => {
+  if (!inbound) return null;
+  const rootProps = isRecord(inbound.properties) ? inbound.properties : undefined;
+  if (!rootProps) return null;
+
+  // Event inbound is usually { DETAILS: { type: object, properties: {...}, required: [...] } }
+  const details = rootProps.DETAILS;
+  if (isRecord(details) && isRecord(details.properties)) {
+    const required = Array.isArray(details.required)
+      ? new Set(details.required.filter((r): r is string => typeof r === 'string'))
+      : new Set<string>();
+    return { properties: details.properties, required };
+  }
+
+  // Some schemas flatten DETAILS properties at the inbound root.
+  const required = Array.isArray(inbound.required)
+    ? new Set(inbound.required.filter((r): r is string => typeof r === 'string'))
+    : new Set<string>();
+  return { properties: rootProps, required };
+};
+
+/**
+ * Parse a header-captured event-metadata.json dump into per-event contracts.
+ */
+export const parseEventMetadataDump = (
+  dump: EventMetadataDump,
+): { contracts: MetadataEventContract[]; enums: MetadataEnumDef[]; unmapped: string[] } => {
+  const contracts: MetadataEventContract[] = [];
+  const enums = new Map<string, string[]>();
+  const unmapped: string[] = [];
+
+  const eventNames = Object.keys(dump.events ?? {}).sort((a, b) => a.localeCompare(b));
+
+  for (const eventName of eventNames) {
+    if (!eventName.startsWith('EVENT_')) {
+      unmapped.push(`${eventName}: not an EVENT_* handler`);
+      continue;
+    }
+
+    const entry = dump.events[eventName];
+    const inbound = isRecord(entry?.schema?.INBOUND)
+      ? (entry.schema.INBOUND as Record<string, unknown>)
+      : undefined;
+    const detailsSchema = extractDetailsSchema(inbound);
+
+    const fields: MetadataField[] = [];
+
+    if (detailsSchema) {
+      for (const [fieldName, rawProp] of Object.entries(detailsSchema.properties)) {
+        if (fieldName === 'MESSAGE_TYPE' || fieldName === 'SOURCE_REF') continue;
+        if (!isRecord(rawProp)) continue;
+        const optional = !detailsSchema.required.has(fieldName);
+        const enumNameHint = eventName.startsWith('EVENT_')
+          ? `${eventName.slice('EVENT_'.length)}_${fieldName}`
+          : `${eventName}_${fieldName}`;
+        fields.push({
+          name: fieldName,
+          tsType: jsonSchemaTypeToTs(
+            rawProp,
+            enums,
+            enumNameHint,
+            unmapped,
+            `${eventName}.${fieldName}`,
+          ),
+          optional,
+        });
+      }
+    } else if (entry?.metadata?.FIELD?.length) {
+      for (const field of entry.metadata.FIELD) {
+        fields.push({
+          name: field.NAME,
+          tsType: metadataJsonTypeToTs(field.JSON_TYPE, field.TYPE),
+          optional: field.OPTIONAL !== false,
+        });
+      }
+    } else {
+      unmapped.push(`${eventName}: no INBOUND DETAILS schema or metadata.FIELD`);
+      continue;
+    }
+
+    contracts.push({
+      eventName,
+      detailsInterface: eventNameToDetailsInterfaceName(eventName),
+      fields,
+    });
+  }
+
+  const enumDefs: MetadataEnumDef[] = [...enums.entries()]
+    .map(([name, values]) => ({ name, values }))
+    .sort((a, b) => a.name.localeCompare(b.name));
+
+  return { contracts, enums: enumDefs, unmapped };
+};
+
+export const renderEventTypesFromMetadataContracts = (
+  contracts: MetadataEventContract[],
+  enums: MetadataEnumDef[],
+  unmapped: string[],
+): string => {
+  const unmappedComment =
+    unmapped.length > 0
+      ? `/**\n * Unmapped handlers (not included in EventDetailsMap):\n${unmapped
+          .map((line) => ` * - ${line}`)
+          .join('\n')}\n */\n\n`
+      : '';
+
+  const enumExports = enums
+    .map((e) => {
+      const entries = e.values
+        .map((value) => `  ${quoteTsString(value)}: ${quoteTsString(value)},`)
+        .join('\n');
+      return `export const ${e.name} = {\n${entries}\n} as const;\n\nexport type ${e.name} = (typeof ${e.name})[keyof typeof ${e.name}];`;
+    })
+    .join('\n\n');
+
+  const interfaces = contracts
+    .map((c) => {
+      const lines = c.fields.map((f) => {
+        const optional = f.optional ? '?' : '';
+        return `  ${tsPropertyKey(f.name)}${optional}: ${f.tsType};`;
+      });
+      return `export interface ${c.detailsInterface} {\n${lines.join('\n')}\n}`;
+    })
+    .join('\n\n');
+
+  const mapEntries = contracts
+    .map((c) => `  ${tsPropertyKey(c.eventName)}: ${c.detailsInterface};`)
+    .join('\n');
+
+  const eventClasses = contracts
+    .map((c) => {
+      const className = eventNameToEventClassName(c.eventName);
+      return `export class ${className} extends GenesisEvent<'${c.eventName}', ${c.detailsInterface}> {
+  readonly MESSAGE_TYPE = '${c.eventName}' as const;
+
+  constructor(details: ${c.detailsInterface}) {
+    super(details);
+  }
+}`;
+    })
+    .join('\n\n');
+
+  const foundationCommsImport =
+    contracts.length > 0 ? `import { GenesisEvent } from '@genesislcap/foundation-comms';\n\n` : '';
+
+  return `// AUTO-GENERATED — do not edit
+// Source: event metadata dump (genx generate event-types --from-metadata)
+
+${unmappedComment}${foundationCommsImport}${enumExports ? `${enumExports}\n\n` : ''}${interfaces}
+
+export interface EventDetailsMap {
+${mapEntries}
+}
+
+export type GenesisEventName = keyof EventDetailsMap;
+${eventClasses ? `\n${eventClasses}\n` : ''}`;
+};

package/test/fixtures/client-out/genesis-event-types.ts

@@ -62,7 +62,7 @@ export interface TradeDetails {
   SIDE?: Side;
   PRICE: number;
   COMMISSION?: string;
-  CREATED_AT?: string;
+  CREATED_AT?: number;
 }
 
 export interface TradeByIdDetails {

package/test/fixtures/golden/genesis-event-types.ts

@@ -62,7 +62,7 @@ export interface TradeDetails {
   SIDE?: Side;
   PRICE: number;
   COMMISSION?: string;
-  CREATED_AT?: string;
+  CREATED_AT?: number;
 }
 
 export interface TradeByIdDetails {

package/test/kotlin-parse-utils.test.ts

@@ -0,0 +1,42 @@
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+
+import { parseKotlinProperty } from '../src/kotlin-parse-utils';
+import { kotlinPropertyToWireField } from '../src/naming';
+
+const suite = createLogicSuite('parseKotlinProperty');
+
+suite('parses ordinary camelCase properties', () => {
+  const prop = parseKotlinProperty('public var instrumentId: String');
+  assert.ok(prop);
+  assert.equal(prop!.name, 'instrumentId');
+  assert.equal(prop!.kotlinType, 'String');
+  assert.equal(prop!.optional, false);
+  assert.equal(kotlinPropertyToWireField(prop!.name), 'INSTRUMENT_ID');
+});
+
+suite('parses backtick-escaped reserved identifiers (Position.VALUE)', () => {
+  const prop = parseKotlinProperty(
+    '@Title("Value") @GenesisType(Field.Type.DOUBLE) public var `value`: Double? = null',
+  );
+  assert.ok(prop);
+  assert.equal(prop!.name, 'value');
+  assert.equal(prop!.kotlinType, 'Double');
+  assert.equal(prop!.optional, true);
+  assert.equal(kotlinPropertyToWireField(prop!.name), 'VALUE');
+});
+
+suite('parses bare backtick params when allowBareParams is set', () => {
+  const prop = parseKotlinProperty('`object`: String? = null', { allowBareParams: true });
+  assert.ok(prop);
+  assert.equal(prop!.name, 'object');
+  assert.equal(kotlinPropertyToWireField(prop!.name), 'OBJECT');
+});
+
+suite('passes through backticked UPPER_SNAKE properties unchanged on the wire', () => {
+  const prop = parseKotlinProperty('public var `ORDER_ID`: String');
+  assert.ok(prop);
+  assert.equal(prop!.name, 'ORDER_ID');
+  assert.equal(kotlinPropertyToWireField(prop!.name), 'ORDER_ID');
+});
+
+suite.run();

package/test/naming.test.ts

@@ -0,0 +1,49 @@
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+
+import { kotlinPropertyToWireField, toUpperUnderscoreWithAcronyms } from '../src/naming';
+
+const suite = createLogicSuite('toUpperUnderscoreWithAcronyms');
+
+/** Cases mirrored from genesis-server ToUpperUnderscoreWithAcronymsTest. */
+suite('matches genesis-server simple cases', () => {
+  assert.equal(toUpperUnderscoreWithAcronyms('orderIds'), 'ORDER_IDS');
+  assert.equal(toUpperUnderscoreWithAcronyms('orderIdsTest'), 'ORDER_IDS_TEST');
+});
+
+suite('matches genesis-server acronym cases', () => {
+  assert.equal(toUpperUnderscoreWithAcronyms('orderI'), 'ORDER_I');
+  assert.equal(toUpperUnderscoreWithAcronyms('orderID'), 'ORDER_ID');
+  assert.equal(toUpperUnderscoreWithAcronyms('orderIDS'), 'ORDER_IDS');
+  assert.equal(toUpperUnderscoreWithAcronyms('orderIa'), 'ORDER_IA');
+  assert.equal(toUpperUnderscoreWithAcronyms('orderIDNotional'), 'ORDER_ID_NOTIONAL');
+  assert.equal(toUpperUnderscoreWithAcronyms('orderIDSInstrument'), 'ORDER_IDS_INSTRUMENT');
+});
+
+suite('matches genesis-server number cases', () => {
+  assert.equal(toUpperUnderscoreWithAcronyms('order1'), 'ORDER_1');
+  assert.equal(toUpperUnderscoreWithAcronyms('order12'), 'ORDER_12');
+  assert.equal(toUpperUnderscoreWithAcronyms('order123'), 'ORDER_123');
+  assert.equal(toUpperUnderscoreWithAcronyms('order1a'), 'ORDER_1A');
+  assert.equal(toUpperUnderscoreWithAcronyms('order12a'), 'ORDER_12A');
+  assert.equal(toUpperUnderscoreWithAcronyms('order123a'), 'ORDER_123A');
+  assert.equal(toUpperUnderscoreWithAcronyms('order1A'), 'ORDER_1_A');
+  assert.equal(toUpperUnderscoreWithAcronyms('order12A'), 'ORDER_12_A');
+  assert.equal(toUpperUnderscoreWithAcronyms('order123A'), 'ORDER_123_A');
+});
+
+suite('fixes FUI-2606 field-name examples', () => {
+  assert.equal(kotlinPropertyToWireField('addressLine1'), 'ADDRESS_LINE_1');
+  assert.equal(kotlinPropertyToWireField('addressLine2'), 'ADDRESS_LINE_2');
+  assert.equal(kotlinPropertyToWireField('brokerCtmBicM2i'), 'BROKER_CTM_BIC_M_2I');
+  assert.equal(kotlinPropertyToWireField('dfaNotes1'), 'DFA_NOTES_1');
+  assert.equal(kotlinPropertyToWireField('tradeType1'), 'TRADE_TYPE_1');
+  assert.equal(kotlinPropertyToWireField('createdAt'), 'CREATED_AT');
+});
+
+suite('passes through names that are already UPPER_SNAKE', () => {
+  assert.equal(toUpperUnderscoreWithAcronyms('ORDER_ID'), 'ORDER_ID');
+  assert.equal(toUpperUnderscoreWithAcronyms('ADDRESS_LINE_1'), 'ADDRESS_LINE_1');
+  assert.equal(toUpperUnderscoreWithAcronyms('ALREADY_UPPER'), 'ALREADY_UPPER');
+});
+
+suite.run();

package/test/parse-metadata.test.ts

@@ -0,0 +1,208 @@
+import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
+
+import {
+  eventNameToDetailsInterfaceName,
+  parseEventMetadataDump,
+  renderEventTypesFromMetadataContracts,
+  type EventMetadataDump,
+} from '../src/parse-metadata';
+
+const suite = createLogicSuite('parse-metadata');
+
+const sampleDump: EventMetadataDump = {
+  capturedAt: '2026-08-24T10:00:00.000Z',
+  events: {
+    EVENT_BROKER_INSERT: {
+      schema: {
+        MESSAGE_TYPE: 'EVENT_BROKER_INSERT',
+        INBOUND: {
+          properties: {
+            DETAILS: {
+              type: 'object',
+              required: ['BROKER_NAME'],
+              properties: {
+                BROKER_ID: {
+                  oneOf: [{ type: 'null' }, { type: 'string' }],
+                  genesisType: 'STRING',
+                },
+                BROKER_NAME: { type: 'string', genesisType: 'STRING' },
+                ADDRESS_LINE_1: {
+                  oneOf: [{ type: 'null' }, { type: 'string' }],
+                },
+                UPDATE_DATE: { type: 'integer', genesisType: 'DATETIME' },
+              },
+            },
+          },
+        },
+      },
+    },
+    EVENT_BROKER_AMEND: {
+      schema: {
+        INBOUND: {
+          properties: {
+            DETAILS: {
+              type: 'object',
+              required: ['BROKER_ID', 'BROKER_NAME'],
+              properties: {
+                BROKER_ID: { type: 'string' },
+                BROKER_NAME: { type: 'string' },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+};
+
+suite('derives per-event details interface names', () => {
+  assert.equal(eventNameToDetailsInterfaceName('EVENT_BROKER_INSERT'), 'BrokerInsertDetails');
+  assert.equal(eventNameToDetailsInterfaceName('EVENT_TRADE_MODIFY'), 'TradeModifyDetails');
+});
+
+suite('parses schema DETAILS with correct optionality and integer dates', () => {
+  const { contracts, unmapped } = parseEventMetadataDump(sampleDump);
+  assert.equal(unmapped.length, 0);
+  assert.equal(contracts.length, 2);
+
+  const insert = contracts.find((c) => c.eventName === 'EVENT_BROKER_INSERT')!;
+  const brokerId = insert.fields.find((f) => f.name === 'BROKER_ID')!;
+  const brokerName = insert.fields.find((f) => f.name === 'BROKER_NAME')!;
+  const address = insert.fields.find((f) => f.name === 'ADDRESS_LINE_1')!;
+  const updateDate = insert.fields.find((f) => f.name === 'UPDATE_DATE')!;
+
+  assert.equal(brokerId.optional, true);
+  assert.equal(brokerName.optional, false);
+  assert.equal(address.name, 'ADDRESS_LINE_1');
+  assert.equal(updateDate.tsType, 'number');
+
+  const amend = contracts.find((c) => c.eventName === 'EVENT_BROKER_AMEND')!;
+  assert.equal(amend.fields.find((f) => f.name === 'BROKER_ID')!.optional, false);
+});
+
+suite('renders separate insert/amend interfaces from metadata', () => {
+  const { contracts, enums, unmapped } = parseEventMetadataDump(sampleDump);
+  const rendered = renderEventTypesFromMetadataContracts(contracts, enums, unmapped);
+  assert.is(rendered.includes('export interface BrokerInsertDetails'), true);
+  assert.is(rendered.includes('export interface BrokerAmendDetails'), true);
+  assert.is(rendered.includes('ADDRESS_LINE_1?: string'), true);
+  assert.is(rendered.includes('UPDATE_DATE?: number'), true);
+  assert.is(rendered.includes('EVENT_BROKER_INSERT: BrokerInsertDetails'), true);
+});
+
+suite('scopes enum names per event to avoid cross-event collisions', () => {
+  const enumDump: EventMetadataDump = {
+    events: {
+      EVENT_TRADE_INSERT: {
+        schema: {
+          INBOUND: {
+            properties: {
+              DETAILS: {
+                type: 'object',
+                properties: {
+                  SIDE: { type: 'string', enum: ['BUY', 'SELL'] },
+                  status: { type: 'string', enum: ['OPEN', 'CLOSED'] },
+                  SETTLEMENT: { type: 'string', enum: ['T+1', 'N/A', "O'Brien"] },
+                  'MY-FIELD': { type: 'string', enum: ['A', 'B'] },
+                },
+              },
+            },
+          },
+        },
+      },
+      EVENT_ORDER_INSERT: {
+        schema: {
+          INBOUND: {
+            properties: {
+              DETAILS: {
+                type: 'object',
+                properties: {
+                  SIDE: { type: 'string', enum: ['LONG', 'SHORT'] },
+                },
+              },
+            },
+          },
+        },
+      },
+      // Hashes to the same PascalCase as EVENT_TRADE_INSERT.SIDE → TradeInsertSide
+      EVENT_TRADE: {
+        schema: {
+          INBOUND: {
+            properties: {
+              DETAILS: {
+                type: 'object',
+                properties: {
+                  INSERT_SIDE: { type: 'string', enum: ['IN', 'OUT'] },
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  };
+
+  const { contracts, enums, unmapped } = parseEventMetadataDump(enumDump);
+
+  const tradeSide = enums.find((e) => e.name === 'TradeInsertSide');
+  const orderSide = enums.find((e) => e.name === 'OrderInsertSide');
+  const tradeStatus = enums.find((e) => e.name === 'TradeInsertStatus');
+  const settlement = enums.find((e) => e.name === 'TradeInsertSettlement');
+  const myField = enums.find((e) => e.name === 'TradeInsertMyField');
+  const collision = enums.find((e) => e.name === 'TradeInsertSide2');
+
+  assert.ok(tradeSide);
+  assert.ok(orderSide);
+  assert.ok(tradeStatus);
+  assert.ok(settlement);
+  assert.ok(myField);
+  assert.ok(collision);
+  // EVENT_TRADE sorts before EVENT_TRADE_INSERT, so INSERT_SIDE wins TradeInsertSide
+  assert.equal(tradeSide!.values.join(','), 'IN,OUT');
+  assert.equal(orderSide!.values.join(','), 'LONG,SHORT');
+  assert.equal(tradeStatus!.values.join(','), 'OPEN,CLOSED');
+  assert.equal(settlement!.values.join(','), "T+1,N/A,O'Brien");
+  assert.equal(collision!.values.join(','), 'BUY,SELL');
+  assert.ok(unmapped.some((line) => line.includes('enum name collision for TradeInsertSide')));
+
+  const trade = contracts.find((c) => c.eventName === 'EVENT_TRADE_INSERT')!;
+  assert.equal(trade.fields.find((f) => f.name === 'SIDE')!.tsType, 'TradeInsertSide2');
+  assert.equal(trade.fields.find((f) => f.name === 'status')!.tsType, 'TradeInsertStatus');
+  assert.equal(trade.fields.find((f) => f.name === 'MY-FIELD')!.tsType, 'TradeInsertMyField');
+
+  const tradeOnly = contracts.find((c) => c.eventName === 'EVENT_TRADE')!;
+  assert.equal(tradeOnly.fields.find((f) => f.name === 'INSERT_SIDE')!.tsType, 'TradeInsertSide');
+
+  const rendered = renderEventTypesFromMetadataContracts(contracts, enums, unmapped);
+  assert.is(rendered.includes('export const TradeInsertSide'), true);
+  assert.is(rendered.includes('export const OrderInsertSide'), true);
+  assert.is(rendered.includes('SIDE?: TradeInsertSide2'), true);
+  assert.is(rendered.includes("'MY-FIELD'?: TradeInsertMyField"), true);
+  // Non-identifier / quote-bearing values must be quoted on both sides
+  assert.is(rendered.includes("'T+1': 'T+1'"), true);
+  assert.is(rendered.includes("'N/A': 'N/A'"), true);
+  assert.is(rendered.includes("'O\\'Brien': 'O\\'Brien'"), true);
+  // Emitted file must be syntactically valid JS for the enum object
+  const enumBlock = rendered.slice(
+    rendered.indexOf('export const TradeInsertSettlement'),
+    rendered.indexOf('export type TradeInsertSettlement'),
+  );
+  assert.ok(enumBlock.includes('as const'));
+  const runnable = enumBlock.replace(/^export\s+/m, '').replace(/\s+as const/, '');
+  // eslint-disable-next-line no-new-func -- assert generated enum object parses
+  const parsed = new Function(`${runnable}; return TradeInsertSettlement;`)();
+  assert.equal(parsed['T+1'], 'T+1');
+  assert.equal(parsed['N/A'], 'N/A');
+  assert.equal(parsed["O'Brien"], "O'Brien");
+
+  const ifaceStart = rendered.indexOf('export interface TradeInsertDetails {');
+  const ifaceEnd = rendered.indexOf('}', ifaceStart);
+  const ifaceBody = rendered.slice(rendered.indexOf('{', ifaceStart) + 1, ifaceEnd);
+  const objectLiteral = `{${ifaceBody.replace(/\?:/g, ':').replace(/: [^;]+;/g, ': 1,')}}`;
+  // eslint-disable-next-line no-new-func -- assert generated interface keys parse
+  const keys = new Function(`return ${objectLiteral};`)() as Record<string, number>;
+  assert.equal(keys['MY-FIELD'], 1);
+  assert.equal(keys.SIDE, 1);
+});
+
+suite.run();

package/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/config.ts","./src/index.ts","./src/kotlin-parse-utils.ts","./src/naming.ts","./src/parse-dao.ts","./src/parse-enums.ts","./src/parse-kotlin.ts","./src/render.ts","./src/types.ts"],"version":"5.9.2"}
+{"root":["./src/config.ts","./src/index.ts","./src/kotlin-parse-utils.ts","./src/naming.ts","./src/parse-dao.ts","./src/parse-enums.ts","./src/parse-kotlin.ts","./src/parse-metadata.ts","./src/render.ts","./src/types.ts"],"version":"5.9.2"}