drizzle-kit 0.20.1 → 0.20.2-8e648e0

package/utils.js

@@ -1043,7 +1043,7 @@ var require_hanji = __commonJS({
       }
     };
     exports.TaskTerminal = TaskTerminal;
-    function render5(view) {
+    function render6(view) {
       const { stdin, stdout, closable } = (0, readline_1.prepareReadLine)();
       if (view instanceof Prompt3) {
         const terminal = new Terminal(view, stdin, stdout, closable);
@@ -1055,8 +1055,8 @@ var require_hanji = __commonJS({
       closable.close();
       return;
     }
-    exports.render = render5;
-    function renderWithTask3(view, task) {
+    exports.render = render6;
+    function renderWithTask4(view, task) {
       return __awaiter(this, void 0, void 0, function* () {
         const terminal = new TaskTerminal(view, process.stdout);
         terminal.requestLayout();
@@ -1065,7 +1065,7 @@ var require_hanji = __commonJS({
         return result;
       });
     }
-    exports.renderWithTask = renderWithTask3;
+    exports.renderWithTask = renderWithTask4;
     var terminateHandler;
     function onTerminate(callback) {
       terminateHandler = callback;
@@ -11180,14 +11180,30 @@ var init_utils = __esm({
 // src/serializer/mysqlImports.ts
 var mysqlImports_exports = {};
 __export(mysqlImports_exports, {
+  prepareFromExports: () => prepareFromExports,
   prepareFromMySqlImports: () => prepareFromMySqlImports
 });
-var import_mysql_core, import_drizzle_orm, prepareFromMySqlImports;
+var import_mysql_core, import_drizzle_orm, prepareFromExports, prepareFromMySqlImports;
 var init_mysqlImports = __esm({
   "src/serializer/mysqlImports.ts"() {
     import_mysql_core = require("drizzle-orm/mysql-core");
     import_drizzle_orm = require("drizzle-orm");
     init_utils();
+    prepareFromExports = (exports) => {
+      const tables = [];
+      const enums = [];
+      const schemas = [];
+      const i0values = Object.values(exports);
+      i0values.forEach((t) => {
+        if ((0, import_drizzle_orm.is)(t, import_mysql_core.MySqlTable)) {
+          tables.push(t);
+        }
+        if ((0, import_drizzle_orm.is)(t, import_mysql_core.MySqlSchema)) {
+          schemas.push(t);
+        }
+      });
+      return { tables, enums, schemas };
+    };
     prepareFromMySqlImports = async (imports) => {
       const tables = [];
       const enums = [];
@@ -11196,15 +11212,10 @@ var init_mysqlImports = __esm({
       for (let i = 0; i < imports.length; i++) {
         const it = imports[i];
         const i0 = require(`${it}`);
-        const i0values = Object.values(i0);
-        i0values.forEach((t) => {
-          if ((0, import_drizzle_orm.is)(t, import_mysql_core.MySqlTable)) {
-            tables.push(t);
-          }
-          if ((0, import_drizzle_orm.is)(t, import_mysql_core.MySqlSchema)) {
-            schemas.push(t);
-          }
-        });
+        const prepared = prepareFromExports(i0);
+        tables.push(...prepared.tables);
+        enums.push(...prepared.enums);
+        schemas.push(...prepared.schemas);
       }
       unregister();
       return { tables, enums, schemas };
@@ -11497,21 +11508,20 @@ We have encountered a collision between the index name on columns ${source_defau
     fromDatabase = async (db, inputSchema, tablesFilter = (table4) => true, progressCallback) => {
       const result = {};
       const internals = { tables: {} };
-      const columns = await db.execute(`select * from information_schema.columns
+      const columns = await db.query(`select * from information_schema.columns
 	where table_schema = '${inputSchema}' and table_name != '__drizzle_migrations'
 	order by table_name, ordinal_position;`);
-      const response = columns[0];
+      const response = columns;
       const schemas = [];
       let columnsCount = 0;
       let tablesCount = /* @__PURE__ */ new Set();
       let indexesCount = 0;
       let foreignKeysCount = 0;
-      const idxs = await db.execute(
+      const idxs = await db.query(
         `select * from INFORMATION_SCHEMA.STATISTICS
-	WHERE INFORMATION_SCHEMA.STATISTICS.TABLE_SCHEMA = ? and INFORMATION_SCHEMA.STATISTICS.INDEX_NAME != 'PRIMARY';`,
-        [inputSchema]
+	WHERE INFORMATION_SCHEMA.STATISTICS.TABLE_SCHEMA = '${inputSchema}' and INFORMATION_SCHEMA.STATISTICS.INDEX_NAME != 'PRIMARY';`
       );
-      const idxRows = idxs[0];
+      const idxRows = idxs;
       for (const column5 of response) {
         if (!tablesFilter(column5["TABLE_NAME"]))
           continue;
@@ -11604,19 +11614,18 @@ We have encountered a collision between the index name on columns ${source_defau
           result[tableName].columns[columnName] = newColumn;
         }
       }
-      const tablePks = await db.execute(
+      const tablePks = await db.query(
         `SELECT table_name, column_name, ordinal_position
   FROM information_schema.table_constraints t
   LEFT JOIN information_schema.key_column_usage k
   USING(constraint_name,table_schema,table_name)
   WHERE t.constraint_type='PRIMARY KEY'
       and table_name != '__drizzle_migrations'
-      AND t.table_schema = ?
-      ORDER BY ordinal_position`,
-        [inputSchema]
+      AND t.table_schema = '${inputSchema}'
+      ORDER BY ordinal_position`
       );
       const tableToPk = {};
-      const tableToPkRows = tablePks[0];
+      const tableToPkRows = tablePks;
       for (const tableToPkRow of tableToPkRows) {
         const tableName = tableToPkRow["TABLE_NAME"];
         const columnName = tableToPkRow["COLUMN_NAME"];
@@ -11643,15 +11652,14 @@ We have encountered a collision between the index name on columns ${source_defau
         progressCallback("tables", tablesCount.size, "done");
       }
       try {
-        const fks = await db.execute(
+        const fks = await db.query(
           `SELECT INFORMATION_SCHEMA.KEY_COLUMN_USAGE.TABLE_SCHEMA,INFORMATION_SCHEMA.KEY_COLUMN_USAGE.TABLE_NAME,INFORMATION_SCHEMA.KEY_COLUMN_USAGE.CONSTRAINT_NAME,INFORMATION_SCHEMA.KEY_COLUMN_USAGE.COLUMN_NAME,INFORMATION_SCHEMA.KEY_COLUMN_USAGE.REFERENCED_TABLE_SCHEMA,INFORMATION_SCHEMA.KEY_COLUMN_USAGE.REFERENCED_TABLE_NAME, INFORMATION_SCHEMA.KEY_COLUMN_USAGE.REFERENCED_COLUMN_NAME,information_schema.referential_constraints.UPDATE_RULE, information_schema.referential_constraints.DELETE_RULE
 		FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
 		LEFT JOIN information_schema.referential_constraints on information_schema.referential_constraints.constraint_name = information_schema.KEY_COLUMN_USAGE.CONSTRAINT_NAME
-		WHERE INFORMATION_SCHEMA.KEY_COLUMN_USAGE.TABLE_SCHEMA = ? AND INFORMATION_SCHEMA.KEY_COLUMN_USAGE.CONSTRAINT_NAME != 'PRIMARY' and INFORMATION_SCHEMA.KEY_COLUMN_USAGE.REFERENCED_TABLE_NAME is not null;
-		`,
-          [inputSchema]
+		WHERE INFORMATION_SCHEMA.KEY_COLUMN_USAGE.TABLE_SCHEMA = '${inputSchema}' AND INFORMATION_SCHEMA.KEY_COLUMN_USAGE.CONSTRAINT_NAME != 'PRIMARY' and INFORMATION_SCHEMA.KEY_COLUMN_USAGE.REFERENCED_TABLE_NAME is not null;
+		`
         );
-        const fkRows = fks[0];
+        const fkRows = fks;
         for (const fkRow of fkRows) {
           foreignKeysCount += 1;
           if (progressCallback) {
@@ -11759,16 +11767,16 @@ We have encountered a collision between the index name on columns ${source_defau
 // src/serializer/pgImports.ts
 var pgImports_exports = {};
 __export(pgImports_exports, {
-  prepareFromExports: () => prepareFromExports,
+  prepareFromExports: () => prepareFromExports2,
   prepareFromPgImports: () => prepareFromPgImports
 });
-var import_pg_core, import_drizzle_orm4, prepareFromExports, prepareFromPgImports;
+var import_pg_core, import_drizzle_orm4, prepareFromExports2, prepareFromPgImports;
 var init_pgImports = __esm({
   "src/serializer/pgImports.ts"() {
     import_pg_core = require("drizzle-orm/pg-core");
     import_drizzle_orm4 = require("drizzle-orm");
     init_utils();
-    prepareFromExports = (exports) => {
+    prepareFromExports2 = (exports) => {
       const tables = [];
       const enums = [];
       const schemas = [];
@@ -11795,10 +11803,10 @@ var init_pgImports = __esm({
       for (let i = 0; i < imports.length; i++) {
         const it = imports[i];
         const i0 = require(`${it}`);
-        const prepared = prepareFromExports(i0);
-        tables = prepared.tables;
-        enums = prepared.enums;
-        schemas = prepared.schemas;
+        const prepared = prepareFromExports2(i0);
+        tables.push(...prepared.tables);
+        enums.push(...prepared.enums);
+        schemas.push(...prepared.schemas);
       }
       unregister();
       return { tables, enums, schemas };
@@ -12532,14 +12540,26 @@ ${withStyle.errorWarning(`We've found duplicated unique constraint names in ${so
 // src/serializer/sqliteImports.ts
 var sqliteImports_exports = {};
 __export(sqliteImports_exports, {
+  prepareFromExports: () => prepareFromExports3,
   prepareFromSqliteImports: () => prepareFromSqliteImports
 });
-var import_sqlite_core, import_drizzle_orm6, prepareFromSqliteImports;
+var import_sqlite_core, import_drizzle_orm6, prepareFromExports3, prepareFromSqliteImports;
 var init_sqliteImports = __esm({
   "src/serializer/sqliteImports.ts"() {
     import_sqlite_core = require("drizzle-orm/sqlite-core");
     import_drizzle_orm6 = require("drizzle-orm");
     init_utils();
+    prepareFromExports3 = (exports) => {
+      const tables = [];
+      const enums = [];
+      const i0values = Object.values(exports);
+      i0values.forEach((t) => {
+        if ((0, import_drizzle_orm6.is)(t, import_sqlite_core.SQLiteTable)) {
+          tables.push(t);
+        }
+      });
+      return { tables, enums };
+    };
     prepareFromSqliteImports = async (imports) => {
       const tables = [];
       const enums = [];
@@ -12547,12 +12567,9 @@ var init_sqliteImports = __esm({
       for (let i = 0; i < imports.length; i++) {
         const it = imports[i];
         const i0 = require(`${it}`);
-        const i0values = Object.values(i0);
-        i0values.forEach((t) => {
-          if ((0, import_drizzle_orm6.is)(t, import_sqlite_core.SQLiteTable)) {
-            tables.push(t);
-          }
-        });
+        const prepared = prepareFromExports3(i0);
+        tables.push(...prepared.tables);
+        enums.push(...prepared.enums);
       }
       unregister();
       return { tables, enums };
@@ -22466,7 +22483,7 @@ var require_connection = __commonJS({
     var flushBuffer = serialize.flush();
     var syncBuffer = serialize.sync();
     var endBuffer = serialize.end();
-    var Connection = class extends EventEmitter {
+    var Connection2 = class extends EventEmitter {
       constructor(config) {
         super();
         config = config || {};
@@ -22636,7 +22653,7 @@ var require_connection = __commonJS({
         this._send(serialize.copyFail(msg));
       }
     };
-    module2.exports = Connection;
+    module2.exports = Connection2;
   }
 });
 
@@ -22945,7 +22962,7 @@ var require_client = __commonJS({
     var ConnectionParameters = require_connection_parameters();
     var Query = require_query();
     var defaults3 = require_defaults();
-    var Connection = require_connection();
+    var Connection2 = require_connection();
     var crypto = require_utils3();
     var Client2 = class extends EventEmitter {
       constructor(config) {
@@ -22971,7 +22988,7 @@ var require_client = __commonJS({
         this._connected = false;
         this._connectionError = false;
         this._queryable = true;
-        this.connection = c.connection || new Connection({
+        this.connection = c.connection || new Connection2({
           stream: c.stream,
           ssl: this.connectionParameters.ssl,
           keepAlive: c.keepAlive || false,
@@ -24226,7 +24243,7 @@ var require_lib2 = __commonJS({
     "use strict";
     var Client2 = require_client();
     var defaults3 = require_defaults();
-    var Connection = require_connection();
+    var Connection2 = require_connection();
     var Pool = require_pg_pool();
     var { DatabaseError } = require_dist();
     var { escapeIdentifier, escapeLiteral } = require_utils2();
@@ -24243,7 +24260,7 @@ var require_lib2 = __commonJS({
       this.Query = this.Client.Query;
       this.Pool = poolFactory(this.Client);
       this._pools = [];
-      this.Connection = Connection;
+      this.Connection = Connection2;
       this.types = require_pg_types();
       this.DatabaseError = DatabaseError;
       this.escapeIdentifier = escapeIdentifier;
@@ -24280,11 +24297,14 @@ var drivers_exports = {};
 __export(drivers_exports, {
   BetterSqlite: () => BetterSqlite,
   DrizzleDbClient: () => DrizzleDbClient,
+  DrizzleORMMySQLClient: () => DrizzleORMMySQLClient,
   DrizzleORMPgClient: () => DrizzleORMPgClient,
+  DrizzleORMSQLiteClient: () => DrizzleORMSQLiteClient,
+  MySQL2Client: () => MySQL2Client,
   PgPostgres: () => PgPostgres,
   TursoSqlite: () => TursoSqlite
 });
-var import_drizzle_orm8, DrizzleDbClient, DrizzleORMPgClient, BetterSqlite, TursoSqlite, PgPostgres;
+var import_drizzle_orm8, DrizzleDbClient, DrizzleORMPgClient, DrizzleORMMySQLClient, DrizzleORMSQLiteClient, BetterSqlite, MySQL2Client, TursoSqlite, PgPostgres;
 var init_drivers = __esm({
   "src/drivers/index.ts"() {
     import_drizzle_orm8 = require("drizzle-orm");
@@ -24303,6 +24323,24 @@ var init_drivers = __esm({
         return res.rows;
       }
     };
+    DrizzleORMMySQLClient = class extends DrizzleDbClient {
+      async query(query, values) {
+        const res = await this.db.execute(import_drizzle_orm8.sql.raw(query));
+        return res[0];
+      }
+      async run(query) {
+        await this.db.execute(import_drizzle_orm8.sql.raw(query));
+      }
+    };
+    DrizzleORMSQLiteClient = class extends DrizzleDbClient {
+      async query(query, values) {
+        const res = this.db.all(import_drizzle_orm8.sql.raw(query));
+        return res;
+      }
+      async run(query) {
+        this.db.run(import_drizzle_orm8.sql.raw(query));
+      }
+    };
     BetterSqlite = class extends DrizzleDbClient {
       async run(query) {
         this.db.prepare(query).run();
@@ -24311,6 +24349,15 @@ var init_drivers = __esm({
         return this.db.prepare(query).all();
       }
     };
+    MySQL2Client = class extends DrizzleDbClient {
+      async run(query) {
+        await this.db.execute(query);
+      }
+      async query(query) {
+        const res = await this.db.execute(query);
+        return res[0];
+      }
+    };
     TursoSqlite = class extends DrizzleDbClient {
       async run(query) {
         await this.db.execute(query);
@@ -37515,8 +37562,8 @@ var require_prepare = __commonJS({
         this.options = options;
       }
       start(packet, connection) {
-        const Connection = connection.constructor;
-        this.key = Connection.statementKey(this.options);
+        const Connection2 = connection.constructor;
+        this.key = Connection2.statementKey(this.options);
         const statement = connection._statements.get(this.key);
         if (statement) {
           if (this.onResult) {
@@ -39455,7 +39502,7 @@ var require_connection2 = __commonJS({
     var CharsetToEncoding = require_charset_encodings();
     var _connectionId = 0;
     var convertNamedPlaceholders = null;
-    var Connection = class _Connection extends EventEmitter {
+    var Connection2 = class _Connection extends EventEmitter {
       constructor(opts) {
         super();
         this.config = opts.config;
@@ -40179,7 +40226,7 @@ var require_connection2 = __commonJS({
     };
     if (Tls.TLSSocket) {
     } else {
-      Connection.prototype.startTLS = function _startTLS(onSecure) {
+      Connection2.prototype.startTLS = function _startTLS(onSecure) {
         if (this.config.debug) {
           console.log("Upgrading connection to TLS");
         }
@@ -40217,7 +40264,7 @@ var require_connection2 = __commonJS({
         });
       };
     }
-    module2.exports = Connection;
+    module2.exports = Connection2;
   }
 });
 
@@ -40225,8 +40272,8 @@ var require_connection2 = __commonJS({
 var require_pool_connection = __commonJS({
   "node_modules/.pnpm/mysql2@2.3.3/node_modules/mysql2/lib/pool_connection.js"(exports, module2) {
     "use strict";
-    var Connection = require_mysql2().Connection;
-    var PoolConnection = class extends Connection {
+    var Connection2 = require_mysql2().Connection;
+    var PoolConnection = class extends Connection2 {
       constructor(pool, options) {
         super(options);
         this._pool = pool;
@@ -40268,9 +40315,9 @@ var require_pool_connection = __commonJS({
         pool._removeConnection(this);
       }
     };
-    PoolConnection.statementKey = Connection.statementKey;
+    PoolConnection.statementKey = Connection2.statementKey;
     module2.exports = PoolConnection;
-    PoolConnection.prototype._realEnd = Connection.prototype.end;
+    PoolConnection.prototype._realEnd = Connection2.prototype.end;
   }
 });
 
@@ -40283,7 +40330,7 @@ var require_pool = __commonJS({
     var EventEmitter = require("events").EventEmitter;
     var PoolConnection = require_pool_connection();
     var Queue = require_denque();
-    var Connection = require_connection2();
+    var Connection2 = require_connection2();
     function spliceConnection(queue, connection) {
       const len = queue.length;
       for (let i = 0; i < len; i++) {
@@ -40390,7 +40437,7 @@ var require_pool = __commonJS({
         }
       }
       query(sql2, values, cb) {
-        const cmdQuery = Connection.createQuery(
+        const cmdQuery = Connection2.createQuery(
           sql2,
           values,
           cb,
@@ -40493,7 +40540,7 @@ var require_pool_cluster = __commonJS({
     var process4 = require("process");
     var Pool = require_pool();
     var PoolConfig = require_pool_config();
-    var Connection = require_connection2();
+    var Connection2 = require_connection2();
     var EventEmitter = require("events").EventEmitter;
     var makeSelector = {
       RR() {
@@ -40536,7 +40583,7 @@ var require_pool_cluster = __commonJS({
        * @returns query
        */
       query(sql2, values, cb) {
-        const query = Connection.createQuery(sql2, values, cb, {});
+        const query = Connection2.createQuery(sql2, values, cb, {});
         this.getConnection((err2, conn) => {
           if (err2) {
             if (typeof query.onResult === "function") {
@@ -40742,7 +40789,7 @@ var require_server = __commonJS({
     "use strict";
     var net = require("net");
     var EventEmitter = require("events").EventEmitter;
-    var Connection = require_connection2();
+    var Connection2 = require_connection2();
     var ConnectionConfig = require_connection_config();
     var Server = class extends EventEmitter {
       constructor() {
@@ -40755,7 +40802,7 @@ var require_server = __commonJS({
           stream: socket,
           isServer: true
         });
-        const connection = new Connection({ config: connectionConfig });
+        const connection = new Connection2({ config: connectionConfig });
         this.emit("connection", connection);
       }
       listen(port) {
@@ -40776,14 +40823,14 @@ var require_mysql2 = __commonJS({
   "node_modules/.pnpm/mysql2@2.3.3/node_modules/mysql2/index.js"(exports) {
     "use strict";
     var SqlString = require_sqlstring();
-    var Connection = require_connection2();
+    var Connection2 = require_connection2();
     var ConnectionConfig = require_connection_config();
     var parserCache = require_parser_cache();
     exports.createConnection = function(opts) {
-      return new Connection({ config: new ConnectionConfig(opts) });
+      return new Connection2({ config: new ConnectionConfig(opts) });
     };
     exports.connect = exports.createConnection;
-    exports.Connection = Connection;
+    exports.Connection = Connection2;
     var Pool = require_pool();
     var PoolCluster = require_pool_cluster();
     exports.createPool = function(config) {
@@ -40794,7 +40841,7 @@ var require_mysql2 = __commonJS({
       const PoolCluster2 = require_pool_cluster();
       return new PoolCluster2(config);
     };
-    exports.createQuery = Connection.createQuery;
+    exports.createQuery = Connection2.createQuery;
     exports.Pool = Pool;
     exports.PoolCluster = PoolCluster;
     exports.createServer = function(handler) {
@@ -41058,7 +41105,7 @@ var require_promise = __commonJS({
         return this.connection.threadId;
       }
     };
-    function createConnection(opts) {
+    function createConnection2(opts) {
       const coreConnection = core.createConnection(opts);
       const createConnectionErr = new Error();
       const thePromise = opts.Promise || Promise;
@@ -41311,7 +41358,7 @@ var require_promise = __commonJS({
       }
       return new PromisePoolCluster(corePoolCluster, thePromise);
     }
-    exports.createConnection = createConnection;
+    exports.createConnection = createConnection2;
     exports.createPool = createPool;
     exports.createPoolCluster = createPoolCluster;
     exports.escape = core.escape;
@@ -56889,6 +56936,567 @@ var init_studioUtils = __esm({
   }
 });
 
+// src/cli/commands/sqlitePushUtils.ts
+var _moveDataStatements, getOldTableName, getNewTableName, logSuggestionsAndReturn;
+var init_sqlitePushUtils = __esm({
+  "src/cli/commands/sqlitePushUtils.ts"() {
+    init_source();
+    init_sqliteSchema();
+    init_sqlgenerator();
+    _moveDataStatements = (tableName, json, dataLoss = false) => {
+      const statements = [];
+      statements.push(
+        new SqliteRenameTableConvertor().convert({
+          type: "rename_table",
+          tableNameFrom: tableName,
+          tableNameTo: `__old_push_${tableName}`,
+          fromSchema: "",
+          toSchema: ""
+        })
+      );
+      const tableColumns = Object.values(json.tables[tableName].columns);
+      const referenceData = Object.values(json.tables[tableName].foreignKeys);
+      const compositePKs = Object.values(
+        json.tables[tableName].compositePrimaryKeys
+      ).map((it) => SQLiteSquasher.unsquashPK(it));
+      statements.push(
+        new SQLiteCreateTableConvertor().convert({
+          type: "sqlite_create_table",
+          tableName,
+          columns: tableColumns,
+          referenceData,
+          compositePKs
+        })
+      );
+      if (!dataLoss) {
+        statements.push(
+          `INSERT INTO "${tableName}" SELECT * FROM "__old_push_${tableName}";`
+        );
+      }
+      statements.push(
+        new SQLiteDropTableConvertor().convert({
+          type: "drop_table",
+          tableName: `__old_push_${tableName}`,
+          schema: ""
+        })
+      );
+      for (const idx of Object.values(json.tables[tableName].indexes)) {
+        statements.push(
+          new CreateSqliteIndexConvertor().convert({
+            type: "create_index",
+            tableName,
+            schema: "",
+            data: idx
+          })
+        );
+      }
+      return statements;
+    };
+    getOldTableName = (tableName, meta) => {
+      for (const key of Object.keys(meta.tables)) {
+        const value = meta.tables[key];
+        if (`"${tableName}"` === value) {
+          return key.substring(1, key.length - 1);
+        }
+      }
+      return tableName;
+    };
+    getNewTableName = (tableName, meta) => {
+      if (typeof meta.tables[`"${tableName}"`] !== "undefined") {
+        return meta.tables[`"${tableName}"`].substring(
+          1,
+          meta.tables[`"${tableName}"`].length - 1
+        );
+      }
+      return tableName;
+    };
+    logSuggestionsAndReturn = async ({
+      connection,
+      statements,
+      json1,
+      json2,
+      meta
+    }) => {
+      let shouldAskForApprove = false;
+      const statementsToExecute = [];
+      const infoToPrint = [];
+      const tablesToRemove = [];
+      const columnsToRemove = [];
+      const schemasToRemove = [];
+      const tablesToTruncate = [];
+      const tablesContext = {};
+      for (const statement of statements) {
+        if (statement.type === "drop_table") {
+          const res = await connection.query(
+            `select count(*) as count from \`${statement.tableName}\``
+          );
+          const count = Number(res[0].count);
+          if (count > 0) {
+            infoToPrint.push(
+              `\xB7 You're about to delete ${source_default.underline(
+                statement.tableName
+              )} table with ${count} items`
+            );
+            tablesToRemove.push(statement.tableName);
+            shouldAskForApprove = true;
+          }
+          const stmnt = fromJson([statement], "sqlite")[0];
+          statementsToExecute.push(stmnt);
+        } else if (statement.type === "alter_table_drop_column") {
+          const newTableName = getOldTableName(statement.tableName, meta);
+          const columnIsPartOfPk = Object.values(
+            json1.tables[newTableName].compositePrimaryKeys
+          ).find(
+            (c) => SQLiteSquasher.unsquashPK(c).includes(statement.columnName)
+          );
+          const columnIsPartOfIndex = Object.values(
+            json1.tables[newTableName].indexes
+          ).find(
+            (c) => SQLiteSquasher.unsquashIdx(c).columns.includes(statement.columnName)
+          );
+          const columnIsPk = json1.tables[newTableName].columns[statement.columnName].primaryKey;
+          const columnIsPartOfFk = Object.values(
+            json1.tables[newTableName].foreignKeys
+          ).find(
+            (t) => SQLiteSquasher.unsquashFK(t).columnsFrom.includes(statement.columnName)
+          );
+          const res = await connection.query(
+            `select count(*) as count from \`${newTableName}\``
+          );
+          const count = Number(res[0].count);
+          if (count > 0) {
+            infoToPrint.push(
+              `\xB7 You're about to delete ${source_default.underline(
+                statement.columnName
+              )} column in ${newTableName} table with ${count} items`
+            );
+            columnsToRemove.push(`${newTableName}_${statement.columnName}`);
+            shouldAskForApprove = true;
+          }
+          if (columnIsPk || columnIsPartOfPk || columnIsPartOfIndex || columnIsPartOfFk) {
+            tablesContext[newTableName] = [
+              ..._moveDataStatements(statement.tableName, json2, true)
+            ];
+            const tablesReferncingCurrent = [];
+            for (const table4 of Object.values(json1.tables)) {
+              const tablesRefs = Object.values(json1.tables[table4.name].foreignKeys).filter(
+                (t) => SQLiteSquasher.unsquashFK(t).tableTo === newTableName
+              ).map((t) => SQLiteSquasher.unsquashFK(t).tableFrom);
+              tablesReferncingCurrent.push(...tablesRefs);
+            }
+            const uniqueTableRefs = [...new Set(tablesReferncingCurrent)];
+            for (const table4 of uniqueTableRefs) {
+              if (typeof tablesContext[table4] === "undefined") {
+                tablesContext[table4] = [..._moveDataStatements(table4, json2)];
+              }
+            }
+          } else {
+            if (typeof tablesContext[newTableName] === "undefined") {
+              const stmnt = fromJson([statement], "sqlite")[0];
+              statementsToExecute.push(stmnt);
+            }
+          }
+        } else if (statement.type === "sqlite_alter_table_add_column") {
+          const newTableName = getOldTableName(statement.tableName, meta);
+          if (statement.column.notNull && !statement.column.default) {
+            const res = await connection.query(
+              `select count(*) as count from \`${newTableName}\``
+            );
+            const count = Number(res[0].count);
+            if (count > 0) {
+              infoToPrint.push(
+                `\xB7 You're about to add not-null ${source_default.underline(
+                  statement.column.name
+                )} column without default value, which contains ${count} items`
+              );
+              tablesToTruncate.push(newTableName);
+              statementsToExecute.push(`delete from ${newTableName};`);
+              shouldAskForApprove = true;
+            }
+          }
+          if (statement.column.primaryKey) {
+            tablesContext[newTableName] = [
+              ..._moveDataStatements(statement.tableName, json2, true)
+            ];
+            const tablesReferncingCurrent = [];
+            for (const table4 of Object.values(json1.tables)) {
+              const tablesRefs = Object.values(json1.tables[table4.name].foreignKeys).filter(
+                (t) => SQLiteSquasher.unsquashFK(t).tableTo === newTableName
+              ).map((t) => SQLiteSquasher.unsquashFK(t).tableFrom);
+              tablesReferncingCurrent.push(...tablesRefs);
+            }
+            const uniqueTableRefs = [...new Set(tablesReferncingCurrent)];
+            for (const table4 of uniqueTableRefs) {
+              if (typeof tablesContext[table4] === "undefined") {
+                tablesContext[table4] = [..._moveDataStatements(table4, json2)];
+              }
+            }
+          } else {
+            if (typeof tablesContext[newTableName] === "undefined") {
+              const stmnt = fromJson([statement], "sqlite")[0];
+              statementsToExecute.push(stmnt);
+            }
+          }
+        } else if (statement.type === "alter_table_alter_column_set_type" || statement.type === "alter_table_alter_column_set_default" || statement.type === "alter_table_alter_column_drop_default" || statement.type === "alter_table_alter_column_set_notnull" || statement.type === "alter_table_alter_column_drop_notnull" || statement.type === "alter_table_alter_column_drop_autoincrement" || statement.type === "alter_table_alter_column_set_autoincrement" || statement.type === "alter_table_alter_column_drop_pk" || statement.type === "alter_table_alter_column_set_pk") {
+          const newTableName = getOldTableName(statement.tableName, meta);
+          if (statement.type === "alter_table_alter_column_set_notnull" && typeof statement.columnDefault === "undefined") {
+            const res = await connection.query(
+              `select count(*) as count from \`${newTableName}\``
+            );
+            const count = Number(res[0].count);
+            if (count > 0) {
+              infoToPrint.push(
+                `\xB7 You're about to add not-null constraint to ${source_default.underline(
+                  statement.columnName
+                )} column without default value, which contains ${count} items`
+              );
+              tablesToTruncate.push(newTableName);
+              shouldAskForApprove = true;
+            }
+            tablesContext[newTableName] = _moveDataStatements(
+              statement.tableName,
+              json2,
+              true
+            );
+          } else {
+            if (typeof tablesContext[newTableName] === "undefined") {
+              tablesContext[newTableName] = _moveDataStatements(
+                statement.tableName,
+                json2
+              );
+            }
+          }
+          const tablesReferncingCurrent = [];
+          for (const table4 of Object.values(json1.tables)) {
+            const tablesRefs = Object.values(json1.tables[table4.name].foreignKeys).filter((t) => SQLiteSquasher.unsquashFK(t).tableTo === newTableName).map((t) => {
+              return getNewTableName(
+                SQLiteSquasher.unsquashFK(t).tableFrom,
+                meta
+              );
+            });
+            tablesReferncingCurrent.push(...tablesRefs);
+          }
+          const uniqueTableRefs = [...new Set(tablesReferncingCurrent)];
+          for (const table4 of uniqueTableRefs) {
+            if (typeof tablesContext[table4] === "undefined") {
+              tablesContext[table4] = [..._moveDataStatements(table4, json2)];
+            }
+          }
+        } else if (statement.type === "create_reference" || statement.type === "delete_reference" || statement.type === "alter_reference") {
+          const fk4 = SQLiteSquasher.unsquashFK(statement.data);
+          if (typeof tablesContext[statement.tableName] === "undefined") {
+            tablesContext[statement.tableName] = _moveDataStatements(
+              statement.tableName,
+              json2
+            );
+          }
+        } else if (statement.type === "create_composite_pk" || statement.type === "alter_composite_pk" || statement.type === "delete_composite_pk" || statement.type === "create_unique_constraint" || statement.type === "delete_unique_constraint") {
+          const newTableName = getOldTableName(statement.tableName, meta);
+          if (typeof tablesContext[newTableName] === "undefined") {
+            tablesContext[newTableName] = _moveDataStatements(
+              statement.tableName,
+              json2
+            );
+          }
+        } else {
+          const stmnt = fromJson([statement], "sqlite")[0];
+          if (typeof stmnt !== "undefined") {
+            statementsToExecute.push(stmnt);
+          }
+        }
+      }
+      for (const context of Object.values(tablesContext)) {
+        statementsToExecute.push(...context);
+      }
+      return {
+        statementsToExecute,
+        shouldAskForApprove,
+        infoToPrint,
+        columnsToRemove: [...new Set(columnsToRemove)],
+        schemasToRemove: [...new Set(schemasToRemove)],
+        tablesToTruncate: [...new Set(tablesToTruncate)],
+        tablesToRemove: [...new Set(tablesToRemove)]
+      };
+    };
+  }
+});
+
+// src/mysql-introspect.ts
+var init_mysql_introspect = __esm({
+  "src/mysql-introspect.ts"() {
+    init_utils2();
+    init_mysqlSerializer();
+  }
+});
+
+// src/cli/commands/mysqlIntrospect.ts
+var import_hanji8, import_promise, mysqlPushIntrospect;
+var init_mysqlIntrospect = __esm({
+  "src/cli/commands/mysqlIntrospect.ts"() {
+    import_hanji8 = __toESM(require_hanji());
+    init_views();
+    import_promise = __toESM(require_promise());
+    init_mysqlSerializer();
+    init_mysql_introspect();
+    init_global();
+    init_mjs();
+    init_drivers();
+    mysqlPushIntrospect = async (connection, filters) => {
+      const { client, databaseName } = connection;
+      const matchers = filters.map((it) => {
+        return new Minimatch(it);
+      });
+      const filter2 = (tableName) => {
+        if (matchers.length === 0)
+          return true;
+        for (let i = 0; i < matchers.length; i++) {
+          const matcher = matchers[i];
+          if (matcher.match(tableName))
+            return true;
+        }
+        return false;
+      };
+      const res = await fromDatabase(client, databaseName, filter2);
+      const schema4 = { id: originUUID, prevId: "", ...res };
+      const { internal, ...schemaWithoutInternals } = schema4;
+      return { schema: schemaWithoutInternals };
+    };
+  }
+});
+
+// src/cli/commands/mysqlPushUtils.ts
+var mysqlPushUtils_exports = {};
+__export(mysqlPushUtils_exports, {
+  filterStatements: () => filterStatements,
+  logSuggestionsAndReturn: () => logSuggestionsAndReturn2
+});
+var import_hanji9, filterStatements, logSuggestionsAndReturn2;
+var init_mysqlPushUtils = __esm({
+  "src/cli/commands/mysqlPushUtils.ts"() {
+    init_source();
+    import_hanji9 = __toESM(require_hanji());
+    init_mysqlSchema();
+    init_selector_ui();
+    filterStatements = (statements, currentSchema, prevSchema) => {
+      return statements.filter((statement) => {
+        if (statement.type === "alter_table_alter_column_set_type") {
+          if (statement.oldDataType.startsWith("tinyint") && statement.newDataType.startsWith("boolean")) {
+            return false;
+          }
+          if (statement.oldDataType.startsWith("bigint unsigned") && statement.newDataType.startsWith("serial")) {
+            return false;
+          }
+          if (statement.oldDataType.startsWith("serial") && statement.newDataType.startsWith("bigint unsigned")) {
+            return false;
+          }
+        } else if (statement.type === "alter_table_alter_column_set_default") {
+          if (statement.newDefaultValue === false && statement.oldDefaultValue === 0 && statement.newDataType === "boolean") {
+            return false;
+          }
+          if (statement.newDefaultValue === true && statement.oldDefaultValue === 1 && statement.newDataType === "boolean") {
+            return false;
+          }
+        } else if (statement.type === "delete_unique_constraint") {
+          const unsquashed = MySqlSquasher.unsquashUnique(statement.data);
+          if (unsquashed.columns.length === 1 && currentSchema.tables[statement.tableName].columns[unsquashed.columns[0]].type === "serial" && prevSchema.tables[statement.tableName].columns[unsquashed.columns[0]].type === "serial" && currentSchema.tables[statement.tableName].columns[unsquashed.columns[0]].name === unsquashed.columns[0]) {
+            return false;
+          }
+        } else if (statement.type === "alter_table_alter_column_drop_notnull") {
+          const serialStatement = statements.find(
+            (it) => it.type === "alter_table_alter_column_set_type"
+          );
+          if ((serialStatement == null ? void 0 : serialStatement.oldDataType.startsWith("bigint unsigned")) && (serialStatement == null ? void 0 : serialStatement.newDataType.startsWith("serial")) && serialStatement.columnName === statement.columnName && serialStatement.tableName === statement.tableName) {
+            return false;
+          }
+          if (statement.newDataType === "serial" && !statement.columnNotNull) {
+            return false;
+          }
+          if (statement.columnAutoIncrement) {
+            return false;
+          }
+        }
+        return true;
+      });
+    };
+    logSuggestionsAndReturn2 = async ({
+      connection,
+      statements
+    }) => {
+      let shouldAskForApprove = false;
+      const statementsToExecute = [];
+      const infoToPrint = [];
+      const tablesToRemove = [];
+      const columnsToRemove = [];
+      const schemasToRemove = [];
+      const tablesToTruncate = [];
+      for (const statement of statements) {
+        if (statement.type === "drop_table") {
+          const res = await connection.query(
+            `select count(*) as count from \`${statement.tableName}\``
+          );
+          const count = Number(res[0].count);
+          if (count > 0) {
+            infoToPrint.push(
+              `\xB7 You're about to delete ${source_default.underline(
+                statement.tableName
+              )} table with ${count} items`
+            );
+            tablesToRemove.push(statement.tableName);
+            shouldAskForApprove = true;
+          }
+        } else if (statement.type === "alter_table_drop_column") {
+          const res = await connection.query(
+            `select count(*) as count from \`${statement.tableName}\``
+          );
+          const count = Number(res[0].count);
+          if (count > 0) {
+            infoToPrint.push(
+              `\xB7 You're about to delete ${source_default.underline(
+                statement.columnName
+              )} column in ${statement.tableName} table with ${count} items`
+            );
+            columnsToRemove.push(`${statement.tableName}_${statement.columnName}`);
+            shouldAskForApprove = true;
+          }
+        } else if (statement.type === "drop_schema") {
+          const res = await connection.query(
+            `select count(*) as count from information_schema.tables where table_schema = \`${statement.name}\`;`
+          );
+          const count = Number(res[0].count);
+          if (count > 0) {
+            infoToPrint.push(
+              `\xB7 You're about to delete ${source_default.underline(
+                statement.name
+              )} schema with ${count} tables`
+            );
+            schemasToRemove.push(statement.name);
+            shouldAskForApprove = true;
+          }
+        } else if (statement.type === "alter_table_alter_column_set_type") {
+          const res = await connection.query(
+            `select count(*) as count from \`${statement.tableName}\``
+          );
+          const count = Number(res[0].count);
+          if (count > 0) {
+            infoToPrint.push(
+              `\xB7 You're about to change ${source_default.underline(
+                statement.columnName
+              )} column type from ${source_default.underline(
+                statement.oldDataType
+              )} to ${source_default.underline(statement.newDataType)} with ${count} items`
+            );
+            statementsToExecute.push(`truncate table ${statement.tableName};`);
+            tablesToTruncate.push(statement.tableName);
+            shouldAskForApprove = true;
+          }
+        } else if (statement.type === "alter_table_alter_column_drop_default") {
+          if (statement.columnNotNull) {
+            const res = await connection.query(
+              `select count(*) as count from \`${statement.tableName}\``
+            );
+            const count = Number(res[0].count);
+            if (count > 0) {
+              infoToPrint.push(
+                `\xB7 You're about to remove default value from ${source_default.underline(
+                  statement.columnName
+                )} not-null column with ${count} items`
+              );
+              tablesToTruncate.push(statement.tableName);
+              statementsToExecute.push(`truncate table ${statement.tableName};`);
+              shouldAskForApprove = true;
+            }
+          }
+          shouldAskForApprove = true;
+        } else if (statement.type === "alter_table_alter_column_set_notnull") {
+          if (typeof statement.columnDefault === "undefined") {
+            const res = await connection.query(
+              `select count(*) as count from \`${statement.tableName}\``
+            );
+            const count = Number(res[0].count);
+            if (count > 0) {
+              infoToPrint.push(
+                `\xB7 You're about to set not-null constraint to ${source_default.underline(
+                  statement.columnName
+                )} column without default, which contains ${count} items`
+              );
+              tablesToTruncate.push(statement.tableName);
+              statementsToExecute.push(`truncate table ${statement.tableName};`);
+              shouldAskForApprove = true;
+            }
+          }
+        } else if (statement.type === "alter_table_alter_column_drop_pk") {
+          const res = await connection.query(
+            `select count(*) as count from \`${statement.tableName}\``
+          );
+          const count = Number(res[0].count);
+          if (count > 0) {
+            infoToPrint.push(
+              `\xB7 You're about to change ${source_default.underline(
+                statement.tableName
+              )} primary key. This statements may fail and you table may left without primary key`
+            );
+            tablesToTruncate.push(statement.tableName);
+            shouldAskForApprove = true;
+          }
+        } else if (statement.type === "alter_table_add_column") {
+          if (statement.column.notNull && typeof statement.column.default === "undefined") {
+            const res = await connection.query(
+              `select count(*) as count from \`${statement.tableName}\``
+            );
+            const count = Number(res[0].count);
+            if (count > 0) {
+              infoToPrint.push(
+                `\xB7 You're about to add not-null ${source_default.underline(
+                  statement.column.name
+                )} column without default value, which contains ${count} items`
+              );
+              tablesToTruncate.push(statement.tableName);
+              statementsToExecute.push(`truncate table ${statement.tableName};`);
+              shouldAskForApprove = true;
+            }
+          }
+        } else if (statement.type === "create_unique_constraint") {
+          const res = await connection.query(
+            `select count(*) as count from \`${statement.tableName}\``
+          );
+          const count = Number(res[0].count);
+          if (count > 0) {
+            const unsquashedUnique = MySqlSquasher.unsquashUnique(statement.data);
+            console.log(
+              `\xB7 You're about to add ${source_default.underline(
+                unsquashedUnique.name
+              )} unique constraint to the table, which contains ${count} items. If this statement fails, you will receive an error from the database. Do you want to truncate ${source_default.underline(
+                statement.tableName
+              )} table?
+`
+            );
+            const { status, data } = await (0, import_hanji9.render)(
+              new Select([
+                "No, add the constraint without truncating the table",
+                `Yes, truncate the table`
+              ])
+            );
+            if ((data == null ? void 0 : data.index) === 1) {
+              tablesToTruncate.push(statement.tableName);
+              statementsToExecute.push(`truncate table ${statement.tableName};`);
+              shouldAskForApprove = true;
+            }
+          }
+        }
+      }
+      return {
+        statementsToExecute,
+        shouldAskForApprove,
+        infoToPrint,
+        columnsToRemove: [...new Set(columnsToRemove)],
+        schemasToRemove: [...new Set(schemasToRemove)],
+        tablesToTruncate: [...new Set(tablesToTruncate)],
+        tablesToRemove: [...new Set(tablesToRemove)]
+      };
+    };
+  }
+});
+
 // src/utils.ts
 var utils_exports = {};
 __export(utils_exports, {
@@ -56897,12 +57505,18 @@ __export(utils_exports, {
   dryJournal: () => dryJournal,
   generateDrizzleJson: () => generateDrizzleJson,
   generateMigration: () => generateMigration,
+  generateMySQLDrizzleJson: () => generateMySQLDrizzleJson,
+  generateMySQLMigration: () => generateMySQLMigration,
+  generateSQLiteDrizzleJson: () => generateSQLiteDrizzleJson,
+  generateSQLiteMigration: () => generateSQLiteMigration,
   kloudMeta: () => kloudMeta,
   mapValues: () => mapValues,
   prepareFrom: () => prepareFrom,
   prepareMigrationFolder: () => prepareMigrationFolder,
   prepareMigrationMeta: () => prepareMigrationMeta,
   prepareOutFolder: () => prepareOutFolder2,
+  pushMySQLSchema: () => pushMySQLSchema,
+  pushSQLiteSchema: () => pushSQLiteSchema,
   pushSchema: () => pushSchema,
   schemaRenameKey: () => schemaRenameKey,
   snapshotsPriorV4: () => snapshotsPriorV4,
@@ -56911,7 +57525,7 @@ __export(utils_exports, {
   validateWithReport: () => validateWithReport
 });
 module.exports = __toCommonJS(utils_exports);
-var import_fs4, import_path3, import_crypto2, assertV1OutFolder, dryJournal, snapshotsPriorV4, prepareOutFolder2, mapValues, validatorForDialect, validateWithReport, prepareMigrationFolder, prepareMigrationMeta, schemaRenameKey, tableRenameKey, columnRenameKey, kloudMeta, statementsForDiffs, generateDrizzleJson, generateMigration, pushSchema, prepareFrom;
+var import_fs4, import_path3, import_crypto2, import_drizzle_orm15, assertV1OutFolder, dryJournal, snapshotsPriorV4, prepareOutFolder2, mapValues, validatorForDialect, validateWithReport, prepareMigrationFolder, prepareMigrationMeta, schemaRenameKey, tableRenameKey, columnRenameKey, kloudMeta, statementsForDiffs, generateDrizzleJson, generateMigration, pushSchema, prepareFrom, generateSQLiteDrizzleJson, generateSQLiteMigration, pushSQLiteSchema, generateMySQLDrizzleJson, generateMySQLMigration, pushMySQLSchema;
 var init_utils5 = __esm({
   "src/utils.ts"() {
     import_fs4 = require("fs");
@@ -56935,6 +57549,10 @@ var init_utils5 = __esm({
     init_pgSerializer();
     init_studioUtils();
     init_pgConnect();
+    init_sqlitePushUtils();
+    init_mysqlSerializer();
+    init_mysqlIntrospect();
+    import_drizzle_orm15 = require("drizzle-orm");
     assertV1OutFolder = (out, dialect6) => {
       if (!(0, import_fs4.existsSync)(out))
         return;
@@ -57184,7 +57802,7 @@ var init_utils5 = __esm({
       return { ...result, left, right };
     };
     generateDrizzleJson = (imports, prevId) => {
-      const prepared = prepareFromExports(imports);
+      const prepared = prepareFromExports2(imports);
       const id = (0, import_crypto2.randomUUID)();
       const snapshot = generatePgSnapshot(
         prepared.tables,
@@ -57288,6 +57906,134 @@ var init_utils5 = __esm({
       }
       throw Error("Only sqlite and pg is supported for now");
     };
+    generateSQLiteDrizzleJson = async (imports, prevId) => {
+      const { prepareFromExports: prepareFromExports4 } = await Promise.resolve().then(() => (init_sqliteImports(), sqliteImports_exports));
+      const prepared = prepareFromExports4(imports);
+      const id = (0, import_crypto2.randomUUID)();
+      const snapshot = generateSqliteSnapshot(prepared.tables, prepared.enums);
+      return {
+        ...snapshot,
+        id,
+        prevId: prevId ?? originUUID
+      };
+    };
+    generateSQLiteMigration = async (prev, cur) => {
+      const { prepareSQL: prepareSQL2 } = await Promise.resolve().then(() => (init_migrate(), migrate_exports));
+      const validatedPrev = sqliteSchema.parse(prev);
+      const validatedCur = sqliteSchema.parse(cur);
+      const squashedPrev = squashSqliteScheme(validatedPrev);
+      const squashedCur = squashSqliteScheme(validatedCur);
+      const { sqlStatements, _meta } = await prepareSQL2(
+        squashedPrev,
+        squashedCur,
+        "sqlite",
+        validatedPrev,
+        validatedCur
+      );
+      return sqlStatements;
+    };
+    pushSQLiteSchema = async (imports, db) => {
+      const { prepareSQL: prepareSQL2 } = await Promise.resolve().then(() => (init_migrate(), migrate_exports));
+      const { DrizzleORMSQLiteClient: DrizzleORMSQLiteClient2 } = await Promise.resolve().then(() => (init_drivers(), drivers_exports));
+      const client = new DrizzleORMSQLiteClient2(db);
+      const cur = generateSQLiteDrizzleJson(imports);
+      const { schema: prev } = await sqlitePushIntrospect(client, []);
+      const validatedPrev = sqliteSchema.parse(prev);
+      const validatedCur = sqliteSchema.parse(cur);
+      const squashedPrev = squashSqliteScheme(validatedPrev);
+      const squashedCur = squashSqliteScheme(validatedCur);
+      const { statements, _meta } = await prepareSQL2(
+        squashedPrev,
+        squashedCur,
+        "sqlite",
+        validatedPrev,
+        validatedCur
+      );
+      const { shouldAskForApprove, statementsToExecute, infoToPrint } = await logSuggestionsAndReturn({
+        connection: client,
+        statements,
+        json1: squashedPrev,
+        json2: squashedCur,
+        meta: _meta
+      });
+      return {
+        hasDataLoss: shouldAskForApprove,
+        warnings: infoToPrint,
+        statementsToExecute,
+        apply: async () => {
+          for (const dStmnt of statementsToExecute) {
+            await client.query(dStmnt);
+          }
+        }
+      };
+    };
+    (0, import_drizzle_orm15.eq)({}, 1);
+    generateMySQLDrizzleJson = async (imports, prevId) => {
+      const { prepareFromExports: prepareFromExports4 } = await Promise.resolve().then(() => (init_mysqlImports(), mysqlImports_exports));
+      const prepared = prepareFromExports4(imports);
+      const id = (0, import_crypto2.randomUUID)();
+      const snapshot = generateMySqlSnapshot(
+        prepared.tables,
+        prepared.enums,
+        prepared.schemas
+      );
+      return {
+        ...snapshot,
+        id,
+        prevId: prevId ?? originUUID
+      };
+    };
+    generateMySQLMigration = async (prev, cur) => {
+      const { prepareSQL: prepareSQL2 } = await Promise.resolve().then(() => (init_migrate(), migrate_exports));
+      const validatedPrev = mysqlSchema.parse(prev);
+      const validatedCur = mysqlSchema.parse(cur);
+      const squashedPrev = squashMysqlScheme(validatedPrev);
+      const squashedCur = squashMysqlScheme(validatedCur);
+      const { sqlStatements, _meta } = await prepareSQL2(
+        squashedPrev,
+        squashedCur,
+        "mysql",
+        validatedPrev,
+        validatedCur
+      );
+      return sqlStatements;
+    };
+    pushMySQLSchema = async (imports, db, databaseName) => {
+      const { prepareSQL: prepareSQL2 } = await Promise.resolve().then(() => (init_migrate(), migrate_exports));
+      const { DrizzleORMMySQLClient: DrizzleORMMySQLClient2 } = await Promise.resolve().then(() => (init_drivers(), drivers_exports));
+      const { logSuggestionsAndReturn: logSuggestionsAndReturn3 } = await Promise.resolve().then(() => (init_mysqlPushUtils(), mysqlPushUtils_exports));
+      const client = new DrizzleORMMySQLClient2(db);
+      const cur = generateMySQLDrizzleJson(imports);
+      const { schema: prev } = await mysqlPushIntrospect(
+        { client, databaseName },
+        []
+      );
+      const validatedPrev = mysqlSchema.parse(prev);
+      const validatedCur = mysqlSchema.parse(cur);
+      const squashedPrev = squashMysqlScheme(validatedPrev);
+      const squashedCur = squashMysqlScheme(validatedCur);
+      const { statements, _meta } = await prepareSQL2(
+        squashedPrev,
+        squashedCur,
+        "mysql",
+        validatedPrev,
+        validatedCur
+      );
+      const { shouldAskForApprove, statementsToExecute, infoToPrint } = await logSuggestionsAndReturn3({
+        connection: client,
+        statements
+      });
+      return {
+        hasDataLoss: shouldAskForApprove,
+        warnings: infoToPrint,
+        statementsToExecute,
+        apply: async () => {
+          for (const dStmnt of statementsToExecute) {
+            await client.query(dStmnt);
+          }
+        }
+      };
+    };
   }
 });
 init_utils5();
@@ -57298,12 +58044,18 @@ init_utils5();
   dryJournal,
   generateDrizzleJson,
   generateMigration,
+  generateMySQLDrizzleJson,
+  generateMySQLMigration,
+  generateSQLiteDrizzleJson,
+  generateSQLiteMigration,
   kloudMeta,
   mapValues,
   prepareFrom,
   prepareMigrationFolder,
   prepareMigrationMeta,
   prepareOutFolder,
+  pushMySQLSchema,
+  pushSQLiteSchema,
   pushSchema,
   schemaRenameKey,
   snapshotsPriorV4,