drizzle-kit 0.19.3-d338b71 → 0.19.4-2a2e18d

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drizzle-kit",
-  "version": "0.19.3-d338b71",
+  "version": "0.19.4-2a2e18d",
   "repository": "https://github.com/drizzle-team/drizzle-kit-mirror",
   "author": "Drizzle Team",
   "license": "MIT",
@@ -79,7 +79,7 @@
     "better-sqlite3": "^8.4.0",
     "dockerode": "^3.3.4",
     "dotenv": "^16.0.3",
-    "drizzle-orm": "0.27.0",
+    "drizzle-orm": "0.27.0-7b55cc2",
     "eslint": "^8.29.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-prettier": "^4.2.1",

package/utils.js

@@ -12759,6 +12759,10 @@ 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(),
@@ -12772,7 +12776,8 @@ var table = objectType({
   columns: recordType(stringType(), column),
   indexes: recordType(stringType(), index),
   foreignKeys: recordType(stringType(), fk),
-  compositePrimaryKeys: recordType(stringType(), compositePK)
+  compositePrimaryKeys: recordType(stringType(), compositePK),
+  uniqueConstraints: recordType(stringType(), uniqueConstraint).default({})
 }).strict();
 var dialect = literalType("mysql");
 var schemaHash = objectType({
@@ -12855,6 +12860,13 @@ var MySqlSquasher = {
     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 ?? ""}`;
   },
@@ -12881,7 +12893,11 @@ var MySqlSquasher = {
   }
 };
 var mysqlSchema = schema;
-var backwardCompatibleMysqlSchema = unionType([schemaV3, schemaV4, schema]);
+var backwardCompatibleMysqlSchema = unionType([
+  schemaV3,
+  schemaV4,
+  schema
+]);
 var dryMySql = mysqlSchema.parse({
   version: snapshotVersion,
   dialect: "mysql",
@@ -12974,7 +12990,10 @@ var column2 = objectType({
   type: stringType(),
   primaryKey: booleanType(),
   notNull: booleanType(),
-  default: anyType().optional()
+  default: anyType().optional(),
+  isUnique: anyType().optional(),
+  uniqueName: stringType().optional(),
+  nullsNotDistinct: booleanType().optional()
 }).strict();
 var tableV32 = objectType({
   name: stringType(),
@@ -12986,6 +13005,11 @@ 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(),
@@ -12999,7 +13023,8 @@ var table2 = objectType({
   columns: recordType(stringType(), column2),
   indexes: recordType(stringType(), index2),
   foreignKeys: recordType(stringType(), fk2),
-  compositePrimaryKeys: recordType(stringType(), compositePK2)
+  compositePrimaryKeys: recordType(stringType(), compositePK2),
+  uniqueConstraints: recordType(stringType(), uniqueConstraint2).default({})
 }).strict();
 var schemaHash2 = objectType({
   id: stringType(),
@@ -13036,7 +13061,8 @@ var tableSquashed2 = objectType({
   columns: recordType(stringType(), column2),
   indexes: recordType(stringType(), stringType()),
   foreignKeys: recordType(stringType(), stringType()),
-  compositePrimaryKeys: recordType(stringType(), stringType())
+  compositePrimaryKeys: recordType(stringType(), stringType()),
+  uniqueConstraints: recordType(stringType(), stringType())
 }).strict();
 var tableSquashedV42 = objectType({
   name: stringType(),
@@ -13092,6 +13118,17 @@ var PgSquasher = {
   unsquashPK: (pk) => {
     return { name: "", columns: pk.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,
@@ -13126,6 +13163,9 @@ var squashPgScheme = (json) => {
       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],
         {
@@ -13134,7 +13174,8 @@ var squashPgScheme = (json) => {
           columns: it[1].columns,
           indexes: squashedIndexes,
           foreignKeys: squashedFKs,
-          compositePrimaryKeys: squashedPKs
+          compositePrimaryKeys: squashedPKs,
+          uniqueConstraints: squashedUniqueConstraints
         }
       ];
     })
@@ -13196,12 +13237,17 @@ var tableV33 = objectType({
   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)
+  compositePrimaryKeys: recordType(stringType(), compositePK3),
+  uniqueConstraints: recordType(stringType(), uniqueConstraint3).default({})
 }).strict();
 var dialect2 = enumType(["sqlite"]);
 var schemaHash3 = objectType({
@@ -13262,6 +13308,13 @@ var SQLiteSquasher = {
     });
     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 ?? ""}`;
   },
@@ -13440,6 +13493,15 @@ var findAlternationsInTable = (table4, tableSchema) => {
   const alteredCompositePKs = Object.fromEntries(Object.entries(table4.compositePrimaryKeys || {}).filter((it) => {
     return !it[0].endsWith("__deleted") && !it[0].endsWith("__added");
   }));
+  const addedUniqueConstraints = Object.fromEntries(Object.entries(table4.uniqueConstraints || {}).filter((it) => {
+    return it[0].endsWith("__added");
+  }));
+  const deletedUniqueConstraints = Object.fromEntries(Object.entries(table4.uniqueConstraints || {}).filter((it) => {
+    return it[0].endsWith("__deleted");
+  }));
+  const alteredUniqueConstraints = Object.fromEntries(Object.entries(table4.uniqueConstraints || {}).filter((it) => {
+    return !it[0].endsWith("__deleted") && !it[0].endsWith("__added");
+  }));
   const mappedAltered = altered.map((it) => alternationsInColumn(it));
   return {
     name: table4.name,
@@ -13455,7 +13517,10 @@ var findAlternationsInTable = (table4, tableSchema) => {
     alteredForeignKeys,
     addedCompositePKs,
     deletedCompositePKs,
-    alteredCompositePKs
+    alteredCompositePKs,
+    addedUniqueConstraints,
+    deletedUniqueConstraints,
+    alteredUniqueConstraints
   };
 };
 var alternationsInColumn = (column4) => {
@@ -13603,30 +13668,37 @@ var PgCreateTableConvertor = class extends Convertor {
     return statement.type === "create_table" && dialect3 === "pg";
   }
   convert(st) {
-    const { tableName, schema: schema4, columns, compositePKs } = st;
+    const { tableName, schema: schema4, columns, compositePKs, uniqueConstraints } = st;
     let statement = "";
     const name = schema4 ? `"${schema4}"."${tableName}"` : `"${tableName}"`;
     statement += `CREATE TABLE IF NOT EXISTS ${name} (
 `;
     for (let i = 0; i < columns.length; i++) {
       const column4 = columns[i];
-      const primaryKeyStatement = column4.primaryKey ? "PRIMARY KEY" : "";
-      const notNullStatement = column4.notNull ? "NOT NULL" : "";
-      const defaultStatement = column4.default !== void 0 ? `DEFAULT ${column4.default}` : "";
+      const primaryKeyStatement = column4.primaryKey ? " PRIMARY KEY" : "";
+      const notNullStatement = column4.notNull ? " NOT NULL" : "";
+      const defaultStatement = column4.default !== void 0 ? ` DEFAULT ${column4.default}` : "";
+      const uniqueConstraint4 = column4.isUnique ? ` CONSTRAINT ${column4.uniqueName} UNIQUE${column4.nullsNotDistinct ? " NULLS NOT DISTINCT" : ""}` : "";
       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 += `	"${column4.name}" ${type}${primaryKeyStatement}${defaultStatement}${notNullStatement}${uniqueConstraint4}`;
+      statement += i === columns.length - 1 ? "" : ",\n";
     }
-    statement += `);`;
-    statement += `
-`;
     if (typeof compositePKs !== "undefined" && compositePKs.length > 0) {
+      statement += ",\n";
       const compositePK4 = PgSquasher.unsquashPK(compositePKs[0]);
-      statement += BREAKPOINT;
-      statement += `ALTER TABLE ${name} ADD CONSTRAINT "${st.compositePkName}" PRIMARY KEY("${compositePK4.columns.join('","')}");`;
-      statement += `
-`;
+      statement += `	CONSTRAINT ${st.compositePkName} PRIMARY KEY("${compositePK4.columns.join(`","`)}")`;
     }
+    if (typeof uniqueConstraints !== "undefined" && uniqueConstraints.length > 0) {
+      for (const uniqueConstraint4 of uniqueConstraints) {
+        statement += ",\n";
+        const unsquashedUnique = PgSquasher.unsquashUnique(uniqueConstraint4);
+        statement += `	CONSTRAINT ${unsquashedUnique.name} UNIQUE("${unsquashedUnique.columns.join(`","`)}")`;
+      }
+    }
+    statement += `
+);`;
+    statement += `
+`;
     return statement;
   }
 };
@@ -13635,7 +13707,7 @@ var MySqlCreateTableConvertor = class extends Convertor {
     return statement.type === "create_table" && dialect3 === "mysql";
   }
   convert(st) {
-    const { tableName, columns, schema: schema4, compositePKs } = st;
+    const { tableName, columns, schema: schema4, compositePKs, uniqueConstraints } = st;
     let statement = "";
     const tName = schema4 ? `\`${schema4}\`.\`${tableName}\`` : `\`${tableName}\``;
     statement += `CREATE TABLE ${tName} (
@@ -13647,17 +13719,23 @@ var MySqlCreateTableConvertor = class extends Convertor {
       const defaultStatement = column4.default !== void 0 ? ` DEFAULT ${column4.default}` : "";
       const onUpdateStatement = column4.onUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
       const autoincrementStatement = column4.autoincrement ? " AUTO_INCREMENT" : "";
-      statement += "	" + `\`${column4.name}\` ${column4.type}${autoincrementStatement}${primaryKeyStatement}${notNullStatement}${defaultStatement}${onUpdateStatement}`.trim();
+      statement += `	\`${column4.name}\` ${column4.type}${autoincrementStatement}${primaryKeyStatement}${notNullStatement}${defaultStatement}${onUpdateStatement}`;
       statement += i === columns.length - 1 ? "" : ",\n";
     }
     if (typeof compositePKs !== "undefined" && compositePKs.length > 0) {
       statement += ",\n";
       const compositePK4 = MySqlSquasher.unsquashPK(compositePKs[0]);
-      statement += `	PRIMARY KEY(\`${compositePK4.columns.join("`,`")}\`)`;
-      statement += `
-`;
+      statement += `	CONSTRAINT ${st.compositePkName} PRIMARY KEY("${compositePK4.columns.join(`","`)}")`;
     }
-    statement += `);`;
+    if (typeof uniqueConstraints !== "undefined" && uniqueConstraints.length > 0) {
+      for (const uniqueConstraint4 of uniqueConstraints) {
+        statement += ",\n";
+        const unsquashedUnique = MySqlSquasher.unsquashUnique(uniqueConstraint4);
+        statement += `	CONSTRAINT ${unsquashedUnique.name} UNIQUE(\`${unsquashedUnique.columns.join(`\`,\``)}\`)`;
+      }
+    }
+    statement += `
+);`;
     statement += `
 `;
     return statement;
@@ -13668,7 +13746,13 @@ var SQLiteCreateTableConvertor = class extends Convertor {
     return statement.type === "sqlite_create_table" && dialect3 === "sqlite";
   }
   convert(st) {
-    const { tableName, columns, referenceData, compositePKs } = st;
+    const {
+      tableName,
+      columns,
+      referenceData,
+      compositePKs,
+      uniqueConstraints
+    } = st;
     let statement = "";
     statement += `CREATE TABLE \`${tableName}\` (`;
     for (let i = 0; i < columns.length; i++) {
@@ -13700,11 +13784,17 @@ var SQLiteCreateTableConvertor = class extends Convertor {
       const onUpdateStatement = onUpdate ? ` ON UPDATE ${onUpdate}` : "";
       const fromColumnsString = columnsFrom.map((it) => `\`${it}\``).join(",");
       const toColumnsString = columnsTo.map((it) => `\`${it}\``).join(",");
+      statement += ",";
       statement += "\n	";
       statement += `FOREIGN KEY (${fromColumnsString}) REFERENCES \`${tableTo}\`(${toColumnsString})${onUpdateStatement}${onDeleteStatement}`;
-      statement += ",";
     }
-    statement = statement.trimChar(",");
+    if (typeof uniqueConstraints !== "undefined" && uniqueConstraints.length > 0) {
+      for (const uniqueConstraint4 of uniqueConstraints) {
+        statement += ",\n";
+        const unsquashedUnique = MySqlSquasher.unsquashUnique(uniqueConstraint4);
+        statement += `	CONSTRAINT ${unsquashedUnique.name} UNIQUE(\`${unsquashedUnique.columns.join(`\`,\``)}\`)`;
+      }
+    }
     statement += `
 `;
     statement += `);`;
@@ -13713,6 +13803,72 @@ var SQLiteCreateTableConvertor = class extends Convertor {
     return statement;
   }
 };
+var PgAlterTableAddUniqueConstraintConvertor = class extends Convertor {
+  can(statement, dialect3) {
+    return statement.type === "create_unique_constraint" && dialect3 === "pg";
+  }
+  convert(statement) {
+    const unsquashed = PgSquasher.unsquashUnique(statement.data);
+    const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${statement.tableName}"` : `"${statement.tableName}"`;
+    return `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${unsquashed.name}" UNIQUE("${unsquashed.columns.join('","')}");`;
+  }
+};
+var PgAlterTableDropUniqueConstraintConvertor = class extends Convertor {
+  can(statement, dialect3) {
+    return statement.type === "delete_unique_constraint" && dialect3 === "pg";
+  }
+  convert(statement) {
+    const unsquashed = PgSquasher.unsquashUnique(statement.data);
+    const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${statement.tableName}"` : `"${statement.tableName}"`;
+    return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${unsquashed.name}";`;
+  }
+};
+var MySQLAlterTableAddUniqueConstraintConvertor = class extends Convertor {
+  can(statement, dialect3) {
+    return statement.type === "create_unique_constraint" && dialect3 === "mysql";
+  }
+  convert(statement) {
+    const unsquashed = MySqlSquasher.unsquashUnique(statement.data);
+    const tableNameWithSchema = statement.schema ? `\`${statement.schema}\`.\`${statement.tableName}\`` : `\`${statement.tableName}\``;
+    return `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT \`${unsquashed.name}\` UNIQUE(\`${unsquashed.columns.join("`,`")}\`);`;
+  }
+};
+var MySQLAlterTableDropUniqueConstraintConvertor = class extends Convertor {
+  can(statement, dialect3) {
+    return statement.type === "delete_unique_constraint" && dialect3 === "mysql";
+  }
+  convert(statement) {
+    const unsquashed = MySqlSquasher.unsquashUnique(statement.data);
+    const tableNameWithSchema = statement.schema ? `\`${statement.schema}\`.\`${statement.tableName}\`` : `\`${statement.tableName}\``;
+    return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT \`${unsquashed.name}\`;`;
+  }
+};
+var SQLiteAlterTableAddUniqueConstraintConvertor = class extends Convertor {
+  can(statement, dialect3) {
+    return statement.type === "create_unique_constraint" && dialect3 === "sqlite";
+  }
+  convert(statement) {
+    return `/*
+ SQLite does not support "Adding unique constraint to an existing table" out of the box, we do not generate automatic migration for that, so it has to be done manually
+ Please refer to: https://www.techonthenet.com/sqlite/unique.php
+
+ Due to that we don't generate migration automatically and it has to be done manually
+*/`;
+  }
+};
+var SQLiteAlterTableDropUniqueConstraintConvertor = class extends Convertor {
+  can(statement, dialect3) {
+    return statement.type === "delete_unique_constraint" && dialect3 === "sqlite";
+  }
+  convert(statement) {
+    return `/*
+ SQLite does not support "Dropping unique constraint from an existing table" out of the box, we do not generate automatic migration for that, so it has to be done manually
+ Please refer to: https://www.techonthenet.com/sqlite/unique.php
+
+ Due to that we don't generate migration automatically and it has to be done manually
+*/`;
+  }
+};
 var CreateTypeEnumConvertor = class extends Convertor {
   can(statement) {
     return statement.type === "create_type_enum";
@@ -14668,6 +14824,10 @@ convertors.push(new PgAlterTableAddColumnConvertor());
 convertors.push(new MySqlAlterTableAddColumnConvertor());
 convertors.push(new SQLiteAlterTableAddColumnConvertor());
 convertors.push(new PgAlterTableAlterColumnSetTypeConvertor());
+convertors.push(new PgAlterTableAddUniqueConstraintConvertor());
+convertors.push(new PgAlterTableDropUniqueConstraintConvertor());
+convertors.push(new MySQLAlterTableAddUniqueConstraintConvertor());
+convertors.push(new MySQLAlterTableDropUniqueConstraintConvertor());
 convertors.push(new CreatePgIndexConvertor());
 convertors.push(new CreateMySqlIndexConvertor());
 convertors.push(new CreateSqliteIndexConvertor());
@@ -14702,6 +14862,8 @@ convertors.push(new SQLiteAlterTableAlterColumnSetTypeConvertor());
 convertors.push(new SqliteAlterForeignKeyConvertor());
 convertors.push(new SqliteDeleteForeignKeyConvertor());
 convertors.push(new SqliteCreateForeignKeyConvertor());
+convertors.push(new SQLiteAlterTableAddUniqueConstraintConvertor());
+convertors.push(new SQLiteAlterTableDropUniqueConstraintConvertor());
 convertors.push(new SqliteAlterTableAlterColumnSetNotNullConvertor());
 convertors.push(new SqliteAlterTableAlterColumnDropNotNullConvertor());
 convertors.push(new SqliteAlterTableAlterColumnSetDefaultConvertor());
@@ -14762,7 +14924,7 @@ init_lib();
 
 // src/jsonStatements.ts
 var preparePgCreateTableJson = (table4, json2) => {
-  const { name, schema: schema4, columns, compositePrimaryKeys } = table4;
+  const { name, schema: schema4, columns, compositePrimaryKeys, uniqueConstraints } = table4;
   return {
     type: "create_table",
     tableName: name,
@@ -14771,11 +14933,12 @@ var preparePgCreateTableJson = (table4, json2) => {
     compositePKs: Object.values(compositePrimaryKeys),
     compositePkName: Object.values(compositePrimaryKeys).length > 0 ? json2.tables[name].compositePrimaryKeys[`${name}_${PgSquasher.unsquashPK(
       Object.values(compositePrimaryKeys)[0]
-    ).columns.join("_")}`].name : ""
+    ).columns.join("_")}`].name : "",
+    uniqueConstraints: Object.values(uniqueConstraints)
   };
 };
 var prepareMySqlCreateTableJson = (table4, json2) => {
-  const { name, schema: schema4, columns, compositePrimaryKeys } = table4;
+  const { name, schema: schema4, columns, compositePrimaryKeys, uniqueConstraints } = table4;
   return {
     type: "create_table",
     tableName: name,
@@ -14784,11 +14947,12 @@ var prepareMySqlCreateTableJson = (table4, json2) => {
     compositePKs: Object.values(compositePrimaryKeys),
     compositePkName: Object.values(compositePrimaryKeys).length > 0 ? json2.tables[name].compositePrimaryKeys[`${name}_${MySqlSquasher.unsquashPK(
       Object.values(compositePrimaryKeys)[0]
-    ).columns.join("_")}`].name : ""
+    ).columns.join("_")}`].name : "",
+    uniqueConstraints: Object.values(uniqueConstraints)
   };
 };
 var prepareSQLiteCreateTable = (table4) => {
-  const { name, columns } = table4;
+  const { name, columns, uniqueConstraints } = table4;
   const references2 = Object.values(table4.foreignKeys);
   const composites = Object.values(table4.compositePrimaryKeys).map(
     (it) => SQLiteSquasher.unsquashPK(it)
@@ -14798,7 +14962,8 @@ var prepareSQLiteCreateTable = (table4) => {
     tableName: name,
     columns: Object.values(columns),
     referenceData: references2,
-    compositePKs: composites
+    compositePKs: composites,
+    uniqueConstraints: Object.values(uniqueConstraints)
   };
 };
 var prepareDropTableJson = (table4) => {
@@ -15269,6 +15434,26 @@ var prepareAlterCompositePrimaryKeyPg = (tableName, schema4, pks, json1, json2)
     };
   });
 };
+var prepareAddUniqueConstraintPg = (tableName, schema4, unqs) => {
+  return Object.values(unqs).map((it) => {
+    return {
+      type: "create_unique_constraint",
+      tableName,
+      data: it,
+      schema: schema4
+    };
+  });
+};
+var prepareDeleteUniqueConstraintPg = (tableName, schema4, unqs) => {
+  return Object.values(unqs).map((it) => {
+    return {
+      type: "delete_unique_constraint",
+      tableName,
+      data: it,
+      schema: schema4
+    };
+  });
+};
 var prepareAddCompositePrimaryKeyMySql = (tableName, pks, json2) => {
   return Object.values(pks).map((it) => {
     return {
@@ -15374,12 +15559,14 @@ var columnSchema = objectType({
   name: stringType(),
   type: stringType(),
   primaryKey: booleanType().optional(),
-  unique: booleanType().optional(),
   default: anyType().optional(),
   notNull: booleanType().optional(),
   // should it be optional? should if be here?
   autoincrement: booleanType().optional(),
-  onUpdate: booleanType().optional()
+  onUpdate: booleanType().optional(),
+  isUnique: anyType().optional(),
+  uniqueName: stringType().optional(),
+  nullsNotDistinct: booleanType().optional()
 }).strict();
 var alteredColumnSchema = objectType({
   name: makeSelfOrChanged(stringType()),
@@ -15405,7 +15592,8 @@ var tableScheme = objectType({
   columns: recordType(stringType(), columnSchema),
   indexes: recordType(stringType(), stringType()),
   foreignKeys: recordType(stringType(), stringType()),
-  compositePrimaryKeys: recordType(stringType(), stringType()).default({})
+  compositePrimaryKeys: recordType(stringType(), stringType()).default({}),
+  uniqueConstraints: recordType(stringType(), stringType()).default({})
 }).strict();
 var alteredTableScheme = objectType({
   name: stringType(),
@@ -15439,6 +15627,15 @@ var alteredTableScheme = objectType({
       __new: stringType(),
       __old: stringType()
     })
+  ),
+  addedUniqueConstraints: recordType(stringType(), stringType()),
+  deletedUniqueConstraints: recordType(stringType(), stringType()),
+  alteredUniqueConstraints: recordType(
+    stringType(),
+    objectType({
+      __new: stringType(),
+      __old: stringType()
+    })
   )
 }).strict();
 var diffResultScheme = objectType({
@@ -15528,13 +15725,19 @@ var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesR
       alteredForeignKeys: table4.alteredForeignKeys,
       addedCompositePKs: table4.addedCompositePKs,
       deletedCompositePKs: table4.deletedCompositePKs,
-      alteredCompositePKs: table4.alteredCompositePKs
+      alteredCompositePKs: table4.alteredCompositePKs,
+      addedUniqueConstraints: table4.addedUniqueConstraints,
+      deletedUniqueConstraints: table4.deletedUniqueConstraints,
+      alteredUniqueConstraints: table4.alteredUniqueConstraints
     };
     allAlteredResolved.push(resolved);
   }
   const jsonAddedCompositePKs = [];
   const jsonDeletedCompositePKs = [];
   const jsonAlteredCompositePKs = [];
+  const jsonAddedUniqueConstraints = [];
+  const jsonDeletedUniqueConstraints = [];
+  const jsonAlteredUniqueConstraints = [];
   const jsonSetTableSchemas = [];
   const jsonRemoveTableFromSchemas = [];
   const jsonSetNewTableSchemas = [];
@@ -15626,6 +15829,33 @@ var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesR
         curFull
       );
     }
+    let addedUniqueConstraints = [];
+    let deletedUniqueConstraints = [];
+    let alteredUniqueConstraints = [];
+    addedUniqueConstraints = prepareAddUniqueConstraintPg(
+      it.name,
+      schemaUnwrapped,
+      it.addedUniqueConstraints
+    );
+    deletedUniqueConstraints = prepareDeleteUniqueConstraintPg(
+      it.name,
+      schemaUnwrapped,
+      it.deletedUniqueConstraints
+    );
+    if (it.alteredUniqueConstraints) {
+      const added = {};
+      const deleted2 = {};
+      for (const k of Object.keys(it.alteredUniqueConstraints)) {
+        added[k] = it.alteredUniqueConstraints[k].__new;
+        deleted2[k] = it.alteredUniqueConstraints[k].__old;
+      }
+      addedUniqueConstraints.push(
+        ...prepareAddUniqueConstraintPg(it.name, schemaUnwrapped, added)
+      );
+      deletedUniqueConstraints.push(
+        ...prepareDeleteUniqueConstraintPg(it.name, schemaUnwrapped, deleted2)
+      );
+    }
     if (it.schema && typeof it.schema !== "string") {
       switch (it.schema.type) {
         case "added": {
@@ -15658,6 +15888,9 @@ var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesR
     jsonAddedCompositePKs.push(...addedCompositePKs);
     jsonDeletedCompositePKs.push(...deletedCompositePKs);
     jsonAlteredCompositePKs.push(...alteredCompositePKs);
+    jsonAddedUniqueConstraints.push(...addedUniqueConstraints);
+    jsonDeletedUniqueConstraints.push(...deletedUniqueConstraints);
+    jsonAlteredUniqueConstraints.push(...alteredUniqueConstraints);
   });
   const rColumns = jsonRenameColumnsStatements.map((it) => {
     const tableName = it.tableName;
@@ -15782,6 +16015,7 @@ var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesR
     jsonStatements.push(...jsonSQLiteCreateTables);
   } else if (dialect3 === "pg") {
     const jsonPgCreateTables = created.map((it) => {
+      console.log(it);
       return preparePgCreateTableJson(it, curFull);
     });
     jsonStatements.push(...jsonPgCreateTables);
@@ -15795,6 +16029,7 @@ var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesR
   jsonStatements.push(...jsonRenameTables);
   jsonStatements.push(...jsonRenameColumnsStatements);
   jsonStatements.push(...jsonDeletedCompositePKs);
+  jsonStatements.push(...jsonDeletedUniqueConstraints);
   jsonStatements.push(...jsonDroppedReferencesForAlteredTables);
   jsonStatements.push(...jsonDropIndexesForAllAlteredTables);
   jsonStatements.push(...jsonTableAlternations.alterColumns);
@@ -15807,6 +16042,8 @@ var applySnapshotsDiff = async (json1, json2, dialect3, schemasResolver, tablesR
     jsonStatements.push(...jsonCreateReferences);
   jsonStatements.push(...jsonAddedCompositePKs);
   jsonStatements.push(...jsonAlteredCompositePKs);
+  jsonStatements.push(...jsonAddedUniqueConstraints);
+  jsonStatements.push(...jsonAlteredUniqueConstraints);
   jsonStatements.push(...jsonSetTableSchemas);
   jsonStatements.push(...filteredJsonSetNewTableSchemas);
   jsonStatements.push(...jsonRemoveTableFromSchemas);