@genesislcap/event-type-codegen 15.19.0 → 15.19.1

package/src/parse-enums.ts

@@ -1,105 +0,0 @@
-import { readFileSync } from 'node:fs';
-
-export type KotlinEnumMap = Map<string, readonly string[]>;
-
-const KOTLIN_FILE_EXTENSION = '.kt';
-
-/** Any generated DAO tree Kotlin (entities, enums, xref, etc.). */
-export const isGeneratedDaoTreeFile = (filePath: string): boolean => {
-  const normalized = filePath.replace(/\\/g, '/');
-  return /\/gen\/dao\//i.test(normalized) && normalized.endsWith(KOTLIN_FILE_EXTENSION);
-};
-
-const parseEnumMembers = (body: string): string[] =>
-  body
-    .split(',')
-    .map((part) => part.replace(/\/\/.*$/, '').trim())
-    .map((part) => part.split(/\s+/)[0]?.trim() ?? '')
-    .filter((name) => /^\w+$/.test(name));
-
-/** `enum class Side { BUY, SELL }` in generated DAO sources. */
-export const extractEnumClassesFromContent = (content: string): KotlinEnumMap => {
-  const enums: KotlinEnumMap = new Map();
-  const enumRegex = /(?:^|\n)\s*(?:public\s+)?enum\s+class\s+(\w+)\s*\{([^}]*)\}/gm;
-  let match: RegExpExecArray | null;
-
-  while ((match = enumRegex.exec(content)) !== null) {
-    const name = match[1];
-    const members = parseEnumMembers(match[2]);
-    if (members.length > 0) {
-      enums.set(name, members);
-    }
-  }
-
-  return enums;
-};
-
-/**
- * Companion `Field` metadata on generated entities, e.g.
- * `values = "STANDARD PREMIUM TRIAL"` on `NonNullable<Tier>(Field(… type = Field.Type.ENUM …))`.
- */
-export const extractCompanionFieldEnumValues = (content: string): KotlinEnumMap => {
-  const enums: KotlinEnumMap = new Map();
-  const blockRegex =
-    /public\s+val\s+\w+:\s*NonNullable<(\w+)>\s*=\s*NonNullable<\1>\(Field\(([\s\S]*?)\)\)/g;
-  let match: RegExpExecArray | null;
-
-  while ((match = blockRegex.exec(content)) !== null) {
-    const enumTypeName = match[1];
-    const fieldBody = match[2];
-    if (!fieldBody.includes('Field.Type.ENUM')) continue;
-
-    const valuesMatch = fieldBody.match(/values\s*=\s*"([^"]+)"/);
-    if (!valuesMatch) continue;
-
-    const literals = valuesMatch[1]
-      .trim()
-      .split(/\s+/)
-      .filter((value) => value.length > 0);
-
-    if (literals.length > 0) {
-      enums.set(enumTypeName, literals);
-    }
-  }
-
-  return enums;
-};
-
-const mergeEnumMaps = (into: KotlinEnumMap, from: KotlinEnumMap): void => {
-  for (const [name, values] of from) {
-    if (!into.has(name)) {
-      into.set(name, values);
-    }
-  }
-};
-
-export const parseGeneratedEnumsFromSources = (files: string[]): KotlinEnumMap => {
-  const enums: KotlinEnumMap = new Map();
-
-  for (const filePath of files) {
-    if (!isGeneratedDaoTreeFile(filePath)) continue;
-    const content = readFileSync(filePath, 'utf8');
-    mergeEnumMaps(enums, extractEnumClassesFromContent(content));
-    mergeEnumMaps(enums, extractCompanionFieldEnumValues(content));
-  }
-
-  return enums;
-};
-
-export const kotlinEnumSimpleName = (kotlinType: string): string => {
-  const bare = kotlinType.replace(/\?$/, '').trim();
-  return bare.includes('.') ? (bare.split('.').pop() ?? bare) : bare;
-};
-
-export const kotlinEnumTypeToTs = (kotlinType: string, enums: KotlinEnumMap): string | null => {
-  const simpleName = kotlinEnumSimpleName(kotlinType);
-  const values = enums.get(simpleName);
-  if (!values || values.length === 0) return null;
-  return values.map((value) => `'${value}'`).join(' | ');
-};
-
-/** Use generated enum type name when declared (paired with `renderEnumExports`). */
-export const kotlinEnumTypeRef = (kotlinType: string, enums: KotlinEnumMap): string | null => {
-  const simpleName = kotlinEnumSimpleName(kotlinType);
-  return enums.has(simpleName) ? simpleName : null;
-};

package/src/parse-kotlin.ts

@@ -1,181 +0,0 @@
-import { readFileSync } from 'node:fs';
-
-import { parseKotlinProperty, splitTopLevelArgs, stripKotlinComments } from './kotlin-parse-utils';
-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',
-  // Genesis wire JSON_TYPE for DATE/DATETIME is integer (epoch millis).
-  DateTime: 'number',
-  Instant: 'number',
-  LocalDate: 'number',
-  LocalDateTime: 'number',
-};
-
-const DATA_CLASS_START = /^\s*(?:data\s+)?class\s+(\w+)\s*(?:\([^)]*\))?\s*(?:\([^)]*\)|\{)/;
-
-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((segment) => parseKotlinProperty(segment))
-      .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 content = stripKotlinComments(readFileSync(filePath, 'utf8'));
-    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 stripped = stripKotlinComments(readFileSync(filePath, 'utf8'));
-
-    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/parse-metadata.ts

@@ -1,327 +0,0 @@
-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` : ''}`;
-};