drizzle-kit 0.21.2-ae19ee7 → 0.21.2-cf9fe8d

package/utils-studio.mjs

@@ -570,7 +570,7 @@ var init_global = __esm({
   "src/global.ts"() {
     "use strict";
     originUUID = "00000000-0000-0000-0000-000000000000";
-    snapshotVersion = "6";
+    snapshotVersion = "7";
   }
 });
 
@@ -4499,7 +4499,7 @@ var init_mysqlSchema = __esm({
 });
 
 // src/serializer/pgSchema.ts
-var indexV2, columnV2, tableV2, enumSchemaV1, 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, pgSchema2, backwardCompatiblePgSchema, dryPg;
+var indexV2, columnV2, tableV2, enumSchemaV1, enumSchema, pgSchemaV2, references, columnV1, tableV1, pgSchemaV1, indexColumn, index2, indexV4, indexV5, indexV6, fk2, column2, tableV32, compositePK2, uniqueConstraint2, tableV42, tableV6, tableV5, table2, schemaHash2, kitInternals2, pgSchemaInternalV3, pgSchemaInternalV4, pgSchemaInternalV5, pgSchemaInternalV6, pgSchemaExternal, pgSchemaInternal, tableSquashed2, tableSquashedV42, pgSchemaSquashedV4, pgSchemaSquashedV6, pgSchemaSquashed, pgSchemaV3, pgSchemaV4, pgSchemaV5, pgSchemaV6, pgSchema2, backwardCompatiblePgSchema, dryPg;
 var init_pgSchema = __esm({
   "src/serializer/pgSchema.ts"() {
     "use strict";
@@ -4567,10 +4567,48 @@ var init_pgSchema = __esm({
       tables: recordType(stringType(), tableV1),
       enums: recordType(stringType(), enumSchemaV1)
     }).strict();
+    indexColumn = objectType({
+      expression: stringType(),
+      isExpression: booleanType(),
+      asc: booleanType(),
+      nulls: stringType().optional(),
+      opclass: stringType().optional()
+    });
     index2 = objectType({
+      name: stringType(),
+      columns: indexColumn.array(),
+      isUnique: booleanType(),
+      with: recordType(stringType(), anyType()).optional(),
+      method: stringType().default("btree"),
+      where: stringType().optional(),
+      concurrently: booleanType().default(false)
+    }).strict();
+    indexV4 = objectType({
       name: stringType(),
       columns: stringType().array(),
-      isUnique: booleanType()
+      isUnique: booleanType(),
+      with: recordType(stringType(), stringType()).optional(),
+      method: stringType().default("btree"),
+      where: stringType().optional(),
+      concurrently: booleanType().default(false)
+    }).strict();
+    indexV5 = objectType({
+      name: stringType(),
+      columns: stringType().array(),
+      isUnique: booleanType(),
+      with: recordType(stringType(), stringType()).optional(),
+      method: stringType().default("btree"),
+      where: stringType().optional(),
+      concurrently: booleanType().default(false)
+    }).strict();
+    indexV6 = objectType({
+      name: stringType(),
+      columns: stringType().array(),
+      isUnique: booleanType(),
+      with: recordType(stringType(), stringType()).optional(),
+      method: stringType().default("btree"),
+      where: stringType().optional(),
+      concurrently: booleanType().default(false)
     }).strict();
     fk2 = objectType({
       name: stringType(),
@@ -4612,9 +4650,27 @@ var init_pgSchema = __esm({
       name: stringType(),
       schema: stringType(),
       columns: recordType(stringType(), column2),
-      indexes: recordType(stringType(), index2),
+      indexes: recordType(stringType(), indexV4),
       foreignKeys: recordType(stringType(), fk2)
     }).strict();
+    tableV6 = objectType({
+      name: stringType(),
+      schema: stringType(),
+      columns: recordType(stringType(), column2),
+      indexes: recordType(stringType(), indexV6),
+      foreignKeys: recordType(stringType(), fk2),
+      compositePrimaryKeys: recordType(stringType(), compositePK2),
+      uniqueConstraints: recordType(stringType(), uniqueConstraint2).default({})
+    }).strict();
+    tableV5 = objectType({
+      name: stringType(),
+      schema: stringType(),
+      columns: recordType(stringType(), column2),
+      indexes: recordType(stringType(), indexV5),
+      foreignKeys: recordType(stringType(), fk2),
+      compositePrimaryKeys: recordType(stringType(), compositePK2),
+      uniqueConstraints: recordType(stringType(), uniqueConstraint2).default({})
+    }).strict();
     table2 = objectType({
       name: stringType(),
       schema: stringType(),
@@ -4659,7 +4715,7 @@ var init_pgSchema = __esm({
     pgSchemaInternalV5 = objectType({
       version: literalType("5"),
       dialect: literalType("pg"),
-      tables: recordType(stringType(), table2),
+      tables: recordType(stringType(), tableV5),
       enums: recordType(stringType(), enumSchemaV1),
       schemas: recordType(stringType(), stringType()),
       _meta: objectType({
@@ -4669,6 +4725,19 @@ var init_pgSchema = __esm({
       }),
       internal: kitInternals2
     }).strict();
+    pgSchemaInternalV6 = objectType({
+      version: literalType("6"),
+      dialect: literalType("postgresql"),
+      tables: recordType(stringType(), tableV6),
+      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"),
@@ -4682,7 +4751,7 @@ var init_pgSchema = __esm({
       })
     }).strict();
     pgSchemaInternal = objectType({
-      version: literalType("6"),
+      version: literalType("7"),
       dialect: literalType("postgresql"),
       tables: recordType(stringType(), table2),
       enums: recordType(stringType(), enumSchema),
@@ -4717,18 +4786,30 @@ var init_pgSchema = __esm({
       enums: recordType(stringType(), enumSchemaV1),
       schemas: recordType(stringType(), stringType())
     }).strict();
-    pgSchemaSquashed = objectType({
+    pgSchemaSquashedV6 = objectType({
       version: literalType("6"),
       dialect: literalType("postgresql"),
       tables: recordType(stringType(), tableSquashed2),
       enums: recordType(stringType(), enumSchema),
       schemas: recordType(stringType(), stringType())
     }).strict();
+    pgSchemaSquashed = objectType({
+      version: literalType("7"),
+      dialect: literalType("postgresql"),
+      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);
+    pgSchemaV6 = pgSchemaInternalV6.merge(schemaHash2);
     pgSchema2 = pgSchemaInternal.merge(schemaHash2);
-    backwardCompatiblePgSchema = unionType([pgSchemaV5, pgSchema2]);
+    backwardCompatiblePgSchema = unionType([
+      pgSchemaV5,
+      pgSchemaV6,
+      pgSchema2
+    ]);
     dryPg = pgSchema2.parse({
       version: snapshotVersion,
       dialect: "postgresql",
@@ -4971,24 +5052,12 @@ var init_sqliteSerializer = __esm({
         `SELECT 
     m.name as "tableName", p.name as "columnName", p.type as "columnType", p."notnull" as "notNull", p.dflt_value as "defaultValue", p.pk as pk
     FROM sqlite_master AS m JOIN pragma_table_info(m.name) AS p
-    WHERE m.type = 'table' 
-    and m.tbl_name != 'sqlite_sequence' 
-    and m.tbl_name != 'sqlite_stat1' 
-    and m.tbl_name != '_litestream_seq' 
-    and m.tbl_name != '_litestream_lock' 
-    and m.tbl_name != 'libsql_wasm_func_table' 
-    and m.tbl_name != '__drizzle_migrations' 
-    and m.tbl_name != '_cf_KV';
+    WHERE m.type = 'table' and m.tbl_name != 'sqlite_sequence' and m.tbl_name != 'sqlite_stat1' and m.tbl_name != '_litestream_seq' and m.tbl_name != '_litestream_lock' and m.tbl_name != 'libsql_wasm_func_table' and m.tbl_name != '__drizzle_migrations';
     `
       );
       const tablesWithSeq = [];
       const seq = await db.query(
-        `SELECT * FROM sqlite_master WHERE name != 'sqlite_sequence' 
-    and name != 'sqlite_stat1' 
-    and name != '_litestream_seq' 
-    and name != '_litestream_lock' 
-    and tbl_name != '_cf_KV' 
-    and sql GLOB '*[ *' || CHAR(9) || CHAR(10) || CHAR(13) || ']AUTOINCREMENT[^'']*';`
+        `SELECT * FROM sqlite_master WHERE name != 'sqlite_sequence' and name != 'sqlite_stat1' and name != '_litestream_seq' and name != '_litestream_lock' and sql GLOB '*[ *' || CHAR(9) || CHAR(10) || CHAR(13) || ']AUTOINCREMENT[^'']*';`
       );
       for (const s of seq) {
         tablesWithSeq.push(s.name);
@@ -5073,8 +5142,7 @@ var init_sqliteSerializer = __esm({
       try {
         const fks = await db.query(
           `SELECT m.name as "tableFrom", f.id as "id", f."table" as "tableTo", f."from", f."to", f."on_update" as "onUpdate", f."on_delete" as "onDelete", f.seq as "seq"
-      FROM sqlite_master m, pragma_foreign_key_list(m.name) as f 
-      where m.tbl_name != '_cf_KV';`
+      FROM sqlite_master m, pragma_foreign_key_list(m.name) as f;`
         );
         const fkByTableName = {};
         for (const fkRow of fks) {
@@ -5133,9 +5201,7 @@ FROM sqlite_master AS m,
     pragma_index_list(m.name) AS il,
     pragma_index_info(il.name) AS ii
 WHERE 
-    m.type = 'table' 
-    and il.name NOT LIKE 'sqlite_autoindex_%'
-    and m.tbl_name != '_cf_KV';`
+    m.type = 'table' and il.name NOT LIKE 'sqlite_autoindex_%';`
       );
       for (const idxRow of idxs) {
         const tableName = idxRow.tableName;
@@ -5663,7 +5729,10 @@ var init_pgSerializer = __esm({
               columnTypeMapped = trimChar(columnTypeMapped, '"');
               columnToReturn[columnName] = {
                 name: columnName,
-                type: columnAdditionalDT === "USER-DEFINED" ? enumType3 : columnTypeMapped,
+                type: (
+                  // filter vectors, but in future we should filter any extension that was installed by user
+                  columnAdditionalDT === "USER-DEFINED" && enumType3 !== "vector" ? enumType3 : columnTypeMapped
+                ),
                 typeSchema: enumsToReturn[`${tableSchema}.${enumType3}`] !== void 0 ? enumsToReturn[`${tableSchema}.${enumType3}`].schema : void 0,
                 primaryKey: primaryKey.length === 1 && cprimaryKey.length < 2,
                 // default: isSerial ? undefined : defaultValue,
@@ -5674,15 +5743,42 @@ var init_pgSerializer = __esm({
               }
             }
             const dbIndexes = await db.query(
-              `SELECT t.relname as table_name, i.relname AS index_name, ix.indisunique AS is_unique, a.attname AS column_name
-          FROM pg_class t
-          JOIN pg_index ix ON t.oid = ix.indrelid
-          JOIN pg_class i ON i.oid = ix.indexrelid
-          JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
-          JOIN pg_namespace ns ON ns.oid = t.relnamespace
-          WHERE ns.nspname = '${tableSchema}'
-            AND t.relname = '${tableName}'
-            and ix.indisprimary = false;`
+              `SELECT  t.relname as table_name, ic.relname AS indexname,
+        k.i AS index_order,
+        i.indisunique as is_unique,
+        am.amname as method,
+        ic.reloptions as with,
+        coalesce(a.attname,
+                  (('{' || pg_get_expr(
+                              i.indexprs,
+                              i.indrelid
+                          )
+                        || '}')::text[]
+                  )[k.i]
+                ) AS column_name,
+          CASE
+        WHEN pg_get_expr(i.indexprs, i.indrelid) IS NOT NULL THEN 1
+        ELSE 0
+    END AS is_expression,
+        i.indoption[k.i-1] & 1 = 1 AS descending,
+        i.indoption[k.i-1] & 2 = 2 AS nulls_first,
+        pg_get_expr(
+                              i.indpred,
+                              i.indrelid
+                          ) as where,
+         opc.opcname
+      FROM pg_class t
+          LEFT JOIN pg_index i ON t.oid = i.indrelid
+          LEFT JOIN pg_class ic ON ic.oid = i.indexrelid
+		  CROSS JOIN LATERAL (SELECT unnest(i.indkey), generate_subscripts(i.indkey, 1) + 1) AS k(attnum, i)
+          LEFT JOIN pg_attribute AS a
+            ON i.indrelid = a.attrelid AND k.attnum = a.attnum
+          JOIN pg_namespace c on c.oid = t.relnamespace
+        LEFT JOIN pg_am AS am ON ic.relam = am.oid
+        JOIN pg_opclass opc ON opc.oid = ANY(i.indclass)
+      WHERE
+      c.nspname = '${tableSchema}' AND
+      t.relname = '${tableName}';`
             );
             const dbIndexFromConstraint = await db.query(
               `SELECT
@@ -5699,18 +5795,51 @@ var init_pgSerializer = __esm({
             );
             const idxsInConsteraint = dbIndexFromConstraint.filter((it) => it.generated_by_constraint === 1).map((it) => it.index_name);
             for (const dbIndex of dbIndexes) {
-              const indexName = dbIndex.index_name;
+              const indexName = dbIndex.indexname;
               const indexColumnName = dbIndex.column_name;
               const indexIsUnique = dbIndex.is_unique;
+              const indexMethod = dbIndex.method;
+              const indexWith = dbIndex.with;
+              const indexWhere = dbIndex.where;
+              const opclass = dbIndex.opcname;
+              const isExpression = dbIndex.is_expression === 1;
+              const desc = dbIndex.descending;
+              const nullsFirst = dbIndex.nulls_first;
+              const mappedWith = {};
+              if (indexWith !== null) {
+                indexWith.forEach((it) => {
+                  const splitted = it.split("=");
+                  mappedWith[splitted[0]] = splitted[1];
+                });
+              }
               if (idxsInConsteraint.includes(indexName))
                 continue;
               if (typeof indexToReturn[indexName] !== "undefined") {
-                indexToReturn[indexName].columns.push(indexColumnName);
+                indexToReturn[indexName].columns.push({
+                  expression: indexColumnName,
+                  asc: !desc,
+                  nulls: nullsFirst ? "first" : "last",
+                  opclass,
+                  isExpression
+                });
               } else {
                 indexToReturn[indexName] = {
                   name: indexName,
-                  columns: [indexColumnName],
-                  isUnique: indexIsUnique
+                  columns: [
+                    {
+                      expression: indexColumnName,
+                      asc: !desc,
+                      nulls: nullsFirst ? "first" : "last",
+                      opclass,
+                      isExpression
+                    }
+                  ],
+                  isUnique: indexIsUnique,
+                  // should not be a part of diff detecs
+                  concurrently: false,
+                  method: indexMethod,
+                  where: indexWhere === null ? void 0 : indexWhere,
+                  with: mappedWith
                 };
               }
             }
@@ -5746,7 +5875,7 @@ var init_pgSerializer = __esm({
       }
       const schemasObject = Object.fromEntries([...schemas].map((it) => [it, it]));
       return {
-        version: "6",
+        version: "7",
         dialect: "postgresql",
         tables: result,
         enums: enumsToReturn,
@@ -5768,7 +5897,6 @@ var init_pgSerializer = __esm({
       "time without time zone": "::time without time zone",
       // "timestamp with time zone": "::timestamp with time zone",
       "timestamp without time zone": "::timestamp without time zone",
-      "timestamp(": "::timestamp without time zone",
       // date: "::date",
       // interval: "::interval",
       // character: "::bpchar",
@@ -5781,15 +5909,15 @@ var init_pgSerializer = __esm({
       "character(": "::bpchar"
     };
     defaultForColumn = (column4) => {
-      if (column4.column_default === null) {
-        return void 0;
-      }
       if (column4.data_type === "serial" || column4.data_type === "smallserial" || column4.data_type === "bigserial") {
         return void 0;
       }
       const hasDifferentDefaultCast = Object.keys(columnToDefault).find(
         (it) => column4.data_type.startsWith(it)
       );
+      if (column4.column_default === null) {
+        return void 0;
+      }
       const columnDefaultAsString = column4.column_default.toString();
       if (columnDefaultAsString.endsWith(
         hasDifferentDefaultCast ? columnToDefault[hasDifferentDefaultCast] : column4.data_type

package/utils.js

@@ -1077,7 +1077,7 @@ var info = (msg, greyMsg = "") => {
 
 // src/global.ts
 var originUUID = "00000000-0000-0000-0000-000000000000";
-var snapshotVersion = "6";
+var snapshotVersion = "7";
 
 // node_modules/.pnpm/zod@3.23.8/node_modules/zod/lib/index.mjs
 var util;
@@ -5060,10 +5060,48 @@ var pgSchemaV1 = objectType({
   tables: recordType(stringType(), tableV1),
   enums: recordType(stringType(), enumSchemaV1)
 }).strict();
+var indexColumn = objectType({
+  expression: stringType(),
+  isExpression: booleanType(),
+  asc: booleanType(),
+  nulls: stringType().optional(),
+  opclass: stringType().optional()
+});
 var index2 = objectType({
+  name: stringType(),
+  columns: indexColumn.array(),
+  isUnique: booleanType(),
+  with: recordType(stringType(), anyType()).optional(),
+  method: stringType().default("btree"),
+  where: stringType().optional(),
+  concurrently: booleanType().default(false)
+}).strict();
+var indexV4 = objectType({
   name: stringType(),
   columns: stringType().array(),
-  isUnique: booleanType()
+  isUnique: booleanType(),
+  with: recordType(stringType(), stringType()).optional(),
+  method: stringType().default("btree"),
+  where: stringType().optional(),
+  concurrently: booleanType().default(false)
+}).strict();
+var indexV5 = objectType({
+  name: stringType(),
+  columns: stringType().array(),
+  isUnique: booleanType(),
+  with: recordType(stringType(), stringType()).optional(),
+  method: stringType().default("btree"),
+  where: stringType().optional(),
+  concurrently: booleanType().default(false)
+}).strict();
+var indexV6 = objectType({
+  name: stringType(),
+  columns: stringType().array(),
+  isUnique: booleanType(),
+  with: recordType(stringType(), stringType()).optional(),
+  method: stringType().default("btree"),
+  where: stringType().optional(),
+  concurrently: booleanType().default(false)
 }).strict();
 var fk2 = objectType({
   name: stringType(),
@@ -5105,9 +5143,27 @@ var tableV42 = objectType({
   name: stringType(),
   schema: stringType(),
   columns: recordType(stringType(), column2),
-  indexes: recordType(stringType(), index2),
+  indexes: recordType(stringType(), indexV4),
   foreignKeys: recordType(stringType(), fk2)
 }).strict();
+var tableV6 = objectType({
+  name: stringType(),
+  schema: stringType(),
+  columns: recordType(stringType(), column2),
+  indexes: recordType(stringType(), indexV6),
+  foreignKeys: recordType(stringType(), fk2),
+  compositePrimaryKeys: recordType(stringType(), compositePK2),
+  uniqueConstraints: recordType(stringType(), uniqueConstraint2).default({})
+}).strict();
+var tableV5 = objectType({
+  name: stringType(),
+  schema: stringType(),
+  columns: recordType(stringType(), column2),
+  indexes: recordType(stringType(), indexV5),
+  foreignKeys: recordType(stringType(), fk2),
+  compositePrimaryKeys: recordType(stringType(), compositePK2),
+  uniqueConstraints: recordType(stringType(), uniqueConstraint2).default({})
+}).strict();
 var table2 = objectType({
   name: stringType(),
   schema: stringType(),
@@ -5152,7 +5208,7 @@ var pgSchemaInternalV4 = objectType({
 var pgSchemaInternalV5 = objectType({
   version: literalType("5"),
   dialect: literalType("pg"),
-  tables: recordType(stringType(), table2),
+  tables: recordType(stringType(), tableV5),
   enums: recordType(stringType(), enumSchemaV1),
   schemas: recordType(stringType(), stringType()),
   _meta: objectType({
@@ -5162,6 +5218,19 @@ var pgSchemaInternalV5 = objectType({
   }),
   internal: kitInternals2
 }).strict();
+var pgSchemaInternalV6 = objectType({
+  version: literalType("6"),
+  dialect: literalType("postgresql"),
+  tables: recordType(stringType(), tableV6),
+  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 pgSchemaExternal = objectType({
   version: literalType("5"),
   dialect: literalType("pg"),
@@ -5175,7 +5244,7 @@ var pgSchemaExternal = objectType({
   })
 }).strict();
 var pgSchemaInternal = objectType({
-  version: literalType("6"),
+  version: literalType("7"),
   dialect: literalType("postgresql"),
   tables: recordType(stringType(), table2),
   enums: recordType(stringType(), enumSchema),
@@ -5210,18 +5279,30 @@ var pgSchemaSquashedV4 = objectType({
   enums: recordType(stringType(), enumSchemaV1),
   schemas: recordType(stringType(), stringType())
 }).strict();
-var pgSchemaSquashed = objectType({
+var pgSchemaSquashedV6 = objectType({
   version: literalType("6"),
   dialect: literalType("postgresql"),
   tables: recordType(stringType(), tableSquashed2),
   enums: recordType(stringType(), enumSchema),
   schemas: recordType(stringType(), stringType())
 }).strict();
+var pgSchemaSquashed = objectType({
+  version: literalType("7"),
+  dialect: literalType("postgresql"),
+  tables: recordType(stringType(), tableSquashed2),
+  enums: recordType(stringType(), enumSchema),
+  schemas: recordType(stringType(), stringType())
+}).strict();
 var pgSchemaV3 = pgSchemaInternalV3.merge(schemaHash2);
 var pgSchemaV4 = pgSchemaInternalV4.merge(schemaHash2);
 var pgSchemaV5 = pgSchemaInternalV5.merge(schemaHash2);
+var pgSchemaV6 = pgSchemaInternalV6.merge(schemaHash2);
 var pgSchema = pgSchemaInternal.merge(schemaHash2);
-var backwardCompatiblePgSchema = unionType([pgSchemaV5, pgSchema]);
+var backwardCompatiblePgSchema = unionType([
+  pgSchemaV5,
+  pgSchemaV6,
+  pgSchema
+]);
 var dryPg = pgSchema.parse({
   version: snapshotVersion,
   dialect: "postgresql",
@@ -5399,7 +5480,7 @@ var prepareOutFolder = (out, dialect3) => {
 var validatorForDialect = (dialect3) => {
   switch (dialect3) {
     case "postgresql":
-      return { validator: backwardCompatiblePgSchema, version: 6 };
+      return { validator: backwardCompatiblePgSchema, version: 7 };
     case "sqlite":
       return { validator: backwardCompatibleSqliteSchema, version: 6 };
     case "mysql":
@@ -5422,6 +5503,7 @@ var validateWithReport = (snapshots, dialect3) => {
       }
       const result2 = validator.safeParse(raw);
       if (!result2.success) {
+        console.error(result2.error);
         accum.malformed.push(it);
         return accum;
       }