@uql/core 1.0.12 → 3.0.0

package/dist/migrate/cli.js

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { MongoSchemaGenerator } from './generator/mongoSchemaGenerator.js';
+import { MysqlSchemaGenerator } from './generator/mysqlSchemaGenerator.js';
+import { PostgresSchemaGenerator } from './generator/postgresSchemaGenerator.js';
+import { SqliteSchemaGenerator } from './generator/sqliteSchemaGenerator.js';
+import { Migrator } from './migrator.js';
+async function loadConfig() {
+    const configPaths = ['uql.config.ts', 'uql.config.js', 'uql.config.mjs', '.uqlrc.ts', '.uqlrc.js'];
+    for (const configPath of configPaths) {
+        try {
+            const fullPath = resolve(process.cwd(), configPath);
+            const fileUrl = pathToFileURL(fullPath).href;
+            const module = await import(fileUrl);
+            return module.default ?? module;
+        }
+        catch {
+            // Config file not found, try next one
+        }
+    }
+    throw new Error('Could not find uql configuration file. ' + 'Create a uql.config.ts or uql.config.js file in your project root.');
+}
+function getSchemaGenerator(dialect, namingStrategy) {
+    switch (dialect) {
+        case 'postgres':
+            return new PostgresSchemaGenerator(namingStrategy);
+        case 'mysql':
+        case 'mariadb':
+            return new MysqlSchemaGenerator(namingStrategy);
+        case 'sqlite':
+            return new SqliteSchemaGenerator(namingStrategy);
+        case 'mongodb':
+            return new MongoSchemaGenerator(namingStrategy);
+        default:
+            throw new TypeError(`Unknown dialect: ${dialect}`);
+    }
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    if (!command || command === '--help' || command === '-h') {
+        printHelp();
+        return;
+    }
+    try {
+        const config = await loadConfig();
+        if (!config.querierPool) {
+            throw new Error('querierPool is required in configuration');
+        }
+        const dialect = config.dialect ?? 'postgres';
+        const options = {
+            migrationsPath: config.migrationsPath ?? './migrations',
+            tableName: config.tableName,
+            logger: console.log,
+            entities: config.entities,
+            dialect,
+            namingStrategy: config.namingStrategy,
+        };
+        const migrator = new Migrator(config.querierPool, options);
+        migrator.setSchemaGenerator(getSchemaGenerator(dialect, config.namingStrategy));
+        switch (command) {
+            case 'up':
+                await runUp(migrator, args.slice(1));
+                break;
+            case 'down':
+                await runDown(migrator, args.slice(1));
+                break;
+            case 'status':
+                await runStatus(migrator);
+                break;
+            case 'generate':
+            case 'create':
+                await runGenerate(migrator, args.slice(1));
+                break;
+            case 'generate:entities':
+            case 'generate-entities':
+                await runGenerateFromEntities(migrator, args.slice(1));
+                break;
+            case 'sync':
+                await runSync(migrator, args.slice(1));
+                break;
+            case 'pending':
+                await runPending(migrator);
+                break;
+            default:
+                console.error(`Unknown command: ${command}`);
+                printHelp();
+                process.exit(1);
+        }
+        // Close the connection pool
+        const pool = config.querierPool;
+        if (pool.end) {
+            await pool.end();
+        }
+    }
+    catch (error) {
+        console.error('Error:', error.message);
+        process.exit(1);
+    }
+}
+async function runUp(migrator, args) {
+    const options = {};
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--to' && args[i + 1]) {
+            options.to = args[++i];
+        }
+        else if (args[i] === '--step' && args[i + 1]) {
+            options.step = Number.parseInt(args[++i], 10);
+        }
+    }
+    const results = await migrator.up(options);
+    if (results.length === 0) {
+        console.log('No pending migrations.');
+        return;
+    }
+    const successful = results.filter((r) => r.success).length;
+    const failed = results.filter((r) => !r.success).length;
+    console.log(`\nMigrations complete: ${successful} successful, ${failed} failed`);
+    if (failed > 0) {
+        process.exit(1);
+    }
+}
+async function runDown(migrator, args) {
+    const options = { step: 1 }; // Default to 1 step
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--to' && args[i + 1]) {
+            options.to = args[++i];
+            delete options.step;
+        }
+        else if (args[i] === '--step' && args[i + 1]) {
+            options.step = Number.parseInt(args[++i], 10);
+        }
+        else if (args[i] === '--all') {
+            delete options.step;
+        }
+    }
+    const results = await migrator.down(options);
+    if (results.length === 0) {
+        console.log('No migrations to rollback.');
+        return;
+    }
+    const successful = results.filter((r) => r.success).length;
+    const failed = results.filter((r) => !r.success).length;
+    console.log(`\nRollback complete: ${successful} successful, ${failed} failed`);
+    if (failed > 0) {
+        process.exit(1);
+    }
+}
+async function runStatus(migrator) {
+    const status = await migrator.status();
+    console.log('\n=== Migration Status ===\n');
+    console.log('Executed migrations:');
+    if (status.executed.length === 0) {
+        console.log('  (none)');
+    }
+    else {
+        for (const name of status.executed) {
+            console.log(`  ✓ ${name}`);
+        }
+    }
+    console.log('\nPending migrations:');
+    if (status.pending.length === 0) {
+        console.log('  (none)');
+    }
+    else {
+        for (const name of status.pending) {
+            console.log(`  ○ ${name}`);
+        }
+    }
+    console.log('');
+}
+async function runPending(migrator) {
+    const pending = await migrator.pending();
+    if (pending.length === 0) {
+        console.log('No pending migrations.');
+        return;
+    }
+    console.log('Pending migrations:');
+    for (const migration of pending) {
+        console.log(`  ○ ${migration.name}`);
+    }
+}
+async function runGenerate(migrator, args) {
+    const name = args.join('_') || 'migration';
+    const filePath = await migrator.generate(name);
+    console.log(`\nCreated migration: ${filePath}`);
+}
+async function runGenerateFromEntities(migrator, args) {
+    const name = args.join('_') || 'schema';
+    const filePath = await migrator.generateFromEntities(name);
+    console.log(`\nCreated migration from entities: ${filePath}`);
+}
+async function runSync(migrator, args) {
+    const force = args.includes('--force');
+    if (force) {
+        console.log('\n⚠️  WARNING: This will drop and recreate all tables!');
+        console.log('   All data will be lost. This should only be used in development.\n');
+    }
+    await migrator.sync({ force });
+    console.log('\nSchema sync completed.');
+}
+function printHelp() {
+    console.log(`
+@uql/migrate - Database migration tool for uql ORM
+
+Usage: @uql/migrate <command> [options]
+
+Commands:
+  up                    Run all pending migrations
+    --to <name>         Run migrations up to and including <name>
+    --step <n>          Run only <n> migrations
+
+  down                  Rollback the last migration
+    --to <name>         Rollback to (and including) migration <name>
+    --step <n>          Rollback <n> migrations (default: 1)
+    --all               Rollback all migrations
+
+  status                Show migration status
+
+  pending               Show pending migrations
+
+  generate <name>       Create a new empty migration file
+  create <name>         Alias for generate
+
+  generate:entities     Generate migration from entity definitions
+    <name>              Optional name for the migration
+
+  sync                  Sync schema directly (development only!)
+    --force             Drop and recreate all tables
+
+Configuration:
+  Create a uql.config.ts or uql.config.js file in your project root:
+
+  export default {
+    querierPool: new PgQuerierPool({ ... }),
+    migrationsPath: './migrations',
+    tableName: 'uql_migrations',
+    dialect: 'postgres', // 'postgres' | 'mysql' | 'mariadb' | 'sqlite'
+    entities: [User, Post, ...],
+  };
+
+Examples:
+  @uql/migrate up
+  @uql/migrate up --step 1
+  @uql/migrate down
+  @uql/migrate down --step 3
+  @uql/migrate status
+  @uql/migrate generate add_users_table
+  @uql/migrate generate:entities initial_schema
+`);
+}
+main().catch(console.error);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../src/migrate/cli.ts"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env node\n\nimport { resolve } from 'node:path';\nimport { pathToFileURL } from 'node:url';\nimport type { Dialect, MigratorOptions, NamingStrategy, QuerierPool } from '../type/index.js';\nimport { MongoSchemaGenerator } from './generator/mongoSchemaGenerator.js';\nimport { MysqlSchemaGenerator } from './generator/mysqlSchemaGenerator.js';\nimport { PostgresSchemaGenerator } from './generator/postgresSchemaGenerator.js';\nimport { SqliteSchemaGenerator } from './generator/sqliteSchemaGenerator.js';\nimport { Migrator } from './migrator.js';\n\ninterface CliConfig {\n  querierPool?: QuerierPool;\n  migrationsPath?: string;\n  tableName?: string;\n  dialect?: Dialect;\n  entities?: unknown[];\n  namingStrategy?: NamingStrategy;\n}\n\nasync function loadConfig(): Promise<CliConfig> {\n  const configPaths = ['uql.config.ts', 'uql.config.js', 'uql.config.mjs', '.uqlrc.ts', '.uqlrc.js'];\n\n  for (const configPath of configPaths) {\n    try {\n      const fullPath = resolve(process.cwd(), configPath);\n      const fileUrl = pathToFileURL(fullPath).href;\n      const module = await import(fileUrl);\n      return module.default ?? module;\n    } catch {\n      // Config file not found, try next one\n    }\n  }\n\n  throw new Error(\n    'Could not find uql configuration file. ' + 'Create a uql.config.ts or uql.config.js file in your project root.',\n  );\n}\n\nfunction getSchemaGenerator(dialect: Dialect, namingStrategy?: NamingStrategy) {\n  switch (dialect) {\n    case 'postgres':\n      return new PostgresSchemaGenerator(namingStrategy);\n    case 'mysql':\n    case 'mariadb':\n      return new MysqlSchemaGenerator(namingStrategy);\n    case 'sqlite':\n      return new SqliteSchemaGenerator(namingStrategy);\n    case 'mongodb':\n      return new MongoSchemaGenerator(namingStrategy);\n    default:\n      throw new TypeError(`Unknown dialect: ${dialect}`);\n  }\n}\n\nasync function main() {\n  const args = process.argv.slice(2);\n  const command = args[0];\n\n  if (!command || command === '--help' || command === '-h') {\n    printHelp();\n    return;\n  }\n\n  try {\n    const config = await loadConfig();\n\n    if (!config.querierPool) {\n      throw new Error('querierPool is required in configuration');\n    }\n\n    const dialect = config.dialect ?? 'postgres';\n\n    const options: MigratorOptions & { dialect: Dialect } = {\n      migrationsPath: config.migrationsPath ?? './migrations',\n      tableName: config.tableName,\n      logger: console.log,\n      entities: config.entities as MigratorOptions['entities'],\n      dialect,\n      namingStrategy: config.namingStrategy,\n    };\n\n    const migrator = new Migrator(config.querierPool, options);\n    migrator.setSchemaGenerator(getSchemaGenerator(dialect, config.namingStrategy));\n\n    switch (command) {\n      case 'up':\n        await runUp(migrator, args.slice(1));\n        break;\n      case 'down':\n        await runDown(migrator, args.slice(1));\n        break;\n      case 'status':\n        await runStatus(migrator);\n        break;\n      case 'generate':\n      case 'create':\n        await runGenerate(migrator, args.slice(1));\n        break;\n      case 'generate:entities':\n      case 'generate-entities':\n        await runGenerateFromEntities(migrator, args.slice(1));\n        break;\n      case 'sync':\n        await runSync(migrator, args.slice(1));\n        break;\n      case 'pending':\n        await runPending(migrator);\n        break;\n      default:\n        console.error(`Unknown command: ${command}`);\n        printHelp();\n        process.exit(1);\n    }\n\n    // Close the connection pool\n    const pool = config.querierPool as { end?: () => Promise<void> };\n    if (pool.end) {\n      await pool.end();\n    }\n  } catch (error) {\n    console.error('Error:', (error as Error).message);\n    process.exit(1);\n  }\n}\n\nasync function runUp(migrator: Migrator, args: string[]) {\n  const options: { to?: string; step?: number } = {};\n\n  for (let i = 0; i < args.length; i++) {\n    if (args[i] === '--to' && args[i + 1]) {\n      options.to = args[++i];\n    } else if (args[i] === '--step' && args[i + 1]) {\n      options.step = Number.parseInt(args[++i], 10);\n    }\n  }\n\n  const results = await migrator.up(options);\n\n  if (results.length === 0) {\n    console.log('No pending migrations.');\n    return;\n  }\n\n  const successful = results.filter((r: any) => r.success).length;\n  const failed = results.filter((r: any) => !r.success).length;\n\n  console.log(`\\nMigrations complete: ${successful} successful, ${failed} failed`);\n\n  if (failed > 0) {\n    process.exit(1);\n  }\n}\n\nasync function runDown(migrator: Migrator, args: string[]) {\n  const options: { to?: string; step?: number } = { step: 1 }; // Default to 1 step\n\n  for (let i = 0; i < args.length; i++) {\n    if (args[i] === '--to' && args[i + 1]) {\n      options.to = args[++i];\n      delete options.step;\n    } else if (args[i] === '--step' && args[i + 1]) {\n      options.step = Number.parseInt(args[++i], 10);\n    } else if (args[i] === '--all') {\n      delete options.step;\n    }\n  }\n\n  const results = await migrator.down(options);\n\n  if (results.length === 0) {\n    console.log('No migrations to rollback.');\n    return;\n  }\n\n  const successful = results.filter((r: any) => r.success).length;\n  const failed = results.filter((r: any) => !r.success).length;\n\n  console.log(`\\nRollback complete: ${successful} successful, ${failed} failed`);\n\n  if (failed > 0) {\n    process.exit(1);\n  }\n}\n\nasync function runStatus(migrator: Migrator) {\n  const status = await migrator.status();\n\n  console.log('\\n=== Migration Status ===\\n');\n\n  console.log('Executed migrations:');\n  if (status.executed.length === 0) {\n    console.log('  (none)');\n  } else {\n    for (const name of status.executed) {\n      console.log(`  ✓ ${name}`);\n    }\n  }\n\n  console.log('\\nPending migrations:');\n  if (status.pending.length === 0) {\n    console.log('  (none)');\n  } else {\n    for (const name of status.pending) {\n      console.log(`  ○ ${name}`);\n    }\n  }\n\n  console.log('');\n}\n\nasync function runPending(migrator: Migrator) {\n  const pending = await migrator.pending();\n\n  if (pending.length === 0) {\n    console.log('No pending migrations.');\n    return;\n  }\n\n  console.log('Pending migrations:');\n  for (const migration of pending) {\n    console.log(`  ○ ${migration.name}`);\n  }\n}\n\nasync function runGenerate(migrator: Migrator, args: string[]) {\n  const name = args.join('_') || 'migration';\n  const filePath = await migrator.generate(name);\n  console.log(`\\nCreated migration: ${filePath}`);\n}\n\nasync function runGenerateFromEntities(migrator: Migrator, args: string[]) {\n  const name = args.join('_') || 'schema';\n  const filePath = await migrator.generateFromEntities(name);\n  console.log(`\\nCreated migration from entities: ${filePath}`);\n}\n\nasync function runSync(migrator: Migrator, args: string[]) {\n  const force = args.includes('--force');\n\n  if (force) {\n    console.log('\\n⚠️  WARNING: This will drop and recreate all tables!');\n    console.log('   All data will be lost. This should only be used in development.\\n');\n  }\n\n  await migrator.sync({ force });\n  console.log('\\nSchema sync completed.');\n}\n\nfunction printHelp() {\n  console.log(`\n@uql/migrate - Database migration tool for uql ORM\n\nUsage: @uql/migrate <command> [options]\n\nCommands:\n  up                    Run all pending migrations\n    --to <name>         Run migrations up to and including <name>\n    --step <n>          Run only <n> migrations\n\n  down                  Rollback the last migration\n    --to <name>         Rollback to (and including) migration <name>\n    --step <n>          Rollback <n> migrations (default: 1)\n    --all               Rollback all migrations\n\n  status                Show migration status\n\n  pending               Show pending migrations\n\n  generate <name>       Create a new empty migration file\n  create <name>         Alias for generate\n\n  generate:entities     Generate migration from entity definitions\n    <name>              Optional name for the migration\n\n  sync                  Sync schema directly (development only!)\n    --force             Drop and recreate all tables\n\nConfiguration:\n  Create a uql.config.ts or uql.config.js file in your project root:\n\n  export default {\n    querierPool: new PgQuerierPool({ ... }),\n    migrationsPath: './migrations',\n    tableName: 'uql_migrations',\n    dialect: 'postgres', // 'postgres' | 'mysql' | 'mariadb' | 'sqlite'\n    entities: [User, Post, ...],\n  };\n\nExamples:\n  @uql/migrate up\n  @uql/migrate up --step 1\n  @uql/migrate down\n  @uql/migrate down --step 3\n  @uql/migrate status\n  @uql/migrate generate add_users_table\n  @uql/migrate generate:entities initial_schema\n`);\n}\n\nmain().catch(console.error);\n"]}

package/dist/migrate/generator/index.d.ts

@@ -0,0 +1,4 @@
+export * from './mongoSchemaGenerator.js';
+export { MysqlSchemaGenerator, MysqlSchemaGenerator as MariadbSchemaGenerator } from './mysqlSchemaGenerator.js';
+export * from './postgresSchemaGenerator.js';
+export * from './sqliteSchemaGenerator.js';

package/dist/migrate/generator/index.js

@@ -0,0 +1,5 @@
+export * from './mongoSchemaGenerator.js';
+export { MysqlSchemaGenerator, MysqlSchemaGenerator as MariadbSchemaGenerator } from './mysqlSchemaGenerator.js';
+export * from './postgresSchemaGenerator.js';
+export * from './sqliteSchemaGenerator.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWlncmF0ZS9nZW5lcmF0b3IvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsb0JBQW9CLElBQUksc0JBQXNCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUNqSCxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsNEJBQTRCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL21vbmdvU2NoZW1hR2VuZXJhdG9yLmpzJztcbmV4cG9ydCB7IE15c3FsU2NoZW1hR2VuZXJhdG9yLCBNeXNxbFNjaGVtYUdlbmVyYXRvciBhcyBNYXJpYWRiU2NoZW1hR2VuZXJhdG9yIH0gZnJvbSAnLi9teXNxbFNjaGVtYUdlbmVyYXRvci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3Bvc3RncmVzU2NoZW1hR2VuZXJhdG9yLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vc3FsaXRlU2NoZW1hR2VuZXJhdG9yLmpzJztcbiJdfQ==

package/dist/migrate/generator/mongoSchemaGenerator.d.ts

@@ -0,0 +1,12 @@
+import { AbstractDialect } from '../../dialect/index.js';
+import type { IndexSchema, SchemaDiff, SchemaGenerator, TableSchema, Type } from '../../type/index.js';
+export declare class MongoSchemaGenerator extends AbstractDialect implements SchemaGenerator {
+    generateCreateTable<E>(entity: Type<E>): string;
+    generateDropTable<E>(entity: Type<E>): string;
+    generateAlterTable(diff: SchemaDiff): string[];
+    generateAlterTableDown(diff: SchemaDiff): string[];
+    generateCreateIndex(tableName: string, index: IndexSchema): string;
+    generateDropIndex(tableName: string, indexName: string): string;
+    getSqlType(): string;
+    diffSchema<E>(entity: Type<E>, currentSchema: TableSchema | undefined): SchemaDiff | undefined;
+}

package/dist/migrate/generator/mongoSchemaGenerator.js

@@ -0,0 +1,100 @@
+import { AbstractDialect } from '../../dialect/index.js';
+import { getMeta } from '../../entity/index.js';
+export class MongoSchemaGenerator extends AbstractDialect {
+    generateCreateTable(entity) {
+        const meta = getMeta(entity);
+        const collectionName = this.resolveTableName(entity, meta);
+        const indexes = [];
+        for (const key in meta.fields) {
+            const field = meta.fields[key];
+            if (field.index) {
+                const columnName = this.resolveColumnName(key, field);
+                const indexName = typeof field.index === 'string' ? field.index : `idx_${collectionName}_${columnName}`;
+                indexes.push({
+                    name: indexName,
+                    columns: [columnName],
+                    unique: !!field.unique,
+                });
+            }
+        }
+        return JSON.stringify({ action: 'createCollection', name: collectionName, indexes });
+    }
+    generateDropTable(entity) {
+        const meta = getMeta(entity);
+        const collectionName = this.resolveTableName(entity, meta);
+        return JSON.stringify({ action: 'dropCollection', name: collectionName });
+    }
+    generateAlterTable(diff) {
+        const statements = [];
+        if (diff.indexesToAdd?.length) {
+            for (const index of diff.indexesToAdd) {
+                statements.push(this.generateCreateIndex(diff.tableName, index));
+            }
+        }
+        return statements;
+    }
+    generateAlterTableDown(diff) {
+        const statements = [];
+        if (diff.indexesToAdd?.length) {
+            for (const index of diff.indexesToAdd) {
+                statements.push(this.generateDropIndex(diff.tableName, index.name));
+            }
+        }
+        return statements;
+    }
+    generateCreateIndex(tableName, index) {
+        const key = {};
+        for (const col of index.columns) {
+            key[col] = 1;
+        }
+        return JSON.stringify({
+            action: 'createIndex',
+            collection: tableName,
+            name: index.name,
+            key,
+            options: { unique: index.unique, name: index.name },
+        });
+    }
+    generateDropIndex(tableName, indexName) {
+        return JSON.stringify({
+            action: 'dropIndex',
+            collection: tableName,
+            name: indexName,
+        });
+    }
+    getSqlType() {
+        return '';
+    }
+    diffSchema(entity, currentSchema) {
+        const meta = getMeta(entity);
+        const collectionName = this.resolveTableName(entity, meta);
+        if (!currentSchema) {
+            return { tableName: collectionName, type: 'create' };
+        }
+        const indexesToAdd = [];
+        const existingIndexes = new Set(currentSchema.indexes?.map((i) => i.name) ?? []);
+        for (const key in meta.fields) {
+            const field = meta.fields[key];
+            if (field.index) {
+                const columnName = this.resolveColumnName(key, field);
+                const indexName = typeof field.index === 'string' ? field.index : `idx_${collectionName}_${columnName}`;
+                if (!existingIndexes.has(indexName)) {
+                    indexesToAdd.push({
+                        name: indexName,
+                        columns: [columnName],
+                        unique: !!field.unique,
+                    });
+                }
+            }
+        }
+        if (indexesToAdd.length === 0) {
+            return undefined;
+        }
+        return {
+            tableName: collectionName,
+            type: 'alter',
+            indexesToAdd,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mongoSchemaGenerator.js","sourceRoot":"","sources":["../../../src/migrate/generator/mongoSchemaGenerator.ts"],"names":[],"mappings":"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","sourcesContent":["import { AbstractDialect } from '../../dialect/index.js';\nimport { getMeta } from '../../entity/index.js';\nimport type { IndexSchema, SchemaDiff, SchemaGenerator, TableSchema, Type } from '../../type/index.js';\n\nexport class MongoSchemaGenerator extends AbstractDialect implements SchemaGenerator {\n  generateCreateTable<E>(entity: Type<E>): string {\n    const meta = getMeta(entity);\n    const collectionName = this.resolveTableName(entity, meta);\n    const indexes: IndexSchema[] = [];\n\n    for (const key in meta.fields) {\n      const field = meta.fields[key];\n      if (field.index) {\n        const columnName = this.resolveColumnName(key, field);\n        const indexName = typeof field.index === 'string' ? field.index : `idx_${collectionName}_${columnName}`;\n        indexes.push({\n          name: indexName,\n          columns: [columnName],\n          unique: !!field.unique,\n        });\n      }\n    }\n\n    return JSON.stringify({ action: 'createCollection', name: collectionName, indexes });\n  }\n\n  generateDropTable<E>(entity: Type<E>): string {\n    const meta = getMeta(entity);\n    const collectionName = this.resolveTableName(entity, meta);\n    return JSON.stringify({ action: 'dropCollection', name: collectionName });\n  }\n\n  generateAlterTable(diff: SchemaDiff): string[] {\n    const statements: string[] = [];\n    if (diff.indexesToAdd?.length) {\n      for (const index of diff.indexesToAdd) {\n        statements.push(this.generateCreateIndex(diff.tableName, index));\n      }\n    }\n    return statements;\n  }\n\n  generateAlterTableDown(diff: SchemaDiff): string[] {\n    const statements: string[] = [];\n    if (diff.indexesToAdd?.length) {\n      for (const index of diff.indexesToAdd) {\n        statements.push(this.generateDropIndex(diff.tableName, index.name));\n      }\n    }\n    return statements;\n  }\n\n  generateCreateIndex(tableName: string, index: IndexSchema): string {\n    const key: Record<string, number> = {};\n    for (const col of index.columns) {\n      key[col] = 1;\n    }\n    return JSON.stringify({\n      action: 'createIndex',\n      collection: tableName,\n      name: index.name,\n      key,\n      options: { unique: index.unique, name: index.name },\n    });\n  }\n\n  generateDropIndex(tableName: string, indexName: string): string {\n    return JSON.stringify({\n      action: 'dropIndex',\n      collection: tableName,\n      name: indexName,\n    });\n  }\n\n  getSqlType(): string {\n    return '';\n  }\n\n  diffSchema<E>(entity: Type<E>, currentSchema: TableSchema | undefined): SchemaDiff | undefined {\n    const meta = getMeta(entity);\n    const collectionName = this.resolveTableName(entity, meta);\n\n    if (!currentSchema) {\n      return { tableName: collectionName, type: 'create' };\n    }\n\n    const indexesToAdd: IndexSchema[] = [];\n    const existingIndexes = new Set(currentSchema.indexes?.map((i: IndexSchema) => i.name) ?? []);\n\n    for (const key in meta.fields) {\n      const field = meta.fields[key];\n      if (field.index) {\n        const columnName = this.resolveColumnName(key, field);\n        const indexName = typeof field.index === 'string' ? field.index : `idx_${collectionName}_${columnName}`;\n        if (!existingIndexes.has(indexName)) {\n          indexesToAdd.push({\n            name: indexName,\n            columns: [columnName],\n            unique: !!field.unique,\n          });\n        }\n      }\n    }\n\n    if (indexesToAdd.length === 0) {\n      return undefined;\n    }\n\n    return {\n      tableName: collectionName,\n      type: 'alter',\n      indexesToAdd,\n    };\n  }\n}\n"]}

package/dist/migrate/generator/mysqlSchemaGenerator.d.ts

@@ -0,0 +1,14 @@
+import type { ColumnSchema, ColumnType, FieldOptions } from '../../type/index.js';
+import { AbstractSchemaGenerator } from '../schemaGenerator.js';
+/**
+ * MySQL/MariaDB-specific schema generator
+ */
+export declare class MysqlSchemaGenerator extends AbstractSchemaGenerator {
+    protected readonly serialPrimaryKeyType = "INT AUTO_INCREMENT PRIMARY KEY";
+    mapColumnType(columnType: ColumnType, field: FieldOptions): string;
+    getBooleanType(): string;
+    generateAlterColumnStatements(tableName: string, column: ColumnSchema, newDefinition: string): string[];
+    generateColumnComment(tableName: string, columnName: string, comment: string): string;
+    getTableOptions<E>(): string;
+    generateDropIndex(tableName: string, indexName: string): string;
+}

package/dist/migrate/generator/mysqlSchemaGenerator.js

@@ -0,0 +1,81 @@
+import { AbstractSchemaGenerator } from '../schemaGenerator.js';
+/**
+ * MySQL/MariaDB-specific schema generator
+ */
+export class MysqlSchemaGenerator extends AbstractSchemaGenerator {
+    serialPrimaryKeyType = 'INT AUTO_INCREMENT PRIMARY KEY';
+    mapColumnType(columnType, field) {
+        switch (columnType) {
+            case 'int':
+                return 'INT';
+            case 'smallint':
+                return 'SMALLINT';
+            case 'bigint':
+                return 'BIGINT';
+            case 'float':
+                return 'FLOAT';
+            case 'double':
+            case 'real':
+                return 'DOUBLE';
+            case 'decimal':
+            case 'numeric':
+                if (field.precision !== undefined) {
+                    if (field.scale !== undefined) {
+                        return `DECIMAL(${field.precision}, ${field.scale})`;
+                    }
+                    return `DECIMAL(${field.precision})`;
+                }
+                return 'DECIMAL(10, 2)';
+            case 'boolean':
+                return 'TINYINT(1)';
+            case 'char':
+                return `CHAR(${field.length ?? 1})`;
+            case 'varchar':
+                return `VARCHAR(${field.length ?? 255})`;
+            case 'text':
+                return 'TEXT';
+            case 'uuid':
+                return 'CHAR(36)';
+            case 'date':
+                return 'DATE';
+            case 'time':
+                return 'TIME';
+            case 'timestamp':
+            case 'timestamptz':
+                return 'TIMESTAMP';
+            case 'json':
+            case 'jsonb':
+                return 'JSON';
+            case 'blob':
+            case 'bytea':
+                return 'BLOB';
+            case 'vector':
+                // MySQL doesn't have native vector support, use JSON
+                return 'JSON';
+            case 'serial':
+                return 'INT AUTO_INCREMENT';
+            case 'bigserial':
+                return 'BIGINT AUTO_INCREMENT';
+            default:
+                return 'TEXT';
+        }
+    }
+    getBooleanType() {
+        return 'TINYINT(1)';
+    }
+    generateAlterColumnStatements(tableName, column, newDefinition) {
+        return [`ALTER TABLE ${this.escapeId(tableName)} MODIFY COLUMN ${newDefinition};`];
+    }
+    generateColumnComment(tableName, columnName, comment) {
+        const escapedComment = comment.replace(/'/g, "''");
+        return ` COMMENT '${escapedComment}'`;
+    }
+    getTableOptions() {
+        return ' ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci';
+    }
+    generateDropIndex(tableName, indexName) {
+        // MySQL requires table name in DROP INDEX
+        return `DROP INDEX ${this.escapeId(indexName)} ON ${this.escapeId(tableName)};`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/migrate/generator/postgresSchemaGenerator.d.ts

@@ -0,0 +1,18 @@
+import type { ColumnSchema, ColumnType, FieldOptions, NamingStrategy } from '../../type/index.js';
+import { AbstractSchemaGenerator } from '../schemaGenerator.js';
+/**
+ * PostgreSQL-specific schema generator
+ */
+export declare class PostgresSchemaGenerator extends AbstractSchemaGenerator {
+    protected readonly serialPrimaryKeyType = "SERIAL PRIMARY KEY";
+    constructor(namingStrategy?: NamingStrategy);
+    mapColumnType(columnType: ColumnType, field: FieldOptions): string;
+    getBooleanType(): string;
+    generateAlterColumnStatements(tableName: string, column: ColumnSchema, newDefinition: string): string[];
+    generateColumnComment(tableName: string, columnName: string, comment: string): string;
+    /**
+     * Generate COMMENT ON COLUMN statement for PostgreSQL
+     */
+    generateColumnCommentStatement(tableName: string, columnName: string, comment: string): string;
+    generateDropIndex(tableName: string, indexName: string): string;
+}