uql-orm 0.7.3 → 0.7.4

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

@@ -5454,1647 +5454,3 @@ 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, createSpec, createTables, dropTables };
 //# sourceMappingURL=uql-browser.min.js.map
-ADE';
-            case 'SET NULL':
-                return 'SET NULL';
-            case 'RESTRICT':
-                return 'RESTRICT';
-            case 'NO ACTION':
-                return 'NO ACTION';
-            default:
-                return undefined;
-        }
-    }
-    /**
-   * Convert bigint/null values to number safely.
-   */ toNumber(value) {
-        if (value == null || value === '') {
-            return undefined;
-        }
-        return Number(value);
-    }
-}
-
-/**
- * MongoDB schema introspector.
- * MongoDB doesn't have a fixed schema, so this primarily focuses on collections and indexes.
- */ class MongoSchemaIntrospector {
-    constructor(pool){
-        this.pool = pool;
-    }
-    async introspect() {
-        const tableNames = await this.getTableNames();
-        const ast = new SchemaAST();
-        for (const name of tableNames){
-            const schema = await this.getTableSchema(name);
-            if (schema) {
-                const columns = new Map();
-                const table = {
-                    name,
-                    columns,
-                    primaryKey: [],
-                    indexes: [],
-                    schema: ast,
-                    incomingRelations: [],
-                    outgoingRelations: []
-                };
-                if (schema.indexes) {
-                    for (const idx of schema.indexes){
-                        const indexColumns = [];
-                        for (const colName of idx.columns){
-                            let column = columns.get(colName);
-                            if (!column) {
-                                column = {
-                                    name: colName,
-                                    type: {
-                                        category: 'string'
-                                    },
-                                    nullable: true,
-                                    isPrimaryKey: false,
-                                    isAutoIncrement: false,
-                                    isUnique: false,
-                                    table,
-                                    referencedBy: []
-                                };
-                                columns.set(colName, column);
-                            }
-                            indexColumns.push(column);
-                        }
-                        table.indexes.push({
-                            name: idx.name,
-                            table,
-                            columns: indexColumns,
-                            unique: idx.unique
-                        });
-                    }
-                }
-                ast.addTable(table);
-            }
-        }
-        return ast;
-    }
-    async getTableSchema(tableName) {
-        const querier = await this.pool.getQuerier();
-        try {
-            const { db } = querier;
-            const collections = await db.listCollections({
-                name: tableName
-            }).toArray();
-            if (collections.length === 0) {
-                return undefined;
-            }
-            // MongoDB doesn't have a fixed schema, but we can look at the indexes
-            const indexes = await db.collection(tableName).indexes();
-            return {
-                name: tableName,
-                columns: [],
-                indexes: indexes.map((idx)=>({
-                        name: idx.name ?? Object.keys(idx.key).join('_'),
-                        columns: Object.keys(idx.key),
-                        unique: !!idx.unique
-                    }))
-            };
-        } finally{
-            await querier.release();
-        }
-    }
-    async getTableNames() {
-        const querier = await this.pool.getQuerier();
-        try {
-            const { db } = querier;
-            const collections = await db.listCollections().toArray();
-            return collections.map((c)=>c.name);
-        } finally{
-            await querier.release();
-        }
-    }
-    async tableExists(tableName) {
-        const names = await this.getTableNames();
-        return names.includes(tableName);
-    }
-}
-
-/**
- * MySQL/MariaDB schema introspector.
- * Works with both MySQL and MariaDB as they share the same information_schema structure.
- */ class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
-    constructor(pool){
-        super('mysql');
-        this.pool = pool;
-    }
-    // ============================================================================
-    // SQL Queries (dialect-specific)
-    // ============================================================================
-    getTableNamesQuery() {
-        return /*sql*/ `
-      SELECT TABLE_NAME as table_name
-      FROM information_schema.TABLES
-      WHERE TABLE_SCHEMA = DATABASE()
-        AND TABLE_TYPE = 'BASE TABLE'
-      ORDER BY TABLE_NAME
-    `;
-    }
-    tableExistsQuery() {
-        return /*sql*/ `
-      SELECT COUNT(*) as count
-      FROM information_schema.TABLES
-      WHERE TABLE_SCHEMA = DATABASE()
-        AND TABLE_NAME = ?
-    `;
-    }
-    parseTableExistsResult(results) {
-        const row = results[0];
-        if (row?.count !== undefined) {
-            return (this.toNumber(row.count) ?? 0) > 0;
-        }
-        return false;
-    }
-    getColumnsQuery(_tableName) {
-        return /*sql*/ `
-      SELECT
-        COLUMN_NAME as column_name,
-        DATA_TYPE as data_type,
-        COLUMN_TYPE as column_type,
-        IS_NULLABLE as is_nullable,
-        COLUMN_DEFAULT as column_default,
-        CHARACTER_MAXIMUM_LENGTH as character_maximum_length,
-        NUMERIC_PRECISION as numeric_precision,
-        NUMERIC_SCALE as numeric_scale,
-        COLUMN_KEY as column_key,
-        EXTRA as extra,
-        COLUMN_COMMENT as column_comment
-      FROM information_schema.COLUMNS
-      WHERE TABLE_SCHEMA = DATABASE()
-        AND TABLE_NAME = ?
-      ORDER BY ORDINAL_POSITION
-    `;
-    }
-    getIndexesQuery(_tableName) {
-        return /*sql*/ `
-      SELECT
-        INDEX_NAME as index_name,
-        GROUP_CONCAT(COLUMN_NAME ORDER BY SEQ_IN_INDEX) as columns,
-        NOT NON_UNIQUE as is_unique
-      FROM information_schema.STATISTICS
-      WHERE TABLE_SCHEMA = DATABASE()
-        AND TABLE_NAME = ?
-        AND INDEX_NAME != 'PRIMARY'
-      GROUP BY INDEX_NAME, NON_UNIQUE
-      ORDER BY INDEX_NAME
-    `;
-    }
-    getForeignKeysQuery(_tableName) {
-        return /*sql*/ `
-      SELECT
-        kcu.CONSTRAINT_NAME as constraint_name,
-        GROUP_CONCAT(kcu.COLUMN_NAME ORDER BY kcu.ORDINAL_POSITION) as columns,
-        kcu.REFERENCED_TABLE_NAME as referenced_table,
-        GROUP_CONCAT(kcu.REFERENCED_COLUMN_NAME ORDER BY kcu.ORDINAL_POSITION) as referenced_columns,
-        rc.DELETE_RULE as delete_rule,
-        rc.UPDATE_RULE as update_rule
-      FROM information_schema.KEY_COLUMN_USAGE kcu
-      JOIN information_schema.REFERENTIAL_CONSTRAINTS rc
-        ON kcu.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
-        AND kcu.TABLE_SCHEMA = rc.CONSTRAINT_SCHEMA
-      WHERE kcu.TABLE_SCHEMA = DATABASE()
-        AND kcu.TABLE_NAME = ?
-        AND kcu.REFERENCED_TABLE_NAME IS NOT NULL
-      GROUP BY kcu.CONSTRAINT_NAME, kcu.REFERENCED_TABLE_NAME, rc.DELETE_RULE, rc.UPDATE_RULE
-      ORDER BY kcu.CONSTRAINT_NAME
-    `;
-    }
-    getPrimaryKeyQuery(_tableName) {
-        return /*sql*/ `
-      SELECT COLUMN_NAME as column_name
-      FROM information_schema.KEY_COLUMN_USAGE
-      WHERE TABLE_SCHEMA = DATABASE()
-        AND TABLE_NAME = ?
-        AND CONSTRAINT_NAME = 'PRIMARY'
-      ORDER BY ORDINAL_POSITION
-    `;
-    }
-    // ============================================================================
-    // Internal Types
-    // ============================================================================
-    mapTableNameRow(row) {
-        return row.table_name;
-    }
-    async mapColumnsResult(_querier, _tableName, results) {
-        return results.map((row)=>({
-                name: row.column_name,
-                type: (row.column_type || '').toUpperCase(),
-                nullable: row.is_nullable === 'YES',
-                defaultValue: this.parseDefaultValue(row.column_default),
-                isPrimaryKey: row.column_key === 'PRI',
-                isAutoIncrement: (row.extra || '').toLowerCase().includes('auto_increment'),
-                isUnique: row.column_key === 'UNI',
-                length: this.toNumber(row.character_maximum_length),
-                precision: this.toNumber(row.numeric_precision),
-                scale: this.toNumber(row.numeric_scale),
-                comment: row.column_comment || undefined
-            }));
-    }
-    async mapIndexesResult(_querier, _tableName, results) {
-        return results.map((row)=>({
-                name: row.index_name,
-                columns: (row.columns || '').split(','),
-                unique: Boolean(row.is_unique)
-            }));
-    }
-    async mapForeignKeysResult(_querier, _tableName, results) {
-        return results.map((row)=>({
-                name: row.constraint_name,
-                columns: (row.columns || '').split(','),
-                referencedTable: row.referenced_table,
-                referencedColumns: (row.referenced_columns || '').split(','),
-                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);
-    }
-    parseDefaultValue(defaultValue) {
-        if (defaultValue === null) {
-            return undefined;
-        }
-        const normalized = 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('postgres');
-        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('sqlite');
-        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 (/^-?\d+\.\d+$/.test(defaultValue)) {
-            return Number.parseFloat(defaultValue);
-        }
-        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
- */ // Dialect configuration
-/**
- * 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();
-}
-
-/**
- * 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 this.pool.getQuerier();
-        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 this.pool.getQuerier();
-        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(value);
-    }
-    get entities() {
-        return this._entities ?? getEntities();
-    }
-    constructor(pool, options = {}){
-        this.pool = pool;
-        this.dialect = options.dialect ?? pool.dialect ?? 'postgres';
-        this.storage = options.storage ?? new DatabaseMigrationStorage(pool, {
-            tableName: options.tableName
-        });
-        this.migrationsPath = options.migrationsPath ?? './migrations';
-        this._logger = new LoggerWrapper(options.logger, options.slowQuery);
-        this._entities = options.entities;
-        this.schemaIntrospector = this.createIntrospector();
-        this.schemaGenerator = options.schemaGenerator ?? this.createGenerator(options.namingStrategy);
-    }
-    /**
-   * Set the schema generator for DDL operations
-   */ setSchemaGenerator(generator) {
-        this.schemaGenerator = generator;
-    }
-    createIntrospector() {
-        switch(this.dialect){
-            case 'cockroachdb':
-            case 'postgres':
-                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) {
-        return createSchemaGenerator(this.dialect, namingStrategy);
-    }
-    /**
-   * Get the SQL dialect
-   */ getDialect() {
-        return this.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 this.pool.getQuerier();
-        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 = this.generateMigrationContent(name);
-        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) {
-        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 = 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 content = this.generateMigrationContentWithStatements(name, upStatements, downStatements.reverse());
-        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() {
-        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;
-    }
-    findEntityForTable(tableName) {
-        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() {
-        if (!this.schemaGenerator) {
-            throw new Error('Schema generator not set. Call setSchemaGenerator() first.');
-        }
-        const querier = await this.pool.getQuerier();
-        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 createSql = this.schemaGenerator.generateCreateTable(entity);
-                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 = {}) {
-        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 = 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 this.pool.getQuerier();
-        try {
-            if (this.dialect === '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.dialect !== '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, '');
-    }
-    /**
-   * Generate migration file content
-   */ generateMigrationContent(name) {
-        return /*ts*/ `import type { SqlQuerier } from 'uql-orm/migrate';
-
-/**
- * Migration: ${name}
- * Created: ${new Date().toISOString()}
- */
-export default {
-  async up(querier: SqlQuerier): Promise<void> {
-    // Add your migration logic here
-    // Example:
-    // await querier.run(\`
-    //   CREATE TABLE "users" (
-    //     "id" SERIAL PRIMARY KEY,
-    //     "name" VARCHAR(255) NOT NULL,
-    //     "email" VARCHAR(255) UNIQUE NOT NULL,
-    //     "createdAt" TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-    //   )
-    // \`);
-  },
-
-  async down(querier: SqlQuerier): Promise<void> {
-    // Add your rollback logic here
-    // Example:
-    // await querier.run(\`DROP TABLE IF EXISTS "users"\`);
-  },
-};
-`;
-    }
-    /**
-   * Generate migration file content with SQL statements
-   */ generateMigrationContentWithStatements(name, upStatements, downStatements) {
-        const upSql = upStatements.map((s)=>/*ts*/ `    await querier.run(\`${s}\`);`).join('\n');
-        const downSql = downStatements.map((s)=>/*ts*/ `    await querier.run(\`${s}\`);`).join('\n');
-        return /*ts*/ `import type { SqlQuerier } from 'uql-orm/migrate';
-
-/**
- * Migration: ${name}
- * Created: ${new Date().toISOString()}
- * Generated from entity definitions
- */
-export default {
-  async up(querier: SqlQuerier): Promise<void> {
-${upSql}
-  },
-
-  async down(querier: SqlQuerier): Promise<void> {
-${downSql}
-  },
-};
-`;
-    }
-}
-/**
- * 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, EntityCodeGenerator, EntityMerger, JsonMigrationStorage, MariadbSchemaIntrospector, MigrationBuilder, MigrationCodeGenerator, Migrator, MongoSchemaGenerator, MongoSchemaIntrospector, MysqlSchemaIntrospector, OperationRecorder, PostgresSchemaIntrospector, SchemaSync, SmartRelationDetector, SqlExpression, SqlSchemaGenerator, SqliteSchemaIntrospector, TableBuilder, createDriftDetector, createDryRunBuilder, createEntityCodeGenerator, createEntityMerger, createMigrationCodeGenerator, createRelationDetector, createSchemaGenerator, createSchemaSync, defineBuilderMigration, defineMigration, detectDrift, formatDefaultValue, loadConfig, t };
-//# sourceMappingURL=uql-browser.min.js.map