@ductape/sdk 0.1.8 → 0.1.9

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

@@ -0,0 +1,1371 @@
+"use strict";
+/**
+ * MySQL Adapter
+ *
+ * Database adapter for MySQL databases using the 'mysql2' library.
+ * Implements all methods from BaseAdapter with MySQL-specific optimizations.
+ */
+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 enums_1 = require("../types/enums");
+const database_error_1 = require("../utils/database-error");
+/**
+ * MySQL database adapter
+ * Provides MySQL-specific implementations for all database operations
+ */
+class MySQLAdapter extends base_adapter_1.BaseAdapter {
+    constructor() {
+        super(...arguments);
+        this.databaseType = enums_1.DatabaseType.MYSQL;
+        this.pool = null;
+    }
+    // ==================== CONNECTION METHODS ====================
+    async connect(options) {
+        try {
+            // Dynamic import of mysql2 to avoid bundling issues
+            const mysql = await Promise.resolve().then(() => __importStar(require('mysql2/promise')));
+            this.connectionUrl = options.connectionUrl;
+            this.connectionOptions = options; // Store for auto-reconnection
+            // Parse connection URL to extract components
+            const url = new URL(options.connectionUrl);
+            const poolConfig = {
+                host: url.hostname,
+                port: parseInt(url.port) || 3306,
+                user: url.username,
+                password: url.password,
+                database: url.pathname.slice(1),
+                waitForConnections: true,
+                connectionLimit: options.poolSize || 10,
+                queueLimit: 0,
+                connectTimeout: options.connectionTimeout || 10000,
+                ssl: options.ssl ? { rejectUnauthorized: false } : undefined,
+            };
+            this.pool = mysql.createPool(poolConfig);
+            // Test the connection
+            const connection = await this.pool.getConnection();
+            const [rows] = await connection.query('SELECT VERSION() as version');
+            connection.release();
+            this.client = this.pool;
+            this.connected = true;
+            return {
+                connected: true,
+                version: rows[0].version,
+            };
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.connectionError(`Failed to connect to MySQL: ${error.message}`, error);
+        }
+    }
+    async testConnection(options) {
+        try {
+            const mysql = await Promise.resolve().then(() => __importStar(require('mysql2/promise')));
+            const url = new URL(options.connectionUrl);
+            const connection = await mysql.createConnection({
+                host: url.hostname,
+                port: parseInt(url.port) || 3306,
+                user: url.username,
+                password: url.password,
+                database: url.pathname.slice(1),
+                connectTimeout: options.connectionTimeout || 5000,
+            });
+            const [rows] = await connection.query('SELECT VERSION() as version');
+            await connection.end();
+            return {
+                connected: true,
+                version: rows[0].version,
+            };
+        }
+        catch (error) {
+            return {
+                connected: false,
+            };
+        }
+    }
+    async disconnect() {
+        if (this.pool) {
+            await this.pool.end();
+            this.pool = null;
+            this.client = null;
+            this.connected = false;
+        }
+    }
+    // ==================== QUERY METHODS ====================
+    async query(query) {
+        var _a, _b;
+        this.ensureConnected();
+        try {
+            const connection = ((_a = query.options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
+            const [rows, fields] = await connection.query(query.sql, query.params);
+            // Get total count if needed for pagination
+            let count = rows.length;
+            if (query.options.limit || query.options.offset) {
+                const countSql = this.buildCountQuery(query);
+                // Calculate how many params to remove based on actual pagination options
+                let paramsToRemove = 0;
+                if (query.options.limit !== undefined)
+                    paramsToRemove++;
+                if (query.options.offset !== undefined)
+                    paramsToRemove++;
+                const countParams = paramsToRemove > 0 ? (_b = query.params) === null || _b === void 0 ? void 0 : _b.slice(0, -paramsToRemove) : query.params;
+                const [countRows] = await connection.query(countSql, countParams);
+                count = countRows[0].count;
+            }
+            return {
+                data: rows,
+                count,
+                fields: fields === null || fields === void 0 ? void 0 : fields.map((f) => f.name),
+            };
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mysql');
+        }
+    }
+    async raw(options) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            var _a;
+            try {
+                const connection = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
+                const [rows, fields] = await connection.query(options.query, options.params);
+                const isArray = Array.isArray(rows);
+                return {
+                    data: (isArray ? rows : []),
+                    count: isArray ? rows.length : 0,
+                    fields: fields === null || fields === void 0 ? void 0 : fields.map((f) => f.name),
+                };
+            }
+            catch (error) {
+                throw database_error_1.DatabaseError.fromDatabaseError(error, 'mysql');
+            }
+        });
+    }
+    // ==================== WRITE METHODS ====================
+    async insert(options) {
+        var _a, _b;
+        this.ensureConnected();
+        try {
+            const connection = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
+            const data = Array.isArray(options.data) ? options.data : [options.data];
+            if (data.length === 0) {
+                return { data: [], count: 0, insertedIds: [] };
+            }
+            const columns = Object.keys(data[0]);
+            const values = [];
+            const valuePlaceholders = [];
+            data.forEach((record) => {
+                const rowPlaceholders = [];
+                columns.forEach((col) => {
+                    let value = record[col];
+                    // Serialize objects and arrays to JSON strings for MySQL JSON columns
+                    if (value !== null && value !== undefined) {
+                        if (Array.isArray(value) || (typeof value === 'object' && !(value instanceof Date))) {
+                            value = JSON.stringify(value);
+                        }
+                    }
+                    values.push(value);
+                    rowPlaceholders.push('?');
+                });
+                valuePlaceholders.push(`(${rowPlaceholders.join(', ')})`);
+            });
+            let sql = `INSERT INTO ${this.escapeIdentifier(options.table)} (${columns.map(c => this.escapeIdentifier(c)).join(', ')}) VALUES ${valuePlaceholders.join(', ')}`;
+            // Handle ON DUPLICATE KEY (upsert)
+            if (options.onConflict) {
+                if (options.onConflict.action === 'ignore') {
+                    sql = sql.replace('INSERT INTO', 'INSERT IGNORE INTO');
+                }
+                else if (options.onConflict.action === 'update' && options.onConflict.update) {
+                    const updates = options.onConflict.update.map(col => `${this.escapeIdentifier(col)} = VALUES(${this.escapeIdentifier(col)})`).join(', ');
+                    sql += ` ON DUPLICATE KEY UPDATE ${updates}`;
+                }
+            }
+            const [result] = await connection.query(sql, values);
+            // Get inserted IDs
+            const insertedIds = [];
+            const insertId = result.insertId;
+            const affectedRows = result.affectedRows;
+            // MySQL's insertId only works for AUTO_INCREMENT columns
+            // If insertId is 0, it means no AUTO_INCREMENT column or value wasn't generated
+            if (insertId > 0) {
+                for (let i = 0; i < data.length; i++) {
+                    insertedIds.push(insertId + i);
+                }
+            }
+            // If returning is requested, fetch the inserted records
+            let returnedData = [];
+            if (options.returning) {
+                // If we have insertedIds from AUTO_INCREMENT, try to find primary key column
+                if (insertedIds.length > 0) {
+                    // Get the primary key column name from the table
+                    const [pkResult] = await connection.query(`SELECT COLUMN_NAME FROM information_schema.KEY_COLUMN_USAGE
+             WHERE TABLE_SCHEMA = DATABASE()
+             AND TABLE_NAME = ?
+             AND CONSTRAINT_NAME = 'PRIMARY'
+             ORDER BY ORDINAL_POSITION LIMIT 1`, [options.table]);
+                    const pkColumn = ((_b = pkResult[0]) === null || _b === void 0 ? void 0 : _b.COLUMN_NAME) || 'id';
+                    const [rows] = await connection.query(`SELECT * FROM ${this.escapeIdentifier(options.table)} WHERE ${this.escapeIdentifier(pkColumn)} IN (?)`, [insertedIds]);
+                    returnedData = rows;
+                }
+                else {
+                    // No AUTO_INCREMENT - fetch by matching the inserted data's values
+                    // Build WHERE clauses to match each inserted record
+                    const whereConditions = [];
+                    const whereValues = [];
+                    for (const record of data) {
+                        const conditions = [];
+                        for (const [col, val] of Object.entries(record)) {
+                            if (val === null) {
+                                conditions.push(`${this.escapeIdentifier(col)} IS NULL`);
+                            }
+                            else if (Array.isArray(val) || (typeof val === 'object' && !(val instanceof Date))) {
+                                // Skip JSON columns in WHERE - they're complex to compare reliably
+                                // The string columns should be enough to identify the record
+                                continue;
+                            }
+                            else if (typeof val === 'boolean') {
+                                // MySQL stores booleans as TINYINT(1), so convert to 1/0
+                                conditions.push(`${this.escapeIdentifier(col)} = ?`);
+                                whereValues.push(val ? 1 : 0);
+                            }
+                            else if (val instanceof Date) {
+                                // For dates, compare as strings to avoid timezone issues
+                                conditions.push(`${this.escapeIdentifier(col)} = ?`);
+                                whereValues.push(val.toISOString().slice(0, 19).replace('T', ' '));
+                            }
+                            else {
+                                conditions.push(`${this.escapeIdentifier(col)} = ?`);
+                                whereValues.push(val);
+                            }
+                        }
+                        if (conditions.length > 0) {
+                            whereConditions.push(`(${conditions.join(' AND ')})`);
+                        }
+                    }
+                    if (whereConditions.length > 0) {
+                        const [rows] = await connection.query(`SELECT * FROM ${this.escapeIdentifier(options.table)} WHERE ${whereConditions.join(' OR ')}`, whereValues);
+                        returnedData = rows;
+                    }
+                }
+            }
+            return {
+                data: returnedData,
+                count: affectedRows,
+                insertedIds,
+            };
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mysql');
+        }
+    }
+    async update(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        this.ensureConnected();
+        try {
+            const connection = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
+            const setClauses = [];
+            const values = [];
+            // Track nested JSON updates to merge them (multiple updates to same column)
+            const jsonSetUpdates = new Map();
+            // Build SET clause
+            for (const [key, value] of Object.entries(options.data)) {
+                // Check if this is a nested JSON path (e.g., 'metadata.preferences.notifications')
+                if (key.includes('.') && !this.isUpdateOperator(value)) {
+                    const parts = key.split('.');
+                    const column = parts[0];
+                    const jsonPath = '$.' + parts.slice(1).join('.');
+                    // Collect nested updates for the same column
+                    if (!jsonSetUpdates.has(column)) {
+                        jsonSetUpdates.set(column, []);
+                    }
+                    jsonSetUpdates.get(column).push({ path: jsonPath, value });
+                    continue;
+                }
+                if (value && typeof value === 'object' && this.isUpdateOperator(value)) {
+                    // Handle update operators - support both lowercase (new) and uppercase (legacy)
+                    if ('$inc' in value || '$INC' in value) {
+                        setClauses.push(`${this.escapeIdentifier(key)} = ${this.escapeIdentifier(key)} + ?`);
+                        values.push((_b = value.$inc) !== null && _b !== void 0 ? _b : value.$INC);
+                    }
+                    else if ('$dec' in value || '$DEC' in value) {
+                        setClauses.push(`${this.escapeIdentifier(key)} = ${this.escapeIdentifier(key)} - ?`);
+                        values.push((_c = value.$dec) !== null && _c !== void 0 ? _c : value.$DEC);
+                    }
+                    else if ('$mul' in value || '$MUL' in value) {
+                        setClauses.push(`${this.escapeIdentifier(key)} = ${this.escapeIdentifier(key)} * ?`);
+                        values.push((_d = value.$mul) !== null && _d !== void 0 ? _d : value.$MUL);
+                    }
+                    else if ('$min' in value || '$MIN' in value) {
+                        // LEAST function for minimum
+                        setClauses.push(`${this.escapeIdentifier(key)} = LEAST(${this.escapeIdentifier(key)}, ?)`);
+                        values.push((_e = value.$min) !== null && _e !== void 0 ? _e : value.$MIN);
+                    }
+                    else if ('$max' in value || '$MAX' in value) {
+                        // GREATEST function for maximum
+                        setClauses.push(`${this.escapeIdentifier(key)} = GREATEST(${this.escapeIdentifier(key)}, ?)`);
+                        values.push((_f = value.$max) !== null && _f !== void 0 ? _f : value.$MAX);
+                    }
+                    else if ('$set' in value || '$SET' in value) {
+                        setClauses.push(`${this.escapeIdentifier(key)} = ?`);
+                        values.push((_g = value.$set) !== null && _g !== void 0 ? _g : value.$SET);
+                    }
+                    else if (('$unset' in value && value.$unset) || ('$UNSET' in value && value.$UNSET)) {
+                        setClauses.push(`${this.escapeIdentifier(key)} = NULL`);
+                    }
+                    else if ('$push' in value || '$PUSH' in value) {
+                        // JSON array append for MySQL (column must be JSON type)
+                        setClauses.push(`${this.escapeIdentifier(key)} = JSON_ARRAY_APPEND(COALESCE(${this.escapeIdentifier(key)}, '[]'), '$', ?)`);
+                        values.push((_h = value.$push) !== null && _h !== void 0 ? _h : value.$PUSH);
+                    }
+                    else if ('$pull' in value || '$PULL' in value) {
+                        // JSON array remove for MySQL - requires JSON_REMOVE with path, complex operation
+                        // For simplicity, use JSON_REMOVE with search
+                        setClauses.push(`${this.escapeIdentifier(key)} = JSON_REMOVE(${this.escapeIdentifier(key)}, JSON_UNQUOTE(JSON_SEARCH(${this.escapeIdentifier(key)}, 'one', ?)))`);
+                        values.push((_j = value.$pull) !== null && _j !== void 0 ? _j : value.$PULL);
+                    }
+                    else if ('$addToSet' in value || '$ADDTOSET' in value) {
+                        // Add unique to JSON array - use IF to check existence
+                        const addValue = (_k = value.$addToSet) !== null && _k !== void 0 ? _k : value.$ADDTOSET;
+                        setClauses.push(`${this.escapeIdentifier(key)} = IF(JSON_CONTAINS(COALESCE(${this.escapeIdentifier(key)}, '[]'), JSON_QUOTE(?)), ${this.escapeIdentifier(key)}, JSON_ARRAY_APPEND(COALESCE(${this.escapeIdentifier(key)}, '[]'), '$', ?))`);
+                        values.push(addValue, addValue);
+                    }
+                    else if ('$currentDate' in value || '$CURRENTDATE' in value) {
+                        setClauses.push(`${this.escapeIdentifier(key)} = NOW()`);
+                    }
+                }
+                else {
+                    setClauses.push(`${this.escapeIdentifier(key)} = ?`);
+                    values.push(value);
+                }
+            }
+            // Build JSON_SET clauses for nested JSON updates
+            for (const [column, updates] of jsonSetUpdates) {
+                // Build nested JSON_SET calls for multiple updates to the same column
+                // MySQL's JSON_SET can take multiple path-value pairs
+                let setExpr = `COALESCE(${this.escapeIdentifier(column)}, '{}')`;
+                const pathValuePairs = [];
+                for (const update of updates) {
+                    pathValuePairs.push(`'${update.path}', CAST(? AS JSON)`);
+                    values.push(JSON.stringify(update.value));
+                }
+                setExpr = `JSON_SET(${setExpr}, ${pathValuePairs.join(', ')})`;
+                setClauses.push(`${this.escapeIdentifier(column)} = ${setExpr}`);
+            }
+            let sql = `UPDATE ${this.escapeIdentifier(options.table)} SET ${setClauses.join(', ')}`;
+            // Build WHERE clause - required for UPDATE to prevent accidental mass updates
+            if (options.where && Object.keys(options.where).length > 0) {
+                const { whereClause, whereParams } = this.buildWhereClause(options.where);
+                // Only add WHERE if we have a non-empty clause
+                if (whereClause && whereClause.trim() !== '') {
+                    sql += ` WHERE ${whereClause}`;
+                    values.push(...whereParams);
+                }
+                else {
+                    // Empty where object - throw error to prevent updating all rows
+                    throw new database_error_1.DatabaseError('UPDATE operation requires a valid WHERE clause to prevent accidental mass updates', enums_1.DatabaseErrorType.VALIDATION_ERROR);
+                }
+            }
+            else {
+                // No where clause provided - this would update all rows, which is dangerous
+                throw new database_error_1.DatabaseError('UPDATE operation requires a WHERE clause to prevent accidental mass updates. Provide a where clause with at least one condition.', enums_1.DatabaseErrorType.VALIDATION_ERROR);
+            }
+            const [result] = await connection.query(sql, values);
+            const affectedRows = result.affectedRows;
+            // If returning is requested, fetch updated records
+            let returnedData = [];
+            if (options.returning && options.where) {
+                const { whereClause, whereParams } = this.buildWhereClause(options.where);
+                const [rows] = await connection.query(`SELECT * FROM ${this.escapeIdentifier(options.table)} WHERE ${whereClause}`, whereParams);
+                returnedData = rows;
+            }
+            return {
+                data: returnedData,
+                count: affectedRows,
+            };
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mysql');
+        }
+    }
+    async delete(options) {
+        var _a;
+        this.ensureConnected();
+        try {
+            const connection = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
+            let sql = `DELETE FROM ${this.escapeIdentifier(options.table)}`;
+            const values = [];
+            // Fetch records before delete if returning is requested
+            let deletedData;
+            if (options.returning && options.where) {
+                const { whereClause, whereParams } = this.buildWhereClause(options.where);
+                const [rows] = await connection.query(`SELECT * FROM ${this.escapeIdentifier(options.table)} WHERE ${whereClause}`, whereParams);
+                deletedData = rows;
+            }
+            // Build WHERE clause
+            if (options.where) {
+                const { whereClause, whereParams } = this.buildWhereClause(options.where);
+                sql += ` WHERE ${whereClause}`;
+                values.push(...whereParams);
+            }
+            const [result] = await connection.query(sql, values);
+            return {
+                count: result.affectedRows,
+                data: deletedData,
+            };
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mysql');
+        }
+    }
+    async upsert(options) {
+        this.ensureConnected();
+        try {
+            const insertResult = await this.insert(Object.assign(Object.assign({}, options), { onConflict: {
+                    columns: options.conflictKeys,
+                    action: 'update',
+                    update: options.updateColumns || Object.keys(options.data).filter(k => !options.conflictKeys.includes(k)),
+                }, returning: true }));
+            return {
+                data: insertResult.data,
+                count: insertResult.count,
+                operation: insertResult.count > 0 ? 'inserted' : 'updated',
+            };
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mysql');
+        }
+    }
+    // ==================== AGGREGATION METHODS ====================
+    async count(options) {
+        var _a;
+        this.ensureConnected();
+        try {
+            const connection = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
+            const column = options.column ? this.escapeIdentifier(options.column) : '*';
+            const distinctPrefix = options.distinct ? 'DISTINCT ' : '';
+            let sql = `SELECT COUNT(${distinctPrefix}${column}) as count FROM ${this.escapeIdentifier(options.table)}`;
+            const values = [];
+            if (options.where) {
+                const { whereClause, whereParams } = this.buildWhereClause(options.where);
+                sql += ` WHERE ${whereClause}`;
+                values.push(...whereParams);
+            }
+            const [rows] = await connection.query(sql, values);
+            return rows[0].count;
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mysql');
+        }
+    }
+    async sum(options) {
+        var _a;
+        this.ensureConnected();
+        try {
+            const connection = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
+            let sql = `SELECT COALESCE(SUM(${this.escapeIdentifier(options.column)}), 0) as sum FROM ${this.escapeIdentifier(options.table)}`;
+            const values = [];
+            if (options.where) {
+                const { whereClause, whereParams } = this.buildWhereClause(options.where);
+                sql += ` WHERE ${whereClause}`;
+                values.push(...whereParams);
+            }
+            const [rows] = await connection.query(sql, values);
+            return parseFloat(rows[0].sum);
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mysql');
+        }
+    }
+    async avg(options) {
+        var _a;
+        this.ensureConnected();
+        try {
+            const connection = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
+            let sql = `SELECT COALESCE(AVG(${this.escapeIdentifier(options.column)}), 0) as avg FROM ${this.escapeIdentifier(options.table)}`;
+            const values = [];
+            if (options.where) {
+                const { whereClause, whereParams } = this.buildWhereClause(options.where);
+                sql += ` WHERE ${whereClause}`;
+                values.push(...whereParams);
+            }
+            const [rows] = await connection.query(sql, values);
+            return parseFloat(rows[0].avg);
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mysql');
+        }
+    }
+    async min(options) {
+        var _a;
+        this.ensureConnected();
+        try {
+            const connection = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
+            let sql = `SELECT MIN(${this.escapeIdentifier(options.column)}) as min FROM ${this.escapeIdentifier(options.table)}`;
+            const values = [];
+            if (options.where) {
+                const { whereClause, whereParams } = this.buildWhereClause(options.where);
+                sql += ` WHERE ${whereClause}`;
+                values.push(...whereParams);
+            }
+            const [rows] = await connection.query(sql, values);
+            return rows[0].min;
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mysql');
+        }
+    }
+    async max(options) {
+        var _a;
+        this.ensureConnected();
+        try {
+            const connection = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
+            let sql = `SELECT MAX(${this.escapeIdentifier(options.column)}) as max FROM ${this.escapeIdentifier(options.table)}`;
+            const values = [];
+            if (options.where) {
+                const { whereClause, whereParams } = this.buildWhereClause(options.where);
+                sql += ` WHERE ${whereClause}`;
+                values.push(...whereParams);
+            }
+            const [rows] = await connection.query(sql, values);
+            return rows[0].max;
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mysql');
+        }
+    }
+    async aggregate(builtAggregation) {
+        var _a;
+        this.ensureConnected();
+        try {
+            const connection = ((_a = builtAggregation.options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
+            const [rows] = await connection.query(builtAggregation.sql, builtAggregation.params);
+            return rows[0] || {};
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mysql');
+        }
+    }
+    async groupBy(builtGroupBy) {
+        var _a;
+        this.ensureConnected();
+        try {
+            const connection = ((_a = builtGroupBy.options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
+            const [rows] = await connection.query(builtGroupBy.sql, builtGroupBy.params);
+            // Transform rows into IGroupByResult format
+            const options = builtGroupBy.options;
+            return rows.map((row) => {
+                var _a;
+                const group = {};
+                const aggregates = {};
+                for (const key of Object.keys(row)) {
+                    if ((_a = options.groupBy) === null || _a === void 0 ? void 0 : _a.includes(key)) {
+                        group[key] = row[key];
+                    }
+                    else {
+                        aggregates[key] = row[key];
+                    }
+                }
+                return { group, aggregates: aggregates };
+            });
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'mysql');
+        }
+    }
+    // ==================== TRANSACTION METHODS ====================
+    async beginTransaction(isolationLevel, readOnly, timeout) {
+        this.ensureConnected();
+        try {
+            const connection = await this.pool.getConnection();
+            const id = `mysql_txn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+            // Set isolation level if specified
+            if (isolationLevel) {
+                await connection.query(`SET TRANSACTION ISOLATION LEVEL ${this.mapIsolationLevel(isolationLevel)}`);
+            }
+            // Set read-only if specified
+            if (readOnly) {
+                await connection.query('SET TRANSACTION READ ONLY');
+            }
+            // Begin transaction
+            await connection.query('START TRANSACTION');
+            // Set timeout if specified
+            if (timeout) {
+                await connection.query(`SET SESSION MAX_EXECUTION_TIME = ${timeout}`);
+            }
+            return {
+                id,
+                databaseType: 'mysql',
+                isolationLevel: isolationLevel || enums_1.IsolationLevel.READ_COMMITTED,
+                readOnly: readOnly || false,
+                timeout,
+                startedAt: new Date(),
+                client: connection,
+                savepoints: new Map(),
+                status: 'active',
+            };
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.transactionError(`Failed to begin transaction: ${error.message}`, error);
+        }
+    }
+    async commitTransaction(context) {
+        try {
+            await context.client.query('COMMIT');
+            context.client.release();
+            context.status = 'committed';
+        }
+        catch (error) {
+            context.status = 'error';
+            context.client.release();
+            throw database_error_1.DatabaseError.transactionError(`Failed to commit transaction: ${error.message}`, error);
+        }
+    }
+    async rollbackTransaction(context) {
+        try {
+            await context.client.query('ROLLBACK');
+            context.client.release();
+            context.status = 'rolled_back';
+        }
+        catch (error) {
+            context.status = 'error';
+            context.client.release();
+            throw database_error_1.DatabaseError.transactionError(`Failed to rollback transaction: ${error.message}`, error);
+        }
+    }
+    async createSavepoint(context, name) {
+        try {
+            await context.client.query(`SAVEPOINT ${this.escapeIdentifier(name)}`);
+            const savepoint = {
+                name,
+                release: async () => {
+                    await this.releaseSavepoint(context, savepoint);
+                },
+                rollback: async () => {
+                    await this.rollbackToSavepoint(context, savepoint);
+                },
+            };
+            context.savepoints.set(name, savepoint);
+            return savepoint;
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.transactionError(`Failed to create savepoint: ${error.message}`, error);
+        }
+    }
+    async releaseSavepoint(context, savepoint) {
+        try {
+            await context.client.query(`RELEASE SAVEPOINT ${this.escapeIdentifier(savepoint.name)}`);
+            context.savepoints.delete(savepoint.name);
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.transactionError(`Failed to release savepoint: ${error.message}`, error);
+        }
+    }
+    async rollbackToSavepoint(context, savepoint) {
+        try {
+            await context.client.query(`ROLLBACK TO SAVEPOINT ${this.escapeIdentifier(savepoint.name)}`);
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.transactionError(`Failed to rollback to savepoint: ${error.message}`, error);
+        }
+    }
+    supportsSavepoints() {
+        return true;
+    }
+    // ==================== SCHEMA METHODS ====================
+    async createTable(definition, options) {
+        this.ensureConnected();
+        try {
+            const columnDefs = definition.columns.map(col => this.buildColumnDefinition(col)).join(', ');
+            let sql = 'CREATE';
+            if (options === null || options === void 0 ? void 0 : options.temporary)
+                sql += ' TEMPORARY';
+            sql += ' TABLE';
+            if (options === null || options === void 0 ? void 0 : options.ifNotExists)
+                sql += ' IF NOT EXISTS';
+            sql += ` ${this.escapeIdentifier(definition.name)} (${columnDefs}`;
+            // Add table constraints
+            if (definition.constraints) {
+                const constraintDefs = definition.constraints.map(c => this.buildConstraintDefinition(c)).join(', ');
+                sql += `, ${constraintDefs}`;
+            }
+            sql += ') ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci';
+            // Add table comment
+            if (definition.comment) {
+                sql += ` COMMENT=${this.escapeValue(definition.comment)}`;
+            }
+            await this.pool.query(sql);
+            // Create indexes
+            if (definition.indexes) {
+                for (const index of definition.indexes) {
+                    await this.createIndex(index);
+                }
+            }
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.schemaError(`Failed to create table: ${error.message}`, error);
+        }
+    }
+    async alterTable(tableName, operations) {
+        this.ensureConnected();
+        try {
+            for (const op of operations) {
+                let sql = `ALTER TABLE ${this.escapeIdentifier(tableName)}`;
+                switch (op.type) {
+                    case 'ADD':
+                        if (op.column) {
+                            sql += ` ADD COLUMN ${this.buildColumnDefinition(op.column)}`;
+                        }
+                        else if (op.constraint) {
+                            sql += ` ADD ${this.buildConstraintDefinition(op.constraint)}`;
+                        }
+                        break;
+                    case 'DROP':
+                        if (op.columnName) {
+                            sql += ` DROP COLUMN ${this.escapeIdentifier(op.columnName)}`;
+                        }
+                        else if (op.constraintName) {
+                            sql += ` DROP CONSTRAINT ${this.escapeIdentifier(op.constraintName)}`;
+                        }
+                        break;
+                    case 'MODIFY':
+                        if (op.column) {
+                            sql += ` MODIFY COLUMN ${this.buildColumnDefinition(op.column)}`;
+                        }
+                        break;
+                    case 'RENAME':
+                        if (op.oldName && op.newName) {
+                            sql += ` RENAME COLUMN ${this.escapeIdentifier(op.oldName)} TO ${this.escapeIdentifier(op.newName)}`;
+                        }
+                        break;
+                }
+                await this.pool.query(sql);
+            }
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.schemaError(`Failed to alter table: ${error.message}`, error);
+        }
+    }
+    async dropTable(tableName, ifExists, cascade) {
+        this.ensureConnected();
+        try {
+            let sql = 'DROP TABLE';
+            if (ifExists)
+                sql += ' IF EXISTS';
+            sql += ` ${this.escapeIdentifier(tableName)}`;
+            // MySQL doesn't support CASCADE in DROP TABLE
+            await this.pool.query(sql);
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.schemaError(`Failed to drop table: ${error.message}`, error);
+        }
+    }
+    async listTables() {
+        this.ensureConnected();
+        try {
+            const [rows] = await this.pool.query('SHOW TABLES');
+            return rows.map((r) => Object.values(r)[0]);
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.schemaError(`Failed to list tables: ${error.message}`, error);
+        }
+    }
+    async listTablesWithInfo() {
+        this.ensureConnected();
+        try {
+            const [rows] = await this.pool.query(`
+        SELECT
+          t.table_name as name,
+          t.table_schema as \`schema\`,
+          t.table_rows as estimated_row_count,
+          t.table_comment as comment
+        FROM information_schema.tables t
+        WHERE t.table_schema = DATABASE()
+          AND t.table_type = 'BASE TABLE'
+        ORDER BY t.table_name
+      `);
+            return rows.map((r) => ({
+                name: r.name,
+                schema: r.schema,
+                estimatedRowCount: r.estimated_row_count != null ? Number(r.estimated_row_count) : undefined,
+                comment: r.comment || undefined,
+            }));
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.schemaError(`Failed to list tables with info: ${error.message}`, error);
+        }
+    }
+    async tableExists(tableName) {
+        this.ensureConnected();
+        try {
+            const [rows] = await this.pool.query(`SELECT COUNT(*) as count FROM information_schema.tables WHERE table_schema = DATABASE() AND table_name = ?`, [tableName]);
+            return rows[0].count > 0;
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.schemaError(`Failed to check table existence: ${error.message}`, error);
+        }
+    }
+    async getTableSchema(tableName) {
+        this.ensureConnected();
+        try {
+            // Get columns
+            const [columns] = await this.pool.query(`SELECT
+          COLUMN_NAME as name,
+          DATA_TYPE as type,
+          IS_NULLABLE = 'YES' as nullable,
+          COLUMN_DEFAULT as default_value,
+          CHARACTER_MAXIMUM_LENGTH as max_length,
+          NUMERIC_PRECISION as \`precision\`,
+          NUMERIC_SCALE as scale,
+          COLUMN_KEY = 'PRI' as is_primary_key,
+          COLUMN_KEY = 'UNI' as is_unique,
+          EXTRA LIKE '%auto_increment%' as is_auto_increment,
+          COLUMN_COMMENT as comment
+        FROM information_schema.columns
+        WHERE table_schema = DATABASE() AND table_name = ?
+        ORDER BY ordinal_position`, [tableName]);
+            // Get primary key
+            const primaryKey = columns
+                .filter((c) => c.is_primary_key)
+                .map((c) => c.name);
+            // Get indexes
+            const indexes = await this.listIndexes(tableName);
+            // Get constraints
+            const [constraintRows] = await this.pool.query(`SELECT
+          CONSTRAINT_NAME as name,
+          CONSTRAINT_TYPE as type
+        FROM information_schema.table_constraints
+        WHERE table_schema = DATABASE() AND table_name = ?`, [tableName]);
+            const columnInfos = columns.map((col) => ({
+                name: col.name,
+                type: col.type,
+                nullable: !!col.nullable,
+                defaultValue: col.default_value,
+                isPrimaryKey: !!col.is_primary_key,
+                isUnique: !!col.is_unique,
+                isAutoIncrement: !!col.is_auto_increment,
+                maxLength: col.max_length,
+                precision: col.precision,
+                scale: col.scale,
+                comment: col.comment || undefined,
+            }));
+            const constraints = constraintRows.map((c) => ({
+                name: c.name,
+                type: c.type,
+                columns: [], // Would need additional query to get columns
+            }));
+            return {
+                name: tableName,
+                columns: columnInfos,
+                indexes,
+                constraints,
+                primaryKey: primaryKey.length > 0 ? primaryKey : undefined,
+            };
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.schemaError(`Failed to get table schema: ${error.message}`, error);
+        }
+    }
+    async createIndex(index, ifNotExists, concurrent) {
+        this.ensureConnected();
+        try {
+            let sql = 'CREATE';
+            if (index.unique)
+                sql += ' UNIQUE';
+            // Index type for MySQL
+            if (index.method === 'FULLTEXT') {
+                sql += ' FULLTEXT';
+            }
+            else if (index.method === 'SPATIAL') {
+                sql += ' SPATIAL';
+            }
+            sql += ' INDEX';
+            sql += ` ${this.escapeIdentifier(index.name)} ON ${this.escapeIdentifier(index.table)}`;
+            // Add columns
+            const columnDefs = index.columns.map(col => {
+                let def = this.escapeIdentifier(col.name);
+                if (col.order)
+                    def += ` ${col.order}`;
+                return def;
+            }).join(', ');
+            sql += ` (${columnDefs})`;
+            // Add index type (BTREE, HASH)
+            if (index.method && !['FULLTEXT', 'SPATIAL'].includes(index.method)) {
+                sql += ` USING ${index.method}`;
+            }
+            // Add comment
+            if (index.comment) {
+                sql += ` COMMENT ${this.escapeValue(index.comment)}`;
+            }
+            await this.pool.query(sql);
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.schemaError(`Failed to create index: ${error.message}`, error);
+        }
+    }
+    async dropIndex(tableName, indexName, ifExists, concurrent, cascade) {
+        this.ensureConnected();
+        try {
+            let sql = `DROP INDEX ${this.escapeIdentifier(indexName)} ON ${this.escapeIdentifier(tableName)}`;
+            await this.pool.query(sql);
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.schemaError(`Failed to drop index: ${error.message}`, error);
+        }
+    }
+    async listIndexes(tableName, includeSystem) {
+        this.ensureConnected();
+        try {
+            const [rows] = await this.pool.query(`SHOW INDEX FROM ${this.escapeIdentifier(tableName)}`);
+            // Group by index name
+            const indexMap = new Map();
+            for (const row of rows) {
+                const indexName = row.Key_name;
+                if (!indexMap.has(indexName)) {
+                    indexMap.set(indexName, {
+                        name: indexName,
+                        table: tableName,
+                        columns: [],
+                        unique: !row.Non_unique,
+                        primaryKey: indexName === 'PRIMARY',
+                        type: row.Index_type,
+                    });
+                }
+                indexMap.get(indexName).columns.push(row.Column_name);
+            }
+            return Array.from(indexMap.values());
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.schemaError(`Failed to list indexes: ${error.message}`, error);
+        }
+    }
+    async getIndexStatistics(tableName, indexName) {
+        this.ensureConnected();
+        try {
+            let sql = `
+        SELECT
+          index_name,
+          table_name,
+          stat_value * @@innodb_page_size as size_bytes
+        FROM mysql.innodb_index_stats
+        WHERE database_name = DATABASE() AND table_name = ? AND stat_name = 'size'
+      `;
+            const params = [tableName];
+            if (indexName) {
+                sql += ` AND index_name = ?`;
+                params.push(indexName);
+            }
+            const [rows] = await this.pool.query(sql, params);
+            return rows.map((row) => ({
+                indexName: row.index_name,
+                tableName: row.table_name,
+                scans: 0, // MySQL doesn't provide this easily
+                tuplesRead: 0,
+                sizeBytes: parseInt(row.size_bytes, 10) || 0,
+                sizeFormatted: this.formatBytes(parseInt(row.size_bytes, 10) || 0),
+            }));
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.schemaError(`Failed to get index statistics: ${error.message}`, error);
+        }
+    }
+    // ==================== UTILITY METHODS ====================
+    escapeIdentifier(identifier) {
+        // MySQL uses backticks for identifiers
+        return `\`${identifier.replace(/`/g, '``')}\``;
+    }
+    escapeValue(value) {
+        if (value === null || value === undefined) {
+            return 'NULL';
+        }
+        if (typeof value === 'number') {
+            return String(value);
+        }
+        if (typeof value === 'boolean') {
+            return value ? '1' : '0';
+        }
+        if (value instanceof Date) {
+            return `'${value.toISOString().slice(0, 19).replace('T', ' ')}'`;
+        }
+        if (typeof value === 'object') {
+            return `'${JSON.stringify(value).replace(/'/g, "''")}'`;
+        }
+        // String - escape single quotes
+        return `'${String(value).replace(/'/g, "''")}'`;
+    }
+    /**
+     * Check if value is an update operator object
+     * Supports both lowercase (new) and uppercase (legacy) operators
+     */
+    isUpdateOperator(value) {
+        if (!value || typeof value !== 'object')
+            return false;
+        // Support both lowercase (Mongoose style) and uppercase (legacy) operators
+        const operators = [
+            '$inc', '$INC', '$dec', '$DEC', '$mul', '$MUL', '$min', '$MIN', '$max', '$MAX',
+            '$set', '$SET', '$unset', '$UNSET', '$push', '$PUSH', '$pull', '$PULL',
+            '$addToSet', '$ADDTOSET', '$currentDate', '$CURRENTDATE'
+        ];
+        return operators.some(op => op in value);
+    }
+    getParameterPlaceholder(index) {
+        // MySQL uses ? for all parameters
+        return '?';
+    }
+    getColumnTypeString(columnType, options) {
+        const typeMap = {
+            [enums_1.ColumnType.INTEGER]: 'INT',
+            [enums_1.ColumnType.BIGINT]: 'BIGINT',
+            [enums_1.ColumnType.SMALLINT]: 'SMALLINT',
+            [enums_1.ColumnType.FLOAT]: 'FLOAT',
+            [enums_1.ColumnType.DOUBLE]: 'DOUBLE',
+            [enums_1.ColumnType.DECIMAL]: (options === null || options === void 0 ? void 0 : options.precision)
+                ? `DECIMAL(${options.precision}${options.scale ? `, ${options.scale}` : ''})`
+                : 'DECIMAL(10,2)',
+            [enums_1.ColumnType.STRING]: (options === null || options === void 0 ? void 0 : options.maxLength) ? `VARCHAR(${options.maxLength})` : 'VARCHAR(255)',
+            [enums_1.ColumnType.TEXT]: 'TEXT',
+            [enums_1.ColumnType.BOOLEAN]: 'TINYINT(1)',
+            [enums_1.ColumnType.DATE]: 'DATE',
+            [enums_1.ColumnType.DATETIME]: 'DATETIME',
+            [enums_1.ColumnType.TIMESTAMP]: 'TIMESTAMP',
+            [enums_1.ColumnType.TIME]: 'TIME',
+            [enums_1.ColumnType.JSON]: 'JSON',
+            [enums_1.ColumnType.JSONB]: 'JSON', // MySQL uses JSON for both
+            [enums_1.ColumnType.UUID]: 'CHAR(36)',
+            [enums_1.ColumnType.BINARY]: 'BLOB',
+            [enums_1.ColumnType.ENUM]: (options === null || options === void 0 ? void 0 : options.enumValues)
+                ? `ENUM(${options.enumValues.map(v => `'${v}'`).join(', ')})`
+                : 'VARCHAR(255)',
+            [enums_1.ColumnType.ARRAY]: 'JSON', // MySQL doesn't have native arrays, use JSON
+        };
+        return typeMap[columnType] || columnType;
+    }
+    getSupportedFeatures() {
+        return [
+            base_adapter_1.DatabaseFeature.TRANSACTIONS,
+            base_adapter_1.DatabaseFeature.SAVEPOINTS,
+            base_adapter_1.DatabaseFeature.JSON,
+            base_adapter_1.DatabaseFeature.FULLTEXT_SEARCH,
+            base_adapter_1.DatabaseFeature.HASH_INDEX,
+            base_adapter_1.DatabaseFeature.UPSERT,
+            base_adapter_1.DatabaseFeature.FOREIGN_KEYS,
+            base_adapter_1.DatabaseFeature.CHECK_CONSTRAINTS,
+            base_adapter_1.DatabaseFeature.STORED_PROCEDURES,
+            base_adapter_1.DatabaseFeature.VIEWS,
+            base_adapter_1.DatabaseFeature.TRIGGERS,
+            base_adapter_1.DatabaseFeature.LIKE,
+            base_adapter_1.DatabaseFeature.BETWEEN,
+            base_adapter_1.DatabaseFeature.LIMIT_OFFSET,
+            base_adapter_1.DatabaseFeature.WINDOW_FUNCTIONS,
+            base_adapter_1.DatabaseFeature.CTE,
+        ];
+    }
+    parseError(error) {
+        const code = error.code || error.errno;
+        let type = enums_1.DatabaseErrorType.UNKNOWN_ERROR;
+        // Map MySQL error codes
+        switch (code) {
+            case 'ER_DUP_ENTRY':
+            case 1062:
+                type = enums_1.DatabaseErrorType.UNIQUE_VIOLATION;
+                break;
+            case 'ER_ROW_IS_REFERENCED':
+            case 'ER_NO_REFERENCED_ROW':
+            case 1451:
+            case 1452:
+                type = enums_1.DatabaseErrorType.FOREIGN_KEY_VIOLATION;
+                break;
+            case 'ER_BAD_NULL_ERROR':
+            case 1048:
+                type = enums_1.DatabaseErrorType.NOT_NULL_VIOLATION;
+                break;
+            case 'ER_ACCESS_DENIED_ERROR':
+            case 1045:
+                type = enums_1.DatabaseErrorType.AUTHENTICATION_ERROR;
+                break;
+            case 'ER_NO_SUCH_TABLE':
+            case 1146:
+                type = enums_1.DatabaseErrorType.SCHEMA_ERROR;
+                break;
+            case 'ECONNREFUSED':
+            case 'ETIMEDOUT':
+                type = enums_1.DatabaseErrorType.CONNECTION_ERROR;
+                break;
+            default:
+                if (typeof code === 'string' && code.startsWith('ER_')) {
+                    type = enums_1.DatabaseErrorType.QUERY_ERROR;
+                }
+        }
+        return {
+            type,
+            message: error.message || 'Unknown database error',
+            code: String(code),
+            details: {
+                sqlState: error.sqlState,
+                sqlMessage: error.sqlMessage,
+            },
+        };
+    }
+    // ==================== PRIVATE HELPER METHODS ====================
+    ensureConnected() {
+        if (!this.connected || !this.pool) {
+            throw new database_error_1.DatabaseError('Not connected to MySQL database', enums_1.DatabaseErrorType.CONNECTION_ERROR);
+        }
+    }
+    buildWhereClause(where) {
+        const clauses = [];
+        const params = [];
+        for (const [key, value] of Object.entries(where)) {
+            // Normalize key to lowercase for logical operators (support both cases for backwards compatibility)
+            const normalizedKey = key.toLowerCase();
+            if (normalizedKey === '$and') {
+                const conditions = Array.isArray(value) ? value : [value];
+                const andClauses = [];
+                for (const cond of conditions) {
+                    const andResult = this.buildWhereClause(cond);
+                    andClauses.push(andResult.whereClause);
+                    params.push(...andResult.whereParams);
+                }
+                clauses.push(`(${andClauses.join(' AND ')})`);
+            }
+            else if (normalizedKey === '$or') {
+                const conditions = Array.isArray(value) ? value : Object.entries(value).map(([k, v]) => ({ [k]: v }));
+                const orClauses = [];
+                for (const cond of conditions) {
+                    const orResult = this.buildWhereClause(cond);
+                    orClauses.push(orResult.whereClause);
+                    params.push(...orResult.whereParams);
+                }
+                clauses.push(`(${orClauses.join(' OR ')})`);
+            }
+            else if (normalizedKey === '$not') {
+                const notResult = this.buildWhereClause(value);
+                clauses.push(`NOT (${notResult.whereClause})`);
+                params.push(...notResult.whereParams);
+            }
+            else if (normalizedKey === '$nor') {
+                const conditions = Array.isArray(value) ? value : [value];
+                const norClauses = [];
+                for (const cond of conditions) {
+                    const norResult = this.buildWhereClause(cond);
+                    norClauses.push(norResult.whereClause);
+                    params.push(...norResult.whereParams);
+                }
+                clauses.push(`NOT (${norClauses.join(' OR ')})`);
+            }
+            else if (value !== null && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)) {
+                // Handle operators
+                for (const [op, opValue] of Object.entries(value)) {
+                    // Normalize operator to lowercase (support both cases for backwards compatibility)
+                    const normalizedOp = op.toLowerCase();
+                    switch (normalizedOp) {
+                        case '$eq':
+                            clauses.push(`${this.escapeIdentifier(key)} = ?`);
+                            params.push(opValue);
+                            break;
+                        case '$ne':
+                            clauses.push(`${this.escapeIdentifier(key)} != ?`);
+                            params.push(opValue);
+                            break;
+                        case '$gt':
+                            clauses.push(`${this.escapeIdentifier(key)} > ?`);
+                            params.push(opValue);
+                            break;
+                        case '$gte':
+                            clauses.push(`${this.escapeIdentifier(key)} >= ?`);
+                            params.push(opValue);
+                            break;
+                        case '$lt':
+                            clauses.push(`${this.escapeIdentifier(key)} < ?`);
+                            params.push(opValue);
+                            break;
+                        case '$lte':
+                            clauses.push(`${this.escapeIdentifier(key)} <= ?`);
+                            params.push(opValue);
+                            break;
+                        case '$in':
+                            clauses.push(`${this.escapeIdentifier(key)} IN (?)`);
+                            params.push(opValue);
+                            break;
+                        case '$nin':
+                        case '$not_in':
+                            clauses.push(`${this.escapeIdentifier(key)} NOT IN (?)`);
+                            params.push(opValue);
+                            break;
+                        case '$like':
+                            clauses.push(`${this.escapeIdentifier(key)} LIKE ?`);
+                            params.push(opValue);
+                            break;
+                        case '$ilike':
+                            // MySQL uses LOWER() for case-insensitive comparison
+                            clauses.push(`LOWER(${this.escapeIdentifier(key)}) LIKE LOWER(?)`);
+                            params.push(opValue);
+                            break;
+                        case '$isnull':
+                        case '$is_null':
+                            clauses.push(`${this.escapeIdentifier(key)} IS ${opValue ? 'NULL' : 'NOT NULL'}`);
+                            break;
+                        case '$isnotnull':
+                        case '$is_not_null':
+                            clauses.push(`${this.escapeIdentifier(key)} IS ${opValue ? 'NOT NULL' : 'NULL'}`);
+                            break;
+                        case '$between':
+                            const [min, max] = opValue;
+                            clauses.push(`${this.escapeIdentifier(key)} BETWEEN ? AND ?`);
+                            params.push(min, max);
+                            break;
+                        case '$contains':
+                            // MySQL uses JSON_CONTAINS for JSON columns or FIND_IN_SET for comma-separated values
+                            clauses.push(`JSON_CONTAINS(${this.escapeIdentifier(key)}, ?)`);
+                            params.push(JSON.stringify(opValue));
+                            break;
+                        case '$overlaps':
+                            // MySQL 8.0+ supports JSON_OVERLAPS
+                            clauses.push(`JSON_OVERLAPS(${this.escapeIdentifier(key)}, ?)`);
+                            params.push(JSON.stringify(opValue));
+                            break;
+                        case '$regex':
+                            clauses.push(`${this.escapeIdentifier(key)} REGEXP ?`);
+                            params.push(opValue);
+                            break;
+                        case '$exists':
+                            clauses.push(`${this.escapeIdentifier(key)} IS ${opValue ? 'NOT NULL' : 'NULL'}`);
+                            break;
+                    }
+                }
+            }
+            else {
+                // Simple equality
+                clauses.push(`${this.escapeIdentifier(key)} = ?`);
+                params.push(value);
+            }
+        }
+        return {
+            whereClause: clauses.join(' AND '),
+            whereParams: params,
+        };
+    }
+    buildCountQuery(query) {
+        // Build a COUNT query from the original query
+        const fromIndex = query.sql.toUpperCase().indexOf('FROM');
+        const orderByIndex = query.sql.toUpperCase().indexOf('ORDER BY');
+        const limitIndex = query.sql.toUpperCase().indexOf('LIMIT');
+        let endIndex = query.sql.length;
+        if (orderByIndex > 0)
+            endIndex = Math.min(endIndex, orderByIndex);
+        if (limitIndex > 0)
+            endIndex = Math.min(endIndex, limitIndex);
+        return `SELECT COUNT(*) as count ${query.sql.substring(fromIndex, endIndex)}`;
+    }
+    buildColumnDefinition(column) {
+        let def = `${this.escapeIdentifier(column.name)} ${this.getColumnTypeString(column.type, column)}`;
+        if (column.autoIncrement) {
+            def += ' AUTO_INCREMENT';
+        }
+        if (column.nullable === false) {
+            def += ' NOT NULL';
+        }
+        if (column.unique) {
+            def += ' UNIQUE';
+        }
+        if (column.primaryKey) {
+            def += ' PRIMARY KEY';
+        }
+        if (column.defaultValue !== undefined) {
+            def += ` DEFAULT ${this.escapeValue(column.defaultValue)}`;
+        }
+        if (column.references) {
+            def += ` REFERENCES ${this.escapeIdentifier(column.references.table)}(${this.escapeIdentifier(column.references.column)})`;
+            if (column.references.onDelete) {
+                def += ` ON DELETE ${column.references.onDelete}`;
+            }
+            if (column.references.onUpdate) {
+                def += ` ON UPDATE ${column.references.onUpdate}`;
+            }
+        }
+        if (column.comment) {
+            def += ` COMMENT ${this.escapeValue(column.comment)}`;
+        }
+        return def;
+    }
+    buildConstraintDefinition(constraint) {
+        let def = `CONSTRAINT ${this.escapeIdentifier(constraint.name)}`;
+        switch (constraint.type) {
+            case 'PRIMARY_KEY':
+                def += ` PRIMARY KEY (${constraint.columns.map((c) => this.escapeIdentifier(c)).join(', ')})`;
+                break;
+            case 'UNIQUE':
+                def += ` UNIQUE (${constraint.columns.map((c) => this.escapeIdentifier(c)).join(', ')})`;
+                break;
+            case 'FOREIGN_KEY':
+                def += ` FOREIGN KEY (${constraint.columns.map((c) => this.escapeIdentifier(c)).join(', ')})`;
+                def += ` REFERENCES ${this.escapeIdentifier(constraint.references.table)}(${this.escapeIdentifier(constraint.references.column)})`;
+                if (constraint.references.onDelete) {
+                    def += ` ON DELETE ${constraint.references.onDelete}`;
+                }
+                if (constraint.references.onUpdate) {
+                    def += ` ON UPDATE ${constraint.references.onUpdate}`;
+                }
+                break;
+            case 'CHECK':
+                def += ` CHECK (${constraint.expression})`;
+                break;
+        }
+        return def;
+    }
+    mapIsolationLevel(level) {
+        switch (level) {
+            case enums_1.IsolationLevel.READ_UNCOMMITTED:
+                return 'READ UNCOMMITTED';
+            case enums_1.IsolationLevel.READ_COMMITTED:
+                return 'READ COMMITTED';
+            case enums_1.IsolationLevel.REPEATABLE_READ:
+                return 'REPEATABLE READ';
+            case enums_1.IsolationLevel.SERIALIZABLE:
+                return 'SERIALIZABLE';
+            default:
+                return 'REPEATABLE READ'; // MySQL default
+        }
+    }
+    formatBytes(bytes) {
+        if (bytes === 0)
+            return '0 B';
+        const k = 1024;
+        const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+    }
+}
+exports.MySQLAdapter = MySQLAdapter;
+//# sourceMappingURL=mysql.adapter.js.map