drizzle-kit 0.16.9-fcedf83 → 0.17.0-5763371

package/utils.js

@@ -6669,7 +6669,7 @@ __export(utils_exports, {
   mapValues: () => mapValues,
   prepareMigrationFolder: () => prepareMigrationFolder,
   prepareMigrationMeta: () => prepareMigrationMeta,
-  prepareOutFolder: () => prepareOutFolder,
+  prepareOutFolder: () => prepareOutFolder2,
   schemaRenameKey: () => schemaRenameKey,
   snapshotsPriorV4: () => snapshotsPriorV4,
   statementsForDiffs: () => statementsForDiffs,
@@ -7169,7 +7169,7 @@ var info = (msg, greyMsg = "") => {
 var originUUID = "00000000-0000-0000-0000-000000000000";
 var snapshotVersion = "5";
 
-// node_modules/.pnpm/zod@3.20.2/node_modules/zod/lib/index.mjs
+// node_modules/.pnpm/zod@3.20.6/node_modules/zod/lib/index.mjs
 var util;
 (function(util2) {
   util2.assertEqual = (val) => val;
@@ -7584,7 +7584,7 @@ var OK = (value) => ({ status: "valid", value });
 var isAborted = (x) => x.status === "aborted";
 var isDirty = (x) => x.status === "dirty";
 var isValid = (x) => x.status === "valid";
-var isAsync = (x) => typeof Promise !== void 0 && x instanceof Promise;
+var isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
 var errorUtil;
 (function(errorUtil2) {
   errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
@@ -7800,28 +7800,29 @@ var ZodType = class {
     return this._refinement(refinement);
   }
   optional() {
-    return ZodOptional.create(this);
+    return ZodOptional.create(this, this._def);
   }
   nullable() {
-    return ZodNullable.create(this);
+    return ZodNullable.create(this, this._def);
   }
   nullish() {
-    return this.optional().nullable();
+    return this.nullable().optional();
   }
   array() {
-    return ZodArray.create(this);
+    return ZodArray.create(this, this._def);
   }
   promise() {
-    return ZodPromise.create(this);
+    return ZodPromise.create(this, this._def);
   }
   or(option) {
-    return ZodUnion.create([this, option]);
+    return ZodUnion.create([this, option], this._def);
   }
   and(incoming) {
-    return ZodIntersection.create(this, incoming);
+    return ZodIntersection.create(this, incoming, this._def);
   }
   transform(transform) {
     return new ZodEffects({
+      ...processCreateParams(this._def),
       schema: this,
       typeName: ZodFirstPartyTypeKind.ZodEffects,
       effect: { type: "transform", transform }
@@ -7830,6 +7831,7 @@ var ZodType = class {
   default(def) {
     const defaultValueFunc = typeof def === "function" ? def : () => def;
     return new ZodDefault({
+      ...processCreateParams(this._def),
       innerType: this,
       defaultValue: defaultValueFunc,
       typeName: ZodFirstPartyTypeKind.ZodDefault
@@ -7839,14 +7841,15 @@ var ZodType = class {
     return new ZodBranded({
       typeName: ZodFirstPartyTypeKind.ZodBranded,
       type: this,
-      ...processCreateParams(void 0)
+      ...processCreateParams(this._def)
     });
   }
   catch(def) {
-    const defaultValueFunc = typeof def === "function" ? def : () => def;
+    const catchValueFunc = typeof def === "function" ? def : () => def;
     return new ZodCatch({
+      ...processCreateParams(this._def),
       innerType: this,
-      defaultValue: defaultValueFunc,
+      catchValue: catchValueFunc,
       typeName: ZodFirstPartyTypeKind.ZodCatch
     });
   }
@@ -7868,24 +7871,25 @@ var ZodType = class {
   }
 };
 var cuidRegex = /^c[^\s-]{8,}$/i;
+var cuid2Regex = /^[a-z][a-z0-9]*$/;
 var uuidRegex = /^([a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[a-f0-9]{4}-[a-f0-9]{12}|00000000-0000-0000-0000-000000000000)$/i;
-var emailRegex = /^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;
+var emailRegex = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|([^-]([a-zA-Z0-9-]*\.)+[a-zA-Z]{2,}))$/;
 var datetimeRegex = (args) => {
   if (args.precision) {
     if (args.offset) {
-      return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{${args.precision}}(([+-]\\d{2}:\\d{2})|Z)$`);
+      return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{${args.precision}}(([+-]\\d{2}(:?\\d{2})?)|Z)$`);
     } else {
       return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{${args.precision}}Z$`);
     }
   } else if (args.precision === 0) {
     if (args.offset) {
-      return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(([+-]\\d{2}:\\d{2})|Z)$`);
+      return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(([+-]\\d{2}(:?\\d{2})?)|Z)$`);
     } else {
       return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z$`);
     }
   } else {
     if (args.offset) {
-      return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(([+-]\\d{2}:\\d{2})|Z)$`);
+      return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(([+-]\\d{2}(:?\\d{2})?)|Z)$`);
     } else {
       return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?Z$`);
     }
@@ -8007,6 +8011,16 @@ var ZodString = class extends ZodType {
           });
           status.dirty();
         }
+      } else if (check.kind === "cuid2") {
+        if (!cuid2Regex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            validation: "cuid2",
+            code: ZodIssueCode.invalid_string,
+            message: check.message
+          });
+          status.dirty();
+        }
       } else if (check.kind === "url") {
         try {
           new URL(input.data);
@@ -8088,6 +8102,9 @@ var ZodString = class extends ZodType {
   cuid(message) {
     return this._addCheck({ kind: "cuid", ...errorUtil.errToObj(message) });
   }
+  cuid2(message) {
+    return this._addCheck({ kind: "cuid2", ...errorUtil.errToObj(message) });
+  }
   datetime(options) {
     var _a;
     if (typeof options === "string") {
@@ -8162,6 +8179,9 @@ var ZodString = class extends ZodType {
   get isCUID() {
     return !!this._def.checks.find((ch) => ch.kind === "cuid");
   }
+  get isCUID2() {
+    return !!this._def.checks.find((ch) => ch.kind === "cuid2");
+  }
   get minLength() {
     let min = null;
     for (const ch of this._def.checks) {
@@ -8392,7 +8412,22 @@ var ZodNumber = class extends ZodType {
     return max;
   }
   get isInt() {
-    return !!this._def.checks.find((ch) => ch.kind === "int");
+    return !!this._def.checks.find((ch) => ch.kind === "int" || ch.kind === "multipleOf" && util.isInteger(ch.value));
+  }
+  get isFinite() {
+    let max = null, min = null;
+    for (const ch of this._def.checks) {
+      if (ch.kind === "finite" || ch.kind === "int" || ch.kind === "multipleOf") {
+        return true;
+      } else if (ch.kind === "min") {
+        if (min === null || ch.value > min)
+          min = ch.value;
+      } else if (ch.kind === "max") {
+        if (max === null || ch.value < max)
+          max = ch.value;
+      }
+    }
+    return Number.isFinite(min) && Number.isFinite(max);
   }
 };
 ZodNumber.create = (params) => {
@@ -8749,13 +8784,13 @@ var ZodArray = class extends ZodType {
       }
     }
     if (ctx.common.async) {
-      return Promise.all(ctx.data.map((item, i) => {
+      return Promise.all([...ctx.data].map((item, i) => {
         return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
       })).then((result2) => {
         return ParseStatus.mergeArray(status, result2);
       });
     }
-    const result = ctx.data.map((item, i) => {
+    const result = [...ctx.data].map((item, i) => {
       return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
     });
     return ParseStatus.mergeArray(status, result);
@@ -8804,15 +8839,6 @@ var objectUtil;
     };
   };
 })(objectUtil || (objectUtil = {}));
-var AugmentFactory = (def) => (augmentation) => {
-  return new ZodObject({
-    ...def,
-    shape: () => ({
-      ...def.shape(),
-      ...augmentation
-    })
-  });
-};
 function deepPartialify(schema3) {
   if (schema3 instanceof ZodObject) {
     const newShape = {};
@@ -8841,8 +8867,7 @@ var ZodObject = class extends ZodType {
     super(...arguments);
     this._cached = null;
     this.nonstrict = this.passthrough;
-    this.augment = AugmentFactory(this._def);
-    this.extend = AugmentFactory(this._def);
+    this.augment = this.extend;
   }
   _getCached() {
     if (this._cached !== null)
@@ -8971,8 +8996,14 @@ var ZodObject = class extends ZodType {
       unknownKeys: "passthrough"
     });
   }
-  setKey(key, schema3) {
-    return this.augment({ [key]: schema3 });
+  extend(augmentation) {
+    return new ZodObject({
+      ...this._def,
+      shape: () => ({
+        ...this._def.shape(),
+        ...augmentation
+      })
+    });
   }
   merge(merging) {
     const merged = new ZodObject({
@@ -8983,6 +9014,9 @@ var ZodObject = class extends ZodType {
     });
     return merged;
   }
+  setKey(key, schema3) {
+    return this.augment({ [key]: schema3 });
+  }
   catchall(index4) {
     return new ZodObject({
       ...this._def,
@@ -8991,9 +9025,10 @@ var ZodObject = class extends ZodType {
   }
   pick(mask) {
     const shape = {};
-    util.objectKeys(mask).map((key) => {
-      if (this.shape[key])
+    util.objectKeys(mask).forEach((key) => {
+      if (mask[key] && this.shape[key]) {
         shape[key] = this.shape[key];
+      }
     });
     return new ZodObject({
       ...this._def,
@@ -9002,8 +9037,8 @@ var ZodObject = class extends ZodType {
   }
   omit(mask) {
     const shape = {};
-    util.objectKeys(this.shape).map((key) => {
-      if (util.objectKeys(mask).indexOf(key) === -1) {
+    util.objectKeys(this.shape).forEach((key) => {
+      if (!mask[key]) {
         shape[key] = this.shape[key];
       }
     });
@@ -9017,24 +9052,14 @@ var ZodObject = class extends ZodType {
   }
   partial(mask) {
     const newShape = {};
-    if (mask) {
-      util.objectKeys(this.shape).map((key) => {
-        if (util.objectKeys(mask).indexOf(key) === -1) {
-          newShape[key] = this.shape[key];
-        } else {
-          newShape[key] = this.shape[key].optional();
-        }
-      });
-      return new ZodObject({
-        ...this._def,
-        shape: () => newShape
-      });
-    } else {
-      for (const key in this.shape) {
-        const fieldSchema = this.shape[key];
+    util.objectKeys(this.shape).forEach((key) => {
+      const fieldSchema = this.shape[key];
+      if (mask && !mask[key]) {
+        newShape[key] = fieldSchema;
+      } else {
         newShape[key] = fieldSchema.optional();
       }
-    }
+    });
     return new ZodObject({
       ...this._def,
       shape: () => newShape
@@ -9042,21 +9067,10 @@ var ZodObject = class extends ZodType {
   }
   required(mask) {
     const newShape = {};
-    if (mask) {
-      util.objectKeys(this.shape).map((key) => {
-        if (util.objectKeys(mask).indexOf(key) === -1) {
-          newShape[key] = this.shape[key];
-        } else {
-          const fieldSchema = this.shape[key];
-          let newField = fieldSchema;
-          while (newField instanceof ZodOptional) {
-            newField = newField._def.innerType;
-          }
-          newShape[key] = newField;
-        }
-      });
-    } else {
-      for (const key in this.shape) {
+    util.objectKeys(this.shape).forEach((key) => {
+      if (mask && !mask[key]) {
+        newShape[key] = this.shape[key];
+      } else {
         const fieldSchema = this.shape[key];
         let newField = fieldSchema;
         while (newField instanceof ZodOptional) {
@@ -9064,7 +9078,7 @@ var ZodObject = class extends ZodType {
         }
         newShape[key] = newField;
       }
-    }
+    });
     return new ZodObject({
       ...this._def,
       shape: () => newShape
@@ -9404,7 +9418,7 @@ var ZodTuple = class extends ZodType {
       });
       status.dirty();
     }
-    const items = ctx.data.map((item, itemIndex) => {
+    const items = [...ctx.data].map((item, itemIndex) => {
       const schema3 = this._def.items[itemIndex] || this._def.rest;
       if (!schema3)
         return null;
@@ -9771,6 +9785,7 @@ var ZodLiteral = class extends ZodType {
     if (input.data !== this._def.value) {
       const ctx = this._getOrReturnCtx(input);
       addIssueToContext(ctx, {
+        received: ctx.data,
         code: ZodIssueCode.invalid_literal,
         expected: this._def.value
       });
@@ -9844,6 +9859,12 @@ var ZodEnum = class extends ZodType {
     }
     return enumValues;
   }
+  extract(values) {
+    return ZodEnum.create(values);
+  }
+  exclude(values) {
+    return ZodEnum.create(this.options.filter((opt) => !values.includes(opt)));
+  }
 };
 ZodEnum.create = createZodEnum;
 var ZodNativeEnum = class extends ZodType {
@@ -9882,6 +9903,9 @@ ZodNativeEnum.create = (values, params) => {
   });
 };
 var ZodPromise = class extends ZodType {
+  unwrap() {
+    return this._def.type;
+  }
   _parse(input) {
     const { ctx } = this._processInputParams(input);
     if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
@@ -10095,23 +10119,29 @@ var ZodCatch = class extends ZodType {
     const result = this._def.innerType._parse({
       data: ctx.data,
       path: ctx.path,
-      parent: ctx
+      parent: {
+        ...ctx,
+        common: {
+          ...ctx.common,
+          issues: []
+        }
+      }
     });
     if (isAsync(result)) {
       return result.then((result2) => {
         return {
           status: "valid",
-          value: result2.status === "valid" ? result2.value : this._def.defaultValue()
+          value: result2.status === "valid" ? result2.value : this._def.catchValue()
         };
       });
     } else {
       return {
         status: "valid",
-        value: result.status === "valid" ? result.value : this._def.defaultValue()
+        value: result.status === "valid" ? result.value : this._def.catchValue()
       };
     }
   }
-  removeDefault() {
+  removeCatch() {
     return this._def.innerType;
   }
 };
@@ -10119,7 +10149,7 @@ ZodCatch.create = (type, params) => {
   return new ZodCatch({
     innerType: type,
     typeName: ZodFirstPartyTypeKind.ZodCatch,
-    defaultValue: typeof params.default === "function" ? params.default : () => params.default,
+    catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
     ...processCreateParams(params)
   });
 };
@@ -10323,13 +10353,25 @@ var tableV3 = objectType({
   indexes: recordType(stringType(), index),
   foreignKeys: recordType(stringType(), fk)
 }).strict();
-var table = objectType({
+var compositePK = 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)
+}).strict();
 var dialect = literalType("mysql");
 var schemaHash = objectType({
   id: stringType(),
@@ -10343,7 +10385,7 @@ var schemaInternalV3 = objectType({
 var schemaInternalV4 = objectType({
   version: literalType("4"),
   dialect,
-  tables: recordType(stringType(), table),
+  tables: recordType(stringType(), tableV4),
   schemas: recordType(stringType(), stringType())
 }).strict();
 var schemaInternal = objectType({
@@ -10360,19 +10402,33 @@ var schemaInternal = objectType({
 var schemaV3 = schemaInternalV3.merge(schemaHash);
 var schemaV4 = schemaInternalV4.merge(schemaHash);
 var schema = schemaInternal.merge(schemaHash);
-var tableSquashed = objectType({
+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())
+}).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) => {
     var _a, _b, _c;
@@ -10391,6 +10447,13 @@ var MySqlSquasher = {
     };
     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(",") };
+  },
   squashFK: (fk4) => {
     var _a, _b;
     return `${fk4.name};${fk4.tableFrom};${fk4.columnsFrom.join(",")};${fk4.tableTo};${fk4.columnsTo.join(",")};${(_a = fk4.onUpdate) != null ? _a : ""};${(_b = fk4.onDelete) != null ? _b : ""}`;
@@ -10518,13 +10581,25 @@ var tableV32 = objectType({
   indexes: recordType(stringType(), index2),
   foreignKeys: recordType(stringType(), fk2)
 }).strict();
-var table2 = objectType({
+var compositePK2 = objectType({
+  name: stringType(),
+  columns: stringType().array()
+}).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)
+}).strict();
 var schemaHash2 = objectType({
   id: stringType(),
   prevId: stringType()
@@ -10538,7 +10613,7 @@ var pgSchemaInternalV3 = objectType({
 var pgSchemaInternalV4 = objectType({
   version: literalType("4"),
   dialect: literalType("pg"),
-  tables: recordType(stringType(), table2),
+  tables: recordType(stringType(), tableV42),
   enums: recordType(stringType(), enumSchema),
   schemas: recordType(stringType(), stringType())
 }).strict();
@@ -10555,12 +10630,27 @@ var pgSchemaInternal = objectType({
   })
 }).strict();
 var tableSquashed2 = objectType({
+  name: stringType(),
+  schema: stringType(),
+  columns: recordType(stringType(), column2),
+  indexes: recordType(stringType(), stringType()),
+  foreignKeys: recordType(stringType(), stringType()),
+  compositePrimaryKeys: 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"]),
@@ -10596,6 +10686,12 @@ var PgSquasher = {
     var _a, _b;
     return `${fk4.name};${fk4.tableFrom};${fk4.columnsFrom.join(",")};${fk4.tableTo};${fk4.columnsTo.join(",")};${(_a = fk4.onUpdate) != null ? _a : ""};${(_b = fk4.onDelete) != null ? _b : ""}`;
   },
+  squashPK: (pk) => {
+    return `${pk.columns.join(",")}`;
+  },
+  unsquashPK: (pk) => {
+    return { name: "", columns: pk.split(",") };
+  },
   unsquashFK: (input) => {
     const [
       name,
@@ -10627,6 +10723,9 @@ var squashPgScheme = (json) => {
       const squashedFKs = mapValues(it[1].foreignKeys, (fk4) => {
         return PgSquasher.squashFK(fk4);
       });
+      const squashedPKs = mapValues(it[1].compositePrimaryKeys, (pk) => {
+        return PgSquasher.squashPK(pk);
+      });
       return [
         it[0],
         {
@@ -10634,7 +10733,8 @@ var squashPgScheme = (json) => {
           schema: it[1].schema,
           columns: it[1].columns,
           indexes: squashedIndexes,
-          foreignKeys: squashedFKs
+          foreignKeys: squashedFKs,
+          compositePrimaryKeys: squashedPKs
         }
       ];
     })
@@ -10678,7 +10778,7 @@ var fk3 = objectType({
   onUpdate: stringType().optional(),
   onDelete: stringType().optional()
 }).strict();
-var compositePK = objectType({
+var compositePK3 = objectType({
   columns: stringType().array()
 }).strict();
 var column3 = objectType({
@@ -10700,7 +10800,7 @@ var table3 = objectType({
   columns: recordType(stringType(), column3),
   indexes: recordType(stringType(), index3),
   foreignKeys: recordType(stringType(), fk3),
-  compositePrimaryKeys: recordType(stringType(), compositePK)
+  compositePrimaryKeys: recordType(stringType(), compositePK3)
 }).strict();
 var dialect2 = enumType(["sqlite"]);
 var schemaHash3 = objectType({
@@ -11052,13 +11152,26 @@ var pgNativeTypes = /* @__PURE__ */ new Set([
   "interval",
   "bigint",
   "bigserial",
-  "double precision"
+  "double precision",
+  "interval year",
+  "interval month",
+  "interval day",
+  "interval hour",
+  "interval minute",
+  "interval second",
+  "interval year to month",
+  "interval day to hour",
+  "interval day to minute",
+  "interval day to second",
+  "interval hour to minute",
+  "interval hour to second",
+  "interval minute to second"
 ]);
 var isPgNativeType = (it) => {
   if (pgNativeTypes.has(it))
     return true;
   const toCheck = it.replace(/ /g, "");
-  return toCheck.startsWith("varchar(") || toCheck.startsWith("numeric(") || toCheck.startsWith("timestamp(");
+  return toCheck.startsWith("varchar(") || toCheck.startsWith("char(") || toCheck.startsWith("numeric(") || toCheck.startsWith("timestamp(");
 };
 var Convertor = class {
 };
@@ -11067,7 +11180,7 @@ var PgCreateTableConvertor = class extends Convertor {
     return statement.type === "create_table" && dialect3 === "pg";
   }
   convert(st) {
-    const { tableName, schema: schema3, columns } = st;
+    const { tableName, schema: schema3, columns, compositePKs } = st;
     let statement = "";
     const name = schema3 ? `"${schema3}"."${tableName}"` : `"${tableName}"`;
     statement += `CREATE TABLE IF NOT EXISTS ${name} (
@@ -11077,13 +11190,19 @@ var PgCreateTableConvertor = class extends Convertor {
       const primaryKeyStatement = column4.primaryKey ? "PRIMARY KEY" : "";
       const notNullStatement = column4.notNull ? "NOT NULL" : "";
       const defaultStatement = column4.default !== void 0 ? `DEFAULT ${column4.default}` : "";
-      const type = isPgNativeType(column4.type) ? column4.type : `"${column4.type}"`;
+      const type = isPgNativeType(column4.type) ? column4.type : `${column4.type}`;
       statement += "	" + `"${column4.name}" ${type} ${primaryKeyStatement} ${defaultStatement} ${notNullStatement}`.replace(/  +/g, " ").trim();
       statement += (i === columns.length - 1 ? "" : ",") + "\n";
     }
     statement += `);`;
     statement += `
 `;
+    if (typeof compositePKs !== "undefined" && compositePKs.length > 0) {
+      const compositePK4 = PgSquasher.unsquashPK(compositePKs[0]);
+      statement += `ALTER TABLE ${name} ADD CONSTRAINT "${st.compositePkName}" PRIMARY KEY("${compositePK4.columns.join('","')}");`;
+      statement += `
+`;
+    }
     return statement;
   }
 };
@@ -11092,7 +11211,7 @@ var MySqlCreateTableConvertor = class extends Convertor {
     return statement.type === "create_table" && dialect3 === "mysql";
   }
   convert(st) {
-    const { tableName, columns, schema: schema3 } = st;
+    const { tableName, columns, schema: schema3, compositePKs } = st;
     let statement = "";
     const tName = schema3 ? `\`${schema3}\`.\`${tableName}\`` : `\`${tableName}\``;
     statement += `CREATE TABLE ${tName} (
@@ -11110,6 +11229,12 @@ var MySqlCreateTableConvertor = class extends Convertor {
     statement += `);`;
     statement += `
 `;
+    if (typeof compositePKs !== "undefined" && compositePKs.length > 0) {
+      const compositePK4 = MySqlSquasher.unsquashPK(compositePKs[0]);
+      statement += `ALTER TABLE ${tName} ADD PRIMARY KEY(\`${compositePK4.columns.join("`,`")}\`);`;
+      statement += `
+`;
+    }
     return statement;
   }
 };
@@ -11479,6 +11604,67 @@ var SqliteAlterTableAlterColumnDropDefaultConvertor = class extends Convertor {
 */`;
   }
 };
+var PgAlterTableCreateCompositePrimaryKeyConvertor = class extends Convertor {
+  can(statement, dialect3) {
+    return statement.type === "create_composite_pk" && dialect3 === "pg";
+  }
+  convert(statement) {
+    const { name, columns } = PgSquasher.unsquashPK(statement.data);
+    return `ALTER TABLE "${statement.tableName}" ADD CONSTRAINT "${statement.constraintName}" PRIMARY KEY("${columns.join('","')}");`;
+  }
+};
+var PgAlterTableDeleteCompositePrimaryKeyConvertor = class extends Convertor {
+  can(statement, dialect3) {
+    return statement.type === "delete_composite_pk" && dialect3 === "pg";
+  }
+  convert(statement) {
+    const { name, columns } = PgSquasher.unsquashPK(statement.data);
+    return `ALTER TABLE "${statement.tableName}" DROP CONSTRAINT "${statement.constraintName}";`;
+  }
+};
+var PgAlterTableAlterCompositePrimaryKeyConvertor = class extends Convertor {
+  can(statement, dialect3) {
+    return statement.type === "alter_composite_pk" && dialect3 === "pg";
+  }
+  convert(statement) {
+    const { name, columns } = PgSquasher.unsquashPK(statement.old);
+    const { name: newName, columns: newColumns } = PgSquasher.unsquashPK(
+      statement.new
+    );
+    return `ALTER TABLE "${statement.tableName}" DROP CONSTRAINT ${statement.oldConstraintName};
+ALTER TABLE "${statement.tableName}" ADD CONSTRAINT ${statement.newConstraintName} PRIMARY KEY(${newColumns.join(",")});`;
+  }
+};
+var MySqlAlterTableCreateCompositePrimaryKeyConvertor = class extends Convertor {
+  can(statement, dialect3) {
+    return statement.type === "create_composite_pk" && dialect3 === "mysql";
+  }
+  convert(statement) {
+    const { name, columns } = MySqlSquasher.unsquashPK(statement.data);
+    return `ALTER TABLE \`${statement.tableName}\` ADD PRIMARY KEY(\`${columns.join("`,`")}\`);`;
+  }
+};
+var MySqlAlterTableDeleteCompositePrimaryKeyConvertor = class extends Convertor {
+  can(statement, dialect3) {
+    return statement.type === "delete_composite_pk" && dialect3 === "mysql";
+  }
+  convert(statement) {
+    const { name, columns } = MySqlSquasher.unsquashPK(statement.data);
+    return `ALTER TABLE \`${statement.tableName}\` DROP PRIMARY KEY;`;
+  }
+};
+var MySqlAlterTableAlterCompositePrimaryKeyConvertor = class extends Convertor {
+  can(statement, dialect3) {
+    return statement.type === "alter_composite_pk" && dialect3 === "mysql";
+  }
+  convert(statement) {
+    const { name, columns } = MySqlSquasher.unsquashPK(statement.old);
+    const { name: newName, columns: newColumns } = MySqlSquasher.unsquashPK(
+      statement.new
+    );
+    return `ALTER TABLE \`${statement.tableName}\` DROP PRIMARY KEY, ADD PRIMARY KEY(\`${newColumns.join("`,`")}\`);`;
+  }
+};
 var SqliteAlterTableCreateCompositePrimaryKeyConvertor = class extends Convertor {
   can(statement, dialect3) {
     return statement.type === "create_composite_pk" && dialect3 === "sqlite";
@@ -11985,6 +12171,12 @@ convertors.push(new SqliteAlterTableAlterColumnDropDefaultConvertor());
 convertors.push(new SqliteAlterTableCreateCompositePrimaryKeyConvertor());
 convertors.push(new SqliteAlterTableDeleteCompositePrimaryKeyConvertor());
 convertors.push(new SqliteAlterTableAlterCompositePrimaryKeyConvertor());
+convertors.push(new PgAlterTableCreateCompositePrimaryKeyConvertor());
+convertors.push(new PgAlterTableDeleteCompositePrimaryKeyConvertor());
+convertors.push(new PgAlterTableAlterCompositePrimaryKeyConvertor());
+convertors.push(new MySqlAlterTableCreateCompositePrimaryKeyConvertor());
+convertors.push(new MySqlAlterTableDeleteCompositePrimaryKeyConvertor());
+convertors.push(new MySqlAlterTableAlterCompositePrimaryKeyConvertor());
 var fromJson = (statements, dialect3) => {
   const result = statements.map((statement) => {
     const filtered = convertors.filter((it) => {
@@ -12025,13 +12217,30 @@ drop type __venum;
 `;
 
 // src/jsonStatements.ts
-var prepareCreateTableJson = (table4) => {
-  const { name, schema: schema3, columns } = table4;
+var preparePgCreateTableJson = (table4, json2) => {
+  const { name, schema: schema3, columns, compositePrimaryKeys } = table4;
   return {
     type: "create_table",
     tableName: name,
     schema: schema3,
-    columns: Object.values(columns)
+    columns: Object.values(columns),
+    compositePKs: Object.values(compositePrimaryKeys),
+    compositePkName: Object.values(compositePrimaryKeys).length > 0 ? json2.tables[name].compositePrimaryKeys[`${name}_${PgSquasher.unsquashPK(
+      Object.values(compositePrimaryKeys)[0]
+    ).columns.join("_")}`].name : ""
+  };
+};
+var prepareMySqlCreateTableJson = (table4, json2) => {
+  const { name, schema: schema3, columns, compositePrimaryKeys } = table4;
+  return {
+    type: "create_table",
+    tableName: name,
+    schema: schema3,
+    columns: Object.values(columns),
+    compositePKs: Object.values(compositePrimaryKeys),
+    compositePkName: Object.values(compositePrimaryKeys).length > 0 ? json2.tables[name].compositePrimaryKeys[`${name}_${MySqlSquasher.unsquashPK(
+      Object.values(compositePrimaryKeys)[0]
+    ).columns.join("_")}`].name : ""
   };
 };
 var prepareSQLiteCreateTable = (table4) => {
@@ -12415,6 +12624,70 @@ var prepareAlterCompositePrimaryKeySqlite = (tableName, pks) => {
     };
   });
 };
+var prepareAddCompositePrimaryKeyPg = (tableName, pks, json2) => {
+  return Object.values(pks).map((it) => {
+    return {
+      type: "create_composite_pk",
+      tableName,
+      data: it,
+      constraintName: json2.tables[tableName].compositePrimaryKeys[`${tableName}_${PgSquasher.unsquashPK(it).columns.join("_")}`].name
+    };
+  });
+};
+var prepareDeleteCompositePrimaryKeyPg = (tableName, pks, json1) => {
+  return Object.values(pks).map((it) => {
+    return {
+      type: "delete_composite_pk",
+      tableName,
+      data: it,
+      constraintName: json1.tables[tableName].compositePrimaryKeys[`${tableName}_${PgSquasher.unsquashPK(it).columns.join("_")}`].name
+    };
+  });
+};
+var prepareAlterCompositePrimaryKeyPg = (tableName, pks, json1, json2) => {
+  return Object.values(pks).map((it) => {
+    return {
+      type: "alter_composite_pk",
+      tableName,
+      old: it.__old,
+      new: it.__new,
+      oldConstraintName: json1.tables[tableName].compositePrimaryKeys[`${tableName}_${PgSquasher.unsquashPK(it.__old).columns.join("_")}`].name,
+      newConstraintName: json2.tables[tableName].compositePrimaryKeys[`${tableName}_${PgSquasher.unsquashPK(it.__new).columns.join("_")}`].name
+    };
+  });
+};
+var prepareAddCompositePrimaryKeyMySql = (tableName, pks, json2) => {
+  return Object.values(pks).map((it) => {
+    return {
+      type: "create_composite_pk",
+      tableName,
+      data: it,
+      constraintName: json2.tables[tableName].compositePrimaryKeys[`${tableName}_${MySqlSquasher.unsquashPK(it).columns.join("_")}`].name
+    };
+  });
+};
+var prepareDeleteCompositePrimaryKeyMySql = (tableName, pks, json1) => {
+  return Object.values(pks).map((it) => {
+    return {
+      type: "delete_composite_pk",
+      tableName,
+      data: it,
+      constraintName: json1.tables[tableName].compositePrimaryKeys[`${tableName}_${MySqlSquasher.unsquashPK(it).columns.join("_")}`].name
+    };
+  });
+};
+var prepareAlterCompositePrimaryKeyMySql = (tableName, pks, json1, json2) => {
+  return Object.values(pks).map((it) => {
+    return {
+      type: "alter_composite_pk",
+      tableName,
+      old: it.__old,
+      new: it.__new,
+      oldConstraintName: json1.tables[tableName].compositePrimaryKeys[`${tableName}_${MySqlSquasher.unsquashPK(it.__old).columns.join("_")}`].name,
+      newConstraintName: json2.tables[tableName].compositePrimaryKeys[`${tableName}_${MySqlSquasher.unsquashPK(it.__new).columns.join("_")}`].name
+    };
+  });
+};
 
 // src/snapshotsDiffer.ts
 var makeChanged = (schema3) => {
@@ -12556,7 +12829,7 @@ var diffResultScheme = objectType({
   addedSchemas: stringType().array(),
   deletedSchemas: stringType().array()
 }).strict();
-var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesResolver, columnsResolver) => {
+var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesResolver, columnsResolver, prevFull, curFull) => {
   var _a, _b, _c, _d;
   const diffResult = applyJsonDiff(json1, json2);
   if (Object.keys(diffResult).length === 0) {
@@ -12586,9 +12859,6 @@ var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesR
   const jsonSQLiteCreateTables = created.map((it) => {
     return prepareSQLiteCreateTable(it);
   });
-  const jsonCreateTables = created.map((it) => {
-    return prepareCreateTableJson(it);
-  });
   const jsonCreateIndexesForCreatedTables = created.map((it) => {
     return prepareCreateIndexesJson(it.name, it.schema, it.indexes);
   }).flat();
@@ -12646,18 +12916,57 @@ var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesR
   const jsonRemoveTableFromSchemas = [];
   const jsonSetNewTableSchemas = [];
   allAlteredResolved.forEach((it) => {
-    const addedCompositePKs = prepareAddCompositePrimaryKeySqlite(
-      it.name,
-      it.addedCompositePKs
-    );
-    const deletedCompositePKs = prepareDeleteCompositePrimaryKeySqlite(
-      it.name,
-      it.deletedCompositePKs
-    );
-    const alteredCompositePKs = prepareAlterCompositePrimaryKeySqlite(
-      it.name,
-      it.alteredCompositePKs
-    );
+    let addedCompositePKs;
+    let deletedCompositePKs;
+    let alteredCompositePKs;
+    if (dialect3 === "sqlite") {
+      addedCompositePKs = prepareAddCompositePrimaryKeySqlite(
+        it.name,
+        it.addedCompositePKs
+      );
+      deletedCompositePKs = prepareDeleteCompositePrimaryKeySqlite(
+        it.name,
+        it.deletedCompositePKs
+      );
+      alteredCompositePKs = prepareAlterCompositePrimaryKeySqlite(
+        it.name,
+        it.alteredCompositePKs
+      );
+    } else if (dialect3 === "pg") {
+      addedCompositePKs = prepareAddCompositePrimaryKeyPg(
+        it.name,
+        it.addedCompositePKs,
+        curFull
+      );
+      deletedCompositePKs = prepareDeleteCompositePrimaryKeyPg(
+        it.name,
+        it.deletedCompositePKs,
+        prevFull
+      );
+      alteredCompositePKs = prepareAlterCompositePrimaryKeyPg(
+        it.name,
+        it.alteredCompositePKs,
+        prevFull,
+        curFull
+      );
+    } else {
+      addedCompositePKs = prepareAddCompositePrimaryKeyMySql(
+        it.name,
+        it.addedCompositePKs,
+        curFull
+      );
+      deletedCompositePKs = prepareDeleteCompositePrimaryKeyMySql(
+        it.name,
+        it.deletedCompositePKs,
+        prevFull
+      );
+      alteredCompositePKs = prepareAlterCompositePrimaryKeyMySql(
+        it.name,
+        it.alteredCompositePKs,
+        prevFull,
+        curFull
+      );
+    }
     if (it.schema && typeof it.schema !== "string") {
       switch (it.schema.type) {
         case "added": {
@@ -12780,8 +13089,16 @@ var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesR
   jsonStatements.push(...jsonAlterEnumsWithAddedValues);
   if (dialect3 === "sqlite") {
     jsonStatements.push(...jsonSQLiteCreateTables);
+  } else if (dialect3 === "pg") {
+    const jsonPgCreateTables = created.map((it) => {
+      return preparePgCreateTableJson(it, curFull);
+    });
+    jsonStatements.push(...jsonPgCreateTables);
   } else {
-    jsonStatements.push(...jsonCreateTables);
+    const jsonMySqlCreateTables = created.map((it) => {
+      return prepareMySqlCreateTableJson(it, curFull);
+    });
+    jsonStatements.push(...jsonMySqlCreateTables);
   }
   jsonStatements.push(...jsonDropTables);
   jsonStatements.push(...jsonRenameTables);
@@ -12810,7 +13127,11 @@ var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesR
     }
   });
   const _meta = prepareMigrationMeta(rSchemas, rTables, rColumns);
-  return { statements: jsonStatements, sqlStatements: uniqueSqlStatements, _meta };
+  return {
+    statements: jsonStatements,
+    sqlStatements: uniqueSqlStatements,
+    _meta
+  };
 };
 
 // src/cli/commands/upFolders.ts
@@ -12945,7 +13266,7 @@ var snapshotsPriorV4 = (out) => {
     return pathJson;
   });
 };
-var prepareOutFolder = (out, dialect3) => {
+var prepareOutFolder2 = (out, dialect3) => {
   const meta = (0, import_path.join)(out, "meta");
   const journalPath = (0, import_path.join)(meta, "_journal.json");
   if (!(0, import_fs.existsSync)((0, import_path.join)(out, "meta"))) {
@@ -12969,7 +13290,7 @@ var validatorForDialect = (dialect3) => {
     case "pg":
       return { validator: backwardCompatiblePgSchema, version: 5 };
     case "sqlite":
-      return { validator: backwardCompatibleSqliteSchema, version: 4 };
+      return { validator: backwardCompatibleSqliteSchema, version: 5 };
     case "mysql":
       return { validator: backwardCompatibleMysqlSchema, version: 5 };
   }
@@ -13018,7 +13339,7 @@ var validateWithReport = (snapshots, dialect3) => {
   return result;
 };
 var prepareMigrationFolder = (outFolder = "drizzle", dialect3) => {
-  const { snapshots, journal } = prepareOutFolder(outFolder, dialect3);
+  const { snapshots, journal } = prepareOutFolder2(outFolder, dialect3);
   const report = validateWithReport(snapshots, dialect3);
   if (report.nonLatest.length > 0) {
     console.log(