drizzle-kit 0.20.14-a77266f → 0.20.14-c82ab68

package/utils.mjs

@@ -1080,6 +1080,7 @@ 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 = "") => {
@@ -1088,6 +1089,26 @@ 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;
@@ -4227,734 +4248,778 @@ var init_lib = __esm({
   }
 });
 
-// src/serializer/index.ts
-import * as glob from "glob";
-var init_serializer = __esm({
-  "src/serializer/index.ts"() {
-    init_source();
-    init_views();
-  }
-});
-
-// src/cli/validations/outputs.ts
-var init_outputs = __esm({
-  "src/cli/validations/outputs.ts"() {
-    init_source();
-  }
-});
-
-// src/utils.ts
-init_views();
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  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(
+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({ isDefaultAnExpression: booleanType().optional() }).optional()
+        objectType({
+          columns: recordType(
+            stringType(),
+            objectType({ isDefaultAnExpression: booleanType().optional() }).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
+    }).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: {}
+      }
     });
-    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({
+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({
-          isArray: booleanType().optional(),
-          dimensions: numberType().optional(),
-          rawType: stringType().optional()
+          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()
-  )
-}).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"
+    }).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;
+      }
     };
-  },
-  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);
-        }
+    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 [
-        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: {}
+      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
-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
+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: {}
+      }
     });
-    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: {}
+    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();
+  }
+});
+
+// src/cli/validations/outputs.ts
+var init_outputs = __esm({
+  "src/cli/validations/outputs.ts"() {
+    "use strict";
+    init_source();
   }
 });
-var backwardCompatibleSqliteSchema = unionType([schemaV32, schemaV42, schema2]);
 
 // src/utils.ts
+init_views();
+init_mysqlSchema();
+init_pgSchema();
+init_sqliteSchema();
 init_source();
+init_global();
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync
+} from "fs";
 import { join } from "path";
 
 // src/jsonDiffer.js
@@ -5197,17 +5262,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",
@@ -6519,17 +6597,20 @@ 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: Object.values(compositePrimaryKeys).length > 0 ? json2.tables[name].compositePrimaryKeys[`${PgSquasher.unsquashPK(
-      Object.values(compositePrimaryKeys)[0]
-    ).name}`].name : "",
+    compositePkName,
     uniqueConstraints: Object.values(uniqueConstraints)
   };
 };
@@ -6631,7 +6712,8 @@ var prepareRenameColumns = (tableName, schema4, pairs) => {
 var prepareAlterTableColumnsJson = (tableName, schema4, deleted, added, altered, addedFk, json2, dialect3) => {
   const addColumns = [];
   const dropColumns = _prepareDropColumns(tableName, schema4, deleted);
-  const alterColumns = _prepareAlterColumns(tableName, schema4, altered, json2);
+  const tableKey = `${schema4 || "public"}.${tableName}`;
+  const alterColumns = _prepareAlterColumns(tableKey, schema4, altered, json2);
   if (dialect3 === "sqlite") {
     let jsonCreateFKStatements = Object.values(addedFk);
     const sqliteAddColumns = _prepareSQLiteAddColumns(
@@ -6681,19 +6763,22 @@ var _prepareSQLiteAddColumns = (tableName, columns, referenceData) => {
     };
   });
 };
-var _prepareAlterColumns = (tableName, schema4, columns, json2) => {
+var _prepareAlterColumns = (tableKey, 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 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 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;
     if (((_a = column4.autoincrement) == null ? void 0 : _a.type) === "added") {
       statements.push({
         type: "alter_table_alter_column_set_autoincrement",
@@ -6740,13 +6825,14 @@ var _prepareAlterColumns = (tableName, schema4, columns, json2) => {
   }
   for (const column4 of columns) {
     const columnName = typeof column4.name !== "string" ? column4.name.new : column4.name;
-    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}`];
+    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}`];
     if (typeof column4.name !== "string") {
       statements.push({
         type: "alter_table_rename_column",
@@ -7092,6 +7178,9 @@ var prepareAlterCompositePrimaryKeyMySql = (tableName, pks, json1, json2) => {
 };
 
 // src/snapshotsDiffer.ts
+init_sqliteSchema();
+init_mysqlSchema();
+init_global();
 var makeChanged = (schema4) => {
   return objectType({
     type: enumType(["changed"]),
@@ -7130,7 +7219,7 @@ var makeSelfOrPatched = (schema4) => {
   return unionType([
     objectType({
       type: literalType("none"),
-      value: schema4.optional()
+      value: schema4
     }),
     objectType({
       type: literalType("added"),
@@ -7254,7 +7343,6 @@ 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];
@@ -7282,13 +7370,26 @@ var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesR
         }
       }
     }
-    diffResult = applyJsonDiff(json1, json2);
   }
-  diffResult = applyJsonDiff(json1, json2);
+  const 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,
@@ -7440,7 +7541,7 @@ var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesR
         prevFull,
         curFull
       );
-    } else {
+    } else if (dialect3 === "mysql") {
       addedCompositePKs = prepareAddCompositePrimaryKeyMySql(
         it.name,
         it.addedCompositePKs,
@@ -7458,6 +7559,8 @@ var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesR
         prevFull,
         curFull
       );
+    } else {
+      assertUnreachable(dialect3);
     }
     let addedUniqueConstraints = [];
     let deletedUniqueConstraints = [];
@@ -7648,11 +7751,13 @@ var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesR
       return preparePgCreateTableJson(it, curFull);
     });
     jsonStatements.push(...jsonPgCreateTables);
-  } else {
+  } else if (dialect3 === "mysql") {
     const jsonMySqlCreateTables = created.map((it) => {
       return prepareMySqlCreateTableJson(it, curFull);
     });
     jsonStatements.push(...jsonMySqlCreateTables);
+  } else {
+    assertUnreachable(dialect3);
   }
   jsonStatements.push(...jsonDropTables);
   jsonStatements.push(...jsonRenameTables);
@@ -7702,9 +7807,15 @@ 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) => {
@@ -7805,7 +7916,7 @@ var resolveColumns = (missingColumns, newColumns, predicate) => {
 };
 
 // src/utils.ts
-var assertV1OutFolder = (out, dialect3) => {
+var assertV1OutFolder = (out) => {
   if (!existsSync(out))
     return;
   const oldMigrationFolders = readdirSync(out).filter(
@@ -7814,7 +7925,7 @@ var assertV1OutFolder = (out, dialect3) => {
   if (oldMigrationFolders.length > 0) {
     console.log(
       `Your migrations folder format is outdated, please run ${source_default.green.bold(
-        `drizzle-kit up:${dialect3}`
+        `drizzle-kit up`
       )}`
     );
     process.exit(1);
@@ -7838,7 +7949,7 @@ var snapshotsPriorV4 = (out) => {
     return pathJson;
   });
 };
-var prepareOutFolder2 = (out, dialect3) => {
+var prepareOutFolder = (out, dialect3) => {
   const meta = join(out, "meta");
   const journalPath = join(meta, "_journal.json");
   if (!existsSync(join(out, "meta"))) {
@@ -7853,9 +7964,9 @@ var prepareOutFolder2 = (out, dialect3) => {
 var validatorForDialect = (dialect3) => {
   switch (dialect3) {
     case "pg":
-      return { validator: backwardCompatiblePgSchema, version: 5 };
+      return { validator: backwardCompatiblePgSchema, version: 6 };
     case "sqlite":
-      return { validator: backwardCompatibleSqliteSchema, version: 5 };
+      return { validator: backwardCompatibleSqliteSchema, version: 6 };
     case "mysql":
       return { validator: backwardCompatibleMysqlSchema, version: 5 };
   }
@@ -7903,13 +8014,13 @@ var validateWithReport = (snapshots, dialect3) => {
   return result;
 };
 var prepareMigrationFolder = (outFolder = "drizzle", dialect3) => {
-  const { snapshots, journal } = prepareOutFolder2(outFolder, dialect3);
+  const { snapshots, journal } = prepareOutFolder(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:${dialect3}`)}`).join("\n")
+      }).concat(`Run ${source_default.green.bold(`drizzle-kit up`)}`).join("\n")
     );
     process.exit(0);
   }
@@ -8042,7 +8153,9 @@ var statementsForDiffs = async (in1, in2) => {
     "pg",
     schemasResolver,
     tablesResolver,
-    columnsResolver
+    columnsResolver,
+    left,
+    right
   );
   return { ...result, left, right };
 };
@@ -8053,7 +8166,7 @@ export {
   kloudMeta,
   prepareMigrationFolder,
   prepareMigrationMeta,
-  prepareOutFolder2 as prepareOutFolder,
+  prepareOutFolder,
   schemaRenameKey,
   snapshotsPriorV4,
   statementsForDiffs,