drizzle-kit 0.20.14-c82ab68 → 0.20.14-dc0459e

package/utils.mjs

@@ -1080,7 +1080,6 @@ var require_hanji = __commonJS({
 var import_hanji, info;
 var init_views = __esm({
   "src/cli/views.ts"() {
-    "use strict";
     init_source();
     import_hanji = __toESM(require_hanji());
     info = (msg, greyMsg = "") => {
@@ -1089,26 +1088,6 @@ var init_views = __esm({
   }
 });
 
-// src/global.ts
-function assertUnreachable(x) {
-  throw new Error("Didn't expect to get here");
-}
-var originUUID, snapshotVersion, mapValues;
-var init_global = __esm({
-  "src/global.ts"() {
-    "use strict";
-    originUUID = "00000000-0000-0000-0000-000000000000";
-    snapshotVersion = "6";
-    mapValues = (obj, map) => {
-      const result = Object.keys(obj).reduce(function(result2, key) {
-        result2[key] = map(obj[key]);
-        return result2;
-      }, {});
-      return result;
-    };
-  }
-});
-
 // node_modules/.pnpm/zod@3.20.2/node_modules/zod/lib/index.mjs
 function getErrorMap() {
   return overrideErrorMap;
@@ -4248,751 +4227,10 @@ var init_lib = __esm({
   }
 });
 
-// src/serializer/mysqlSchema.ts
-var index, fk, column, tableV3, compositePK, uniqueConstraint, tableV4, table, kitInternals, dialect, schemaHash, schemaInternalV3, schemaInternalV4, schemaInternalV5, schemaInternalV6, schemaInternal, schemaV3, schemaV4, schemaV5, schema, tableSquashedV4, tableSquashed, schemaSquashed, schemaSquashedV4, MySqlSquasher, mysqlSchema, mysqlSchemaV5, backwardCompatibleMysqlSchema, dryMySql;
-var init_mysqlSchema = __esm({
-  "src/serializer/mysqlSchema.ts"() {
-    "use strict";
-    init_global();
-    init_lib();
-    index = objectType({
-      name: stringType(),
-      columns: stringType().array(),
-      isUnique: booleanType(),
-      using: enumType(["btree", "hash"]).optional(),
-      algorithm: enumType(["default", "inplace", "copy"]).optional(),
-      lock: enumType(["default", "none", "shared", "exclusive"]).optional()
-    }).strict();
-    fk = objectType({
-      name: stringType(),
-      tableFrom: stringType(),
-      columnsFrom: stringType().array(),
-      tableTo: stringType(),
-      columnsTo: stringType().array(),
-      onUpdate: stringType().optional(),
-      onDelete: stringType().optional()
-    }).strict();
-    column = objectType({
-      name: stringType(),
-      type: stringType(),
-      primaryKey: booleanType(),
-      notNull: booleanType(),
-      autoincrement: booleanType().optional(),
-      default: anyType().optional(),
-      onUpdate: anyType().optional()
-    }).strict();
-    tableV3 = objectType({
-      name: stringType(),
-      columns: recordType(stringType(), column),
-      indexes: recordType(stringType(), index),
-      foreignKeys: recordType(stringType(), fk)
-    }).strict();
-    compositePK = objectType({
-      name: stringType(),
-      columns: stringType().array()
-    }).strict();
-    uniqueConstraint = objectType({
-      name: stringType(),
-      columns: stringType().array()
-    }).strict();
-    tableV4 = objectType({
-      name: stringType(),
-      schema: stringType().optional(),
-      columns: recordType(stringType(), column),
-      indexes: recordType(stringType(), index),
-      foreignKeys: recordType(stringType(), fk)
-    }).strict();
-    table = objectType({
-      name: stringType(),
-      schema: stringType().optional(),
-      columns: recordType(stringType(), column),
-      indexes: recordType(stringType(), index),
-      foreignKeys: recordType(stringType(), fk),
-      compositePrimaryKeys: recordType(stringType(), compositePK),
-      uniqueConstraints: recordType(stringType(), uniqueConstraint).default({})
-    }).strict();
-    kitInternals = objectType({
-      tables: recordType(
-        stringType(),
-        objectType({
-          columns: recordType(
-            stringType(),
-            objectType({ isDefaultAnExpression: booleanType().optional() }).optional()
-          )
-        }).optional()
-      )
-    }).optional();
-    dialect = literalType("mysql");
-    schemaHash = objectType({
-      id: stringType(),
-      prevId: stringType()
-    });
-    schemaInternalV3 = objectType({
-      version: literalType("3"),
-      dialect,
-      tables: recordType(stringType(), tableV3)
-    }).strict();
-    schemaInternalV4 = objectType({
-      version: literalType("4"),
-      dialect,
-      tables: recordType(stringType(), tableV4),
-      schemas: recordType(stringType(), stringType())
-    }).strict();
-    schemaInternalV5 = objectType({
-      version: literalType("5"),
-      dialect,
-      tables: recordType(stringType(), table),
-      schemas: recordType(stringType(), stringType()),
-      _meta: objectType({
-        schemas: recordType(stringType(), stringType()),
-        tables: recordType(stringType(), stringType()),
-        columns: recordType(stringType(), stringType())
-      }),
-      internal: kitInternals
-    }).strict();
-    schemaInternalV6 = objectType({
-      version: literalType("6"),
-      dialect,
-      tables: recordType(stringType(), table),
-      schemas: recordType(stringType(), stringType()),
-      _meta: objectType({
-        schemas: recordType(stringType(), stringType()),
-        tables: recordType(stringType(), stringType()),
-        columns: recordType(stringType(), stringType())
-      }),
-      internal: kitInternals
-    }).strict();
-    schemaInternal = objectType({
-      version: literalType("6"),
-      dialect,
-      tables: recordType(stringType(), table),
-      schemas: recordType(stringType(), stringType()),
-      _meta: objectType({
-        schemas: recordType(stringType(), stringType()),
-        tables: recordType(stringType(), stringType()),
-        columns: recordType(stringType(), stringType())
-      }),
-      internal: kitInternals
-    }).strict();
-    schemaV3 = schemaInternalV3.merge(schemaHash);
-    schemaV4 = schemaInternalV4.merge(schemaHash);
-    schemaV5 = schemaInternalV5.merge(schemaHash);
-    schema = schemaInternal.merge(schemaHash);
-    tableSquashedV4 = objectType({
-      name: stringType(),
-      schema: stringType().optional(),
-      columns: recordType(stringType(), column),
-      indexes: recordType(stringType(), stringType()),
-      foreignKeys: recordType(stringType(), stringType())
-    }).strict();
-    tableSquashed = objectType({
-      name: stringType(),
-      schema: stringType().optional(),
-      columns: recordType(stringType(), column),
-      indexes: recordType(stringType(), stringType()),
-      foreignKeys: recordType(stringType(), stringType()),
-      compositePrimaryKeys: recordType(stringType(), stringType()),
-      uniqueConstraints: recordType(stringType(), stringType()).default({})
-    }).strict();
-    schemaSquashed = objectType({
-      version: literalType("5"),
-      dialect,
-      tables: recordType(stringType(), tableSquashed),
-      schemas: recordType(stringType(), stringType())
-    }).strict();
-    schemaSquashedV4 = objectType({
-      version: literalType("4"),
-      dialect,
-      tables: recordType(stringType(), tableSquashedV4),
-      schemas: recordType(stringType(), stringType())
-    }).strict();
-    MySqlSquasher = {
-      squashIdx: (idx) => {
-        index.parse(idx);
-        return `${idx.name};${idx.columns.join(",")};${idx.isUnique};${idx.using ?? ""};${idx.algorithm ?? ""};${idx.lock ?? ""}`;
-      },
-      unsquashIdx: (input) => {
-        const [name, columnsString, isUnique, using, algorithm, lock] = input.split(";");
-        const destructed = {
-          name,
-          columns: columnsString.split(","),
-          isUnique: isUnique === "true",
-          using: using ? using : void 0,
-          algorithm: algorithm ? algorithm : void 0,
-          lock: lock ? lock : void 0
-        };
-        return index.parse(destructed);
-      },
-      squashPK: (pk) => {
-        return `${pk.name};${pk.columns.join(",")}`;
-      },
-      unsquashPK: (pk) => {
-        const splitted = pk.split(";");
-        return { name: splitted[0], columns: splitted[1].split(",") };
-      },
-      squashUnique: (unq) => {
-        return `${unq.name};${unq.columns.join(",")}`;
-      },
-      unsquashUnique: (unq) => {
-        const [name, columns] = unq.split(";");
-        return { name, columns: columns.split(",") };
-      },
-      squashFK: (fk4) => {
-        return `${fk4.name};${fk4.tableFrom};${fk4.columnsFrom.join(",")};${fk4.tableTo};${fk4.columnsTo.join(",")};${fk4.onUpdate ?? ""};${fk4.onDelete ?? ""}`;
-      },
-      unsquashFK: (input) => {
-        const [
-          name,
-          tableFrom,
-          columnsFromStr,
-          tableTo,
-          columnsToStr,
-          onUpdate,
-          onDelete
-        ] = input.split(";");
-        const result = fk.parse({
-          name,
-          tableFrom,
-          columnsFrom: columnsFromStr.split(","),
-          tableTo,
-          columnsTo: columnsToStr.split(","),
-          onUpdate,
-          onDelete
-        });
-        return result;
-      }
-    };
-    mysqlSchema = schema;
-    mysqlSchemaV5 = schemaV5;
-    backwardCompatibleMysqlSchema = unionType([mysqlSchemaV5, schema]);
-    dryMySql = mysqlSchema.parse({
-      version: snapshotVersion,
-      dialect: "mysql",
-      id: originUUID,
-      prevId: "",
-      tables: {},
-      schemas: {},
-      _meta: {
-        schemas: {},
-        tables: {},
-        columns: {}
-      }
-    });
-  }
-});
-
-// src/serializer/pgSchema.ts
-var indexV2, columnV2, tableV2, enumSchema, pgSchemaV2, references, columnV1, tableV1, pgSchemaV1, index2, fk2, column2, tableV32, compositePK2, uniqueConstraint2, tableV42, table2, schemaHash2, kitInternals2, pgSchemaInternalV3, pgSchemaInternalV4, pgSchemaInternalV5, pgSchemaExternal, pgSchemaInternal, tableSquashed2, tableSquashedV42, pgSchemaSquashedV4, pgSchemaSquashed, pgSchemaV3, pgSchemaV4, pgSchemaV5, pgSchema, backwardCompatiblePgSchema, PgSquasher, squashPgScheme, dryPg;
-var init_pgSchema = __esm({
-  "src/serializer/pgSchema.ts"() {
-    "use strict";
-    init_global();
-    init_lib();
-    indexV2 = objectType({
-      name: stringType(),
-      columns: recordType(
-        stringType(),
-        objectType({
-          name: stringType()
-        })
-      ),
-      isUnique: booleanType()
-    }).strict();
-    columnV2 = objectType({
-      name: stringType(),
-      type: stringType(),
-      primaryKey: booleanType(),
-      notNull: booleanType(),
-      default: anyType().optional(),
-      references: stringType().optional()
-    }).strict();
-    tableV2 = objectType({
-      name: stringType(),
-      columns: recordType(stringType(), columnV2),
-      indexes: recordType(stringType(), indexV2)
-    }).strict();
-    enumSchema = objectType({
-      name: stringType(),
-      values: recordType(stringType(), stringType())
-    }).strict();
-    pgSchemaV2 = objectType({
-      version: literalType("2"),
-      tables: recordType(stringType(), tableV2),
-      enums: recordType(stringType(), enumSchema)
-    }).strict();
-    references = objectType({
-      foreignKeyName: stringType(),
-      table: stringType(),
-      column: stringType(),
-      onDelete: stringType().optional(),
-      onUpdate: stringType().optional()
-    }).strict();
-    columnV1 = objectType({
-      name: stringType(),
-      type: stringType(),
-      primaryKey: booleanType(),
-      notNull: booleanType(),
-      default: anyType().optional(),
-      references: references.optional()
-    }).strict();
-    tableV1 = objectType({
-      name: stringType(),
-      columns: recordType(stringType(), columnV1),
-      indexes: recordType(stringType(), indexV2)
-    }).strict();
-    pgSchemaV1 = objectType({
-      version: literalType("1"),
-      tables: recordType(stringType(), tableV1),
-      enums: recordType(stringType(), enumSchema)
-    }).strict();
-    index2 = objectType({
-      name: stringType(),
-      columns: stringType().array(),
-      isUnique: booleanType()
-    }).strict();
-    fk2 = objectType({
-      name: stringType(),
-      tableFrom: stringType(),
-      columnsFrom: stringType().array(),
-      tableTo: stringType(),
-      schemaTo: stringType().optional(),
-      columnsTo: stringType().array(),
-      onUpdate: stringType().optional(),
-      onDelete: stringType().optional()
-    }).strict();
-    column2 = objectType({
-      name: stringType(),
-      type: stringType(),
-      primaryKey: booleanType(),
-      notNull: booleanType(),
-      default: anyType().optional(),
-      isUnique: anyType().optional(),
-      uniqueName: stringType().optional(),
-      nullsNotDistinct: booleanType().optional()
-    }).strict();
-    tableV32 = objectType({
-      name: stringType(),
-      columns: recordType(stringType(), column2),
-      indexes: recordType(stringType(), index2),
-      foreignKeys: recordType(stringType(), fk2)
-    }).strict();
-    compositePK2 = objectType({
-      name: stringType(),
-      columns: stringType().array()
-    }).strict();
-    uniqueConstraint2 = objectType({
-      name: stringType(),
-      columns: stringType().array(),
-      nullsNotDistinct: booleanType()
-    }).strict();
-    tableV42 = objectType({
-      name: stringType(),
-      schema: stringType(),
-      columns: recordType(stringType(), column2),
-      indexes: recordType(stringType(), index2),
-      foreignKeys: recordType(stringType(), fk2)
-    }).strict();
-    table2 = objectType({
-      name: stringType(),
-      schema: stringType(),
-      columns: recordType(stringType(), column2),
-      indexes: recordType(stringType(), index2),
-      foreignKeys: recordType(stringType(), fk2),
-      compositePrimaryKeys: recordType(stringType(), compositePK2),
-      uniqueConstraints: recordType(stringType(), uniqueConstraint2).default({})
-    }).strict();
-    schemaHash2 = objectType({
-      id: stringType(),
-      prevId: stringType()
-    });
-    kitInternals2 = objectType({
-      tables: recordType(
-        stringType(),
-        objectType({
-          columns: recordType(
-            stringType(),
-            objectType({
-              isArray: booleanType().optional(),
-              dimensions: numberType().optional(),
-              rawType: stringType().optional()
-            }).optional()
-          )
-        }).optional()
-      )
-    }).optional();
-    pgSchemaInternalV3 = objectType({
-      version: literalType("3"),
-      dialect: literalType("pg"),
-      tables: recordType(stringType(), tableV32),
-      enums: recordType(stringType(), enumSchema)
-    }).strict();
-    pgSchemaInternalV4 = objectType({
-      version: literalType("4"),
-      dialect: literalType("pg"),
-      tables: recordType(stringType(), tableV42),
-      enums: recordType(stringType(), enumSchema),
-      schemas: recordType(stringType(), stringType())
-    }).strict();
-    pgSchemaInternalV5 = objectType({
-      version: literalType("5"),
-      dialect: literalType("pg"),
-      tables: recordType(stringType(), table2),
-      enums: recordType(stringType(), enumSchema),
-      schemas: recordType(stringType(), stringType()),
-      _meta: objectType({
-        schemas: recordType(stringType(), stringType()),
-        tables: recordType(stringType(), stringType()),
-        columns: recordType(stringType(), stringType())
-      }),
-      internal: kitInternals2
-    }).strict();
-    pgSchemaExternal = objectType({
-      version: literalType("5"),
-      dialect: literalType("pg"),
-      tables: arrayType(table2),
-      enums: arrayType(enumSchema),
-      schemas: arrayType(objectType({ name: stringType() })),
-      _meta: objectType({
-        schemas: recordType(stringType(), stringType()),
-        tables: recordType(stringType(), stringType()),
-        columns: recordType(stringType(), stringType())
-      })
-    }).strict();
-    pgSchemaInternal = objectType({
-      version: literalType("6"),
-      dialect: literalType("pg"),
-      tables: recordType(stringType(), table2),
-      enums: recordType(stringType(), enumSchema),
-      schemas: recordType(stringType(), stringType()),
-      _meta: objectType({
-        schemas: recordType(stringType(), stringType()),
-        tables: recordType(stringType(), stringType()),
-        columns: recordType(stringType(), stringType())
-      }),
-      internal: kitInternals2
-    }).strict();
-    tableSquashed2 = objectType({
-      name: stringType(),
-      schema: stringType(),
-      columns: recordType(stringType(), column2),
-      indexes: recordType(stringType(), stringType()),
-      foreignKeys: recordType(stringType(), stringType()),
-      compositePrimaryKeys: recordType(stringType(), stringType()),
-      uniqueConstraints: recordType(stringType(), stringType())
-    }).strict();
-    tableSquashedV42 = objectType({
-      name: stringType(),
-      schema: stringType(),
-      columns: recordType(stringType(), column2),
-      indexes: recordType(stringType(), stringType()),
-      foreignKeys: recordType(stringType(), stringType())
-    }).strict();
-    pgSchemaSquashedV4 = objectType({
-      version: literalType("4"),
-      dialect: enumType(["pg"]),
-      tables: recordType(stringType(), tableSquashedV42),
-      enums: recordType(stringType(), enumSchema),
-      schemas: recordType(stringType(), stringType())
-    }).strict();
-    pgSchemaSquashed = objectType({
-      version: literalType("6"),
-      dialect: enumType(["pg"]),
-      tables: recordType(stringType(), tableSquashed2),
-      enums: recordType(stringType(), enumSchema),
-      schemas: recordType(stringType(), stringType())
-    }).strict();
-    pgSchemaV3 = pgSchemaInternalV3.merge(schemaHash2);
-    pgSchemaV4 = pgSchemaInternalV4.merge(schemaHash2);
-    pgSchemaV5 = pgSchemaInternalV5.merge(schemaHash2);
-    pgSchema = pgSchemaInternal.merge(schemaHash2);
-    backwardCompatiblePgSchema = unionType([pgSchemaV5, pgSchema]);
-    PgSquasher = {
-      squashIdx: (idx) => {
-        index2.parse(idx);
-        return `${idx.name};${idx.columns.join(",")};${idx.isUnique}`;
-      },
-      unsquashIdx: (input) => {
-        const [name, columnsString, isUnique] = input.split(";");
-        const result = index2.parse({
-          name,
-          columns: columnsString.split(","),
-          isUnique: isUnique === "true"
-        });
-        return result;
-      },
-      squashFK: (fk4) => {
-        return `${fk4.name};${fk4.tableFrom};${fk4.columnsFrom.join(",")};${fk4.tableTo};${fk4.columnsTo.join(",")};${fk4.onUpdate ?? ""};${fk4.onDelete ?? ""};${fk4.schemaTo || "public"}`;
-      },
-      squashPK: (pk) => {
-        return `${pk.columns.join(",")};${pk.name}`;
-      },
-      unsquashPK: (pk) => {
-        const splitted = pk.split(";");
-        return { name: splitted[1], columns: splitted[0].split(",") };
-      },
-      squashUnique: (unq) => {
-        return `${unq.name};${unq.columns.join(",")};${unq.nullsNotDistinct}`;
-      },
-      unsquashUnique: (unq) => {
-        const [name, columns, nullsNotDistinct] = unq.split(";");
-        return {
-          name,
-          columns: columns.split(","),
-          nullsNotDistinct: nullsNotDistinct === "true"
-        };
-      },
-      unsquashFK: (input) => {
-        const [
-          name,
-          tableFrom,
-          columnsFromStr,
-          tableTo,
-          columnsToStr,
-          onUpdate,
-          onDelete,
-          schemaTo
-        ] = input.split(";");
-        const result = fk2.parse({
-          name,
-          tableFrom,
-          columnsFrom: columnsFromStr.split(","),
-          schemaTo,
-          tableTo,
-          columnsTo: columnsToStr.split(","),
-          onUpdate,
-          onDelete
-        });
-        return result;
-      }
-    };
-    squashPgScheme = (json) => {
-      const mappedTables = Object.fromEntries(
-        Object.entries(json.tables).map((it) => {
-          const squashedIndexes = mapValues(it[1].indexes, (index4) => {
-            return PgSquasher.squashIdx(index4);
-          });
-          const squashedFKs = mapValues(it[1].foreignKeys, (fk4) => {
-            return PgSquasher.squashFK(fk4);
-          });
-          const squashedPKs = mapValues(it[1].compositePrimaryKeys, (pk) => {
-            return PgSquasher.squashPK(pk);
-          });
-          const squashedUniqueConstraints = mapValues(
-            it[1].uniqueConstraints,
-            (unq) => {
-              return PgSquasher.squashUnique(unq);
-            }
-          );
-          return [
-            it[0],
-            {
-              name: it[1].name,
-              schema: it[1].schema,
-              columns: it[1].columns,
-              indexes: squashedIndexes,
-              foreignKeys: squashedFKs,
-              compositePrimaryKeys: squashedPKs,
-              uniqueConstraints: squashedUniqueConstraints
-            }
-          ];
-        })
-      );
-      return {
-        version: "6",
-        dialect: json.dialect,
-        tables: mappedTables,
-        enums: json.enums,
-        schemas: json.schemas
-      };
-    };
-    dryPg = pgSchema.parse({
-      version: snapshotVersion,
-      dialect: "pg",
-      id: originUUID,
-      prevId: "",
-      tables: {},
-      enums: {},
-      schemas: {},
-      _meta: {
-        schemas: {},
-        tables: {},
-        columns: {}
-      }
-    });
-  }
-});
-
-// src/serializer/sqliteSchema.ts
-var index3, fk3, compositePK3, column3, tableV33, uniqueConstraint3, table3, dialect2, schemaHash3, schemaInternalV32, schemaInternalV42, latestVersion, schemaInternal2, schemaV32, schemaV42, schema2, tableSquashed3, schemaSquashed2, SQLiteSquasher, drySQLite, backwardCompatibleSqliteSchema;
-var init_sqliteSchema = __esm({
-  "src/serializer/sqliteSchema.ts"() {
-    "use strict";
-    init_global();
-    init_lib();
-    index3 = objectType({
-      name: stringType(),
-      columns: stringType().array(),
-      where: stringType().optional(),
-      isUnique: booleanType()
-    }).strict();
-    fk3 = objectType({
-      name: stringType(),
-      tableFrom: stringType(),
-      columnsFrom: stringType().array(),
-      tableTo: stringType(),
-      columnsTo: stringType().array(),
-      onUpdate: stringType().optional(),
-      onDelete: stringType().optional()
-    }).strict();
-    compositePK3 = objectType({
-      columns: stringType().array(),
-      name: stringType().optional()
-    }).strict();
-    column3 = objectType({
-      name: stringType(),
-      type: stringType(),
-      primaryKey: booleanType(),
-      notNull: booleanType(),
-      autoincrement: booleanType().optional(),
-      default: anyType().optional()
-    }).strict();
-    tableV33 = objectType({
-      name: stringType(),
-      columns: recordType(stringType(), column3),
-      indexes: recordType(stringType(), index3),
-      foreignKeys: recordType(stringType(), fk3)
-    }).strict();
-    uniqueConstraint3 = objectType({
-      name: stringType(),
-      columns: stringType().array()
-    }).strict();
-    table3 = objectType({
-      name: stringType(),
-      columns: recordType(stringType(), column3),
-      indexes: recordType(stringType(), index3),
-      foreignKeys: recordType(stringType(), fk3),
-      compositePrimaryKeys: recordType(stringType(), compositePK3),
-      uniqueConstraints: recordType(stringType(), uniqueConstraint3).default({})
-    }).strict();
-    dialect2 = enumType(["sqlite"]);
-    schemaHash3 = objectType({
-      id: stringType(),
-      prevId: stringType()
-    }).strict();
-    schemaInternalV32 = objectType({
-      version: literalType("3"),
-      dialect: dialect2,
-      tables: recordType(stringType(), tableV33),
-      enums: objectType({})
-    }).strict();
-    schemaInternalV42 = objectType({
-      version: literalType("4"),
-      dialect: dialect2,
-      tables: recordType(stringType(), table3),
-      enums: objectType({})
-    }).strict();
-    latestVersion = literalType("5");
-    schemaInternal2 = objectType({
-      version: latestVersion,
-      dialect: dialect2,
-      tables: recordType(stringType(), table3),
-      enums: objectType({}),
-      _meta: objectType({
-        tables: recordType(stringType(), stringType()),
-        columns: recordType(stringType(), stringType())
-      })
-    }).strict();
-    schemaV32 = schemaInternalV32.merge(schemaHash3).strict();
-    schemaV42 = schemaInternalV42.merge(schemaHash3).strict();
-    schema2 = schemaInternal2.merge(schemaHash3).strict();
-    tableSquashed3 = objectType({
-      name: stringType(),
-      columns: recordType(stringType(), column3),
-      indexes: recordType(stringType(), stringType()),
-      foreignKeys: recordType(stringType(), stringType()),
-      compositePrimaryKeys: recordType(stringType(), stringType()),
-      uniqueConstraints: recordType(stringType(), stringType()).default({})
-    }).strict();
-    schemaSquashed2 = objectType({
-      version: latestVersion,
-      dialect: dialect2,
-      tables: recordType(stringType(), tableSquashed3),
-      enums: anyType()
-    }).strict();
-    SQLiteSquasher = {
-      squashIdx: (idx) => {
-        index3.parse(idx);
-        return `${idx.name};${idx.columns.join(",")};${idx.isUnique};${idx.where ?? ""}`;
-      },
-      unsquashIdx: (input) => {
-        const [name, columnsString, isUnique, where] = input.split(";");
-        const result = index3.parse({
-          name,
-          columns: columnsString.split(","),
-          isUnique: isUnique === "true",
-          where: where ?? void 0
-        });
-        return result;
-      },
-      squashUnique: (unq) => {
-        return `${unq.name};${unq.columns.join(",")}`;
-      },
-      unsquashUnique: (unq) => {
-        const [name, columns] = unq.split(";");
-        return { name, columns: columns.split(",") };
-      },
-      squashFK: (fk4) => {
-        return `${fk4.name};${fk4.tableFrom};${fk4.columnsFrom.join(",")};${fk4.tableTo};${fk4.columnsTo.join(",")};${fk4.onUpdate ?? ""};${fk4.onDelete ?? ""}`;
-      },
-      unsquashFK: (input) => {
-        const [
-          name,
-          tableFrom,
-          columnsFromStr,
-          tableTo,
-          columnsToStr,
-          onUpdate,
-          onDelete
-        ] = input.split(";");
-        const result = fk3.parse({
-          name,
-          tableFrom,
-          columnsFrom: columnsFromStr.split(","),
-          tableTo,
-          columnsTo: columnsToStr.split(","),
-          onUpdate,
-          onDelete
-        });
-        return result;
-      },
-      squashPK: (pk) => {
-        return pk.columns.join(",");
-      },
-      unsquashPK: (pk) => {
-        return pk.split(",");
-      }
-    };
-    drySQLite = schema2.parse({
-      version: "5",
-      dialect: "sqlite",
-      id: originUUID,
-      prevId: "",
-      tables: {},
-      enums: {},
-      _meta: {
-        tables: {},
-        columns: {}
-      }
-    });
-    backwardCompatibleSqliteSchema = schema2;
-  }
-});
-
 // src/serializer/index.ts
 import * as glob from "glob";
 var init_serializer = __esm({
   "src/serializer/index.ts"() {
-    "use strict";
     init_source();
     init_views();
   }
@@ -5001,18 +4239,12 @@ var init_serializer = __esm({
 // src/cli/validations/outputs.ts
 var init_outputs = __esm({
   "src/cli/validations/outputs.ts"() {
-    "use strict";
     init_source();
   }
 });
 
 // src/utils.ts
 init_views();
-init_mysqlSchema();
-init_pgSchema();
-init_sqliteSchema();
-init_source();
-init_global();
 import {
   existsSync,
   mkdirSync,
@@ -5020,6 +4252,709 @@ import {
   readFileSync,
   writeFileSync
 } from "fs";
+
+// src/global.ts
+var originUUID = "00000000-0000-0000-0000-000000000000";
+var snapshotVersion = "5";
+var mapValues = (obj, map) => {
+  const result = Object.keys(obj).reduce(function(result2, key) {
+    result2[key] = map(obj[key]);
+    return result2;
+  }, {});
+  return result;
+};
+
+// src/serializer/mysqlSchema.ts
+init_lib();
+var index = objectType({
+  name: stringType(),
+  columns: stringType().array(),
+  isUnique: booleanType(),
+  using: enumType(["btree", "hash"]).optional(),
+  algorithm: enumType(["default", "inplace", "copy"]).optional(),
+  lock: enumType(["default", "none", "shared", "exclusive"]).optional()
+}).strict();
+var fk = objectType({
+  name: stringType(),
+  tableFrom: stringType(),
+  columnsFrom: stringType().array(),
+  tableTo: stringType(),
+  columnsTo: stringType().array(),
+  onUpdate: stringType().optional(),
+  onDelete: stringType().optional()
+}).strict();
+var column = objectType({
+  name: stringType(),
+  type: stringType(),
+  primaryKey: booleanType(),
+  notNull: booleanType(),
+  autoincrement: booleanType().optional(),
+  default: anyType().optional(),
+  onUpdate: anyType().optional()
+}).strict();
+var tableV3 = objectType({
+  name: stringType(),
+  columns: recordType(stringType(), column),
+  indexes: recordType(stringType(), index),
+  foreignKeys: recordType(stringType(), fk)
+}).strict();
+var compositePK = objectType({
+  name: stringType(),
+  columns: stringType().array()
+}).strict();
+var uniqueConstraint = objectType({
+  name: stringType(),
+  columns: stringType().array()
+}).strict();
+var tableV4 = objectType({
+  name: stringType(),
+  schema: stringType().optional(),
+  columns: recordType(stringType(), column),
+  indexes: recordType(stringType(), index),
+  foreignKeys: recordType(stringType(), fk)
+}).strict();
+var table = objectType({
+  name: stringType(),
+  schema: stringType().optional(),
+  columns: recordType(stringType(), column),
+  indexes: recordType(stringType(), index),
+  foreignKeys: recordType(stringType(), fk),
+  compositePrimaryKeys: recordType(stringType(), compositePK),
+  uniqueConstraints: recordType(stringType(), uniqueConstraint).default({})
+}).strict();
+var dialect = literalType("mysql");
+var schemaHash = objectType({
+  id: stringType(),
+  prevId: stringType()
+});
+var schemaInternalV3 = objectType({
+  version: literalType("3"),
+  dialect,
+  tables: recordType(stringType(), tableV3)
+}).strict();
+var schemaInternalV4 = objectType({
+  version: literalType("4"),
+  dialect,
+  tables: recordType(stringType(), tableV4),
+  schemas: recordType(stringType(), stringType())
+}).strict();
+var kitInternals = objectType({
+  tables: recordType(
+    stringType(),
+    objectType({
+      columns: recordType(
+        stringType(),
+        objectType({ isDefaultAnExpression: booleanType().optional() }).optional()
+      )
+    }).optional()
+  )
+}).optional();
+var schemaInternal = objectType({
+  version: literalType("5"),
+  dialect,
+  tables: recordType(stringType(), table),
+  schemas: recordType(stringType(), stringType()),
+  _meta: objectType({
+    schemas: recordType(stringType(), stringType()),
+    tables: recordType(stringType(), stringType()),
+    columns: recordType(stringType(), stringType())
+  }),
+  internal: kitInternals
+}).strict();
+var schemaV3 = schemaInternalV3.merge(schemaHash);
+var schemaV4 = schemaInternalV4.merge(schemaHash);
+var schema = schemaInternal.merge(schemaHash);
+var tableSquashedV4 = objectType({
+  name: stringType(),
+  schema: stringType().optional(),
+  columns: recordType(stringType(), column),
+  indexes: recordType(stringType(), stringType()),
+  foreignKeys: recordType(stringType(), stringType())
+}).strict();
+var tableSquashed = objectType({
+  name: stringType(),
+  schema: stringType().optional(),
+  columns: recordType(stringType(), column),
+  indexes: recordType(stringType(), stringType()),
+  foreignKeys: recordType(stringType(), stringType()),
+  compositePrimaryKeys: recordType(stringType(), stringType()),
+  uniqueConstraints: recordType(stringType(), stringType()).default({})
+}).strict();
+var schemaSquashed = objectType({
+  version: literalType("5"),
+  dialect,
+  tables: recordType(stringType(), tableSquashed),
+  schemas: recordType(stringType(), stringType())
+}).strict();
+var schemaSquashedV4 = objectType({
+  version: literalType("4"),
+  dialect,
+  tables: recordType(stringType(), tableSquashedV4),
+  schemas: recordType(stringType(), stringType())
+}).strict();
+var MySqlSquasher = {
+  squashIdx: (idx) => {
+    index.parse(idx);
+    return `${idx.name};${idx.columns.join(",")};${idx.isUnique};${idx.using ?? ""};${idx.algorithm ?? ""};${idx.lock ?? ""}`;
+  },
+  unsquashIdx: (input) => {
+    const [name, columnsString, isUnique, using, algorithm, lock] = input.split(";");
+    const destructed = {
+      name,
+      columns: columnsString.split(","),
+      isUnique: isUnique === "true",
+      using: using ? using : void 0,
+      algorithm: algorithm ? algorithm : void 0,
+      lock: lock ? lock : void 0
+    };
+    return index.parse(destructed);
+  },
+  squashPK: (pk) => {
+    return `${pk.name};${pk.columns.join(",")}`;
+  },
+  unsquashPK: (pk) => {
+    const splitted = pk.split(";");
+    return { name: splitted[0], columns: splitted[1].split(",") };
+  },
+  squashUnique: (unq) => {
+    return `${unq.name};${unq.columns.join(",")}`;
+  },
+  unsquashUnique: (unq) => {
+    const [name, columns] = unq.split(";");
+    return { name, columns: columns.split(",") };
+  },
+  squashFK: (fk4) => {
+    return `${fk4.name};${fk4.tableFrom};${fk4.columnsFrom.join(",")};${fk4.tableTo};${fk4.columnsTo.join(",")};${fk4.onUpdate ?? ""};${fk4.onDelete ?? ""}`;
+  },
+  unsquashFK: (input) => {
+    const [
+      name,
+      tableFrom,
+      columnsFromStr,
+      tableTo,
+      columnsToStr,
+      onUpdate,
+      onDelete
+    ] = input.split(";");
+    const result = fk.parse({
+      name,
+      tableFrom,
+      columnsFrom: columnsFromStr.split(","),
+      tableTo,
+      columnsTo: columnsToStr.split(","),
+      onUpdate,
+      onDelete
+    });
+    return result;
+  }
+};
+var mysqlSchema = schema;
+var backwardCompatibleMysqlSchema = unionType([
+  schemaV3,
+  schemaV4,
+  schema
+]);
+var dryMySql = mysqlSchema.parse({
+  version: snapshotVersion,
+  dialect: "mysql",
+  id: originUUID,
+  prevId: "",
+  tables: {},
+  schemas: {},
+  _meta: {
+    schemas: {},
+    tables: {},
+    columns: {}
+  }
+});
+
+// src/serializer/pgSchema.ts
+init_lib();
+var indexV2 = objectType({
+  name: stringType(),
+  columns: recordType(
+    stringType(),
+    objectType({
+      name: stringType()
+    })
+  ),
+  isUnique: booleanType()
+}).strict();
+var columnV2 = objectType({
+  name: stringType(),
+  type: stringType(),
+  primaryKey: booleanType(),
+  notNull: booleanType(),
+  default: anyType().optional(),
+  references: stringType().optional()
+}).strict();
+var tableV2 = objectType({
+  name: stringType(),
+  columns: recordType(stringType(), columnV2),
+  indexes: recordType(stringType(), indexV2)
+}).strict();
+var enumSchema = objectType({
+  name: stringType(),
+  values: recordType(stringType(), stringType())
+}).strict();
+var pgSchemaV2 = objectType({
+  version: literalType("2"),
+  tables: recordType(stringType(), tableV2),
+  enums: recordType(stringType(), enumSchema)
+}).strict();
+var references = objectType({
+  foreignKeyName: stringType(),
+  table: stringType(),
+  column: stringType(),
+  onDelete: stringType().optional(),
+  onUpdate: stringType().optional()
+}).strict();
+var columnV1 = objectType({
+  name: stringType(),
+  type: stringType(),
+  primaryKey: booleanType(),
+  notNull: booleanType(),
+  default: anyType().optional(),
+  references: references.optional()
+}).strict();
+var tableV1 = objectType({
+  name: stringType(),
+  columns: recordType(stringType(), columnV1),
+  indexes: recordType(stringType(), indexV2)
+}).strict();
+var pgSchemaV1 = objectType({
+  version: literalType("1"),
+  tables: recordType(stringType(), tableV1),
+  enums: recordType(stringType(), enumSchema)
+}).strict();
+var index2 = objectType({
+  name: stringType(),
+  columns: stringType().array(),
+  isUnique: booleanType()
+}).strict();
+var fk2 = objectType({
+  name: stringType(),
+  tableFrom: stringType(),
+  columnsFrom: stringType().array(),
+  tableTo: stringType(),
+  schemaTo: stringType().optional(),
+  columnsTo: stringType().array(),
+  onUpdate: stringType().optional(),
+  onDelete: stringType().optional()
+}).strict();
+var column2 = objectType({
+  name: stringType(),
+  type: stringType(),
+  primaryKey: booleanType(),
+  notNull: booleanType(),
+  default: anyType().optional(),
+  isUnique: anyType().optional(),
+  uniqueName: stringType().optional(),
+  nullsNotDistinct: booleanType().optional()
+}).strict();
+var tableV32 = objectType({
+  name: stringType(),
+  columns: recordType(stringType(), column2),
+  indexes: recordType(stringType(), index2),
+  foreignKeys: recordType(stringType(), fk2)
+}).strict();
+var compositePK2 = objectType({
+  name: stringType(),
+  columns: stringType().array()
+}).strict();
+var uniqueConstraint2 = objectType({
+  name: stringType(),
+  columns: stringType().array(),
+  nullsNotDistinct: booleanType()
+}).strict();
+var tableV42 = objectType({
+  name: stringType(),
+  schema: stringType(),
+  columns: recordType(stringType(), column2),
+  indexes: recordType(stringType(), index2),
+  foreignKeys: recordType(stringType(), fk2)
+}).strict();
+var table2 = objectType({
+  name: stringType(),
+  schema: stringType(),
+  columns: recordType(stringType(), column2),
+  indexes: recordType(stringType(), index2),
+  foreignKeys: recordType(stringType(), fk2),
+  compositePrimaryKeys: recordType(stringType(), compositePK2),
+  uniqueConstraints: recordType(stringType(), uniqueConstraint2).default({})
+}).strict();
+var schemaHash2 = objectType({
+  id: stringType(),
+  prevId: stringType()
+});
+var pgSchemaInternalV3 = objectType({
+  version: literalType("3"),
+  dialect: literalType("pg"),
+  tables: recordType(stringType(), tableV32),
+  enums: recordType(stringType(), enumSchema)
+}).strict();
+var pgSchemaInternalV4 = objectType({
+  version: literalType("4"),
+  dialect: literalType("pg"),
+  tables: recordType(stringType(), tableV42),
+  enums: recordType(stringType(), enumSchema),
+  schemas: recordType(stringType(), stringType())
+}).strict();
+var pgSchemaExternal = objectType({
+  version: literalType("5"),
+  dialect: literalType("pg"),
+  tables: arrayType(table2),
+  enums: arrayType(enumSchema),
+  schemas: arrayType(objectType({ name: stringType() })),
+  _meta: objectType({
+    schemas: recordType(stringType(), stringType()),
+    tables: recordType(stringType(), stringType()),
+    columns: recordType(stringType(), stringType())
+  })
+}).strict();
+var kitInternals2 = objectType({
+  tables: recordType(
+    stringType(),
+    objectType({
+      columns: recordType(
+        stringType(),
+        objectType({
+          isArray: booleanType().optional(),
+          dimensions: numberType().optional(),
+          rawType: stringType().optional()
+        }).optional()
+      )
+    }).optional()
+  )
+}).optional();
+var pgSchemaInternal = objectType({
+  version: literalType("5"),
+  dialect: literalType("pg"),
+  tables: recordType(stringType(), table2),
+  enums: recordType(stringType(), enumSchema),
+  schemas: recordType(stringType(), stringType()),
+  _meta: objectType({
+    schemas: recordType(stringType(), stringType()),
+    tables: recordType(stringType(), stringType()),
+    columns: recordType(stringType(), stringType())
+  }),
+  internal: kitInternals2
+}).strict();
+var tableSquashed2 = objectType({
+  name: stringType(),
+  schema: stringType(),
+  columns: recordType(stringType(), column2),
+  indexes: recordType(stringType(), stringType()),
+  foreignKeys: recordType(stringType(), stringType()),
+  compositePrimaryKeys: recordType(stringType(), stringType()),
+  uniqueConstraints: recordType(stringType(), stringType())
+}).strict();
+var tableSquashedV42 = objectType({
+  name: stringType(),
+  schema: stringType(),
+  columns: recordType(stringType(), column2),
+  indexes: recordType(stringType(), stringType()),
+  foreignKeys: recordType(stringType(), stringType())
+}).strict();
+var pgSchemaSquashedV4 = objectType({
+  version: literalType("4"),
+  dialect: enumType(["pg"]),
+  tables: recordType(stringType(), tableSquashedV42),
+  enums: recordType(stringType(), enumSchema),
+  schemas: recordType(stringType(), stringType())
+}).strict();
+var pgSchemaSquashed = objectType({
+  version: literalType("5"),
+  dialect: enumType(["pg"]),
+  tables: recordType(stringType(), tableSquashed2),
+  enums: recordType(stringType(), enumSchema),
+  schemas: recordType(stringType(), stringType())
+}).strict();
+var pgSchemaV3 = pgSchemaInternalV3.merge(schemaHash2);
+var pgSchemaV4 = pgSchemaInternalV4.merge(schemaHash2);
+var pgSchema = pgSchemaInternal.merge(schemaHash2);
+var backwardCompatiblePgSchema = unionType([
+  pgSchemaV1,
+  pgSchemaV2,
+  pgSchemaV3,
+  pgSchemaV4,
+  pgSchema
+]);
+var PgSquasher = {
+  squashIdx: (idx) => {
+    index2.parse(idx);
+    return `${idx.name};${idx.columns.join(",")};${idx.isUnique}`;
+  },
+  unsquashIdx: (input) => {
+    const [name, columnsString, isUnique] = input.split(";");
+    const result = index2.parse({
+      name,
+      columns: columnsString.split(","),
+      isUnique: isUnique === "true"
+    });
+    return result;
+  },
+  squashFK: (fk4) => {
+    return `${fk4.name};${fk4.tableFrom};${fk4.columnsFrom.join(",")};${fk4.tableTo};${fk4.columnsTo.join(",")};${fk4.onUpdate ?? ""};${fk4.onDelete ?? ""};${fk4.schemaTo ?? ""}`;
+  },
+  squashPK: (pk) => {
+    return `${pk.columns.join(",")};${pk.name}`;
+  },
+  unsquashPK: (pk) => {
+    const splitted = pk.split(";");
+    return { name: splitted[1], columns: splitted[0].split(",") };
+  },
+  squashUnique: (unq) => {
+    return `${unq.name};${unq.columns.join(",")};${unq.nullsNotDistinct}`;
+  },
+  unsquashUnique: (unq) => {
+    const [name, columns, nullsNotDistinct] = unq.split(";");
+    return {
+      name,
+      columns: columns.split(","),
+      nullsNotDistinct: nullsNotDistinct === "true"
+    };
+  },
+  unsquashFK: (input) => {
+    const [
+      name,
+      tableFrom,
+      columnsFromStr,
+      tableTo,
+      columnsToStr,
+      onUpdate,
+      onDelete,
+      schemaTo
+    ] = input.split(";");
+    const result = fk2.parse({
+      name,
+      tableFrom,
+      columnsFrom: columnsFromStr.split(","),
+      schemaTo,
+      tableTo,
+      columnsTo: columnsToStr.split(","),
+      onUpdate,
+      onDelete
+    });
+    return result;
+  }
+};
+var squashPgScheme = (json) => {
+  const mappedTables = Object.fromEntries(
+    Object.entries(json.tables).map((it) => {
+      const squashedIndexes = mapValues(it[1].indexes, (index4) => {
+        return PgSquasher.squashIdx(index4);
+      });
+      const squashedFKs = mapValues(it[1].foreignKeys, (fk4) => {
+        return PgSquasher.squashFK(fk4);
+      });
+      const squashedPKs = mapValues(it[1].compositePrimaryKeys, (pk) => {
+        return PgSquasher.squashPK(pk);
+      });
+      const squashedUniqueConstraints = mapValues(
+        it[1].uniqueConstraints,
+        (unq) => {
+          return PgSquasher.squashUnique(unq);
+        }
+      );
+      return [
+        it[0],
+        {
+          name: it[1].name,
+          schema: it[1].schema,
+          columns: it[1].columns,
+          indexes: squashedIndexes,
+          foreignKeys: squashedFKs,
+          compositePrimaryKeys: squashedPKs,
+          uniqueConstraints: squashedUniqueConstraints
+        }
+      ];
+    })
+  );
+  return {
+    version: "5",
+    dialect: json.dialect,
+    tables: mappedTables,
+    enums: json.enums,
+    schemas: json.schemas
+  };
+};
+var dryPg = pgSchema.parse({
+  version: snapshotVersion,
+  dialect: "pg",
+  id: originUUID,
+  prevId: "",
+  tables: {},
+  enums: {},
+  schemas: {},
+  _meta: {
+    schemas: {},
+    tables: {},
+    columns: {}
+  }
+});
+
+// src/serializer/sqliteSchema.ts
+init_lib();
+var index3 = objectType({
+  name: stringType(),
+  columns: stringType().array(),
+  where: stringType().optional(),
+  isUnique: booleanType()
+}).strict();
+var fk3 = objectType({
+  name: stringType(),
+  tableFrom: stringType(),
+  columnsFrom: stringType().array(),
+  tableTo: stringType(),
+  columnsTo: stringType().array(),
+  onUpdate: stringType().optional(),
+  onDelete: stringType().optional()
+}).strict();
+var compositePK3 = objectType({
+  columns: stringType().array(),
+  name: stringType().optional()
+}).strict();
+var column3 = objectType({
+  name: stringType(),
+  type: stringType(),
+  primaryKey: booleanType(),
+  notNull: booleanType(),
+  autoincrement: booleanType().optional(),
+  default: anyType().optional()
+}).strict();
+var tableV33 = objectType({
+  name: stringType(),
+  columns: recordType(stringType(), column3),
+  indexes: recordType(stringType(), index3),
+  foreignKeys: recordType(stringType(), fk3)
+}).strict();
+var uniqueConstraint3 = objectType({
+  name: stringType(),
+  columns: stringType().array()
+}).strict();
+var table3 = objectType({
+  name: stringType(),
+  columns: recordType(stringType(), column3),
+  indexes: recordType(stringType(), index3),
+  foreignKeys: recordType(stringType(), fk3),
+  compositePrimaryKeys: recordType(stringType(), compositePK3),
+  uniqueConstraints: recordType(stringType(), uniqueConstraint3).default({})
+}).strict();
+var dialect2 = enumType(["sqlite"]);
+var schemaHash3 = objectType({
+  id: stringType(),
+  prevId: stringType()
+}).strict();
+var schemaInternalV32 = objectType({
+  version: literalType("3"),
+  dialect: dialect2,
+  tables: recordType(stringType(), tableV33),
+  enums: objectType({})
+}).strict();
+var schemaInternalV42 = objectType({
+  version: literalType("4"),
+  dialect: dialect2,
+  tables: recordType(stringType(), table3),
+  enums: objectType({})
+}).strict();
+var latestVersion = literalType("5");
+var schemaInternal2 = objectType({
+  version: latestVersion,
+  dialect: dialect2,
+  tables: recordType(stringType(), table3),
+  enums: objectType({}),
+  _meta: objectType({
+    tables: recordType(stringType(), stringType()),
+    columns: recordType(stringType(), stringType())
+  })
+}).strict();
+var schemaV32 = schemaInternalV32.merge(schemaHash3).strict();
+var schemaV42 = schemaInternalV42.merge(schemaHash3).strict();
+var schema2 = schemaInternal2.merge(schemaHash3).strict();
+var tableSquashed3 = objectType({
+  name: stringType(),
+  columns: recordType(stringType(), column3),
+  indexes: recordType(stringType(), stringType()),
+  foreignKeys: recordType(stringType(), stringType()),
+  compositePrimaryKeys: recordType(stringType(), stringType()),
+  uniqueConstraints: recordType(stringType(), stringType()).default({})
+}).strict();
+var schemaSquashed2 = objectType({
+  version: latestVersion,
+  dialect: dialect2,
+  tables: recordType(stringType(), tableSquashed3),
+  enums: anyType()
+}).strict();
+var SQLiteSquasher = {
+  squashIdx: (idx) => {
+    index3.parse(idx);
+    return `${idx.name};${idx.columns.join(",")};${idx.isUnique};${idx.where ?? ""}`;
+  },
+  unsquashIdx: (input) => {
+    const [name, columnsString, isUnique, where] = input.split(";");
+    const result = index3.parse({
+      name,
+      columns: columnsString.split(","),
+      isUnique: isUnique === "true",
+      where: where ?? void 0
+    });
+    return result;
+  },
+  squashUnique: (unq) => {
+    return `${unq.name};${unq.columns.join(",")}`;
+  },
+  unsquashUnique: (unq) => {
+    const [name, columns] = unq.split(";");
+    return { name, columns: columns.split(",") };
+  },
+  squashFK: (fk4) => {
+    return `${fk4.name};${fk4.tableFrom};${fk4.columnsFrom.join(",")};${fk4.tableTo};${fk4.columnsTo.join(",")};${fk4.onUpdate ?? ""};${fk4.onDelete ?? ""}`;
+  },
+  unsquashFK: (input) => {
+    const [
+      name,
+      tableFrom,
+      columnsFromStr,
+      tableTo,
+      columnsToStr,
+      onUpdate,
+      onDelete
+    ] = input.split(";");
+    const result = fk3.parse({
+      name,
+      tableFrom,
+      columnsFrom: columnsFromStr.split(","),
+      tableTo,
+      columnsTo: columnsToStr.split(","),
+      onUpdate,
+      onDelete
+    });
+    return result;
+  },
+  squashPK: (pk) => {
+    return pk.columns.join(",");
+  },
+  unsquashPK: (pk) => {
+    return pk.split(",");
+  }
+};
+var drySQLite = schema2.parse({
+  version: snapshotVersion,
+  dialect: "sqlite",
+  id: originUUID,
+  prevId: "",
+  tables: {},
+  enums: {},
+  _meta: {
+    tables: {},
+    columns: {}
+  }
+});
+var backwardCompatibleSqliteSchema = unionType([schemaV32, schemaV42, schema2]);
+
+// src/utils.ts
+init_source();
 import { join } from "path";
 
 // src/jsonDiffer.js
@@ -5262,30 +5197,17 @@ var alternationsInColumn = (column4) => {
   return result[0];
 };
 
-// src/cli/commands/upFolders.ts
-init_mysqlSchema();
-init_sqliteSchema();
-
 // src/migrationPreparator.ts
 init_serializer();
-init_pgSchema();
-init_sqliteSchema();
-init_mysqlSchema();
 
 // src/cli/commands/migrate.ts
 var import_hanji2 = __toESM(require_hanji());
 init_views();
 init_source();
-init_pgSchema();
-init_sqliteSchema();
-init_mysqlSchema();
 init_outputs();
 var BREAKPOINT = "--> statement-breakpoint\n";
 
 // src/sqlgenerator.ts
-init_mysqlSchema();
-init_pgSchema();
-init_sqliteSchema();
 var pgNativeTypes = /* @__PURE__ */ new Set([
   "uuid",
   "smallint",
@@ -6597,20 +6519,17 @@ drop type __venum;
 init_lib();
 
 // src/jsonStatements.ts
-init_mysqlSchema();
-init_pgSchema();
-init_sqliteSchema();
 var preparePgCreateTableJson = (table4, json2) => {
   const { name, schema: schema4, columns, compositePrimaryKeys, uniqueConstraints } = table4;
-  const tableKey = `${schema4 || "public"}.${name}`;
-  const compositePkName = Object.values(compositePrimaryKeys).length > 0 ? json2.tables[tableKey].compositePrimaryKeys[`${PgSquasher.unsquashPK(Object.values(compositePrimaryKeys)[0]).name}`].name : "";
   return {
     type: "create_table",
     tableName: name,
     schema: schema4,
     columns: Object.values(columns),
     compositePKs: Object.values(compositePrimaryKeys),
-    compositePkName,
+    compositePkName: Object.values(compositePrimaryKeys).length > 0 ? json2.tables[name].compositePrimaryKeys[`${PgSquasher.unsquashPK(
+      Object.values(compositePrimaryKeys)[0]
+    ).name}`].name : "",
     uniqueConstraints: Object.values(uniqueConstraints)
   };
 };
@@ -6712,8 +6631,7 @@ var prepareRenameColumns = (tableName, schema4, pairs) => {
 var prepareAlterTableColumnsJson = (tableName, schema4, deleted, added, altered, addedFk, json2, dialect3) => {
   const addColumns = [];
   const dropColumns = _prepareDropColumns(tableName, schema4, deleted);
-  const tableKey = `${schema4 || "public"}.${tableName}`;
-  const alterColumns = _prepareAlterColumns(tableKey, schema4, altered, json2);
+  const alterColumns = _prepareAlterColumns(tableName, schema4, altered, json2);
   if (dialect3 === "sqlite") {
     let jsonCreateFKStatements = Object.values(addedFk);
     const sqliteAddColumns = _prepareSQLiteAddColumns(
@@ -6763,22 +6681,19 @@ var _prepareSQLiteAddColumns = (tableName, columns, referenceData) => {
     };
   });
 };
-var _prepareAlterColumns = (tableKey, schema4, columns, json2) => {
+var _prepareAlterColumns = (tableName, schema4, columns, json2) => {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
   let statements = [];
   let dropPkStatements = [];
   let setPkStatements = [];
   for (const column4 of columns) {
     const columnName = typeof column4.name !== "string" ? column4.name.new : column4.name;
-    const table4 = json2.tables[tableKey];
-    const tableName = table4.name;
-    const snapshotColumn = table4.columns[columnName];
-    const columnType = snapshotColumn.type;
-    const columnDefault = snapshotColumn.default;
-    const columnOnUpdate = "onUpdate" in snapshotColumn ? snapshotColumn.onUpdate : void 0;
-    const columnNotNull = table4.columns[columnName].notNull;
-    const columnAutoIncrement = "autoincrement" in snapshotColumn ? snapshotColumn.autoincrement ?? false : false;
-    const columnPk = table4.columns[columnName].primaryKey;
+    const columnType = json2.tables[tableName].columns[columnName].type;
+    const columnDefault = json2.tables[tableName].columns[columnName].default;
+    const columnOnUpdate = json2.tables[tableName].columns[columnName].onUpdate;
+    const columnNotNull = json2.tables[tableName].columns[columnName].notNull;
+    const columnAutoIncrement = json2.tables[tableName].columns[columnName].autoincrement;
+    const columnPk = json2.tables[tableName].columns[columnName].primaryKey;
     if (((_a = column4.autoincrement) == null ? void 0 : _a.type) === "added") {
       statements.push({
         type: "alter_table_alter_column_set_autoincrement",
@@ -6825,14 +6740,13 @@ var _prepareAlterColumns = (tableKey, schema4, columns, json2) => {
   }
   for (const column4 of columns) {
     const columnName = typeof column4.name !== "string" ? column4.name.new : column4.name;
-    const tableName = json2.tables[tableKey].name;
-    const columnType = json2.tables[tableKey].columns[columnName].type;
-    const columnDefault = json2.tables[tableKey].columns[columnName].default;
-    const columnOnUpdate = json2.tables[tableKey].columns[columnName].onUpdate;
-    const columnNotNull = json2.tables[tableKey].columns[columnName].notNull;
-    const columnAutoIncrement = json2.tables[tableKey].columns[columnName].autoincrement;
-    const columnPk = json2.tables[tableKey].columns[columnName].primaryKey;
-    const compositePk = json2.tables[tableKey].compositePrimaryKeys[`${tableName}_${columnName}`];
+    const columnType = json2.tables[tableName].columns[columnName].type;
+    const columnDefault = json2.tables[tableName].columns[columnName].default;
+    const columnOnUpdate = json2.tables[tableName].columns[columnName].onUpdate;
+    const columnNotNull = json2.tables[tableName].columns[columnName].notNull;
+    const columnAutoIncrement = json2.tables[tableName].columns[columnName].autoincrement;
+    const columnPk = json2.tables[tableName].columns[columnName].primaryKey;
+    const compositePk = json2.tables[tableName].compositePrimaryKeys[`${tableName}_${columnName}`];
     if (typeof column4.name !== "string") {
       statements.push({
         type: "alter_table_rename_column",
@@ -7178,9 +7092,6 @@ var prepareAlterCompositePrimaryKeyMySql = (tableName, pks, json1, json2) => {
 };
 
 // src/snapshotsDiffer.ts
-init_sqliteSchema();
-init_mysqlSchema();
-init_global();
 var makeChanged = (schema4) => {
   return objectType({
     type: enumType(["changed"]),
@@ -7219,7 +7130,7 @@ var makeSelfOrPatched = (schema4) => {
   return unionType([
     objectType({
       type: literalType("none"),
-      value: schema4
+      value: schema4.optional()
     }),
     objectType({
       type: literalType("added"),
@@ -7343,6 +7254,7 @@ var diffResultScheme = objectType({
 }).strict();
 var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesResolver, columnsResolver, prevFull, curFull) => {
   var _a, _b;
+  let diffResult;
   if (dialect3 === "mysql") {
     for (const tableName in json1.tables) {
       const table4 = json1.tables[tableName];
@@ -7370,26 +7282,13 @@ var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesR
         }
       }
     }
+    diffResult = applyJsonDiff(json1, json2);
   }
-  const diffResult = applyJsonDiff(json1, json2);
+  diffResult = applyJsonDiff(json1, json2);
   if (Object.keys(diffResult).length === 0) {
     return { statements: [], sqlStatements: [], _meta: void 0 };
   }
   const typedResult = diffResultScheme.parse(diffResult);
-  typedResult.alteredTablesWithColumns = typedResult.alteredTablesWithColumns.map((it) => {
-    let schemaToTrim;
-    if (it.schema.type === "none") {
-      schemaToTrim = it.schema.value || "public";
-    } else if (it.schema.type === "deleted") {
-      schemaToTrim = it.schema.value;
-    } else if (it.schema.type === "added") {
-      schemaToTrim = "public";
-    } else {
-      schemaToTrim = it.schema.old;
-    }
-    it.name = it.name.substring(schemaToTrim.length + 1);
-    return it;
-  });
   const {
     created: createdSchemas,
     deleted: deletedSchemas,
@@ -7541,7 +7440,7 @@ var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesR
         prevFull,
         curFull
       );
-    } else if (dialect3 === "mysql") {
+    } else {
       addedCompositePKs = prepareAddCompositePrimaryKeyMySql(
         it.name,
         it.addedCompositePKs,
@@ -7559,8 +7458,6 @@ var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesR
         prevFull,
         curFull
       );
-    } else {
-      assertUnreachable(dialect3);
     }
     let addedUniqueConstraints = [];
     let deletedUniqueConstraints = [];
@@ -7751,13 +7648,11 @@ var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesR
       return preparePgCreateTableJson(it, curFull);
     });
     jsonStatements.push(...jsonPgCreateTables);
-  } else if (dialect3 === "mysql") {
+  } else {
     const jsonMySqlCreateTables = created.map((it) => {
       return prepareMySqlCreateTableJson(it, curFull);
     });
     jsonStatements.push(...jsonMySqlCreateTables);
-  } else {
-    assertUnreachable(dialect3);
   }
   jsonStatements.push(...jsonDropTables);
   jsonStatements.push(...jsonRenameTables);
@@ -7807,15 +7702,9 @@ var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesR
 
 // src/cli/commands/pgUp.ts
 init_source();
-init_global();
-init_pgSchema();
-
-// src/cli/commands/upFolders.ts
-init_pgSchema();
 
 // src/cli/commands/mysqlUp.ts
 init_source();
-init_mysqlSchema();
 
 // src/cli/commands/upFolders.ts
 var resolveSchemas = (missingSchemas, newSchemas, predicate) => {
@@ -7916,7 +7805,7 @@ var resolveColumns = (missingColumns, newColumns, predicate) => {
 };
 
 // src/utils.ts
-var assertV1OutFolder = (out) => {
+var assertV1OutFolder = (out, dialect3) => {
   if (!existsSync(out))
     return;
   const oldMigrationFolders = readdirSync(out).filter(
@@ -7925,7 +7814,7 @@ var assertV1OutFolder = (out) => {
   if (oldMigrationFolders.length > 0) {
     console.log(
       `Your migrations folder format is outdated, please run ${source_default.green.bold(
-        `drizzle-kit up`
+        `drizzle-kit up:${dialect3}`
       )}`
     );
     process.exit(1);
@@ -7949,7 +7838,7 @@ var snapshotsPriorV4 = (out) => {
     return pathJson;
   });
 };
-var prepareOutFolder = (out, dialect3) => {
+var prepareOutFolder2 = (out, dialect3) => {
   const meta = join(out, "meta");
   const journalPath = join(meta, "_journal.json");
   if (!existsSync(join(out, "meta"))) {
@@ -7964,9 +7853,9 @@ var prepareOutFolder = (out, dialect3) => {
 var validatorForDialect = (dialect3) => {
   switch (dialect3) {
     case "pg":
-      return { validator: backwardCompatiblePgSchema, version: 6 };
+      return { validator: backwardCompatiblePgSchema, version: 5 };
     case "sqlite":
-      return { validator: backwardCompatibleSqliteSchema, version: 6 };
+      return { validator: backwardCompatibleSqliteSchema, version: 5 };
     case "mysql":
       return { validator: backwardCompatibleMysqlSchema, version: 5 };
   }
@@ -8014,13 +7903,13 @@ var validateWithReport = (snapshots, dialect3) => {
   return result;
 };
 var prepareMigrationFolder = (outFolder = "drizzle", dialect3) => {
-  const { snapshots, journal } = prepareOutFolder(outFolder, dialect3);
+  const { snapshots, journal } = prepareOutFolder2(outFolder, dialect3);
   const report = validateWithReport(snapshots, dialect3);
   if (report.nonLatest.length > 0) {
     console.log(
       report.nonLatest.map((it) => {
         return `${it}/snapshot.json is not of the latest version`;
-      }).concat(`Run ${source_default.green.bold(`drizzle-kit up`)}`).join("\n")
+      }).concat(`Run ${source_default.green.bold(`drizzle-kit up:${dialect3}`)}`).join("\n")
     );
     process.exit(0);
   }
@@ -8153,9 +8042,7 @@ var statementsForDiffs = async (in1, in2) => {
     "pg",
     schemasResolver,
     tablesResolver,
-    columnsResolver,
-    left,
-    right
+    columnsResolver
   );
   return { ...result, left, right };
 };
@@ -8166,7 +8053,7 @@ export {
   kloudMeta,
   prepareMigrationFolder,
   prepareMigrationMeta,
-  prepareOutFolder,
+  prepareOutFolder2 as prepareOutFolder,
   schemaRenameKey,
   snapshotsPriorV4,
   statementsForDiffs,