uql-orm 0.9.4 → 0.9.5

package/dist/browser/uql-browser.min.js

@@ -5649,3 +5649,1383 @@ const hooks = {
 
 export { BaseEntity, _Company as Company, _InventoryAdjustment as InventoryAdjustment, _Item as Item, _ItemAdjustment as ItemAdjustment, _ItemTag as ItemTag, _LedgerAccount as LedgerAccount, _MeasureUnit as MeasureUnit, _MeasureUnitCategory as MeasureUnitCategory, _Profile as Profile, _Storehouse as Storehouse, _Tag as Tag, _Tax as Tax, _TaxCategory as TaxCategory, _User as User, _UserWithNonUpdatableId as UserWithNonUpdatableId, _VectorItem as VectorItem, clearTables, createMockQuerierPool, createSpec, createTables, dropTables, loadTsDefaultExportWithJiti };
 //# sourceMappingURL=uql-browser.min.js.map
+ized = defaultValue.toUpperCase();
+        if (normalized === 'NULL') {
+            return null;
+        }
+        if (normalized === 'CURRENT_TIMESTAMP' || normalized === 'CURRENT_TIMESTAMP()') {
+            return 'CURRENT_TIMESTAMP';
+        }
+        if (/^-?\d+$/.test(defaultValue)) {
+            return Number.parseInt(defaultValue, 10);
+        }
+        if (/^-?\d+\.\d+$/.test(defaultValue)) {
+            return Number.parseFloat(defaultValue);
+        }
+        if (defaultValue?.startsWith("'") && defaultValue?.endsWith("'")) {
+            return defaultValue.slice(1, -1);
+        }
+        return defaultValue;
+    }
+}
+/**
+ * Alias for MysqlSchemaIntrospector.
+ * MariaDB uses the same information_schema structure as MySQL.
+ */ const MariadbSchemaIntrospector = MysqlSchemaIntrospector;
+
+/**
+ * PostgreSQL schema introspector
+ */ class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
+    constructor(pool){
+        super(pool.dialect), this.pool = pool;
+    }
+    // ============================================================================
+    // SQL Queries (dialect-specific)
+    // ============================================================================
+    getTableNamesQuery() {
+        return /*sql*/ `
+      SELECT table_name
+      FROM information_schema.tables
+      WHERE table_schema = 'public'
+        AND table_type = 'BASE TABLE'
+      ORDER BY table_name
+    `;
+    }
+    tableExistsQuery() {
+        return /*sql*/ `
+      SELECT EXISTS (
+        SELECT FROM information_schema.tables
+        WHERE table_schema = 'public'
+          AND table_name = $1
+      ) AS exists
+    `;
+    }
+    parseTableExistsResult(results) {
+        return results[0]?.['exists'] ?? false;
+    }
+    getColumnsQuery(_tableName) {
+        return /*sql*/ `
+      SELECT
+        c.column_name,
+        c.data_type,
+        c.udt_name,
+        c.is_nullable,
+        c.column_default,
+        c.character_maximum_length,
+        c.numeric_precision,
+        c.numeric_scale,
+        c.is_identity,
+        c.identity_generation,
+        COALESCE(
+          (SELECT TRUE FROM information_schema.table_constraints tc
+           JOIN information_schema.key_column_usage kcu
+             ON tc.constraint_name = kcu.constraint_name
+           WHERE tc.table_name = c.table_name
+             AND tc.constraint_type = 'PRIMARY KEY'
+             AND kcu.column_name = c.column_name
+           LIMIT 1),
+          FALSE
+        ) AS is_primary_key,
+        COALESCE(
+          (SELECT TRUE FROM information_schema.table_constraints tc
+           JOIN information_schema.key_column_usage kcu
+             ON tc.constraint_name = kcu.constraint_name
+           WHERE tc.table_name = c.table_name
+             AND tc.constraint_type = 'UNIQUE'
+             AND kcu.column_name = c.column_name
+           LIMIT 1),
+          FALSE
+        ) AS is_unique,
+        pg_catalog.col_description(
+          (SELECT oid FROM pg_catalog.pg_class WHERE relname = c.table_name),
+          c.ordinal_position
+        ) AS column_comment
+      FROM information_schema.columns c
+      WHERE c.table_schema = 'public'
+        AND c.table_name = $1
+      ORDER BY c.ordinal_position
+    `;
+    }
+    getIndexesQuery(_tableName) {
+        return /*sql*/ `
+      SELECT
+        i.relname AS index_name,
+        array_to_json(array_agg(a.attname ORDER BY k.n)) AS columns,
+        ix.indisunique AS is_unique
+      FROM pg_class t
+      JOIN pg_index ix ON t.oid = ix.indrelid
+      JOIN pg_class i ON i.oid = ix.indexrelid
+      JOIN pg_namespace n ON n.oid = t.relnamespace
+      CROSS JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, n)
+      JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
+      WHERE t.relname = $1
+        AND n.nspname = 'public'
+        AND NOT ix.indisprimary
+      GROUP BY i.relname, ix.indisunique
+      ORDER BY i.relname
+    `;
+    }
+    getForeignKeysQuery(_tableName) {
+        return /*sql*/ `
+      SELECT
+        tc.constraint_name,
+        array_to_json(array_agg(kcu.column_name ORDER BY kcu.ordinal_position)) AS columns,
+        ccu.table_name AS referenced_table,
+        array_to_json(array_agg(ccu.column_name ORDER BY kcu.ordinal_position)) AS referenced_columns,
+        rc.delete_rule,
+        rc.update_rule
+      FROM information_schema.table_constraints tc
+      JOIN information_schema.key_column_usage kcu
+        ON tc.constraint_name = kcu.constraint_name
+        AND tc.table_schema = kcu.table_schema
+      JOIN information_schema.constraint_column_usage ccu
+        ON ccu.constraint_name = tc.constraint_name
+        AND ccu.table_schema = tc.table_schema
+      JOIN information_schema.referential_constraints rc
+        ON rc.constraint_name = tc.constraint_name
+        AND rc.constraint_schema = tc.table_schema
+      WHERE tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_name = $1
+        AND tc.table_schema = 'public'
+      GROUP BY tc.constraint_name, ccu.table_name, rc.delete_rule, rc.update_rule
+      ORDER BY tc.constraint_name
+    `;
+    }
+    getPrimaryKeyQuery(_tableName) {
+        return /*sql*/ `
+      SELECT kcu.column_name
+      FROM information_schema.table_constraints tc
+      JOIN information_schema.key_column_usage kcu
+        ON tc.constraint_name = kcu.constraint_name
+        AND tc.table_schema = kcu.table_schema
+      WHERE tc.constraint_type = 'PRIMARY KEY'
+        AND tc.table_name = $1
+        AND tc.table_schema = 'public'
+      ORDER BY kcu.ordinal_position
+    `;
+    }
+    // ============================================================================
+    // Internal Types
+    // ============================================================================
+    mapTableNameRow(row) {
+        return row.table_name;
+    }
+    async mapColumnsResult(_querier, _tableName, results) {
+        return results.map((row)=>({
+                name: row.column_name,
+                type: this.normalizeType(row.data_type, row.udt_name),
+                nullable: row.is_nullable === 'YES',
+                defaultValue: this.parseDefaultValue(row.column_default),
+                isPrimaryKey: row.is_primary_key,
+                isAutoIncrement: this.isAutoIncrement(row.column_default, row.is_identity),
+                isUnique: row.is_unique,
+                length: row.character_maximum_length ?? undefined,
+                precision: row.numeric_precision ?? undefined,
+                scale: row.numeric_scale ?? undefined,
+                comment: row.column_comment ?? undefined
+            }));
+    }
+    async mapIndexesResult(_querier, _tableName, results) {
+        return results.map((row)=>({
+                name: row.index_name,
+                columns: row.columns,
+                unique: row.is_unique
+            }));
+    }
+    async mapForeignKeysResult(_querier, _tableName, results) {
+        return results.map((row)=>({
+                name: row.constraint_name,
+                columns: row.columns,
+                referencedTable: row.referenced_table,
+                referencedColumns: row.referenced_columns,
+                onDelete: this.normalizeReferentialAction(row.delete_rule),
+                onUpdate: this.normalizeReferentialAction(row.update_rule)
+            }));
+    }
+    mapPrimaryKeyResult(results) {
+        if (results.length === 0) {
+            return undefined;
+        }
+        return results.map((r)=>r.column_name);
+    }
+    // ============================================================================
+    // PostgreSQL-specific helpers
+    // ============================================================================
+    normalizeType(dataType, udtName) {
+        // Handle user-defined types and arrays
+        if (dataType === 'USER-DEFINED') {
+            return udtName.toUpperCase();
+        }
+        if (dataType === 'ARRAY') {
+            return `${udtName.replace(/^_/, '').toUpperCase()}[]`;
+        }
+        return dataType.toUpperCase();
+    }
+    parseDefaultValue(defaultValue) {
+        if (!defaultValue) {
+            return undefined;
+        }
+        // Remove type casting (e.g., ::text, ::character varying, ::text[])
+        const cleaned = defaultValue.replace(/::[a-z_]+(\s+[a-z_]+)?(\[\])?/gi, '').trim();
+        if (cleaned.startsWith("'") && cleaned.endsWith("'")) {
+            return cleaned.slice(1, -1);
+        }
+        if (cleaned === 'true' || cleaned === 'false') {
+            return cleaned === 'true';
+        }
+        if (cleaned === 'NULL') {
+            return null;
+        }
+        if (/^-?\d+$/.test(cleaned)) {
+            return Number.parseInt(cleaned, 10);
+        }
+        if (/^-?\d+\.\d+$/.test(cleaned)) {
+            return Number.parseFloat(cleaned);
+        }
+        // Return cleaned value for functions like CURRENT_TIMESTAMP, nextval(), etc.
+        return cleaned;
+    }
+    isAutoIncrement(columnDefault, isIdentity) {
+        // PostgreSQL identity columns (GENERATED ... AS IDENTITY)
+        if (isIdentity === 'YES') {
+            return true;
+        }
+        // Serial/bigserial columns use nextval()
+        return columnDefault?.includes('nextval(') ?? false;
+    }
+}
+
+/**
+ * SQLite schema introspector
+ */ class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospector {
+    constructor(pool){
+        super(pool.dialect), this.pool = pool;
+    }
+    // ============================================================================
+    // SQL Queries (dialect-specific)
+    // ============================================================================
+    getTableNamesQuery() {
+        return /*sql*/ `
+      SELECT name
+      FROM sqlite_master
+      WHERE type = 'table'
+        AND name NOT LIKE 'sqlite_%'
+      ORDER BY name
+    `;
+    }
+    tableExistsQuery() {
+        return /*sql*/ `
+      SELECT COUNT(*) as count
+      FROM sqlite_master
+      WHERE type = 'table'
+        AND name = ?
+    `;
+    }
+    parseTableExistsResult(results) {
+        const row = results[0];
+        if (row?.count !== undefined) {
+            return (this.toNumber(row.count) ?? 0) > 0;
+        }
+        return false;
+    }
+    // SQLite uses PRAGMA which doesn't use parameterized queries in the same way
+    getColumnsQuery(tableName) {
+        return `PRAGMA table_info(${this.escapeId(tableName)})`;
+    }
+    getIndexesQuery(tableName) {
+        return `PRAGMA index_list(${this.escapeId(tableName)})`;
+    }
+    getForeignKeysQuery(tableName) {
+        return `PRAGMA foreign_key_list(${this.escapeId(tableName)})`;
+    }
+    getPrimaryKeyQuery(tableName) {
+        return `PRAGMA table_info(${this.escapeId(tableName)})`;
+    }
+    getColumnsParams(_tableName) {
+        return [];
+    }
+    getIndexesParams(_tableName) {
+        return [];
+    }
+    getForeignKeysParams(_tableName) {
+        return [];
+    }
+    getPrimaryKeyParams(_tableName) {
+        return [];
+    }
+    // ============================================================================
+    // Row Mapping (dialect-specific)
+    // ============================================================================
+    mapTableNameRow(row) {
+        return row.name;
+    }
+    async mapColumnsResult(querier, tableName, results) {
+        // Get unique columns from indexes
+        const uniqueColumns = await this.getUniqueColumns(querier, tableName);
+        return results.map((row)=>({
+                name: row.name,
+                type: this.normalizeType(row.type),
+                nullable: row.notnull === 0,
+                defaultValue: this.parseDefaultValue(row.dflt_value),
+                isPrimaryKey: row.pk > 0,
+                isAutoIncrement: row.pk > 0 && row.type.toUpperCase() === 'INTEGER',
+                isUnique: uniqueColumns.has(row.name),
+                length: this.extractLength(row.type),
+                precision: undefined,
+                scale: undefined,
+                comment: undefined
+            }));
+    }
+    async mapIndexesResult(querier, _tableName, results) {
+        const indexSchemas = [];
+        for (const index of results){
+            const columns = await querier.all(`PRAGMA index_info(${this.escapeId(index.name)})`);
+            // Include user-created indexes ('c') and multi-column unique constraints ('u')
+            // Skip primary key indexes ('pk') and single-column unique constraints
+            const isUserCreated = index.origin === 'c';
+            const isCompositeUnique = index.origin === 'u' && columns.length > 1;
+            if (isUserCreated || isCompositeUnique) {
+                indexSchemas.push({
+                    name: index.name,
+                    columns: columns.map((c)=>c.name),
+                    unique: Boolean(index.unique)
+                });
+            }
+        }
+        return indexSchemas;
+    }
+    async mapForeignKeysResult(_querier, tableName, results) {
+        // Group by id to handle composite foreign keys
+        const grouped = new Map();
+        for (const row of results){
+            const id = row.id;
+            const existing = grouped.get(id) ?? [];
+            existing.push(row);
+            grouped.set(id, existing);
+        }
+        return Array.from(grouped.entries()).map(([id, rows])=>{
+            const first = rows[0];
+            return {
+                name: `fk_${tableName}_${id}`,
+                columns: rows.map((r)=>r.from),
+                referencedTable: first.table,
+                referencedColumns: rows.map((r)=>r.to),
+                onDelete: this.normalizeReferentialAction(first.on_delete),
+                onUpdate: this.normalizeReferentialAction(first.on_update)
+            };
+        });
+    }
+    mapPrimaryKeyResult(results) {
+        const pkColumns = results.filter((r)=>r.pk > 0).sort((a, b)=>a.pk - b.pk);
+        if (pkColumns.length === 0) {
+            return undefined;
+        }
+        return pkColumns.map((r)=>r.name);
+    }
+    // ============================================================================
+    // SQLite-specific helpers
+    // ============================================================================
+    async getUniqueColumns(querier, tableName) {
+        const results = await querier.all(`PRAGMA index_list(${this.escapeId(tableName)})`);
+        const uniqueColumns = new Set();
+        for (const index of results){
+            if (index.unique) {
+                const indexInfo = await querier.all(`PRAGMA index_info(${this.escapeId(index.name)})`);
+                // Only single-column unique constraints
+                if (indexInfo.length === 1) {
+                    uniqueColumns.add(indexInfo[0].name);
+                }
+            }
+        }
+        return uniqueColumns;
+    }
+    normalizeType(type) {
+        // Extract base type without length/precision
+        const match = type.match(/^([A-Za-z]+)/);
+        return match ? match[1].toUpperCase() : type.toUpperCase();
+    }
+    extractLength(type) {
+        const match = type.match(/\((\d+)\)/);
+        return match ? Number.parseInt(match[1], 10) : undefined;
+    }
+    parseDefaultValue(defaultValue) {
+        if (defaultValue === null) {
+            return undefined;
+        }
+        if (defaultValue === 'NULL') {
+            return null;
+        }
+        if (defaultValue === 'CURRENT_TIMESTAMP' || defaultValue === 'CURRENT_DATE' || defaultValue === 'CURRENT_TIME') {
+            return defaultValue;
+        }
+        if (/^'.*'$/.test(defaultValue)) {
+            return defaultValue.slice(1, -1);
+        }
+        if (/^-?\d+$/.test(defaultValue)) {
+            return Number.parseInt(defaultValue, 10);
+        }
+        if (typeof defaultValue !== 'string') {
+            return defaultValue;
+        }
+        if (/^-?\d+\.\d+$/.test(defaultValue)) {
+            return Number.parseFloat(defaultValue);
+        }
+        const upper = defaultValue.toUpperCase();
+        if (upper === 'TRUE') return 1;
+        if (upper === 'FALSE') return 0;
+        return defaultValue;
+    }
+}
+
+/**
+ * Schema AST Module
+ *
+ * Provides a unified graph representation of database schema for:
+ * - Schema diffing and migration generation
+ * - Entity code generation from database
+ * - Drift detection
+ * - Smart relation inference
+ */ // Canonical type utilities
+/**
+ * Introspect the database and build a SchemaAST from it.
+ *
+ * @param introspector - The schema introspector to use
+ * @returns The SchemaAST representing the database schema
+ */ async function introspectSchema(introspector) {
+    return introspector.introspect();
+}
+
+/**
+ * Async factory for schema generators. Use this for MongoDB so the optional peer
+ * `mongodb` is only loaded when this path runs. SQL dialects delegate to {@link createSchemaGenerator}.
+ */ async function createSchemaGeneratorAsync(dialect, namingStrategy, defaultForeignKeyAction) {
+    if (dialect.dialectName === 'mongodb') {
+        const { MongoSchemaGenerator } = await import('./mongoSchemaGenerator-BT2_u1wI.js');
+        return new MongoSchemaGenerator(namingStrategy, defaultForeignKeyAction);
+    }
+    return createSchemaGenerator(dialect, namingStrategy, defaultForeignKeyAction);
+}
+
+/**
+ * Stores migration state in a database table.
+ * Uses the querier's dialect for escaping and placeholders.
+ */ class DatabaseMigrationStorage {
+    constructor(pool, options = {}){
+        this.pool = pool;
+        this.storageInitialized = false;
+        this.tableName = options.tableName ?? 'uql_migrations';
+    }
+    async ensureStorage() {
+        if (this.storageInitialized) {
+            return;
+        }
+        const querier = await acquireQuerierForMigrations(this.pool);
+        if (!isSqlQuerier(querier)) {
+            await querier.release();
+            throw new Error('DatabaseMigrationStorage requires a SQL-based querier');
+        }
+        try {
+            await this.createTableIfNotExists(querier);
+            this.storageInitialized = true;
+        } finally{
+            await querier.release();
+        }
+    }
+    async createTableIfNotExists(querier) {
+        const { dialect } = querier;
+        const sql = `
+      CREATE TABLE IF NOT EXISTS ${dialect.escapeId(this.tableName)} (
+        ${dialect.escapeId('name')} VARCHAR(255) PRIMARY KEY,
+        ${dialect.escapeId('executed_at')} TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+        await querier.run(sql);
+    }
+    async executed() {
+        await this.ensureStorage();
+        const querier = await acquireQuerierForMigrations(this.pool);
+        if (!isSqlQuerier(querier)) {
+            await querier.release();
+            throw new Error('DatabaseMigrationStorage requires a SQL-based querier');
+        }
+        try {
+            const { dialect } = querier;
+            const sql = `SELECT ${dialect.escapeId('name')} FROM ${dialect.escapeId(this.tableName)} ORDER BY ${dialect.escapeId('name')} ASC`;
+            const results = await querier.all(sql);
+            return results.map((r)=>r.name);
+        } finally{
+            await querier.release();
+        }
+    }
+    /**
+   * Log a migration as executed - uses provided querier (within transaction)
+   */ async logWithQuerier(querier, migrationName) {
+        await this.ensureStorage();
+        const { dialect } = querier;
+        const sql = `INSERT INTO ${dialect.escapeId(this.tableName)} (${dialect.escapeId('name')}) VALUES (${dialect.placeholder(1)})`;
+        await querier.run(sql, [
+            migrationName
+        ]);
+    }
+    /**
+   * Unlog a migration - uses provided querier (within transaction)
+   */ async unlogWithQuerier(querier, migrationName) {
+        await this.ensureStorage();
+        const { dialect } = querier;
+        const sql = `DELETE FROM ${dialect.escapeId(this.tableName)} WHERE ${dialect.escapeId('name')} = ${dialect.placeholder(1)}`;
+        await querier.run(sql, [
+            migrationName
+        ]);
+    }
+}
+
+/**
+ * Main class for managing database migrations
+ */ class Migrator {
+    get logger() {
+        return this._logger;
+    }
+    set logger(value) {
+        this._logger = new LoggerWrapper$1(value);
+    }
+    get entities() {
+        return this._entities ?? getEntities();
+    }
+    constructor(pool, options = {}){
+        this.pool = pool;
+        this.dialectName = pool.dialect.dialectName ?? 'postgres';
+        this._namingStrategy = options.namingStrategy;
+        this.storage = options.storage ?? new DatabaseMigrationStorage(pool, {
+            tableName: options.tableName
+        });
+        this.migrationsPath = options.migrationsPath ?? './migrations';
+        this._logger = new LoggerWrapper$1(options.logger, options.slowQuery);
+        this._entities = options.entities;
+        this.schemaIntrospector = this.createIntrospector();
+        this.schemaGenerator = options.schemaGenerator ?? (this.dialectName === 'mongodb' ? undefined : this.createGenerator(options.namingStrategy));
+    }
+    /** Loads MongoDB schema generator on first use; SQL generators are set in the constructor (or via {@link setSchemaGenerator}). */ async ensureSchemaGenerator() {
+        if (this.schemaGenerator || this.dialectName !== 'mongodb') {
+            return;
+        }
+        if (!this._mongoSchemaLoadPromise) {
+            this._mongoSchemaLoadPromise = createSchemaGeneratorAsync(this.pool.dialect, this._namingStrategy).then((gen)=>{
+                if (gen) {
+                    this.schemaGenerator = gen;
+                }
+            });
+        }
+        await this._mongoSchemaLoadPromise;
+    }
+    /**
+   * Set the schema generator for DDL operations
+   */ setSchemaGenerator(generator) {
+        this.schemaGenerator = generator;
+    }
+    createIntrospector() {
+        const d = this.dialectName;
+        if (!isKnownMigratorDialect(d)) {
+            return undefined;
+        }
+        switch(d){
+            case 'postgres':
+            case 'cockroachdb':
+                return new PostgresSchemaIntrospector(this.pool);
+            case 'mysql':
+            case 'mariadb':
+                return new MysqlSchemaIntrospector(this.pool);
+            case 'sqlite':
+                return new SqliteSchemaIntrospector(this.pool);
+            case 'mongodb':
+                return new MongoSchemaIntrospector(this.pool);
+            default:
+                return undefined;
+        }
+    }
+    createGenerator(namingStrategy) {
+        if (!isKnownMigratorDialect(this.dialectName)) {
+            return undefined;
+        }
+        return createSchemaGenerator(this.pool.dialect);
+    }
+    /**
+   * Get all discovered migrations from the migrations directory
+   */ async getMigrations() {
+        const files = await this.getMigrationFiles();
+        const migrations = [];
+        for (const file of files){
+            const migration = await this.loadMigration(file);
+            if (migration) {
+                migrations.push(migration);
+            }
+        }
+        // Sort by name (which typically includes timestamp)
+        return migrations.sort((a, b)=>a.name.localeCompare(b.name));
+    }
+    /**
+   * Get list of pending migrations (not yet executed)
+   */ async pending() {
+        const [migrations, executed] = await Promise.all([
+            this.getMigrations(),
+            this.storage.executed()
+        ]);
+        const executedSet = new Set(executed);
+        return migrations.filter((m)=>!executedSet.has(m.name));
+    }
+    /**
+   * Get list of executed migrations
+   */ async executed() {
+        return this.storage.executed();
+    }
+    /**
+   * Run all pending migrations
+   */ async up(options = {}) {
+        const pendingMigrations = await this.pending();
+        const results = [];
+        let migrationsToRun = pendingMigrations;
+        if (options.to) {
+            const toIndex = migrationsToRun.findIndex((m)=>m.name === options.to);
+            if (toIndex === -1) {
+                throw new Error(`Migration '${options.to}' not found`);
+            }
+            migrationsToRun = migrationsToRun.slice(0, toIndex + 1);
+        }
+        if (options.step !== undefined) {
+            migrationsToRun = migrationsToRun.slice(0, options.step);
+        }
+        for (const migration of migrationsToRun){
+            const result = await this.runMigration(migration, 'up');
+            results.push(result);
+            if (!result.success) {
+                break; // Stop on first failure
+            }
+        }
+        return results;
+    }
+    /**
+   * Rollback migrations
+   */ async down(options = {}) {
+        const [migrations, executed] = await Promise.all([
+            this.getMigrations(),
+            this.storage.executed()
+        ]);
+        const executedSet = new Set(executed);
+        const executedMigrations = migrations.filter((m)=>executedSet.has(m.name)).reverse(); // Rollback in reverse order
+        const results = [];
+        let migrationsToRun = executedMigrations;
+        if (options.to) {
+            const toIndex = migrationsToRun.findIndex((m)=>m.name === options.to);
+            if (toIndex === -1) {
+                throw new Error(`Migration '${options.to}' not found`);
+            }
+            migrationsToRun = migrationsToRun.slice(0, toIndex + 1);
+        }
+        if (options.step !== undefined) {
+            migrationsToRun = migrationsToRun.slice(0, options.step);
+        }
+        for (const migration of migrationsToRun){
+            const result = await this.runMigration(migration, 'down');
+            results.push(result);
+            if (!result.success) {
+                break; // Stop on first failure
+            }
+        }
+        return results;
+    }
+    /**
+   * Run a single migration within a transaction
+   */ async runMigration(migration, direction) {
+        const startTime = Date.now();
+        const querier = await acquireQuerierForMigrations(this.pool);
+        if (!isSqlQuerier(querier)) {
+            await querier.release();
+            throw new Error('Migrator requires a SQL-based querier');
+        }
+        try {
+            this.logger.logMigration(`${direction === 'up' ? 'Running' : 'Reverting'} migration: ${migration.name}`);
+            await querier.beginTransaction();
+            if (direction === 'up') {
+                await migration.up(querier);
+                // Log within the same transaction
+                await this.storage.logWithQuerier(querier, migration.name);
+            } else {
+                await migration.down(querier);
+                // Unlog within the same transaction
+                await this.storage.unlogWithQuerier(querier, migration.name);
+            }
+            await querier.commitTransaction();
+            const duration = Date.now() - startTime;
+            this.logger.logMigration(`Migration ${migration.name} ${direction === 'up' ? 'applied' : 'reverted'} in ${duration}ms`);
+            return {
+                name: migration.name,
+                direction,
+                duration,
+                success: true
+            };
+        } catch (error) {
+            await querier.rollbackTransaction();
+            const duration = Date.now() - startTime;
+            this.logger.logError(`Migration ${migration.name} failed: ${error.message}`, error);
+            return {
+                name: migration.name,
+                direction,
+                duration,
+                success: false,
+                error: error
+            };
+        } finally{
+            await querier.release();
+        }
+    }
+    /**
+   * Generate a new migration file
+   */ async generate(name) {
+        const timestamp = this.getTimestamp();
+        const fileName = `${timestamp}_${this.slugify(name)}.ts`;
+        const filePath = join(this.migrationsPath, fileName);
+        const content = buildSqlQuerierMigrationModule({
+            migrationName: name,
+            createdAt: new Date(),
+            upInner: EMPTY_MANUAL_MIGRATION_UP_INNER,
+            downInner: EMPTY_MANUAL_MIGRATION_DOWN_INNER
+        });
+        await mkdir(this.migrationsPath, {
+            recursive: true
+        });
+        await writeFile(filePath, content, 'utf-8');
+        this.logger.logInfo(`Created migration: ${filePath}`);
+        return filePath;
+    }
+    /**
+   * Generate a migration based on entity schema differences
+   */ async generateFromEntities(name) {
+        await this.ensureSchemaGenerator();
+        if (!this.schemaGenerator) {
+            throw new Error('Schema generator not set. Call setSchemaGenerator() first.');
+        }
+        const diffs = await this.getDiffs();
+        const upStatements = [];
+        const downStatements = [];
+        for (const diff of diffs){
+            if (diff.type === 'create') {
+                const entity = await this.findEntityForTable(diff.tableName);
+                if (entity) {
+                    upStatements.push(...this.schemaGenerator.generateCreateTable(entity));
+                    downStatements.push(this.schemaGenerator.generateDropTable(entity));
+                }
+            } else if (diff.type === 'alter') {
+                const alterStatements = this.schemaGenerator.generateAlterTable(diff);
+                upStatements.push(...alterStatements);
+                const alterDownStatements = this.schemaGenerator.generateAlterTableDown(diff);
+                downStatements.push(...alterDownStatements);
+            }
+        }
+        if (upStatements.length === 0) {
+            this.logger.logInfo('No schema changes detected.');
+            return '';
+        }
+        const timestamp = this.getTimestamp();
+        const fileName = `${timestamp}_${this.slugify(name)}.ts`;
+        const filePath = join(this.migrationsPath, fileName);
+        const down = [
+            ...downStatements
+        ].reverse();
+        const content = buildSqlQuerierMigrationModule({
+            migrationName: name,
+            createdAt: new Date(),
+            docExtraLines: [
+                'Generated from entity definitions'
+            ],
+            upInner: emitSqlRunCalls(upStatements),
+            downInner: emitSqlRunCalls(down)
+        });
+        await mkdir(this.migrationsPath, {
+            recursive: true
+        });
+        await writeFile(filePath, content, 'utf-8');
+        this.logger.logInfo(`Created migration from entities: ${filePath}`);
+        return filePath;
+    }
+    /**
+   * Get all schema differences between entities and database
+   */ async getDiffs() {
+        await this.ensureSchemaGenerator();
+        if (!this.schemaGenerator || !this.schemaIntrospector) {
+            throw new Error('Schema generator and introspector must be set');
+        }
+        const ast = await introspectSchema(this.schemaIntrospector);
+        const diffs = [];
+        for (const entity of this.entities){
+            const meta = getMeta$1(entity);
+            const tableName = this.schemaGenerator.resolveTableName(entity, meta);
+            const currentTable = ast.getTable(tableName);
+            const diff = this.schemaGenerator.diffSchema(entity, currentTable);
+            if (diff) {
+                diffs.push(diff);
+            }
+        }
+        return diffs;
+    }
+    async findEntityForTable(tableName) {
+        await this.ensureSchemaGenerator();
+        if (!this.schemaGenerator) {
+            return undefined;
+        }
+        for (const entity of this.entities){
+            const meta = getMeta$1(entity);
+            const name = this.schemaGenerator.resolveTableName(entity, meta);
+            if (name === tableName) {
+                return entity;
+            }
+        }
+        return undefined;
+    }
+    /**
+   * Sync schema directly (for development only - not for production!)
+   */ async sync(options = {}) {
+        if (options.force) {
+            return this.syncForce();
+        }
+        return this.autoSync({
+            safe: true
+        });
+    }
+    /**
+   * Drops and recreates all tables (Development only!)
+   */ async syncForce() {
+        await this.ensureSchemaGenerator();
+        if (!this.schemaGenerator) {
+            throw new Error('Schema generator not set. Call setSchemaGenerator() first.');
+        }
+        const querier = await acquireQuerierForMigrations(this.pool);
+        if (!isSqlQuerier(querier)) {
+            await querier.release();
+            throw new Error('Migrator requires a SQL-based querier');
+        }
+        try {
+            await querier.beginTransaction();
+            // Drop all tables first (in reverse order for foreign keys)
+            for (const entity of [
+                ...this.entities
+            ].reverse()){
+                const dropSql = this.schemaGenerator.generateDropTable(entity);
+                this.logger.logSchema(`Executing: ${dropSql}`);
+                await querier.run(dropSql);
+            }
+            // Create all tables
+            for (const entity of this.entities){
+                const createStmts = this.schemaGenerator.generateCreateTable(entity);
+                for (const createSql of createStmts){
+                    this.logger.logSchema(`Executing: ${createSql}`);
+                    await querier.run(createSql);
+                }
+            }
+            await querier.commitTransaction();
+            this.logger.logSchema('Schema sync (force) completed');
+        } catch (error) {
+            await querier.rollbackTransaction();
+            throw error;
+        } finally{
+            await querier.release();
+        }
+    }
+    /**
+   * Safely synchronizes the schema by only adding missing tables and columns.
+   */ async autoSync(options = {}) {
+        await this.ensureSchemaGenerator();
+        if (!this.schemaGenerator || !this.schemaIntrospector) {
+            throw new Error('Schema generator and introspector must be set');
+        }
+        const diffs = await this.getDiffs();
+        const statements = [];
+        for (const diff of diffs){
+            if (diff.type === 'create') {
+                const entity = await this.findEntityForTable(diff.tableName);
+                if (entity) {
+                    statements.push(...this.schemaGenerator.generateCreateTable(entity));
+                }
+            } else if (diff.type === 'alter') {
+                const filteredDiff = this.filterDiff(diff, options);
+                const alterStatements = this.schemaGenerator.generateAlterTable(filteredDiff);
+                statements.push(...alterStatements);
+            }
+        }
+        if (statements.length === 0) {
+            if (options.logging) this.logger.logSchema('Schema is already in sync.');
+            return;
+        }
+        await this.executeSyncStatements(statements, options);
+    }
+    filterDiff(diff, options) {
+        const filteredDiff = {
+            ...diff
+        };
+        if (options.safe !== false) {
+            // In safe mode, we only allow additions (creating tables/columns)
+            // We block drops and alterations to prevent accidental data loss
+            if (filteredDiff.columnsToDrop?.length) {
+                this.logger.logSkippedMigration(`[AutoSync] Skipped dropping ${filteredDiff.columnsToDrop.length} columns in table '${diff.tableName}': ${filteredDiff.columnsToDrop.join(', ')} (safe mode active)`);
+                delete filteredDiff.columnsToDrop;
+            }
+            if (filteredDiff.columnsToAlter?.length) {
+                this.logger.logSkippedMigration(`[AutoSync] Skipped altering ${filteredDiff.columnsToAlter.length} columns in table '${diff.tableName}': ${filteredDiff.columnsToAlter.map((c)=>c.to.name).join(', ')} (safe mode active). Use a migration or { safe: false } to apply.`);
+                delete filteredDiff.columnsToAlter;
+            }
+            delete filteredDiff.indexesToDrop;
+            delete filteredDiff.foreignKeysToDrop;
+        }
+        if (!options.drop && filteredDiff.columnsToDrop?.length) {
+            this.logger.logSkippedMigration(`[AutoSync] Skipped dropping ${filteredDiff.columnsToDrop.length} columns in table '${diff.tableName}' (drop: false). Use { drop: true } to apply.`);
+            delete filteredDiff.columnsToDrop;
+        }
+        return filteredDiff;
+    }
+    async executeSyncStatements(statements, options) {
+        const querier = await acquireQuerierForMigrations(this.pool);
+        try {
+            if (this.dialectName === 'mongodb') {
+                await this.executeMongoSyncStatements(statements, options, querier);
+            } else {
+                await this.executeSqlSyncStatements(statements, options, querier);
+            }
+            if (options.logging) this.logger.logSchema('Schema synchronization completed');
+        } catch (error) {
+            if (this.dialectName !== 'mongodb' && isSqlQuerier(querier)) {
+                await querier.rollbackTransaction();
+            }
+            throw error;
+        } finally{
+            await querier.release();
+        }
+    }
+    async executeMongoSyncStatements(statements, options, querier) {
+        const db = querier.db;
+        for (const stmt of statements){
+            const cmd = JSON.parse(stmt);
+            if (options.logging) this.logger.logSchema(`Executing MongoDB: ${stmt}`);
+            const collectionName = cmd.name || cmd.collection;
+            if (!collectionName) {
+                throw new Error(`MongoDB command missing collection name: ${stmt}`);
+            }
+            const collection = db.collection(collectionName);
+            if (cmd.action === 'createCollection') {
+                await db.createCollection(cmd.name);
+                if (cmd.indexes?.length) {
+                    for (const idx of cmd.indexes){
+                        const key = Object.fromEntries(idx.columns.map((c)=>[
+                                c,
+                                1
+                            ]));
+                        await collection.createIndex(key, {
+                            unique: idx.unique,
+                            name: idx.name
+                        });
+                    }
+                }
+            } else if (cmd.action === 'dropCollection') {
+                await collection.drop();
+            } else if (cmd.action === 'createIndex') {
+                await collection.createIndex(cmd.key, cmd.options);
+            } else if (cmd.action === 'dropIndex') {
+                await collection.dropIndex(cmd.name);
+            }
+        }
+    }
+    async executeSqlSyncStatements(statements, options, querier) {
+        if (!isSqlQuerier(querier)) {
+            throw new Error('Migrator requires a SQL-based querier for this dialect');
+        }
+        await querier.beginTransaction();
+        for (const sql of statements){
+            if (options.logging) this.logger.logSchema(`Executing: ${sql}`);
+            await querier.run(sql);
+        }
+        await querier.commitTransaction();
+    }
+    /**
+   * Get migration status
+   */ async status() {
+        const [pending, executed] = await Promise.all([
+            this.pending().then((m)=>m.map((x)=>x.name)),
+            this.executed()
+        ]);
+        return {
+            pending,
+            executed
+        };
+    }
+    /**
+   * Get migration files from the migrations directory
+   */ async getMigrationFiles() {
+        try {
+            const files = await readdir(this.migrationsPath);
+            return files.filter((f)=>/\.(ts|js|mjs)$/.test(f)).filter((f)=>!f.endsWith('.d.ts')).sort();
+        } catch (error) {
+            if (error.code === 'ENOENT') {
+                return [];
+            }
+            throw error;
+        }
+    }
+    /**
+   * Load a migration from a file
+   */ async loadMigration(fileName) {
+        const filePath = join(this.migrationsPath, fileName);
+        const fileUrl = pathToFileURL(filePath).href;
+        try {
+            const module = await import(fileUrl);
+            const migration = module.default ?? module;
+            if (this.isMigration(migration)) {
+                return {
+                    name: this.getMigrationName(fileName),
+                    up: migration.up.bind(migration),
+                    down: migration.down.bind(migration)
+                };
+            }
+            this.logger.logWarn(`Warning: ${fileName} is not a valid migration`);
+            return undefined;
+        } catch (error) {
+            this.logger.logError(`Error loading migration ${fileName}: ${error.message}`, error);
+            return undefined;
+        }
+    }
+    /**
+   * Check if an object is a valid migration
+   */ isMigration(obj) {
+        return typeof obj === 'object' && obj !== undefined && obj !== null && typeof obj.up === 'function' && typeof obj.down === 'function';
+    }
+    /**
+   * Extract migration name from filename
+   */ getMigrationName(fileName) {
+        return basename(fileName, extname(fileName));
+    }
+    /**
+   * Generate timestamp string for migration names
+   */ getTimestamp() {
+        const now = new Date();
+        return [
+            now.getFullYear(),
+            String(now.getMonth() + 1).padStart(2, '0'),
+            String(now.getDate()).padStart(2, '0'),
+            String(now.getHours()).padStart(2, '0'),
+            String(now.getMinutes()).padStart(2, '0'),
+            String(now.getSeconds()).padStart(2, '0')
+        ].join('');
+    }
+    /**
+   * Convert a string to a slug for filenames
+   */ slugify(text) {
+        return text.toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '');
+    }
+}
+/**
+ * Helper function to define a migration with proper typing
+ */ function defineMigration(migration) {
+    return migration;
+}
+/**
+ * Define a migration using the type-safe builder API.
+ *
+ * @example
+ * ```ts
+ * export default defineBuilderMigration({
+ *   async up(m) {
+ *     await m.createTable('users', (table) => {
+ *       table.id();
+ *       table.string('email', 255).unique();
+ *       table.timestamps();
+ *     });
+ *   },
+ *   async down(m) {
+ *     await m.dropTable('users');
+ *   }
+ * });
+ * ```
+ */ function defineBuilderMigration(migration) {
+    return migration;
+}
+
+/**
+ * Stores migration state in a JSON file.
+ * Useful for development or environments without a database.
+ */ class JsonMigrationStorage {
+    constructor(filePath = './migrations/.uql-migrations.json'){
+        this.executedMigrations = [];
+        this.filePath = filePath;
+    }
+    async ensureStorage() {
+        const content = await fs.readFile(this.filePath, 'utf-8').catch(async (error)=>{
+            if (error.code === 'ENOENT') {
+                const initial = '[]';
+                await fs.writeFile(this.filePath, initial, 'utf-8');
+                return initial;
+            }
+            throw error;
+        });
+        this.executedMigrations = JSON.parse(content);
+    }
+    async executed() {
+        await this.ensureStorage();
+        return this.executedMigrations;
+    }
+    async logWithQuerier(_querier, migrationName) {
+        await this.ensureStorage();
+        if (!this.executedMigrations.includes(migrationName)) {
+            this.executedMigrations.push(migrationName);
+            await this.save();
+        }
+    }
+    async unlogWithQuerier(_querier, migrationName) {
+        await this.ensureStorage();
+        this.executedMigrations = this.executedMigrations.filter((m)=>m !== migrationName);
+        await this.save();
+    }
+    async save() {
+        await fs.writeFile(this.filePath, JSON.stringify(this.executedMigrations, null, 2), 'utf-8');
+    }
+}
+
+/**
+ * Service for synchronizing schemas between entities and database.
+ */ class SchemaSync {
+    constructor(options){
+        this.options = options;
+    }
+    /**
+   * Execute schema synchronization.
+   */ async sync() {
+        const direction = this.options.direction ?? 'bidirectional';
+        switch(direction){
+            case 'entity-to-db':
+                return this.syncEntityToDb();
+            case 'db-to-entity':
+                return this.syncDbToEntity();
+            case 'bidirectional':
+                return this.syncBidirectional();
+        }
+    }
+    /**
+   * Sync from entities to database (push).
+   */ async syncEntityToDb() {
+        const entityAST = this.buildEntityAST();
+        const dbAST = await this.buildDatabaseAST();
+        const differ = new SchemaASTDiffer();
+        const diff = differ.diff(entityAST, dbAST);
+        // In safe mode, filter out destructive changes
+        const safeDiff = this.options.safe ? this.filterDestructiveChanges(diff) : diff;
+        return {
+            direction: 'entity-to-db',
+            success: true,
+            dbChanges: safeDiff,
+            entityChanges: undefined,
+            conflicts: [],
+            summary: this.formatSummary('entity-to-db', safeDiff),
+            details: {
+                db: this.getDiffCounts(safeDiff),
+                entity: {
+                    created: 0,
+                    dropped: 0,
+                    altered: 0
+                }
+            }
+        };
+    }
+    /**
+   * Sync from database to entities (pull).
+   */ async syncDbToEntity() {
+        const entityAST = this.buildEntityAST();
+        const dbAST = await this.buildDatabaseAST();
+        const differ = new SchemaASTDiffer();
+        // Diff in opposite direction: DB is source, entity is target
+        const diff = differ.diff(dbAST, entityAST);
+        // Apply safe mode if enabled
+        const safeDiff = this.options.safe ? this.filterDestructiveChanges(diff) : diff;
+        return {
+            direction: 'db-to-entity',
+            success: true,
+            dbChanges: undefined,
+            entityChanges: safeDiff,
+            conflicts: [],
+            summary: this.formatSummary('db-to-entity', safeDiff),
+            details: {
+                db: {
+                    created: 0,
+                    dropped: 0,
+                    altered: 0
+                },
+                entity: this.getDiffCounts(safeDiff)
+            }
+        };
+    }
+    /**
+   * Bidirectional sync with conflict detection.
+   */ async syncBidirectional() {
+        const entityAST = this.buildEntityAST();
+        const dbAST = await this.buildDatabaseAST();
+        const differ = new SchemaASTDiffer();
+        // Get both directions
+        const entityToDb = differ.diff(entityAST, dbAST);
+        const dbToEntity = differ.diff(dbAST, entityAST);
+        // Detect conflicts (changes in both directions for same elements)
+        const conflicts = this.detectConflicts(entityToDb, dbToEntity);
+        // Filter out conflicting changes
+        let safeEntityToDb = this.filterConflictingChanges(entityToDb, conflicts);
+        let safeDbToEntity = this.filterConflictingChanges(dbToEntity, conflicts);
+        // Apply safe mode if enabled
+        if (this.options.safe) {
+            safeEntityToDb = this.filterDestructiveChanges(safeEntityToDb);
+            safeDbToEntity = this.filterDestructiveChanges(safeDbToEntity);
+        }
+        return {
+            direction: 'bidirectional',
+            success: conflicts.length === 0,
+            dbChanges: safeEntityToDb,
+            entityChanges: safeDbToEntity,
+            conflicts,
+            summary: this.formatBidirectionalSummary(safeEntityToDb, safeDbToEntity, conflicts),
+            details: {
+                db: this.getDiffCounts(safeEntityToDb),
+                entity: this.getDiffCounts(safeDbToEntity)
+            }
+        };
+    }
+    /**
+   * Build SchemaAST from entities.
+   */ buildEntityAST() {
+        const builder = new SchemaASTBuilder();
+        return builder.fromEntities(this.options.entities);
+    }
+    /**
+   * Build SchemaAST from database.
+   */ async buildDatabaseAST() {
+        return this.options.introspector.introspect();
+    }
+    /**
+   * Filter destructive changes for safe mode.
+   */ filterDestructiveChanges(diff) {
+        return {
+            ...diff,
+            tablesToDrop: [],
+            columnDiffs: diff.columnDiffs.filter((d)=>d.type !== 'drop'),
+            indexDiffs: diff.indexDiffs.filter((d)=>d.type !== 'drop'),
+            relationshipDiffs: diff.relationshipDiffs.filter((d)=>d.type !== 'drop')
+        };
+    }
+    /**
+   * Detect conflicts between bidirectional changes.
+   */ detectConflicts(entityToDb, dbToEntity) {
+        const conflicts = [];
+        // Find column alterations that exist in both directions (type conflicts)
+        const entityColAlters = new Map(entityToDb.columnDiffs.filter((d)=>d.type === 'alter').map((d)=>[
+                `${d.table}.${d.column}`,
+                d
+            ]));
+        for (const dbColDiff of dbToEntity.columnDiffs.filter((d)=>d.type === 'alter')){
+            const key = `${dbColDiff.table}.${dbColDiff.column}`;
+            const entityColDiff = entityColAlters.get(key);
+            if (entityColDiff) {
+                // Both sides want to alter the same column - conflict
+                conflicts.push({
+                    type: 'type_mismatch',
+                    table: dbColDiff.table,
+                    column: dbColDiff.column,
+                    entityValue: entityColDiff.expected?.type,
+                    dbValue: dbColDiff.expected?.type,
+                    suggestion: `Column has different types. Entity: ${this.formatType(entityColDiff.expected?.type)}, DB: ${this.formatType(dbColDiff.expected?.type)}`
+                });
+            }
+        }
+        return conflicts;
+    }
+    /**
+   * Filter out conflicting changes.
+   */ filterConflictingChanges(diff, conflicts) {
+        const conflictKeys = new Set(conflicts.map((c)=>`${c.table}.${c.column ?? ''}`));
+        return {
+            ...diff,
+            columnDiffs: diff.columnDiffs.filter((d)=>!conflictKeys.has(`${d.table}.${d.column}`)),
+            tablesToAlter: diff.tablesToAlter.filter((t)=>!conflictKeys.has(`${t.name}.`))
+        };
+    }
+    /**
+   * Get counts of changes from a diff.
+   */ getDiffCounts(diff) {
+        return {
+            created: diff.tablesToCreate.length + diff.columnDiffs.filter((d)=>d.type === 'add').length,
+            dropped: diff.tablesToDrop.length + diff.columnDiffs.filter((d)=>d.type === 'drop').length,
+            altered: diff.columnDiffs.filter((d)=>d.type === 'alter').length
+        };
+    }
+    /**
+   * Format summary for single-direction sync.
+   */ formatSummary(direction, diff) {
+        const lines = [];
+        if (direction === 'entity-to-db') {
+            lines.push('Entity → Database Changes:');
+        } else {
+            lines.push('Database → Entity Changes:');
+        }
+        if (diff.tablesToCreate.length > 0) {
+            lines.push(`  + ${diff.tablesToCreate.length} table(s) to create`);
+        }
+        if (diff.tablesToDrop.length > 0) {
+            lines.push(`  - ${diff.tablesToDrop.length} table(s) to drop`);
+        }
+        if (diff.columnDiffs.length > 0) {
+            const adds = diff.columnDiffs.filter((d)=>d.type === 'add').length;
+            const drops = diff.columnDiffs.filter((d)=>d.type === 'drop').length;
+            const alters = diff.columnDiffs.filter((d)=>d.type === 'alter').length;
+            if (adds) lines.push(`  + ${adds} column(s) to add`);
+            if (drops) lines.push(`  - ${drops} column(s) to drop`);
+            if (alters) lines.push(`  ~ ${alters} column(s) to alter`);
+        }
+        if (diff.indexDiffs.length > 0) {
+            lines.push(`  ${diff.indexDiffs.length} index change(s)`);
+        }
+        if (!diff.hasDifferences) {
+            lines.push('  Schema is already in sync.');
+        }
+        return lines.join('\n');
+    }
+    /**
+   * Format summary for bidirectional sync.
+   */ formatBidirectionalSummary(entityToDb, dbToEntity, conflicts) {
+        const lines = [];
+        lines.push('Bidirectional Sync Report');
+        lines.push('========================\n');
+        if (conflicts.length > 0) {
+            lines.push(`⚠️  ${conflicts.length} conflict(s) require manual resolution:\n`);
+            for (const conflict of conflicts){
+                lines.push(`  • ${conflict.table}.${conflict.column ?? ''}: ${conflict.suggestion}`);
+            }
+            lines.push('');
+        }
+        if (entityToDb.hasDifferences) {
+            lines.push('Entity → Database:');
+            lines.push(this.formatSummary('entity-to-db', entityToDb).split('\n').slice(1).join('\n'));
+            lines.push('');
+        }
+        if (dbToEntity.hasDifferences) {
+            lines.push('Database → Entity:');
+            lines.push(this.formatSummary('db-to-entity', dbToEntity).split('\n').slice(1).join('\n'));
+        }
+        if (!entityToDb.hasDifferences && !dbToEntity.hasDifferences && conflicts.length === 0) {
+            lines.push('✓ Schema is in sync.');
+        }
+        return lines.join('\n');
+    }
+    /**
+   * Format type for display.
+   */ formatType(type) {
+        if (!type?.category) return 'unknown';
+        return type.length ? `${type.category}(${type.length})` : type.category;
+    }
+}
+/**
+ * Create a SchemaSync instance.
+ */ function createSchemaSync(options) {
+    return new SchemaSync(options);
+}
+
+export { AbstractSqlSchemaIntrospector, ColumnBuilder, DatabaseMigrationStorage, DriftDetector, EMPTY_MANUAL_MIGRATION_DOWN_INNER, EMPTY_MANUAL_MIGRATION_UP_INNER, EntityCodeGenerator, EntityMerger, JsonMigrationStorage, MariadbSchemaIntrospector, MigrationBuilder, MigrationCodeGenerator, Migrator, MongoSchemaIntrospector, MysqlSchemaIntrospector, OperationRecorder, PostgresSchemaIntrospector, SchemaSync, SmartRelationDetector, SqlExpression, SqlSchemaGenerator, SqliteSchemaIntrospector, TableBuilder, acquireQuerierForMigrations, assertCliConfig, buildSqlQuerierMigrationModule, createDriftDetector, createDryRunBuilder, createEntityCodeGenerator, createEntityMerger, createMigrationCodeGenerator, createRelationDetector, createSchemaGenerator, createSchemaGeneratorAsync, createSchemaSync, defineBuilderMigration, defineMigration, detectDrift, emitSqlRunCall, emitSqlRunCalls, formatDefaultValue, loadConfig, t };
+//# sourceMappingURL=uql-browser.min.js.map