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

package/utils-studio.mjs

@@ -1099,13 +1099,565 @@ var init_outputs = __esm({
   }
 });
 
+// src/serializer/pgSerializer.ts
+import {
+  customType,
+  PgBigInt53Builder,
+  PgBigSerial53Builder,
+  PgBooleanBuilder,
+  PgCharBuilder,
+  PgCidrBuilder,
+  PgDateBuilder,
+  PgDialect,
+  PgDoublePrecisionBuilder,
+  PgInetBuilder,
+  PgIntegerBuilder,
+  PgIntervalBuilder,
+  PgJsonbBuilder,
+  PgJsonBuilder,
+  PgMacaddr8Builder,
+  PgMacaddrBuilder,
+  PgNumericBuilder,
+  PgRealBuilder,
+  pgSchema,
+  PgSerialBuilder,
+  PgSmallIntBuilder,
+  PgSmallSerialBuilder,
+  pgTable,
+  PgTextBuilder,
+  PgTimeBuilder,
+  PgTimestampBuilder,
+  PgUUIDBuilder,
+  PgVarcharBuilder,
+  PrimaryKeyBuilder,
+  uniqueKeyName
+} from "drizzle-orm/pg-core";
+import { getTableConfig } from "drizzle-orm/pg-core";
+import { is, SQL, getTableName } from "drizzle-orm";
+var dialect, trimChar, fromDatabase, columnToDefault, defaultForColumn, toDrizzle;
+var init_pgSerializer = __esm({
+  "src/serializer/pgSerializer.ts"() {
+    init_serializer();
+    init_source();
+    init_outputs();
+    dialect = new PgDialect();
+    trimChar = (str, char) => {
+      let start = 0;
+      let end = str.length;
+      while (start < end && str[start] === char)
+        ++start;
+      while (end > start && str[end - 1] === char)
+        --end;
+      return start > 0 || end < str.length ? str.substring(start, end) : str.toString();
+    };
+    fromDatabase = async (db, tablesFilter = (table) => true, schemaFilters, progressCallback) => {
+      const result = {};
+      const internals = { tables: {} };
+      const where = schemaFilters.map((t) => `table_schema = '${t}'`).join(" or ");
+      const allTables = await db.query(
+        `SELECT table_schema, table_name FROM information_schema.tables WHERE ${where};`
+      );
+      const schemas = new Set(allTables.map((it) => it.table_schema));
+      schemas.delete("public");
+      const allSchemas = await db.query(`select s.nspname as table_schema
+  from pg_catalog.pg_namespace s
+  join pg_catalog.pg_user u on u.usesysid = s.nspowner
+  where nspname not in ('information_schema', 'pg_catalog', 'public')
+        and nspname not like 'pg_toast%'
+        and nspname not like 'pg_temp_%'
+  order by table_schema;`);
+      allSchemas.forEach((item) => {
+        if (schemaFilters.includes(item.table_schema)) {
+          schemas.add(item.table_schema);
+        }
+      });
+      let columnsCount = 0;
+      let indexesCount = 0;
+      let foreignKeysCount = 0;
+      let tableCount = 0;
+      const all = allTables.map((row) => {
+        return new Promise(async (res, rej) => {
+          const tableName = row.table_name;
+          if (!tablesFilter(tableName))
+            return res("");
+          tableCount += 1;
+          const tableSchema = row.table_schema;
+          try {
+            const columnToReturn = {};
+            const indexToReturn = {};
+            const foreignKeysToReturn = {};
+            const primaryKeys = {};
+            const uniqueConstrains = {};
+            const tableResponse = await db.query(
+              `SELECT a.attrelid::regclass::text, a.attname, is_nullable, a.attndims as array_dimensions
+        , CASE WHEN a.atttypid = ANY ('{int,int8,int2}'::regtype[])
+             AND EXISTS (
+                SELECT FROM pg_attrdef ad
+                WHERE  ad.adrelid = a.attrelid
+                AND    ad.adnum   = a.attnum
+                AND    pg_get_expr(ad.adbin, ad.adrelid)
+                     = 'nextval('''
+                    || (pg_get_serial_sequence (a.attrelid::regclass::text
+                                             , a.attname))::regclass
+                    || '''::regclass)'
+                )
+           THEN CASE a.atttypid
+                   WHEN 'int'::regtype  THEN 'serial'
+                   WHEN 'int8'::regtype THEN 'bigserial'
+                   WHEN 'int2'::regtype THEN 'smallserial'
+                END
+           ELSE format_type(a.atttypid, a.atttypmod)
+           END AS data_type, INFORMATION_SCHEMA.COLUMNS.table_name, INFORMATION_SCHEMA.COLUMNS.column_name, INFORMATION_SCHEMA.COLUMNS.column_default, INFORMATION_SCHEMA.COLUMNS.data_type as additional_dt
+   FROM  pg_attribute  a
+   JOIN INFORMATION_SCHEMA.COLUMNS ON INFORMATION_SCHEMA.COLUMNS.column_name = a.attname
+   WHERE  a.attrelid = '"${tableSchema}"."${tableName}"'::regclass and INFORMATION_SCHEMA.COLUMNS.table_name = '${tableName}'
+   AND    a.attnum > 0
+   AND    NOT a.attisdropped
+   ORDER  BY a.attnum;`
+            );
+            const tableConstraints = await db.query(
+              `SELECT c.column_name, c.data_type, constraint_type, constraint_name, constraint_schema
+      FROM information_schema.table_constraints tc
+      JOIN information_schema.constraint_column_usage AS ccu USING (constraint_schema, constraint_name)
+      JOIN information_schema.columns AS c ON c.table_schema = tc.constraint_schema
+        AND tc.table_name = c.table_name AND ccu.column_name = c.column_name
+      WHERE tc.table_name = '${tableName}' and constraint_schema = '${tableSchema}';`
+            );
+            columnsCount += tableResponse.length;
+            if (progressCallback) {
+              progressCallback("columns", columnsCount, "fetching");
+            }
+            const tableForeignKeys = await db.query(
+              `SELECT
+        tc.table_schema,
+        tc.constraint_name,
+        tc.table_name,
+        kcu.column_name,
+        ccu.table_schema AS foreign_table_schema,
+        ccu.table_name AS foreign_table_name,
+        ccu.column_name AS foreign_column_name,
+        rc.delete_rule, rc.update_rule
+    FROM
+        information_schema.table_constraints AS tc
+        JOIN information_schema.key_column_usage AS kcu
+          ON tc.constraint_name = kcu.constraint_name
+          AND tc.table_schema = kcu.table_schema
+        JOIN information_schema.constraint_column_usage AS ccu
+          ON ccu.constraint_name = tc.constraint_name
+          AND ccu.table_schema = tc.table_schema
+        JOIN information_schema.referential_constraints AS rc
+          ON ccu.constraint_name = rc.constraint_name
+    WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_name='${tableName}' and tc.table_schema='${tableSchema}';`
+            );
+            foreignKeysCount += tableForeignKeys.length;
+            if (progressCallback) {
+              progressCallback("fks", foreignKeysCount, "fetching");
+            }
+            for (const fk of tableForeignKeys) {
+              const columnFrom = fk.column_name;
+              const tableTo = fk.foreign_table_name;
+              const columnTo = fk.foreign_column_name;
+              const foreignKeyName = fk.constraint_name;
+              const onUpdate = fk.update_rule.toLowerCase();
+              const onDelete = fk.delete_rule.toLowerCase();
+              if (typeof foreignKeysToReturn[foreignKeyName] !== "undefined") {
+                foreignKeysToReturn[foreignKeyName].columnsFrom.push(columnFrom);
+                foreignKeysToReturn[foreignKeyName].columnsTo.push(columnTo);
+              } else {
+                foreignKeysToReturn[foreignKeyName] = {
+                  name: foreignKeyName,
+                  tableFrom: tableName,
+                  tableTo,
+                  columnsFrom: [columnFrom],
+                  columnsTo: [columnTo],
+                  onDelete,
+                  onUpdate
+                };
+              }
+              foreignKeysToReturn[foreignKeyName].columnsFrom = [
+                ...new Set(foreignKeysToReturn[foreignKeyName].columnsFrom)
+              ];
+              foreignKeysToReturn[foreignKeyName].columnsTo = [
+                ...new Set(foreignKeysToReturn[foreignKeyName].columnsTo)
+              ];
+            }
+            const uniqueConstrainsRows = tableConstraints.filter(
+              (mapRow) => mapRow.constraint_type === "UNIQUE"
+            );
+            for (const unqs of uniqueConstrainsRows) {
+              const columnName = unqs.column_name;
+              const constraintName = unqs.constraint_name;
+              if (typeof uniqueConstrains[constraintName] !== "undefined") {
+                uniqueConstrains[constraintName].columns.push(columnName);
+              } else {
+                uniqueConstrains[constraintName] = {
+                  columns: [columnName],
+                  nullsNotDistinct: false,
+                  name: constraintName
+                };
+              }
+            }
+            for (const columnResponse of tableResponse) {
+              const columnName = columnResponse.attname;
+              const columnAdditionalDT = columnResponse.additional_dt;
+              const columnDimensions = columnResponse.array_dimensions;
+              let columnType = columnResponse.data_type;
+              const primaryKey = tableConstraints.filter(
+                (mapRow) => columnName === mapRow.column_name && mapRow.constraint_type === "PRIMARY KEY"
+              );
+              const cprimaryKey = tableConstraints.filter(
+                (mapRow) => mapRow.constraint_type === "PRIMARY KEY"
+              );
+              if (cprimaryKey.length > 1) {
+                const tableCompositePkName = await db.query(
+                  `SELECT conname AS primary_key
+            FROM   pg_constraint join pg_class on (pg_class.oid = conrelid)
+            WHERE  contype = 'p' 
+            AND    connamespace = $1::regnamespace  
+            AND    pg_class.relname = $2;`,
+                  [tableSchema, tableName]
+                );
+                primaryKeys[tableCompositePkName[0].primary_key] = {
+                  name: tableCompositePkName[0].primary_key,
+                  columns: cprimaryKey.map((c) => c.column_name)
+                };
+              }
+              const defaultValue = defaultForColumn(columnResponse);
+              const isSerial = columnType === "serial";
+              let columnTypeMapped = columnType;
+              if (columnTypeMapped.startsWith("numeric(")) {
+                columnTypeMapped = columnTypeMapped.replace(",", ", ");
+              }
+              if (columnAdditionalDT === "ARRAY") {
+                if (typeof internals.tables[tableName] === "undefined") {
+                  internals.tables[tableName] = {
+                    columns: {
+                      [columnName]: {
+                        isArray: true,
+                        dimensions: columnDimensions,
+                        rawType: columnTypeMapped.substring(
+                          0,
+                          columnTypeMapped.length - 2
+                        )
+                      }
+                    }
+                  };
+                } else {
+                  if (typeof internals.tables[tableName].columns[columnName] === "undefined") {
+                    internals.tables[tableName].columns[columnName] = {
+                      isArray: true,
+                      dimensions: columnDimensions,
+                      rawType: columnTypeMapped.substring(
+                        0,
+                        columnTypeMapped.length - 2
+                      )
+                    };
+                  }
+                }
+              }
+              if (columnAdditionalDT === "ARRAY") {
+                for (let i = 1; i < Number(columnDimensions); i++) {
+                  columnTypeMapped += "[]";
+                }
+              }
+              columnTypeMapped = columnTypeMapped.replace("character varying", "varchar").replace(" without time zone", "").replace("character", "char");
+              columnTypeMapped = trimChar(columnTypeMapped, '"');
+              columnToReturn[columnName] = {
+                name: columnName,
+                type: columnTypeMapped,
+                primaryKey: primaryKey.length === 1 && cprimaryKey.length < 2,
+                // default: isSerial ? undefined : defaultValue,
+                notNull: columnResponse.is_nullable === "NO"
+              };
+              if (!isSerial && typeof defaultValue !== "undefined") {
+                columnToReturn[columnName].default = defaultValue;
+              }
+            }
+            const dbIndexes = await db.query(
+              `SELECT t.relname as table_name, i.relname AS index_name, ix.indisunique AS is_unique, a.attname AS column_name
+          FROM pg_class t
+          JOIN pg_index ix ON t.oid = ix.indrelid
+          JOIN pg_class i ON i.oid = ix.indexrelid
+          JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
+          JOIN pg_namespace ns ON ns.oid = t.relnamespace
+          WHERE ns.nspname = '${tableSchema}'
+            AND t.relname = '${tableName}'
+            and ix.indisprimary = false;`
+            );
+            const dbIndexFromConstraint = await db.query(
+              `SELECT
+          idx.indexrelname AS index_name,
+          idx.relname AS table_name,
+          schemaname,
+          CASE WHEN con.conname IS NOT NULL THEN 1 ELSE 0 END AS generated_by_constraint
+        FROM
+          pg_stat_user_indexes idx
+        LEFT JOIN
+          pg_constraint con ON con.conindid = idx.indexrelid
+        WHERE idx.relname = '${tableName}' and schemaname = '${tableSchema}'
+        group by index_name, table_name,schemaname, generated_by_constraint;`
+            );
+            const idxsInConsteraint = dbIndexFromConstraint.filter((it) => it.generated_by_constraint === 1).map((it) => it.index_name);
+            for (const dbIndex of dbIndexes) {
+              const indexName2 = dbIndex.index_name;
+              const indexColumnName = dbIndex.column_name;
+              const indexIsUnique = dbIndex.is_unique;
+              if (idxsInConsteraint.includes(indexName2))
+                continue;
+              if (typeof indexToReturn[indexName2] !== "undefined") {
+                indexToReturn[indexName2].columns.push(indexColumnName);
+              } else {
+                indexToReturn[indexName2] = {
+                  name: indexName2,
+                  columns: [indexColumnName],
+                  isUnique: indexIsUnique
+                };
+              }
+            }
+            indexesCount += Object.keys(indexToReturn).length;
+            if (progressCallback) {
+              progressCallback("indexes", indexesCount, "fetching");
+            }
+            result[tableName] = {
+              name: tableName,
+              schema: tableSchema !== "public" ? tableSchema : "",
+              columns: columnToReturn,
+              indexes: indexToReturn,
+              foreignKeys: foreignKeysToReturn,
+              compositePrimaryKeys: primaryKeys,
+              uniqueConstraints: uniqueConstrains
+            };
+          } catch (e) {
+            rej(e);
+            return;
+          }
+          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 PgBigInt53Builder(columnName);
+          } else if (type === "bigserial") {
+            columnBuilder = new PgBigSerial53Builder(columnName);
+          } else if (type === "boolean") {
+            columnBuilder = new PgBooleanBuilder(columnName);
+          } else if (type === "cidr") {
+            columnBuilder = new PgCidrBuilder(columnName);
+          } else if (type === "date") {
+            columnBuilder = new PgDateBuilder(columnName);
+          } else if (type === "double precision") {
+            columnBuilder = new PgDoublePrecisionBuilder(columnName);
+          } else if (type === "inet") {
+            columnBuilder = new PgInetBuilder(columnName);
+          } else if (type === "integer") {
+            columnBuilder = new PgIntegerBuilder(columnName);
+          } else if (type === "interval" || type.startsWith("interval ")) {
+            columnBuilder = new PgIntervalBuilder(columnName, {});
+          } else if (type === "json") {
+            columnBuilder = new PgJsonBuilder(columnName);
+          } else if (type === "jsonb") {
+            columnBuilder = new PgJsonbBuilder(columnName);
+          } else if (type === "macaddr") {
+            columnBuilder = new PgMacaddrBuilder(columnName);
+          } else if (type === "macaddr8") {
+            columnBuilder = new PgMacaddr8Builder(columnName);
+          } else if (type === "numeric" || type.startsWith("numeric(")) {
+            columnBuilder = new PgNumericBuilder(columnName);
+          } else if (type === "real") {
+            columnBuilder = new PgRealBuilder(columnName);
+          } else if (type === "serial") {
+            columnBuilder = new PgSerialBuilder(columnName);
+          } else if (type === "smallint") {
+            columnBuilder = new PgSmallIntBuilder(columnName);
+          } else if (type === "smallserial") {
+            columnBuilder = new PgSmallSerialBuilder(columnName);
+          } else if (type === "text") {
+            columnBuilder = new PgTextBuilder(columnName, {});
+          } else if (type === "time" || type.startsWith("time(") || type === "time with time zone") {
+            columnBuilder = new PgTimeBuilder(columnName, false, void 0);
+          } else if (type === "timestamp" || type.startsWith("timestamp(") || type === "timestamp with time zone") {
+            columnBuilder = new PgTimestampBuilder(columnName, false, void 0);
+          } else if (type === "uuid") {
+            columnBuilder = new PgUUIDBuilder(columnName);
+          } else if (type === "varchar" || type.startsWith("varchar(")) {
+            columnBuilder = new PgVarcharBuilder(columnName, {});
+          } else if (type === "char" || type.startsWith("char(")) {
+            columnBuilder = new PgCharBuilder(columnName, {});
+          } else {
+            columnBuilder = 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] = 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 PrimaryKeyBuilder(
+                gh,
+                cpk.name
+              );
+            });
+            return res;
+          });
+        } else {
+          tables[t.name] = 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 PrimaryKeyBuilder(
+                gh,
+                cpk.name
+              );
+            });
+            return res;
+          });
+        }
+      });
+      return tables;
+    };
+  }
+});
+
 // src/serializer/sqliteSerializer.ts
-import { getTableName, is, SQL } from "drizzle-orm";
+import { getTableName as getTableName2, is as is2, SQL as SQL2 } from "drizzle-orm";
 import {
-  getTableConfig,
+  getTableConfig as getTableConfig2,
+  PrimaryKeyBuilder as PrimaryKeyBuilder2,
   SQLiteBaseInteger,
+  SQLiteBlobBufferBuilder,
+  SQLiteIntegerBuilder,
+  SQLiteNumericBuilder,
+  SQLiteRealBuilder,
   SQLiteSyncDialect,
-  uniqueKeyName
+  sqliteTable,
+  SQLiteTextBuilder,
+  uniqueKeyName as uniqueKeyName2
 } from "drizzle-orm/sqlite-core";
 function mapSqlToSqliteType(sqlType) {
   if ([
@@ -1142,14 +1694,14 @@ function mapSqlToSqliteType(sqlType) {
     return "numeric";
   }
 }
-var dialect, fromDatabase;
+var dialect2, fromDatabase2, toDrizzle2;
 var init_sqliteSerializer = __esm({
   "src/serializer/sqliteSerializer.ts"() {
     init_serializer();
     init_outputs();
     init_source();
-    dialect = new SQLiteSyncDialect();
-    fromDatabase = async (db, tablesFilter = (table) => true, progressCallback) => {
+    dialect2 = new SQLiteSyncDialect();
+    fromDatabase2 = async (db, tablesFilter = (table) => true, progressCallback) => {
       const result = {};
       const columns = await db.query(
         `SELECT 
@@ -1343,6 +1895,50 @@ WHERE
         }
       };
     };
+    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 SQLiteIntegerBuilder(columnName);
+          } else if (type === "text") {
+            columnBuilder = new SQLiteTextBuilder(columnName, {});
+          } else if (type === "blob") {
+            columnBuilder = new SQLiteBlobBufferBuilder(columnName);
+          } else if (type === "real") {
+            columnBuilder = new SQLiteRealBuilder(columnName);
+          } else {
+            columnBuilder = new 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] = 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 PrimaryKeyBuilder2(
+              gh,
+              cpk.name
+            );
+          });
+          return res;
+        });
+      });
+      return tables;
+    };
   }
 });
 
@@ -1529,446 +2125,31 @@ var require_brace_expansion = __commonJS({
                 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
-import {
-  PgDialect,
-  uniqueKeyName as uniqueKeyName2
-} from "drizzle-orm/pg-core";
-import { getTableConfig as getTableConfig2 } from "drizzle-orm/pg-core";
-import { is as is2, SQL as SQL2, getTableName as getTableName2 } from "drizzle-orm";
-var dialect2, trimChar, fromDatabase2, columnToDefault, defaultForColumn;
-var init_pgSerializer = __esm({
-  "src/serializer/pgSerializer.ts"() {
-    init_serializer();
-    init_source();
-    init_outputs();
-    dialect2 = new PgDialect();
-    trimChar = (str, char) => {
-      let start = 0;
-      let end = str.length;
-      while (start < end && str[start] === char)
-        ++start;
-      while (end > start && str[end - 1] === char)
-        --end;
-      return start > 0 || end < str.length ? str.substring(start, end) : str.toString();
-    };
-    fromDatabase2 = async (db, tablesFilter = (table) => true, schemaFilters, progressCallback) => {
-      const result = {};
-      const internals = { tables: {} };
-      const where = schemaFilters.map((t) => `table_schema = '${t}'`).join(" or ");
-      const allTables = await db.query(
-        `SELECT table_schema, table_name FROM information_schema.tables WHERE ${where};`
-      );
-      const schemas = new Set(allTables.map((it) => it.table_schema));
-      schemas.delete("public");
-      const allSchemas = await db.query(`select s.nspname as table_schema
-  from pg_catalog.pg_namespace s
-  join pg_catalog.pg_user u on u.usesysid = s.nspowner
-  where nspname not in ('information_schema', 'pg_catalog', 'public')
-        and nspname not like 'pg_toast%'
-        and nspname not like 'pg_temp_%'
-  order by table_schema;`);
-      allSchemas.forEach((item) => {
-        if (schemaFilters.includes(item.table_schema)) {
-          schemas.add(item.table_schema);
-        }
-      });
-      let columnsCount = 0;
-      let indexesCount = 0;
-      let foreignKeysCount = 0;
-      let tableCount = 0;
-      const all = allTables.map((row) => {
-        return new Promise(async (res, rej) => {
-          const tableName = row.table_name;
-          if (!tablesFilter(tableName))
-            return res("");
-          tableCount += 1;
-          const tableSchema = row.table_schema;
-          try {
-            const columnToReturn = {};
-            const indexToReturn = {};
-            const foreignKeysToReturn = {};
-            const primaryKeys = {};
-            const uniqueConstrains = {};
-            const tableResponse = await db.query(
-              `SELECT a.attrelid::regclass::text, a.attname, is_nullable, a.attndims as array_dimensions
-        , CASE WHEN a.atttypid = ANY ('{int,int8,int2}'::regtype[])
-             AND EXISTS (
-                SELECT FROM pg_attrdef ad
-                WHERE  ad.adrelid = a.attrelid
-                AND    ad.adnum   = a.attnum
-                AND    pg_get_expr(ad.adbin, ad.adrelid)
-                     = 'nextval('''
-                    || (pg_get_serial_sequence (a.attrelid::regclass::text
-                                             , a.attname))::regclass
-                    || '''::regclass)'
-                )
-           THEN CASE a.atttypid
-                   WHEN 'int'::regtype  THEN 'serial'
-                   WHEN 'int8'::regtype THEN 'bigserial'
-                   WHEN 'int2'::regtype THEN 'smallserial'
-                END
-           ELSE format_type(a.atttypid, a.atttypmod)
-           END AS data_type, INFORMATION_SCHEMA.COLUMNS.table_name, INFORMATION_SCHEMA.COLUMNS.column_name, INFORMATION_SCHEMA.COLUMNS.column_default, INFORMATION_SCHEMA.COLUMNS.data_type as additional_dt
-   FROM  pg_attribute  a
-   JOIN INFORMATION_SCHEMA.COLUMNS ON INFORMATION_SCHEMA.COLUMNS.column_name = a.attname
-   WHERE  a.attrelid = '"${tableSchema}"."${tableName}"'::regclass and INFORMATION_SCHEMA.COLUMNS.table_name = '${tableName}'
-   AND    a.attnum > 0
-   AND    NOT a.attisdropped
-   ORDER  BY a.attnum;`
-            );
-            const tableConstraints = await db.query(
-              `SELECT c.column_name, c.data_type, constraint_type, constraint_name, constraint_schema
-      FROM information_schema.table_constraints tc
-      JOIN information_schema.constraint_column_usage AS ccu USING (constraint_schema, constraint_name)
-      JOIN information_schema.columns AS c ON c.table_schema = tc.constraint_schema
-        AND tc.table_name = c.table_name AND ccu.column_name = c.column_name
-      WHERE tc.table_name = '${tableName}' and constraint_schema = '${tableSchema}';`
-            );
-            columnsCount += tableResponse.length;
-            if (progressCallback) {
-              progressCallback("columns", columnsCount, "fetching");
-            }
-            const tableForeignKeys = await db.query(
-              `SELECT
-        tc.table_schema,
-        tc.constraint_name,
-        tc.table_name,
-        kcu.column_name,
-        ccu.table_schema AS foreign_table_schema,
-        ccu.table_name AS foreign_table_name,
-        ccu.column_name AS foreign_column_name,
-        rc.delete_rule, rc.update_rule
-    FROM
-        information_schema.table_constraints AS tc
-        JOIN information_schema.key_column_usage AS kcu
-          ON tc.constraint_name = kcu.constraint_name
-          AND tc.table_schema = kcu.table_schema
-        JOIN information_schema.constraint_column_usage AS ccu
-          ON ccu.constraint_name = tc.constraint_name
-          AND ccu.table_schema = tc.table_schema
-        JOIN information_schema.referential_constraints AS rc
-          ON ccu.constraint_name = rc.constraint_name
-    WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_name='${tableName}' and tc.table_schema='${tableSchema}';`
-            );
-            foreignKeysCount += tableForeignKeys.length;
-            if (progressCallback) {
-              progressCallback("fks", foreignKeysCount, "fetching");
-            }
-            for (const fk of tableForeignKeys) {
-              const columnFrom = fk.column_name;
-              const tableTo = fk.foreign_table_name;
-              const columnTo = fk.foreign_column_name;
-              const foreignKeyName = fk.constraint_name;
-              const onUpdate = fk.update_rule.toLowerCase();
-              const onDelete = fk.delete_rule.toLowerCase();
-              if (typeof foreignKeysToReturn[foreignKeyName] !== "undefined") {
-                foreignKeysToReturn[foreignKeyName].columnsFrom.push(columnFrom);
-                foreignKeysToReturn[foreignKeyName].columnsTo.push(columnTo);
-              } else {
-                foreignKeysToReturn[foreignKeyName] = {
-                  name: foreignKeyName,
-                  tableFrom: tableName,
-                  tableTo,
-                  columnsFrom: [columnFrom],
-                  columnsTo: [columnTo],
-                  onDelete,
-                  onUpdate
-                };
-              }
-              foreignKeysToReturn[foreignKeyName].columnsFrom = [
-                ...new Set(foreignKeysToReturn[foreignKeyName].columnsFrom)
-              ];
-              foreignKeysToReturn[foreignKeyName].columnsTo = [
-                ...new Set(foreignKeysToReturn[foreignKeyName].columnsTo)
-              ];
-            }
-            const uniqueConstrainsRows = tableConstraints.filter(
-              (mapRow) => mapRow.constraint_type === "UNIQUE"
-            );
-            for (const unqs of uniqueConstrainsRows) {
-              const columnName = unqs.column_name;
-              const constraintName = unqs.constraint_name;
-              if (typeof uniqueConstrains[constraintName] !== "undefined") {
-                uniqueConstrains[constraintName].columns.push(columnName);
-              } else {
-                uniqueConstrains[constraintName] = {
-                  columns: [columnName],
-                  nullsNotDistinct: false,
-                  name: constraintName
-                };
-              }
-            }
-            for (const columnResponse of tableResponse) {
-              const columnName = columnResponse.attname;
-              const columnAdditionalDT = columnResponse.additional_dt;
-              const columnDimensions = columnResponse.array_dimensions;
-              let columnType = columnResponse.data_type;
-              const primaryKey = tableConstraints.filter(
-                (mapRow) => columnName === mapRow.column_name && mapRow.constraint_type === "PRIMARY KEY"
-              );
-              const cprimaryKey = tableConstraints.filter(
-                (mapRow) => mapRow.constraint_type === "PRIMARY KEY"
-              );
-              if (cprimaryKey.length > 1) {
-                const tableCompositePkName = await db.query(
-                  `SELECT conname AS primary_key
-            FROM   pg_constraint join pg_class on (pg_class.oid = conrelid)
-            WHERE  contype = 'p' 
-            AND    connamespace = $1::regnamespace  
-            AND    pg_class.relname = $2;`,
-                  [tableSchema, tableName]
-                );
-                primaryKeys[tableCompositePkName[0].primary_key] = {
-                  name: tableCompositePkName[0].primary_key,
-                  columns: cprimaryKey.map((c) => c.column_name)
-                };
-              }
-              const defaultValue = defaultForColumn(columnResponse);
-              const isSerial = columnType === "serial";
-              let columnTypeMapped = columnType;
-              if (columnTypeMapped.startsWith("numeric(")) {
-                columnTypeMapped = columnTypeMapped.replace(",", ", ");
-              }
-              if (columnAdditionalDT === "ARRAY") {
-                if (typeof internals.tables[tableName] === "undefined") {
-                  internals.tables[tableName] = {
-                    columns: {
-                      [columnName]: {
-                        isArray: true,
-                        dimensions: columnDimensions,
-                        rawType: columnTypeMapped.substring(
-                          0,
-                          columnTypeMapped.length - 2
-                        )
-                      }
-                    }
-                  };
-                } else {
-                  if (typeof internals.tables[tableName].columns[columnName] === "undefined") {
-                    internals.tables[tableName].columns[columnName] = {
-                      isArray: true,
-                      dimensions: columnDimensions,
-                      rawType: columnTypeMapped.substring(
-                        0,
-                        columnTypeMapped.length - 2
-                      )
-                    };
-                  }
-                }
-              }
-              if (columnAdditionalDT === "ARRAY") {
-                for (let i = 1; i < Number(columnDimensions); i++) {
-                  columnTypeMapped += "[]";
+                  if (i < 0)
+                    c = "-" + z + c.slice(1);
+                  else
+                    c = z + c;
                 }
               }
-              columnTypeMapped = columnTypeMapped.replace("character varying", "varchar").replace(" without time zone", "").replace("character", "char");
-              columnTypeMapped = trimChar(columnTypeMapped, '"');
-              columnToReturn[columnName] = {
-                name: columnName,
-                type: columnTypeMapped,
-                primaryKey: primaryKey.length === 1 && cprimaryKey.length < 2,
-                // default: isSerial ? undefined : defaultValue,
-                notNull: columnResponse.is_nullable === "NO"
-              };
-              if (!isSerial && typeof defaultValue !== "undefined") {
-                columnToReturn[columnName].default = defaultValue;
-              }
-            }
-            const dbIndexes = await db.query(
-              `SELECT t.relname as table_name, i.relname AS index_name, ix.indisunique AS is_unique, a.attname AS column_name
-          FROM pg_class t
-          JOIN pg_index ix ON t.oid = ix.indrelid
-          JOIN pg_class i ON i.oid = ix.indexrelid
-          JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
-          JOIN pg_namespace ns ON ns.oid = t.relnamespace
-          WHERE ns.nspname = '${tableSchema}'
-            AND t.relname = '${tableName}'
-            and ix.indisprimary = false;`
-            );
-            const dbIndexFromConstraint = await db.query(
-              `SELECT
-          idx.indexrelname AS index_name,
-          idx.relname AS table_name,
-          schemaname,
-          CASE WHEN con.conname IS NOT NULL THEN 1 ELSE 0 END AS generated_by_constraint
-        FROM
-          pg_stat_user_indexes idx
-        LEFT JOIN
-          pg_constraint con ON con.conindid = idx.indexrelid
-        WHERE idx.relname = '${tableName}' and schemaname = '${tableSchema}'
-        group by index_name, table_name,schemaname, generated_by_constraint;`
-            );
-            const idxsInConsteraint = dbIndexFromConstraint.filter((it) => it.generated_by_constraint === 1).map((it) => it.index_name);
-            for (const dbIndex of dbIndexes) {
-              const indexName2 = dbIndex.index_name;
-              const indexColumnName = dbIndex.column_name;
-              const indexIsUnique = dbIndex.is_unique;
-              if (idxsInConsteraint.includes(indexName2))
-                continue;
-              if (typeof indexToReturn[indexName2] !== "undefined") {
-                indexToReturn[indexName2].columns.push(indexColumnName);
-              } else {
-                indexToReturn[indexName2] = {
-                  name: indexName2,
-                  columns: [indexColumnName],
-                  isUnique: indexIsUnique
-                };
-              }
-            }
-            indexesCount += Object.keys(indexToReturn).length;
-            if (progressCallback) {
-              progressCallback("indexes", indexesCount, "fetching");
             }
-            result[tableName] = {
-              name: tableName,
-              schema: tableSchema !== "public" ? tableSchema : "",
-              columns: columnToReturn,
-              indexes: indexToReturn,
-              foreignKeys: foreignKeysToReturn,
-              compositePrimaryKeys: primaryKeys,
-              uniqueConstraints: uniqueConstrains
-            };
-          } catch (e) {
-            rej(e);
-            return;
+            N.push(c);
           }
-          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}'`;
+          N = [];
+          for (var j = 0; j < n.length; j++) {
+            N.push.apply(N, expand2(n[j], false));
+          }
         }
-      } 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}`;
+        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;
+    }
   }
 });
 
@@ -2004,192 +2185,9 @@ var init_drivers = __esm({
   }
 });
 
-// src/serializer/schemaToDrizzle.ts
-import {
-  customType,
-  PgBigInt53Builder,
-  PgBigSerial53Builder,
-  PgBooleanBuilder,
-  PgCharBuilder,
-  PgCidrBuilder,
-  PgDateBuilder,
-  PgDoublePrecisionBuilder,
-  PgInetBuilder,
-  PgIntegerBuilder,
-  PgIntervalBuilder,
-  PgJsonbBuilder,
-  PgJsonBuilder,
-  PgMacaddr8Builder,
-  PgMacaddrBuilder,
-  PgNumericBuilder,
-  PgRealBuilder,
-  pgSchema,
-  PgSerialBuilder,
-  PgSmallIntBuilder,
-  PgSmallSerialBuilder,
-  pgTable,
-  PgTextBuilder,
-  PgTimeBuilder,
-  PgTimestampBuilder,
-  PgUUIDBuilder,
-  PgVarcharBuilder,
-  PrimaryKeyBuilder as PgPrimaryKeyBuilder
-} from "drizzle-orm/pg-core";
-import {
-  SQLiteIntegerBuilder,
-  SQLiteTextBuilder,
-  SQLiteBlobBufferBuilder,
-  SQLiteRealBuilder,
-  SQLiteNumericBuilder,
-  sqliteTable,
-  PrimaryKeyBuilder as SQLitePrimaryKeyBuilder
-} from "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 PgBigInt53Builder(columnName);
-      } else if (type === "bigserial") {
-        columnBuilder = new PgBigSerial53Builder(columnName);
-      } else if (type === "boolean") {
-        columnBuilder = new PgBooleanBuilder(columnName);
-      } else if (type === "cidr") {
-        columnBuilder = new PgCidrBuilder(columnName);
-      } else if (type === "date") {
-        columnBuilder = new PgDateBuilder(columnName);
-      } else if (type === "double precision") {
-        columnBuilder = new PgDoublePrecisionBuilder(columnName);
-      } else if (type === "inet") {
-        columnBuilder = new PgInetBuilder(columnName);
-      } else if (type === "integer") {
-        columnBuilder = new PgIntegerBuilder(columnName);
-      } else if (type === "interval" || type.startsWith("interval ")) {
-        columnBuilder = new PgIntervalBuilder(columnName, {});
-      } else if (type === "json") {
-        columnBuilder = new PgJsonBuilder(columnName);
-      } else if (type === "jsonb") {
-        columnBuilder = new PgJsonbBuilder(columnName);
-      } else if (type === "macaddr") {
-        columnBuilder = new PgMacaddrBuilder(columnName);
-      } else if (type === "macaddr8") {
-        columnBuilder = new PgMacaddr8Builder(columnName);
-      } else if (type === "numeric" || type.startsWith("numeric(")) {
-        columnBuilder = new PgNumericBuilder(columnName);
-      } else if (type === "real") {
-        columnBuilder = new PgRealBuilder(columnName);
-      } else if (type === "serial") {
-        columnBuilder = new PgSerialBuilder(columnName);
-      } else if (type === "smallint") {
-        columnBuilder = new PgSmallIntBuilder(columnName);
-      } else if (type === "smallserial") {
-        columnBuilder = new PgSmallSerialBuilder(columnName);
-      } else if (type === "text") {
-        columnBuilder = new PgTextBuilder(columnName, {});
-      } else if (type === "time" || type.startsWith("time(") || type === "time with time zone") {
-        columnBuilder = new PgTimeBuilder(columnName, false, void 0);
-      } else if (type === "timestamp" || type.startsWith("timestamp(") || type === "timestamp with time zone") {
-        columnBuilder = new PgTimestampBuilder(columnName, false, void 0);
-      } else if (type === "uuid") {
-        columnBuilder = new PgUUIDBuilder(columnName);
-      } else if (type === "varchar" || type.startsWith("varchar(")) {
-        columnBuilder = new PgVarcharBuilder(columnName, {});
-      } else if (type === "char" || type.startsWith("char(")) {
-        columnBuilder = new PgCharBuilder(columnName, {});
-      } else {
-        columnBuilder = 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] = 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 PgPrimaryKeyBuilder(
-            gh,
-            cpk.name
-          );
-        });
-        return res;
-      });
-    } else {
-      tables[t.name] = 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 PgPrimaryKeyBuilder(
-            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 SQLiteIntegerBuilder(columnName);
-      } else if (type === "text") {
-        columnBuilder = new SQLiteTextBuilder(columnName, {});
-      } else if (type === "blob") {
-        columnBuilder = new SQLiteBlobBufferBuilder(columnName);
-      } else if (type === "real") {
-        columnBuilder = new SQLiteRealBuilder(columnName);
-      } else {
-        columnBuilder = new 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] = 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 SQLitePrimaryKeyBuilder(
-          gh,
-          cpk.name
-        );
-      });
-      return res;
-    });
-  });
-  return tables;
-};
+// src/utils-studio.ts
+init_pgSerializer();
+init_sqliteSerializer();
 
 // src/cli/commands/sqliteIntrospect.ts
 init_views();
@@ -3367,7 +3365,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 };
 };
@@ -3403,7 +3401,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 };
@@ -3414,8 +3412,8 @@ init_drivers();
 export {
   DrizzleORMPgClient,
   TursoSqlite,
-  pgSchemaToDrizzle as drizzleSchemaPg,
-  sqliteSchemaToDrizzle as drizzleSchemaSQLite,
+  toDrizzle as drizzleSchemaPg,
+  toDrizzle2 as drizzleSchemaSQLite,
   pgPushIntrospect,
   sqlitePushIntrospect
 };