feat: support rollback via down migration

Author: sweatybridge

packages/mcp-server-supabase/src/platform/api-platform.ts

@@ -41,6 +41,8 @@ import {
   type StorageConfig,
   type StorageOperations,
   type SupabasePlatform,
+  type RollbackMigrationOptions,
+  rollbackMigrationOptionsSchema,
 } from './index.js';
 
 const { version } = packageJson;
@@ -235,6 +237,27 @@ export function createSupabaseApiPlatform(
       // to avoid prompt injection attacks. If the migration failed,
       // it will throw an error.
     },
+    async rollbackMigration(projectId: string, options: RollbackMigrationOptions) {
+      const { version } = rollbackMigrationOptionsSchema.parse(options);
+
+      const response = await managementApiClient.DELETE(
+        '/v1/projects/{ref}/database/migrations',
+        {
+          params: {
+            path: {
+              ref: projectId,
+            },
+            query: {
+              gte: version
+            }
+          },
+        }
+      );
+
+      assertSuccess(response, 'Failed to rollback migration');
+
+      return response.data;
+    },
   };
 
   const debugging: DebuggingOperations = {

packages/mcp-server-supabase/src/platform/types.ts

@@ -121,6 +121,11 @@ export const executeSqlOptionsSchema = z.object({
 export const applyMigrationOptionsSchema = z.object({
   name: z.string(),
   query: z.string(),
+  rollback: z.string(),
+});
+
+export const rollbackMigrationOptionsSchema = z.object({
+  version: z.string(),
 });
 
 export const migrationSchema = z.object({
@@ -163,6 +168,7 @@ export type DeployEdgeFunctionOptions = z.infer<
 
 export type ExecuteSqlOptions = z.infer<typeof executeSqlOptionsSchema>;
 export type ApplyMigrationOptions = z.infer<typeof applyMigrationOptionsSchema>;
+export type RollbackMigrationOptions = z.infer<typeof rollbackMigrationOptionsSchema>;
 export type Migration = z.infer<typeof migrationSchema>;
 export type ListMigrationsResult = z.infer<typeof migrationSchema>;
 
@@ -182,6 +188,10 @@ export type DatabaseOperations = {
     projectId: string,
     options: ApplyMigrationOptions
   ): Promise<void>;
+  rollbackMigration(
+    projectId: string,
+    options: RollbackMigrationOptions
+  ): Promise<void>;
 };
 
 export type AccountOperations = {
@@ -234,10 +244,7 @@ export type DevelopmentOperations = {
 
 export type StorageOperations = {
   getStorageConfig(projectId: string): Promise<StorageConfig>;
-  updateStorageConfig(
-    projectId: string,
-    config: StorageConfig
-  ): Promise<void>;
+  updateStorageConfig(projectId: string, config: StorageConfig): Promise<void>;
   listAllBuckets(projectId: string): Promise<StorageBucket[]>;
 };
 
@@ -249,10 +256,7 @@ export type BranchingOperations = {
   ): Promise<Branch>;
   deleteBranch(branchId: string): Promise<void>;
   mergeBranch(branchId: string): Promise<void>;
-  resetBranch(
-    branchId: string,
-    options: ResetBranchOptions
-  ): Promise<void>;
+  resetBranch(branchId: string, options: ResetBranchOptions): Promise<void>;
   rebaseBranch(branchId: string): Promise<void>;
 };
 

packages/mcp-server-supabase/src/server.test.ts

@@ -2734,6 +2734,9 @@ describe('feature groups', () => {
         applyMigration() {
           throw new Error('Not implemented');
         },
+        rollbackMigration() {
+          throw new Error('Not implemented');
+        },
       },
     };
 
@@ -2763,6 +2766,9 @@ describe('feature groups', () => {
         applyMigration() {
           throw new Error('Not implemented');
         },
+        rollbackMigration() {
+          throw new Error('Not implemented');
+        },
       },
     };
 

packages/mcp-server-supabase/src/tools/database-operation-tools.ts

@@ -208,16 +208,45 @@ export function getDatabaseTools({
         project_id: z.string(),
         name: z.string().describe('The name of the migration in snake_case'),
         query: z.string().describe('The SQL query to apply'),
+        rollback: z.string().describe('The SQL query to rollback'),
       }),
       inject: { project_id },
-      execute: async ({ project_id, name, query }) => {
+      execute: async ({ project_id, name, query, rollback }) => {
         if (readOnly) {
           throw new Error('Cannot apply migration in read-only mode.');
         }
 
         await database.applyMigration(project_id, {
           name,
           query,
+          rollback,
+        });
+
+        return SUCCESS_RESPONSE;
+      },
+    }),
+    rollback_migration: injectableTool({
+      description:
+        'Rollback database migrations greater or equal to the specified version.',
+      annotations: {
+        title: 'Rollback migration',
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true,
+      },
+      parameters: z.object({
+        project_id: z.string(),
+        version: z.string().describe('The target migration version to rollback'),
+      }),
+      inject: { project_id },
+      execute: async ({ project_id, version }) => {
+        if (readOnly) {
+          throw new Error('Cannot apply migration in read-only mode.');
+        }
+
+        await database.rollbackMigration(project_id, {
+          version,
         });
 
         return SUCCESS_RESPONSE;