@vibeorm/migrate 1.1.1 → 1.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibeorm/migrate",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "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.1"
+    "@vibeorm/parser": "1.1.3"
   }
 }

package/src/index.ts

@@ -30,6 +30,7 @@ export {
   applyMigration,
   removeMigrationRecord,
   markMigrationApplied,
+  rollbackMigration,
 } from "./migration-runner.ts";
 export type { AppliedMigration } from "./migration-runner.ts";
 

package/src/migration-runner.ts

@@ -101,3 +101,27 @@ export async function removeMigrationRecord(params: {
     values: [migrationName],
   });
 }
+
+// ─── Rollback Migration ───────────────────────────────────────────
+
+export async function rollbackMigration(params: {
+  executor: SqlExecutor;
+  migrationName: string;
+  sql: string;
+}): Promise<{ executionTime: number }> {
+  const { executor, migrationName, sql } = params;
+  const start = Date.now();
+
+  // Split down migration SQL into individual statements
+  const statements = splitSqlStatements({ sql });
+  for (const stmt of statements) {
+    await executor({ text: stmt });
+  }
+
+  const executionTime = Date.now() - start;
+
+  // Remove the migration tracking record
+  await removeMigrationRecord({ executor, migrationName });
+
+  return { executionTime };
+}

package/src/schema-differ.ts

@@ -44,7 +44,11 @@ export type DiffOperationType =
 export type DiffOperation = {
   type: DiffOperationType;
   sql: string;
+  /** Reverse SQL to undo this operation (for down migrations) */
+  downSql: string;
   isDestructive: boolean;
+  /** Whether this operation can be cleanly reversed without data loss */
+  isReversible: boolean;
   description: string;
 };
 
@@ -225,20 +229,27 @@ export function diffSchemas(params: { previous: Schema; current: Schema }): Diff
       ops.push({
         type: "createEnum",
         sql: `DO $$ BEGIN\n  CREATE TYPE ${q({ name: typeName })} AS ENUM (${values});\nEXCEPTION WHEN duplicate_object THEN NULL;\nEND $$;`,
+        downSql: `DROP TYPE IF EXISTS ${q({ name: typeName })};`,
         isDestructive: false,
+        isReversible: true,
         description: `Create enum type "${name}"`,
       });
     }
   }
 
-  // Dropped enums
+  // Dropped enums — reverse is recreating the enum with its previous values
   for (const [name, enumDef] of prevEnumMap) {
     if (!currEnumMap.has(name)) {
       const typeName = enumDef.dbName ?? enumDef.name;
+      const values = enumDef.values
+        .map((v) => `'${(v.dbName ?? v.name).replace(/'/g, "''")}'`)
+        .join(", ");
       ops.push({
         type: "dropEnum",
         sql: `DROP TYPE IF EXISTS ${q({ name: typeName })};`,
+        downSql: `DO $$ BEGIN\n  CREATE TYPE ${q({ name: typeName })} AS ENUM (${values});\nEXCEPTION WHEN duplicate_object THEN NULL;\nEND $$;`,
         isDestructive: true,
+        isReversible: true,
         description: `Drop enum type "${name}"`,
       });
     }
@@ -253,14 +264,16 @@ export function diffSchemas(params: { previous: Schema; current: Schema }): Diff
     const prevValues = new Set(prevEnum.values.map((v) => v.name));
     const currValues = new Set(currEnum.values.map((v) => v.name));
 
-    // Added values
+    // Added values — reverse requires type recreation (PG cannot DROP VALUE)
     for (const val of currEnum.values) {
       if (!prevValues.has(val.name)) {
         const dbVal = val.dbName ?? val.name;
         ops.push({
           type: "addEnumValue",
           sql: `ALTER TYPE ${q({ name: typeName })} ADD VALUE IF NOT EXISTS '${dbVal.replace(/'/g, "''")}';`,
+          downSql: `-- WARNING: PostgreSQL does not support removing enum values directly.\n-- Value "${val.name}" was added to enum "${name}" and cannot be cleanly removed.\n-- Manual type recreation may be required.`,
           isDestructive: false,
+          isReversible: false,
           description: `Add value "${val.name}" to enum "${name}"`,
         });
       }
@@ -269,10 +282,13 @@ export function diffSchemas(params: { previous: Schema; current: Schema }): Diff
     // Removed values (destructive — PG doesn't support DROP VALUE easily)
     for (const val of prevEnum.values) {
       if (!currValues.has(val.name)) {
+        const dbVal = val.dbName ?? val.name;
         ops.push({
           type: "removeEnumValue",
           sql: `-- WARNING: PostgreSQL does not support removing enum values directly.\n-- You need to recreate the type. Value "${val.name}" removed from enum "${name}".`,
+          downSql: `ALTER TYPE ${q({ name: typeName })} ADD VALUE IF NOT EXISTS '${dbVal.replace(/'/g, "''")}';`,
           isDestructive: true,
+          isReversible: true,
           description: `Remove value "${val.name}" from enum "${name}" (requires type recreation)`,
         });
       }
@@ -318,7 +334,9 @@ export function diffSchemas(params: { previous: Schema; current: Schema }): Diff
     ops.push({
       type: "createTable",
       sql: `CREATE TABLE ${q({ name: tableName })} (\n${columns.join(",\n")}\n);`,
+      downSql: `DROP TABLE IF EXISTS ${q({ name: tableName })} CASCADE;`,
       isDestructive: false,
+      isReversible: true,
       description: `Create table "${name}"`,
     });
   }
@@ -337,7 +355,9 @@ export function diffSchemas(params: { previous: Schema; current: Schema }): Diff
       ops.push({
         type: "addUnique",
         sql: `CREATE UNIQUE INDEX ${q({ name: idxName })} ON ${q({ name: tableName })} (${cols});`,
+        downSql: `DROP INDEX IF EXISTS ${q({ name: idxName })};`,
         isDestructive: false,
+        isReversible: true,
         description: `Add unique constraint on (${uc.fields.join(", ")}) in "${name}"`,
       });
     }
@@ -350,7 +370,9 @@ export function diffSchemas(params: { previous: Schema; current: Schema }): Diff
       ops.push({
         type: "addIndex",
         sql: `CREATE INDEX ${q({ name: idxName })} ON ${q({ name: tableName })} (${cols});`,
+        downSql: `DROP INDEX IF EXISTS ${q({ name: idxName })};`,
         isDestructive: false,
+        isReversible: true,
         description: `Add index on (${idx.fields.join(", ")}) in "${name}"`,
       });
     }
@@ -371,19 +393,50 @@ export function diffSchemas(params: { previous: Schema; current: Schema }): Diff
       ops.push({
         type: "addForeignKey",
         sql: `ALTER TABLE ${q({ name: tableName })} ADD CONSTRAINT ${q({ name: constraintName })} FOREIGN KEY (${fkCols}) REFERENCES ${q({ name: relatedTableName })} (${refCols}) ON DELETE RESTRICT ON UPDATE CASCADE;`,
+        downSql: `ALTER TABLE ${q({ name: tableName })} DROP CONSTRAINT IF EXISTS ${q({ name: constraintName })};`,
         isDestructive: false,
+        isReversible: true,
         description: `Add foreign key on "${name}" (${rel.relation.fields.join(", ")}) \u2192 "${rel.relatedModel}"`,
       });
     }
   }
 
-  // Dropped tables
+  // Dropped tables — reverse is recreating the table from the previous schema
   for (const [name, model] of prevModelMap) {
     if (currModelMap.has(name)) continue;
+
+    // Build the CREATE TABLE statement for the down migration
+    const dropTableName = model.dbName;
+    const downColumns: string[] = [];
+    for (const field of getScalarFields({ model })) {
+      const colName = field.dbName;
+      const colType = resolveColumnType({ field, enums: previous.enums });
+      let colDef = `  ${q({ name: colName })} ${colType}`;
+      if (field.kind === "scalar" && field.isRequired && field.default?.kind !== "autoincrement") {
+        colDef += " NOT NULL";
+      } else if (field.kind === "enum" && field.isRequired) {
+        colDef += " NOT NULL";
+      }
+      const defaultExpr = resolveDefault({ field });
+      if (defaultExpr) colDef += ` DEFAULT ${defaultExpr}`;
+      if (field.isUnique) colDef += " UNIQUE";
+      downColumns.push(colDef);
+    }
+    const downPkFields = model.primaryKey.fields
+      .map((f: string) => {
+        const fld = model.fields.find((mf: Field) => mf.name === f);
+        if (fld && fld.kind !== "relation") return q({ name: fld.dbName });
+        return q({ name: f });
+      })
+      .join(", ");
+    downColumns.push(`  CONSTRAINT ${q({ name: `${dropTableName}_pkey` })} PRIMARY KEY (${downPkFields})`);
+
     ops.push({
       type: "dropTable",
       sql: `DROP TABLE IF EXISTS ${q({ name: model.dbName })} CASCADE;`,
+      downSql: `CREATE TABLE ${q({ name: dropTableName })} (\n${downColumns.join(",\n")}\n);`,
       isDestructive: true,
+      isReversible: true,
       description: `Drop table "${name}"`,
     });
   }
@@ -402,7 +455,7 @@ export function diffSchemas(params: { previous: Schema; current: Schema }): Diff
       getScalarFields({ model: currModel }).map((f) => [f.dbName, f])
     );
 
-    // Added columns
+    // Added columns — reverse is dropping the column
     for (const [fieldName, field] of currFields) {
       if (prevFields.has(fieldName)) continue;
 
@@ -424,18 +477,32 @@ export function diffSchemas(params: { previous: Schema; current: Schema }): Diff
       ops.push({
         type: "addColumn",
         sql: `ALTER TABLE ${q({ name: tableName })} ADD COLUMN ${q({ name: colName })} ${colDef};`,
+        downSql: `ALTER TABLE ${q({ name: tableName })} DROP COLUMN IF EXISTS ${q({ name: colName })};`,
         isDestructive,
+        isReversible: true,
         description: `Add column "${fieldName}" to "${name}"`,
       });
     }
 
-    // Dropped columns
+    // Dropped columns — reverse is re-adding the column with its previous definition
     for (const [fieldName, field] of prevFields) {
       if (currFields.has(fieldName)) continue;
+
+      const colName = field.dbName;
+      const colType = resolveColumnType({ field, enums: previous.enums });
+      const defaultExpr = resolveDefault({ field });
+      // Down migration always adds the column back as nullable because
+      // the original data is lost after DROP COLUMN — adding NOT NULL
+      // would fail if the table has existing rows with null values.
+      let downColDef = `${colType}`;
+      if (defaultExpr) downColDef += ` DEFAULT ${defaultExpr}`;
+
       ops.push({
         type: "dropColumn",
         sql: `ALTER TABLE ${q({ name: tableName })} DROP COLUMN IF EXISTS ${q({ name: field.dbName })};`,
+        downSql: `ALTER TABLE ${q({ name: tableName })} ADD COLUMN ${q({ name: colName })} ${downColDef};`,
         isDestructive: true,
+        isReversible: true,
         description: `Drop column "${fieldName}" from "${name}"`,
       });
     }
@@ -449,51 +516,67 @@ export function diffSchemas(params: { previous: Schema; current: Schema }): Diff
       const prevType = resolveColumnType({ field: prevField, enums: previous.enums });
       const currType = resolveColumnType({ field: currField, enums: current.enums });
 
-      // Type change
+      // Type change — reverse is setting back to the previous type
       if (prevType !== currType) {
         ops.push({
           type: "alterColumnType",
           sql: `ALTER TABLE ${q({ name: tableName })} ALTER COLUMN ${q({ name: colName })} SET DATA TYPE ${currType};`,
+          downSql: `ALTER TABLE ${q({ name: tableName })} ALTER COLUMN ${q({ name: colName })} SET DATA TYPE ${prevType};`,
           isDestructive: true,
+          isReversible: true,
           description: `Change type of "${fieldName}" in "${name}" from ${prevType} to ${currType}`,
         });
       }
 
-      // Nullability change
+      // Nullability change — reverse is toggling back
       if (prevField.isRequired !== currField.isRequired) {
         if (currField.isRequired) {
           ops.push({
             type: "alterColumnNullability",
             sql: `ALTER TABLE ${q({ name: tableName })} ALTER COLUMN ${q({ name: colName })} SET NOT NULL;`,
+            downSql: `ALTER TABLE ${q({ name: tableName })} ALTER COLUMN ${q({ name: colName })} DROP NOT NULL;`,
             isDestructive: true,
+            isReversible: true,
             description: `Set NOT NULL on "${fieldName}" in "${name}"`,
           });
         } else {
           ops.push({
             type: "alterColumnNullability",
             sql: `ALTER TABLE ${q({ name: tableName })} ALTER COLUMN ${q({ name: colName })} DROP NOT NULL;`,
+            downSql: `ALTER TABLE ${q({ name: tableName })} ALTER COLUMN ${q({ name: colName })} SET NOT NULL;`,
             isDestructive: false,
+            isReversible: true,
             description: `Drop NOT NULL on "${fieldName}" in "${name}"`,
           });
         }
       }
 
-      // Default change
+      // Default change — reverse is restoring the previous default
       const prevDefault = resolveDefault({ field: prevField });
       const currDefault = resolveDefault({ field: currField });
       if (prevDefault !== currDefault) {
         if (currDefault) {
+          const downDefaultSql = prevDefault
+            ? `ALTER TABLE ${q({ name: tableName })} ALTER COLUMN ${q({ name: colName })} SET DEFAULT ${prevDefault};`
+            : `ALTER TABLE ${q({ name: tableName })} ALTER COLUMN ${q({ name: colName })} DROP DEFAULT;`;
           ops.push({
             type: "alterColumnDefault",
             sql: `ALTER TABLE ${q({ name: tableName })} ALTER COLUMN ${q({ name: colName })} SET DEFAULT ${currDefault};`,
+            downSql: downDefaultSql,
             isDestructive: false,
+            isReversible: true,
             description: `Set default on "${fieldName}" in "${name}" to ${currDefault}`,
           });
         } else {
+          const downDefaultSql = prevDefault
+            ? `ALTER TABLE ${q({ name: tableName })} ALTER COLUMN ${q({ name: colName })} SET DEFAULT ${prevDefault};`
+            : `-- No previous default to restore`;
           ops.push({
             type: "alterColumnDefault",
             sql: `ALTER TABLE ${q({ name: tableName })} ALTER COLUMN ${q({ name: colName })} DROP DEFAULT;`,
+            downSql: downDefaultSql,
             isDestructive: false,
+            isReversible: true,
             description: `Drop default on "${fieldName}" in "${name}"`,
           });
         }
@@ -517,19 +600,24 @@ export function diffSchemas(params: { previous: Schema; current: Schema }): Diff
       ops.push({
         type: "addUnique",
         sql: `CREATE UNIQUE INDEX ${q({ name: idxName })} ON ${q({ name: tableName })} (${cols});`,
+        downSql: `DROP INDEX IF EXISTS ${q({ name: idxName })};`,
         isDestructive: false,
+        isReversible: true,
         description: `Add unique constraint on (${uc.fields.join(", ")}) in "${name}"`,
       });
     }
 
     for (const [key, uc] of prevUniques) {
       if (currUniques.has(key)) continue;
+      const cols = uc.fields.map((f: string) => q({ name: resolveFieldDbName({ model: prevModel, fieldName: f }) })).join(", ");
       const resolvedFieldNames = uc.fields.map((f: string) => resolveFieldDbName({ model: prevModel, fieldName: f }));
       const idxName = uc.name ?? `${tableName}_${resolvedFieldNames.join("_")}_key`;
       ops.push({
         type: "dropUnique",
         sql: `DROP INDEX IF EXISTS ${q({ name: idxName })};`,
+        downSql: `CREATE UNIQUE INDEX ${q({ name: idxName })} ON ${q({ name: tableName })} (${cols});`,
         isDestructive: true,
+        isReversible: true,
         description: `Drop unique constraint on (${uc.fields.join(", ")}) in "${name}"`,
       });
     }
@@ -551,19 +639,24 @@ export function diffSchemas(params: { previous: Schema; current: Schema }): Diff
       ops.push({
         type: "addIndex",
         sql: `CREATE INDEX ${q({ name: idxName })} ON ${q({ name: tableName })} (${cols});`,
+        downSql: `DROP INDEX IF EXISTS ${q({ name: idxName })};`,
         isDestructive: false,
+        isReversible: true,
         description: `Add index on (${idx.fields.join(", ")}) in "${name}"`,
       });
     }
 
     for (const [key, idx] of prevIndexes) {
       if (currIndexes.has(key)) continue;
+      const cols = idx.fields.map((f: string) => q({ name: resolveFieldDbName({ model: prevModel, fieldName: f }) })).join(", ");
       const resolvedFieldNames = idx.fields.map((f: string) => resolveFieldDbName({ model: prevModel, fieldName: f }));
       const idxName = idx.name ?? `${tableName}_${resolvedFieldNames.join("_")}_idx`;
       ops.push({
         type: "dropIndex",
         sql: `DROP INDEX IF EXISTS ${q({ name: idxName })};`,
+        downSql: `CREATE INDEX ${q({ name: idxName })} ON ${q({ name: tableName })} (${cols});`,
         isDestructive: true,
+        isReversible: true,
         description: `Drop index on (${idx.fields.join(", ")}) in "${name}"`,
       });
     }
@@ -595,19 +688,30 @@ export function diffSchemas(params: { previous: Schema; current: Schema }): Diff
       ops.push({
         type: "addForeignKey",
         sql: `ALTER TABLE ${q({ name: tableName })} ADD CONSTRAINT ${q({ name: constraintName })} FOREIGN KEY (${fkCols}) REFERENCES ${q({ name: relatedTableName })} (${refCols}) ON DELETE RESTRICT ON UPDATE CASCADE;`,
+        downSql: `ALTER TABLE ${q({ name: tableName })} DROP CONSTRAINT IF EXISTS ${q({ name: constraintName })};`,
         isDestructive: false,
+        isReversible: true,
         description: `Add foreign key on "${name}" (${rel.relation.fields.join(", ")}) → "${rel.relatedModel}"`,
       });
     }
 
     for (const [key, rel] of prevFKs) {
       if (currFKs.has(key)) continue;
+      const fkCols = rel.relation.fields.map((f: string) => q({ name: resolveFieldDbName({ model: prevModel, fieldName: f }) })).join(", ");
+      const relatedModel = previous.models.find((m: Model) => m.name === rel.relatedModel);
+      const relatedTableName = relatedModel?.dbName ?? rel.relatedModel;
+      const refCols = rel.relation.references.map((f: string) => {
+        if (relatedModel) return q({ name: resolveFieldDbName({ model: relatedModel, fieldName: f }) });
+        return q({ name: f });
+      }).join(", ");
       const resolvedFkNames = rel.relation.fields.map((f: string) => resolveFieldDbName({ model: prevModel, fieldName: f }));
       const constraintName = `${tableName}_${resolvedFkNames.join("_")}_fkey`;
       ops.push({
         type: "dropForeignKey",
         sql: `ALTER TABLE ${q({ name: tableName })} DROP CONSTRAINT IF EXISTS ${q({ name: constraintName })};`,
+        downSql: `ALTER TABLE ${q({ name: tableName })} ADD CONSTRAINT ${q({ name: constraintName })} FOREIGN KEY (${fkCols}) REFERENCES ${q({ name: relatedTableName })} (${refCols}) ON DELETE RESTRICT ON UPDATE CASCADE;`,
         isDestructive: true,
+        isReversible: true,
         description: `Drop foreign key on "${name}" (${rel.relation.fields.join(", ")}) → "${rel.relatedModel}"`,
       });
     }
@@ -654,17 +758,50 @@ export function diffSchemas(params: { previous: Schema; current: Schema }): Diff
         `ALTER TABLE ${q({ name: jt.tableName })} ADD CONSTRAINT ${q({ name: `${jt.tableName}_A_fkey` })} FOREIGN KEY ("A") REFERENCES ${q({ name: tableA })} ("${pkFieldA}") ON DELETE CASCADE ON UPDATE CASCADE;`,
         `ALTER TABLE ${q({ name: jt.tableName })} ADD CONSTRAINT ${q({ name: `${jt.tableName}_B_fkey` })} FOREIGN KEY ("B") REFERENCES ${q({ name: tableB })} ("${pkFieldB}") ON DELETE CASCADE ON UPDATE CASCADE;`,
       ].join("\n"),
+      downSql: `DROP TABLE IF EXISTS ${q({ name: jt.tableName })} CASCADE;`,
       isDestructive: false,
+      isReversible: true,
       description: `Create join table "${jt.tableName}" for ${jt.modelA} ↔ ${jt.modelB}`,
     });
   }
 
   for (const jt of prevJoinTables) {
     if (currJoinSet.has(jt.tableName)) continue;
+
+    // For the down migration, reconstruct the join table from the previous schema
+    const prevModelADef = prevModelMap.get(jt.modelA);
+    const prevModelBDef = prevModelMap.get(jt.modelB);
+    let downJoinSql = `-- WARNING: Cannot fully reconstruct join table "${jt.tableName}". Manual intervention required.`;
+
+    if (prevModelADef && prevModelBDef) {
+      const prevPkFieldA = prevModelADef.primaryKey.fields[0]!;
+      const prevPkFieldB = prevModelBDef.primaryKey.fields[0]!;
+      const prevPkFieldDefA = prevModelADef.fields.find((f: Field) => f.name === prevPkFieldA);
+      const prevPkFieldDefB = prevModelBDef.fields.find((f: Field) => f.name === prevPkFieldB);
+      const prevPkTypeA = prevPkFieldDefA && (prevPkFieldDefA.kind === "scalar" || prevPkFieldDefA.kind === "enum")
+        ? resolveBaseColumnType({ field: prevPkFieldDefA, enums: previous.enums })
+        : "INTEGER";
+      const prevPkTypeB = prevPkFieldDefB && (prevPkFieldDefB.kind === "scalar" || prevPkFieldDefB.kind === "enum")
+        ? resolveBaseColumnType({ field: prevPkFieldDefB, enums: previous.enums })
+        : "INTEGER";
+      const prevTableA = prevModelADef.dbName;
+      const prevTableB = prevModelBDef.dbName;
+
+      downJoinSql = [
+        `CREATE TABLE ${q({ name: jt.tableName })} (\n  "A" ${prevPkTypeA} NOT NULL,\n  "B" ${prevPkTypeB} NOT NULL\n);`,
+        `CREATE UNIQUE INDEX ${q({ name: `${jt.tableName}_AB_unique` })} ON ${q({ name: jt.tableName })} ("A", "B");`,
+        `CREATE INDEX ${q({ name: `${jt.tableName}_B_index` })} ON ${q({ name: jt.tableName })} ("B");`,
+        `ALTER TABLE ${q({ name: jt.tableName })} ADD CONSTRAINT ${q({ name: `${jt.tableName}_A_fkey` })} FOREIGN KEY ("A") REFERENCES ${q({ name: prevTableA })} ("${prevPkFieldA}") ON DELETE CASCADE ON UPDATE CASCADE;`,
+        `ALTER TABLE ${q({ name: jt.tableName })} ADD CONSTRAINT ${q({ name: `${jt.tableName}_B_fkey` })} FOREIGN KEY ("B") REFERENCES ${q({ name: prevTableB })} ("${prevPkFieldB}") ON DELETE CASCADE ON UPDATE CASCADE;`,
+      ].join("\n");
+    }
+
     ops.push({
       type: "dropJoinTable",
       sql: `DROP TABLE IF EXISTS ${q({ name: jt.tableName })} CASCADE;`,
+      downSql: downJoinSql,
       isDestructive: true,
+      isReversible: prevModelADef !== undefined && prevModelBDef !== undefined,
       description: `Drop join table "${jt.tableName}" for ${jt.modelA} ↔ ${jt.modelB}`,
     });
   }