@vibeorm/migrate 1.1.4 → 1.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibeorm/migrate",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "Migration, introspection, and schema diff toolkit for VibeORM",
   "license": "MIT",
   "keywords": [
@@ -37,6 +37,6 @@
     "bun": ">=1.1.0"
   },
   "dependencies": {
-    "@vibeorm/parser": "1.1.4"
+    "@vibeorm/parser": "1.1.5"
   }
 }

package/src/ddl-builder.ts

@@ -37,9 +37,9 @@ function resolveColumnType(params: { field: ScalarField }): string {
     return field.prismaType === "BigInt" ? "BIGSERIAL" : "SERIAL";
   }
 
-  // Native type override (e.g., @db.VarChar(255))
+  // Native type override (e.g., @db.VarChar(255)) — lowercased to canonical PG form
   if (field.nativeType) {
-    return field.nativeType;
+    return field.nativeType.toLowerCase();
   }
 
   // List fields use PostgreSQL arrays
@@ -53,7 +53,7 @@ function resolveColumnType(params: { field: ScalarField }): string {
 /** Resolve to the base column type (no SERIAL — used for FK reference columns) */
 function resolveBaseColumnType(params: { field: ScalarField }): string {
   const { field } = params;
-  if (field.nativeType) return field.nativeType;
+  if (field.nativeType) return field.nativeType.toLowerCase();
   if (field.isList) return `${PRISMA_TO_PG[field.prismaType]}[]`;
   return PRISMA_TO_PG[field.prismaType];
 }

package/src/schema-differ.ts

@@ -77,7 +77,7 @@ function resolveColumnType(params: { field: ScalarField | EnumField; enums: Enum
   if (field.default?.kind === "autoincrement") {
     return field.prismaType === "BigInt" ? "BIGSERIAL" : "SERIAL";
   }
-  if (field.nativeType) return field.nativeType;
+  if (field.nativeType) return field.nativeType.toLowerCase();
   if (field.isList) return `${PRISMA_TO_PG[field.prismaType]}[]`;
   return PRISMA_TO_PG[field.prismaType];
 }
@@ -89,7 +89,7 @@ function resolveBaseColumnType(params: { field: ScalarField | EnumField; enums:
     const enumDef = enums.find((e) => e.name === field.enumName);
     return q({ name: enumDef?.dbName ?? field.enumName });
   }
-  if (field.nativeType) return field.nativeType;
+  if (field.nativeType) return field.nativeType.toLowerCase();
   if (field.isList) return `${PRISMA_TO_PG[field.prismaType]}[]`;
   return PRISMA_TO_PG[field.prismaType];
 }
@@ -123,6 +123,42 @@ function uniqueKey(params: { uc: UniqueConstraint; model: Model }): string {
     .join(",");
 }
 
+/**
+ * Build the effective set of unique constraints for a model by merging
+ * explicit `uniqueConstraints` entries with synthetic single-field entries
+ * from fields that have `isUnique: true`.
+ *
+ * This normalizes the two representations of single-field uniqueness:
+ * - `@unique` on a field → `isUnique: true`, no `uniqueConstraints` entry
+ * - `@@unique([field])` on a model → `uniqueConstraints` entry, `isUnique: false`
+ *
+ * The database represents both identically, so the differ must treat them
+ * as equivalent to avoid phantom diffs when comparing parsed schemas against
+ * introspected schemas (which always use `isUnique: true` for single-field uniques).
+ */
+function getEffectiveUniques(params: { model: Model }): Map<string, UniqueConstraint> {
+  const { model } = params;
+  const result = new Map<string, UniqueConstraint>();
+
+  // Add all explicit uniqueConstraints entries
+  for (const uc of model.uniqueConstraints) {
+    result.set(uniqueKey({ uc, model }), uc);
+  }
+
+  // Add synthetic entries for isUnique fields not already covered
+  for (const field of model.fields) {
+    if (field.kind === "relation") continue;
+    if (!field.isUnique) continue;
+    const syntheticUc: UniqueConstraint = { fields: [field.name], name: undefined };
+    const key = uniqueKey({ uc: syntheticUc, model });
+    if (!result.has(key)) {
+      result.set(key, syntheticUc);
+    }
+  }
+
+  return result;
+}
+
 function indexKey(params: { idx: IndexDefinition; model: Model }): string {
   return params.idx.fields
     .map((f: string) => resolveFieldDbName({ model: params.model, fieldName: f }))
@@ -347,7 +383,7 @@ export function diffSchemas(params: { previous: Schema; current: Schema }): Diff
 
     const tableName = model.dbName;
 
-    // Composite unique constraints
+    // Unique constraints from @@unique (single-field @unique is inline on the column)
     for (const uc of model.uniqueConstraints) {
       const cols = uc.fields.map((f: string) => q({ name: resolveFieldDbName({ model, fieldName: f }) })).join(", ");
       const resolvedFieldNames = uc.fields.map((f: string) => resolveFieldDbName({ model, fieldName: f }));
@@ -584,13 +620,11 @@ export function diffSchemas(params: { previous: Schema; current: Schema }): Diff
     }
 
     // ─── Unique Constraint Diffs ──────────────────────────────
+    // Use effective uniques to normalize @unique (field-level) and
+    // @@unique([field]) (model-level) representations before diffing.
 
-    const prevUniques = new Map(
-      prevModel.uniqueConstraints.map((uc: UniqueConstraint) => [uniqueKey({ uc, model: prevModel }), uc])
-    );
-    const currUniques = new Map(
-      currModel.uniqueConstraints.map((uc: UniqueConstraint) => [uniqueKey({ uc, model: currModel }), uc])
-    );
+    const prevUniques = getEffectiveUniques({ model: prevModel });
+    const currUniques = getEffectiveUniques({ model: currModel });
 
     for (const [key, uc] of currUniques) {
       if (prevUniques.has(key)) continue;