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

package/src/config.ts

@@ -0,0 +1,67 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+
+import type { EventTypesConfig, EventTypesResolvedConfig } from './types';
+
+const DEFAULT_KOTLIN_SOURCES = [
+  'src/main/kotlin/**/dto/**/*.kt',
+  'src/main/genesis/scripts/**/*.kts',
+];
+
+const DEFAULT_HANDLER_SCAN = ['src/main/kotlin/**/*.kt', 'src/main/genesis/scripts/**/*.kts'];
+
+/**
+ * Relative to the parent of `serverModule` (the Gradle `server/` tree).
+ * Covers dictionary-cache and genesis-home layouts after `./gradlew …` generateDao.
+ */
+const DEFAULT_GENERATED_DAO_SOURCES = [
+  'build/internal-modules/**/*-generated-dao/build/generated/sources/dao/global/genesis/gen/dao/**/*.kt',
+  '**/build/genesis-home/generated/**/gen/dao/**/*.kt',
+];
+
+const DEFAULT_OUTPUT = 'src/generated/genesis-event-types.ts';
+
+const discoverServerModule = (clientRoot: string): string => {
+  const serverDir = resolve(clientRoot, '../server');
+  if (!existsSync(serverDir)) {
+    return '../server';
+  }
+
+  const children = readdirSync(serverDir)
+    .map((name) => join(serverDir, name))
+    .filter((path) => {
+      try {
+        return statSync(path).isDirectory();
+      } catch {
+        return false;
+      }
+    })
+    .filter((path) => existsSync(join(path, 'src', 'main', 'kotlin')));
+
+  if (children.length === 1) {
+    const relative = join('..', 'server', children[0].split(/[/\\]/).pop()!);
+    return relative.replace(/\\/g, '/');
+  }
+
+  return '../server';
+};
+
+export const resolveEventTypesConfig = (
+  clientRoot: string,
+  config?: Partial<EventTypesConfig> & { enabled?: boolean },
+  packageGenesis?: { eventTypes?: EventTypesConfig },
+): EventTypesResolvedConfig => {
+  const fromGenesis = packageGenesis?.eventTypes ?? {};
+  const merged = { ...fromGenesis, ...config };
+  const enabled = merged.enabled === true;
+
+  return {
+    enabled,
+    serverModule: merged.serverModule ?? discoverServerModule(clientRoot),
+    kotlinSources: merged.kotlinSources ?? DEFAULT_KOTLIN_SOURCES,
+    generatedDaoSources: merged.generatedDaoSources ?? DEFAULT_GENERATED_DAO_SOURCES,
+    handlerScan: merged.handlerScan ?? DEFAULT_HANDLER_SCAN,
+    output: merged.output ?? DEFAULT_OUTPUT,
+    runOnBuild: merged.runOnBuild ?? true,
+  };
+};

package/src/index.ts

@@ -0,0 +1,118 @@
+import { existsSync, globSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { consola } from 'consola';
+
+import { resolveEventTypesConfig } from './config';
+import { parseGeneratedDaosFromSources } from './parse-dao';
+import { parseGeneratedEnumsFromSources } from './parse-enums';
+import { parseHandlersFromSources, parseDtosFromSources } from './parse-kotlin';
+import { renderEventTypesFile } from './render';
+import type { EventTypesResolvedConfig, GenerateResult, KotlinDto } from './types';
+
+const isDtoScanPath = (filePath: string) => filePath.replace(/\\/g, '/').includes('/dto/');
+
+const isExcludedHandlerFile = (filePath: string) => {
+  const normalized = filePath.replace(/\\/g, '/');
+  return isDtoScanPath(normalized) && normalized.endsWith('EventHandler.kt');
+};
+
+const collectFiles = (
+  root: string,
+  patterns: string[],
+  options?: { includeBuildDirs?: boolean },
+) => {
+  const files = new Set<string>();
+  for (const pattern of patterns) {
+    const matches = globSync(pattern, {
+      cwd: root,
+      exclude: (name) => {
+        if (name === 'node_modules') return true;
+        if (!options?.includeBuildDirs && name === 'build') return true;
+        return false;
+      },
+    });
+    for (const match of matches) {
+      files.add(join(root, match));
+    }
+  }
+  return [...files];
+};
+
+const mergeTypeMaps = (
+  primary: Map<string, KotlinDto>,
+  secondary: Map<string, KotlinDto>,
+): Map<string, KotlinDto> => {
+  const merged = new Map(secondary);
+  for (const [name, dto] of primary) {
+    merged.set(name, dto);
+  }
+  return merged;
+};
+
+export type GenerateEventTypesOptions = {
+  clientRoot: string;
+  config?: EventTypesResolvedConfig;
+  packageGenesis?: { eventTypes?: unknown };
+};
+
+export async function generateEventTypes(
+  options: GenerateEventTypesOptions,
+): Promise<GenerateResult | null> {
+  const resolved =
+    options.config ??
+    resolveEventTypesConfig(options.clientRoot, undefined, options.packageGenesis);
+
+  if (!resolved.enabled) {
+    return null;
+  }
+
+  const serverRoot = resolve(options.clientRoot, resolved.serverModule);
+  if (!existsSync(serverRoot)) {
+    throw new Error(`eventTypes: server module not found at ${serverRoot}`);
+  }
+
+  // Gradle `server/` tree — parent of the app module (e.g. …/server/showcase-app → …/server)
+  const serverWorkspaceRoot = resolve(serverRoot, '..');
+
+  const dtoFiles = collectFiles(serverRoot, resolved.kotlinSources).filter(
+    (file) => !isExcludedHandlerFile(file),
+  );
+  const handlerFiles = collectFiles(serverRoot, resolved.handlerScan).filter(
+    (file) => !isExcludedHandlerFile(file),
+  );
+  // Scan app module and Gradle server workspace (dictionary-cache lives under server/build/).
+  const daoFiles = [
+    ...collectFiles(serverRoot, resolved.generatedDaoSources, { includeBuildDirs: true }),
+    ...collectFiles(serverWorkspaceRoot, resolved.generatedDaoSources, {
+      includeBuildDirs: true,
+    }),
+  ];
+  const uniqueDaoFiles = [...new Set(daoFiles)];
+
+  const customDtos = parseDtosFromSources(dtoFiles);
+  const generatedDaos = parseGeneratedDaosFromSources(uniqueDaoFiles);
+  const generatedEnums = parseGeneratedEnumsFromSources(uniqueDaoFiles);
+  const dtos = mergeTypeMaps(customDtos, generatedDaos);
+  const { mapped, unmapped } = parseHandlersFromSources(handlerFiles, dtos);
+
+  const outputPath = resolve(options.clientRoot, resolved.output);
+  const contents = renderEventTypesFile(mapped, unmapped, dtos, generatedEnums);
+
+  await mkdir(dirname(outputPath), { recursive: true });
+  await writeFile(outputPath, contents, 'utf8');
+
+  consola.info(
+    `eventTypes: wrote ${outputPath} (${mapped.length} events, ${customDtos.size} DTOs, ${generatedDaos.size} generated DAOs)`,
+  );
+
+  return {
+    outputPath,
+    eventCount: mapped.length,
+    dtoCount: dtos.size,
+    unmappedCount: unmapped.length,
+  };
+}
+
+export * from './types';
+export { resolveEventTypesConfig } from './config';

package/src/naming.ts

@@ -0,0 +1,24 @@
+import { constantCase, pascalCase } from 'change-case';
+
+/** Wire field name for a Kotlin property (DETAILS uses UPPER_SNAKE_CASE). */
+export const kotlinPropertyToWireField = (propertyName: string): string =>
+  constantCase(propertyName);
+
+/** Generated interface name for a Kotlin DTO or handler input type. */
+export const dtoToDetailsInterfaceName = (dtoName: string): string =>
+  dtoName.endsWith('Details') ? dtoName : `${dtoName}Details`;
+
+/** e.g. `Trade.ById` → `TradeByIdDetails`, `FooInput` → `FooInputDetails` */
+export const handlerInputToDetailsInterfaceName = (inputType: string): string => {
+  const indexMatch = inputType.match(/^(\w+)\.(By\w+)$/);
+  if (indexMatch) {
+    return `${indexMatch[1]}${indexMatch[2]}Details`;
+  }
+  return dtoToDetailsInterfaceName(inputType);
+};
+
+/** Per-event class carrying MESSAGE_TYPE and DETAILS (one per PAL handler). */
+export const eventNameToEventClassName = (eventName: string): string => {
+  const base = eventName.startsWith('EVENT_') ? eventName.slice('EVENT_'.length) : eventName;
+  return `Event${pascalCase(base)}`;
+};

package/src/parse-dao.ts

@@ -0,0 +1,186 @@
+import { readFileSync } from 'node:fs';
+
+import type { KotlinDto, KotlinProperty } from './types';
+
+/**
+ * Generated Genesis DAO entities use a primary constructor with annotated
+ * `public var` parameters (and sometimes bare params for sequenced PKs).
+ * Only files directly under `.../gen/dao/*.kt` are entity classes.
+ */
+export const isGeneratedDaoEntityFile = (filePath: string): boolean => {
+  const normalized = filePath.replace(/\\/g, '/');
+  return /\/gen\/dao\/[^/]+\.kt$/i.test(normalized);
+};
+
+const stripKotlinAnnotations = (segment: string): string =>
+  segment
+    .replace(/@[A-Za-z_][\w.]*(?:\s*<[^>]*>)?(?:\s*\([^)]*\))?/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+
+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 parseDaoConstructorProperty = (segment: string): KotlinProperty | null => {
+  const cleaned = stripKotlinAnnotations(segment);
+  // Prefer property syntax: (public) var/val name: Type
+  const propertyMatch = cleaned.match(
+    /^(?:public\s+)?(?:val|var)\s+(\w+)\s*:\s*([^=]+?)(?:\s*=\s*.+)?$/,
+  );
+  // Bare ctor param used for sequenced PKs: tradeId: String? = null
+  const bareMatch = propertyMatch ?? cleaned.match(/^(\w+)\s*:\s*([^=]+?)(?:\s*=\s*.+)?$/);
+
+  if (!bareMatch) return null;
+
+  const name = bareMatch[1];
+  let kotlinType = bareMatch[2].trim();
+  const optional = kotlinType.endsWith('?') || cleaned.includes('=');
+  kotlinType = kotlinType.replace(/\?$/, '').trim();
+
+  return { name, kotlinType, optional };
+};
+
+const parseIndexDataClassProperty = (segment: string): KotlinProperty | null => {
+  const cleaned = stripKotlinAnnotations(segment);
+  const match = cleaned.match(/^(?:public\s+)?(?: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 KOTLIN_FILE_EXTENSION = '.kt';
+
+const entityNameFromDaoFile = (filePath: string): string | null => {
+  const base = filePath.replace(/\\/g, '/').split('/').pop();
+  if (!base?.endsWith(KOTLIN_FILE_EXTENSION)) return null;
+  return base.slice(0, base.length - KOTLIN_FILE_EXTENSION.length);
+};
+
+/**
+ * Nested `data class By*` index types inside generated entity Kotlin (e.g. Trade.ById).
+ */
+export const extractGeneratedDaoIndices = (content: string, filePath: string): KotlinDto[] => {
+  const entityName = entityNameFromDaoFile(filePath);
+  if (!entityName) return [];
+
+  const results: KotlinDto[] = [];
+  const indexRegex = /(?:^|\n)\s*public\s+data\s+class\s+(By\w+)\s*\(/gm;
+  let match: RegExpExecArray | null;
+
+  while ((match = indexRegex.exec(content)) !== null) {
+    const indexName = 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(parseIndexDataClassProperty)
+      .filter((p): p is KotlinProperty => p != null);
+
+    if (properties.length === 0) continue;
+
+    results.push({
+      name: `${entityName}.${indexName}`,
+      properties,
+      filePath,
+    });
+  }
+
+  return results;
+};
+
+/**
+ * Extract table entity classes from generated DAO Kotlin sources.
+ * Prefer entities that look like Genesis table DAOs (constructor + TableEntity).
+ */
+export const extractGeneratedDaoEntities = (content: string, filePath: string): KotlinDto[] => {
+  const results: KotlinDto[] = [];
+  // Matches: public class Trade public constructor( ... ) :
+  const classRegex = /(?:^|\n)\s*(?:public\s+)?class\s+(\w+)\s+(?:public\s+)?constructor\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(parseDaoConstructorProperty)
+      .filter((p): p is KotlinProperty => p != null);
+
+    if (properties.length > 0) {
+      results.push({ name, properties, filePath });
+    }
+  }
+
+  return results;
+};
+
+export const parseGeneratedDaosFromSources = (files: string[]): Map<string, KotlinDto> => {
+  const daos = new Map<string, KotlinDto>();
+
+  for (const filePath of files) {
+    if (!isGeneratedDaoEntityFile(filePath)) continue;
+    const rawContent = readFileSync(filePath, 'utf8');
+    const content = rawContent.replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/.*$/gm, '');
+    for (const entity of extractGeneratedDaoEntities(content, filePath)) {
+      if (!daos.has(entity.name)) {
+        daos.set(entity.name, entity);
+      }
+    }
+    for (const index of extractGeneratedDaoIndices(content, filePath)) {
+      if (!daos.has(index.name)) {
+        daos.set(index.name, index);
+      }
+    }
+  }
+
+  return daos;
+};

package/src/parse-enums.ts

@@ -0,0 +1,105 @@
+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;
+};