drizzle-kit 0.20.14-6ce9d1f → 0.20.14-a183d8b

package/utils.js

@@ -4241,6 +4241,717 @@ var init_lib = __esm({
   }
 });
 
+// src/serializer/mysqlSchema.ts
+var index, fk, column, tableV3, compositePK, uniqueConstraint, tableV4, table, dialect, schemaHash, schemaInternalV3, schemaInternalV4, kitInternals, schemaInternal, schemaV3, schemaV4, schema, tableSquashedV4, tableSquashed, schemaSquashed, schemaSquashedV4, MySqlSquasher, mysqlSchema, backwardCompatibleMysqlSchema, dryMySql;
+var init_mysqlSchema = __esm({
+  "src/serializer/mysqlSchema.ts"() {
+    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();
+    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();
+    kitInternals = objectType({
+      tables: recordType(
+        stringType(),
+        objectType({
+          columns: recordType(
+            stringType(),
+            objectType({ isDefaultAnExpression: booleanType().optional() }).optional()
+          )
+        }).optional()
+      )
+    }).optional();
+    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();
+    schemaV3 = schemaInternalV3.merge(schemaHash);
+    schemaV4 = schemaInternalV4.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;
+    backwardCompatibleMysqlSchema = unionType([
+      schemaV3,
+      schemaV4,
+      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, pgSchemaInternalV3, pgSchemaInternalV4, pgSchemaExternal, kitInternals2, pgSchemaInternal, tableSquashed2, tableSquashedV42, pgSchemaSquashedV4, pgSchemaSquashed, pgSchemaV3, pgSchemaV4, pgSchema, backwardCompatiblePgSchema, PgSquasher, squashPgScheme, dryPg;
+var init_pgSchema = __esm({
+  "src/serializer/pgSchema.ts"() {
+    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()
+    });
+    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();
+    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();
+    kitInternals2 = objectType({
+      tables: recordType(
+        stringType(),
+        objectType({
+          columns: recordType(
+            stringType(),
+            objectType({
+              isArray: booleanType().optional(),
+              dimensions: numberType().optional(),
+              rawType: stringType().optional()
+            }).optional()
+          )
+        }).optional()
+      )
+    }).optional();
+    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();
+    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("5"),
+      dialect: enumType(["pg"]),
+      tables: recordType(stringType(), tableSquashed2),
+      enums: recordType(stringType(), enumSchema),
+      schemas: recordType(stringType(), stringType())
+    }).strict();
+    pgSchemaV3 = pgSchemaInternalV3.merge(schemaHash2);
+    pgSchemaV4 = pgSchemaInternalV4.merge(schemaHash2);
+    pgSchema = pgSchemaInternal.merge(schemaHash2);
+    backwardCompatiblePgSchema = unionType([
+      pgSchemaV1,
+      pgSchemaV2,
+      pgSchemaV3,
+      pgSchemaV4,
+      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 ?? ""}`;
+      },
+      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: "5",
+        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"() {
+    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: snapshotVersion,
+      dialect: "sqlite",
+      id: originUUID,
+      prevId: "",
+      tables: {},
+      enums: {},
+      _meta: {
+        tables: {},
+        columns: {}
+      }
+    });
+    backwardCompatibleSqliteSchema = unionType([
+      schemaV32,
+      schemaV42,
+      schema2
+    ]);
+  }
+});
+
 // src/serializer/index.ts
 var glob;
 var init_serializer = __esm({
@@ -4277,704 +4988,9 @@ __export(utils_exports, {
 module.exports = __toCommonJS(utils_exports);
 var import_fs = require("fs");
 init_views();
-
-// src/serializer/mysqlSchema.ts
-init_global();
-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_global();
-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_global();
-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_mysqlSchema();
+init_pgSchema();
+init_sqliteSchema();
 init_source();
 var import_path = require("path");
 init_global();
@@ -5219,17 +5235,30 @@ 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",
@@ -6541,6 +6570,9 @@ 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;
   return {
@@ -7114,6 +7146,8 @@ var prepareAlterCompositePrimaryKeyMySql = (tableName, pks, json1, json2) => {
 };
 
 // src/snapshotsDiffer.ts
+init_sqliteSchema();
+init_mysqlSchema();
 var makeChanged = (schema4) => {
   return objectType({
     type: enumType(["changed"]),
@@ -7725,9 +7759,14 @@ 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) => {