@ductape/sdk 0.0.4-v5 → 0.0.4-v51

package/dist/database/adapters/mysql.adapter.js

@@ -0,0 +1,1492 @@
+"use strict";
+/**
+ * MySQL Database Adapter
+ * Implements database operations for MySQL/MariaDB
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySQLAdapter = void 0;
+const base_adapter_1 = require("./base.adapter");
+const database_types_1 = require("../types/database.types");
+const uuid_1 = require("uuid");
+const schema_types_1 = require("../types/schema.types");
+const migration_types_1 = require("../types/migration.types");
+/**
+ * MySQL Connection wrapper
+ */
+class MySQLConnection {
+    constructor(id, connection) {
+        this.id = id;
+        this.type = database_types_1.DatabaseType.MYSQL;
+        this.status = database_types_1.ConnectionStatus.CONNECTED;
+        this.connection = connection;
+    }
+    async connect() {
+        this.status = database_types_1.ConnectionStatus.CONNECTED;
+    }
+    async disconnect() {
+        if (this.connection) {
+            await this.connection.end();
+            this.status = database_types_1.ConnectionStatus.DISCONNECTED;
+        }
+    }
+    isConnected() {
+        return this.status === database_types_1.ConnectionStatus.CONNECTED;
+    }
+    getClient() {
+        return this.connection;
+    }
+    getType() {
+        return this.type;
+    }
+    getConfig() {
+        throw new Error('Config not stored in connection');
+    }
+}
+/**
+ * MySQL Savepoint implementation
+ */
+class MySQLSavepoint {
+    constructor(name, transaction, client) {
+        this.name = name;
+        this.transaction = transaction;
+        this.createdAt = new Date();
+        this.client = client;
+    }
+    async rollback() {
+        await this.client.query(`ROLLBACK TO SAVEPOINT \`${this.name}\``);
+    }
+    async release() {
+        await this.client.query(`RELEASE SAVEPOINT \`${this.name}\``);
+    }
+}
+/**
+ * MySQL Transaction implementation
+ */
+class MySQLTransaction {
+    constructor(connection, client, options) {
+        this.id = (0, uuid_1.v4)();
+        this.connection = connection;
+        this.status = database_types_1.TransactionStatus.ACTIVE;
+        this.isolationLevel = options === null || options === void 0 ? void 0 : options.isolationLevel;
+        this.createdAt = new Date();
+        this.client = client;
+        this.native = client;
+    }
+    async commit() {
+        if (this.status !== database_types_1.TransactionStatus.ACTIVE) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.TRANSACTION_ERROR, `Cannot commit transaction: status is ${this.status}`);
+        }
+        await this.client.commit();
+        this.status = database_types_1.TransactionStatus.COMMITTED;
+    }
+    async rollback() {
+        if (this.status !== database_types_1.TransactionStatus.ACTIVE) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.TRANSACTION_ERROR, `Cannot rollback transaction: status is ${this.status}`);
+        }
+        await this.client.rollback();
+        this.status = database_types_1.TransactionStatus.ROLLED_BACK;
+    }
+    async savepoint(name) {
+        if (this.status !== database_types_1.TransactionStatus.ACTIVE) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.TRANSACTION_ERROR, `Cannot create savepoint: transaction status is ${this.status}`);
+        }
+        await this.client.query(`SAVEPOINT \`${name}\``);
+        return new MySQLSavepoint(name, this, this.client);
+    }
+    isActive() {
+        return this.status === database_types_1.TransactionStatus.ACTIVE;
+    }
+}
+/**
+ * MySQL Database Adapter
+ */
+class MySQLAdapter extends base_adapter_1.BaseDatabaseAdapter {
+    constructor() {
+        super(...arguments);
+        this.type = database_types_1.DatabaseType.MYSQL;
+    }
+    // ==================== Connection Methods ====================
+    async connect(config) {
+        var _a, _b, _c, _d, _e, _f;
+        try {
+            // Dynamic import of mysql2/promise
+            // @ts-ignore - mysql2 is an optional peer dependency
+            const mysql = await Promise.resolve().then(() => __importStar(require('mysql2/promise')));
+            const connection = await mysql.createConnection(Object.assign({ host: (_a = config.options) === null || _a === void 0 ? void 0 : _a.host, port: ((_b = config.options) === null || _b === void 0 ? void 0 : _b.port) || 3306, user: ((_c = config.options) === null || _c === void 0 ? void 0 : _c.username) || ((_d = config.options) === null || _d === void 0 ? void 0 : _d.user), password: (_e = config.options) === null || _e === void 0 ? void 0 : _e.password, database: config.database, ssl: (_f = config.options) === null || _f === void 0 ? void 0 : _f.ssl }, config.options));
+            return new MySQLConnection(`mysql-${Date.now()}`, connection);
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.CONNECTION_ERROR, `Failed to connect to MySQL: ${error.message}`, error);
+        }
+    }
+    async disconnect(connection) {
+        await connection.disconnect();
+    }
+    async testConnection(connection) {
+        const startTime = Date.now();
+        try {
+            const conn = connection.getClient();
+            await conn.query('SELECT 1');
+            return {
+                connected: true,
+                message: 'MySQL connection successful',
+                databaseType: 'MySQL',
+                responseTime: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                connected: false,
+                message: `MySQL connection failed: ${error.message}`,
+                databaseType: 'MySQL',
+                responseTime: Date.now() - startTime,
+                error: error.message,
+            };
+        }
+    }
+    // ==================== Transaction Methods ====================
+    async beginTransaction(connection, options) {
+        try {
+            const conn = connection.getClient();
+            // Set isolation level if specified
+            if (options === null || options === void 0 ? void 0 : options.isolationLevel) {
+                const isolationLevel = options.isolationLevel.replace('_', ' ');
+                await conn.query(`SET TRANSACTION ISOLATION LEVEL ${isolationLevel}`);
+            }
+            // Set read-only mode if specified
+            if (options === null || options === void 0 ? void 0 : options.readOnly) {
+                await conn.query('SET TRANSACTION READ ONLY');
+            }
+            await conn.beginTransaction();
+            return new MySQLTransaction(connection, conn, options);
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.TRANSACTION_ERROR, `Failed to begin transaction: ${error.message}`, error);
+        }
+    }
+    async commitTransaction(connection, transaction) {
+        await transaction.commit();
+    }
+    async rollbackTransaction(connection, transaction) {
+        await transaction.rollback();
+    }
+    async createSavepoint(connection, transaction, savepointName) {
+        return transaction.savepoint(savepointName);
+    }
+    async rollbackToSavepoint(_connection, _transaction, savepoint) {
+        await savepoint.rollback();
+    }
+    async releaseSavepoint(_connection, _transaction, savepoint) {
+        await savepoint.release();
+    }
+    // ==================== Query Methods ====================
+    async query(connection, options) {
+        const startTime = Date.now();
+        try {
+            const { query, params } = this.buildSelectQuery(options);
+            const conn = connection.getClient();
+            const [rows] = await conn.query(query, params);
+            const executionTime = Date.now() - startTime;
+            return {
+                data: rows,
+                count: Array.isArray(rows) ? rows.length : 0,
+                executionTime,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MySQL query failed: ${error.message}`, error);
+        }
+    }
+    async insert(connection, options) {
+        const startTime = Date.now();
+        try {
+            const { query, params } = this.buildInsertQuery(options);
+            const conn = connection.getClient();
+            const [result] = await conn.query(query, params);
+            const executionTime = Date.now() - startTime;
+            return {
+                insertedCount: result.affectedRows,
+                insertedIds: [result.insertId],
+                data: undefined,
+                executionTime,
+                success: true,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MySQL insert failed: ${error.message}`, error);
+        }
+    }
+    async update(connection, options) {
+        const startTime = Date.now();
+        try {
+            const { query, params } = this.buildUpdateQuery(options);
+            const conn = connection.getClient();
+            const [result] = await conn.query(query, params);
+            const executionTime = Date.now() - startTime;
+            return {
+                updatedCount: result.affectedRows,
+                matchedCount: result.affectedRows,
+                data: undefined,
+                executionTime,
+                success: true,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MySQL update failed: ${error.message}`, error);
+        }
+    }
+    async delete(connection, options) {
+        const startTime = Date.now();
+        try {
+            const { query, params } = this.buildDeleteQuery(options);
+            const conn = connection.getClient();
+            const [result] = await conn.query(query, params);
+            const executionTime = Date.now() - startTime;
+            return {
+                deletedCount: result.affectedRows,
+                data: undefined,
+                executionTime,
+                success: true,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MySQL delete failed: ${error.message}`, error);
+        }
+    }
+    async upsert(connection, options) {
+        const startTime = Date.now();
+        try {
+            const { query, params } = this.buildUpsertQuery(options);
+            const conn = connection.getClient();
+            const [result] = await conn.query(query, params);
+            const executionTime = Date.now() - startTime;
+            return {
+                insertedCount: 0,
+                updatedCount: 0,
+                affectedCount: result.affectedRows,
+                data: undefined,
+                executionTime,
+                success: true,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MySQL upsert failed: ${error.message}`, error);
+        }
+    }
+    async executeRaw(connection, options) {
+        const startTime = Date.now();
+        try {
+            const conn = connection.getClient();
+            const [rows, fields] = await conn.query(options.query, options.params || []);
+            const executionTime = Date.now() - startTime;
+            return {
+                rows: rows,
+                rowCount: Array.isArray(rows) ? rows.length : 0,
+                fields: fields === null || fields === void 0 ? void 0 : fields.map((f) => ({
+                    name: f.name,
+                    type: f.type,
+                })),
+                executionTime,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MySQL raw query failed: ${error.message}`, error);
+        }
+    }
+    // ==================== Aggregation Methods ====================
+    async count(connection, options) {
+        try {
+            const { query, params } = this.buildCountQuery(options);
+            const conn = connection.getClient();
+            const [rows] = await conn.query(query, params);
+            return parseInt(rows[0].count, 10);
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MySQL count failed: ${error.message}`, error);
+        }
+    }
+    async sum(connection, options) {
+        try {
+            const { query, params } = this.buildAggregateQuery('SUM', options.column, options);
+            const conn = connection.getClient();
+            const [rows] = await conn.query(query, params);
+            return parseFloat(rows[0].result) || 0;
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MySQL sum failed: ${error.message}`, error);
+        }
+    }
+    async avg(connection, options) {
+        try {
+            const { query, params } = this.buildAggregateQuery('AVG', options.column, options);
+            const conn = connection.getClient();
+            const [rows] = await conn.query(query, params);
+            return parseFloat(rows[0].result) || 0;
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MySQL avg failed: ${error.message}`, error);
+        }
+    }
+    async min(connection, options) {
+        try {
+            const { query, params } = this.buildAggregateQuery('MIN', options.column, options);
+            const conn = connection.getClient();
+            const [rows] = await conn.query(query, params);
+            return rows[0].result;
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MySQL min failed: ${error.message}`, error);
+        }
+    }
+    async max(connection, options) {
+        try {
+            const { query, params } = this.buildAggregateQuery('MAX', options.column, options);
+            const conn = connection.getClient();
+            const [rows] = await conn.query(query, params);
+            return rows[0].result;
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MySQL max failed: ${error.message}`, error);
+        }
+    }
+    async groupBy(connection, options) {
+        try {
+            const { query, params } = this.buildGroupByQuery(options);
+            const conn = connection.getClient();
+            const [rows] = await conn.query(query, params);
+            return rows;
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MySQL groupBy failed: ${error.message}`, error);
+        }
+    }
+    async aggregate(connection, options) {
+        try {
+            const { query, params } = this.buildMultiAggregateQuery(options);
+            const conn = connection.getClient();
+            const [rows] = await conn.query(query, params);
+            return rows[0] || {};
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `MySQL aggregate failed: ${error.message}`, error);
+        }
+    }
+    // ==================== Schema Methods ====================
+    async createTable(connection, schema, options) {
+        const startTime = Date.now();
+        try {
+            const query = this.buildCreateTableQuery(schema, options);
+            const conn = connection.getClient();
+            await conn.query(query);
+            const executionTime = Date.now() - startTime;
+            return {
+                success: true,
+                operation: 'create',
+                table: schema.name,
+                executionTime,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                operation: 'create',
+                table: schema.name,
+                error: error.message,
+                executionTime: Date.now() - startTime,
+            };
+        }
+    }
+    async dropTable(connection, tableName) {
+        const startTime = Date.now();
+        try {
+            const conn = connection.getClient();
+            await conn.query(`DROP TABLE IF EXISTS \`${tableName}\``);
+            return {
+                success: true,
+                operation: 'drop',
+                table: tableName,
+                executionTime: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                operation: 'drop',
+                table: tableName,
+                error: error.message,
+                executionTime: Date.now() - startTime,
+            };
+        }
+    }
+    async alterTable(connection, tableName, alterations, options) {
+        const startTime = Date.now();
+        try {
+            const conn = connection.getClient();
+            const queries = this.buildAlterTableQueries(tableName, alterations);
+            for (const query of queries) {
+                await conn.query(query);
+            }
+            return {
+                success: true,
+                operation: 'alter',
+                table: tableName,
+                executionTime: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                operation: 'alter',
+                table: tableName,
+                error: error.message,
+                executionTime: Date.now() - startTime,
+            };
+        }
+    }
+    async getTableSchema(connection, tableName) {
+        try {
+            const conn = connection.getClient();
+            const query = `
+        SELECT
+          COLUMN_NAME as column_name,
+          DATA_TYPE as data_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
+        FROM INFORMATION_SCHEMA.COLUMNS
+        WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?
+        ORDER BY ORDINAL_POSITION
+      `;
+            const [rows] = await conn.query(query, [tableName]);
+            const columns = rows.map((row) => ({
+                name: row.column_name,
+                type: this.mapMySQLTypeToColumnType(row.data_type),
+                nullable: row.is_nullable === 'YES',
+                primaryKey: row.column_key === 'PRI',
+                unique: row.column_key === 'UNI',
+                defaultValue: row.column_default,
+                length: row.character_maximum_length,
+                precision: row.numeric_precision,
+                scale: row.numeric_scale,
+            }));
+            return {
+                name: tableName,
+                columns,
+            };
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.SCHEMA_ERROR, `Failed to get MySQL table schema: ${error.message}`, error);
+        }
+    }
+    async listTables(connection) {
+        try {
+            const conn = connection.getClient();
+            const [rows] = await conn.query('SHOW TABLES');
+            return rows.map((row) => Object.values(row)[0]);
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.SCHEMA_ERROR, `Failed to list MySQL tables: ${error.message}`, error);
+        }
+    }
+    async tableExists(connection, tableName) {
+        try {
+            const conn = connection.getClient();
+            const query = `
+        SELECT COUNT(*) as count
+        FROM INFORMATION_SCHEMA.TABLES
+        WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?
+      `;
+            const [rows] = await conn.query(query, [tableName]);
+            return rows[0].count > 0;
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.SCHEMA_ERROR, `Failed to check MySQL table existence: ${error.message}`, error);
+        }
+    }
+    // ==================== Index Methods ====================
+    async createIndex(connection, options) {
+        const startTime = Date.now();
+        try {
+            const query = this.buildCreateIndexQuery(options);
+            const conn = connection.getClient();
+            await conn.query(query);
+            return {
+                success: true,
+                operation: 'create',
+                indexName: options.index.name,
+                table: options.table,
+                executionTime: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                operation: 'create',
+                indexName: options.index.name,
+                table: options.table,
+                error: error.message,
+                executionTime: Date.now() - startTime,
+            };
+        }
+    }
+    async dropIndex(connection, options) {
+        const startTime = Date.now();
+        try {
+            const conn = connection.getClient();
+            await conn.query(`DROP INDEX \`${options.indexName}\` ON \`${options.table}\``);
+            return {
+                success: true,
+                operation: 'drop',
+                indexName: options.indexName,
+                table: options.table,
+                executionTime: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                operation: 'drop',
+                indexName: options.indexName,
+                table: options.table,
+                error: error.message,
+                executionTime: Date.now() - startTime,
+            };
+        }
+    }
+    async listIndexes(connection, options) {
+        try {
+            const conn = connection.getClient();
+            const query = `
+        SELECT
+          INDEX_NAME as index_name,
+          COLUMN_NAME as column_name,
+          NON_UNIQUE as non_unique,
+          INDEX_TYPE as index_type
+        FROM INFORMATION_SCHEMA.STATISTICS
+        WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?
+        ORDER BY INDEX_NAME, SEQ_IN_INDEX
+      `;
+            const [rows] = await conn.query(query, [options.table]);
+            const indexMap = new Map();
+            rows.forEach((row) => {
+                if (!indexMap.has(row.index_name)) {
+                    indexMap.set(row.index_name, {
+                        name: row.index_name,
+                        table: options.table,
+                        columns: [],
+                        columnDetails: [],
+                        unique: row.non_unique === 0,
+                        primaryKey: row.index_name === 'PRIMARY',
+                        type: row.index_type,
+                    });
+                }
+                const indexInfo = indexMap.get(row.index_name);
+                indexInfo.columns.push(row.column_name);
+                indexInfo.columnDetails.push({
+                    name: row.column_name,
+                    order: 'ASC',
+                });
+            });
+            return Array.from(indexMap.values());
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.INDEX_ERROR, `Failed to list MySQL indexes: ${error.message}`, error);
+        }
+    }
+    async getIndexStatistics(connection, tableName, indexName) {
+        try {
+            const conn = connection.getClient();
+            let query = `
+        SELECT
+          INDEX_NAME as index_name,
+          CARDINALITY as cardinality
+        FROM INFORMATION_SCHEMA.STATISTICS
+        WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?
+      `;
+            const params = [tableName];
+            if (indexName) {
+                query += ' AND INDEX_NAME = ?';
+                params.push(indexName);
+            }
+            const [rows] = await conn.query(query, params);
+            return rows.map((row) => ({
+                indexName: row.index_name,
+                table: tableName,
+                size: 0, // MySQL doesn't provide this easily
+                tuplesRead: row.cardinality || 0,
+            }));
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.INDEX_ERROR, `Failed to get MySQL index statistics: ${error.message}`, error);
+        }
+    }
+    // ==================== Migration Methods ====================
+    /**
+     * Build SQL for a migration operation
+     */
+    async buildMigrationOperationSQL(operation) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        switch (operation.type) {
+            case migration_types_1.MigrationOperationType.RAW_SQL:
+                return operation.sql || null;
+            case migration_types_1.MigrationOperationType.CREATE_TABLE:
+                if ((_a = operation.params) === null || _a === void 0 ? void 0 : _a.schema) {
+                    const schema = operation.params.schema;
+                    const columns = schema.columns
+                        .map((col) => {
+                        let def = `\`${col.name}\` ${this.mapColumnTypeToMySQL(col.type)}`;
+                        if (col.primaryKey)
+                            def += ' PRIMARY KEY';
+                        if (col.autoIncrement)
+                            def += ' AUTO_INCREMENT';
+                        if (!col.nullable)
+                            def += ' NOT NULL';
+                        if (col.unique)
+                            def += ' UNIQUE';
+                        if (col.defaultValue !== undefined) {
+                            def += ` DEFAULT ${this.escapeValue(col.defaultValue)}`;
+                        }
+                        return def;
+                    })
+                        .join(', ');
+                    return `CREATE TABLE \`${schema.name}\` (${columns})`;
+                }
+                return null;
+            case migration_types_1.MigrationOperationType.DROP_TABLE:
+                return operation.table ? `DROP TABLE IF EXISTS \`${operation.table}\`` : null;
+            case migration_types_1.MigrationOperationType.ADD_COLUMN:
+                if (operation.table && ((_b = operation.params) === null || _b === void 0 ? void 0 : _b.column)) {
+                    const col = operation.params.column;
+                    let def = `ALTER TABLE \`${operation.table}\` ADD COLUMN \`${col.name}\` ${this.mapColumnTypeToMySQL(col.type)}`;
+                    if (!col.nullable)
+                        def += ' NOT NULL';
+                    if (col.defaultValue !== undefined) {
+                        def += ` DEFAULT ${this.escapeValue(col.defaultValue)}`;
+                    }
+                    return def;
+                }
+                return null;
+            case migration_types_1.MigrationOperationType.DROP_COLUMN:
+                return operation.table && ((_c = operation.params) === null || _c === void 0 ? void 0 : _c.columnName)
+                    ? `ALTER TABLE \`${operation.table}\` DROP COLUMN \`${operation.params.columnName}\``
+                    : null;
+            case migration_types_1.MigrationOperationType.MODIFY_COLUMN:
+                if (operation.table && ((_d = operation.params) === null || _d === void 0 ? void 0 : _d.column)) {
+                    const col = operation.params.column;
+                    return `ALTER TABLE \`${operation.table}\` MODIFY COLUMN \`${col.name}\` ${this.mapColumnTypeToMySQL(col.type)}`;
+                }
+                return null;
+            case migration_types_1.MigrationOperationType.RENAME_COLUMN:
+                return operation.table && ((_e = operation.params) === null || _e === void 0 ? void 0 : _e.oldName) && ((_f = operation.params) === null || _f === void 0 ? void 0 : _f.newName)
+                    ? `ALTER TABLE \`${operation.table}\` RENAME COLUMN \`${operation.params.oldName}\` TO \`${operation.params.newName}\``
+                    : null;
+            case migration_types_1.MigrationOperationType.ADD_INDEX:
+                if (operation.table && ((_g = operation.params) === null || _g === void 0 ? void 0 : _g.indexName) && ((_h = operation.params) === null || _h === void 0 ? void 0 : _h.columns)) {
+                    const unique = operation.params.unique ? 'UNIQUE ' : '';
+                    const columns = operation.params.columns.map((col) => `\`${col}\``).join(', ');
+                    return `CREATE ${unique}INDEX \`${operation.params.indexName}\` ON \`${operation.table}\` (${columns})`;
+                }
+                return null;
+            case migration_types_1.MigrationOperationType.DROP_INDEX:
+                return ((_j = operation.params) === null || _j === void 0 ? void 0 : _j.indexName) && operation.table
+                    ? `DROP INDEX \`${operation.params.indexName}\` ON \`${operation.table}\``
+                    : null;
+            case migration_types_1.MigrationOperationType.ADD_CONSTRAINT:
+                if (operation.table && ((_k = operation.params) === null || _k === void 0 ? void 0 : _k.constraintName) && ((_l = operation.params) === null || _l === void 0 ? void 0 : _l.definition)) {
+                    return `ALTER TABLE \`${operation.table}\` ADD CONSTRAINT \`${operation.params.constraintName}\` ${operation.params.definition}`;
+                }
+                return null;
+            case migration_types_1.MigrationOperationType.DROP_CONSTRAINT:
+                return operation.table && ((_m = operation.params) === null || _m === void 0 ? void 0 : _m.constraintName)
+                    ? `ALTER TABLE \`${operation.table}\` DROP CONSTRAINT \`${operation.params.constraintName}\``
+                    : null;
+            default:
+                return null;
+        }
+    }
+    async runMigration(connection, migration, options) {
+        const startTime = Date.now();
+        const statements = [];
+        try {
+            const conn = connection.getClient();
+            await conn.query('START TRANSACTION');
+            try {
+                // Execute migration operations
+                for (const operation of migration.up) {
+                    const sql = await this.buildMigrationOperationSQL(operation);
+                    if (sql) {
+                        statements.push(sql);
+                        await conn.query(sql);
+                    }
+                }
+                // Record migration in history table
+                await this.recordMigration(conn, migration, migration_types_1.MigrationDirection.UP);
+                await conn.query('COMMIT');
+                return {
+                    tag: migration.tag,
+                    status: migration_types_1.MigrationStatus.COMPLETED,
+                    direction: migration_types_1.MigrationDirection.UP,
+                    executedAt: new Date(),
+                    duration: Date.now() - startTime,
+                    statements,
+                };
+            }
+            catch (error) {
+                await conn.query('ROLLBACK');
+                throw error;
+            }
+        }
+        catch (error) {
+            return {
+                tag: migration.tag,
+                status: migration_types_1.MigrationStatus.FAILED,
+                direction: migration_types_1.MigrationDirection.UP,
+                executedAt: new Date(),
+                duration: Date.now() - startTime,
+                error: error.message,
+                statements,
+            };
+        }
+    }
+    async rollbackMigration(connection, migration, options) {
+        const startTime = Date.now();
+        const statements = [];
+        try {
+            const conn = connection.getClient();
+            await conn.query('START TRANSACTION');
+            try {
+                // Execute rollback operations
+                for (const operation of migration.down) {
+                    const sql = await this.buildMigrationOperationSQL(operation);
+                    if (sql) {
+                        statements.push(sql);
+                        await conn.query(sql);
+                    }
+                }
+                // Remove migration from history table
+                await this.removeMigration(conn, migration.tag);
+                await conn.query('COMMIT');
+                return {
+                    tag: migration.tag,
+                    status: migration_types_1.MigrationStatus.ROLLED_BACK,
+                    direction: migration_types_1.MigrationDirection.DOWN,
+                    executedAt: new Date(),
+                    duration: Date.now() - startTime,
+                    statements,
+                };
+            }
+            catch (error) {
+                await conn.query('ROLLBACK');
+                throw error;
+            }
+        }
+        catch (error) {
+            return {
+                tag: migration.tag,
+                status: migration_types_1.MigrationStatus.FAILED,
+                direction: migration_types_1.MigrationDirection.DOWN,
+                executedAt: new Date(),
+                duration: Date.now() - startTime,
+                error: error.message,
+                statements,
+            };
+        }
+    }
+    async getMigrationHistory(connection, options) {
+        try {
+            const conn = connection.getClient();
+            // Ensure migration table exists
+            await this.ensureMigrationTable(conn);
+            const query = `
+        SELECT tag, name, executed_at
+        FROM _ductape_migrations
+        ORDER BY executed_at DESC
+      `;
+            const [rows] = await conn.query(query);
+            return rows.map((row) => ({
+                tag: row.tag,
+                name: row.name,
+                env: options.env,
+                product: options.product,
+                database: options.database,
+                status: migration_types_1.MigrationStatus.COMPLETED,
+                direction: migration_types_1.MigrationDirection.UP,
+                appliedAt: row.executed_at,
+            }));
+        }
+        catch (error) {
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.MIGRATION_ERROR, `Failed to get MySQL migration history: ${error.message}`, error);
+        }
+    }
+    // ==================== Query Builder Helpers ====================
+    /**
+     * Build SELECT query from options
+     */
+    buildSelectQuery(options) {
+        const params = [];
+        // Handle includes
+        const hasIncludes = options.include && (Array.isArray(options.include) ? options.include.length > 0 : true);
+        // SELECT clause
+        let selectColumns;
+        if (options.select) {
+            const cols = Array.isArray(options.select) ? options.select : [options.select];
+            // Prefix main table columns with table name
+            selectColumns = cols.map((col) => `\`${options.table}\`.\`${col}\``).join(', ');
+        }
+        else {
+            // Select all from main table
+            selectColumns = hasIncludes ? `\`${options.table}\`.*` : '*';
+        }
+        // Add included relation columns
+        if (hasIncludes) {
+            const includes = Array.isArray(options.include) ? options.include : [options.include];
+            includes.forEach((include) => {
+                const relationAlias = include.relation;
+                if (include.select && include.select.length > 0) {
+                    const relationCols = include.select.map((col) => `\`${relationAlias}\`.\`${col}\` as \`${relationAlias}_${col}\``).join(', ');
+                    selectColumns += `, ${relationCols}`;
+                }
+                else {
+                    // Use JSON aggregation for one-to-many
+                    if (include.type === 'one-to-many') {
+                        selectColumns += `, JSON_ARRAYAGG(JSON_OBJECT('*', \`${relationAlias}\`.*)) as \`${relationAlias}\``;
+                    }
+                    else {
+                        selectColumns += `, JSON_OBJECT('*', \`${relationAlias}\`.*) as \`${relationAlias}\``;
+                    }
+                }
+            });
+        }
+        let query = `SELECT ${options.distinct ? 'DISTINCT ' : ''}${selectColumns} FROM \`${options.table}\``;
+        // JOIN clauses for includes
+        if (hasIncludes) {
+            const includes = Array.isArray(options.include) ? options.include : [options.include];
+            includes.forEach((include) => {
+                const { joinClause } = this.buildIncludeJoin(options.table, include);
+                query += ` ${joinClause}`;
+            });
+        }
+        // WHERE clause
+        if (options.where) {
+            const { clause, values } = this.buildWhereClause(options.where);
+            query += ` WHERE ${clause}`;
+            params.push(...values);
+        }
+        // GROUP BY clause
+        if (options.groupBy && options.groupBy.length > 0) {
+            query += ` GROUP BY ${options.groupBy.map((col) => `\`${col}\``).join(', ')}`;
+        }
+        else if (hasIncludes) {
+            // Auto group by main table primary key for one-to-many relations
+            const includes = Array.isArray(options.include) ? options.include : [options.include];
+            const hasOneToMany = includes.some(inc => inc.type === 'one-to-many');
+            if (hasOneToMany) {
+                query += ` GROUP BY \`${options.table}\`.\`id\``;
+            }
+        }
+        // HAVING clause
+        if (options.having) {
+            const { clause, values } = this.buildWhereClause(options.having);
+            query += ` HAVING ${clause}`;
+            params.push(...values);
+        }
+        // ORDER BY clause
+        if (options.orderBy) {
+            const orderByArray = Array.isArray(options.orderBy) ? options.orderBy : [options.orderBy];
+            const orderClauses = orderByArray.map((order) => `\`${options.table}\`.\`${order.column}\` ${order.order || 'ASC'}`);
+            query += ` ORDER BY ${orderClauses.join(', ')}`;
+        }
+        // LIMIT clause
+        if (options.limit) {
+            query += ` LIMIT ?`;
+            params.push(options.limit);
+        }
+        // OFFSET clause
+        if (options.offset) {
+            query += ` OFFSET ?`;
+            params.push(options.offset);
+        }
+        return { query, params };
+    }
+    /**
+     * Build JOIN clause for include relationships
+     */
+    buildIncludeJoin(mainTable, include) {
+        const relationTable = include.relation;
+        const foreignKey = include.foreignKey || `${relationTable}_id`;
+        const primaryKey = include.primaryKey || 'id';
+        const joinType = include.type === 'one-to-many' || include.type === 'one-to-one' ? 'LEFT' : 'INNER';
+        let joinClause;
+        if (include.type === 'many-to-many' && include.through) {
+            // Many-to-many with junction table
+            const throughTable = include.through;
+            const throughForeignKey = include.throughForeignKey || `${mainTable}_id`;
+            const throughRelatedKey = include.throughRelatedKey || `${relationTable}_id`;
+            joinClause = `${joinType} JOIN \`${throughTable}\` ON \`${mainTable}\`.\`${primaryKey}\` = \`${throughTable}\`.\`${throughForeignKey}\` `;
+            joinClause += `${joinType} JOIN \`${relationTable}\` ON \`${throughTable}\`.\`${throughRelatedKey}\` = \`${relationTable}\`.\`${primaryKey}\``;
+        }
+        else if (include.type === 'one-to-many') {
+            // One-to-many: foreign key is in the related table
+            joinClause = `${joinType} JOIN \`${relationTable}\` ON \`${mainTable}\`.\`${primaryKey}\` = \`${relationTable}\`.\`${foreignKey}\``;
+        }
+        else {
+            // Many-to-one or one-to-one: foreign key is in the main table
+            joinClause = `${joinType} JOIN \`${relationTable}\` ON \`${mainTable}\`.\`${foreignKey}\` = \`${relationTable}\`.\`${primaryKey}\``;
+        }
+        // Add where clause for the relation if specified
+        if (include.where) {
+            const { clause } = this.buildWhereClause(include.where);
+            joinClause += ` AND ${clause}`;
+        }
+        return { joinClause };
+    }
+    /**
+     * Build WHERE clause from options
+     * Supports both simplified syntax (GT, LT, AND, OR) and legacy syntax ($gt, $lt, $and, $or)
+     */
+    buildWhereClause(where) {
+        const values = [];
+        const buildCondition = (condition) => {
+            if (typeof condition !== 'object' || condition === null) {
+                values.push(condition);
+                return '?';
+            }
+            // Handle logical operators (supports $AND, AND, and legacy $and)
+            if (condition.$AND || condition.AND || condition.$and) {
+                const andConditions = condition.$AND || condition.AND || condition.$and;
+                if (typeof andConditions === 'object' && !Array.isArray(andConditions)) {
+                    // New syntax: { $AND: { col1: val1, col2: val2 } }
+                    return buildCondition(andConditions);
+                }
+                else {
+                    // Legacy syntax: { $and: [cond1, cond2] }
+                    const subConditions = andConditions.map(buildCondition);
+                    return `(${subConditions.join(' AND ')})`;
+                }
+            }
+            if (condition.$OR || condition.OR || condition.$or) {
+                const orConditions = condition.$OR || condition.OR || condition.$or;
+                if (typeof orConditions === 'object' && !Array.isArray(orConditions)) {
+                    // New syntax: { $OR: { col1: val1, col2: val2 } }
+                    const subClauses = [];
+                    for (const [key, value] of Object.entries(orConditions)) {
+                        if (key === '$AND' || key === 'AND' || key === '$and' || key === '$OR' || key === 'OR' || key === '$or') {
+                            subClauses.push(buildCondition({ [key]: value }));
+                        }
+                        else {
+                            subClauses.push(buildCondition({ [key]: value }));
+                        }
+                    }
+                    return `(${subClauses.join(' OR ')})`;
+                }
+                else {
+                    // Legacy syntax: { $or: [cond1, cond2] }
+                    const subConditions = orConditions.map(buildCondition);
+                    return `(${subConditions.join(' OR ')})`;
+                }
+            }
+            // Handle column conditions
+            const conditions = [];
+            for (const [key, value] of Object.entries(condition)) {
+                // Skip logical operators
+                if (key === '$AND' || key === 'AND' || key === '$and' || key === '$OR' || key === 'OR' || key === '$or') {
+                    continue;
+                }
+                if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                    // Handle comparison operators
+                    for (const [op, opValue] of Object.entries(value)) {
+                        switch (op) {
+                            // Preferred $-prefixed syntax
+                            case '$GT':
+                            case 'GT':
+                            case '$gt':
+                                values.push(opValue);
+                                conditions.push(`\`${key}\` > ?`);
+                                break;
+                            case '$GTE':
+                            case 'GTE':
+                            case '$gte':
+                                values.push(opValue);
+                                conditions.push(`\`${key}\` >= ?`);
+                                break;
+                            case '$LT':
+                            case 'LT':
+                            case '$lt':
+                                values.push(opValue);
+                                conditions.push(`\`${key}\` < ?`);
+                                break;
+                            case '$LTE':
+                            case 'LTE':
+                            case '$lte':
+                                values.push(opValue);
+                                conditions.push(`\`${key}\` <= ?`);
+                                break;
+                            case '$NE':
+                            case '$NOT':
+                            case 'NE':
+                            case 'NOT':
+                            case '$ne':
+                                values.push(opValue);
+                                conditions.push(`\`${key}\` != ?`);
+                                break;
+                            case '$IN':
+                            case 'IN':
+                            case '$in':
+                                if (Array.isArray(opValue)) {
+                                    const placeholders = opValue.map(() => '?').join(', ');
+                                    values.push(...opValue);
+                                    conditions.push(`\`${key}\` IN (${placeholders})`);
+                                }
+                                break;
+                            case '$NOT_IN':
+                            case 'NOT_IN':
+                            case '$nin':
+                                if (Array.isArray(opValue)) {
+                                    const placeholders = opValue.map(() => '?').join(', ');
+                                    values.push(...opValue);
+                                    conditions.push(`\`${key}\` NOT IN (${placeholders})`);
+                                }
+                                break;
+                            case '$LIKE':
+                            case 'LIKE':
+                            case '$like':
+                                values.push(opValue);
+                                conditions.push(`\`${key}\` LIKE ?`);
+                                break;
+                            case '$IS_NULL':
+                            case 'IS_NULL':
+                            case '$null':
+                                conditions.push(`\`${key}\` IS NULL`);
+                                break;
+                            case '$IS_NOT_NULL':
+                            case 'IS_NOT_NULL':
+                            case '$notNull':
+                                conditions.push(`\`${key}\` IS NOT NULL`);
+                                break;
+                            case '$BETWEEN':
+                            case 'BETWEEN':
+                            case '$between':
+                                if (Array.isArray(opValue) && opValue.length === 2) {
+                                    values.push(opValue[0], opValue[1]);
+                                    conditions.push(`\`${key}\` BETWEEN ? AND ?`);
+                                }
+                                break;
+                        }
+                    }
+                }
+                else {
+                    // Simple equality
+                    values.push(value);
+                    conditions.push(`\`${key}\` = ?`);
+                }
+            }
+            return conditions.join(' AND ');
+        };
+        const clause = buildCondition(where);
+        return { clause, values };
+    }
+    /**
+     * Build COUNT query
+     */
+    buildCountQuery(options) {
+        const params = [];
+        const column = options.column ? `\`${options.column}\`` : '*';
+        let query = `SELECT COUNT(${column}) as count FROM \`${options.table}\``;
+        if (options.where) {
+            const { clause, values } = this.buildWhereClause(options.where);
+            query += ` WHERE ${clause}`;
+            params.push(...values);
+        }
+        return { query, params };
+    }
+    /**
+     * Build aggregate query
+     */
+    buildAggregateQuery(fn, column, options) {
+        const params = [];
+        let query = `SELECT ${fn}(\`${column}\`) as result FROM \`${options.table}\``;
+        if (options.where) {
+            const { clause, values } = this.buildWhereClause(options.where);
+            query += ` WHERE ${clause}`;
+            params.push(...values);
+        }
+        return { query, params };
+    }
+    /**
+     * Build INSERT query
+     */
+    buildInsertQuery(options) {
+        const dataArray = Array.isArray(options.data) ? options.data : [options.data];
+        const columns = Object.keys(dataArray[0]);
+        const params = [];
+        let query = `INSERT INTO \`${options.table}\` (${columns.map((col) => `\`${col}\``).join(', ')}) VALUES `;
+        const valuesClauses = dataArray.map((data) => {
+            const placeholders = columns.map(() => '?');
+            params.push(...columns.map((col) => data[col]));
+            return `(${placeholders.join(', ')})`;
+        });
+        query += valuesClauses.join(', ');
+        return { query, params };
+    }
+    /**
+     * Build UPDATE query
+     */
+    buildUpdateQuery(options) {
+        const params = [];
+        const setClauses = Object.keys(options.data).map((key) => {
+            params.push(options.data[key]);
+            return `\`${key}\` = ?`;
+        });
+        let query = `UPDATE \`${options.table}\` SET ${setClauses.join(', ')}`;
+        if (options.where) {
+            const { clause, values } = this.buildWhereClause(options.where);
+            query += ` WHERE ${clause}`;
+            params.push(...values);
+        }
+        return { query, params };
+    }
+    /**
+     * Build DELETE query
+     */
+    buildDeleteQuery(options) {
+        const params = [];
+        let query = `DELETE FROM \`${options.table}\``;
+        if (options.where) {
+            const { clause, values } = this.buildWhereClause(options.where);
+            query += ` WHERE ${clause}`;
+            params.push(...values);
+        }
+        return { query, params };
+    }
+    /**
+     * Build UPSERT query (INSERT ... ON DUPLICATE KEY UPDATE)
+     */
+    buildUpsertQuery(options) {
+        const data = Array.isArray(options.data) ? options.data[0] : options.data;
+        const columns = Object.keys(data);
+        const params = [];
+        let query = `INSERT INTO \`${options.table}\` (${columns.map((col) => `\`${col}\``).join(', ')}) VALUES (`;
+        query += columns.map(() => '?').join(', ');
+        params.push(...columns.map((col) => data[col]));
+        query += ') ON DUPLICATE KEY UPDATE ';
+        const updateClauses = columns
+            .filter((col) => !options.uniqueColumns.includes(col))
+            .map((col) => `\`${col}\` = VALUES(\`${col}\`)`);
+        query += updateClauses.join(', ');
+        return { query, params };
+    }
+    /**
+     * Build GROUP BY query
+     */
+    buildGroupByQuery(options) {
+        const params = [];
+        const groupColumns = options.groupBy.map((col) => `\`${col}\``);
+        const selectColumns = [...groupColumns];
+        // Build aggregations
+        if (options.aggregate) {
+            Object.entries(options.aggregate).forEach(([alias, agg]) => {
+                const aggObj = agg;
+                if (aggObj.$COUNT !== undefined) {
+                    const column = aggObj.$COUNT === '*' ? '*' : `\`${aggObj.$COUNT}\``;
+                    selectColumns.push(`COUNT(${column}) as \`${alias}\``);
+                }
+                else if (aggObj.$SUM !== undefined) {
+                    selectColumns.push(`SUM(\`${aggObj.$SUM}\`) as \`${alias}\``);
+                }
+                else if (aggObj.$AVG !== undefined) {
+                    selectColumns.push(`AVG(\`${aggObj.$AVG}\`) as \`${alias}\``);
+                }
+                else if (aggObj.$MIN !== undefined) {
+                    selectColumns.push(`MIN(\`${aggObj.$MIN}\`) as \`${alias}\``);
+                }
+                else if (aggObj.$MAX !== undefined) {
+                    selectColumns.push(`MAX(\`${aggObj.$MAX}\`) as \`${alias}\``);
+                }
+                else if (aggObj.$GROUP_CONCAT !== undefined) {
+                    selectColumns.push(`GROUP_CONCAT(\`${aggObj.$GROUP_CONCAT}\`) as \`${alias}\``);
+                }
+            });
+        }
+        let query = `SELECT ${selectColumns.join(', ')} FROM \`${options.table}\``;
+        if (options.where) {
+            const { clause, values } = this.buildWhereClause(options.where);
+            query += ` WHERE ${clause}`;
+            params.push(...values);
+        }
+        query += ` GROUP BY ${groupColumns.join(', ')}`;
+        return { query, params };
+    }
+    /**
+     * Build multi-aggregate query
+     */
+    buildMultiAggregateQuery(options) {
+        const params = [];
+        const aggregations = Object.entries(options.operations).map(([alias, agg]) => {
+            const aggObj = agg;
+            if (aggObj.$COUNT !== undefined) {
+                const column = aggObj.$COUNT === '*' ? '*' : `\`${aggObj.$COUNT}\``;
+                return `COUNT(${column}) as \`${alias}\``;
+            }
+            if (aggObj.$SUM !== undefined) {
+                return `SUM(\`${aggObj.$SUM}\`) as \`${alias}\``;
+            }
+            if (aggObj.$AVG !== undefined) {
+                return `AVG(\`${aggObj.$AVG}\`) as \`${alias}\``;
+            }
+            if (aggObj.$MIN !== undefined) {
+                return `MIN(\`${aggObj.$MIN}\`) as \`${alias}\``;
+            }
+            if (aggObj.$MAX !== undefined) {
+                return `MAX(\`${aggObj.$MAX}\`) as \`${alias}\``;
+            }
+            if (aggObj.$GROUP_CONCAT !== undefined) {
+                return `GROUP_CONCAT(\`${aggObj.$GROUP_CONCAT}\`) as \`${alias}\``;
+            }
+            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.VALIDATION_ERROR, `Invalid aggregation operation for alias "${alias}". Use format: { $COUNT: '*' }, { $SUM: 'column' }, etc.`);
+        });
+        let query = `SELECT ${aggregations.join(', ')} FROM \`${options.table}\``;
+        if (options.where) {
+            const { clause, values } = this.buildWhereClause(options.where);
+            query += ` WHERE ${clause}`;
+            params.push(...values);
+        }
+        return { query, params };
+    }
+    /**
+     * Build CREATE TABLE query
+     */
+    buildCreateTableQuery(schema, options) {
+        const columnDefs = schema.columns.map((col) => {
+            let def = `\`${col.name}\` ${this.mapColumnTypeToMySQL(col.type)}`;
+            if (col.length) {
+                def += `(${col.length})`;
+            }
+            if (col.primaryKey) {
+                def += ' PRIMARY KEY';
+            }
+            if (col.autoIncrement) {
+                def += ' AUTO_INCREMENT';
+            }
+            if (!col.nullable) {
+                def += ' NOT NULL';
+            }
+            if (col.unique) {
+                def += ' UNIQUE';
+            }
+            if (col.defaultValue !== undefined) {
+                def += ` DEFAULT ${this.escapeValue(col.defaultValue)}`;
+            }
+            return def;
+        });
+        let query = `CREATE TABLE ${(options === null || options === void 0 ? void 0 : options.ifNotExists) ? 'IF NOT EXISTS ' : ''}\`${schema.name}\` (${columnDefs.join(', ')})`;
+        return query;
+    }
+    /**
+     * Build ALTER TABLE queries
+     */
+    buildAlterTableQueries(tableName, alterations) {
+        return alterations.map((alt) => {
+            let query = `ALTER TABLE \`${tableName}\` `;
+            switch (alt.type) {
+                case schema_types_1.ColumnAlterationType.ADD:
+                    query += `ADD COLUMN \`${alt.column.name}\` ${this.mapColumnTypeToMySQL(alt.column.type)}`;
+                    if (!alt.column.nullable) {
+                        query += ' NOT NULL';
+                    }
+                    break;
+                case schema_types_1.ColumnAlterationType.DROP:
+                    query += `DROP COLUMN \`${alt.oldName}\``;
+                    break;
+                case schema_types_1.ColumnAlterationType.MODIFY:
+                    query += `MODIFY COLUMN \`${alt.column.name}\` ${this.mapColumnTypeToMySQL(alt.column.type)}`;
+                    break;
+                case schema_types_1.ColumnAlterationType.RENAME:
+                    query += `RENAME COLUMN \`${alt.oldName}\` TO \`${alt.newName}\``;
+                    break;
+            }
+            return query;
+        });
+    }
+    /**
+     * Build CREATE INDEX query
+     */
+    buildCreateIndexQuery(options) {
+        const unique = options.index.unique ? 'UNIQUE ' : '';
+        const columns = options.index.columns.map((col) => `\`${col.name}\``).join(', ');
+        return `CREATE ${unique}INDEX \`${options.index.name}\` ON \`${options.table}\` (${columns})`;
+    }
+    /**
+     * Map ColumnType to MySQL type
+     */
+    mapColumnTypeToMySQL(type) {
+        const typeMap = {
+            [schema_types_1.ColumnType.STRING]: 'VARCHAR',
+            [schema_types_1.ColumnType.TEXT]: 'TEXT',
+            [schema_types_1.ColumnType.VARCHAR]: 'VARCHAR',
+            [schema_types_1.ColumnType.CHAR]: 'CHAR',
+            [schema_types_1.ColumnType.INTEGER]: 'INT',
+            [schema_types_1.ColumnType.BIGINT]: 'BIGINT',
+            [schema_types_1.ColumnType.SMALLINT]: 'SMALLINT',
+            [schema_types_1.ColumnType.DECIMAL]: 'DECIMAL',
+            [schema_types_1.ColumnType.NUMERIC]: 'DECIMAL',
+            [schema_types_1.ColumnType.FLOAT]: 'FLOAT',
+            [schema_types_1.ColumnType.DOUBLE]: 'DOUBLE',
+            [schema_types_1.ColumnType.REAL]: 'FLOAT',
+            [schema_types_1.ColumnType.BOOLEAN]: 'TINYINT',
+            [schema_types_1.ColumnType.DATE]: 'DATE',
+            [schema_types_1.ColumnType.TIME]: 'TIME',
+            [schema_types_1.ColumnType.DATETIME]: 'DATETIME',
+            [schema_types_1.ColumnType.TIMESTAMP]: 'TIMESTAMP',
+            [schema_types_1.ColumnType.JSON]: 'JSON',
+            [schema_types_1.ColumnType.JSONB]: 'JSON',
+            [schema_types_1.ColumnType.UUID]: 'CHAR(36)',
+            [schema_types_1.ColumnType.BLOB]: 'BLOB',
+            [schema_types_1.ColumnType.BINARY]: 'BINARY',
+            [schema_types_1.ColumnType.ARRAY]: 'JSON',
+            [schema_types_1.ColumnType.OBJECT]: 'JSON',
+            [schema_types_1.ColumnType.ENUM]: 'VARCHAR',
+        };
+        return typeMap[type] || 'TEXT';
+    }
+    /**
+     * Map MySQL type to ColumnType
+     */
+    mapMySQLTypeToColumnType(mysqlType) {
+        const typeMap = {
+            varchar: schema_types_1.ColumnType.VARCHAR,
+            text: schema_types_1.ColumnType.TEXT,
+            char: schema_types_1.ColumnType.CHAR,
+            int: schema_types_1.ColumnType.INTEGER,
+            bigint: schema_types_1.ColumnType.BIGINT,
+            smallint: schema_types_1.ColumnType.SMALLINT,
+            decimal: schema_types_1.ColumnType.DECIMAL,
+            float: schema_types_1.ColumnType.FLOAT,
+            double: schema_types_1.ColumnType.DOUBLE,
+            tinyint: schema_types_1.ColumnType.BOOLEAN,
+            date: schema_types_1.ColumnType.DATE,
+            time: schema_types_1.ColumnType.TIME,
+            datetime: schema_types_1.ColumnType.DATETIME,
+            timestamp: schema_types_1.ColumnType.TIMESTAMP,
+            json: schema_types_1.ColumnType.JSON,
+            blob: schema_types_1.ColumnType.BLOB,
+            binary: schema_types_1.ColumnType.BINARY,
+        };
+        return typeMap[mysqlType.toLowerCase()] || schema_types_1.ColumnType.TEXT;
+    }
+    /**
+     * Ensure migration table exists
+     */
+    async ensureMigrationTable(conn) {
+        const query = `
+      CREATE TABLE IF NOT EXISTS _ductape_migrations (
+        tag VARCHAR(255) PRIMARY KEY,
+        name VARCHAR(255) NOT NULL,
+        executed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+        await conn.query(query);
+    }
+    /**
+     * Record migration execution
+     */
+    async recordMigration(conn, migration, direction) {
+        await this.ensureMigrationTable(conn);
+        const query = `
+      INSERT INTO _ductape_migrations (tag, name, executed_at)
+      VALUES (?, ?, CURRENT_TIMESTAMP)
+      ON DUPLICATE KEY UPDATE executed_at = CURRENT_TIMESTAMP
+    `;
+        await conn.query(query, [migration.tag, migration.name]);
+    }
+    /**
+     * Remove migration from history
+     */
+    async removeMigration(conn, tag) {
+        await this.ensureMigrationTable(conn);
+        const query = `DELETE FROM _ductape_migrations WHERE tag = ?`;
+        await conn.query(query, [tag]);
+    }
+    // ==================== Utility Methods ====================
+    /**
+     * Escape identifier (table/column name)
+     */
+    escapeIdentifier(identifier) {
+        return `\`${identifier.replace(/`/g, '``')}\``;
+    }
+    /**
+     * Escape value for SQL
+     */
+    escapeValue(value) {
+        if (value === null || value === undefined) {
+            return 'NULL';
+        }
+        if (typeof value === 'string') {
+            return `'${value.replace(/'/g, "''")}'`;
+        }
+        if (typeof value === 'boolean') {
+            return value ? '1' : '0';
+        }
+        if (value instanceof Date) {
+            return `'${value.toISOString().slice(0, 19).replace('T', ' ')}'`;
+        }
+        if (Array.isArray(value)) {
+            return `'${JSON.stringify(value)}'`;
+        }
+        if (typeof value === 'object') {
+            return `'${JSON.stringify(value)}'`;
+        }
+        return String(value);
+    }
+    /**
+     * Get database version
+     */
+    async getDatabaseVersion(connection) {
+        var _a;
+        try {
+            const conn = connection.getClient();
+            const [rows] = await conn.query('SELECT VERSION() as version');
+            return ((_a = rows[0]) === null || _a === void 0 ? void 0 : _a.version) || 'Unknown';
+        }
+        catch (error) {
+            return 'Unknown';
+        }
+    }
+}
+exports.MySQLAdapter = MySQLAdapter;
+//# sourceMappingURL=mysql.adapter.js.map