@claudetools/tools 0.9.0 → 0.9.2

package/dist/codedna/kappa-typeorm-generator.js

@@ -0,0 +1,723 @@
+// =============================================================================
+// Kappa v2.5 TypeORM Entity Generator
+// =============================================================================
+//
+// Generates TypeORM entity classes from Kappa entity blocks.
+// Supports PostgreSQL, MySQL, and SQLite dialects.
+//
+// =============================================================================
+// Type Mappings
+// =============================================================================
+const COLUMN_TYPE_MAP = {
+    postgres: {
+        string: 'varchar',
+        int: 'integer',
+        float: 'double precision',
+        bool: 'boolean',
+        email: 'varchar',
+        url: 'text',
+        uuid: 'uuid',
+        phone: 'varchar',
+        slug: 'varchar',
+        markdown: 'text',
+        json: 'jsonb',
+        timestamp: 'timestamp with time zone',
+        date: 'date',
+        time: 'time',
+        duration: 'interval',
+    },
+    mysql: {
+        string: 'varchar',
+        int: 'int',
+        float: 'double',
+        bool: 'tinyint',
+        email: 'varchar',
+        url: 'text',
+        uuid: 'varchar',
+        phone: 'varchar',
+        slug: 'varchar',
+        markdown: 'text',
+        json: 'json',
+        timestamp: 'timestamp',
+        date: 'date',
+        time: 'time',
+        duration: 'varchar',
+    },
+    sqlite: {
+        string: 'varchar',
+        int: 'integer',
+        float: 'real',
+        bool: 'integer',
+        email: 'varchar',
+        url: 'text',
+        uuid: 'varchar',
+        phone: 'varchar',
+        slug: 'varchar',
+        markdown: 'text',
+        json: 'text',
+        timestamp: 'datetime',
+        date: 'date',
+        time: 'time',
+        duration: 'varchar',
+    },
+};
+const TS_TYPE_MAP = {
+    string: 'string',
+    int: 'number',
+    float: 'number',
+    bool: 'boolean',
+    email: 'string',
+    url: 'string',
+    uuid: 'string',
+    phone: 'string',
+    slug: 'string',
+    markdown: 'string',
+    json: 'any',
+    timestamp: 'Date',
+    date: 'Date',
+    time: 'string',
+    duration: 'string',
+};
+// =============================================================================
+// Generator Class
+// =============================================================================
+export class KappaTypeORMGenerator {
+    dialect;
+    provenance;
+    generateRepositories;
+    generateMigrations;
+    constructor(options = {}) {
+        this.dialect = options.dialect ?? 'postgres';
+        this.provenance = options.provenance ?? true;
+        this.generateRepositories = options.repositories ?? false;
+        this.generateMigrations = options.migrations ?? true;
+    }
+    /**
+     * Generate TypeORM entities from entity blocks
+     */
+    generate(entities) {
+        const entityFiles = {};
+        for (const entity of entities) {
+            entityFiles[entity.name] = this.generateEntity(entity, entities);
+        }
+        const result = {
+            entities: entityFiles,
+            dataSource: this.generateDataSource(entities),
+        };
+        if (this.generateRepositories) {
+            result.repositories = this.generateRepositories ? this.generateRepositoryFiles(entities) : undefined;
+        }
+        if (this.generateMigrations) {
+            result.migration = this.generateMigrationFile(entities);
+        }
+        return result;
+    }
+    // ===========================================================================
+    // Entity Generation
+    // ===========================================================================
+    generateEntity(entity, allEntities) {
+        const lines = [];
+        // Header comment
+        if (this.provenance) {
+            lines.push('// Generated by Kappa v2.5 CodeDNA');
+            lines.push(`// Dialect: ${this.dialect}`);
+            lines.push(`// Generated at: ${new Date().toISOString()}`);
+            lines.push('');
+        }
+        // Imports
+        lines.push(this.generateEntityImports(entity, allEntities));
+        lines.push('');
+        // Entity class
+        lines.push(this.generateEntityClass(entity, allEntities));
+        return lines.join('\n');
+    }
+    generateEntityImports(entity, allEntities) {
+        const imports = new Set([
+            'Entity',
+            'Column',
+            'PrimaryGeneratedColumn',
+            'CreateDateColumn',
+            'UpdateDateColumn',
+        ]);
+        // Add Index decorator if needed
+        if (entity.indexes.length > 0) {
+            imports.add('Index');
+        }
+        // Add relationship decorators
+        for (const rel of entity.relationships) {
+            switch (rel.type) {
+                case 'belongs_to':
+                    imports.add('ManyToOne');
+                    imports.add('JoinColumn');
+                    break;
+                case 'has_one':
+                    imports.add('OneToOne');
+                    imports.add('JoinColumn');
+                    break;
+                case 'has_many':
+                    if (rel.through) {
+                        imports.add('ManyToMany');
+                        imports.add('JoinTable');
+                    }
+                    else {
+                        imports.add('OneToMany');
+                    }
+                    break;
+            }
+        }
+        const lines = [];
+        lines.push(`import { ${Array.from(imports).sort().join(', ')} } from 'typeorm';`);
+        // Import related entities
+        const relatedEntities = new Set();
+        for (const rel of entity.relationships) {
+            const relEntity = allEntities.find(e => e.name === rel.entity);
+            if (relEntity) {
+                relatedEntities.add(rel.entity);
+            }
+        }
+        if (relatedEntities.size > 0) {
+            for (const relEntity of Array.from(relatedEntities).sort()) {
+                lines.push(`import { ${relEntity} } from './${relEntity}';`);
+            }
+        }
+        return lines.join('\n');
+    }
+    generateEntityClass(entity, allEntities) {
+        const tableName = this.toSnakeCase(entity.name);
+        const lines = [];
+        // Entity decorator with indexes
+        if (entity.indexes.length > 0) {
+            for (const index of entity.indexes) {
+                const indexFields = index.fields.map(f => `"${this.toSnakeCase(f)}"`).join(', ');
+                lines.push(`@Index([${indexFields}]${index.unique ? ', { unique: true }' : ''})`);
+            }
+        }
+        lines.push(`@Entity('${tableName}')`);
+        lines.push(`export class ${entity.name} {`);
+        // Primary key
+        const pkField = entity.fields.find(f => f.modifiers.includes('primary'));
+        if (pkField) {
+            lines.push(this.generatePrimaryKey(pkField));
+        }
+        else {
+            // Default auto-increment ID
+            lines.push('  @PrimaryGeneratedColumn()');
+            lines.push('  id: number;');
+            lines.push('');
+        }
+        // Regular fields
+        for (const field of entity.fields) {
+            if (!field.modifiers.includes('primary')) {
+                lines.push(this.generateField(field));
+                lines.push('');
+            }
+        }
+        // Foreign key fields and relationships
+        for (const rel of entity.relationships) {
+            lines.push(this.generateRelationship(rel, entity, allEntities));
+            lines.push('');
+        }
+        // Timestamps (if not already defined)
+        const hasCreatedAt = entity.fields.some(f => f.name.toLowerCase() === 'createdat');
+        const hasUpdatedAt = entity.fields.some(f => f.name.toLowerCase() === 'updatedat');
+        if (!hasCreatedAt) {
+            lines.push('  @CreateDateColumn()');
+            lines.push('  createdAt: Date;');
+            lines.push('');
+        }
+        if (!hasUpdatedAt) {
+            lines.push('  @UpdateDateColumn()');
+            lines.push('  updatedAt: Date;');
+            lines.push('');
+        }
+        lines.push('}');
+        return lines.join('\n');
+    }
+    generatePrimaryKey(field) {
+        const lines = [];
+        const columnName = this.toSnakeCase(field.name);
+        const tsType = this.getTSType(field.type);
+        if (field.modifiers.includes('auto')) {
+            if (field.type.kind === 'primitive' && field.type.type === 'uuid') {
+                lines.push('  @PrimaryGeneratedColumn("uuid")');
+            }
+            else {
+                lines.push('  @PrimaryGeneratedColumn()');
+            }
+        }
+        else {
+            const columnType = this.getColumnType(field.type);
+            lines.push(`  @Column({ type: '${columnType}', primary: true })`);
+        }
+        lines.push(`  ${field.name}: ${tsType};`);
+        lines.push('');
+        return lines.join('\n');
+    }
+    generateField(field) {
+        const lines = [];
+        const columnName = this.toSnakeCase(field.name);
+        const columnType = this.getColumnType(field.type);
+        const tsType = this.getTSType(field.type);
+        const columnOptions = [];
+        // Type
+        columnOptions.push(`type: '${columnType}'`);
+        // Name (if different from property)
+        if (columnName !== field.name) {
+            columnOptions.push(`name: '${columnName}'`);
+        }
+        // Nullable
+        if (field.modifiers.includes('optional')) {
+            columnOptions.push('nullable: true');
+        }
+        // Unique
+        if (field.modifiers.includes('unique')) {
+            columnOptions.push('unique: true');
+        }
+        // Length for strings
+        if (field.type.kind === 'primitive' && field.type.range?.max) {
+            if (field.type.type === 'string' || field.type.type === 'email' || field.type.type === 'phone') {
+                columnOptions.push(`length: ${field.type.range.max}`);
+            }
+        }
+        else if (field.type.kind === 'primitive') {
+            // Default lengths for specific types
+            if (field.type.type === 'email') {
+                columnOptions.push('length: 255');
+            }
+            else if (field.type.type === 'phone') {
+                columnOptions.push('length: 20');
+            }
+            else if (field.type.type === 'slug') {
+                columnOptions.push('length: 255');
+            }
+            else if (field.type.type === 'uuid') {
+                columnOptions.push('length: 36');
+            }
+        }
+        else if (field.type.kind === 'enum') {
+            // Default length for enum columns (find longest value + buffer)
+            const maxLength = Math.max(...field.type.values.map(v => v.length));
+            columnOptions.push(`length: ${Math.max(maxLength, 50)}`);
+        }
+        // Default value
+        if (field.defaultValue) {
+            columnOptions.push(`default: ${field.defaultValue}`);
+        }
+        else if (field.type.kind === 'enum' && field.type.defaultValue) {
+            columnOptions.push(`default: '${field.type.defaultValue}'`);
+        }
+        // Update trigger
+        if (field.updateTrigger) {
+            columnOptions.push('onUpdate: "CURRENT_TIMESTAMP"');
+        }
+        lines.push(`  @Column({ ${columnOptions.join(', ')} })`);
+        const optional = field.modifiers.includes('optional') ? '?' : '';
+        lines.push(`  ${field.name}${optional}: ${tsType};`);
+        return lines.join('\n');
+    }
+    generateRelationship(rel, entity, allEntities) {
+        const lines = [];
+        const relatedEntity = rel.entity;
+        const propertyName = rel.as || this.toLowerCamelCase(relatedEntity);
+        switch (rel.type) {
+            case 'belongs_to': {
+                const fkColumn = `${this.toSnakeCase(relatedEntity)}_id`;
+                lines.push(`  @ManyToOne(() => ${relatedEntity}${rel.cascade === 'delete' ? ', { onDelete: "CASCADE" }' : ''})`);
+                lines.push(`  @JoinColumn({ name: '${fkColumn}' })`);
+                lines.push(`  ${propertyName}: ${relatedEntity};`);
+                lines.push('');
+                // Add FK column - determine type based on related entity's PK
+                const { fkType, fkTsType } = this.getForeignKeyType(relatedEntity, allEntities);
+                const columnOptions = [`type: '${fkType}'`, `name: '${fkColumn}'`];
+                // Add length for varchar types
+                if (fkType === 'varchar') {
+                    columnOptions.splice(1, 0, 'length: 36');
+                }
+                if (rel.cascade === 'nullify') {
+                    columnOptions.push('nullable: true');
+                }
+                lines.push(`  @Column({ ${columnOptions.join(', ')} })`);
+                lines.push(`  ${this.toCamelCase(fkColumn)}: ${fkTsType};`);
+                break;
+            }
+            case 'has_one': {
+                const inverseSide = this.toLowerCamelCase(entity.name);
+                lines.push(`  @OneToOne(() => ${relatedEntity}, (${this.toLowerCamelCase(relatedEntity)}) => ${this.toLowerCamelCase(relatedEntity)}.${inverseSide}${rel.cascade === 'delete' ? ', { cascade: true }' : ''})`);
+                lines.push(`  @JoinColumn()`);
+                lines.push(`  ${propertyName}?: ${relatedEntity};`);
+                break;
+            }
+            case 'has_many': {
+                if (rel.through) {
+                    // Many-to-many
+                    const throughTable = this.toSnakeCase(rel.through);
+                    lines.push(`  @ManyToMany(() => ${relatedEntity}${rel.cascade === 'delete' ? ', { cascade: true }' : ''})`);
+                    lines.push(`  @JoinTable({ name: '${throughTable}' })`);
+                    lines.push(`  ${propertyName}: ${relatedEntity}[];`);
+                }
+                else {
+                    // One-to-many
+                    const inverseSide = this.toLowerCamelCase(entity.name);
+                    lines.push(`  @OneToMany(() => ${relatedEntity}, (${this.toLowerCamelCase(relatedEntity)}) => ${this.toLowerCamelCase(relatedEntity)}.${inverseSide}${rel.cascade === 'delete' ? ', { cascade: true }' : ''})`);
+                    lines.push(`  ${propertyName}: ${relatedEntity}[];`);
+                }
+                break;
+            }
+        }
+        return lines.join('\n');
+    }
+    getColumnType(type) {
+        switch (type.kind) {
+            case 'primitive':
+                return COLUMN_TYPE_MAP[this.dialect][type.type];
+            case 'enum':
+                return 'varchar';
+            case 'reference':
+                return this.dialect === 'postgres' ? 'uuid' : 'varchar';
+            case 'array':
+                return this.dialect === 'postgres' ? 'jsonb' : 'text';
+            default:
+                return 'varchar';
+        }
+    }
+    getTSType(type) {
+        switch (type.kind) {
+            case 'primitive':
+                return TS_TYPE_MAP[type.type];
+            case 'enum':
+                return type.values.map(v => `'${v}'`).join(' | ');
+            case 'reference':
+                return type.entity;
+            case 'array':
+                if (type.itemType.kind === 'primitive') {
+                    return `${TS_TYPE_MAP[type.itemType.type]}[]`;
+                }
+                return 'any[]';
+            default:
+                return 'any';
+        }
+    }
+    /**
+     * Determine the foreign key column type based on the related entity's primary key
+     */
+    getForeignKeyType(relatedEntityName, allEntities) {
+        const relatedEntity = allEntities.find(e => e.name === relatedEntityName);
+        if (!relatedEntity) {
+            // Default to varchar if entity not found
+            return { fkType: 'varchar', fkTsType: 'string' };
+        }
+        // Find the primary key field
+        const pkField = relatedEntity.fields.find(f => f.modifiers.includes('primary'));
+        if (!pkField) {
+            // Default auto-increment ID would be integer
+            return { fkType: 'integer', fkTsType: 'number' };
+        }
+        // Get the column type for the PK field
+        const pkType = pkField.type;
+        if (pkType.kind === 'primitive') {
+            const columnType = COLUMN_TYPE_MAP[this.dialect][pkType.type];
+            const tsType = TS_TYPE_MAP[pkType.type];
+            return { fkType: columnType, fkTsType: tsType };
+        }
+        // Fallback
+        return { fkType: 'varchar', fkTsType: 'string' };
+    }
+    // ===========================================================================
+    // Data Source Configuration
+    // ===========================================================================
+    generateDataSource(entities) {
+        const lines = [];
+        if (this.provenance) {
+            lines.push('// Generated by Kappa v2.5 CodeDNA');
+            lines.push('// TypeORM Data Source Configuration');
+            lines.push('');
+        }
+        lines.push(`import { DataSource } from 'typeorm';`);
+        // Import all entities
+        for (const entity of entities) {
+            lines.push(`import { ${entity.name} } from './entities/${entity.name}';`);
+        }
+        lines.push('');
+        // Data source configuration
+        lines.push('export const AppDataSource = new DataSource({');
+        // Dialect-specific configuration
+        switch (this.dialect) {
+            case 'postgres':
+                lines.push('  type: "postgres",');
+                lines.push('  host: process.env.DB_HOST || "localhost",');
+                lines.push('  port: parseInt(process.env.DB_PORT || "5432"),');
+                lines.push('  username: process.env.DB_USER || "postgres",');
+                lines.push('  password: process.env.DB_PASSWORD || "",');
+                lines.push('  database: process.env.DB_NAME || "database",');
+                break;
+            case 'mysql':
+                lines.push('  type: "mysql",');
+                lines.push('  host: process.env.DB_HOST || "localhost",');
+                lines.push('  port: parseInt(process.env.DB_PORT || "3306"),');
+                lines.push('  username: process.env.DB_USER || "root",');
+                lines.push('  password: process.env.DB_PASSWORD || "",');
+                lines.push('  database: process.env.DB_NAME || "database",');
+                break;
+            case 'sqlite':
+                lines.push('  type: "sqlite",');
+                lines.push('  database: process.env.DB_PATH || "database.sqlite",');
+                break;
+        }
+        lines.push('  synchronize: process.env.NODE_ENV === "development",');
+        lines.push('  logging: process.env.NODE_ENV === "development",');
+        lines.push('  entities: [');
+        for (const entity of entities) {
+            lines.push(`    ${entity.name},`);
+        }
+        lines.push('  ],');
+        lines.push('  migrations: ["./migrations/*.ts"],');
+        lines.push('  subscribers: [],');
+        lines.push('});');
+        return lines.join('\n');
+    }
+    // ===========================================================================
+    // Repository Generation
+    // ===========================================================================
+    generateRepositoryFiles(entities) {
+        const repositories = {};
+        for (const entity of entities) {
+            repositories[`${entity.name}Repository`] = this.generateRepository(entity);
+        }
+        return repositories;
+    }
+    generateRepository(entity) {
+        const lines = [];
+        if (this.provenance) {
+            lines.push('// Generated by Kappa v2.5 CodeDNA');
+            lines.push(`// ${entity.name} Repository`);
+            lines.push('');
+        }
+        lines.push(`import { Repository } from 'typeorm';`);
+        lines.push(`import { AppDataSource } from '../data-source';`);
+        lines.push(`import { ${entity.name} } from '../entities/${entity.name}';`);
+        lines.push('');
+        lines.push(`export class ${entity.name}Repository extends Repository<${entity.name}> {`);
+        lines.push('  constructor() {');
+        lines.push(`    super(${entity.name}, AppDataSource.createEntityManager());`);
+        lines.push('  }');
+        lines.push('');
+        lines.push('  // Add custom repository methods here');
+        lines.push('}');
+        return lines.join('\n');
+    }
+    // ===========================================================================
+    // Migration Generation
+    // ===========================================================================
+    generateMigrationFile(entities) {
+        const lines = [];
+        const timestamp = Date.now();
+        const className = `CreateInitialSchema${timestamp}`;
+        if (this.provenance) {
+            lines.push('// Generated by Kappa v2.5 CodeDNA');
+            lines.push('// Initial migration');
+            lines.push('');
+        }
+        lines.push(`import { MigrationInterface, QueryRunner } from 'typeorm';`);
+        lines.push('');
+        lines.push(`export class ${className} implements MigrationInterface {`);
+        lines.push('  public async up(queryRunner: QueryRunner): Promise<void> {');
+        // Generate CREATE TABLE statements for each entity
+        for (const entity of entities) {
+            lines.push(`    // Create ${entity.name} table`);
+            lines.push(`    await queryRunner.query(\``);
+            lines.push(this.generateCreateTableSQL(entity, entities));
+            lines.push(`    \`);`);
+            lines.push('');
+        }
+        // Generate indexes
+        for (const entity of entities) {
+            if (entity.indexes.length > 0) {
+                for (const index of entity.indexes) {
+                    lines.push(this.generateCreateIndexSQL(entity, index));
+                }
+            }
+        }
+        lines.push('  }');
+        lines.push('');
+        lines.push('  public async down(queryRunner: QueryRunner): Promise<void> {');
+        // Drop tables in reverse order
+        for (let i = entities.length - 1; i >= 0; i--) {
+            const tableName = this.toSnakeCase(entities[i].name);
+            lines.push(`    await queryRunner.query(\`DROP TABLE IF EXISTS "${tableName}"\`);`);
+        }
+        lines.push('  }');
+        lines.push('}');
+        return lines.join('\n');
+    }
+    generateCreateTableSQL(entity, entities) {
+        const tableName = this.toSnakeCase(entity.name);
+        const lines = [];
+        lines.push(`      CREATE TABLE "${tableName}" (`);
+        const columns = [];
+        // Primary key
+        const pkField = entity.fields.find(f => f.modifiers.includes('primary'));
+        if (pkField) {
+            columns.push(this.generateColumnSQL(pkField, true));
+        }
+        else {
+            // Default ID column
+            if (this.dialect === 'postgres') {
+                columns.push('        "id" SERIAL PRIMARY KEY');
+            }
+            else if (this.dialect === 'mysql') {
+                columns.push('        "id" INT AUTO_INCREMENT PRIMARY KEY');
+            }
+            else {
+                columns.push('        "id" INTEGER PRIMARY KEY AUTOINCREMENT');
+            }
+        }
+        // Regular columns
+        for (const field of entity.fields) {
+            if (!field.modifiers.includes('primary')) {
+                columns.push(this.generateColumnSQL(field, false));
+            }
+        }
+        // Foreign keys
+        for (const rel of entity.relationships) {
+            if (rel.type === 'belongs_to') {
+                const fkColumn = `${this.toSnakeCase(rel.entity)}_id`;
+                const { fkType } = this.getForeignKeyType(rel.entity, entities);
+                // Convert to SQL type with proper casing and length
+                let sqlType;
+                if (fkType === 'uuid' && this.dialect === 'postgres') {
+                    sqlType = 'UUID';
+                }
+                else if (fkType === 'uuid' || fkType === 'varchar') {
+                    sqlType = 'VARCHAR(36)';
+                }
+                else if (fkType === 'integer') {
+                    sqlType = this.dialect === 'mysql' ? 'INT' : 'INTEGER';
+                }
+                else {
+                    sqlType = fkType.toUpperCase();
+                }
+                const nullable = rel.cascade === 'nullify' ? '' : ' NOT NULL';
+                columns.push(`        "${fkColumn}" ${sqlType}${nullable}`);
+            }
+        }
+        // Timestamps
+        if (!entity.fields.some(f => f.name.toLowerCase() === 'createdat')) {
+            columns.push(`        "created_at" ${this.dialect === 'postgres' ? 'TIMESTAMP WITH TIME ZONE' : 'TIMESTAMP'} DEFAULT CURRENT_TIMESTAMP`);
+        }
+        if (!entity.fields.some(f => f.name.toLowerCase() === 'updatedat')) {
+            columns.push(`        "updated_at" ${this.dialect === 'postgres' ? 'TIMESTAMP WITH TIME ZONE' : 'TIMESTAMP'} DEFAULT CURRENT_TIMESTAMP`);
+        }
+        lines.push(columns.join(',\n'));
+        lines.push('      )');
+        return lines.join('\n');
+    }
+    generateColumnSQL(field, isPrimary) {
+        const columnName = this.toSnakeCase(field.name);
+        const columnType = this.getColumnType(field.type).toUpperCase();
+        const parts = [`        "${columnName}"`];
+        // Type with length
+        if (field.type.kind === 'primitive' && field.type.range?.max) {
+            if (field.type.type === 'string' || field.type.type === 'email' || field.type.type === 'phone') {
+                parts.push(`VARCHAR(${field.type.range.max})`);
+            }
+            else {
+                parts.push(columnType);
+            }
+        }
+        else if (field.type.kind === 'primitive') {
+            if (field.type.type === 'email') {
+                parts.push('VARCHAR(255)');
+            }
+            else if (field.type.type === 'phone') {
+                parts.push('VARCHAR(20)');
+            }
+            else if (field.type.type === 'slug') {
+                parts.push('VARCHAR(255)');
+            }
+            else if (field.type.type === 'uuid') {
+                parts.push(this.dialect === 'postgres' ? 'UUID' : 'VARCHAR(36)');
+            }
+            else {
+                parts.push(columnType);
+            }
+        }
+        else if (field.type.kind === 'enum') {
+            // Enum columns get varchar with appropriate length
+            const maxLength = Math.max(...field.type.values.map(v => v.length));
+            parts.push(`VARCHAR(${Math.max(maxLength, 50)})`);
+        }
+        else {
+            parts.push(columnType);
+        }
+        // Primary key
+        if (isPrimary) {
+            if (field.modifiers.includes('auto')) {
+                if (field.type.kind === 'primitive' && field.type.type === 'uuid') {
+                    parts.push(this.dialect === 'postgres' ? 'DEFAULT gen_random_uuid()' : '');
+                }
+                else {
+                    if (this.dialect === 'postgres') {
+                        parts[parts.length - 1] = 'SERIAL';
+                    }
+                    else if (this.dialect === 'mysql') {
+                        parts.push('PRIMARY KEY');
+                        parts.push('AUTO_INCREMENT');
+                        return parts.join(' ');
+                    }
+                    else {
+                        // SQLite: INTEGER PRIMARY KEY AUTOINCREMENT
+                        parts.push('PRIMARY KEY');
+                        parts.push('AUTOINCREMENT');
+                        return parts.join(' ');
+                    }
+                }
+            }
+            parts.push('PRIMARY KEY');
+        }
+        // Nullable
+        if (!field.modifiers.includes('optional') && !isPrimary) {
+            parts.push('NOT NULL');
+        }
+        // Unique
+        if (field.modifiers.includes('unique')) {
+            parts.push('UNIQUE');
+        }
+        // Default value
+        if (field.defaultValue) {
+            parts.push(`DEFAULT ${field.defaultValue}`);
+        }
+        return parts.join(' ');
+    }
+    generateCreateIndexSQL(entity, index) {
+        const tableName = this.toSnakeCase(entity.name);
+        const indexName = `idx_${tableName}_${index.fields.map(f => this.toSnakeCase(f)).join('_')}`;
+        const fields = index.fields.map(f => `"${this.toSnakeCase(f)}"`).join(', ');
+        const unique = index.unique ? 'UNIQUE ' : '';
+        return `    await queryRunner.query(\`CREATE ${unique}INDEX "${indexName}" ON "${tableName}" (${fields})\`);`;
+    }
+    // ===========================================================================
+    // Utilities
+    // ===========================================================================
+    toSnakeCase(str) {
+        return str
+            .replace(/([A-Z])/g, '_$1')
+            .toLowerCase()
+            .replace(/^_/, '');
+    }
+    toCamelCase(str) {
+        return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+    }
+    toLowerCamelCase(str) {
+        return str.charAt(0).toLowerCase() + str.slice(1);
+    }
+}
+// =============================================================================
+// Convenience Function
+// =============================================================================
+/**
+ * Generate TypeORM entities from Kappa entity blocks
+ */
+export function generateTypeORMEntities(entities, options = {}) {
+    const generator = new KappaTypeORMGenerator(options);
+    return generator.generate(entities);
+}