drizzle-kit 0.21.4 → 0.22.0-18d9643

package/utils-studio.mjs

@@ -1080,7 +1080,7 @@ var init_global = __esm({
   "src/global.ts"() {
     "use strict";
     originUUID = "00000000-0000-0000-0000-000000000000";
-    snapshotVersion = "6";
+    snapshotVersion = "7";
   }
 });
 
@@ -4849,7 +4849,7 @@ var init_lib = __esm({
 });
 
 // src/serializer/mysqlSchema.ts
-var index, fk, column, tableV3, compositePK, uniqueConstraint, tableV4, table, kitInternals, dialect, schemaHash, schemaInternalV3, schemaInternalV4, schemaInternalV5, schemaInternal, schemaV3, schemaV4, schemaV5, schema, tableSquashedV4, tableSquashed, schemaSquashed, schemaSquashedV4, mysqlSchema, mysqlSchemaV5, backwardCompatibleMysqlSchema, dryMySql;
+var index, fk, column, tableV3, compositePK, uniqueConstraint, tableV4, table, kitInternals, dialect, schemaHash, schemaInternalV3, schemaInternalV4, schemaInternalV5, schemaInternal, schemaV3, schemaV4, schemaV5, schema, tableSquashedV4, tableSquashed, schemaSquashed, schemaSquashedV4, mysqlSchema, mysqlSchemaV5, mysqlSchemaSquashed, backwardCompatibleMysqlSchema, dryMySql;
 var init_mysqlSchema = __esm({
   "src/serializer/mysqlSchema.ts"() {
     "use strict";
@@ -4919,7 +4919,16 @@ var init_mysqlSchema = __esm({
             objectType({ isDefaultAnExpression: booleanType().optional() }).optional()
           )
         }).optional()
-      )
+      ).optional(),
+      indexes: recordType(
+        stringType(),
+        objectType({
+          columns: recordType(
+            stringType(),
+            objectType({ isExpression: booleanType().optional() }).optional()
+          )
+        }).optional()
+      ).optional()
     }).optional();
     dialect = literalType("mysql");
     schemaHash = objectType({
@@ -4991,6 +5000,7 @@ var init_mysqlSchema = __esm({
     }).strict();
     mysqlSchema = schema;
     mysqlSchemaV5 = schemaV5;
+    mysqlSchemaSquashed = schemaSquashed;
     backwardCompatibleMysqlSchema = unionType([mysqlSchemaV5, schema]);
     dryMySql = mysqlSchema.parse({
       version: "5",
@@ -5009,7 +5019,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";
@@ -5077,10 +5087,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(),
@@ -5122,9 +5170,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(),
@@ -5169,7 +5235,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({
@@ -5179,6 +5245,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"),
@@ -5192,7 +5271,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),
@@ -5227,18 +5306,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",
@@ -5257,7 +5348,7 @@ var init_pgSchema = __esm({
 });
 
 // src/serializer/sqliteSchema.ts
-var index3, fk3, compositePK3, column3, tableV33, uniqueConstraint3, table3, dialect2, schemaHash3, schemaInternalV32, schemaInternalV42, schemaInternalV52, latestVersion, schemaInternal2, schemaV32, schemaV42, schemaV52, schema2, tableSquashed3, schemaSquashed2, drySQLite, sqliteSchemaV5, backwardCompatibleSqliteSchema;
+var index3, fk3, compositePK3, column3, tableV33, uniqueConstraint3, table3, dialect2, schemaHash3, schemaInternalV32, schemaInternalV42, schemaInternalV52, kitInternals3, latestVersion, schemaInternal2, schemaV32, schemaV42, schemaV52, schema2, tableSquashed3, schemaSquashed2, drySQLite, sqliteSchemaV5, sqliteSchema, SQLiteSchemaSquashed, backwardCompatibleSqliteSchema;
 var init_sqliteSchema = __esm({
   "src/serializer/sqliteSchema.ts"() {
     "use strict";
@@ -5335,6 +5426,17 @@ var init_sqliteSchema = __esm({
         columns: recordType(stringType(), stringType())
       })
     }).strict();
+    kitInternals3 = objectType({
+      indexes: recordType(
+        stringType(),
+        objectType({
+          columns: recordType(
+            stringType(),
+            objectType({ isExpression: booleanType().optional() }).optional()
+          )
+        }).optional()
+      ).optional()
+    }).optional();
     latestVersion = literalType("6");
     schemaInternal2 = objectType({
       version: latestVersion,
@@ -5344,7 +5446,8 @@ var init_sqliteSchema = __esm({
       _meta: objectType({
         tables: recordType(stringType(), stringType()),
         columns: recordType(stringType(), stringType())
-      })
+      }),
+      internal: kitInternals3
     }).strict();
     schemaV32 = schemaInternalV32.merge(schemaHash3).strict();
     schemaV42 = schemaInternalV42.merge(schemaHash3).strict();
@@ -5377,6 +5480,8 @@ var init_sqliteSchema = __esm({
       }
     });
     sqliteSchemaV5 = schemaV52;
+    sqliteSchema = schema2;
+    SQLiteSchemaSquashed = schemaSquashed2;
     backwardCompatibleSqliteSchema = unionType([sqliteSchemaV5, schema2]);
   }
 });
@@ -5449,10 +5554,100 @@ var init_serializer = __esm({
   }
 });
 
+// src/schemaValidator.ts
+var dialect3, commonSquashedSchema, commonSchema;
+var init_schemaValidator = __esm({
+  "src/schemaValidator.ts"() {
+    "use strict";
+    init_lib();
+    init_mysqlSchema();
+    init_pgSchema();
+    init_sqliteSchema();
+    dialect3 = enumType(["postgresql", "mysql", "sqlite"]);
+    commonSquashedSchema = unionType([
+      pgSchemaSquashed,
+      mysqlSchemaSquashed,
+      SQLiteSchemaSquashed
+    ]);
+    commonSchema = unionType([
+      pgSchema2,
+      mysqlSchema,
+      sqliteSchema
+    ]);
+  }
+});
+
+// src/cli/validations/common.ts
+var sqliteDriversLiterals, sqliteDriver, postgresDriver, mysqlDriver, driver, configCommonSchema, casing, introspectParams, configIntrospectCliSchema, configGenerateSchema, configPushSchema;
+var init_common = __esm({
+  "src/cli/validations/common.ts"() {
+    "use strict";
+    init_outputs();
+    init_lib();
+    init_schemaValidator();
+    sqliteDriversLiterals = [
+      literalType("turso"),
+      literalType("d1-http"),
+      literalType("expo")
+    ];
+    sqliteDriver = unionType(sqliteDriversLiterals);
+    postgresDriver = literalType("aws-data-api");
+    mysqlDriver = literalType("mysql2");
+    driver = unionType([sqliteDriver, postgresDriver, mysqlDriver]);
+    configCommonSchema = objectType({
+      dialect: dialect3,
+      schema: unionType([stringType(), stringType().array()]).optional(),
+      out: stringType().optional(),
+      breakpoints: booleanType().optional().default(true),
+      driver: driver.optional(),
+      tablesFilter: unionType([stringType(), stringType().array()]).optional(),
+      schemaFilter: unionType([stringType(), stringType().array()]).default(["public"])
+    });
+    casing = unionType([literalType("camel"), literalType("preserve")]).default(
+      "preserve"
+    );
+    introspectParams = objectType({
+      schema: unionType([stringType(), stringType().array()]).optional(),
+      out: stringType().optional().default("./drizzle"),
+      breakpoints: booleanType().default(true),
+      tablesFilter: unionType([stringType(), stringType().array()]).optional(),
+      schemaFilter: unionType([stringType(), stringType().array()]).default(["public"]),
+      introspect: objectType({
+        casing
+      }).default({ casing: "camel" })
+    });
+    configIntrospectCliSchema = objectType({
+      schema: unionType([stringType(), stringType().array()]).optional(),
+      out: stringType().optional().default("./drizzle"),
+      breakpoints: booleanType().default(true),
+      tablesFilter: unionType([stringType(), stringType().array()]).optional(),
+      schemaFilter: unionType([stringType(), stringType().array()]).default(["public"]),
+      introspectCasing: unionType([literalType("camel"), literalType("preserve")]).default(
+        "camel"
+      )
+    });
+    configGenerateSchema = objectType({
+      schema: unionType([stringType(), stringType().array()]),
+      out: stringType().optional().default("./drizzle"),
+      breakpoints: booleanType().default(true)
+    });
+    configPushSchema = objectType({
+      dialect: dialect3,
+      schema: unionType([stringType(), stringType().array()]),
+      tablesFilter: unionType([stringType(), stringType().array()]).optional(),
+      schemaFilter: unionType([stringType(), stringType().array()]).default(["public"]),
+      verbose: booleanType().default(false),
+      strict: booleanType().default(false),
+      out: stringType().optional()
+    });
+  }
+});
+
 // src/cli/validations/outputs.ts
 var init_outputs = __esm({
   "src/cli/validations/outputs.ts"() {
     "use strict";
+    init_common();
   }
 });
 
@@ -5505,13 +5700,13 @@ function mapSqlToSqliteType(sqlType) {
     return "numeric";
   }
 }
-var dialect3, fromDatabase;
+var dialect4, fromDatabase;
 var init_sqliteSerializer = __esm({
   "src/serializer/sqliteSerializer.ts"() {
     "use strict";
     init_serializer();
     init_outputs();
-    dialect3 = new SQLiteSyncDialect();
+    dialect4 = new SQLiteSyncDialect();
     fromDatabase = async (db, tablesFilter = (table4) => true, progressCallback) => {
       const result = {};
       const columns = await db.query(
@@ -5935,6 +6130,13 @@ var require_brace_expansion = __commonJS({
   }
 });
 
+// src/extensions/vector.ts
+var init_vector = __esm({
+  "src/extensions/vector.ts"() {
+    "use strict";
+  }
+});
+
 // src/serializer/pgSerializer.ts
 import {
   PgDialect,
@@ -5943,13 +6145,14 @@ import {
 } from "drizzle-orm/pg-core";
 import { getTableConfig as getTableConfig2 } from "drizzle-orm/pg-core";
 import { is as is2, SQL as SQL2, getTableName as getTableName2 } from "drizzle-orm";
-var dialect4, trimChar, fromDatabase2, columnToDefault, defaultForColumn;
+var dialect5, trimChar, fromDatabase2, columnToDefault, defaultForColumn;
 var init_pgSerializer = __esm({
   "src/serializer/pgSerializer.ts"() {
     "use strict";
     init_serializer();
     init_outputs();
-    dialect4 = new PgDialect();
+    init_vector();
+    dialect5 = new PgDialect();
     trimChar = (str, char) => {
       let start = 0;
       let end = str.length;
@@ -6210,7 +6413,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" && !["vector", "geometry"].includes(enumType3) ? 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,
@@ -6221,15 +6427,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
@@ -6246,18 +6479,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
                 };
               }
             }
@@ -6293,7 +6559,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,