@vibeorm/migrate 1.2.0 → 1.3.0

package/package.json

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

package/src/introspector.ts

@@ -447,7 +447,7 @@ export async function introspect(params: { executor: SqlExecutor }): Promise<Sch
       const isUnique = uniqueColumns.has(`${tableName}.${col.columnName}`);
       const parsedDefault = parseDefault({ columnDefault: col.columnDefault, dataType: col.dataType });
 
-      // Check if this is an enum column
+      // Branch 1: scalar enum column (data_type=USER-DEFINED, udt_name=EnumName).
       if (col.dataType === "USER-DEFINED" && enumNames.has(col.udtName)) {
         const enumField: EnumField = {
           kind: "enum",
@@ -462,8 +462,33 @@ export async function introspect(params: { executor: SqlExecutor }): Promise<Sch
           documentation: undefined,
         };
         fields.push(enumField);
-      } else {
-        // Map PG type to Prisma type
+      }
+      // Branch 2: enum-array column. Postgres reports the underlying array type
+      // as `_EnumName` (the leading underscore is the array-type naming convention),
+      // and `data_type` is `ARRAY`. Without this branch the field would be parsed
+      // as `String[]` and the round-trip drift differ would always want to ALTER it.
+      // Bug 2 — see .ai/bug-report-2026-05-24.md.
+      else if (
+        col.dataType === "ARRAY" &&
+        col.udtName.startsWith("_") &&
+        enumNames.has(col.udtName.slice(1))
+      ) {
+        const enumField: EnumField = {
+          kind: "enum",
+          name: col.columnName,
+          dbName: col.columnName,
+          enumName: col.udtName.slice(1),
+          isRequired: !col.isNullable,
+          isList: true,
+          isId,
+          isUnique,
+          default: parsedDefault,
+          documentation: undefined,
+        };
+        fields.push(enumField);
+      }
+      // Branch 3: scalar / scalar-array fallback.
+      else {
         const pgType = col.dataType === "ARRAY" ? col.udtName.replace(/^_/, "") : col.udtName;
         const prismaType = PG_TO_PRISMA[pgType] ?? PG_TO_PRISMA[col.dataType] ?? "String";
         const isArray = col.dataType === "ARRAY";

package/src/schema-differ.ts

@@ -72,8 +72,11 @@ function getRelationFields(params: { model: Model }): RelationField[] {
 function resolveColumnType(params: { field: ScalarField | EnumField; enums: Enum[] }): string {
   const { field, enums } = params;
   if (field.kind === "enum") {
+    // Enum lists must emit `EnumName[]`, not the scalar enum type. Mirrors
+    // `ddl-builder.ts:135-141`. Bug 2 — see .ai/bug-report-2026-05-24.md.
     const enumDef = enums.find((e) => e.name === field.enumName);
-    return q({ name: enumDef?.dbName ?? field.enumName });
+    const enumType = q({ name: enumDef?.dbName ?? field.enumName });
+    return field.isList ? `${enumType}[]` : enumType;
   }
   if (field.default?.kind === "autoincrement") {
     return field.prismaType === "BigInt" ? "BIGSERIAL" : "SERIAL";
@@ -87,8 +90,10 @@ function resolveColumnType(params: { field: ScalarField | EnumField; enums: Enum
 function resolveBaseColumnType(params: { field: ScalarField | EnumField; enums: Enum[] }): string {
   const { field, enums } = params;
   if (field.kind === "enum") {
+    // Same enum-list handling as resolveColumnType (Bug 2).
     const enumDef = enums.find((e) => e.name === field.enumName);
-    return q({ name: enumDef?.dbName ?? field.enumName });
+    const enumType = q({ name: enumDef?.dbName ?? field.enumName });
+    return field.isList ? `${enumType}[]` : enumType;
   }
   if (field.nativeType) return field.nativeType.toLowerCase();
   if (field.isList) return `${PRISMA_TO_PG[field.prismaType]}[]`;
@@ -556,11 +561,25 @@ export function diffSchemas(params: { previous: Schema; current: Schema }): Diff
 
       // Type change — reverse is setting back to the previous type
       if (prevType !== currType) {
+        // Detect scalar -> array transition of same base type. PG can't implicit-cast,
+        // so we add a USING clause that wraps the existing value in a 1-element array
+        // (or NULL if the column is NULL). This heals databases broken by an earlier
+        // enum-array bug (Bug 2) where the column was created as the scalar type.
+        // We intentionally do NOT handle the reverse direction (array -> scalar) — that
+        // is lossy and the user must decide which element to keep.
+        const isScalarToArray =
+          currType.endsWith("[]") && !prevType.endsWith("[]") &&
+          currType.slice(0, -2) === prevType;
+
+        const usingClause = isScalarToArray
+          ? ` USING CASE WHEN ${q({ name: colName })} IS NULL THEN NULL ELSE ARRAY[${q({ name: colName })}] END`
+          : "";
+
         ops.push({
           type: "alterColumnType",
-          sql: `ALTER TABLE ${q({ name: tableName })} ALTER COLUMN ${q({ name: colName })} SET DATA TYPE ${currType};`,
+          sql: `ALTER TABLE ${q({ name: tableName })} ALTER COLUMN ${q({ name: colName })} SET DATA TYPE ${currType}${usingClause};`,
           downSql: `ALTER TABLE ${q({ name: tableName })} ALTER COLUMN ${q({ name: colName })} SET DATA TYPE ${prevType};`,
-          isDestructive: true,
+          isDestructive: !isScalarToArray, // scalar -> array is non-destructive (data preserved as 1-element arrays)
           isReversible: true,
           description: `Change type of "${fieldName}" in "${name}" from ${prevType} to ${currType}`,
         });