@genesislcap/event-type-codegen 14.489.0-canary.FUI-2574-1

package/src/parse-kotlin.ts

@@ -0,0 +1,216 @@
+import { readFileSync } from 'node:fs';
+
+import { handlerInputToDetailsInterfaceName } from './naming';
+import { kotlinEnumTypeRef } from './parse-enums';
+import type { KotlinEnumMap } from './parse-enums';
+import type { KotlinDto, KotlinProperty, MappedHandler, UnmappedHandler } from './types';
+
+const PRIMITIVE_TS: Record<string, string> = {
+  String: 'string',
+  Int: 'number',
+  Long: 'number',
+  Short: 'number',
+  Byte: 'number',
+  Double: 'number',
+  Float: 'number',
+  Boolean: 'boolean',
+  BigDecimal: 'string',
+  DateTime: 'string',
+  Instant: 'string',
+  LocalDate: 'string',
+  LocalDateTime: 'string',
+};
+
+const DATA_CLASS_START = /^\s*(?:data\s+)?class\s+(\w+)\s*(?:\([^)]*\))?\s*(?:\([^)]*\)|\{)/;
+
+const splitTopLevelArgs = (body: string): string[] => {
+  const parts: string[] = [];
+  let depth = 0;
+  let current = '';
+  for (const ch of body) {
+    if (ch === '(' || ch === '<' || ch === '[') depth += 1;
+    if (ch === ')' || ch === '>' || ch === ']') depth -= 1;
+    if (ch === ',' && depth === 0) {
+      parts.push(current.trim());
+      current = '';
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim()) parts.push(current.trim());
+  return parts;
+};
+
+const stripKotlinAnnotations = (segment: string): string =>
+  segment
+    .replace(/@[A-Za-z_][\w.]*(?:\s*<[^>]*>)?(?:\s*\([^)]*\))?/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+
+const parseProperty = (segment: string): KotlinProperty | null => {
+  const cleaned = stripKotlinAnnotations(segment);
+  const match = cleaned.match(/^(?:val|var)\s+(\w+)\s*:\s*([^=]+?)(?:\s*=\s*.+)?$/);
+  if (!match) return null;
+  const name = match[1];
+  let kotlinType = match[2].trim();
+  const optional = kotlinType.endsWith('?') || cleaned.includes('=');
+  kotlinType = kotlinType.replace(/\?$/, '').trim();
+  return { name, kotlinType, optional };
+};
+
+const extractDataClasses = (content: string): { name: string; properties: KotlinProperty[] }[] => {
+  const results: { name: string; properties: KotlinProperty[] }[] = [];
+  const classRegex = /(?:^|\n)\s*(?:data\s+)?class\s+(\w+)\s*\(/gm;
+  let match: RegExpExecArray | null;
+
+  while ((match = classRegex.exec(content)) !== null) {
+    const name = match[1];
+    const openParenIndex = match.index + match[0].length - 1;
+    let depth = 0;
+    let closeIndex = -1;
+    for (let i = openParenIndex; i < content.length; i += 1) {
+      const ch = content[i];
+      if (ch === '(') depth += 1;
+      if (ch === ')') {
+        depth -= 1;
+        if (depth === 0) {
+          closeIndex = i;
+          break;
+        }
+      }
+    }
+    if (closeIndex === -1) continue;
+
+    const body = content.slice(openParenIndex + 1, closeIndex);
+    const properties = splitTopLevelArgs(body)
+      .map(parseProperty)
+      .filter((p): p is KotlinProperty => p != null);
+
+    if (properties.length > 0) {
+      results.push({ name, properties });
+    }
+  }
+
+  return results;
+};
+
+export const parseDtosFromSources = (files: string[]): Map<string, KotlinDto> => {
+  const dtos = new Map<string, KotlinDto>();
+
+  for (const filePath of files) {
+    const rawContent = readFileSync(filePath, 'utf8');
+    const content = rawContent.replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/.*$/gm, '');
+    for (const parsed of extractDataClasses(content)) {
+      dtos.set(parsed.name, {
+        name: parsed.name,
+        properties: parsed.properties,
+        filePath,
+      });
+    }
+  }
+
+  return dtos;
+};
+
+const HANDLER_REGEX =
+  /(?:eventHandler|contextEventHandler)\s*<\s*([^<>,]+?)(?:\s*,\s*[^>]+)?\s*>\s*\(\s*(?:name\s*=\s*)?"([^"]+)"[^)]*\)/g;
+
+const HANDLER_INDEX_INPUT = /^(\w+)\.(By\w+)$/;
+
+const unmappedReason = (inputType: string): string | null => {
+  const trimmed = inputType.trim();
+  if (trimmed === 'Unit') return 'Unit input';
+  if (HANDLER_INDEX_INPUT.test(trimmed)) return null;
+  if (trimmed.includes('.')) return 'Non-DTO type (DAO/index/nested qualified type)';
+  return null;
+};
+
+export const parseHandlersFromSources = (
+  files: string[],
+  dtos: Map<string, KotlinDto>,
+): { mapped: MappedHandler[]; unmapped: UnmappedHandler[] } => {
+  const mapped: MappedHandler[] = [];
+  const unmapped: UnmappedHandler[] = [];
+  const seenEvents = new Set<string>();
+
+  for (const filePath of files) {
+    const content = readFileSync(filePath, 'utf8');
+    const stripped = content.replace(/\/\*[\s\S]*?\*\//g, '');
+
+    const tryMatch = (regex: RegExp) => {
+      let handlerMatch: RegExpExecArray | null;
+      regex.lastIndex = 0;
+      while ((handlerMatch = regex.exec(stripped)) !== null) {
+        const inputType = handlerMatch[1].trim();
+        const handlerName = handlerMatch[2].trim();
+        const eventName = handlerName.startsWith('EVENT_') ? handlerName : `EVENT_${handlerName}`;
+
+        const skipReason = unmappedReason(inputType);
+        if (skipReason) {
+          unmapped.push({
+            handlerName,
+            inputType,
+            reason: skipReason,
+            sourceFile: filePath,
+          });
+          continue;
+        }
+
+        if (!dtos.has(inputType)) {
+          unmapped.push({
+            handlerName,
+            inputType,
+            reason: 'No matching data class or generated DAO',
+            sourceFile: filePath,
+          });
+          continue;
+        }
+
+        if (seenEvents.has(eventName)) continue;
+        seenEvents.add(eventName);
+
+        mapped.push({
+          eventName,
+          inputType,
+          detailsInterface: handlerInputToDetailsInterfaceName(inputType),
+          sourceFile: filePath,
+        });
+      }
+    };
+
+    tryMatch(HANDLER_REGEX);
+  }
+
+  mapped.sort((a, b) => a.eventName.localeCompare(b.eventName));
+  unmapped.sort((a, b) => a.handlerName.localeCompare(b.handlerName));
+
+  return { mapped, unmapped };
+};
+
+export const kotlinTypeToTs = (
+  kotlinType: string,
+  dtos: Map<string, KotlinDto>,
+  enums: KotlinEnumMap = new Map(),
+): string => {
+  const listMatch = kotlinType.match(/^(?:List|MutableList|Set|MutableSet)<(.+)>$/);
+  if (listMatch) {
+    return `${kotlinTypeToTs(listMatch[1].trim(), dtos, enums)}[]`;
+  }
+
+  if (PRIMITIVE_TS[kotlinType]) {
+    return PRIMITIVE_TS[kotlinType];
+  }
+
+  const enumTs = kotlinEnumTypeRef(kotlinType, enums);
+  if (enumTs) {
+    return enumTs;
+  }
+
+  if (dtos.has(kotlinType)) {
+    return handlerInputToDetailsInterfaceName(kotlinType);
+  }
+
+  return 'unknown';
+};
+
+export { extractDataClasses, DATA_CLASS_START };

package/src/render.ts

@@ -0,0 +1,118 @@
+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 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 = (
+  mapped: MappedHandler[],
+  dtos: Map<string, KotlinDto>,
+  enums: KotlinEnumMap,
+): Set<string> => {
+  const used = new Set<string>();
+  for (const handler of mapped) {
+    const dto = dtos.get(handler.inputType);
+    if (!dto) continue;
+    for (const prop of dto.properties) {
+      const ref = kotlinEnumTypeRef(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 = new Set(mapped.map((m) => m.inputType));
+  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(mapped, 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

@@ -0,0 +1,56 @@
+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/client-out/genesis-event-types.ts

@@ -0,0 +1,102 @@
+// AUTO-GENERATED — do not edit
+
+/**
+ * Unmapped handlers (not included in EventDetailsMap):
+ * - NOOP (Unit): Unit input [Handlers.kt]
+ */
+
+import { GenesisEvent } from '@genesislcap/foundation-comms';
+
+export const Side = {
+  BUY: 'BUY',
+  SELL: 'SELL',
+} as const;
+
+export type Side = (typeof Side)[keyof typeof Side];
+
+export interface FooInputDetails {
+  FOO_ID: string;
+  BAR_ID?: string;
+}
+
+export interface InstrumentByIdDetails {
+  INSTRUMENT_ID: string;
+}
+
+export interface NestedInputDetails {
+  ITEMS: FooInputDetails[];
+}
+
+export interface TradeDetails {
+  TRADE_ID?: string;
+  INSTRUMENT_ID: string;
+  COUNTERPARTY_ID: string;
+  QUANTITY: number;
+  SIDE?: Side;
+  PRICE: number;
+  COMMISSION?: string;
+  CREATED_AT?: string;
+}
+
+export interface TradeByIdDetails {
+  TRADE_ID: string;
+}
+
+export interface EventDetailsMap {
+  EVENT_BAR_BAZ: NestedInputDetails;
+  EVENT_CONTEXT_FOO: FooInputDetails;
+  EVENT_DAO_HANDLER: InstrumentByIdDetails;
+  EVENT_FOO: FooInputDetails;
+  EVENT_TRADE_DELETE: TradeByIdDetails;
+  EVENT_TRADE_INSERT: TradeDetails;
+}
+
+export type GenesisEventName = keyof EventDetailsMap;
+
+export class EventBarBaz extends GenesisEvent<'EVENT_BAR_BAZ', NestedInputDetails> {
+  readonly MESSAGE_TYPE = 'EVENT_BAR_BAZ' as const;
+
+  constructor(details: NestedInputDetails) {
+    super(details);
+  }
+}
+
+export class EventContextFoo extends GenesisEvent<'EVENT_CONTEXT_FOO', FooInputDetails> {
+  readonly MESSAGE_TYPE = 'EVENT_CONTEXT_FOO' as const;
+
+  constructor(details: FooInputDetails) {
+    super(details);
+  }
+}
+
+export class EventDaoHandler extends GenesisEvent<'EVENT_DAO_HANDLER', InstrumentByIdDetails> {
+  readonly MESSAGE_TYPE = 'EVENT_DAO_HANDLER' as const;
+
+  constructor(details: InstrumentByIdDetails) {
+    super(details);
+  }
+}
+
+export class EventFoo extends GenesisEvent<'EVENT_FOO', FooInputDetails> {
+  readonly MESSAGE_TYPE = 'EVENT_FOO' as const;
+
+  constructor(details: FooInputDetails) {
+    super(details);
+  }
+}
+
+export class EventTradeDelete extends GenesisEvent<'EVENT_TRADE_DELETE', TradeByIdDetails> {
+  readonly MESSAGE_TYPE = 'EVENT_TRADE_DELETE' as const;
+
+  constructor(details: TradeByIdDetails) {
+    super(details);
+  }
+}
+
+export class EventTradeInsert extends GenesisEvent<'EVENT_TRADE_INSERT', TradeDetails> {
+  readonly MESSAGE_TYPE = 'EVENT_TRADE_INSERT' as const;
+
+  constructor(details: TradeDetails) {
+    super(details);
+  }
+}

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

@@ -0,0 +1,102 @@
+// AUTO-GENERATED — do not edit
+
+/**
+ * Unmapped handlers (not included in EventDetailsMap):
+ * - NOOP (Unit): Unit input [Handlers.kt]
+ */
+
+import { GenesisEvent } from '@genesislcap/foundation-comms';
+
+export const Side = {
+  BUY: 'BUY',
+  SELL: 'SELL',
+} as const;
+
+export type Side = (typeof Side)[keyof typeof Side];
+
+export interface FooInputDetails {
+  FOO_ID: string;
+  BAR_ID?: string;
+}
+
+export interface InstrumentByIdDetails {
+  INSTRUMENT_ID: string;
+}
+
+export interface NestedInputDetails {
+  ITEMS: FooInputDetails[];
+}
+
+export interface TradeDetails {
+  TRADE_ID?: string;
+  INSTRUMENT_ID: string;
+  COUNTERPARTY_ID: string;
+  QUANTITY: number;
+  SIDE?: Side;
+  PRICE: number;
+  COMMISSION?: string;
+  CREATED_AT?: string;
+}
+
+export interface TradeByIdDetails {
+  TRADE_ID: string;
+}
+
+export interface EventDetailsMap {
+  EVENT_BAR_BAZ: NestedInputDetails;
+  EVENT_CONTEXT_FOO: FooInputDetails;
+  EVENT_DAO_HANDLER: InstrumentByIdDetails;
+  EVENT_FOO: FooInputDetails;
+  EVENT_TRADE_DELETE: TradeByIdDetails;
+  EVENT_TRADE_INSERT: TradeDetails;
+}
+
+export type GenesisEventName = keyof EventDetailsMap;
+
+export class EventBarBaz extends GenesisEvent<'EVENT_BAR_BAZ', NestedInputDetails> {
+  readonly MESSAGE_TYPE = 'EVENT_BAR_BAZ' as const;
+
+  constructor(details: NestedInputDetails) {
+    super(details);
+  }
+}
+
+export class EventContextFoo extends GenesisEvent<'EVENT_CONTEXT_FOO', FooInputDetails> {
+  readonly MESSAGE_TYPE = 'EVENT_CONTEXT_FOO' as const;
+
+  constructor(details: FooInputDetails) {
+    super(details);
+  }
+}
+
+export class EventDaoHandler extends GenesisEvent<'EVENT_DAO_HANDLER', InstrumentByIdDetails> {
+  readonly MESSAGE_TYPE = 'EVENT_DAO_HANDLER' as const;
+
+  constructor(details: InstrumentByIdDetails) {
+    super(details);
+  }
+}
+
+export class EventFoo extends GenesisEvent<'EVENT_FOO', FooInputDetails> {
+  readonly MESSAGE_TYPE = 'EVENT_FOO' as const;
+
+  constructor(details: FooInputDetails) {
+    super(details);
+  }
+}
+
+export class EventTradeDelete extends GenesisEvent<'EVENT_TRADE_DELETE', TradeByIdDetails> {
+  readonly MESSAGE_TYPE = 'EVENT_TRADE_DELETE' as const;
+
+  constructor(details: TradeByIdDetails) {
+    super(details);
+  }
+}
+
+export class EventTradeInsert extends GenesisEvent<'EVENT_TRADE_INSERT', TradeDetails> {
+  readonly MESSAGE_TYPE = 'EVENT_TRADE_INSERT' as const;
+
+  constructor(details: TradeDetails) {
+    super(details);
+  }
+}

package/test/fixtures/mini-server/generated-dao/global/genesis/gen/dao/Instrument.kt

@@ -0,0 +1,13 @@
+package global.genesis.gen.dao
+
+import global.genesis.db.entity.TableEntity
+import java.io.Serializable
+
+/** Fixture stand-in for generated Instrument DAO (index only). */
+public class Instrument public constructor(
+  public var instrumentId: String,
+) : Serializable, TableEntity {
+  public data class ById(
+    public val instrumentId: String,
+  )
+}

package/test/fixtures/mini-server/generated-dao/global/genesis/gen/dao/Trade.kt

@@ -0,0 +1,51 @@
+package global.genesis.gen.dao
+
+import global.genesis.db.entity.TableEntity
+import global.genesis.dictionary.Field
+import global.genesis.dictionary.annotation.GenesisType
+import global.genesis.message.core.annotation.JsonStringDefault
+import global.genesis.message.core.annotation.Title
+import java.io.Serializable
+import java.math.BigDecimal
+import org.joda.time.DateTime
+
+/**
+ * Fixture stand-in for Genesis generated Trade DAO (trimmed constructor).
+ */
+@Title("Trade")
+public class Trade public constructor(
+  tradeId: String? = null,
+  @Title("Instrument Id")
+  @GenesisType(Field.Type.STRING)
+  public var instrumentId: String, // instrument ref, required
+  @Title("Counterparty Id")
+  @GenesisType(Field.Type.STRING)
+  public var counterpartyId: String,
+  @Title("Quantity")
+  @GenesisType(Field.Type.INT)
+  public var quantity: Int,
+  @Title("Side")
+  @GenesisType(Field.Type.ENUM)
+  @JsonStringDefault("BUY")
+  public var side: Side = Side.BUY,
+  @Title("Price")
+  @GenesisType(Field.Type.DOUBLE)
+  public var price: Double,
+  @Title("Commission")
+  @GenesisType(Field.Type.BIGDECIMAL)
+  public var commission: BigDecimal? = null,
+  @Title("Created At")
+  @GenesisType(Field.Type.DATETIME)
+  public var createdAt: DateTime? = null,
+) : Serializable, TableEntity {
+  public var tradeId: String = tradeId ?: ""
+
+  public data class ById(
+    public val tradeId: String,
+  )
+}
+
+enum class Side {
+  BUY,
+  SELL,
+}

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

@@ -0,0 +1,16 @@
+package com.example
+
+import com.example.dto.FooInput
+import com.example.dto.NestedInput
+
+fun register() {
+    eventHandler<FooInput>("FOO")
+    eventHandler<NestedInput>("BAR_BAZ")
+    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

@@ -0,0 +1,10 @@
+package com.example.dto
+
+data class FooInput(
+    @NotNull val fooId: String, // unique id, required
+    /* optional bar, with comma */ val barId: String? = null,
+)
+
+data class NestedInput(
+    val items: List<FooInput>,
+)