drizzle-kit 0.19.2 → 0.19.3-23a3dbf

package/index.cjs

@@ -12386,7 +12386,7 @@ var init_sqliteSerializer = __esm({
         primaryKeys.forEach((it) => {
           if (it.columns.length > 1) {
             primaryKeysObject[it.getName()] = {
-              columns: it.columns.map((it2) => it2.name)
+              columns: it.columns.map((it2) => it2.name).sort()
             };
           } else {
             columnsObject[it.columns[0].name].primaryKey = true;
@@ -12416,10 +12416,22 @@ var init_sqliteSerializer = __esm({
       const columns = await db.query(
         `SELECT 
     m.name as "tableName", p.name as "columnName", p.type as "columnType", p."notnull" as "notNull", p.dflt_value as "defaultValue", p.pk as pk
-    FROM sqlite_master AS m JOIN pragma_table_info(m.name) AS p 
+    FROM sqlite_master AS m JOIN pragma_table_info(m.name) AS p
     WHERE m.type = 'table' and m.tbl_name != 'sqlite_sequence' and m.tbl_name != 'sqlite_stat1' and m.tbl_name != '_litestream_seq' and m.tbl_name != '_litestream_lock';
     `
       );
+      const isSeqExists = await db.query(
+        `SELECT * FROM sqlite_master WHERE type='table' AND name='sqlite_sequence';`
+      );
+      const tablesWithSeq = [];
+      if (isSeqExists.length > 0) {
+        const seq = await db.query(
+          `SELECT * FROM sqlite_sequence WHERE name != 'sqlite_sequence' and name != 'sqlite_stat1' and name != '_litestream_seq' and name != '_litestream_lock';`
+        );
+        for (const s of seq) {
+          tablesWithSeq.push(s.name);
+        }
+      }
       let columnsCount = 0;
       let tablesCount = /* @__PURE__ */ new Set();
       let indexesCount = 0;
@@ -12442,7 +12454,7 @@ var init_sqliteSerializer = __esm({
         const columnType = column7.columnType;
         const isPrimary = column7.pk !== 0;
         const columnDefault = column7.defaultValue;
-        const isAutoincrement = columnType.endsWith("AUTO_INCREMENT");
+        const isAutoincrement = isPrimary && tablesWithSeq.includes(tableName);
         if (isPrimary) {
           if (typeof tableToPk[tableName] === "undefined") {
             tableToPk[tableName] = [columnName];
@@ -12454,7 +12466,7 @@ var init_sqliteSerializer = __esm({
         const newColumn = {
           default: columnDefault === null ? void 0 : /^-?[\d.]+(?:e-?\d+)?$/.test(columnDefault) ? Number(columnDefault) : ["CURRENT_TIME", "CURRENT_DATE", "CURRENT_TIMESTAMP"].includes(
             columnDefault
-          ) ? `(${columnDefault})` : columnDefault,
+          ) ? `(${columnDefault})` : columnDefault === "false" ? false : columnDefault === "true" ? true : columnDefault.startsWith('"') && columnDefault.endsWith('"') ? columnDefault.substring(1, columnDefault.length - 1) : columnDefault,
           autoincrement: isAutoincrement,
           name: columnName,
           type: mapSqlToSqliteType(columnType),
@@ -12477,9 +12489,10 @@ var init_sqliteSerializer = __esm({
       }
       for (const [key, value] of Object.entries(tableToPk)) {
         if (value.length > 1) {
+          value.sort();
           result[key].compositePrimaryKeys = {
-            [`${key}_${value.sort().join("_")}_pk`]: {
-              columns: value.sort()
+            [`${key}_${value.join("_")}_pk`]: {
+              columns: value
             }
           };
         } else if (value.length === 1) {
@@ -14658,9 +14671,9 @@ var init_sqlgenerator = __esm({
           const primaryKeyStatement = column7.primaryKey ? " PRIMARY KEY" : "";
           const notNullStatement = column7.notNull ? " NOT NULL" : "";
           const defaultStatement = column7.default !== void 0 ? ` DEFAULT ${column7.default}` : "";
-          const autoincrementStatement = column7.autoincrement ? " AUTO_INCREMENT" : "";
+          const autoincrementStatement = column7.autoincrement ? " AUTOINCREMENT" : "";
           statement += "\n	";
-          statement += `\`${column7.name}\` ${column7.type}${autoincrementStatement}${primaryKeyStatement}${defaultStatement}${notNullStatement}`;
+          statement += `\`${column7.name}\` ${column7.type}${primaryKeyStatement}${autoincrementStatement}${defaultStatement}${notNullStatement}`;
           statement += ",";
         }
         compositePKs.forEach((it) => {
@@ -16300,6 +16313,8 @@ var init_snapshotsDiffer = __esm({
     init_jsonDiffer();
     init_jsonStatements();
     init_utils2();
+    init_sqliteSchema();
+    init_mysqlSchema();
     makeChanged = (schema4) => {
       return objectType({
         type: enumType(["changed"]),
@@ -16537,35 +16552,64 @@ var init_snapshotsDiffer = __esm({
       const jsonSetNewTableSchemas = [];
       allAlteredResolved.forEach((it) => {
         const schemaUnwrapped = valueFromSelfOrPatchedNew(it.schema);
-        let addedCompositePKs;
-        let deletedCompositePKs;
-        let alteredCompositePKs;
+        let addedColumns = [];
+        for (const addedPkName of Object.keys(it.addedCompositePKs)) {
+          const addedPkColumns = it.addedCompositePKs[addedPkName];
+          if (dialect6 === "sqlite") {
+            addedColumns = SQLiteSquasher.unsquashPK(addedPkColumns);
+          } else if (dialect6 === "mysql") {
+            addedColumns = MySqlSquasher.unsquashPK(addedPkColumns).columns;
+          } else {
+            addedColumns = SQLiteSquasher.unsquashPK(addedPkColumns);
+          }
+        }
+        let deletedColumns = [];
+        for (const deletedPkName of Object.keys(it.deletedCompositePKs)) {
+          const deletedPkColumns = it.deletedCompositePKs[deletedPkName];
+          if (dialect6 === "sqlite") {
+            deletedColumns = SQLiteSquasher.unsquashPK(deletedPkColumns);
+          } else if (dialect6 === "mysql") {
+            deletedColumns = MySqlSquasher.unsquashPK(deletedPkColumns).columns;
+          } else {
+            deletedColumns = SQLiteSquasher.unsquashPK(deletedPkColumns);
+          }
+        }
+        addedColumns.sort();
+        deletedColumns.sort();
+        const doPerformDeleteAndCreate = JSON.stringify(addedColumns) !== JSON.stringify(deletedColumns);
+        let addedCompositePKs = [];
+        let deletedCompositePKs = [];
+        let alteredCompositePKs = [];
         if (dialect6 === "sqlite") {
-          addedCompositePKs = prepareAddCompositePrimaryKeySqlite(
-            it.name,
-            it.addedCompositePKs
-          );
-          deletedCompositePKs = prepareDeleteCompositePrimaryKeySqlite(
-            it.name,
-            it.deletedCompositePKs
-          );
+          if (doPerformDeleteAndCreate) {
+            addedCompositePKs = prepareAddCompositePrimaryKeySqlite(
+              it.name,
+              it.addedCompositePKs
+            );
+            deletedCompositePKs = prepareDeleteCompositePrimaryKeySqlite(
+              it.name,
+              it.deletedCompositePKs
+            );
+          }
           alteredCompositePKs = prepareAlterCompositePrimaryKeySqlite(
             it.name,
             it.alteredCompositePKs
           );
         } else if (dialect6 === "pg") {
-          addedCompositePKs = prepareAddCompositePrimaryKeyPg(
-            it.name,
-            schemaUnwrapped,
-            it.addedCompositePKs,
-            curFull
-          );
-          deletedCompositePKs = prepareDeleteCompositePrimaryKeyPg(
-            it.name,
-            schemaUnwrapped,
-            it.deletedCompositePKs,
-            prevFull
-          );
+          if (doPerformDeleteAndCreate) {
+            addedCompositePKs = prepareAddCompositePrimaryKeyPg(
+              it.name,
+              schemaUnwrapped,
+              it.addedCompositePKs,
+              curFull
+            );
+            deletedCompositePKs = prepareDeleteCompositePrimaryKeyPg(
+              it.name,
+              schemaUnwrapped,
+              it.deletedCompositePKs,
+              prevFull
+            );
+          }
           alteredCompositePKs = prepareAlterCompositePrimaryKeyPg(
             it.name,
             schemaUnwrapped,
@@ -16574,16 +16618,19 @@ var init_snapshotsDiffer = __esm({
             curFull
           );
         } else {
-          addedCompositePKs = prepareAddCompositePrimaryKeyMySql(
-            it.name,
-            it.addedCompositePKs,
-            curFull
-          );
-          deletedCompositePKs = prepareDeleteCompositePrimaryKeyMySql(
-            it.name,
-            it.deletedCompositePKs,
-            prevFull
-          );
+          if (doPerformDeleteAndCreate) {
+            addedCompositePKs = prepareAddCompositePrimaryKeyMySql(
+              it.name,
+              it.addedCompositePKs,
+              curFull
+            );
+            deletedCompositePKs = prepareDeleteCompositePrimaryKeyMySql(
+              it.name,
+              it.deletedCompositePKs,
+              prevFull
+            );
+          }
+          ;
           alteredCompositePKs = prepareAlterCompositePrimaryKeyMySql(
             it.name,
             it.alteredCompositePKs,
@@ -17966,6 +18013,577 @@ var init_utils3 = __esm({
   }
 });
 
+// src/cli/commands/sqliteUtils.ts
+var sqliteConnectionSchema, sqliteCliConfigSchema;
+var init_sqliteUtils = __esm({
+  "src/cli/commands/sqliteUtils.ts"() {
+    init_lib();
+    init_utils();
+    sqliteConnectionSchema = unionType([
+      objectType({
+        driver: literalType("turso"),
+        dbCredentials: objectType({
+          url: stringType(),
+          authToken: stringType().optional()
+        })
+      }),
+      objectType({
+        driver: literalType("libsql"),
+        dbCredentials: objectType({
+          url: stringType()
+        })
+      }),
+      objectType({
+        driver: literalType("better-sqlite"),
+        dbCredentials: objectType({
+          url: stringType()
+        })
+      })
+    ]);
+    sqliteCliConfigSchema = intersectionType(
+      configIntrospectSchema,
+      sqliteConnectionSchema
+    );
+  }
+});
+
+// src/cli/validations/outputs.ts
+var withStyle, outputs;
+var init_outputs = __esm({
+  "src/cli/validations/outputs.ts"() {
+    init_source();
+    withStyle = {
+      error: (str) => `${source_default.red(`${source_default.white.bgRed(" Invalid input ")} ${str}`)}`,
+      warning: (str) => `${source_default.white.bgGray(" Warning ")} ${str}`,
+      fullWarning: (str) => `${source_default.black.bgYellow("[Warning]")} ${source_default.bold(str)}`
+    };
+    outputs = {
+      studio: {
+        drivers: (param) => withStyle.error(
+          `"${param}" is not a valid driver. Available drivers: "pg", "mysql2", "better-sqlite", "libsql", "turso". You can read more about drizzle.config: https://orm.drizzle.team/kit-docs/config-reference`
+        ),
+        noCredentials: () => withStyle.error(
+          `You need to specify a "dbCredentials" param in you config. It will help drizzle to know how to query you database. You can read more about drizzle.config: https://orm.drizzle.team/kit-docs/config-reference`
+        ),
+        noDriver: () => withStyle.error(
+          `You need to specify a "driver" param in you config. It will help drizzle to know how to query you database. You can read more about drizzle.config: https://orm.drizzle.team/kit-docs/config-reference`
+        )
+      },
+      common: {
+        ambiguousParams: (command) => withStyle.error(
+          `You can't use both --config and other cli options for ${command} command`
+        ),
+        schema: (command) => withStyle.error(`"--schema" is a required field for ${command} command`),
+        schemaConfig: (command) => withStyle.error(
+          `"schema" is a required field in drizzle.config for ${command} command`
+        )
+      },
+      postgres: {
+        connection: {
+          driver: () => withStyle.error(`Only "pg" is available options for "--driver"`),
+          required: () => withStyle.error(
+            `Either "connectionString" or "host", "database" are required for database connection`
+          )
+        }
+      },
+      mysql: {
+        connection: {
+          driver: () => withStyle.error(`Only "mysql2" is available options for "--driver"`),
+          required: () => withStyle.error(
+            `Either "connectionString" or "host", "database" are required for database connection`
+          )
+        }
+      },
+      sqlite: {
+        connection: {
+          driver: () => withStyle.error(
+            `Either "turso", "libsql", "better-sqlite" are available options for "--driver"`
+          ),
+          url: (driver) => withStyle.error(`"url" is a required option for driver "${driver}". You can read more about drizzle.config: https://orm.drizzle.team/kit-docs/config-reference`),
+          authToken: (driver) => withStyle.error(
+            `"authToken" is a required option for driver "${driver}". You can read more about drizzle.config: https://orm.drizzle.team/kit-docs/config-reference`
+          )
+        },
+        introspect: {},
+        push: {}
+      }
+    };
+  }
+});
+
+// src/cli/validations/common.ts
+var checkCollisions;
+var init_common = __esm({
+  "src/cli/validations/common.ts"() {
+    init_outputs();
+    checkCollisions = (options, command, inputWhitelist = []) => {
+      const { config, ...rest } = options;
+      let atLeastOneParam = false;
+      for (const key of Object.keys(rest)) {
+        if (inputWhitelist.includes(key))
+          continue;
+        atLeastOneParam = true;
+      }
+      if (!atLeastOneParam && typeof config !== "undefined") {
+        return {
+          success: true,
+          action: "config"
+        };
+      }
+      if (typeof config === "undefined" && atLeastOneParam) {
+        return {
+          success: true,
+          action: "cli"
+        };
+      }
+      if (typeof config === "undefined" && !atLeastOneParam) {
+        return {
+          success: true,
+          action: "config"
+        };
+      }
+      return {
+        success: false,
+        message: outputs.common.ambiguousParams(command),
+        action: "error"
+      };
+    };
+  }
+});
+
+// src/cli/validations/sqlite.ts
+var sqliteConnectionCli, sqliteCliIntrospectParams, sqliteCliPushParams, sqliteConfigPushParams, printCliConnectionIssues, printConfigConnectionIssues, validateIntrospect, validatePush;
+var init_sqlite = __esm({
+  "src/cli/validations/sqlite.ts"() {
+    init_lib();
+    init_sqliteUtils();
+    init_utils();
+    init_common();
+    init_outputs();
+    sqliteConnectionCli = unionType([
+      objectType({
+        driver: literalType("turso"),
+        url: stringType(),
+        authToken: stringType()
+      }),
+      objectType({
+        driver: literalType("better-sqlite"),
+        url: stringType()
+      }),
+      objectType({
+        driver: literalType("libsql"),
+        url: stringType()
+      })
+    ]);
+    sqliteCliIntrospectParams = intersectionType(
+      configIntrospectCliSchema,
+      sqliteConnectionCli
+    );
+    sqliteCliPushParams = intersectionType(
+      configPushSchema,
+      sqliteConnectionCli
+    );
+    sqliteConfigPushParams = intersectionType(
+      configPushSchema,
+      sqliteConnectionSchema
+    );
+    printCliConnectionIssues = (options) => {
+      if (options.driver === "turso") {
+        if (typeof options.url === "undefined") {
+          console.log(outputs.sqlite.connection.url("turso"));
+        }
+        if (typeof options.authToken === "undefined") {
+          console.log(outputs.sqlite.connection.authToken("turso"));
+        }
+      } else if (options.driver === "libsql") {
+        if (typeof options.url === "undefined") {
+          console.log(outputs.sqlite.connection.url("libsql"));
+        }
+      } else if (options.driver === "better-sqlite") {
+        if (typeof options.url === "undefined") {
+          console.log(outputs.sqlite.connection.url("better-sqlite"));
+        }
+      } else {
+        console.log(outputs.sqlite.connection.driver());
+      }
+    };
+    printConfigConnectionIssues = (options) => {
+      var _a, _b, _c;
+      if (options.driver === "turso") {
+        if (typeof options.url === "undefined") {
+          console.log(outputs.sqlite.connection.url("turso"));
+        }
+        if (typeof ((_a = options.dbCredentials) == null ? void 0 : _a.authToken) === "undefined") {
+          console.log(outputs.sqlite.connection.authToken("turso"));
+        }
+      } else if (options.driver === "libsql") {
+        if (typeof ((_b = options.dbCredentials) == null ? void 0 : _b.url) === "undefined") {
+          console.log(outputs.sqlite.connection.url("libsql"));
+        }
+      } else if (options.driver === "better-sqlite") {
+        if (typeof ((_c = options.dbCredentials) == null ? void 0 : _c.url) === "undefined") {
+          console.log(outputs.sqlite.connection.url("better-sqlite"));
+        }
+      } else {
+        console.log(outputs.sqlite.connection.driver());
+      }
+    };
+    validateIntrospect = async (options) => {
+      const collisionRes = checkCollisions(options, "introspect:sqlite");
+      if (!collisionRes.success) {
+        console.log(collisionRes.message);
+        process.exit(1);
+      }
+      if (collisionRes.action === "config") {
+        const drizzleConfig = await readDrizzleConfig(options.config);
+        const configRes = sqliteCliConfigSchema.safeParse(drizzleConfig);
+        if (!configRes.success) {
+          printConfigConnectionIssues(drizzleConfig);
+          process.exit(1);
+        }
+        return configRes.data;
+      }
+      const cliRes = sqliteCliIntrospectParams.safeParse(options);
+      if (!cliRes.success) {
+        printCliConnectionIssues(options);
+        process.exit(1);
+      }
+      if (cliRes.data.driver === "turso") {
+        const { authToken, url: url2, introspectCasing: introspectCasing3, ...rest2 } = cliRes.data;
+        return {
+          ...rest2,
+          dbCredentials: { url: url2, authToken },
+          introspect: { casing: introspectCasing3 }
+        };
+      }
+      if (cliRes.data.driver === "libsql") {
+        const { url: url2, introspectCasing: introspectCasing3, ...rest2 } = cliRes.data;
+        return {
+          ...rest2,
+          dbCredentials: { url: url2 },
+          introspect: { casing: introspectCasing3 }
+        };
+      }
+      const { url, introspectCasing: introspectCasing2, ...rest } = cliRes.data;
+      return {
+        ...rest,
+        dbCredentials: { url },
+        introspect: { casing: introspectCasing2 }
+      };
+    };
+    validatePush = async (options) => {
+      const collisionRes = checkCollisions(options, "push:sqlite");
+      if (!collisionRes.success) {
+        console.log(collisionRes.message);
+        console.log();
+        process.exit(1);
+      }
+      if (collisionRes.action === "config") {
+        const drizzleConfig = await readDrizzleConfig(options.config);
+        const configRes = sqliteConfigPushParams.safeParse(drizzleConfig);
+        if (!configRes.success) {
+          printConfigConnectionIssues(drizzleConfig);
+          process.exit(1);
+        }
+        return configRes.data;
+      }
+      const cliRes = sqliteCliPushParams.safeParse(options);
+      if (!cliRes.success) {
+        if (typeof options.schema === "undefined") {
+          console.log(outputs.common.schema("push:sqlite"));
+        }
+        printCliConnectionIssues(options);
+        process.exit(1);
+      }
+      if (cliRes.data.driver === "turso") {
+        const { authToken, url: url2, ...rest2 } = cliRes.data;
+        return { ...rest2, dbCredentials: { url: url2, authToken } };
+      }
+      const { url, ...rest } = cliRes.data;
+      return { ...rest, dbCredentials: { url } };
+    };
+  }
+});
+
+// src/cli/validations/pg.ts
+var pgConnectionCli, pgConnectionConfig, pgConfigIntrospectSchema, pgCliIntrospectParams, printCliConnectionIssues2, printConfigConnectionIssues2, validatePgIntrospect;
+var init_pg = __esm({
+  "src/cli/validations/pg.ts"() {
+    init_lib();
+    init_utils();
+    init_common();
+    init_outputs();
+    pgConnectionCli = unionType([
+      objectType({
+        driver: literalType("pg"),
+        host: stringType(),
+        port: coerce.number().optional(),
+        user: stringType().default("postgres"),
+        password: stringType().optional(),
+        database: stringType(),
+        ssl: coerce.boolean().optional(),
+        type: literalType("params").default("params")
+      }),
+      objectType({
+        driver: literalType("pg"),
+        connectionString: stringType(),
+        type: literalType("url").default("url")
+      })
+    ]);
+    pgConnectionConfig = unionType([
+      objectType({
+        driver: literalType("pg"),
+        dbCredentials: objectType({
+          host: stringType(),
+          port: coerce.number().optional(),
+          user: stringType().default("postgres"),
+          password: stringType().optional(),
+          database: stringType(),
+          ssl: coerce.boolean().optional()
+        })
+      }),
+      objectType({
+        driver: literalType("pg"),
+        dbCredentials: objectType({
+          connectionString: stringType()
+        })
+      })
+    ]);
+    pgConfigIntrospectSchema = intersectionType(
+      configIntrospectSchema,
+      pgConnectionConfig
+    );
+    pgCliIntrospectParams = intersectionType(
+      configIntrospectCliSchema,
+      pgConnectionCli
+    );
+    printCliConnectionIssues2 = (options) => {
+      if (options.driver === "pg") {
+        if (typeof options.connectionString === "undefined" && (typeof options.host === "undefined" || typeof options.database === "undefined")) {
+          console.log(outputs.postgres.connection.required());
+        }
+      } else {
+        console.log(outputs.postgres.connection.driver());
+      }
+    };
+    printConfigConnectionIssues2 = (options) => {
+      if (options.driver === "pg") {
+        if (typeof options.dbCredentials.connectionString === "undefined" && (typeof options.dbCredentials.host === "undefined" || typeof options.dbCredentials.database === "undefined")) {
+          console.log(outputs.postgres.connection.required());
+        }
+      } else {
+        console.log(outputs.postgres.connection.driver());
+      }
+    };
+    validatePgIntrospect = async (options) => {
+      const collisionRes = checkCollisions(options, "introspect:pg");
+      if (!collisionRes.success) {
+        console.log(collisionRes.message);
+        process.exit(1);
+      }
+      if (collisionRes.action === "config") {
+        const drizzleConfig = await readDrizzleConfig(options.config);
+        const configRes = pgConfigIntrospectSchema.safeParse(drizzleConfig);
+        if (!configRes.success) {
+          printConfigConnectionIssues2(drizzleConfig);
+          process.exit(1);
+        }
+        return configRes.data;
+      }
+      const cliRes = pgCliIntrospectParams.safeParse(options);
+      if (!cliRes.success) {
+        printCliConnectionIssues2(options);
+        process.exit(1);
+      }
+      if (cliRes.data.type === "url") {
+        const { connectionString, introspectCasing: introspectCasing3, ...rest2 } = cliRes.data;
+        return {
+          ...rest2,
+          dbCredentials: { connectionString },
+          introspect: { casing: introspectCasing3 }
+        };
+      }
+      const {
+        host,
+        password,
+        port,
+        database,
+        ssl,
+        user,
+        introspectCasing: introspectCasing2,
+        ...rest
+      } = cliRes.data;
+      return {
+        ...rest,
+        dbCredentials: { host, password, port, database, ssl, user },
+        introspect: { casing: introspectCasing2 }
+      };
+    };
+  }
+});
+
+// src/cli/validations/mysql.ts
+var mysqlConnectionCli, mysqlConnectionConfig, mysqlConfigIntrospectSchema, mysqlCliIntrospectParams, mysqlCliPushParams, mysqlConfigPushParams, printCliConnectionIssues3, printConfigConnectionIssues3, validateMySqlIntrospect, validateMySqlPush;
+var init_mysql = __esm({
+  "src/cli/validations/mysql.ts"() {
+    init_lib();
+    init_utils();
+    init_common();
+    init_outputs();
+    mysqlConnectionCli = unionType([
+      objectType({
+        driver: literalType("mysql2"),
+        host: stringType(),
+        port: coerce.number().optional(),
+        user: stringType().default("mysql"),
+        password: stringType().optional(),
+        database: stringType(),
+        type: literalType("params").default("params")
+      }),
+      objectType({
+        driver: literalType("mysql2"),
+        connectionString: stringType(),
+        type: literalType("url").default("url")
+      })
+    ]);
+    mysqlConnectionConfig = unionType([
+      objectType({
+        driver: literalType("mysql2"),
+        dbCredentials: objectType({
+          host: stringType(),
+          port: coerce.number().optional(),
+          user: stringType().default("mysql"),
+          password: stringType().optional(),
+          database: stringType(),
+          type: literalType("params").default("params")
+        })
+      }),
+      objectType({
+        driver: literalType("mysql2"),
+        dbCredentials: objectType({
+          connectionString: stringType(),
+          type: literalType("url").default("url")
+        })
+      })
+    ]);
+    mysqlConfigIntrospectSchema = intersectionType(
+      configIntrospectSchema,
+      mysqlConnectionConfig
+    );
+    mysqlCliIntrospectParams = intersectionType(
+      configIntrospectCliSchema,
+      mysqlConnectionCli
+    );
+    mysqlCliPushParams = intersectionType(
+      configPushSchema,
+      mysqlConnectionCli
+    );
+    mysqlConfigPushParams = intersectionType(
+      configPushSchema,
+      mysqlConnectionConfig
+    );
+    printCliConnectionIssues3 = (options) => {
+      if (options.driver === "mysql2") {
+        if (typeof options.connectionString === "undefined" && (typeof options.host === "undefined" || typeof options.database === "undefined")) {
+          console.log(outputs.mysql.connection.required());
+        }
+      } else {
+        console.log(outputs.mysql.connection.driver());
+      }
+    };
+    printConfigConnectionIssues3 = (options) => {
+      if (options.driver === "mysql2") {
+        if (typeof options.dbCredentials.connectionString === "undefined" && (typeof options.dbCredentials.host === "undefined" || typeof options.dbCredentials.database === "undefined")) {
+          console.log(outputs.mysql.connection.required());
+        }
+      } else {
+        console.log(outputs.mysql.connection.driver());
+      }
+    };
+    validateMySqlIntrospect = async (options) => {
+      const collisionRes = checkCollisions(options, "introspect:mysql");
+      if (!collisionRes.success) {
+        console.log(collisionRes.message);
+        process.exit(1);
+      }
+      if (collisionRes.action === "config") {
+        const drizzleConfig = await readDrizzleConfig(options.config);
+        const configRes = mysqlConfigIntrospectSchema.safeParse(drizzleConfig);
+        if (!configRes.success) {
+          printConfigConnectionIssues3(drizzleConfig);
+          process.exit(1);
+        }
+        return configRes.data;
+      }
+      const cliRes = mysqlCliIntrospectParams.safeParse(options);
+      if (!cliRes.success) {
+        printCliConnectionIssues3(options);
+        process.exit(1);
+      }
+      if (cliRes.data.type === "url") {
+        const { connectionString, introspectCasing: introspectCasing3, type: type2, ...rest2 } = cliRes.data;
+        return {
+          ...rest2,
+          dbCredentials: { connectionString, type: type2 },
+          introspect: { casing: introspectCasing3 }
+        };
+      }
+      const {
+        host,
+        password,
+        port,
+        database,
+        user,
+        type,
+        introspectCasing: introspectCasing2,
+        ...rest
+      } = cliRes.data;
+      return {
+        ...rest,
+        dbCredentials: { host, password, port, database, user, type },
+        introspect: { casing: introspectCasing2 }
+      };
+    };
+    validateMySqlPush = async (options) => {
+      const collisionRes = checkCollisions(options, "push:mysql");
+      if (!collisionRes.success) {
+        console.log(collisionRes.message);
+        console.log();
+        process.exit(1);
+      }
+      if (collisionRes.action === "config") {
+        const drizzleConfig = await readDrizzleConfig(options.config);
+        const configRes = mysqlConfigPushParams.safeParse(drizzleConfig);
+        if (!configRes.success) {
+          printConfigConnectionIssues3(drizzleConfig);
+          process.exit(1);
+        }
+        return configRes.data;
+      }
+      const cliRes = mysqlCliPushParams.safeParse(options);
+      if (!cliRes.success) {
+        if (typeof options.schema === "undefined") {
+          console.log(outputs.common.schema("push:mysql"));
+        }
+        printCliConnectionIssues3(options);
+        process.exit(1);
+      }
+      if (cliRes.data.type === "url") {
+        const { connectionString, type: type2, ...rest2 } = cliRes.data;
+        return {
+          ...rest2,
+          dbCredentials: { connectionString, type: type2 }
+        };
+      }
+      const { host, password, port, database, user, type, ...rest } = cliRes.data;
+      return {
+        ...rest,
+        dbCredentials: { host, password, port, database, user, type }
+      };
+    };
+  }
+});
+
 // node_modules/.pnpm/sqlstring@2.3.3/node_modules/sqlstring/lib/SqlString.js
 var require_SqlString = __commonJS({
   "node_modules/.pnpm/sqlstring@2.3.3/node_modules/sqlstring/lib/SqlString.js"(exports) {
@@ -44785,12 +45403,12 @@ var require_lib3 = __commonJS({
       const dest = new URL$1(destination).protocol;
       return orig === dest;
     };
-    function fetch2(url, opts) {
-      if (!fetch2.Promise) {
+    function fetch(url, opts) {
+      if (!fetch.Promise) {
         throw new Error("native promise missing, set fetch.Promise to your favorite alternative");
       }
-      Body.Promise = fetch2.Promise;
-      return new fetch2.Promise(function(resolve2, reject) {
+      Body.Promise = fetch.Promise;
+      return new fetch.Promise(function(resolve2, reject) {
         const request = new Request2(url, opts);
         const options = getNodeRequestOptions(request);
         const send = (options.protocol === "https:" ? https : http).request;
@@ -44863,7 +45481,7 @@ var require_lib3 = __commonJS({
         req.on("response", function(res) {
           clearTimeout(reqTimeout);
           const headers = createHeadersLenient(res.headers);
-          if (fetch2.isRedirect(res.statusCode)) {
+          if (fetch.isRedirect(res.statusCode)) {
             const location = headers.get("Location");
             let locationURL = null;
             try {
@@ -44925,7 +45543,7 @@ var require_lib3 = __commonJS({
                   requestOpts.body = void 0;
                   requestOpts.headers.delete("content-length");
                 }
-                resolve2(fetch2(new Request2(locationURL, requestOpts)));
+                resolve2(fetch(new Request2(locationURL, requestOpts)));
                 finalize();
                 return;
             }
@@ -45018,11 +45636,11 @@ var require_lib3 = __commonJS({
         stream.end();
       }
     }
-    fetch2.isRedirect = function(code) {
+    fetch.isRedirect = function(code) {
       return code === 301 || code === 302 || code === 303 || code === 307 || code === 308;
     };
-    fetch2.Promise = global.Promise;
-    module2.exports = exports = fetch2;
+    fetch.Promise = global.Promise;
+    module2.exports = exports = fetch;
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.default = exports;
     exports.Headers = Headers2;
@@ -45032,12 +45650,11 @@ var require_lib3 = __commonJS({
   }
 });
 
-// node_modules/.pnpm/@libsql+isomorphic-fetch@0.1.1/node_modules/@libsql/isomorphic-fetch/node.mjs
-var import_node_fetch, Request, Response, Headers;
+// node_modules/.pnpm/@libsql+isomorphic-fetch@0.1.4/node_modules/@libsql/isomorphic-fetch/node.mjs
+var import_node_fetch;
 var init_node2 = __esm({
-  "node_modules/.pnpm/@libsql+isomorphic-fetch@0.1.1/node_modules/@libsql/isomorphic-fetch/node.mjs"() {
+  "node_modules/.pnpm/@libsql+isomorphic-fetch@0.1.4/node_modules/@libsql/isomorphic-fetch/node.mjs"() {
     import_node_fetch = __toESM(require_lib3(), 1);
-    ({ Request, Response, Headers } = import_node_fetch.default);
   }
 });
 
@@ -45181,6 +45798,11 @@ var init_http = __esm({
 });
 
 // node_modules/.pnpm/@libsql+client@0.1.6/node_modules/@libsql/client/lib-esm/index.js
+var lib_esm_exports2 = {};
+__export(lib_esm_exports2, {
+  LibsqlError: () => LibsqlError,
+  createClient: () => createClient
+});
 function createClient(config) {
   return _createClient4(expandConfig(config));
 }
@@ -50439,6 +51061,164 @@ var init_pgIntrospect = __esm({
   }
 });
 
+// src/cli/validations/studio.ts
+var studio_exports = {};
+__export(studio_exports, {
+  studioConfigSchema: () => studioConfigSchema,
+  validateStudio: () => validateStudio
+});
+var studioConfigSchema, printDriverIssues, validateStudio;
+var init_studio = __esm({
+  "src/cli/validations/studio.ts"() {
+    init_lib();
+    init_pg();
+    init_mysql();
+    init_sqliteUtils();
+    init_utils();
+    init_outputs();
+    init_pg();
+    init_mysql();
+    init_sqlite();
+    studioConfigSchema = intersectionType(
+      objectType({
+        schema: unionType([stringType(), stringType().array()])
+      }),
+      unionType([mysqlConnectionConfig, pgConnectionConfig, sqliteConnectionSchema])
+    );
+    printDriverIssues = (options) => {
+      if (options.driver === "pg") {
+        printConfigConnectionIssues2(options);
+      } else if (options.driver === "mysql") {
+        printConfigConnectionIssues3(options);
+      } else if (["libsql", "turso", "better-sqlite"].includes(options.driver)) {
+        printConfigConnectionIssues(options);
+      } else {
+        if (typeof options.driver === "undefined") {
+          console.log(outputs.studio.noDriver());
+        } else {
+          console.log(outputs.studio.drivers(options.driver));
+        }
+        if (typeof options.dbCredentials === "undefined") {
+          console.log(outputs.studio.noCredentials());
+        }
+      }
+    };
+    validateStudio = async (options) => {
+      const drizzleConfig = await readDrizzleConfig(
+        options.config
+      );
+      const configRes = studioConfigSchema.safeParse(drizzleConfig);
+      if (!configRes.success) {
+        if (typeof drizzleConfig.schema === "undefined") {
+          console.log(outputs.common.schemaConfig("studio"));
+          process.exit(1);
+        }
+        printDriverIssues(drizzleConfig);
+        process.exit(1);
+      }
+      return configRes.data;
+    };
+  }
+});
+
+// src/serializer/studioUtils.ts
+var studioUtils_exports = {};
+__export(studioUtils_exports, {
+  drizzleDb: () => drizzleDb,
+  prepareModels: () => prepareModels
+});
+var import_drizzle_orm10, import_mysql_core4, import_pg_core4, import_sqlite_core3, prepareModels, drizzleDb;
+var init_studioUtils = __esm({
+  "src/serializer/studioUtils.ts"() {
+    import_drizzle_orm10 = require("drizzle-orm");
+    import_mysql_core4 = require("drizzle-orm/mysql-core");
+    import_pg_core4 = require("drizzle-orm/pg-core");
+    import_sqlite_core3 = require("drizzle-orm/sqlite-core");
+    init_utils();
+    init_serializer();
+    prepareModels = async (path3) => {
+      const imports = prepareFilenames(path3);
+      const sqliteSchema2 = {};
+      const pgSchema3 = {};
+      const mysqlSchema3 = {};
+      const { unregister } = safeRegister();
+      for (let i = 0; i < imports.length; i++) {
+        const it = imports[i];
+        const i0 = require(`${it}`);
+        const i0values = Object.entries(i0);
+        i0values.forEach(([k, t]) => {
+          if ((0, import_drizzle_orm10.is)(t, import_pg_core4.PgTable)) {
+            pgSchema3[k] = t;
+          }
+          if ((0, import_drizzle_orm10.is)(t, import_mysql_core4.MySqlTable)) {
+            mysqlSchema3[k] = t;
+          }
+          if ((0, import_drizzle_orm10.is)(t, import_sqlite_core3.SQLiteTable)) {
+            sqliteSchema2[k] = t;
+          }
+          if ((0, import_drizzle_orm10.is)(t, import_drizzle_orm10.Relations)) {
+            sqliteSchema2[k] = t;
+            pgSchema3[k] = t;
+            mysqlSchema3[k] = t;
+          }
+        });
+      }
+      unregister();
+      return { pgSchema: pgSchema3, mysqlSchema: mysqlSchema3, sqliteSchema: sqliteSchema2 };
+    };
+    drizzleDb = async (drizzleConfig, models, logger) => {
+      if (drizzleConfig.driver === "pg") {
+        const { drizzle } = await import("drizzle-orm/node-postgres");
+        const { Pool: Pool2, types } = await Promise.resolve().then(() => __toESM(require_lib5()));
+        const client = new Pool2({ ...drizzleConfig.dbCredentials, max: 1 });
+        types.setTypeParser(types.builtins.INTERVAL, (val) => val);
+        return {
+          db: drizzle(client, { logger }),
+          type: "pg",
+          schema: models.pgSchema
+        };
+      } else if (drizzleConfig.driver === "mysql2") {
+        const { drizzle } = await import("drizzle-orm/mysql2");
+        const { createPool } = await Promise.resolve().then(() => __toESM(require_promise()));
+        const client = createPool({
+          uri: drizzleConfig.dbCredentials.type === "url" ? drizzleConfig.dbCredentials.connectionString : void 0,
+          host: drizzleConfig.dbCredentials.type === "params" ? drizzleConfig.dbCredentials.host : void 0,
+          port: drizzleConfig.dbCredentials.type === "params" ? drizzleConfig.dbCredentials.port : void 0,
+          user: drizzleConfig.dbCredentials.type === "params" ? drizzleConfig.dbCredentials.user : void 0,
+          database: drizzleConfig.dbCredentials.type === "params" ? drizzleConfig.dbCredentials.database : void 0,
+          password: drizzleConfig.dbCredentials.type === "params" ? drizzleConfig.dbCredentials.password : void 0,
+          connectionLimit: 1
+        });
+        return {
+          db: drizzle(client, { logger }),
+          type: "mysql",
+          schema: models.mysqlSchema
+        };
+      } else {
+        if (drizzleConfig.driver === "better-sqlite") {
+          const { drizzle } = await import("drizzle-orm/better-sqlite3");
+          const Database2 = await import("better-sqlite3");
+          const client = new Database2.default(drizzleConfig.dbCredentials.url);
+          return {
+            db: drizzle(client, { logger }),
+            type: "sqlite",
+            schema: models.sqliteSchema
+          };
+        } else {
+          const { drizzle } = await import("drizzle-orm/libsql");
+          const { createClient: createClient2 } = await Promise.resolve().then(() => (init_lib_esm2(), lib_esm_exports2));
+          const client = createClient2({ ...drizzleConfig.dbCredentials });
+          return {
+            db: drizzle(client, { logger }),
+            type: "sqlite",
+            schema: models.sqliteSchema
+          };
+        }
+      }
+    };
+  }
+});
+
 // src/cli/index.ts
 var cli_exports = {};
 __export(cli_exports, {
@@ -50543,7 +51323,7 @@ init_source();
 // package.json
 var package_default = {
   name: "drizzle-kit",
-  version: "0.19.2",
+  version: "0.19.3",
   repository: "https://github.com/drizzle-team/drizzle-kit-mirror",
   author: "Drizzle Team",
   license: "MIT",
@@ -50580,7 +51360,8 @@ var package_default = {
     "build:dev": "rm -rf ./dist && tsx build.dev.ts && tsc -p tsconfig.cli-types.json && chmod +x ./dist/index.cjs",
     pack: "build && package",
     tsc: "tsc -p tsconfig.build.json",
-    pub: "cp package.json readme.md dist/ && cd dist && npm publish"
+    pub: "cp package.json readme.md dist/ && cd dist && npm publish",
+    studio: "./dist/index.cjs studio --verbose"
   },
   ava: {
     files: [
@@ -50594,6 +51375,7 @@ var package_default = {
     ]
   },
   dependencies: {
+    "@drizzle-team/studio": "file:drizzle-team-studio-0.0.1.tgz",
     "@esbuild-kit/esm-loader": "^2.5.5",
     camelcase: "^7.0.1",
     chalk: "^5.2.0",
@@ -50620,13 +51402,14 @@ var package_default = {
     "better-sqlite3": "^8.4.0",
     dockerode: "^3.3.4",
     dotenv: "^16.0.3",
-    "drizzle-orm": "0.27.0-56b9edc",
+    "drizzle-orm": "0.27.0",
     eslint: "^8.29.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-prettier": "^4.2.1",
     "get-port": "^6.1.2",
     mysql2: "2.3.3",
     pg: "^8.8.0",
+    postgres: "^3.3.5",
     prettier: "^2.8.1",
     tsx: "^3.12.1",
     typescript: "^4.9.4",
@@ -51148,532 +51931,12 @@ var logSuggestionsAndReturn2 = async ({
 // src/cli/index.ts
 init_serializer();
 init_sqliteSchema();
-
-// src/cli/validations/sqlite.ts
-init_lib();
-
-// src/cli/commands/sqliteUtils.ts
-init_lib();
-init_utils();
-var sqliteConnectionSchema = unionType([
-  objectType({
-    driver: literalType("turso"),
-    dbCredentials: objectType({
-      url: stringType(),
-      authToken: stringType().optional()
-    })
-  }),
-  objectType({
-    driver: literalType("libsql"),
-    dbCredentials: objectType({
-      url: stringType()
-    })
-  }),
-  objectType({
-    driver: literalType("better-sqlite"),
-    dbCredentials: objectType({
-      url: stringType()
-    })
-  })
-]);
-var sqliteCliConfigSchema = intersectionType(
-  configIntrospectSchema,
-  sqliteConnectionSchema
-);
-
-// src/cli/validations/sqlite.ts
-init_utils();
-
-// src/cli/validations/outputs.ts
-init_source();
-var withStyle = {
-  error: (str) => `${source_default.red(`${source_default.white.bgRed(" Invalid input ")} ${str}`)}`,
-  warning: (str) => `${source_default.white.bgGray(" Warning ")} ${str}`
-};
-var outputs = {
-  common: {
-    ambiguousParams: (command) => withStyle.error(
-      `You can't use both --config and other cli options for ${command} command`
-    ),
-    schema: (command) => withStyle.error(`"--schema" is a required field for ${command} command`)
-  },
-  postgres: {
-    connection: {
-      driver: () => withStyle.error(
-        `Only "pg" is available options for "--driver"`
-      ),
-      required: () => withStyle.error(
-        `Either "connectionString" or "host", "database" are required for database connection`
-      )
-    }
-  },
-  mysql: {
-    connection: {
-      driver: () => withStyle.error(
-        `Only "mysql2" is available options for "--driver"`
-      ),
-      required: () => withStyle.error(
-        `Either "connectionString" or "host", "database" are required for database connection`
-      )
-    }
-  },
-  sqlite: {
-    connection: {
-      driver: () => withStyle.error(`Either "turso", "libsql", "better-sqlite" are available options for "--driver"`),
-      url: (driver) => withStyle.error(`"--url" is a required option for driver "${driver}"`),
-      authToken: (driver) => withStyle.error(
-        `"--auth-token" is a required option for driver "${driver}"`
-      )
-    },
-    introspect: {},
-    push: {}
-  }
-};
-
-// src/cli/validations/common.ts
-var checkCollisions = (options, command, inputWhitelist = []) => {
-  const { config, ...rest } = options;
-  let atLeastOneParam = false;
-  for (const key of Object.keys(rest)) {
-    if (inputWhitelist.includes(key))
-      continue;
-    atLeastOneParam = true;
-  }
-  if (!atLeastOneParam && typeof config !== "undefined") {
-    return {
-      success: true,
-      action: "config"
-    };
-  }
-  if (typeof config === "undefined" && atLeastOneParam) {
-    return {
-      success: true,
-      action: "cli"
-    };
-  }
-  if (typeof config === "undefined" && !atLeastOneParam) {
-    return {
-      success: true,
-      action: "config"
-    };
-  }
-  return {
-    success: false,
-    message: outputs.common.ambiguousParams(command),
-    action: "error"
-  };
-};
-
-// src/cli/validations/sqlite.ts
-var sqliteConnectionCli = unionType([
-  objectType({
-    driver: literalType("turso"),
-    url: stringType(),
-    authToken: stringType()
-  }),
-  objectType({
-    driver: literalType("better-sqlite"),
-    url: stringType()
-  }),
-  objectType({
-    driver: literalType("libsql"),
-    url: stringType()
-  })
-]);
-var sqliteCliIntrospectParams = intersectionType(
-  configIntrospectCliSchema,
-  sqliteConnectionCli
-);
-var sqliteCliPushParams = intersectionType(
-  configPushSchema,
-  sqliteConnectionCli
-);
-var sqliteConfigPushParams = intersectionType(
-  configPushSchema,
-  sqliteConnectionSchema
-);
-var printCliConnectionIssues = (options) => {
-  if (options.driver === "turso") {
-    if (typeof options.url === "undefined") {
-      console.log(outputs.sqlite.connection.url("turso"));
-    }
-    if (typeof options.authToken === "undefined") {
-      console.log(outputs.sqlite.connection.authToken("turso"));
-    }
-  } else if (options.driver === "libsql") {
-    if (typeof options.url === "undefined") {
-      console.log(outputs.sqlite.connection.url("libsql"));
-    }
-  } else if (options.driver === "better-sqlite") {
-    if (typeof options.url === "undefined") {
-      console.log(outputs.sqlite.connection.url("better-sqlite"));
-    }
-  } else {
-    console.log(outputs.sqlite.connection.driver());
-  }
-};
-var printConfigConnectionIssues = (options) => {
-  var _a, _b, _c;
-  if (options.driver === "turso") {
-    if (typeof options.url === "undefined") {
-      console.log(outputs.sqlite.connection.url("turso"));
-    }
-    if (typeof ((_a = options.dbCredentials) == null ? void 0 : _a.authToken) === "undefined") {
-      console.log(outputs.sqlite.connection.authToken("turso"));
-    }
-  } else if (options.driver === "libsql") {
-    if (typeof ((_b = options.dbCredentials) == null ? void 0 : _b.url) === "undefined") {
-      console.log(outputs.sqlite.connection.url("libsql"));
-    }
-  } else if (options.driver === "better-sqlite") {
-    if (typeof ((_c = options.dbCredentials) == null ? void 0 : _c.url) === "undefined") {
-      console.log(outputs.sqlite.connection.url("better-sqlite"));
-    }
-  } else {
-    console.log(outputs.sqlite.connection.driver());
-  }
-};
-var validateIntrospect = async (options) => {
-  const collisionRes = checkCollisions(options, "introspect:sqlite");
-  if (!collisionRes.success) {
-    console.log(collisionRes.message);
-    process.exit(1);
-  }
-  if (collisionRes.action === "config") {
-    const drizzleConfig = await readDrizzleConfig(options.config);
-    const configRes = sqliteCliConfigSchema.safeParse(drizzleConfig);
-    if (!configRes.success) {
-      printConfigConnectionIssues(drizzleConfig);
-      process.exit(1);
-    }
-    return configRes.data;
-  }
-  const cliRes = sqliteCliIntrospectParams.safeParse(options);
-  if (!cliRes.success) {
-    printCliConnectionIssues(options);
-    process.exit(1);
-  }
-  if (cliRes.data.driver === "turso") {
-    const { authToken, url: url2, introspectCasing: introspectCasing3, ...rest2 } = cliRes.data;
-    return {
-      ...rest2,
-      dbCredentials: { url: url2, authToken },
-      introspect: { casing: introspectCasing3 }
-    };
-  }
-  if (cliRes.data.driver === "libsql") {
-    const { url: url2, introspectCasing: introspectCasing3, ...rest2 } = cliRes.data;
-    return {
-      ...rest2,
-      dbCredentials: { url: url2 },
-      introspect: { casing: introspectCasing3 }
-    };
-  }
-  const { url, introspectCasing: introspectCasing2, ...rest } = cliRes.data;
-  return {
-    ...rest,
-    dbCredentials: { url },
-    introspect: { casing: introspectCasing2 }
-  };
-};
-var validatePush = async (options) => {
-  const collisionRes = checkCollisions(options, "push:sqlite");
-  if (!collisionRes.success) {
-    console.log(collisionRes.message);
-    console.log();
-    process.exit(1);
-  }
-  if (collisionRes.action === "config") {
-    const drizzleConfig = await readDrizzleConfig(options.config);
-    const configRes = sqliteConfigPushParams.safeParse(drizzleConfig);
-    if (!configRes.success) {
-      printConfigConnectionIssues(drizzleConfig);
-      process.exit(1);
-    }
-    return configRes.data;
-  }
-  const cliRes = sqliteCliPushParams.safeParse(options);
-  if (!cliRes.success) {
-    if (typeof options.schema === "undefined") {
-      console.log(outputs.common.schema("push:sqlite"));
-    }
-    printCliConnectionIssues(options);
-    process.exit(1);
-  }
-  if (cliRes.data.driver === "turso") {
-    const { authToken, url: url2, ...rest2 } = cliRes.data;
-    return { ...rest2, dbCredentials: { url: url2, authToken } };
-  }
-  const { url, ...rest } = cliRes.data;
-  return { ...rest, dbCredentials: { url } };
-};
-
-// src/cli/validations/pg.ts
-init_lib();
-init_utils();
-var pgConnectionCli = unionType([
-  objectType({
-    driver: literalType("pg"),
-    host: stringType(),
-    port: coerce.number().optional(),
-    user: stringType().default("postgres"),
-    password: stringType().optional(),
-    database: stringType(),
-    ssl: coerce.boolean().optional(),
-    type: literalType("params").default("params")
-  }),
-  objectType({
-    driver: literalType("pg"),
-    connectionString: stringType(),
-    type: literalType("url").default("url")
-  })
-]);
-var pgConnectionConfig = unionType([
-  objectType({
-    driver: literalType("pg"),
-    dbCredentials: objectType({
-      host: stringType(),
-      port: coerce.number().optional(),
-      user: stringType().default("postgres"),
-      password: stringType().optional(),
-      database: stringType(),
-      ssl: coerce.boolean().optional()
-    })
-  }),
-  objectType({
-    driver: literalType("pg"),
-    dbCredentials: objectType({
-      connectionString: stringType()
-    })
-  })
-]);
-var pgConfigIntrospectSchema = intersectionType(
-  configIntrospectSchema,
-  pgConnectionConfig
-);
-var pgCliIntrospectParams = intersectionType(
-  configIntrospectCliSchema,
-  pgConnectionCli
-);
-var printCliConnectionIssues2 = (options) => {
-  if (options.driver === "pg") {
-    if (typeof options.connectionString === "undefined" && (typeof options.host === "undefined" || typeof options.database === "undefined")) {
-      console.log(outputs.postgres.connection.required());
-    }
-  } else {
-    console.log(outputs.postgres.connection.driver());
-  }
-};
-var printConfigConnectionIssues2 = (options) => {
-  if (options.driver === "pg") {
-    if (typeof options.dbCredentials.connectionString === "undefined" && (typeof options.dbCredentials.host === "undefined" || typeof options.dbCredentials.database === "undefined")) {
-      console.log(outputs.postgres.connection.required());
-    }
-  } else {
-    console.log(outputs.postgres.connection.driver());
-  }
-};
-var validatePgIntrospect = async (options) => {
-  const collisionRes = checkCollisions(options, "introspect:pg");
-  if (!collisionRes.success) {
-    console.log(collisionRes.message);
-    process.exit(1);
-  }
-  if (collisionRes.action === "config") {
-    const drizzleConfig = await readDrizzleConfig(options.config);
-    const configRes = pgConfigIntrospectSchema.safeParse(drizzleConfig);
-    if (!configRes.success) {
-      printConfigConnectionIssues2(drizzleConfig);
-      process.exit(1);
-    }
-    return configRes.data;
-  }
-  const cliRes = pgCliIntrospectParams.safeParse(options);
-  if (!cliRes.success) {
-    printCliConnectionIssues2(options);
-    process.exit(1);
-  }
-  if (cliRes.data.type === "url") {
-    const { connectionString, introspectCasing: introspectCasing3, ...rest2 } = cliRes.data;
-    return {
-      ...rest2,
-      dbCredentials: { connectionString },
-      introspect: { casing: introspectCasing3 }
-    };
-  }
-  const {
-    host,
-    password,
-    port,
-    database,
-    ssl,
-    user,
-    introspectCasing: introspectCasing2,
-    ...rest
-  } = cliRes.data;
-  return {
-    ...rest,
-    dbCredentials: { host, password, port, database, ssl, user },
-    introspect: { casing: introspectCasing2 }
-  };
-};
-
-// src/cli/validations/mysql.ts
-init_lib();
-init_utils();
-var mysqlConnectionCli = unionType([
-  objectType({
-    driver: literalType("mysql2"),
-    host: stringType(),
-    port: coerce.number().optional(),
-    user: stringType().default("mysql"),
-    password: stringType().optional(),
-    database: stringType(),
-    type: literalType("params").default("params")
-  }),
-  objectType({
-    driver: literalType("mysql2"),
-    connectionString: stringType(),
-    type: literalType("url").default("url")
-  })
-]);
-var mysqlConnectionConfig = unionType([
-  objectType({
-    driver: literalType("mysql2"),
-    dbCredentials: objectType({
-      host: stringType(),
-      port: coerce.number().optional(),
-      user: stringType().default("mysql"),
-      password: stringType().optional(),
-      database: stringType(),
-      type: literalType("params").default("params")
-    })
-  }),
-  objectType({
-    driver: literalType("mysql2"),
-    dbCredentials: objectType({
-      connectionString: stringType(),
-      type: literalType("url").default("url")
-    })
-  })
-]);
-var mysqlConfigIntrospectSchema = intersectionType(
-  configIntrospectSchema,
-  mysqlConnectionConfig
-);
-var mysqlCliIntrospectParams = intersectionType(
-  configIntrospectCliSchema,
-  mysqlConnectionCli
-);
-var mysqlCliPushParams = intersectionType(
-  configPushSchema,
-  mysqlConnectionCli
-);
-var mysqlConfigPushParams = intersectionType(
-  configPushSchema,
-  mysqlConnectionConfig
-);
-var printCliConnectionIssues3 = (options) => {
-  if (options.driver === "mysql2") {
-    if (typeof options.connectionString === "undefined" && (typeof options.host === "undefined" || typeof options.database === "undefined")) {
-      console.log(outputs.mysql.connection.required());
-    }
-  } else {
-    console.log(outputs.mysql.connection.driver());
-  }
-};
-var printConfigConnectionIssues3 = (options) => {
-  if (options.driver === "mysql2") {
-    if (typeof options.dbCredentials.connectionString === "undefined" && (typeof options.dbCredentials.host === "undefined" || typeof options.dbCredentials.database === "undefined")) {
-      console.log(outputs.mysql.connection.required());
-    }
-  } else {
-    console.log(outputs.mysql.connection.driver());
-  }
-};
-var validateMySqlIntrospect = async (options) => {
-  const collisionRes = checkCollisions(options, "introspect:mysql");
-  if (!collisionRes.success) {
-    console.log(collisionRes.message);
-    process.exit(1);
-  }
-  if (collisionRes.action === "config") {
-    const drizzleConfig = await readDrizzleConfig(options.config);
-    const configRes = mysqlConfigIntrospectSchema.safeParse(drizzleConfig);
-    if (!configRes.success) {
-      printConfigConnectionIssues3(drizzleConfig);
-      process.exit(1);
-    }
-    return configRes.data;
-  }
-  const cliRes = mysqlCliIntrospectParams.safeParse(options);
-  if (!cliRes.success) {
-    printCliConnectionIssues3(options);
-    process.exit(1);
-  }
-  if (cliRes.data.type === "url") {
-    const { connectionString, introspectCasing: introspectCasing3, type: type2, ...rest2 } = cliRes.data;
-    return {
-      ...rest2,
-      dbCredentials: { connectionString, type: type2 },
-      introspect: { casing: introspectCasing3 }
-    };
-  }
-  const {
-    host,
-    password,
-    port,
-    database,
-    user,
-    type,
-    introspectCasing: introspectCasing2,
-    ...rest
-  } = cliRes.data;
-  return {
-    ...rest,
-    dbCredentials: { host, password, port, database, user, type },
-    introspect: { casing: introspectCasing2 }
-  };
-};
-var validateMySqlPush = async (options) => {
-  const collisionRes = checkCollisions(options, "push:mysql");
-  if (!collisionRes.success) {
-    console.log(collisionRes.message);
-    console.log();
-    process.exit(1);
-  }
-  if (collisionRes.action === "config") {
-    const drizzleConfig = await readDrizzleConfig(options.config);
-    const configRes = mysqlConfigPushParams.safeParse(drizzleConfig);
-    if (!configRes.success) {
-      printConfigConnectionIssues3(drizzleConfig);
-      process.exit(1);
-    }
-    return configRes.data;
-  }
-  const cliRes = mysqlCliPushParams.safeParse(options);
-  if (!cliRes.success) {
-    if (typeof options.schema === "undefined") {
-      console.log(outputs.common.schema("push:mysql"));
-    }
-    printCliConnectionIssues3(options);
-    process.exit(1);
-  }
-  if (cliRes.data.type === "url") {
-    const { connectionString, type: type2, ...rest2 } = cliRes.data;
-    return {
-      ...rest2,
-      dbCredentials: { connectionString, type: type2 }
-    };
-  }
-  const { host, password, port, database, user, type, ...rest } = cliRes.data;
-  return {
-    ...rest,
-    dbCredentials: { host, password, port, database, user, type }
-  };
-};
-
-// src/cli/index.ts
+init_sqlite();
+init_pg();
+init_common();
+init_mysql();
+init_outputs();
+var import_studio = require("@drizzle-team/studio");
 var printVersions = async () => {
   const v = await versions();
   console.log(`${source_default.gray(v)}
@@ -52263,6 +52526,37 @@ 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) => {
+  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));
+  const models = await prepareModels2(drizzleConfig.schema);
+  const setup = await drizzleDb2(drizzleConfig, models, options.verbose);
+  const server = await (0, import_studio.prepareServer)(setup);
+  const port = options.port ?? 4983;
+  console.log();
+  console.log(
+    withStyle.fullWarning(
+      "Drizzle Studio is currently in Beta. If you find anything that is not working as expected or should be improved, feel free to create an issue on GitHub: https://github.com/drizzle-team/drizzle-kit-mirror/issues/new or write to us on Discord: https://discord.gg/WcRKz2FFxN"
+    )
+  );
+  server.start({
+    host: "127.0.0.1",
+    port,
+    cb: (err2, address) => {
+      if (err2) {
+        console.error(err2);
+      } else {
+        console.log(
+          `
+Drizzle Studio is up and running on ${source_default.blue(
+            address
+          )}`
+        );
+      }
+    }
+  });
+});
 var main = async () => {
   const version2 = await versions();
   import_commander.program.version(version2, "--version, -v");
@@ -52281,6 +52575,7 @@ var main = async () => {
   import_commander.program.addCommand(introspectSQLiteCommand);
   import_commander.program.addCommand(dbPushSqliteCommand);
   import_commander.program.addCommand(checkMySqlCommand);
+  import_commander.program.addCommand(studioCommand);
   import_commander.program.parse();
 };
 main();