@uql/core 1.0.12 → 3.0.0

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

@@ -0,0 +1,2150 @@
+import { isSqlQuerier } from '../type/index.js';
+export { isSqlQuerier } from '../type/index.js';
+import { AbstractDialect } from '../dialect/index.js';
+import { getMeta, getEntities } from '../entity/index.js';
+import { escapeSqlId, getKeys } from '../util/index.js';
+import { readdir, readFile, mkdir, writeFile } from 'node:fs/promises';
+import { join, basename, extname, dirname } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+/**
+ * Abstract base class for SQL schema generation
+ */ class AbstractSchemaGenerator extends AbstractDialect {
+    constructor(namingStrategy, escapeIdChar = '`'){
+        super(namingStrategy), this.escapeIdChar = escapeIdChar;
+    }
+    /**
+   * Escape an identifier (table name, column name, etc.)
+   */ escapeId(identifier) {
+        return escapeSqlId(identifier, this.escapeIdChar);
+    }
+    generateCreateTable(entity, options = {}) {
+        const meta = getMeta(entity);
+        const tableName = this.resolveTableName(entity, meta);
+        const columns = this.generateColumnDefinitions(meta);
+        const constraints = this.generateTableConstraints(meta);
+        const ifNotExists = options.ifNotExists ? 'IF NOT EXISTS ' : '';
+        let sql = `CREATE TABLE ${ifNotExists}${this.escapeId(tableName)} (\n`;
+        sql += columns.map((col)=>`  ${col}`).join(',\n');
+        if (constraints.length > 0) {
+            sql += ',\n';
+            sql += constraints.map((c)=>`  ${c}`).join(',\n');
+        }
+        sql += '\n)';
+        sql += this.getTableOptions(meta);
+        sql += ';';
+        return sql;
+    }
+    generateDropTable(entity) {
+        const meta = getMeta(entity);
+        const tableName = this.resolveTableName(entity, meta);
+        return `DROP TABLE IF EXISTS ${this.escapeId(tableName)};`;
+    }
+    generateAlterTable(diff) {
+        const statements = [];
+        const tableName = this.escapeId(diff.tableName);
+        // Add new columns
+        if (diff.columnsToAdd?.length) {
+            for (const column of diff.columnsToAdd){
+                const colDef = this.generateColumnDefinitionFromSchema(column);
+                statements.push(`ALTER TABLE ${tableName} ADD COLUMN ${colDef};`);
+            }
+        }
+        // Alter existing columns
+        if (diff.columnsToAlter?.length) {
+            for (const { to } of diff.columnsToAlter){
+                const colDef = this.generateColumnDefinitionFromSchema(to);
+                const colStatements = this.generateAlterColumnStatements(diff.tableName, to, colDef);
+                statements.push(...colStatements);
+            }
+        }
+        // Drop columns
+        if (diff.columnsToDrop?.length) {
+            for (const columnName of diff.columnsToDrop){
+                statements.push(`ALTER TABLE ${tableName} DROP COLUMN ${this.escapeId(columnName)};`);
+            }
+        }
+        // Add indexes
+        if (diff.indexesToAdd?.length) {
+            for (const index of diff.indexesToAdd){
+                statements.push(this.generateCreateIndex(diff.tableName, index));
+            }
+        }
+        // Drop indexes
+        if (diff.indexesToDrop?.length) {
+            for (const indexName of diff.indexesToDrop){
+                statements.push(this.generateDropIndex(diff.tableName, indexName));
+            }
+        }
+        return statements;
+    }
+    generateAlterTableDown(diff) {
+        const statements = [];
+        const tableName = this.escapeId(diff.tableName);
+        // Rollback additions by dropping columns
+        if (diff.columnsToAdd?.length) {
+            for (const column of diff.columnsToAdd){
+                statements.push(`ALTER TABLE ${tableName} DROP COLUMN ${this.escapeId(column.name)};`);
+            }
+        }
+        return statements;
+    }
+    generateCreateIndex(tableName, index) {
+        const unique = index.unique ? 'UNIQUE ' : '';
+        const columns = index.columns.map((c)=>this.escapeId(c)).join(', ');
+        return `CREATE ${unique}INDEX ${this.escapeId(index.name)} ON ${this.escapeId(tableName)} (${columns});`;
+    }
+    generateDropIndex(tableName, indexName) {
+        return `DROP INDEX IF EXISTS ${this.escapeId(indexName)};`;
+    }
+    /**
+   * Generate column definitions from entity metadata
+   */ generateColumnDefinitions(meta) {
+        const columns = [];
+        const fieldKeys = getKeys(meta.fields);
+        for (const key of fieldKeys){
+            const field = meta.fields[key];
+            if (field?.virtual) continue; // Skip virtual fields
+            const colDef = this.generateColumnDefinition(key, field, meta);
+            columns.push(colDef);
+        }
+        return columns;
+    }
+    /**
+   * Generate a single column definition
+   */ generateColumnDefinition(fieldKey, field, meta) {
+        const columnName = this.escapeId(this.resolveColumnName(fieldKey, field));
+        const isId = field.isId === true;
+        const isPrimaryKey = isId && meta.id === fieldKey;
+        // Determine SQL type
+        let sqlType;
+        if (isPrimaryKey && field.autoIncrement !== false && !field.onInsert) {
+            // Auto-increment primary key
+            sqlType = this.serialPrimaryKeyType;
+        } else {
+            sqlType = this.getSqlType(field, field.type);
+        }
+        let definition = `${columnName} ${sqlType}`;
+        // PRIMARY KEY constraint (for non-serial types)
+        if (isPrimaryKey && !sqlType.includes('PRIMARY KEY')) {
+            definition += ' PRIMARY KEY';
+        }
+        // NULL/NOT NULL
+        if (!isPrimaryKey) {
+            const nullable = field.nullable ?? true;
+            if (!nullable) {
+                definition += ' NOT NULL';
+            }
+        }
+        // UNIQUE constraint
+        if (field.unique && !isPrimaryKey) {
+            definition += ' UNIQUE';
+        }
+        // DEFAULT value
+        if (field.defaultValue !== undefined) {
+            definition += ` DEFAULT ${this.formatDefaultValue(field.defaultValue)}`;
+        }
+        // COMMENT (if supported)
+        if (field.comment) {
+            definition += this.generateColumnComment(this.resolveTableName(meta.entity, meta), this.resolveColumnName(fieldKey, field), field.comment);
+        }
+        return definition;
+    }
+    /**
+   * Generate column definition from a ColumnSchema object
+   */ generateColumnDefinitionFromSchema(column) {
+        const columnName = this.escapeId(column.name);
+        let type = column.type;
+        if (column.length && !type.includes('(')) {
+            type = `${type}(${column.length})`;
+        } else if (column.precision !== undefined && !type.includes('(')) {
+            if (column.scale !== undefined) {
+                type = `${type}(${column.precision}, ${column.scale})`;
+            } else {
+                type = `${type}(${column.precision})`;
+            }
+        }
+        let definition = `${columnName} ${type}`;
+        if (column.isPrimaryKey) {
+            definition += ' PRIMARY KEY';
+        }
+        if (!column.nullable && !column.isPrimaryKey) {
+            definition += ' NOT NULL';
+        }
+        if (column.isUnique && !column.isPrimaryKey) {
+            definition += ' UNIQUE';
+        }
+        if (column.defaultValue !== undefined) {
+            definition += ` DEFAULT ${this.formatDefaultValue(column.defaultValue)}`;
+        }
+        return definition;
+    }
+    /**
+   * Generate table constraints (indexes, foreign keys, etc.)
+   */ generateTableConstraints(meta) {
+        const constraints = [];
+        const fieldKeys = getKeys(meta.fields);
+        const tableName = this.resolveTableName(meta.entity, meta);
+        // Generate indexes from field options
+        for (const key of fieldKeys){
+            const field = meta.fields[key];
+            if (field?.index) {
+                const columnName = this.resolveColumnName(key, field);
+                const indexName = typeof field.index === 'string' ? field.index : `idx_${tableName}_${columnName}`;
+                constraints.push(`INDEX ${this.escapeId(indexName)} (${this.escapeId(columnName)})`);
+            }
+        }
+        // Generate foreign key constraints from references
+        for (const key of fieldKeys){
+            const field = meta.fields[key];
+            if (field?.reference) {
+                const refEntity = field.reference();
+                const refMeta = getMeta(refEntity);
+                const refIdField = refMeta.fields[refMeta.id];
+                const columnName = this.resolveColumnName(key, field);
+                const refTableName = this.resolveTableName(refEntity, refMeta);
+                const refColumnName = this.resolveColumnName(refMeta.id, refIdField);
+                const fkName = `fk_${tableName}_${columnName}`;
+                constraints.push(`CONSTRAINT ${this.escapeId(fkName)} FOREIGN KEY (${this.escapeId(columnName)}) ` + `REFERENCES ${this.escapeId(refTableName)} (${this.escapeId(refColumnName)})`);
+            }
+        }
+        return constraints;
+    }
+    getSqlType(field, fieldType) {
+        // Use explicit column type if specified
+        if (field.columnType) {
+            return this.mapColumnType(field.columnType, field);
+        }
+        // Handle special types
+        if (field.type === 'json' || field.type === 'jsonb') {
+            return this.mapColumnType(field.type, field);
+        }
+        if (field.type === 'vector') {
+            return this.mapColumnType('vector', field);
+        }
+        // Infer from TypeScript type
+        const type = fieldType ?? field.type;
+        if (type === Number || type === 'number') {
+            return field.precision ? this.mapColumnType('decimal', field) : 'BIGINT';
+        }
+        if (type === String || type === 'string') {
+            const length = field.length ?? 255;
+            return `VARCHAR(${length})`;
+        }
+        if (type === Boolean || type === 'boolean') {
+            return this.getBooleanType();
+        }
+        if (type === Date || type === 'date') {
+            return 'TIMESTAMP';
+        }
+        if (type === BigInt || type === 'bigint') {
+            return 'BIGINT';
+        }
+        // Default to VARCHAR
+        return `VARCHAR(${field.length ?? 255})`;
+    }
+    /**
+   * Get table options (e.g., ENGINE for MySQL)
+   */ getTableOptions(meta) {
+        return '';
+    }
+    /**
+   * Format a default value for SQL
+   */ formatDefaultValue(value) {
+        if (value === null) {
+            return 'NULL';
+        }
+        if (typeof value === 'string') {
+            return `'${value.replace(/'/g, "''")}'`;
+        }
+        if (typeof value === 'boolean') {
+            return value ? 'TRUE' : 'FALSE';
+        }
+        if (typeof value === 'number' || typeof value === 'bigint') {
+            return String(value);
+        }
+        if (value instanceof Date) {
+            return `'${value.toISOString()}'`;
+        }
+        return String(value);
+    }
+    /**
+   * Compare two schemas and return the differences
+   */ diffSchema(entity, currentSchema) {
+        const meta = getMeta(entity);
+        if (!currentSchema) {
+            // Table doesn't exist, need to create
+            return {
+                tableName: this.resolveTableName(entity, meta),
+                type: 'create'
+            };
+        }
+        const columnsToAdd = [];
+        const columnsToAlter = [];
+        const columnsToDrop = [];
+        const currentColumns = new Map(currentSchema.columns.map((c)=>[
+                c.name,
+                c
+            ]));
+        const fieldKeys = getKeys(meta.fields);
+        // Check for new or altered columns
+        for (const key of fieldKeys){
+            const field = meta.fields[key];
+            if (field?.virtual) continue;
+            const columnName = this.resolveColumnName(key, field);
+            const currentColumn = currentColumns.get(columnName);
+            if (!currentColumn) {
+                // Column needs to be added
+                columnsToAdd.push(this.fieldToColumnSchema(key, field, meta));
+            } else {
+                // Check if column needs alteration
+                const desiredColumn = this.fieldToColumnSchema(key, field, meta);
+                if (this.columnsNeedAlteration(currentColumn, desiredColumn)) {
+                    columnsToAlter.push({
+                        from: currentColumn,
+                        to: desiredColumn
+                    });
+                }
+            }
+            currentColumns.delete(columnName);
+        }
+        // Remaining columns in currentColumns should be dropped
+        for (const [name] of currentColumns){
+            columnsToDrop.push(name);
+        }
+        if (columnsToAdd.length === 0 && columnsToAlter.length === 0 && columnsToDrop.length === 0) {
+            return undefined; // No changes needed
+        }
+        return {
+            tableName: this.resolveTableName(entity, meta),
+            type: 'alter',
+            columnsToAdd: columnsToAdd.length > 0 ? columnsToAdd : undefined,
+            columnsToAlter: columnsToAlter.length > 0 ? columnsToAlter : undefined,
+            columnsToDrop: columnsToDrop.length > 0 ? columnsToDrop : undefined
+        };
+    }
+    /**
+   * Convert field options to ColumnSchema
+   */ fieldToColumnSchema(fieldKey, field, meta) {
+        const isId = field.isId === true;
+        const isPrimaryKey = isId && meta.id === fieldKey;
+        return {
+            name: this.resolveColumnName(fieldKey, field),
+            type: this.getSqlType(field, field.type),
+            nullable: field.nullable ?? !isPrimaryKey,
+            defaultValue: field.defaultValue,
+            isPrimaryKey,
+            isAutoIncrement: isPrimaryKey && field.autoIncrement !== false && !field.onInsert,
+            isUnique: field.unique ?? false,
+            length: field.length,
+            precision: field.precision,
+            scale: field.scale,
+            comment: field.comment
+        };
+    }
+    /**
+   * Check if two columns differ enough to require alteration
+   */ columnsNeedAlteration(current, desired) {
+        // Compare relevant properties
+        return current.type.toLowerCase() !== desired.type.toLowerCase() || current.nullable !== desired.nullable || current.isUnique !== desired.isUnique || JSON.stringify(current.defaultValue) !== JSON.stringify(desired.defaultValue);
+    }
+}
+
+/**
+ * MySQL/MariaDB-specific schema generator
+ */ class MysqlSchemaGenerator extends AbstractSchemaGenerator {
+    mapColumnType(columnType, field) {
+        switch(columnType){
+            case 'int':
+                return 'INT';
+            case 'smallint':
+                return 'SMALLINT';
+            case 'bigint':
+                return 'BIGINT';
+            case 'float':
+                return 'FLOAT';
+            case 'double':
+            case 'real':
+                return 'DOUBLE';
+            case 'decimal':
+            case 'numeric':
+                if (field.precision !== undefined) {
+                    if (field.scale !== undefined) {
+                        return `DECIMAL(${field.precision}, ${field.scale})`;
+                    }
+                    return `DECIMAL(${field.precision})`;
+                }
+                return 'DECIMAL(10, 2)';
+            case 'boolean':
+                return 'TINYINT(1)';
+            case 'char':
+                return `CHAR(${field.length ?? 1})`;
+            case 'varchar':
+                return `VARCHAR(${field.length ?? 255})`;
+            case 'text':
+                return 'TEXT';
+            case 'uuid':
+                return 'CHAR(36)';
+            case 'date':
+                return 'DATE';
+            case 'time':
+                return 'TIME';
+            case 'timestamp':
+            case 'timestamptz':
+                return 'TIMESTAMP';
+            case 'json':
+            case 'jsonb':
+                return 'JSON';
+            case 'blob':
+            case 'bytea':
+                return 'BLOB';
+            case 'vector':
+                // MySQL doesn't have native vector support, use JSON
+                return 'JSON';
+            case 'serial':
+                return 'INT AUTO_INCREMENT';
+            case 'bigserial':
+                return 'BIGINT AUTO_INCREMENT';
+            default:
+                return 'TEXT';
+        }
+    }
+    getBooleanType() {
+        return 'TINYINT(1)';
+    }
+    generateAlterColumnStatements(tableName, column, newDefinition) {
+        return [
+            `ALTER TABLE ${this.escapeId(tableName)} MODIFY COLUMN ${newDefinition};`
+        ];
+    }
+    generateColumnComment(tableName, columnName, comment) {
+        const escapedComment = comment.replace(/'/g, "''");
+        return ` COMMENT '${escapedComment}'`;
+    }
+    getTableOptions() {
+        return ' ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci';
+    }
+    generateDropIndex(tableName, indexName) {
+        // MySQL requires table name in DROP INDEX
+        return `DROP INDEX ${this.escapeId(indexName)} ON ${this.escapeId(tableName)};`;
+    }
+    constructor(...args){
+        super(...args), this.serialPrimaryKeyType = 'INT AUTO_INCREMENT PRIMARY KEY';
+    }
+}
+
+/**
+ * PostgreSQL-specific schema generator
+ */ class PostgresSchemaGenerator extends AbstractSchemaGenerator {
+    constructor(namingStrategy){
+        super(namingStrategy, '"'), this.serialPrimaryKeyType = 'SERIAL PRIMARY KEY';
+    }
+    mapColumnType(columnType, field) {
+        switch(columnType){
+            case 'int':
+                return 'INTEGER';
+            case 'smallint':
+                return 'SMALLINT';
+            case 'bigint':
+                return 'BIGINT';
+            case 'float':
+            case 'double':
+            case 'real':
+                return 'DOUBLE PRECISION';
+            case 'decimal':
+            case 'numeric':
+                if (field.precision !== undefined) {
+                    if (field.scale !== undefined) {
+                        return `NUMERIC(${field.precision}, ${field.scale})`;
+                    }
+                    return `NUMERIC(${field.precision})`;
+                }
+                return 'NUMERIC';
+            case 'boolean':
+                return 'BOOLEAN';
+            case 'char':
+                return `CHAR(${field.length ?? 1})`;
+            case 'varchar':
+                return `VARCHAR(${field.length ?? 255})`;
+            case 'text':
+                return 'TEXT';
+            case 'uuid':
+                return 'UUID';
+            case 'date':
+                return 'DATE';
+            case 'time':
+                return 'TIME';
+            case 'timestamp':
+                return 'TIMESTAMP';
+            case 'timestamptz':
+                return 'TIMESTAMPTZ';
+            case 'json':
+                return 'JSON';
+            case 'jsonb':
+                return 'JSONB';
+            case 'blob':
+            case 'bytea':
+                return 'BYTEA';
+            case 'vector':
+                if (field.length) {
+                    return `VECTOR(${field.length})`;
+                }
+                return 'VECTOR';
+            case 'serial':
+                return 'SERIAL';
+            case 'bigserial':
+                return 'BIGSERIAL';
+            default:
+                return 'TEXT';
+        }
+    }
+    getBooleanType() {
+        return 'BOOLEAN';
+    }
+    generateAlterColumnStatements(tableName, column, newDefinition) {
+        const statements = [];
+        const escapedTableName = this.escapeId(tableName);
+        const escapedColumnName = this.escapeId(column.name);
+        // PostgreSQL uses separate ALTER COLUMN clauses for different changes
+        // 1. Change type
+        statements.push(`ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} TYPE ${column.type};`);
+        // 2. Change nullability
+        if (column.nullable) {
+            statements.push(`ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} DROP NOT NULL;`);
+        } else {
+            statements.push(`ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} SET NOT NULL;`);
+        }
+        // 3. Change default value
+        if (column.defaultValue !== undefined) {
+            statements.push(`ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} SET DEFAULT ${this.formatDefaultValue(column.defaultValue)};`);
+        } else {
+            statements.push(`ALTER TABLE ${escapedTableName} ALTER COLUMN ${escapedColumnName} DROP DEFAULT;`);
+        }
+        return statements;
+    }
+    generateColumnComment(tableName, columnName, comment) {
+        // PostgreSQL handles comments separately via COMMENT ON COLUMN
+        return '';
+    }
+    /**
+   * Generate COMMENT ON COLUMN statement for PostgreSQL
+   */ generateColumnCommentStatement(tableName, columnName, comment) {
+        const escapedComment = comment.replace(/'/g, "''");
+        return `COMMENT ON COLUMN ${this.escapeId(tableName)}.${this.escapeId(columnName)} IS '${escapedComment}';`;
+    }
+    generateDropIndex(tableName, indexName) {
+        // PostgreSQL doesn't require table name in DROP INDEX
+        return `DROP INDEX IF EXISTS ${this.escapeId(indexName)};`;
+    }
+}
+
+/**
+ * SQLite-specific schema generator
+ */ class SqliteSchemaGenerator extends AbstractSchemaGenerator {
+    mapColumnType(columnType, field) {
+        // SQLite has dynamic typing, but we use type affinity
+        switch(columnType){
+            case 'int':
+            case 'smallint':
+            case 'bigint':
+            case 'serial':
+            case 'bigserial':
+                return 'INTEGER';
+            case 'float':
+            case 'double':
+            case 'real':
+            case 'decimal':
+            case 'numeric':
+                return 'REAL';
+            case 'boolean':
+                return 'INTEGER'; // SQLite uses 0/1 for booleans
+            case 'char':
+            case 'varchar':
+            case 'text':
+            case 'uuid':
+                return 'TEXT';
+            case 'date':
+            case 'time':
+            case 'timestamp':
+            case 'timestamptz':
+                return 'TEXT'; // SQLite stores dates as TEXT or INTEGER
+            case 'json':
+            case 'jsonb':
+                return 'TEXT'; // SQLite stores JSON as TEXT
+            case 'blob':
+            case 'bytea':
+                return 'BLOB';
+            case 'vector':
+                return 'TEXT'; // Store as JSON array
+            default:
+                return 'TEXT';
+        }
+    }
+    getBooleanType() {
+        return 'INTEGER';
+    }
+    generateAlterColumnStatements(tableName, column, newDefinition) {
+        // SQLite has very limited ALTER TABLE support
+        // Column type changes require recreating the table
+        throw new Error(`SQLite does not support altering column '${column.name}' in table '${tableName}'. ` + 'You need to recreate the table to change column types.');
+    }
+    generateColumnComment(tableName, columnName, comment) {
+        return '';
+    }
+    generateDropIndex(tableName, indexName) {
+        return `DROP INDEX IF EXISTS ${this.escapeId(indexName)};`;
+    }
+    formatDefaultValue(value) {
+        if (typeof value === 'boolean') {
+            return value ? '1' : '0';
+        }
+        return super.formatDefaultValue(value);
+    }
+    constructor(...args){
+        super(...args), this.serialPrimaryKeyType = 'INTEGER PRIMARY KEY AUTOINCREMENT';
+    }
+}
+
+/**
+ * MySQL/MariaDB schema introspector.
+ * Works with both MySQL and MariaDB as they share the same information_schema structure.
+ */ class MysqlSchemaIntrospector {
+    constructor(querierPool){
+        this.querierPool = querierPool;
+    }
+    async getTableSchema(tableName) {
+        const querier = await this.getQuerier();
+        try {
+            const exists = await this.tableExistsInternal(querier, tableName);
+            if (!exists) {
+                return undefined;
+            }
+            const [columns, indexes, foreignKeys, primaryKey] = await Promise.all([
+                this.getColumns(querier, tableName),
+                this.getIndexes(querier, tableName),
+                this.getForeignKeys(querier, tableName),
+                this.getPrimaryKey(querier, tableName)
+            ]);
+            return {
+                name: tableName,
+                columns,
+                primaryKey,
+                indexes,
+                foreignKeys
+            };
+        } finally{
+            await querier.release();
+        }
+    }
+    async getTableNames() {
+        const querier = await this.getQuerier();
+        try {
+            const sql = `
+        SELECT TABLE_NAME as table_name
+        FROM information_schema.TABLES
+        WHERE TABLE_SCHEMA = DATABASE()
+          AND TABLE_TYPE = 'BASE TABLE'
+        ORDER BY TABLE_NAME
+      `;
+            const results = await querier.all(sql);
+            return results.map((r)=>r.table_name);
+        } finally{
+            await querier.release();
+        }
+    }
+    async tableExists(tableName) {
+        const querier = await this.getQuerier();
+        try {
+            return this.tableExistsInternal(querier, tableName);
+        } finally{
+            await querier.release();
+        }
+    }
+    async tableExistsInternal(querier, tableName) {
+        const sql = `
+      SELECT COUNT(*) as count
+      FROM information_schema.TABLES
+      WHERE TABLE_SCHEMA = DATABASE()
+        AND TABLE_NAME = ?
+    `;
+        const results = await querier.all(sql, [
+            tableName
+        ]);
+        return (results[0]?.count ?? 0) > 0;
+    }
+    async getQuerier() {
+        const querier = await this.querierPool.getQuerier();
+        if (!isSqlQuerier(querier)) {
+            await querier.release();
+            throw new Error('MysqlSchemaIntrospector requires a SQL-based querier');
+        }
+        return querier;
+    }
+    async getColumns(querier, tableName) {
+        const 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
+    `;
+        const results = await querier.all(sql, [
+            tableName
+        ]);
+        return results.map((row)=>({
+                name: row.column_name,
+                type: row.data_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: row.character_maximum_length ?? undefined,
+                precision: row.numeric_precision ?? undefined,
+                scale: row.numeric_scale ?? undefined,
+                comment: row.column_comment || undefined
+            }));
+    }
+    async getIndexes(querier, tableName) {
+        const 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
+    `;
+        const results = await querier.all(sql, [
+            tableName
+        ]);
+        return results.map((row)=>({
+                name: row.index_name,
+                columns: row.columns.split(','),
+                unique: Boolean(row.is_unique)
+            }));
+    }
+    async getForeignKeys(querier, tableName) {
+        const 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
+    `;
+        const results = await querier.all(sql, [
+            tableName
+        ]);
+        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)
+            }));
+    }
+    async getPrimaryKey(querier, tableName) {
+        const 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
+    `;
+        const results = await querier.all(sql, [
+            tableName
+        ]);
+        if (results.length === 0) {
+            return undefined;
+        }
+        return results.map((r)=>r.column_name);
+    }
+    parseDefaultValue(defaultValue) {
+        if (defaultValue === null) {
+            return undefined;
+        }
+        // Check for common patterns
+        if (defaultValue === 'NULL') {
+            return null;
+        }
+        if (defaultValue === 'CURRENT_TIMESTAMP') {
+            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;
+    }
+    normalizeReferentialAction(action) {
+        switch(action.toUpperCase()){
+            case 'CASCADE':
+                return 'CASCADE';
+            case 'SET NULL':
+                return 'SET NULL';
+            case 'RESTRICT':
+                return 'RESTRICT';
+            case 'NO ACTION':
+                return 'NO ACTION';
+            default:
+                return undefined;
+        }
+    }
+}
+/**
+ * Alias for MysqlSchemaIntrospector.
+ * MariaDB uses the same information_schema structure as MySQL.
+ */ const MariadbSchemaIntrospector = MysqlSchemaIntrospector;
+
+/**
+ * PostgreSQL schema introspector
+ */ class PostgresSchemaIntrospector {
+    constructor(querierPool){
+        this.querierPool = querierPool;
+    }
+    async getTableSchema(tableName) {
+        const querier = await this.getQuerier();
+        try {
+            const exists = await this.tableExistsInternal(querier, tableName);
+            if (!exists) {
+                return undefined;
+            }
+            const [columns, indexes, foreignKeys, primaryKey] = await Promise.all([
+                this.getColumns(querier, tableName),
+                this.getIndexes(querier, tableName),
+                this.getForeignKeys(querier, tableName),
+                this.getPrimaryKey(querier, tableName)
+            ]);
+            return {
+                name: tableName,
+                columns,
+                primaryKey,
+                indexes,
+                foreignKeys
+            };
+        } finally{
+            await querier.release();
+        }
+    }
+    async getTableNames() {
+        const querier = await this.getQuerier();
+        try {
+            const sql = `
+        SELECT table_name
+        FROM information_schema.tables
+        WHERE table_schema = 'public'
+          AND table_type = 'BASE TABLE'
+        ORDER BY table_name
+      `;
+            const results = await querier.all(sql);
+            return results.map((r)=>r.table_name);
+        } finally{
+            await querier.release();
+        }
+    }
+    async tableExists(tableName) {
+        const querier = await this.getQuerier();
+        try {
+            return this.tableExistsInternal(querier, tableName);
+        } finally{
+            await querier.release();
+        }
+    }
+    async tableExistsInternal(querier, tableName) {
+        const sql = `
+      SELECT EXISTS (
+        SELECT FROM information_schema.tables
+        WHERE table_schema = 'public'
+          AND table_name = $1
+      ) AS exists
+    `;
+        const results = await querier.all(sql, [
+            tableName
+        ]);
+        return results[0]?.exists ?? false;
+    }
+    async getQuerier() {
+        const querier = await this.querierPool.getQuerier();
+        if (!isSqlQuerier(querier)) {
+            await querier.release();
+            throw new Error('PostgresSchemaIntrospector requires a SQL-based querier');
+        }
+        return querier;
+    }
+    async getColumns(querier, tableName) {
+        const sql = /*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,
+        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
+    `;
+        const results = await querier.all(sql, [
+            tableName
+        ]);
+        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),
+                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 getIndexes(querier, tableName) {
+        const sql = /*sql*/ `
+      SELECT
+        i.relname AS index_name,
+        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
+    `;
+        const results = await querier.all(sql, [
+            tableName
+        ]);
+        return results.map((row)=>({
+                name: row.index_name,
+                columns: row.columns,
+                unique: row.is_unique
+            }));
+    }
+    async getForeignKeys(querier, tableName) {
+        const sql = /*sql*/ `
+      SELECT
+        tc.constraint_name,
+        array_agg(kcu.column_name ORDER BY kcu.ordinal_position) AS columns,
+        ccu.table_name AS referenced_table,
+        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
+    `;
+        const results = await querier.all(sql, [
+            tableName
+        ]);
+        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)
+            }));
+    }
+    async getPrimaryKey(querier, tableName) {
+        const sql = /*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
+    `;
+        const results = await querier.all(sql, [
+            tableName
+        ]);
+        if (results.length === 0) {
+            return undefined;
+        }
+        return results.map((r)=>r.column_name);
+    }
+    normalizeType(dataType, udtName) {
+        // Handle user-defined types and arrays
+        if (dataType === 'USER-DEFINED') {
+            return udtName.toUpperCase();
+        }
+        if (dataType === 'ARRAY') {
+            return `${udtName.replace(/^_/, '')}[]`;
+        }
+        return dataType.toUpperCase();
+    }
+    parseDefaultValue(defaultValue) {
+        if (!defaultValue) {
+            return undefined;
+        }
+        // Remove type casting
+        const cleaned = defaultValue.replace(/::[a-z_]+(\[\])?/gi, '').trim();
+        // Check for common patterns
+        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 as-is for functions like CURRENT_TIMESTAMP, nextval(), etc.
+        return defaultValue;
+    }
+    isAutoIncrement(defaultValue) {
+        if (!defaultValue) {
+            return false;
+        }
+        return defaultValue.includes('nextval(');
+    }
+    normalizeReferentialAction(action) {
+        switch(action.toUpperCase()){
+            case 'CASCADE':
+                return 'CASCADE';
+            case 'SET NULL':
+                return 'SET NULL';
+            case 'RESTRICT':
+                return 'RESTRICT';
+            case 'NO ACTION':
+                return 'NO ACTION';
+            default:
+                return undefined;
+        }
+    }
+}
+
+/**
+ * SQLite schema introspector
+ */ class SqliteSchemaIntrospector {
+    constructor(querierPool){
+        this.querierPool = querierPool;
+    }
+    async getTableSchema(tableName) {
+        const querier = await this.getQuerier();
+        try {
+            const exists = await this.tableExistsInternal(querier, tableName);
+            if (!exists) {
+                return undefined;
+            }
+            const [columns, indexes, foreignKeys, primaryKey] = await Promise.all([
+                this.getColumns(querier, tableName),
+                this.getIndexes(querier, tableName),
+                this.getForeignKeys(querier, tableName),
+                this.getPrimaryKey(querier, tableName)
+            ]);
+            return {
+                name: tableName,
+                columns,
+                primaryKey,
+                indexes,
+                foreignKeys
+            };
+        } finally{
+            await querier.release();
+        }
+    }
+    async getTableNames() {
+        const querier = await this.getQuerier();
+        try {
+            const sql = /*sql*/ `
+        SELECT name
+        FROM sqlite_master
+        WHERE type = 'table'
+          AND name NOT LIKE 'sqlite_%'
+        ORDER BY name
+      `;
+            const results = await querier.all(sql);
+            return results.map((r)=>r.name);
+        } finally{
+            await querier.release();
+        }
+    }
+    async tableExists(tableName) {
+        const querier = await this.getQuerier();
+        try {
+            return this.tableExistsInternal(querier, tableName);
+        } finally{
+            await querier.release();
+        }
+    }
+    async tableExistsInternal(querier, tableName) {
+        const sql = /*sql*/ `
+      SELECT COUNT(*) as count
+      FROM sqlite_master
+      WHERE type = 'table'
+        AND name = ?
+    `;
+        const results = await querier.all(sql, [
+            tableName
+        ]);
+        return (results[0]?.count ?? 0) > 0;
+    }
+    async getQuerier() {
+        const querier = await this.querierPool.getQuerier();
+        if (!isSqlQuerier(querier)) {
+            await querier.release();
+            throw new Error('SqliteSchemaIntrospector requires a SQL-based querier');
+        }
+        return querier;
+    }
+    async getColumns(querier, tableName) {
+        // SQLite uses PRAGMA for table info
+        const sql = `PRAGMA table_info(${this.escapeId(tableName)})`;
+        const results = await querier.all(sql);
+        // 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 getUniqueColumns(querier, tableName) {
+        const sql = `PRAGMA index_list(${this.escapeId(tableName)})`;
+        const indexes = await querier.all(sql);
+        const uniqueColumns = new Set();
+        for (const index of indexes){
+            if (index.unique && index.origin === 'u') {
+                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;
+    }
+    async getIndexes(querier, tableName) {
+        const sql = `PRAGMA index_list(${this.escapeId(tableName)})`;
+        const indexes = await querier.all(sql);
+        const result = [];
+        for (const index of indexes){
+            // Skip auto-generated indexes (primary key, unique constraints)
+            if (index.origin !== 'c') {
+                continue;
+            }
+            const columns = await querier.all(`PRAGMA index_info(${this.escapeId(index.name)})`);
+            result.push({
+                name: index.name,
+                columns: columns.map((c)=>c.name),
+                unique: Boolean(index.unique)
+            });
+        }
+        return result;
+    }
+    async getForeignKeys(querier, tableName) {
+        const sql = `PRAGMA foreign_key_list(${this.escapeId(tableName)})`;
+        const results = await querier.all(sql);
+        // Group by id to handle composite foreign keys
+        const grouped = new Map();
+        for (const row of results){
+            const existing = grouped.get(row.id) ?? [];
+            existing.push(row);
+            grouped.set(row.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)
+            };
+        });
+    }
+    async getPrimaryKey(querier, tableName) {
+        const sql = `PRAGMA table_info(${this.escapeId(tableName)})`;
+        const results = await querier.all(sql);
+        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);
+    }
+    escapeId(identifier) {
+        return `\`${identifier.replace(/`/g, '``')}\``;
+    }
+    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;
+        }
+        // Check for common patterns
+        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;
+    }
+    normalizeReferentialAction(action) {
+        switch(action.toUpperCase()){
+            case 'CASCADE':
+                return 'CASCADE';
+            case 'SET NULL':
+                return 'SET NULL';
+            case 'RESTRICT':
+                return 'RESTRICT';
+            case 'NO ACTION':
+                return 'NO ACTION';
+            default:
+                return undefined;
+        }
+    }
+}
+
+class MongoSchemaGenerator extends AbstractDialect {
+    generateCreateTable(entity) {
+        const meta = getMeta(entity);
+        const collectionName = this.resolveTableName(entity, meta);
+        const indexes = [];
+        for(const key in meta.fields){
+            const field = meta.fields[key];
+            if (field.index) {
+                const columnName = this.resolveColumnName(key, field);
+                const indexName = typeof field.index === 'string' ? field.index : `idx_${collectionName}_${columnName}`;
+                indexes.push({
+                    name: indexName,
+                    columns: [
+                        columnName
+                    ],
+                    unique: !!field.unique
+                });
+            }
+        }
+        return JSON.stringify({
+            action: 'createCollection',
+            name: collectionName,
+            indexes
+        });
+    }
+    generateDropTable(entity) {
+        const meta = getMeta(entity);
+        const collectionName = this.resolveTableName(entity, meta);
+        return JSON.stringify({
+            action: 'dropCollection',
+            name: collectionName
+        });
+    }
+    generateAlterTable(diff) {
+        const statements = [];
+        if (diff.indexesToAdd?.length) {
+            for (const index of diff.indexesToAdd){
+                statements.push(this.generateCreateIndex(diff.tableName, index));
+            }
+        }
+        return statements;
+    }
+    generateAlterTableDown(diff) {
+        const statements = [];
+        if (diff.indexesToAdd?.length) {
+            for (const index of diff.indexesToAdd){
+                statements.push(this.generateDropIndex(diff.tableName, index.name));
+            }
+        }
+        return statements;
+    }
+    generateCreateIndex(tableName, index) {
+        const key = {};
+        for (const col of index.columns){
+            key[col] = 1;
+        }
+        return JSON.stringify({
+            action: 'createIndex',
+            collection: tableName,
+            name: index.name,
+            key,
+            options: {
+                unique: index.unique,
+                name: index.name
+            }
+        });
+    }
+    generateDropIndex(tableName, indexName) {
+        return JSON.stringify({
+            action: 'dropIndex',
+            collection: tableName,
+            name: indexName
+        });
+    }
+    getSqlType() {
+        return '';
+    }
+    diffSchema(entity, currentSchema) {
+        const meta = getMeta(entity);
+        const collectionName = this.resolveTableName(entity, meta);
+        if (!currentSchema) {
+            return {
+                tableName: collectionName,
+                type: 'create'
+            };
+        }
+        const indexesToAdd = [];
+        const existingIndexes = new Set(currentSchema.indexes?.map((i)=>i.name) ?? []);
+        for(const key in meta.fields){
+            const field = meta.fields[key];
+            if (field.index) {
+                const columnName = this.resolveColumnName(key, field);
+                const indexName = typeof field.index === 'string' ? field.index : `idx_${collectionName}_${columnName}`;
+                if (!existingIndexes.has(indexName)) {
+                    indexesToAdd.push({
+                        name: indexName,
+                        columns: [
+                            columnName
+                        ],
+                        unique: !!field.unique
+                    });
+                }
+            }
+        }
+        if (indexesToAdd.length === 0) {
+            return undefined;
+        }
+        return {
+            tableName: collectionName,
+            type: 'alter',
+            indexesToAdd
+        };
+    }
+}
+
+class MongoSchemaIntrospector {
+    constructor(querierPool){
+        this.querierPool = querierPool;
+    }
+    async getTableSchema(tableName) {
+        const querier = await this.querierPool.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,
+                        columns: Object.keys(idx.key),
+                        unique: !!idx.unique
+                    }))
+            };
+        } finally{
+            await querier.release();
+        }
+    }
+    async getTableNames() {
+        const querier = await this.querierPool.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);
+    }
+}
+
+/**
+ * Stores migration state in a database table.
+ * Uses the querier's dialect for escaping and placeholders.
+ */ class DatabaseMigrationStorage {
+    constructor(querierPool, options = {}){
+        this.querierPool = querierPool;
+        this.storageInitialized = false;
+        this.tableName = options.tableName ?? 'uql_migrations';
+    }
+    async ensureStorage() {
+        if (this.storageInitialized) {
+            return;
+        }
+        const querier = await this.querierPool.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 { escapeId } = querier.dialect;
+        const sql = `
+      CREATE TABLE IF NOT EXISTS ${escapeId(this.tableName)} (
+        ${escapeId('name')} VARCHAR(255) PRIMARY KEY,
+        ${escapeId('executed_at')} TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+        await querier.run(sql);
+    }
+    async executed() {
+        await this.ensureStorage();
+        const querier = await this.querierPool.getQuerier();
+        if (!isSqlQuerier(querier)) {
+            await querier.release();
+            throw new Error('DatabaseMigrationStorage requires a SQL-based querier');
+        }
+        try {
+            const { escapeId } = querier.dialect;
+            const sql = `SELECT ${escapeId('name')} FROM ${escapeId(this.tableName)} ORDER BY ${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 { escapeId, placeholder } = querier.dialect;
+        const sql = `INSERT INTO ${escapeId(this.tableName)} (${escapeId('name')}) VALUES (${placeholder(1)})`;
+        await querier.run(sql, [
+            migrationName
+        ]);
+    }
+    /**
+   * Unlog a migration - uses provided querier (within transaction)
+   */ async unlogWithQuerier(querier, migrationName) {
+        await this.ensureStorage();
+        const { escapeId, placeholder } = querier.dialect;
+        const sql = `DELETE FROM ${escapeId(this.tableName)} WHERE ${escapeId('name')} = ${placeholder(1)}`;
+        await querier.run(sql, [
+            migrationName
+        ]);
+    }
+}
+
+/**
+ * Main class for managing database migrations
+ */ class Migrator {
+    constructor(querierPool, options = {}){
+        this.querierPool = querierPool;
+        this.dialect = options.dialect ?? querierPool.dialect ?? 'postgres';
+        this.storage = options.storage ?? new DatabaseMigrationStorage(querierPool, {
+            tableName: options.tableName
+        });
+        this.migrationsPath = options.migrationsPath ?? './migrations';
+        this.logger = options.logger ?? (()=>{});
+        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 'postgres':
+                return new PostgresSchemaIntrospector(this.querierPool);
+            case 'mysql':
+                return new MysqlSchemaIntrospector(this.querierPool);
+            case 'mariadb':
+                return new MariadbSchemaIntrospector(this.querierPool);
+            case 'sqlite':
+                return new SqliteSchemaIntrospector(this.querierPool);
+            case 'mongodb':
+                return new MongoSchemaIntrospector(this.querierPool);
+            default:
+                return undefined;
+        }
+    }
+    createGenerator(namingStrategy) {
+        switch(this.dialect){
+            case 'postgres':
+                return new PostgresSchemaGenerator(namingStrategy);
+            case 'mysql':
+                return new MysqlSchemaGenerator(namingStrategy);
+            case 'mariadb':
+                return new MysqlSchemaGenerator(namingStrategy);
+            case 'sqlite':
+                return new SqliteSchemaGenerator(namingStrategy);
+            case 'mongodb':
+                return new MongoSchemaGenerator(namingStrategy);
+            default:
+                return undefined;
+        }
+    }
+    /**
+   * 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.querierPool.getQuerier();
+        if (!isSqlQuerier(querier)) {
+            await querier.release();
+            throw new Error('Migrator requires a SQL-based querier');
+        }
+        try {
+            this.logger(`${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(`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(`Migration ${migration.name} failed: ${error.message}`);
+            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);
+        const { writeFile, mkdir } = await import('node:fs/promises');
+        await mkdir(this.migrationsPath, {
+            recursive: true
+        });
+        await writeFile(filePath, content, 'utf-8');
+        this.logger(`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('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());
+        const { writeFile, mkdir } = await import('node:fs/promises');
+        await mkdir(this.migrationsPath, {
+            recursive: true
+        });
+        await writeFile(filePath, content, 'utf-8');
+        this.logger(`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 entities = this.entities.length > 0 ? this.entities : getEntities();
+        const diffs = [];
+        for (const entity of entities){
+            const meta = getMeta(entity);
+            const tableName = this.schemaGenerator.resolveTableName(entity, meta);
+            const currentSchema = await this.schemaIntrospector.getTableSchema(tableName);
+            const diff = this.schemaGenerator.diffSchema(entity, currentSchema);
+            if (diff) {
+                diffs.push(diff);
+            }
+        }
+        return diffs;
+    }
+    findEntityForTable(tableName) {
+        const entities = this.entities.length > 0 ? this.entities : getEntities();
+        for (const entity of entities){
+            const meta = getMeta(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 entities = this.entities.length > 0 ? this.entities : getEntities();
+        const querier = await this.querierPool.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 [
+                ...entities
+            ].reverse()){
+                const dropSql = this.schemaGenerator.generateDropTable(entity);
+                this.logger(`Executing: ${dropSql}`);
+                await querier.run(dropSql);
+            }
+            // Create all tables
+            for (const entity of entities){
+                const createSql = this.schemaGenerator.generateCreateTable(entity);
+                this.logger(`Executing: ${createSql}`);
+                await querier.run(createSql);
+            }
+            await querier.commitTransaction();
+            this.logger('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('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
+            delete filteredDiff.columnsToDrop;
+            delete filteredDiff.indexesToDrop;
+            delete filteredDiff.foreignKeysToDrop;
+        }
+        if (!options.drop) {
+            delete filteredDiff.columnsToDrop;
+        }
+        return filteredDiff;
+    }
+    async executeSyncStatements(statements, options) {
+        const querier = await this.querierPool.getQuerier();
+        try {
+            if (this.dialect === 'mongodb') {
+                await this.executeMongoSyncStatements(statements, options, querier);
+            } else {
+                await this.executeSqlSyncStatements(statements, options, querier);
+            }
+            if (options.logging) this.logger('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(`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(`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(`Warning: ${fileName} is not a valid migration`);
+            return undefined;
+        } catch (error) {
+            this.logger(`Error loading migration ${fileName}: ${error.message}`);
+            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/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/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;
+}
+
+/**
+ * Stores migration state in a JSON file (useful for development/testing)
+ */ class JsonMigrationStorage {
+    constructor(filePath = './migrations/.uql-migrations.json'){
+        this.cache = null;
+        this.filePath = filePath;
+    }
+    async ensureStorage() {
+        try {
+            await this.load();
+        } catch  {
+            // File doesn't exist, create it
+            await this.save([]);
+        }
+    }
+    async executed() {
+        await this.ensureStorage();
+        return this.cache ?? [];
+    }
+    async logWithQuerier(_querier, migrationName) {
+        const executed = await this.executed();
+        if (!executed.includes(migrationName)) {
+            executed.push(migrationName);
+            executed.sort();
+            await this.save(executed);
+        }
+    }
+    async unlogWithQuerier(_querier, migrationName) {
+        const executed = await this.executed();
+        const index = executed.indexOf(migrationName);
+        if (index !== -1) {
+            executed.splice(index, 1);
+            await this.save(executed);
+        }
+    }
+    async load() {
+        const content = await readFile(this.filePath, 'utf-8');
+        this.cache = JSON.parse(content);
+    }
+    async save(migrations) {
+        await mkdir(dirname(this.filePath), {
+            recursive: true
+        });
+        await writeFile(this.filePath, JSON.stringify(migrations, null, 2), 'utf-8');
+        this.cache = migrations;
+    }
+}
+
+export { AbstractSchemaGenerator, DatabaseMigrationStorage, JsonMigrationStorage, MysqlSchemaGenerator as MariadbSchemaGenerator, MariadbSchemaIntrospector, Migrator, MysqlSchemaGenerator, MysqlSchemaIntrospector, PostgresSchemaGenerator, PostgresSchemaIntrospector, SqliteSchemaGenerator, SqliteSchemaIntrospector, defineMigration };
+//# sourceMappingURL=uql-browser.min.js.map