drizzle-kit 0.20.6-88f61dc → 0.20.7-3bc340d

package/utils-studio.js

@@ -1098,470 +1098,17 @@ var init_outputs = __esm({
   }
 });
 
-// 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_orm, import_sqlite_core2, dialect, fromDatabase;
-var init_sqliteSerializer = __esm({
-  "src/serializer/sqliteSerializer.ts"() {
-    import_drizzle_orm = require("drizzle-orm");
-    import_sqlite_core2 = require("drizzle-orm/sqlite-core");
-    init_serializer();
-    init_outputs();
-    init_source();
-    dialect = new import_sqlite_core2.SQLiteSyncDialect();
-    fromDatabase = 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: {}
-        }
-      };
-    };
-  }
-});
-
-// node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js
-var require_balanced_match = __commonJS({
-  "node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js"(exports, module2) {
-    "use strict";
-    module2.exports = balanced;
-    function balanced(a, b, str) {
-      if (a instanceof RegExp)
-        a = maybeMatch(a, str);
-      if (b instanceof RegExp)
-        b = maybeMatch(b, str);
-      var r = range(a, b, str);
-      return r && {
-        start: r[0],
-        end: r[1],
-        pre: str.slice(0, r[0]),
-        body: str.slice(r[0] + a.length, r[1]),
-        post: str.slice(r[1] + b.length)
-      };
-    }
-    function maybeMatch(reg, str) {
-      var m = str.match(reg);
-      return m ? m[0] : null;
-    }
-    balanced.range = range;
-    function range(a, b, str) {
-      var begs, beg, left, right, result;
-      var ai = str.indexOf(a);
-      var bi = str.indexOf(b, ai + 1);
-      var i = ai;
-      if (ai >= 0 && bi > 0) {
-        if (a === b) {
-          return [ai, bi];
-        }
-        begs = [];
-        left = str.length;
-        while (i >= 0 && !result) {
-          if (i == ai) {
-            begs.push(i);
-            ai = str.indexOf(a, i + 1);
-          } else if (begs.length == 1) {
-            result = [begs.pop(), bi];
-          } else {
-            beg = begs.pop();
-            if (beg < left) {
-              left = beg;
-              right = bi;
-            }
-            bi = str.indexOf(b, i + 1);
-          }
-          i = ai < bi && ai >= 0 ? ai : bi;
-        }
-        if (begs.length) {
-          result = [left, right];
-        }
-      }
-      return result;
-    }
-  }
-});
-
-// node_modules/.pnpm/brace-expansion@2.0.1/node_modules/brace-expansion/index.js
-var require_brace_expansion = __commonJS({
-  "node_modules/.pnpm/brace-expansion@2.0.1/node_modules/brace-expansion/index.js"(exports, module2) {
-    var balanced = require_balanced_match();
-    module2.exports = expandTop;
-    var escSlash = "\0SLASH" + Math.random() + "\0";
-    var escOpen = "\0OPEN" + Math.random() + "\0";
-    var escClose = "\0CLOSE" + Math.random() + "\0";
-    var escComma = "\0COMMA" + Math.random() + "\0";
-    var escPeriod = "\0PERIOD" + Math.random() + "\0";
-    function numeric(str) {
-      return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
-    }
-    function escapeBraces(str) {
-      return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
-    }
-    function unescapeBraces(str) {
-      return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
-    }
-    function parseCommaParts(str) {
-      if (!str)
-        return [""];
-      var parts = [];
-      var m = balanced("{", "}", str);
-      if (!m)
-        return str.split(",");
-      var pre = m.pre;
-      var body = m.body;
-      var post = m.post;
-      var p = pre.split(",");
-      p[p.length - 1] += "{" + body + "}";
-      var postParts = parseCommaParts(post);
-      if (post.length) {
-        p[p.length - 1] += postParts.shift();
-        p.push.apply(p, postParts);
-      }
-      parts.push.apply(parts, p);
-      return parts;
-    }
-    function expandTop(str) {
-      if (!str)
-        return [];
-      if (str.substr(0, 2) === "{}") {
-        str = "\\{\\}" + str.substr(2);
-      }
-      return expand2(escapeBraces(str), true).map(unescapeBraces);
-    }
-    function embrace(str) {
-      return "{" + str + "}";
-    }
-    function isPadded(el) {
-      return /^-?0\d/.test(el);
-    }
-    function lte(i, y) {
-      return i <= y;
-    }
-    function gte(i, y) {
-      return i >= y;
-    }
-    function expand2(str, isTop) {
-      var expansions = [];
-      var m = balanced("{", "}", str);
-      if (!m)
-        return [str];
-      var pre = m.pre;
-      var post = m.post.length ? expand2(m.post, false) : [""];
-      if (/\$$/.test(m.pre)) {
-        for (var k = 0; k < post.length; k++) {
-          var expansion = pre + "{" + m.body + "}" + post[k];
-          expansions.push(expansion);
-        }
-      } else {
-        var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-        var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-        var isSequence = isNumericSequence || isAlphaSequence;
-        var isOptions = m.body.indexOf(",") >= 0;
-        if (!isSequence && !isOptions) {
-          if (m.post.match(/,.*\}/)) {
-            str = m.pre + "{" + m.body + escClose + m.post;
-            return expand2(str);
-          }
-          return [str];
-        }
-        var n;
-        if (isSequence) {
-          n = m.body.split(/\.\./);
-        } else {
-          n = parseCommaParts(m.body);
-          if (n.length === 1) {
-            n = expand2(n[0], false).map(embrace);
-            if (n.length === 1) {
-              return post.map(function(p) {
-                return m.pre + n[0] + p;
-              });
-            }
-          }
-        }
-        var N;
-        if (isSequence) {
-          var x = numeric(n[0]);
-          var y = numeric(n[1]);
-          var width = Math.max(n[0].length, n[1].length);
-          var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
-          var test = lte;
-          var reverse = y < x;
-          if (reverse) {
-            incr *= -1;
-            test = gte;
-          }
-          var pad = n.some(isPadded);
-          N = [];
-          for (var i = x; test(i, y); i += incr) {
-            var c;
-            if (isAlphaSequence) {
-              c = String.fromCharCode(i);
-              if (c === "\\")
-                c = "";
-            } else {
-              c = String(i);
-              if (pad) {
-                var need = width - c.length;
-                if (need > 0) {
-                  var z = new Array(need + 1).join("0");
-                  if (i < 0)
-                    c = "-" + z + c.slice(1);
-                  else
-                    c = z + c;
-                }
-              }
-            }
-            N.push(c);
-          }
-        } else {
-          N = [];
-          for (var j = 0; j < n.length; j++) {
-            N.push.apply(N, expand2(n[j], false));
-          }
-        }
-        for (var j = 0; j < N.length; j++) {
-          for (var k = 0; k < post.length; k++) {
-            var expansion = pre + N[j] + post[k];
-            if (!isTop || isSequence || expansion)
-              expansions.push(expansion);
-          }
-        }
-      }
-      return expansions;
-    }
-  }
-});
-
 // src/serializer/pgSerializer.ts
-var import_pg_core2, import_pg_core3, import_drizzle_orm2, dialect2, trimChar, fromDatabase2, columnToDefault, defaultForColumn;
+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_pg_core3 = require("drizzle-orm/pg-core");
-    import_drizzle_orm2 = require("drizzle-orm");
+    import_drizzle_orm = require("drizzle-orm");
     init_serializer();
     init_source();
     init_outputs();
-    dialect2 = new import_pg_core2.PgDialect();
+    dialect = new import_pg_core.PgDialect();
     trimChar = (str, char) => {
       let start = 0;
       let end = str.length;
@@ -1571,7 +1118,7 @@ var init_pgSerializer = __esm({
         --end;
       return start > 0 || end < str.length ? str.substring(start, end) : str.toString();
     };
-    fromDatabase2 = async (db, tablesFilter = (table) => true, schemaFilters, progressCallback) => {
+    fromDatabase = async (db, tablesFilter = (table) => true, schemaFilters, progressCallback) => {
       const result = {};
       const internals = { tables: {} };
       const where = schemaFilters.map((t) => `table_schema = '${t}'`).join(" or ");
@@ -1852,114 +1399,713 @@ var init_pgSerializer = __esm({
             rej(e);
             return;
           }
-          res("");
-        });
-      });
-      if (progressCallback) {
-        progressCallback("tables", tableCount, "done");
+          res("");
+        });
+      });
+      if (progressCallback) {
+        progressCallback("tables", tableCount, "done");
+      }
+      for await (const _ of all) {
+      }
+      if (progressCallback) {
+        progressCallback("columns", columnsCount, "done");
+        progressCallback("indexes", indexesCount, "done");
+        progressCallback("fks", foreignKeysCount, "done");
+      }
+      const allEnums = await db.query(
+        `select n.nspname as enum_schema,
+  t.typname as enum_name,
+  e.enumlabel as enum_value
+  from pg_type t
+  join pg_enum e on t.oid = e.enumtypid
+  join pg_catalog.pg_namespace n ON n.oid = t.typnamespace;`
+      );
+      const enumsToReturn = {};
+      for (const dbEnum of allEnums) {
+        const enumName = dbEnum.enum_name;
+        const enumValue = dbEnum.enum_value;
+        if (enumsToReturn[enumName] !== void 0 && enumsToReturn[enumName] !== null) {
+          enumsToReturn[enumName].values[enumValue] = enumValue;
+        } else {
+          enumsToReturn[enumName] = {
+            name: enumName,
+            values: { [enumValue]: enumValue }
+          };
+        }
+      }
+      if (progressCallback) {
+        progressCallback("enums", Object.keys(enumsToReturn).length, "done");
+      }
+      const schemasObject = Object.fromEntries([...schemas].map((it) => [it, it]));
+      return {
+        version: "5",
+        dialect: "pg",
+        tables: result,
+        enums: enumsToReturn,
+        schemas: schemasObject,
+        _meta: {
+          schemas: {},
+          tables: {},
+          columns: {}
+        },
+        internal: internals
+      };
+    };
+    columnToDefault = {
+      "numeric(": "::numeric",
+      // text: "::text",
+      // "character varying": "::character varying",
+      // "double precision": "::double precision",
+      // "time with time zone": "::time with time zone",
+      "time without time zone": "::time without time zone",
+      // "timestamp with time zone": "::timestamp with time zone",
+      "timestamp without time zone": "::timestamp without time zone",
+      // date: "::date",
+      // interval: "::interval",
+      // character: "::bpchar",
+      // macaddr8: "::macaddr8",
+      // macaddr: "::macaddr",
+      // inet: "::inet",
+      // cidr: "::cidr",
+      // jsonb: "::jsonb",
+      // json: "::json",
+      "character(": "::bpchar"
+    };
+    defaultForColumn = (column) => {
+      if (column.data_type === "serial" || column.data_type === "smallserial" || column.data_type === "bigserial") {
+        return void 0;
+      }
+      const hasDifferentDefaultCast = Object.keys(columnToDefault).find(
+        (it) => column.data_type.startsWith(it)
+      );
+      if (column.column_default === null) {
+        return void 0;
+      }
+      const columnDefaultAsString = column.column_default.toString();
+      if (columnDefaultAsString.endsWith(
+        hasDifferentDefaultCast ? columnToDefault[hasDifferentDefaultCast] : column.data_type
+      )) {
+        const nonPrefixPart = column.column_default.length - (hasDifferentDefaultCast ? columnToDefault[hasDifferentDefaultCast] : `::${column.data_type}`).length - 1;
+        const rt = column.column_default.toString().substring(1, nonPrefixPart);
+        if (/^-?[\d.]+(?:e-?\d+)?$/.test(rt) && !column.data_type.startsWith("numeric")) {
+          return Number(rt);
+        } else if (column.data_type === "json" || column.data_type === "jsonb") {
+          const jsonWithoutSpaces = JSON.stringify(JSON.parse(rt));
+          return `'${jsonWithoutSpaces}'${hasDifferentDefaultCast ? columnToDefault[hasDifferentDefaultCast] : `::${column.data_type}`}`;
+        } else if (column.data_type === "boolean") {
+          return column.column_default === "true";
+        } else {
+          return `'${rt}'`;
+        }
+      } else {
+        if (/^-?[\d.]+(?:e-?\d+)?$/.test(columnDefaultAsString) && !column.data_type.startsWith("numeric")) {
+          return Number(columnDefaultAsString);
+        } else if (column.data_type === "boolean") {
+          return column.column_default === "true";
+        } else {
+          return `${columnDefaultAsString}`;
+        }
+      }
+    };
+    toDrizzle = (schema, schemaName) => {
+      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 === "bigint") {
+            columnBuilder = new import_pg_core.PgBigInt53Builder(columnName);
+          } else if (type === "bigserial") {
+            columnBuilder = new import_pg_core.PgBigSerial53Builder(columnName);
+          } else if (type === "boolean") {
+            columnBuilder = new import_pg_core.PgBooleanBuilder(columnName);
+          } else if (type === "cidr") {
+            columnBuilder = new import_pg_core.PgCidrBuilder(columnName);
+          } else if (type === "date") {
+            columnBuilder = new import_pg_core.PgDateBuilder(columnName);
+          } else if (type === "double precision") {
+            columnBuilder = new import_pg_core.PgDoublePrecisionBuilder(columnName);
+          } else if (type === "inet") {
+            columnBuilder = new import_pg_core.PgInetBuilder(columnName);
+          } else if (type === "integer") {
+            columnBuilder = new import_pg_core.PgIntegerBuilder(columnName);
+          } else if (type === "interval" || type.startsWith("interval ")) {
+            columnBuilder = new import_pg_core.PgIntervalBuilder(columnName, {});
+          } else if (type === "json") {
+            columnBuilder = new import_pg_core.PgJsonBuilder(columnName);
+          } else if (type === "jsonb") {
+            columnBuilder = new import_pg_core.PgJsonbBuilder(columnName);
+          } else if (type === "macaddr") {
+            columnBuilder = new import_pg_core.PgMacaddrBuilder(columnName);
+          } else if (type === "macaddr8") {
+            columnBuilder = new import_pg_core.PgMacaddr8Builder(columnName);
+          } else if (type === "numeric" || type.startsWith("numeric(")) {
+            columnBuilder = new import_pg_core.PgNumericBuilder(columnName);
+          } else if (type === "real") {
+            columnBuilder = new import_pg_core.PgRealBuilder(columnName);
+          } else if (type === "serial") {
+            columnBuilder = new import_pg_core.PgSerialBuilder(columnName);
+          } else if (type === "smallint") {
+            columnBuilder = new import_pg_core.PgSmallIntBuilder(columnName);
+          } else if (type === "smallserial") {
+            columnBuilder = new import_pg_core.PgSmallSerialBuilder(columnName);
+          } else if (type === "text") {
+            columnBuilder = new import_pg_core.PgTextBuilder(columnName, {});
+          } else if (type === "time" || type.startsWith("time(") || type === "time with time zone") {
+            columnBuilder = new import_pg_core.PgTimeBuilder(columnName, false, void 0);
+          } else if (type === "timestamp" || type.startsWith("timestamp(") || type === "timestamp with time zone") {
+            columnBuilder = new import_pg_core.PgTimestampBuilder(columnName, false, void 0);
+          } else if (type === "uuid") {
+            columnBuilder = new import_pg_core.PgUUIDBuilder(columnName);
+          } else if (type === "varchar" || type.startsWith("varchar(")) {
+            columnBuilder = new import_pg_core.PgVarcharBuilder(columnName, {});
+          } else if (type === "char" || type.startsWith("char(")) {
+            columnBuilder = new import_pg_core.PgCharBuilder(columnName, {});
+          } else {
+            columnBuilder = (0, import_pg_core.customType)({
+              dataType() {
+                return type;
+              }
+            })(columnName);
+          }
+          if (c.notNull) {
+            columnBuilder = columnBuilder.notNull();
+          }
+          if (c.default) {
+            columnBuilder = columnBuilder.default(c.default);
+          }
+          if (c.primaryKey) {
+            columnBuilder = columnBuilder.primaryKey();
+          }
+          columns[columnName] = columnBuilder;
+        });
+        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 await (const _ of all) {
+      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("indexes", indexesCount, "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 allEnums = await db.query(
-        `select n.nspname as enum_schema,
-  t.typname as enum_name,
-  e.enumlabel as enum_value
-  from pg_type t
-  join pg_enum e on t.oid = e.enumtypid
-  join pg_catalog.pg_namespace n ON n.oid = t.typnamespace;`
+      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_%';`
       );
-      const enumsToReturn = {};
-      for (const dbEnum of allEnums) {
-        const enumName = dbEnum.enum_name;
-        const enumValue = dbEnum.enum_value;
-        if (enumsToReturn[enumName] !== void 0 && enumsToReturn[enumName] !== null) {
-          enumsToReturn[enumName].values[enumValue] = enumValue;
+      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 {
-          enumsToReturn[enumName] = {
-            name: enumName,
-            values: { [enumValue]: enumValue }
+          tableInResult.indexes[constraintName] = {
+            name: constraintName,
+            columns: [columnName],
+            isUnique
           };
         }
       }
-      if (progressCallback) {
-        progressCallback("enums", Object.keys(enumsToReturn).length, "done");
-      }
-      const schemasObject = Object.fromEntries([...schemas].map((it) => [it, it]));
-      return {
-        version: "5",
-        dialect: "pg",
-        tables: result,
-        enums: enumsToReturn,
-        schemas: schemasObject,
-        _meta: {
-          schemas: {},
-          tables: {},
-          columns: {}
-        },
-        internal: internals
-      };
-    };
-    columnToDefault = {
-      "numeric(": "::numeric",
-      // text: "::text",
-      // "character varying": "::character varying",
-      // "double precision": "::double precision",
-      // "time with time zone": "::time with time zone",
-      "time without time zone": "::time without time zone",
-      // "timestamp with time zone": "::timestamp with time zone",
-      "timestamp without time zone": "::timestamp without time zone",
-      // date: "::date",
-      // interval: "::interval",
-      // character: "::bpchar",
-      // macaddr8: "::macaddr8",
-      // macaddr: "::macaddr",
-      // inet: "::inet",
-      // cidr: "::cidr",
-      // jsonb: "::jsonb",
-      // json: "::json",
-      "character(": "::bpchar"
-    };
-    defaultForColumn = (column) => {
-      if (column.data_type === "serial" || column.data_type === "smallserial" || column.data_type === "bigserial") {
-        return void 0;
+      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_sqlite_core.PrimaryKeyBuilder(
+              gh,
+              cpk.name
+            );
+          });
+          return res;
+        });
+      });
+      return tables;
+    };
+  }
+});
+
+// node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js
+var require_balanced_match = __commonJS({
+  "node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js"(exports, module2) {
+    "use strict";
+    module2.exports = balanced;
+    function balanced(a, b, str) {
+      if (a instanceof RegExp)
+        a = maybeMatch(a, str);
+      if (b instanceof RegExp)
+        b = maybeMatch(b, str);
+      var r = range(a, b, str);
+      return r && {
+        start: r[0],
+        end: r[1],
+        pre: str.slice(0, r[0]),
+        body: str.slice(r[0] + a.length, r[1]),
+        post: str.slice(r[1] + b.length)
+      };
+    }
+    function maybeMatch(reg, str) {
+      var m = str.match(reg);
+      return m ? m[0] : null;
+    }
+    balanced.range = range;
+    function range(a, b, str) {
+      var begs, beg, left, right, result;
+      var ai = str.indexOf(a);
+      var bi = str.indexOf(b, ai + 1);
+      var i = ai;
+      if (ai >= 0 && bi > 0) {
+        if (a === b) {
+          return [ai, bi];
+        }
+        begs = [];
+        left = str.length;
+        while (i >= 0 && !result) {
+          if (i == ai) {
+            begs.push(i);
+            ai = str.indexOf(a, i + 1);
+          } else if (begs.length == 1) {
+            result = [begs.pop(), bi];
+          } else {
+            beg = begs.pop();
+            if (beg < left) {
+              left = beg;
+              right = bi;
+            }
+            bi = str.indexOf(b, i + 1);
+          }
+          i = ai < bi && ai >= 0 ? ai : bi;
+        }
+        if (begs.length) {
+          result = [left, right];
+        }
+      }
+      return result;
+    }
+  }
+});
+
+// node_modules/.pnpm/brace-expansion@2.0.1/node_modules/brace-expansion/index.js
+var require_brace_expansion = __commonJS({
+  "node_modules/.pnpm/brace-expansion@2.0.1/node_modules/brace-expansion/index.js"(exports, module2) {
+    var balanced = require_balanced_match();
+    module2.exports = expandTop;
+    var escSlash = "\0SLASH" + Math.random() + "\0";
+    var escOpen = "\0OPEN" + Math.random() + "\0";
+    var escClose = "\0CLOSE" + Math.random() + "\0";
+    var escComma = "\0COMMA" + Math.random() + "\0";
+    var escPeriod = "\0PERIOD" + Math.random() + "\0";
+    function numeric(str) {
+      return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
+    }
+    function escapeBraces(str) {
+      return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
+    }
+    function unescapeBraces(str) {
+      return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
+    }
+    function parseCommaParts(str) {
+      if (!str)
+        return [""];
+      var parts = [];
+      var m = balanced("{", "}", str);
+      if (!m)
+        return str.split(",");
+      var pre = m.pre;
+      var body = m.body;
+      var post = m.post;
+      var p = pre.split(",");
+      p[p.length - 1] += "{" + body + "}";
+      var postParts = parseCommaParts(post);
+      if (post.length) {
+        p[p.length - 1] += postParts.shift();
+        p.push.apply(p, postParts);
       }
-      const hasDifferentDefaultCast = Object.keys(columnToDefault).find(
-        (it) => column.data_type.startsWith(it)
-      );
-      if (column.column_default === null) {
-        return void 0;
+      parts.push.apply(parts, p);
+      return parts;
+    }
+    function expandTop(str) {
+      if (!str)
+        return [];
+      if (str.substr(0, 2) === "{}") {
+        str = "\\{\\}" + str.substr(2);
       }
-      const columnDefaultAsString = column.column_default.toString();
-      if (columnDefaultAsString.endsWith(
-        hasDifferentDefaultCast ? columnToDefault[hasDifferentDefaultCast] : column.data_type
-      )) {
-        const nonPrefixPart = column.column_default.length - (hasDifferentDefaultCast ? columnToDefault[hasDifferentDefaultCast] : `::${column.data_type}`).length - 1;
-        const rt = column.column_default.toString().substring(1, nonPrefixPart);
-        if (/^-?[\d.]+(?:e-?\d+)?$/.test(rt) && !column.data_type.startsWith("numeric")) {
-          return Number(rt);
-        } else if (column.data_type === "json" || column.data_type === "jsonb") {
-          const jsonWithoutSpaces = JSON.stringify(JSON.parse(rt));
-          return `'${jsonWithoutSpaces}'${hasDifferentDefaultCast ? columnToDefault[hasDifferentDefaultCast] : `::${column.data_type}`}`;
-        } else if (column.data_type === "boolean") {
-          return column.column_default === "true";
-        } else {
-          return `'${rt}'`;
+      return expand2(escapeBraces(str), true).map(unescapeBraces);
+    }
+    function embrace(str) {
+      return "{" + str + "}";
+    }
+    function isPadded(el) {
+      return /^-?0\d/.test(el);
+    }
+    function lte(i, y) {
+      return i <= y;
+    }
+    function gte(i, y) {
+      return i >= y;
+    }
+    function expand2(str, isTop) {
+      var expansions = [];
+      var m = balanced("{", "}", str);
+      if (!m)
+        return [str];
+      var pre = m.pre;
+      var post = m.post.length ? expand2(m.post, false) : [""];
+      if (/\$$/.test(m.pre)) {
+        for (var k = 0; k < post.length; k++) {
+          var expansion = pre + "{" + m.body + "}" + post[k];
+          expansions.push(expansion);
         }
       } else {
-        if (/^-?[\d.]+(?:e-?\d+)?$/.test(columnDefaultAsString) && !column.data_type.startsWith("numeric")) {
-          return Number(columnDefaultAsString);
-        } else if (column.data_type === "boolean") {
-          return column.column_default === "true";
+        var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+        var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+        var isSequence = isNumericSequence || isAlphaSequence;
+        var isOptions = m.body.indexOf(",") >= 0;
+        if (!isSequence && !isOptions) {
+          if (m.post.match(/,.*\}/)) {
+            str = m.pre + "{" + m.body + escClose + m.post;
+            return expand2(str);
+          }
+          return [str];
+        }
+        var n;
+        if (isSequence) {
+          n = m.body.split(/\.\./);
         } else {
-          return `${columnDefaultAsString}`;
+          n = parseCommaParts(m.body);
+          if (n.length === 1) {
+            n = expand2(n[0], false).map(embrace);
+            if (n.length === 1) {
+              return post.map(function(p) {
+                return m.pre + n[0] + p;
+              });
+            }
+          }
+        }
+        var N;
+        if (isSequence) {
+          var x = numeric(n[0]);
+          var y = numeric(n[1]);
+          var width = Math.max(n[0].length, n[1].length);
+          var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
+          var test = lte;
+          var reverse = y < x;
+          if (reverse) {
+            incr *= -1;
+            test = gte;
+          }
+          var pad = n.some(isPadded);
+          N = [];
+          for (var i = x; test(i, y); i += incr) {
+            var c;
+            if (isAlphaSequence) {
+              c = String.fromCharCode(i);
+              if (c === "\\")
+                c = "";
+            } else {
+              c = String(i);
+              if (pad) {
+                var need = width - c.length;
+                if (need > 0) {
+                  var z = new Array(need + 1).join("0");
+                  if (i < 0)
+                    c = "-" + z + c.slice(1);
+                  else
+                    c = z + c;
+                }
+              }
+            }
+            N.push(c);
+          }
+        } else {
+          N = [];
+          for (var j = 0; j < n.length; j++) {
+            N.push.apply(N, expand2(n[j], false));
+          }
+        }
+        for (var j = 0; j < N.length; j++) {
+          for (var k = 0; k < post.length; k++) {
+            var expansion = pre + N[j] + post[k];
+            if (!isTop || isSequence || expansion)
+              expansions.push(expansion);
+          }
         }
       }
-    };
+      return expansions;
+    }
   }
 });
 
@@ -2000,162 +2146,14 @@ var utils_studio_exports = {};
 __export(utils_studio_exports, {
   DrizzleORMPgClient: () => DrizzleORMPgClient,
   TursoSqlite: () => TursoSqlite,
-  drizzleSchemaPg: () => pgSchemaToDrizzle,
-  drizzleSchemaSQLite: () => sqliteSchemaToDrizzle,
+  drizzleSchemaPg: () => toDrizzle,
+  drizzleSchemaSQLite: () => toDrizzle2,
   pgPushIntrospect: () => pgPushIntrospect,
   sqlitePushIntrospect: () => sqlitePushIntrospect
 });
 module.exports = __toCommonJS(utils_studio_exports);
-
-// src/serializer/schemaToDrizzle.ts
-var import_pg_core = require("drizzle-orm/pg-core");
-var import_sqlite_core = require("drizzle-orm/sqlite-core");
-var pgSchemaToDrizzle = (schema, schemaName) => {
-  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 === "bigint") {
-        columnBuilder = new import_pg_core.PgBigInt53Builder(columnName);
-      } else if (type === "bigserial") {
-        columnBuilder = new import_pg_core.PgBigSerial53Builder(columnName);
-      } else if (type === "boolean") {
-        columnBuilder = new import_pg_core.PgBooleanBuilder(columnName);
-      } else if (type === "cidr") {
-        columnBuilder = new import_pg_core.PgCidrBuilder(columnName);
-      } else if (type === "date") {
-        columnBuilder = new import_pg_core.PgDateBuilder(columnName);
-      } else if (type === "double precision") {
-        columnBuilder = new import_pg_core.PgDoublePrecisionBuilder(columnName);
-      } else if (type === "inet") {
-        columnBuilder = new import_pg_core.PgInetBuilder(columnName);
-      } else if (type === "integer") {
-        columnBuilder = new import_pg_core.PgIntegerBuilder(columnName);
-      } else if (type === "interval" || type.startsWith("interval ")) {
-        columnBuilder = new import_pg_core.PgIntervalBuilder(columnName, {});
-      } else if (type === "json") {
-        columnBuilder = new import_pg_core.PgJsonBuilder(columnName);
-      } else if (type === "jsonb") {
-        columnBuilder = new import_pg_core.PgJsonbBuilder(columnName);
-      } else if (type === "macaddr") {
-        columnBuilder = new import_pg_core.PgMacaddrBuilder(columnName);
-      } else if (type === "macaddr8") {
-        columnBuilder = new import_pg_core.PgMacaddr8Builder(columnName);
-      } else if (type === "numeric" || type.startsWith("numeric(")) {
-        columnBuilder = new import_pg_core.PgNumericBuilder(columnName);
-      } else if (type === "real") {
-        columnBuilder = new import_pg_core.PgRealBuilder(columnName);
-      } else if (type === "serial") {
-        columnBuilder = new import_pg_core.PgSerialBuilder(columnName);
-      } else if (type === "smallint") {
-        columnBuilder = new import_pg_core.PgSmallIntBuilder(columnName);
-      } else if (type === "smallserial") {
-        columnBuilder = new import_pg_core.PgSmallSerialBuilder(columnName);
-      } else if (type === "text") {
-        columnBuilder = new import_pg_core.PgTextBuilder(columnName, {});
-      } else if (type === "time" || type.startsWith("time(") || type === "time with time zone") {
-        columnBuilder = new import_pg_core.PgTimeBuilder(columnName, false, void 0);
-      } else if (type === "timestamp" || type.startsWith("timestamp(") || type === "timestamp with time zone") {
-        columnBuilder = new import_pg_core.PgTimestampBuilder(columnName, false, void 0);
-      } else if (type === "uuid") {
-        columnBuilder = new import_pg_core.PgUUIDBuilder(columnName);
-      } else if (type === "varchar" || type.startsWith("varchar(")) {
-        columnBuilder = new import_pg_core.PgVarcharBuilder(columnName, {});
-      } else if (type === "char" || type.startsWith("char(")) {
-        columnBuilder = new import_pg_core.PgCharBuilder(columnName, {});
-      } else {
-        columnBuilder = (0, import_pg_core.customType)({
-          dataType() {
-            return type;
-          }
-        })(columnName);
-      }
-      if (c.notNull) {
-        columnBuilder = columnBuilder.notNull();
-      }
-      if (c.default) {
-        columnBuilder = columnBuilder.default(c.default);
-      }
-      if (c.primaryKey) {
-        columnBuilder = columnBuilder.primaryKey();
-      }
-      columns[columnName] = columnBuilder;
-    });
-    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;
-};
-var sqliteSchemaToDrizzle = (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_sqlite_core.PrimaryKeyBuilder(
-          gh,
-          cpk.name
-        );
-      });
-      return res;
-    });
-  });
-  return tables;
-};
+init_pgSerializer();
+init_sqliteSerializer();
 
 // src/cli/commands/sqliteIntrospect.ts
 init_views();
@@ -3333,7 +3331,7 @@ var sqlitePushIntrospect = async (client, filters) => {
     }
     return false;
   };
-  const res = await fromDatabase(client, filter2);
+  const res = await fromDatabase2(client, filter2);
   const schema = { id: originUUID, prevId: "", ...res };
   return { schema };
 };
@@ -3364,7 +3362,7 @@ var pgPushIntrospect = async (connection, filters, schemaFilters) => {
     }
     return false;
   };
-  const res = await fromDatabase2(client, filter2, schemaFilters);
+  const res = await fromDatabase(client, filter2, schemaFilters);
   const schema = { id: originUUID, prevId: "", ...res };
   const { internal, ...schemaWithoutInternals } = schema;
   return { schema: schemaWithoutInternals };