@genesislcap/event-type-codegen 15.19.0 → 15.19.1

package/src/render.ts

@@ -1,149 +0,0 @@
-import {
-  kotlinPropertyToWireField,
-  handlerInputToDetailsInterfaceName,
-  eventNameToEventClassName,
-} from './naming';
-import { kotlinEnumTypeRef, type KotlinEnumMap } from './parse-enums';
-import { kotlinTypeToTs } from './parse-kotlin';
-import type { KotlinDto, MappedHandler, UnmappedHandler } from './types';
-
-const kotlinTypeRoot = (kotlinType: string): string => {
-  const listMatch = kotlinType.match(/^(?:List|MutableList|Set|MutableSet)<(.+)>$/);
-  if (listMatch) {
-    return kotlinTypeRoot(listMatch[1].trim());
-  }
-  return kotlinType.replace(/\?$/, '').trim();
-};
-
-/** Handler inputs plus any nested custom DTOs referenced from their properties. */
-const expandUsedDtoNames = (mapped: MappedHandler[], dtos: Map<string, KotlinDto>): Set<string> => {
-  const used = new Set<string>();
-
-  const visit = (dtoName: string) => {
-    if (used.has(dtoName) || !dtos.has(dtoName)) return;
-    used.add(dtoName);
-    const dto = dtos.get(dtoName)!;
-    for (const prop of dto.properties) {
-      const nested = kotlinTypeRoot(prop.kotlinType);
-      if (dtos.has(nested)) {
-        visit(nested);
-      }
-    }
-  };
-
-  for (const handler of mapped) {
-    visit(handler.inputType);
-  }
-
-  return used;
-};
-
-const renderInterface = (
-  dto: KotlinDto,
-  dtos: Map<string, KotlinDto>,
-  enums: KotlinEnumMap,
-): string => {
-  const interfaceName = handlerInputToDetailsInterfaceName(dto.name);
-  const lines = dto.properties.map((prop) => {
-    const wireName = kotlinPropertyToWireField(prop.name);
-    const tsType = kotlinTypeToTs(prop.kotlinType, dtos, enums);
-    const optional = prop.optional ? '?' : '';
-    return `  ${wireName}${optional}: ${tsType};`;
-  });
-
-  return `export interface ${interfaceName} {\n${lines.join('\n')}\n}`;
-};
-
-const renderEventClasses = (mapped: MappedHandler[]): string => {
-  if (mapped.length === 0) return '';
-
-  const sorted = [...mapped].sort((a, b) => a.eventName.localeCompare(b.eventName));
-
-  return sorted
-    .map((handler) => {
-      const className = eventNameToEventClassName(handler.eventName);
-      return `export class ${className} extends GenesisEvent<'${handler.eventName}', ${handler.detailsInterface}> {
-  readonly MESSAGE_TYPE = '${handler.eventName}' as const;
-
-  constructor(details: ${handler.detailsInterface}) {
-    super(details);
-  }
-}`;
-    })
-    .join('\n\n');
-};
-
-const renderUnmappedComment = (unmapped: UnmappedHandler[]): string => {
-  if (unmapped.length === 0) return '';
-
-  const lines = unmapped.map(
-    (entry) =>
-      ` * - ${entry.handlerName} (${entry.inputType}): ${entry.reason} [${entry.sourceFile.split(/[/\\]/).pop()}]`,
-  );
-
-  return `/**\n * Unmapped handlers (not included in EventDetailsMap):\n${lines.join('\n')}\n */\n\n`;
-};
-
-const renderEnumExports = (enums: KotlinEnumMap, usedEnumNames: Set<string>): string => {
-  const blocks: string[] = [];
-  for (const name of [...usedEnumNames].sort()) {
-    const values = enums.get(name);
-    if (!values?.length) continue;
-    const entries = values.map((value) => `  ${value}: '${value}',`).join('\n');
-    blocks.push(
-      `export const ${name} = {\n${entries}\n} as const;\n\nexport type ${name} = (typeof ${name})[keyof typeof ${name}];`,
-    );
-  }
-  return blocks.length > 0 ? `${blocks.join('\n\n')}\n\n` : '';
-};
-
-const collectUsedEnumNames = (
-  usedDtoNames: Set<string>,
-  dtos: Map<string, KotlinDto>,
-  enums: KotlinEnumMap,
-): Set<string> => {
-  const used = new Set<string>();
-  for (const dtoName of usedDtoNames) {
-    const dto = dtos.get(dtoName);
-    if (!dto) continue;
-    for (const prop of dto.properties) {
-      const ref = kotlinEnumTypeRef(kotlinTypeRoot(prop.kotlinType), enums);
-      if (ref) used.add(ref);
-    }
-  }
-  return used;
-};
-
-export const renderEventTypesFile = (
-  mapped: MappedHandler[],
-  unmapped: UnmappedHandler[],
-  dtos: Map<string, KotlinDto>,
-  enums: KotlinEnumMap = new Map(),
-): string => {
-  const usedDtos = expandUsedDtoNames(mapped, dtos);
-  const interfaces = [...usedDtos]
-    .map((name) => dtos.get(name))
-    .filter((dto): dto is KotlinDto => dto != null)
-    .sort((a, b) => a.name.localeCompare(b.name))
-    .map((dto) => renderInterface(dto, dtos, enums));
-
-  const usedEnumNames = collectUsedEnumNames(usedDtos, dtos, enums);
-  const enumExports = renderEnumExports(enums, usedEnumNames);
-
-  const mapEntries = mapped.map((m) => `  ${m.eventName}: ${m.detailsInterface};`).join('\n');
-
-  const eventClasses = renderEventClasses(mapped);
-  const foundationCommsImport =
-    mapped.length > 0 ? `import { GenesisEvent } from '@genesislcap/foundation-comms';\n\n` : '';
-
-  return `// AUTO-GENERATED — do not edit
-
-${renderUnmappedComment(unmapped)}${foundationCommsImport}${enumExports}${interfaces.join('\n\n')}
-
-export interface EventDetailsMap {
-${mapEntries}
-}
-
-export type GenesisEventName = keyof EventDetailsMap;
-${eventClasses ? `\n${eventClasses}\n` : ''}`;
-};

package/src/types.ts

@@ -1,56 +0,0 @@
-export type EventTypesConfig = {
-  enabled?: boolean;
-  serverModule?: string;
-  kotlinSources?: string[];
-  /**
-   * Glob patterns (relative to the parent of `serverModule`, typically `../server`)
-   * for Genesis generated table DAO Kotlin sources (`…/gen/dao/Trade.kt`).
-   */
-  generatedDaoSources?: string[];
-  handlerScan?: string[];
-  output?: string;
-  runOnBuild?: boolean;
-};
-
-export type EventTypesResolvedConfig = {
-  enabled: boolean;
-  serverModule: string;
-  kotlinSources: string[];
-  generatedDaoSources: string[];
-  handlerScan: string[];
-  output: string;
-  runOnBuild: boolean;
-};
-
-export type KotlinProperty = {
-  name: string;
-  kotlinType: string;
-  optional: boolean;
-};
-
-export type KotlinDto = {
-  name: string;
-  properties: KotlinProperty[];
-  filePath: string;
-};
-
-export type MappedHandler = {
-  eventName: string;
-  inputType: string;
-  detailsInterface: string;
-  sourceFile: string;
-};
-
-export type UnmappedHandler = {
-  handlerName: string;
-  inputType: string;
-  reason: string;
-  sourceFile: string;
-};
-
-export type GenerateResult = {
-  outputPath: string;
-  eventCount: number;
-  dtoCount: number;
-  unmappedCount: number;
-};

package/test/fixtures/mini-server/src/main/kotlin/com/example/Handlers.kt

@@ -1,23 +0,0 @@
-package com.example
-
-import com.example.dto.AnnotatedInput
-import com.example.dto.BulkSideInput
-import com.example.dto.ChargeAmendInput
-import com.example.dto.FooInput
-import com.example.dto.NestedInput
-
-fun register() {
-    // eventHandler<FooInput>("GHOST")
-    eventHandler<FooInput>("FOO")
-    eventHandler<NestedInput>("BAR_BAZ")
-    eventHandler<ChargeAmendInput>("CHARGE_AMEND")
-    eventHandler<AnnotatedInput>("ANNOTATED")
-    eventHandler<BulkSideInput>("BULK_SIDE")
-    contextEventHandler<FooInput, String>(name = "CONTEXT_FOO")
-    // Full table DAO — resolved from generated-dao sources
-    eventHandler<Trade>("TRADE_INSERT", transactional = true)
-    eventHandler<Trade.ById>("TRADE_DELETE", transactional = true)
-    // Index type — resolved from generated DAO nested data class
-    eventHandler<Instrument.ById>("DAO_HANDLER", transactional = true)
-    eventHandler<Unit>("NOOP")
-}

package/test/fixtures/mini-server/src/main/kotlin/com/example/dto/Samples.kt

@@ -1,30 +0,0 @@
-package com.example.dto
-
-data class FooInput(
-    @NotNull val fooId: String, // unique id, required
-    /* optional bar, with comma */ val barId: String? = null,
-)
-
-data class AnnotatedInput(
-    @field:JsonProperty("x") val counterpartyId: String,
-    @param:NotNull val name: String,
-    @get:JsonIgnore val ignoredHint: String? = null,
-)
-
-data class BulkSideInput(
-    val priorities: List<Priority>,
-)
-
-data class AmendCellInput(
-    val maxSize: Int,
-    val maxInstrumentScore: Int,
-)
-
-data class ChargeAmendInput(
-    val chargeAdditionId: String,
-    val cells: List<AmendCellInput>,
-)
-
-data class NestedInput(
-    val items: List<FooInput>,
-)

package/test/generate.test.ts

@@ -1,115 +0,0 @@
-import { readFileSync, rmSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-
-import { generateEventTypes } from '../src/index';
-
-const fixtureRoot = resolve(__dirname, 'fixtures');
-const serverModule = join(fixtureRoot, 'mini-server');
-const goldenPath = join(fixtureRoot, 'golden', 'genesis-event-types.ts');
-
-const suite = createLogicSuite('event-type-codegen');
-
-suite('generates golden genesis-event-types.ts from fixture Kotlin module', async () => {
-  const clientRoot = join(fixtureRoot, 'client-out');
-  const output = 'genesis-event-types.ts';
-  const outputPath = join(clientRoot, output);
-
-  rmSync(clientRoot, { recursive: true, force: true });
-
-  const result = await generateEventTypes({
-    clientRoot,
-    config: {
-      enabled: true,
-      serverModule,
-      kotlinSources: ['src/main/kotlin/**/dto/**/*.kt'],
-      generatedDaoSources: ['generated-dao/**/*.kt'],
-      handlerScan: ['src/main/kotlin/**/*.kt'],
-      output,
-      runOnBuild: true,
-    },
-  });
-
-  assert.ok(result);
-  assert.equal(result?.eventCount, 9);
-
-  const actual = readFileSync(outputPath, 'utf8').trim();
-  const expected = readFileSync(goldenPath, 'utf8').trim();
-  assert.equal(actual, expected);
-});
-
-suite('maps handler name FOO to EVENT_FOO', async () => {
-  const actual = readFileSync(goldenPath, 'utf8');
-  assert.is(actual.includes('EVENT_FOO: FooInputDetails'), true);
-});
-
-suite('ignores line-commented eventHandler registrations', async () => {
-  const actual = readFileSync(goldenPath, 'utf8');
-  assert.is(actual.includes('EVENT_GHOST'), false);
-});
-
-suite('keeps properties with Kotlin use-site annotations', async () => {
-  const actual = readFileSync(goldenPath, 'utf8');
-  assert.is(actual.includes('export interface AnnotatedInputDetails'), true);
-  assert.is(actual.includes('COUNTERPARTY_ID: string'), true);
-  assert.is(actual.includes('NAME: string'), true);
-});
-
-suite('exports enums referenced only from List/Set properties', async () => {
-  const actual = readFileSync(goldenPath, 'utf8');
-  assert.is(actual.includes('PRIORITIES: Priority[]'), true);
-  assert.is(actual.includes('export const Priority = {'), true);
-  // Priority is not used as a bare enum field on any DTO/DAO — only via List<>.
-  assert.is(/PRIORITY\??: Priority\b/.test(actual), false);
-});
-
-suite('maps generated DAO Trade handler to EVENT_TRADE_INSERT', async () => {
-  const actual = readFileSync(goldenPath, 'utf8');
-  assert.is(actual.includes('EVENT_TRADE_INSERT: TradeDetails'), true);
-  assert.is(actual.includes('INSTRUMENT_ID: string'), true);
-  assert.is(
-    actual.includes("export class EventTradeInsert extends GenesisEvent<'EVENT_TRADE_INSERT'"),
-    true,
-  );
-});
-
-suite('emits GenesisEvent subclasses with message type', async () => {
-  const actual = readFileSync(goldenPath, 'utf8');
-  assert.is(actual.includes("export class EventFoo extends GenesisEvent<'EVENT_FOO'"), true);
-  assert.is(actual.includes("readonly MESSAGE_TYPE = 'EVENT_FOO' as const"), true);
-});
-
-suite('maps generated DAO Trade.ById handler to EVENT_TRADE_DELETE', async () => {
-  const actual = readFileSync(goldenPath, 'utf8');
-  assert.is(actual.includes('EVENT_TRADE_DELETE: TradeByIdDetails'), true);
-  assert.is(actual.includes('export interface TradeByIdDetails'), true);
-  assert.is(
-    actual.includes("export class EventTradeDelete extends GenesisEvent<'EVENT_TRADE_DELETE'"),
-    true,
-  );
-});
-
-suite('maps Instrument.ById index handler', async () => {
-  const actual = readFileSync(goldenPath, 'utf8');
-  assert.is(actual.includes('EVENT_DAO_HANDLER: InstrumentByIdDetails'), true);
-});
-
-suite('maps Trade SIDE enum to string union', async () => {
-  const actual = readFileSync(goldenPath, 'utf8');
-  assert.is(actual.includes('export const Side = {'), true);
-  assert.is(actual.includes('SIDE?: Side'), true);
-});
-
-suite('parses handlers with trailing named args (transactional)', async () => {
-  const actual = readFileSync(goldenPath, 'utf8');
-  assert.is(actual.includes('EVENT_TRADE_INSERT: TradeDetails'), true);
-});
-
-suite('emits nested DTO interfaces not used as handler inputs', async () => {
-  const actual = readFileSync(goldenPath, 'utf8');
-  assert.is(actual.includes('export interface AmendCellInputDetails'), true);
-  assert.is(actual.includes('CELLS: AmendCellInputDetails[]'), true);
-  assert.is(actual.includes('EVENT_CHARGE_AMEND: ChargeAmendInputDetails'), true);
-});
-
-suite.run();

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

@@ -1,42 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,208 +0,0 @@
-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();