drizzle-kit 0.21.1-ce37d6c → 0.21.2-1ddc155

package/utils-studio.js

@@ -569,7 +569,7 @@ var init_global = __esm({
   "src/global.ts"() {
     "use strict";
     originUUID = "00000000-0000-0000-0000-000000000000";
-    snapshotVersion = "6";
+    snapshotVersion = "7";
   }
 });
 
@@ -4498,7 +4498,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";
@@ -4566,10 +4566,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(),
@@ -4611,9 +4649,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(),
@@ -4658,7 +4714,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({
@@ -4668,6 +4724,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"),
@@ -4681,7 +4750,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),
@@ -4716,18 +4785,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",
@@ -5639,7 +5720,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,
@@ -5650,15 +5734,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  DISTINCT ON (t.relname, ic.relname, k.i) 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
@@ -5675,18 +5786,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
                 };
               }
             }
@@ -5722,7 +5866,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,

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",
@@ -5648,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,
@@ -5659,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  DISTINCT ON (t.relname, ic.relname, k.i) 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
@@ -5684,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
                 };
               }
             }
@@ -5731,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,