drizzle-kit 0.19.12 → 0.19.13-53915b2

package/index.cjs

@@ -4831,7 +4831,7 @@ var init_mysqlSchema = __esm({
 });
 
 // src/serializer/pgSchema.ts
-var indexV2, columnV2, tableV2, enumSchema, pgSchemaV2, references, columnV1, tableV1, pgSchemaV1, index2, fk2, column2, tableV32, compositePK2, uniqueConstraint2, tableV42, table2, schemaHash2, pgSchemaInternalV3, pgSchemaInternalV4, pgSchemaExternal, pgSchemaInternal, tableSquashed2, tableSquashedV42, pgSchemaSquashedV4, pgSchemaSquashed, pgSchemaV3, pgSchemaV4, pgSchema, backwardCompatiblePgSchema, PgSquasher, squashPgSchemeV4, squashPgScheme, dryPg;
+var indexV2, columnV2, tableV2, enumSchema, pgSchemaV2, references, columnV1, tableV1, pgSchemaV1, index2, fk2, column2, tableV32, compositePK2, uniqueConstraint2, tableV42, table2, schemaHash2, pgSchemaInternalV3, pgSchemaInternalV4, pgSchemaExternal, kitInternals2, pgSchemaInternal, tableSquashed2, tableSquashedV42, pgSchemaSquashedV4, pgSchemaSquashed, pgSchemaV3, pgSchemaV4, pgSchema, backwardCompatiblePgSchema, PgSquasher, squashPgSchemeV4, squashPgScheme, dryPg;
 var init_pgSchema = __esm({
   "src/serializer/pgSchema.ts"() {
     init_global();
@@ -4978,6 +4978,21 @@ var init_pgSchema = __esm({
         columns: recordType(stringType(), stringType())
       })
     }).strict();
+    kitInternals2 = objectType({
+      tables: recordType(
+        stringType(),
+        objectType({
+          columns: recordType(
+            stringType(),
+            objectType({
+              isArray: booleanType().optional(),
+              dimensions: numberType().optional(),
+              rawType: stringType().optional()
+            }).optional()
+          )
+        }).optional()
+      )
+    }).optional();
     pgSchemaInternal = objectType({
       version: literalType("5"),
       dialect: literalType("pg"),
@@ -4988,7 +5003,8 @@ var init_pgSchema = __esm({
         schemas: recordType(stringType(), stringType()),
         tables: recordType(stringType(), stringType()),
         columns: recordType(stringType(), stringType())
-      })
+      }),
+      internal: kitInternals2
     }).strict();
     tableSquashed2 = objectType({
       name: stringType(),
@@ -5057,12 +5073,12 @@ var init_pgSchema = __esm({
         return `${unq.name};${unq.columns.join(",")};${unq.nullsNotDistinct}`;
       },
       unsquashUnique: (unq) => {
-        const [
+        const [name, columns, nullsNotDistinct] = unq.split(";");
+        return {
           name,
-          columns,
-          nullsNotDistinct
-        ] = unq.split(";");
-        return { name, columns: columns.split(","), nullsNotDistinct: nullsNotDistinct === "true" };
+          columns: columns.split(","),
+          nullsNotDistinct: nullsNotDistinct === "true"
+        };
       },
       unsquashFK: (input) => {
         const [
@@ -5127,9 +5143,12 @@ var init_pgSchema = __esm({
           const squashedPKs = mapValues(it[1].compositePrimaryKeys, (pk) => {
             return PgSquasher.squashPK(pk);
           });
-          const squashedUniqueConstraints = mapValues(it[1].uniqueConstraints, (unq) => {
-            return PgSquasher.squashUnique(unq);
-          });
+          const squashedUniqueConstraints = mapValues(
+            it[1].uniqueConstraints,
+            (unq) => {
+              return PgSquasher.squashUnique(unq);
+            }
+          );
           return [
             it[0],
             {
@@ -11360,10 +11379,17 @@ var init_utils = __esm({
         (0, import_path.join)((0, import_path.resolve)("drizzle.config.json"))
       );
       const defaultConfigPath = defaultTsConfigExists ? "drizzle.config.ts" : defaultJsConfigExists ? "drizzle.config.js" : "drizzle.config.json";
+      if (configPath) {
+        console.log(
+          source_default.gray(
+            `Custom config path was provided, using '${configPath}'`
+          )
+        );
+      }
       if (!configPath) {
         console.log(
           source_default.gray(
-            `No config path provided, using default '${defaultConfigPath}'`
+            `No config path provided, using default path`
           )
         );
       }
@@ -12239,17 +12265,13 @@ ${withStyle.errorWarning(`We've found duplicated unique constraint names in ${so
         return map;
       }, {});
       const schemasObject = Object.fromEntries(
-        schemas.filter(
-          (it) => {
-            if (it.schemaName !== "public")
-              return true;
-            if (schemaFilter) {
-              return schemaFilter.includes(it.schemaName);
-            } else {
-              return true;
-            }
+        schemas.filter((it) => {
+          if (schemaFilter) {
+            return schemaFilter.includes(it.schemaName) && it.schemaName !== "public";
+          } else {
+            return it.schemaName !== "public";
           }
-        ).map((it) => [it.schemaName, it.schemaName])
+        }).map((it) => [it.schemaName, it.schemaName])
       );
       return {
         version: "5",
@@ -12275,12 +12297,25 @@ ${withStyle.errorWarning(`We've found duplicated unique constraint names in ${so
     };
     fromDatabase2 = async (db, tablesFilter = (table4) => true, schemaFilters, progressCallback) => {
       const result = {};
+      const internals = { tables: {} };
       const where = schemaFilters.map((t) => `table_schema = '${t}'`).join(" or ");
       const allTables = await db.query(
         `SELECT table_schema, table_name FROM information_schema.tables WHERE ${where};`
       );
       const schemas = new Set(allTables.map((it) => it.table_schema));
       schemas.delete("public");
+      const allSchemas = await db.query(`select s.nspname as table_schema
+  from pg_catalog.pg_namespace s
+  join pg_catalog.pg_user u on u.usesysid = s.nspowner
+  where nspname not in ('information_schema', 'pg_catalog', 'public')
+        and nspname not like 'pg_toast%'
+        and nspname not like 'pg_temp_%'
+  order by table_schema;`);
+      allSchemas.forEach((item) => {
+        if (schemaFilters.includes(item.table_schema)) {
+          schemas.add(item.table_schema);
+        }
+      });
       let columnsCount = 0;
       let indexesCount = 0;
       let foreignKeysCount = 0;
@@ -12438,6 +12473,33 @@ ${withStyle.errorWarning(`We've found duplicated unique constraint names in ${so
               if (columnTypeMapped.startsWith("numeric(")) {
                 columnTypeMapped = columnTypeMapped.replace(",", ", ");
               }
+              if (columnAdditionalDT === "ARRAY") {
+                if (typeof internals.tables[tableName] === "undefined") {
+                  internals.tables[tableName] = {
+                    columns: {
+                      [columnName]: {
+                        isArray: true,
+                        dimensions: columnDimensions,
+                        rawType: columnTypeMapped.substring(
+                          0,
+                          columnTypeMapped.length - 2
+                        )
+                      }
+                    }
+                  };
+                } else {
+                  if (typeof internals.tables[tableName].columns[columnName] === "undefined") {
+                    internals.tables[tableName].columns[columnName] = {
+                      isArray: true,
+                      dimensions: columnDimensions,
+                      rawType: columnTypeMapped.substring(
+                        0,
+                        columnTypeMapped.length - 2
+                      )
+                    };
+                  }
+                }
+              }
               if (columnAdditionalDT === "ARRAY") {
                 for (let i = 1; i < Number(columnDimensions); i++) {
                   columnTypeMapped += "[]";
@@ -12562,7 +12624,8 @@ ${withStyle.errorWarning(`We've found duplicated unique constraint names in ${so
           schemas: {},
           tables: {},
           columns: {}
-        }
+        },
+        internal: internals
       };
     };
     columnToDefault = {
@@ -14652,14 +14715,14 @@ var init_migrate = __esm({
         const validatedCur = sqliteSchema.parse(cur);
         const squashedPrev = squashSqliteScheme(validatedPrev);
         const squashedCur = squashSqliteScheme(validatedCur);
-        const { sqlStatements, statements } = await prepareSQL(
+        const { sqlStatements, statements, _meta } = await prepareSQL(
           squashedPrev,
           squashedCur,
           "sqlite",
           validatedPrev,
           validatedCur
         );
-        return { sqlStatements, statements, squashedPrev, squashedCur };
+        return { sqlStatements, statements, squashedPrev, squashedCur, meta: _meta };
       } catch (e) {
         console.error(e);
       }
@@ -17494,12 +17557,12 @@ var init_snapshotsDiffer = __esm({
         });
         jsonStatements.push(...jsonMySqlCreateTables);
       }
-      jsonStatements.push(...jsonDroppedReferencesForAlteredTables);
       jsonStatements.push(...jsonDropTables);
       jsonStatements.push(...jsonRenameTables);
       jsonStatements.push(...jsonRenameColumnsStatements);
       jsonStatements.push(...jsonDeletedCompositePKs);
       jsonStatements.push(...jsonDeletedUniqueConstraints);
+      jsonStatements.push(...jsonDroppedReferencesForAlteredTables);
       jsonStatements.push(...jsonDropIndexesForAllAlteredTables);
       jsonStatements.push(...jsonTableAlternations.alterColumns);
       jsonStatements.push(...jsonTableAlternations.createColumns);
@@ -36329,7 +36392,7 @@ import { sql } from "drizzle-orm"
         statement += `${it.columns.map((c) => {
           return `table.${withCasing(c, casing)}`;
         }).join(", ")}`;
-        statement += ")";
+        statement += "),";
         statement += `
 `;
       });
@@ -42408,16 +42471,25 @@ var init_introspect = __esm({
             (idx) => idx.isUnique ? "uniqueIndex" : "index"
           );
           const fkImpots = Object.values(it.foreignKeys).map((it2) => "foreignKey");
+          if (Object.values(it.foreignKeys).some((it2) => isCyclic2(it2) && !isSelf2(it2))) {
+            res.pg.push("type AnyPgColumn");
+          }
           const pkImports = Object.values(it.compositePrimaryKeys).map(
             (it2) => "primaryKey"
           );
           const uniqueImports = Object.values(it.uniqueConstraints).map(
             (it2) => "unique"
           );
+          if (it.schema && it.schema !== "public" && it.schema !== "") {
+            res.pg.push("pgSchema");
+          }
           res.pg.push(...idxImports);
           res.pg.push(...fkImpots);
           res.pg.push(...pkImports);
           res.pg.push(...uniqueImports);
+          if (enumTypes.size > 0) {
+            res.pg.push("pgEnum");
+          }
           const columnImports = Object.values(it.columns).map((col) => {
             let patched = importsPatch2[col.type] ?? col.type;
             patched = patched.startsWith("varchar(") ? "varchar" : patched;
@@ -42444,18 +42516,20 @@ var init_introspect = __esm({
 `;
       }).join();
       const tableStatements = Object.values(schema4.tables).map((table4) => {
-        const schema5 = schemas[table4.schema];
-        const func = schema5 ? `${schema5}.table` : "pgTable";
+        const tableSchema = schemas[table4.schema];
+        const func = tableSchema ? `${tableSchema}.table` : "pgTable";
         let statement = `export const ${withCasing2(
           table4.name,
           casing
         )} = ${func}("${table4.name}", {
 `;
         statement += createTableColumns2(
+          table4.name,
           Object.values(table4.columns),
           Object.values(table4.foreignKeys),
           enumTypes,
-          casing
+          casing,
+          schema4.internal
         );
         statement += "}";
         const filteredFKs = Object.values(table4.foreignKeys).filter((it) => {
@@ -42485,22 +42559,16 @@ var init_introspect = __esm({
         statement += ");";
         return statement;
       });
-      const uniquePgImports = [
-        "pgTable",
-        "pgEnum",
-        "pgSchema",
-        "AnyPgColumn",
-        ...new Set(imports.pg)
-      ];
+      const uniquePgImports = ["pgTable", ...new Set(imports.pg)];
       let result = `import { ${uniquePgImports.join(
         ", "
       )} } from "drizzle-orm/pg-core"
 
 `;
-      result += enumStatements;
-      result += schemaStatements;
       result += `import { sql } from "drizzle-orm"
 `;
+      result += enumStatements;
+      result += schemaStatements;
       result += "\n";
       result += tableStatements.join("\n\n");
       return result;
@@ -42513,7 +42581,8 @@ var init_introspect = __esm({
     isSelf2 = (fk4) => {
       return fk4.tableFrom === fk4.tableTo;
     };
-    column5 = (type, name, enumTypes, defaultValue, casing) => {
+    column5 = (tableName, type, name, enumTypes, defaultValue, casing, internals) => {
+      var _a;
       const lowered = type.toLowerCase();
       if (lowered.startsWith("serial")) {
         return `${withCasing2(name, casing)}: serial("${name}")`;
@@ -42687,6 +42756,17 @@ var init_introspect = __esm({
         out += typeof defaultValue !== "undefined" ? `.default(${defaultValue})` : "";
         return out;
       }
+      const columnInternals = (_a = internals == null ? void 0 : internals.tables[tableName]) == null ? void 0 : _a.columns[name];
+      if (typeof columnInternals !== "undefined") {
+        if (columnInternals.isArray && columnInternals.rawType && enumTypes.has(columnInternals.rawType)) {
+          let out = `${withCasing2(columnInternals.rawType, casing)}: ${withCasing2(
+            columnInternals.rawType,
+            casing
+          )}("${name}")`;
+          out += typeof defaultValue !== "undefined" ? `.default(${defaultValue})` : "";
+          return out;
+        }
+      }
       if (enumTypes.has(type)) {
         let out = `${withCasing2(name, casing)}: ${withCasing2(
           type,
@@ -42700,16 +42780,16 @@ var init_introspect = __esm({
       unknown += `	${withCasing2(name, casing)}: unknown("${name}")`;
       return unknown;
     };
-    dimensionsInArray = (str) => {
+    dimensionsInArray = (size) => {
       let res = "";
-      for (let i = 0; i < str.length; i++) {
-        if (str[i] === "[" && str[i + 1] === "]") {
-          res += ".array()";
-        }
+      if (typeof size === "undefined")
+        return res;
+      for (let i = 0; i < size; i++) {
+        res += ".array()";
       }
       return res;
     };
-    createTableColumns2 = (columns, fks, enumTypes, casing) => {
+    createTableColumns2 = (tableName, columns, fks, enumTypes, casing, internals) => {
       let statement = "";
       const oneColumnsFKs = Object.values(fks).filter((it) => {
         return !isSelf2(it);
@@ -42721,16 +42801,23 @@ var init_introspect = __esm({
         return res;
       }, {});
       columns.forEach((it) => {
+        var _a, _b, _c, _d;
         const columnStatement = column5(
+          tableName,
           it.type,
           it.name,
           enumTypes,
           it.default,
-          casing
+          casing,
+          internals
         );
         statement += "	";
         statement += columnStatement;
-        statement += dimensionsInArray(it.type);
+        if ((_b = (_a = internals == null ? void 0 : internals.tables[tableName]) == null ? void 0 : _a.columns[it.name]) == null ? void 0 : _b.isArray) {
+          statement += dimensionsInArray(
+            (_d = (_c = internals == null ? void 0 : internals.tables[tableName]) == null ? void 0 : _c.columns[it.name]) == null ? void 0 : _d.dimensions
+          );
+        }
         statement += it.primaryKey ? ".primaryKey()" : "";
         statement += it.notNull ? ".notNull()" : "";
         const fks2 = fkByColumnName[it.name];
@@ -42909,7 +42996,8 @@ var init_pgIntrospect = __esm({
       };
       const res = await fromDatabase2(client, filter2, schemaFilters);
       const schema4 = { id: originUUID, prevId: "", ...res };
-      return { schema: schema4 };
+      const { internal, ...schemaWithoutInternals } = schema4;
+      return { schema: schemaWithoutInternals };
     };
     pgIntrospect = async (config, filters, schemaFilters) => {
       const pool = await connectToPg(config);
@@ -42935,7 +43023,8 @@ var init_pgIntrospect = __esm({
       );
       const schema4 = { id: originUUID, prevId: "", ...res };
       const ts = schemaToTypeScript2(schema4, { casing: config.introspect.casing });
-      return { schema: schema4, ts };
+      const { internal, ...schemaWithoutInternals } = schema4;
+      return { schema: schemaWithoutInternals, ts };
     };
   }
 });
@@ -51891,7 +51980,7 @@ var init_studio = __esm({
     printDriverIssues = (options) => {
       if (options.driver === "pg") {
         printConfigConnectionIssues2(options);
-      } else if (options.driver === "mysql") {
+      } else if (options.driver === "mysql2") {
         printConfigConnectionIssues3(options);
       } else if (["libsql", "turso", "better-sqlite"].includes(options.driver)) {
         printConfigConnectionIssues(options);
@@ -52126,7 +52215,7 @@ init_source();
 // package.json
 var package_default = {
   name: "drizzle-kit",
-  version: "0.19.12",
+  version: "0.19.13",
   repository: "https://github.com/drizzle-team/drizzle-kit-mirror",
   author: "Drizzle Team",
   license: "MIT",
@@ -52179,7 +52268,7 @@ var package_default = {
     ]
   },
   dependencies: {
-    "@drizzle-team/studio": "^0.0.5",
+    "@drizzle-team/studio": "^0.0.8",
     "@esbuild-kit/esm-loader": "^2.5.5",
     camelcase: "^7.0.1",
     chalk: "^5.2.0",
@@ -52563,11 +52652,30 @@ var _moveDataStatements = (tableName, json, dataLoss = false) => {
   }
   return statements;
 };
+var 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;
+};
+var getNewTableName = (tableName, meta) => {
+  if (typeof meta.tables[`"${tableName}"`] !== "undefined") {
+    return meta.tables[`"${tableName}"`].substring(
+      1,
+      meta.tables[`"${tableName}"`].length - 1
+    );
+  }
+  return tableName;
+};
 var logSuggestionsAndReturn2 = async ({
   connection,
   statements,
   json1,
-  json2
+  json2,
+  meta
 }) => {
   let shouldAskForApprove = false;
   const statementsToExecute = [];
@@ -52595,43 +52703,44 @@ var logSuggestionsAndReturn2 = async ({
       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[statement.tableName].compositePrimaryKeys
+        json1.tables[newTableName].compositePrimaryKeys
       ).find(
         (c) => SQLiteSquasher.unsquashPK(c).includes(statement.columnName)
       );
       const columnIsPartOfIndex = Object.values(
-        json1.tables[statement.tableName].indexes
+        json1.tables[newTableName].indexes
       ).find(
         (c) => SQLiteSquasher.unsquashIdx(c).columns.includes(statement.columnName)
       );
-      const columnIsPk = json1.tables[statement.tableName].columns[statement.columnName].primaryKey;
+      const columnIsPk = json1.tables[newTableName].columns[statement.columnName].primaryKey;
       const columnIsPartOfFk = Object.values(
-        json1.tables[statement.tableName].foreignKeys
+        json1.tables[newTableName].foreignKeys
       ).find(
         (t) => SQLiteSquasher.unsquashFK(t).columnsFrom.includes(statement.columnName)
       );
       const res = await connection.query(
-        `select count(*) as count from \`${statement.tableName}\``
+        `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 ${statement.tableName} table with ${count} items`
+          )} column in ${newTableName} table with ${count} items`
         );
-        columnsToRemove.push(`${statement.tableName}_${statement.columnName}`);
+        columnsToRemove.push(`${newTableName}_${statement.columnName}`);
         shouldAskForApprove = true;
       }
       if (columnIsPk || columnIsPartOfPk || columnIsPartOfIndex || columnIsPartOfFk) {
-        tablesContext[statement.tableName] = [
+        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 === statement.tableName
+            (t) => SQLiteSquasher.unsquashFK(t).tableTo === newTableName
           ).map((t) => SQLiteSquasher.unsquashFK(t).tableFrom);
           tablesReferncingCurrent.push(...tablesRefs);
         }
@@ -52642,15 +52751,16 @@ var logSuggestionsAndReturn2 = async ({
           }
         }
       } else {
-        if (typeof tablesContext[statement.tableName] === "undefined") {
+        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 \`${statement.tableName}\``
+          `select count(*) as count from \`${newTableName}\``
         );
         const count = Number(res[0].count);
         if (count > 0) {
@@ -52659,19 +52769,19 @@ var logSuggestionsAndReturn2 = async ({
               statement.column.name
             )} column without default value, which contains ${count} items`
           );
-          tablesToTruncate.push(statement.tableName);
-          statementsToExecute.push(`delete from ${statement.tableName};`);
+          tablesToTruncate.push(newTableName);
+          statementsToExecute.push(`delete from ${newTableName};`);
           shouldAskForApprove = true;
         }
       }
       if (statement.column.primaryKey) {
-        tablesContext[statement.tableName] = [
+        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 === statement.tableName
+            (t) => SQLiteSquasher.unsquashFK(t).tableTo === newTableName
           ).map((t) => SQLiteSquasher.unsquashFK(t).tableFrom);
           tablesReferncingCurrent.push(...tablesRefs);
         }
@@ -52682,15 +52792,16 @@ var logSuggestionsAndReturn2 = async ({
           }
         }
       } else {
-        if (typeof tablesContext[statement.tableName] === "undefined") {
+        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 \`${statement.tableName}\``
+          `select count(*) as count from \`${newTableName}\``
         );
         const count = Number(res[0].count);
         if (count > 0) {
@@ -52699,17 +52810,17 @@ var logSuggestionsAndReturn2 = async ({
               statement.columnName
             )} column without default value, which contains ${count} items`
           );
-          tablesContext[statement.tableName] = _moveDataStatements(
-            statement.tableName,
-            json2,
-            true
-          );
-          tablesToTruncate.push(statement.tableName);
+          tablesToTruncate.push(newTableName);
           shouldAskForApprove = true;
         }
+        tablesContext[newTableName] = _moveDataStatements(
+          statement.tableName,
+          json2,
+          true
+        );
       } else {
-        if (typeof tablesContext[statement.tableName] === "undefined") {
-          tablesContext[statement.tableName] = _moveDataStatements(
+        if (typeof tablesContext[newTableName] === "undefined") {
+          tablesContext[newTableName] = _moveDataStatements(
             statement.tableName,
             json2
           );
@@ -52717,9 +52828,12 @@ var logSuggestionsAndReturn2 = async ({
       }
       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 === statement.tableName
-        ).map((t) => SQLiteSquasher.unsquashFK(t).tableFrom);
+        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)];
@@ -52730,16 +52844,20 @@ var logSuggestionsAndReturn2 = async ({
       }
     } else if (statement.type === "create_reference" || statement.type === "delete_reference" || statement.type === "alter_reference") {
       const fk4 = SQLiteSquasher.unsquashFK(statement.data);
-      if (typeof tablesContext[fk4.tableFrom] === "undefined") {
-        tablesContext[fk4.tableFrom] = _moveDataStatements(fk4.tableFrom, 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") {
       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") {
@@ -53012,7 +53130,7 @@ var optionsSchema = objectType({
 }).strict();
 var generatePgCommand = new import_commander.Command("generate:pg").option("--schema <schema...>", "Path to a schema file or folder").option("--out <out>", `Output folder, 'drizzle' by default`).option("--breakpoints", `Prepare SQL statements with breakpoints`).option("--custom", "Prepare empty migration file for custom SQL").option(
   "--config <config>",
-  "Path to a config.json file, drizzle.config.json by default"
+  "Path to a config.json file, drizzle.config.ts by default"
 ).action(async (options) => {
   await printVersions();
   await assertOrmCoreVersion();
@@ -53033,7 +53151,7 @@ var generatePgCommand = new import_commander.Command("generate:pg").option("--sc
 });
 var generateMysqlCommand = new import_commander.Command("generate:mysql").option("--schema <schema...>", "Path to a schema file or folder").option("--out <out>", `Output folder, 'drizzle' by default`).option("--breakpoints", `Prepare SQL statements with breakpoints`).option("--custom", "Prepare empty migration file for custom SQL").option(
   "--config <config>",
-  "Path to a config.json file, drizzle.config.json by default"
+  "Path to a config.json file, drizzle.config.ts by default"
 ).action(async (options) => {
   await printVersions();
   await assertOrmCoreVersion();
@@ -53081,7 +53199,7 @@ var Select = class extends import_hanji10.Prompt {
 };
 var dbPushMysqlCommand = new import_commander.Command("push:mysql").option(
   "--config <config>",
-  "Path to a config.json file, drizzle.config.json by default"
+  "Path to a config.json file, drizzle.config.ts by default"
 ).option("--schema <schema...>", "Path to a schema file or folder").option("--tablesFilter", `Table name filters`).option("--connectionString <connectionString>", "MySQL connection string").option("--driver <driver>", "MySQL database path").option("--connectionString <connectionString>", "MySQL connection string").option("--host <host>", "MySQL host").option("--port <port>", "MySQL port").option("--user <user>", "MySQL user").option("--password <password>", "MySQL password").option("--database <database>", "MySQL database name").option("--verbose", "Print all statements for each push").option("--strict", "Always ask for confirmation").action(async (options) => {
   await printVersions();
   await assertPackages("drizzle-orm");
@@ -53339,7 +53457,8 @@ var dbPushSqliteCommand = new import_commander.Command("push:sqlite").option(
         connection: connection.client,
         statements: statements.statements,
         json1: statements.squashedPrev,
-        json2: statements.squashedCur
+        json2: statements.squashedCur,
+        meta: statements.meta
       });
       if (res.verbose) {
         console.log();
@@ -53394,7 +53513,7 @@ var dbPushSqliteCommand = new import_commander.Command("push:sqlite").option(
 });
 var generateSqliteCommand = new import_commander.Command("generate:sqlite").option("--schema <schema...>", "Path to a schema file or folder").option("--out <out>", `Output folder, 'drizzle' by default`).option("--breakpoints", `Prepare SQL statements with breakpoints`).option("--custom", "Prepare empty migration file for custom SQL").option(
   "--config <config>",
-  "Path to a config.json file, drizzle.config.json by default"
+  "Path to a config.json file, drizzle.config.ts by default"
 ).action(async (options) => {
   await printVersions();
   await assertOrmCoreVersion();
@@ -53417,7 +53536,7 @@ var checkSchema = objectType({
   out: stringType().optional(),
   config: stringType().optional()
 }).strict();
-var checkPgCommand = new import_commander.Command("check:pg").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.json]`).action(async (options) => {
+var checkPgCommand = new import_commander.Command("check:pg").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.ts]`).action(async (options) => {
   await printVersions();
   await assertOrmCoreVersion();
   const collisionRes = checkCollisions(
@@ -53433,7 +53552,7 @@ var checkPgCommand = new import_commander.Command("check:pg").option("--out <out
   checkHandler(out, "pg");
   console.log("Everything's fine \u{1F436}\u{1F525}");
 });
-var checkSqliteCommand = new import_commander.Command("check:sqlite").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.json]`).action(async (options) => {
+var checkSqliteCommand = new import_commander.Command("check:sqlite").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.ts]`).action(async (options) => {
   await printVersions();
   await assertOrmCoreVersion();
   const collisionRes = checkCollisions(
@@ -53449,7 +53568,7 @@ var checkSqliteCommand = new import_commander.Command("check:sqlite").option("--
   checkHandler(out, "sqlite");
   console.log("Everything's fine \u{1F436}\u{1F525}");
 });
-var checkMySqlCommand = new import_commander.Command("check:mysql").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.json]`).action(async (options) => {
+var checkMySqlCommand = new import_commander.Command("check:mysql").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.ts]`).action(async (options) => {
   await printVersions();
   await assertOrmCoreVersion();
   const collisionRes = checkCollisions(
@@ -53465,7 +53584,7 @@ var checkMySqlCommand = new import_commander.Command("check:mysql").option("--ou
   checkHandler(out, "mysql");
   console.log("Everything's fine \u{1F436}\u{1F525}");
 });
-var upPgCommand = new import_commander.Command("up:pg").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.json]`).action(async (options) => {
+var upPgCommand = new import_commander.Command("up:pg").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.ts]`).action(async (options) => {
   await printVersions();
   await assertOrmCoreVersion();
   const collisionRes = checkCollisions(
@@ -53483,7 +53602,7 @@ var upPgCommand = new import_commander.Command("up:pg").option("--out <out>", `O
   upgradeFolders("pg", out);
   upPgHandler(out);
 });
-var upMysqlCommand = new import_commander.Command("up:mysql").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.json]`).action(async (options) => {
+var upMysqlCommand = new import_commander.Command("up:mysql").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.ts]`).action(async (options) => {
   await printVersions();
   await assertOrmCoreVersion();
   const collisionRes = checkCollisions(
@@ -53573,7 +53692,7 @@ var introspectPgCommand = new import_commander.Command("introspect:pg").option("
 });
 var introspectMySqlCommand = new import_commander.Command("introspect:mysql").option(
   "--config <config>",
-  "Path to a config.json file, drizzle.config.json by default"
+  "Path to a config.json file, drizzle.config.ts by default"
 ).option(
   "--introspect-casing <introspectCasing>",
   "Column object keys naming strategy"
@@ -53626,7 +53745,7 @@ var introspectMySqlCommand = new import_commander.Command("introspect:mysql").op
 });
 var introspectSQLiteCommand = new import_commander.Command("introspect:sqlite").option(
   "--config <config>",
-  "Path to a config.json file, drizzle.config.json by default"
+  "Path to a config.json file, drizzle.config.ts by default"
 ).option(
   "--introspect-casing <introspectCasing>",
   "Column object keys naming strategy"
@@ -53677,7 +53796,7 @@ var introspectSQLiteCommand = new import_commander.Command("introspect:sqlite").
   );
   process.exit(0);
 });
-var dropCommand = new import_commander.Command("drop").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.json]`).action(async (options) => {
+var dropCommand = new import_commander.Command("drop").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.ts]`).action(async (options) => {
   await printVersions();
   await assertOrmCoreVersion();
   const collisionRes = checkCollisions(
@@ -53693,7 +53812,7 @@ var dropCommand = new import_commander.Command("drop").option("--out <out>", `Ou
   assertV1OutFolder(out, "{dialect}");
   await dropMigration(out);
 });
-var studioCommand = new import_commander.Command("studio").option("--port <port>", "Custom port for drizzle studio [default=4983]").option("--verbose", "Print all stataments that are executed by Studio").option("--config <config>", `Config path [default=drizzle.config.ts]`).action(async (options) => {
+var studioCommand = new import_commander.Command("studio").option("--port <port>", "Custom port for drizzle studio [default=4983]").option("--host <host>", "Custom host for drizzle studio [default=0.0.0.0]").option("--verbose", "Print all stataments that are executed by Studio").option("--config <config>", `Config path [default=drizzle.config.ts]`).action(async (options) => {
   const { validateStudio: validateStudio2 } = await Promise.resolve().then(() => (init_studio(), studio_exports));
   const drizzleConfig = await validateStudio2(options);
   const { prepareModels: prepareModels2, drizzleDb: drizzleDb2 } = await Promise.resolve().then(() => (init_studioUtils(), studioUtils_exports));
@@ -53705,6 +53824,7 @@ var studioCommand = new import_commander.Command("studio").option("--port <port>
   );
   const server = await (0, import_studio.prepareServer)(setup);
   const port = options.port ?? 4983;
+  const host = options.host ?? "0.0.0.0";
   console.log();
   console.log(
     withStyle.fullWarning(
@@ -53712,7 +53832,7 @@ var studioCommand = new import_commander.Command("studio").option("--port <port>
     )
   );
   server.start({
-    host: "127.0.0.1",
+    host,
     port,
     cb: (err2, address) => {
       if (err2) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drizzle-kit",
-  "version": "0.19.12",
+  "version": "0.19.13-53915b2",
   "repository": "https://github.com/drizzle-team/drizzle-kit-mirror",
   "author": "Drizzle Team",
   "license": "MIT",
@@ -53,7 +53,7 @@
     ]
   },
   "dependencies": {
-    "@drizzle-team/studio": "^0.0.5",
+    "@drizzle-team/studio": "^0.0.8",
     "@esbuild-kit/esm-loader": "^2.5.5",
     "camelcase": "^7.0.1",
     "chalk": "^5.2.0",

package/utils.js

@@ -13068,6 +13068,21 @@ var pgSchemaExternal = objectType({
     columns: recordType(stringType(), stringType())
   })
 }).strict();
+var kitInternals2 = objectType({
+  tables: recordType(
+    stringType(),
+    objectType({
+      columns: recordType(
+        stringType(),
+        objectType({
+          isArray: booleanType().optional(),
+          dimensions: numberType().optional(),
+          rawType: stringType().optional()
+        }).optional()
+      )
+    }).optional()
+  )
+}).optional();
 var pgSchemaInternal = objectType({
   version: literalType("5"),
   dialect: literalType("pg"),
@@ -13078,7 +13093,8 @@ var pgSchemaInternal = objectType({
     schemas: recordType(stringType(), stringType()),
     tables: recordType(stringType(), stringType()),
     columns: recordType(stringType(), stringType())
-  })
+  }),
+  internal: kitInternals2
 }).strict();
 var tableSquashed2 = objectType({
   name: stringType(),
@@ -13147,12 +13163,12 @@ var PgSquasher = {
     return `${unq.name};${unq.columns.join(",")};${unq.nullsNotDistinct}`;
   },
   unsquashUnique: (unq) => {
-    const [
+    const [name, columns, nullsNotDistinct] = unq.split(";");
+    return {
       name,
-      columns,
-      nullsNotDistinct
-    ] = unq.split(";");
-    return { name, columns: columns.split(","), nullsNotDistinct: nullsNotDistinct === "true" };
+      columns: columns.split(","),
+      nullsNotDistinct: nullsNotDistinct === "true"
+    };
   },
   unsquashFK: (input) => {
     const [
@@ -13188,9 +13204,12 @@ var squashPgScheme = (json) => {
       const squashedPKs = mapValues(it[1].compositePrimaryKeys, (pk) => {
         return PgSquasher.squashPK(pk);
       });
-      const squashedUniqueConstraints = mapValues(it[1].uniqueConstraints, (unq) => {
-        return PgSquasher.squashUnique(unq);
-      });
+      const squashedUniqueConstraints = mapValues(
+        it[1].uniqueConstraints,
+        (unq) => {
+          return PgSquasher.squashUnique(unq);
+        }
+      );
       return [
         it[0],
         {
@@ -16089,12 +16108,12 @@ var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesR
     });
     jsonStatements.push(...jsonMySqlCreateTables);
   }
-  jsonStatements.push(...jsonDroppedReferencesForAlteredTables);
   jsonStatements.push(...jsonDropTables);
   jsonStatements.push(...jsonRenameTables);
   jsonStatements.push(...jsonRenameColumnsStatements);
   jsonStatements.push(...jsonDeletedCompositePKs);
   jsonStatements.push(...jsonDeletedUniqueConstraints);
+  jsonStatements.push(...jsonDroppedReferencesForAlteredTables);
   jsonStatements.push(...jsonDropIndexesForAllAlteredTables);
   jsonStatements.push(...jsonTableAlternations.alterColumns);
   jsonStatements.push(...jsonTableAlternations.createColumns);