drizzle-kit 0.20.0-029419a → 0.20.0-13160ca

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drizzle-kit",
-  "version": "0.20.0-029419a",
+  "version": "0.20.0-13160ca",
   "repository": "https://github.com/drizzle-team/drizzle-kit-mirror",
   "author": "Drizzle Team",
   "license": "MIT",
@@ -54,7 +54,7 @@
     ]
   },
   "dependencies": {
-    "@drizzle-team/studio": "^0.0.9",
+    "@drizzle-team/studio": "^0.0.17",
     "@esbuild-kit/esm-loader": "^2.5.5",
     "camelcase": "^7.0.1",
     "chalk": "^5.2.0",

package/serializer/index.d.ts

@@ -1,7 +1,7 @@
-import { PgSchemaInternal } from "./pgSchema";
-import { SQLiteSchemaInternal } from "./sqliteSchema";
-import { MySqlSchemaInternal } from "./mysqlSchema";
-import { SQL } from "drizzle-orm";
+import type { PgSchemaInternal } from "./pgSchema";
+import type { SQLiteSchemaInternal } from "./sqliteSchema";
+import type { MySqlSchemaInternal } from "./mysqlSchema";
+import type { SQL } from "drizzle-orm";
 export declare const sqlToStr: (sql: SQL) => string;
 export declare const serializeMySql: (path: string | string[]) => Promise<MySqlSchemaInternal>;
 export declare const serializePg: (path: string | string[], schemaFilter?: string[]) => Promise<PgSchemaInternal>;

package/serializer/pgSerializer.d.ts

@@ -1,9 +1,9 @@
 import { AnyPgTable, PgEnum, PgSchema } from "drizzle-orm/pg-core";
 import { Relations } from "drizzle-orm";
-import { IntrospectStage, IntrospectStatus } from "src/cli/views";
-import { PgSchemaInternal } from "src/serializer/pgSchema";
-import type { DrizzleDbClient } from "src/drivers";
+import type { IntrospectStage, IntrospectStatus } from "../cli/views";
+import type { PgSchemaInternal } from "../serializer/pgSchema";
+import type { DrizzleDbClient } from "../drivers";
 export declare const indexName: (tableName: string, columns: string[]) => string;
 export declare const generatePgSnapshot: (tables: AnyPgTable[], enums: PgEnum<any>[], schemas: PgSchema[], schemaFilter?: string[]) => PgSchemaInternal;
 export declare const fromDatabase: (db: DrizzleDbClient, tablesFilter: ((table: string) => boolean) | undefined, schemaFilters: string[], progressCallback?: ((stage: IntrospectStage, count: number, status: IntrospectStatus) => void) | undefined) => Promise<PgSchemaInternal>;
-export declare const toDrizzle: (schema: PgSchemaInternal) => Record<string, AnyPgTable | Relations>;
+export declare const toDrizzle: (schema: PgSchemaInternal, schemaName: string) => Record<string, AnyPgTable | Relations>;

package/serializer/sqliteSerializer.d.ts

@@ -1,7 +1,7 @@
-import { SQLiteSchemaInternal } from "src/serializer/sqliteSchema";
+import type { SQLiteSchemaInternal } from "../serializer/sqliteSchema";
 import { Relations } from "drizzle-orm";
 import { AnySQLiteTable } from "drizzle-orm/sqlite-core";
-import { IntrospectStage, IntrospectStatus } from "src/cli/views";
+import type { IntrospectStage, IntrospectStatus } from "src/cli/views";
 import type { DrizzleDbClient } from "src/drivers";
 export declare const generateSqliteSnapshot: (tables: AnySQLiteTable[], enums: any[]) => SQLiteSchemaInternal;
 export declare const fromDatabase: (db: DrizzleDbClient, tablesFilter?: (table: string) => boolean, progressCallback?: ((stage: IntrospectStage, count: number, status: IntrospectStatus) => void) | undefined) => Promise<SQLiteSchemaInternal>;

package/serializer/studioUtils.d.ts

@@ -1,18 +1,22 @@
+import type { Setup } from "@drizzle-team/studio";
 import { Relations } from "drizzle-orm";
 import { AnyMySqlTable } from "drizzle-orm/mysql-core";
 import { AnyPgTable } from "drizzle-orm/pg-core";
 import { AnySQLiteTable } from "drizzle-orm/sqlite-core";
+import type { Pool } from "pg";
+import { PgConnectionConfig } from "src/cli/validations/pg";
 import { StudioConfigConnections } from "src/cli/validations/studio";
 export declare const prepareModels: (path: string | string[]) => Promise<{
     pgSchema: Record<string, AnyPgTable<{}> | Relations<string, Record<string, import("drizzle-orm").Relation<string>>>>;
     mysqlSchema: Record<string, AnyMySqlTable<{}> | Relations<string, Record<string, import("drizzle-orm").Relation<string>>>>;
     sqliteSchema: Record<string, Relations<string, Record<string, import("drizzle-orm").Relation<string>>> | AnySQLiteTable<{}>>;
 }>;
+export declare const drizzleForPostgres: (connectionConfig: PgConnectionConfig, pgSchema: Record<string, AnyPgTable | Relations>, verbose: boolean) => Promise<Setup>;
 export declare const drizzleDb: (drizzleConfig: StudioConfigConnections, models: {
     pgSchema?: Record<string, AnyPgTable | Relations>;
     mysqlSchema?: Record<string, AnyMySqlTable | Relations>;
     sqliteSchema?: Record<string, AnySQLiteTable | Relations>;
-}, logger: boolean) => Promise<{
+}, logger: boolean, pgClient?: Pool) => Promise<{
     db: import("drizzle-orm/node-postgres").NodePgDatabase<Record<string, never>>;
     type: "pg";
     schema: Record<string, AnyPgTable<{}> | Relations<string, Record<string, import("drizzle-orm").Relation<string>>>> | undefined;

package/sqlite-introspect.d.ts

@@ -1,5 +1,5 @@
 import "./@types/utils";
-import { ConfigIntrospectCasing } from "./cli/commands/utils";
-import { SQLiteSchema } from "./serializer/sqliteSchema";
+import type { ConfigIntrospectCasing } from "./cli/commands/utils";
+import type { SQLiteSchema } from "./serializer/sqliteSchema";
 export declare const indexName: (tableName: string, columns: string[]) => string;
 export declare const schemaToTypeScript: (schema: SQLiteSchema, casing: ConfigIntrospectCasing["casing"]) => string;

package/utils-studio.d.ts

@@ -1,2 +1,5 @@
 export { toDrizzle as drizzleSchemaPg } from "./serializer/pgSerializer";
+export { toDrizzle as drizzleSchemaSQLite } from "./serializer/sqliteSerializer";
+export { sqlitePushIntrospect } from "./cli/commands/sqliteIntrospect";
 export { pgPushIntrospect } from "./cli/commands/pgIntrospect";
+export { DrizzleORMPgClient } from "./drivers";

package/utils-studio.js

@@ -560,13 +560,12 @@ var init_outputs = __esm({
 });
 
 // src/serializer/pgSerializer.ts
-var import_pg_core, import_pg_core2, import_drizzle_orm, import_drizzle_orm2, dialect, trimChar, fromDatabase, columnToDefault, defaultForColumn, toDrizzle;
+var import_pg_core, import_pg_core2, import_drizzle_orm, dialect, trimChar, fromDatabase, columnToDefault, defaultForColumn, toDrizzle;
 var init_pgSerializer = __esm({
   "src/serializer/pgSerializer.ts"() {
     import_pg_core = require("drizzle-orm/pg-core");
     import_pg_core2 = require("drizzle-orm/pg-core");
     import_drizzle_orm = require("drizzle-orm");
-    import_drizzle_orm2 = require("drizzle-orm");
     init_serializer();
     init_source();
     init_outputs();
@@ -968,7 +967,7 @@ var init_pgSerializer = __esm({
         }
       }
     };
-    toDrizzle = (schema) => {
+    toDrizzle = (schema, schemaName) => {
       const tables = {};
       Object.values(schema.tables).forEach((t) => {
         const columns = {};
@@ -1042,11 +1041,311 @@ var init_pgSerializer = __esm({
           }
           columns[columnName] = columnBuilder;
         });
-        tables[t.name] = (0, import_pg_core.pgTable)(t.name, columns, (cb) => {
+        if (schemaName === "public") {
+          tables[t.name] = (0, import_pg_core.pgTable)(t.name, columns, (cb) => {
+            const res = {};
+            Object.values(t.compositePrimaryKeys).forEach((cpk) => {
+              const gh = cpk.columns.map((c) => cb[c]);
+              res[cpk.name] = new import_pg_core.PrimaryKeyBuilder(
+                gh,
+                cpk.name
+              );
+            });
+            return res;
+          });
+        } else {
+          tables[t.name] = (0, import_pg_core.pgSchema)(schemaName).table(t.name, columns, (cb) => {
+            const res = {};
+            Object.values(t.compositePrimaryKeys).forEach((cpk) => {
+              const gh = cpk.columns.map((c) => cb[c]);
+              res[cpk.name] = new import_pg_core.PrimaryKeyBuilder(
+                gh,
+                cpk.name
+              );
+            });
+            return res;
+          });
+        }
+      });
+      return tables;
+    };
+  }
+});
+
+// src/serializer/sqliteSerializer.ts
+function mapSqlToSqliteType(sqlType) {
+  if ([
+    "int",
+    "integer",
+    "integer auto_increment",
+    "tinyint",
+    "smallint",
+    "mediumint",
+    "bigint",
+    "unsigned big int",
+    "int2",
+    "int8"
+  ].includes(sqlType.toLowerCase())) {
+    return "integer";
+  } else if ([
+    "character",
+    "varchar",
+    "vatying character",
+    "nchar",
+    "native character",
+    "nvarchar",
+    "text",
+    "clob"
+  ].some((it) => it.startsWith(sqlType.toLowerCase()))) {
+    return "text";
+  } else if (sqlType.toLowerCase() === "blob") {
+    return "blob";
+  } else if (["real", "double", "double precision", "float"].includes(
+    sqlType.toLowerCase()
+  )) {
+    return "real";
+  } else {
+    return "numeric";
+  }
+}
+var import_drizzle_orm2, import_sqlite_core, dialect2, fromDatabase2, toDrizzle2;
+var init_sqliteSerializer = __esm({
+  "src/serializer/sqliteSerializer.ts"() {
+    import_drizzle_orm2 = require("drizzle-orm");
+    import_sqlite_core = require("drizzle-orm/sqlite-core");
+    init_serializer();
+    init_outputs();
+    init_source();
+    dialect2 = new import_sqlite_core.SQLiteSyncDialect();
+    fromDatabase2 = async (db, tablesFilter = (table) => true, progressCallback) => {
+      const result = {};
+      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
+    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' and m.tbl_name != 'libsql_wasm_func_table';
+    `
+      );
+      const tablesWithSeq = [];
+      const seq = await db.query(
+        `SELECT * FROM sqlite_master WHERE name != 'sqlite_sequence' and name != 'sqlite_stat1' and name != '_litestream_seq' and name != '_litestream_lock' and sql GLOB '*[ *' || CHAR(9) || CHAR(10) || CHAR(13) || ']AUTOINCREMENT[^'']*';`
+      );
+      for (const s of seq) {
+        tablesWithSeq.push(s.name);
+      }
+      let columnsCount = 0;
+      let tablesCount = /* @__PURE__ */ new Set();
+      let indexesCount = 0;
+      let foreignKeysCount = 0;
+      const tableToPk = {};
+      for (const column of columns) {
+        if (!tablesFilter(column.tableName))
+          continue;
+        columnsCount += 1;
+        if (progressCallback) {
+          progressCallback("columns", columnsCount, "fetching");
+        }
+        const tableName = column.tableName;
+        tablesCount.add(tableName);
+        if (progressCallback) {
+          progressCallback("tables", tablesCount.size, "fetching");
+        }
+        const columnName = column.columnName;
+        const isNotNull = column.notNull === 1;
+        const columnType = column.columnType;
+        const isPrimary = column.pk !== 0;
+        const columnDefault = column.defaultValue;
+        const isAutoincrement = isPrimary && tablesWithSeq.includes(tableName);
+        if (isPrimary) {
+          if (typeof tableToPk[tableName] === "undefined") {
+            tableToPk[tableName] = [columnName];
+          } else {
+            tableToPk[tableName].push(columnName);
+          }
+        }
+        const table = result[tableName];
+        const newColumn = {
+          default: columnDefault === null ? void 0 : /^-?[\d.]+(?:e-?\d+)?$/.test(columnDefault) ? Number(columnDefault) : ["CURRENT_TIME", "CURRENT_DATE", "CURRENT_TIMESTAMP"].includes(
+            columnDefault
+          ) ? `(${columnDefault})` : columnDefault === "false" ? false : columnDefault === "true" ? true : columnDefault.startsWith("'") && columnDefault.endsWith("'") ? columnDefault : (
+            // ? columnDefault.substring(1, columnDefault.length - 1)
+            `(${columnDefault})`
+          ),
+          autoincrement: isAutoincrement,
+          name: columnName,
+          type: mapSqlToSqliteType(columnType),
+          primaryKey: false,
+          notNull: isNotNull
+        };
+        if (!table) {
+          result[tableName] = {
+            name: tableName,
+            columns: {
+              [columnName]: newColumn
+            },
+            compositePrimaryKeys: {},
+            indexes: {},
+            foreignKeys: {},
+            uniqueConstraints: {}
+          };
+        } else {
+          result[tableName].columns[columnName] = newColumn;
+        }
+      }
+      for (const [key, value] of Object.entries(tableToPk)) {
+        if (value.length > 1) {
+          value.sort();
+          result[key].compositePrimaryKeys = {
+            [`${key}_${value.join("_")}_pk`]: {
+              columns: value,
+              name: `${key}_${value.join("_")}_pk`
+            }
+          };
+        } else if (value.length === 1) {
+          result[key].columns[value[0]].primaryKey = true;
+        } else {
+        }
+      }
+      if (progressCallback) {
+        progressCallback("columns", columnsCount, "done");
+        progressCallback("tables", tablesCount.size, "done");
+      }
+      try {
+        const fks = await db.query(
+          `SELECT m.name as "tableFrom", f.id as "id", f."table" as "tableTo", f."from", f."to", f."on_update" as "onUpdate", f."on_delete" as "onDelete", f.seq as "seq"
+      FROM sqlite_master m, pragma_foreign_key_list(m.name) as f;`
+        );
+        const fkByTableName = {};
+        for (const fkRow of fks) {
+          foreignKeysCount += 1;
+          if (progressCallback) {
+            progressCallback("fks", foreignKeysCount, "fetching");
+          }
+          const tableName = fkRow.tableFrom;
+          const columnName = fkRow.from;
+          const refTableName = fkRow.tableTo;
+          const refColumnName = fkRow.to;
+          const updateRule = fkRow.onUpdate;
+          const deleteRule = fkRow.onDelete;
+          const sequence = fkRow.seq;
+          const id = fkRow.id;
+          const tableInResult = result[tableName];
+          if (typeof tableInResult === "undefined")
+            continue;
+          if (typeof fkByTableName[`${tableName}_${id}`] !== "undefined") {
+            fkByTableName[`${tableName}_${id}`].columnsFrom.push(columnName);
+            fkByTableName[`${tableName}_${id}`].columnsTo.push(refColumnName);
+          } else {
+            fkByTableName[`${tableName}_${id}`] = {
+              name: "",
+              tableFrom: tableName,
+              tableTo: refTableName,
+              columnsFrom: [columnName],
+              columnsTo: [refColumnName],
+              onDelete: deleteRule == null ? void 0 : deleteRule.toLowerCase(),
+              onUpdate: updateRule == null ? void 0 : updateRule.toLowerCase()
+            };
+          }
+          const columnsFrom = fkByTableName[`${tableName}_${id}`].columnsFrom;
+          const columnsTo = fkByTableName[`${tableName}_${id}`].columnsTo;
+          fkByTableName[`${tableName}_${id}`].name = `${tableName}_${columnsFrom.join(
+            "_"
+          )}_${refTableName}_${columnsTo.join("_")}_fk`;
+        }
+        for (const idx of Object.keys(fkByTableName)) {
+          const value = fkByTableName[idx];
+          result[value.tableFrom].foreignKeys[value.name] = value;
+        }
+      } catch (e) {
+      }
+      if (progressCallback) {
+        progressCallback("fks", foreignKeysCount, "done");
+      }
+      const idxs = await db.query(
+        `SELECT 
+    m.tbl_name as tableName,
+    il.name as indexName,
+    ii.name as columnName,
+    il.[unique] as isUnique,
+    il.seq as seq
+FROM sqlite_master AS m,
+    pragma_index_list(m.name) AS il,
+    pragma_index_info(il.name) AS ii
+WHERE 
+    m.type = 'table' and il.name NOT LIKE 'sqlite_autoindex_%';`
+      );
+      for (const idxRow of idxs) {
+        const tableName = idxRow.tableName;
+        const constraintName = idxRow.indexName;
+        const columnName = idxRow.columnName;
+        const isUnique = idxRow.isUnique === 1;
+        const tableInResult = result[tableName];
+        if (typeof tableInResult === "undefined")
+          continue;
+        indexesCount += 1;
+        if (progressCallback) {
+          progressCallback("indexes", indexesCount, "fetching");
+        }
+        if (typeof tableInResult.indexes[constraintName] !== "undefined") {
+          tableInResult.indexes[constraintName].columns.push(columnName);
+        } else {
+          tableInResult.indexes[constraintName] = {
+            name: constraintName,
+            columns: [columnName],
+            isUnique
+          };
+        }
+      }
+      if (progressCallback) {
+        progressCallback("indexes", indexesCount, "done");
+        progressCallback("enums", 0, "done");
+      }
+      return {
+        version: "5",
+        dialect: "sqlite",
+        tables: result,
+        enums: {},
+        _meta: {
+          tables: {},
+          columns: {}
+        }
+      };
+    };
+    toDrizzle2 = (schema) => {
+      const tables = {};
+      Object.values(schema.tables).forEach((t) => {
+        const columns = {};
+        Object.values(t.columns).forEach((c) => {
+          const columnName = c.name;
+          const type = c.type;
+          let columnBuilder;
+          if (type === "integer") {
+            columnBuilder = new import_sqlite_core.SQLiteIntegerBuilder(columnName);
+          } else if (type === "text") {
+            columnBuilder = new import_sqlite_core.SQLiteTextBuilder(columnName, {});
+          } else if (type === "blob") {
+            columnBuilder = new import_sqlite_core.SQLiteBlobBufferBuilder(columnName);
+          } else if (type === "real") {
+            columnBuilder = new import_sqlite_core.SQLiteRealBuilder(columnName);
+          } else {
+            columnBuilder = new import_sqlite_core.SQLiteNumericBuilder(columnName);
+          }
+          if (c.notNull) {
+            columnBuilder = columnBuilder.notNull();
+          }
+          if (c.default) {
+            columnBuilder = columnBuilder.default(c.default);
+          }
+          if (c.primaryKey) {
+            columnBuilder = columnBuilder.primaryKey();
+          }
+          columns[columnName] = columnBuilder;
+        });
+        tables[t.name] = (0, import_sqlite_core.sqliteTable)(t.name, columns, (cb) => {
           const res = {};
           Object.values(t.compositePrimaryKeys).forEach((cpk) => {
             const gh = cpk.columns.map((c) => cb[c]);
-            res[cpk.name] = new import_pg_core.PrimaryKeyBuilder(
+            res[cpk.name] = new import_sqlite_core.PrimaryKeyBuilder(
               gh,
               cpk.name
             );
@@ -1571,7 +1870,7 @@ var require_hanji = __commonJS({
       return;
     }
     exports.render = render2;
-    function renderWithTask2(view, task) {
+    function renderWithTask3(view, task) {
       return __awaiter(this, void 0, void 0, function* () {
         const terminal = new TaskTerminal(view, process.stdout);
         terminal.requestLayout();
@@ -1580,7 +1879,7 @@ var require_hanji = __commonJS({
         return result;
       });
     }
-    exports.renderWithTask = renderWithTask2;
+    exports.renderWithTask = renderWithTask3;
     var terminateHandler;
     function onTerminate(callback) {
       terminateHandler = callback;
@@ -1809,19 +2108,50 @@ var require_brace_expansion = __commonJS({
   }
 });
 
+// src/drivers/index.ts
+var import_drizzle_orm3, DrizzleDbClient, DrizzleORMPgClient;
+var init_drivers = __esm({
+  "src/drivers/index.ts"() {
+    import_drizzle_orm3 = require("drizzle-orm");
+    DrizzleDbClient = class {
+      constructor(db) {
+        this.db = db;
+      }
+    };
+    DrizzleORMPgClient = class extends DrizzleDbClient {
+      async query(query, values) {
+        const res = await this.db.execute(import_drizzle_orm3.sql.raw(query));
+        return res.rows;
+      }
+      async run(query) {
+        const res = await this.db.execute(import_drizzle_orm3.sql.raw(query));
+        return res.rows;
+      }
+    };
+  }
+});
+
 // src/utils-studio.ts
 var utils_studio_exports = {};
 __export(utils_studio_exports, {
+  DrizzleORMPgClient: () => DrizzleORMPgClient,
   drizzleSchemaPg: () => toDrizzle,
-  pgPushIntrospect: () => pgPushIntrospect
+  drizzleSchemaSQLite: () => toDrizzle2,
+  pgPushIntrospect: () => pgPushIntrospect,
+  sqlitePushIntrospect: () => sqlitePushIntrospect
 });
 module.exports = __toCommonJS(utils_studio_exports);
 init_pgSerializer();
+init_sqliteSerializer();
 
-// src/cli/commands/pgIntrospect.ts
-var import_hanji2 = __toESM(require_hanji());
+// src/cli/commands/sqliteIntrospect.ts
 init_views();
-init_pgSerializer();
+
+// src/global.ts
+var originUUID = "00000000-0000-0000-0000-000000000000";
+
+// src/cli/commands/sqliteIntrospect.ts
+init_sqliteSerializer();
 
 // node_modules/.pnpm/camelcase@7.0.1/node_modules/camelcase/index.js
 var UPPERCASE = /[\p{Lu}]/u;
@@ -1928,12 +2258,6 @@ Array.prototype.random = function() {
   return this[~~(Math.random() * this.length)];
 };
 
-// src/introspect.ts
-init_pgSerializer();
-
-// src/global.ts
-var originUUID = "00000000-0000-0000-0000-000000000000";
-
 // node_modules/.pnpm/minimatch@7.4.3/node_modules/minimatch/dist/mjs/index.js
 var import_brace_expansion = __toESM(require_brace_expansion(), 1);
 
@@ -2980,6 +3304,35 @@ minimatch.Minimatch = Minimatch;
 minimatch.escape = escape;
 minimatch.unescape = unescape;
 
+// src/cli/commands/sqliteIntrospect.ts
+var import_hanji2 = __toESM(require_hanji());
+var sqlitePushIntrospect = async (client, filters) => {
+  const matchers = filters.map((it) => {
+    return new Minimatch(it);
+  });
+  const filter2 = (tableName) => {
+    if (matchers.length === 0)
+      return true;
+    for (let i = 0; i < matchers.length; i++) {
+      const matcher = matchers[i];
+      if (matcher.match(tableName))
+        return true;
+    }
+    return false;
+  };
+  const res = await fromDatabase2(client, filter2);
+  const schema = { id: originUUID, prevId: "", ...res };
+  return { schema };
+};
+
+// src/cli/commands/pgIntrospect.ts
+var import_hanji3 = __toESM(require_hanji());
+init_views();
+init_pgSerializer();
+
+// src/introspect.ts
+init_pgSerializer();
+
 // src/cli/commands/pgIntrospect.ts
 var pgPushIntrospect = async (connection, filters, schemaFilters) => {
   const { client } = connection;
@@ -3001,8 +3354,14 @@ var pgPushIntrospect = async (connection, filters, schemaFilters) => {
   const { internal, ...schemaWithoutInternals } = schema;
   return { schema: schemaWithoutInternals };
 };
+
+// src/utils-studio.ts
+init_drivers();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DrizzleORMPgClient,
   drizzleSchemaPg,
-  pgPushIntrospect
+  drizzleSchemaSQLite,
+  pgPushIntrospect,
+  sqlitePushIntrospect
 });

package/utils.d.ts

@@ -1,6 +1,6 @@
 import { Dialect } from "./schemaValidator";
 import { NamedWithSchema } from "./cli/commands/migrate";
-import { AnyPgTable, PgDatabase } from "drizzle-orm/pg-core";
+import { PgDatabase } from "drizzle-orm/pg-core";
 import { PgSchema as PgSchemaKit } from "./serializer/pgSchema";
 import { Config, DbConnection } from ".";
 export declare const assertV1OutFolder: (out: string, dialect: Dialect | "{dialect}") => void;
@@ -209,24 +209,4 @@ export declare const pushSchema: (imports: Record<string, unknown>, db: PgDataba
     statementsToExecute: string[];
     apply: () => Promise<void>;
 }>;
-export declare const prepareFrom: (connection: DbConnection) => Promise<{
-    db: import("drizzle-orm/node-postgres").NodePgDatabase<Record<string, never>>;
-    type: "pg";
-    schema: Record<string, AnyPgTable<{}> | import("drizzle-orm").Relations<string, Record<string, import("drizzle-orm").Relation<string>>>> | undefined;
-} | {
-    db: import("drizzle-orm/mysql2").MySql2Database<Record<string, never>>;
-    type: "mysql";
-    schema: Record<string, import("drizzle-orm/mysql-core").AnyMySqlTable<{}> | import("drizzle-orm").Relations<string, Record<string, import("drizzle-orm").Relation<string>>>> | undefined;
-} | {
-    db: import("./orm-extenstions/d1-driver/driver").DrizzleD1WranglerDatabase<Record<string, never>>;
-    type: "sqlite";
-    schema: Record<string, import("drizzle-orm").Relations<string, Record<string, import("drizzle-orm").Relation<string>>> | import("drizzle-orm/sqlite-core").AnySQLiteTable<{}>> | undefined;
-} | {
-    db: import("drizzle-orm/better-sqlite3").BetterSQLite3Database<Record<string, never>>;
-    type: "sqlite";
-    schema: Record<string, import("drizzle-orm").Relations<string, Record<string, import("drizzle-orm").Relation<string>>> | import("drizzle-orm/sqlite-core").AnySQLiteTable<{}>> | undefined;
-} | {
-    db: import("drizzle-orm/libsql").LibSQLDatabase<Record<string, never>>;
-    type: "sqlite";
-    schema: Record<string, import("drizzle-orm").Relations<string, Record<string, import("drizzle-orm").Relation<string>>> | import("drizzle-orm/sqlite-core").AnySQLiteTable<{}>> | undefined;
-}>;
+export declare const prepareFrom: (connection: DbConnection) => Promise<Record<string, any>>;