feat: v2.1.0 - Add full database backup management (#60)

* feat: add full backup management to MCP

- Add create/update/delete actions to database_backups tool
- Add CreateDatabaseBackupRequest and UpdateDatabaseBackupRequest types
- Add createDatabaseBackup, updateDatabaseBackup, deleteDatabaseBackup client methods
- Support all backup configuration parameters:
  - frequency, enabled, save_s3, s3_storage_uuid
  - database_backup_retention_days_locally/s3
  - database_backup_retention_amount_locally/s3
  - databases_to_backup, dump_all

Enables full database backup lifecycle management via MCP API.

* 2.1.0

* fix: add missing tests and documentation for backup management

- Add tests for createDatabaseBackup, updateDatabaseBackup, deleteDatabaseBackup in coolify-client.test.ts
- Add method existence tests in mcp-server.test.ts
- Add CHANGELOG.md entry for v2.1.0 with full backup management details
- Update CLAUDE.md with testing requirements and codecov reminder

Addresses PR review feedback:
- Codecov coverage restored to 98.25%
- All new client methods now have proper test coverage
- Documentation updated per CLAUDE.md standards

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: StuMason

CHANGELOG.md

@@ -5,6 +5,32 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.1.0] - 2026-01-07
+
+### Added
+
+- **Full Database Backup Management** - Complete lifecycle management for database backup schedules:
+  - `database_backups` tool now supports `create`, `update`, and `delete` actions
+  - Configure backup frequency (hourly, daily, weekly, monthly)
+  - Set retention policies (days or amount limits for local and S3 storage)
+  - Enable/disable backup schedules without deletion
+  - S3 storage integration for off-server backups
+  - All backup configuration parameters supported:
+    - `frequency` - Cron expression or predefined schedule
+    - `enabled` - Enable/disable the backup schedule
+    - `save_s3` - Store backups in S3-compatible storage
+    - `s3_storage_uuid` - Which S3 storage to use
+    - `database_backup_retention_days_locally` - Days to keep backups locally (0 = unlimited)
+    - `database_backup_retention_days_s3` - Days to keep backups in S3 (0 = unlimited)
+    - `database_backup_retention_amount_locally` - Number of most recent backups to keep locally
+    - `database_backup_retention_amount_s3` - Number of most recent backups to keep in S3
+    - `databases_to_backup` - Specific databases to backup (for applicable database types)
+    - `dump_all` - Dump all databases (for applicable database types)
+
+### Changed
+
+- `database_backups` tool actions expanded from 4 to 7: `list_schedules`, `get_schedule`, `list_executions`, `get_execution`, `create`, `update`, `delete`
+
 ## [2.0.0] - 2026-01-06
 
 ### Breaking Changes - Token Diet Release 🏋️

CLAUDE.md

@@ -48,7 +48,25 @@ List endpoints return summaries (uuid, name, status) not full objects. This redu
 2. Add types to `src/types/coolify.ts`
 3. Add client method with explicit return type
 4. Add MCP tool to `src/lib/mcp-server.ts`
-5. Add mocked test
+5. Add mocked tests (required for codecov coverage)
+
+### Testing Requirements
+
+**IMPORTANT**: All new client methods MUST have test coverage to pass codecov checks.
+
+When adding new client methods, you must add:
+
+1. **Client method tests** in `src/__tests__/coolify-client.test.ts`:
+   - Test the HTTP method (GET, POST, PATCH, DELETE)
+   - Test the endpoint path
+   - Test the request body if applicable
+   - Follow the existing test patterns in the file
+
+2. **Method existence tests** in `src/__tests__/mcp-server.test.ts`:
+   - Add `expect(typeof client.methodName).toBe('function');` in the appropriate section
+   - Ensures the method is properly exported and accessible
+
+**codecov will fail PRs with uncovered lines.** Always run `npm test` before committing.
 
 ### Client Method Example
 

package-lock.json

@@ -1,7 +1,7 @@
 {
   "name": "@masonator/coolify-mcp",
   "scope": "@masonator",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "MCP server implementation for Coolify",
   "type": "module",
   "main": "./dist/index.js",

package.json

@@ -1152,6 +1152,55 @@ describe('CoolifyClient', () => {
       );
     });
 
+    it('should create a database backup', async () => {
+      const mockBackup = { uuid: 'backup-uuid', frequency: '0 0 * * *', enabled: true };
+      mockFetch.mockResolvedValueOnce(mockResponse(mockBackup));
+
+      const result = await client.createDatabaseBackup('db-uuid', {
+        frequency: '0 0 * * *',
+        enabled: true,
+        save_s3: true,
+        s3_storage_uuid: 'storage-uuid',
+        database_backup_retention_days_locally: 7,
+        database_backup_retention_days_s3: 7,
+      });
+
+      expect(result).toEqual(mockBackup);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:3000/api/v1/databases/db-uuid/backups',
+        expect.objectContaining({ method: 'POST' }),
+      );
+    });
+
+    it('should update a database backup', async () => {
+      const mockData = { message: 'Backup updated' };
+      mockFetch.mockResolvedValueOnce(mockResponse(mockData));
+
+      const result = await client.updateDatabaseBackup('db-uuid', 'backup-uuid', {
+        enabled: false,
+        frequency: '0 2 * * *',
+      });
+
+      expect(result).toEqual(mockData);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:3000/api/v1/databases/db-uuid/backups/backup-uuid',
+        expect.objectContaining({ method: 'PATCH' }),
+      );
+    });
+
+    it('should delete a database backup', async () => {
+      const mockData = { message: 'Backup deleted' };
+      mockFetch.mockResolvedValueOnce(mockResponse(mockData));
+
+      const result = await client.deleteDatabaseBackup('db-uuid', 'backup-uuid');
+
+      expect(result).toEqual(mockData);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:3000/api/v1/databases/db-uuid/backups/backup-uuid',
+        expect.objectContaining({ method: 'DELETE' }),
+      );
+    });
+
     it('should list backup executions', async () => {
       const mockExecutions = [{ uuid: 'exec-uuid', status: 'success' }];
       mockFetch.mockResolvedValueOnce(mockResponse(mockExecutions));

src/__tests__/coolify-client.test.ts

@@ -126,6 +126,9 @@ describe('CoolifyMcpServer v2', () => {
       // Backup operations
       expect(typeof client.listDatabaseBackups).toBe('function');
       expect(typeof client.getDatabaseBackup).toBe('function');
+      expect(typeof client.createDatabaseBackup).toBe('function');
+      expect(typeof client.updateDatabaseBackup).toBe('function');
+      expect(typeof client.deleteDatabaseBackup).toBe('function');
       expect(typeof client.listBackupExecutions).toBe('function');
       expect(typeof client.getBackupExecution).toBe('function');
 

src/__tests__/mcp-server.test.ts

@@ -53,6 +53,8 @@ import type {
   CreateDatabaseResponse,
   DatabaseBackup,
   BackupExecution,
+  CreateDatabaseBackupRequest,
+  UpdateDatabaseBackupRequest,
   // Service types
   Service,
   CreateServiceRequest,
@@ -962,6 +964,33 @@ export class CoolifyClient {
     );
   }
 
+  async createDatabaseBackup(
+    databaseUuid: string,
+    data: CreateDatabaseBackupRequest,
+  ): Promise<DatabaseBackup> {
+    return this.request<DatabaseBackup>(`/databases/${databaseUuid}/backups`, {
+      method: 'POST',
+      body: JSON.stringify(data),
+    });
+  }
+
+  async updateDatabaseBackup(
+    databaseUuid: string,
+    backupUuid: string,
+    data: UpdateDatabaseBackupRequest,
+  ): Promise<MessageResponse> {
+    return this.request<MessageResponse>(`/databases/${databaseUuid}/backups/${backupUuid}`, {
+      method: 'PATCH',
+      body: JSON.stringify(data),
+    });
+  }
+
+  async deleteDatabaseBackup(databaseUuid: string, backupUuid: string): Promise<MessageResponse> {
+    return this.request<MessageResponse>(`/databases/${databaseUuid}/backups/${backupUuid}`, {
+      method: 'DELETE',
+    });
+  }
+
   // ===========================================================================
   // Deployment Control endpoints
   // ===========================================================================

src/lib/coolify-client.ts

@@ -1,5 +1,5 @@
 /**
- * Coolify MCP Server v2.0.0
+ * Coolify MCP Server v2.1.0
  * Consolidated tools for efficient token usage
  */
 /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -17,7 +17,7 @@ import {
 } from './coolify-client.js';
 import type { CoolifyConfig } from '../types/coolify.js';
 
-const VERSION = '2.0.0';
+const VERSION = '2.1.0';
 
 /** Wrap handler with error handling */
 function wrap<T>(
@@ -666,14 +666,34 @@ export class CoolifyMcpServer extends McpServer {
     // =========================================================================
     this.tool(
       'database_backups',
-      'Manage backups: list_schedules/get_schedule/list_executions/get_execution',
+      'Manage backups: list_schedules/get_schedule/list_executions/get_execution/create/update/delete',
       {
-        action: z.enum(['list_schedules', 'get_schedule', 'list_executions', 'get_execution']),
+        action: z.enum([
+          'list_schedules',
+          'get_schedule',
+          'list_executions',
+          'get_execution',
+          'create',
+          'update',
+          'delete',
+        ]),
         database_uuid: z.string(),
         backup_uuid: z.string().optional(),
         execution_uuid: z.string().optional(),
+        // Backup configuration parameters
+        frequency: z.string().optional(),
+        enabled: z.boolean().optional(),
+        save_s3: z.boolean().optional(),
+        s3_storage_uuid: z.string().optional(),
+        databases_to_backup: z.string().optional(),
+        dump_all: z.boolean().optional(),
+        database_backup_retention_days_locally: z.number().optional(),
+        database_backup_retention_days_s3: z.number().optional(),
+        database_backup_retention_amount_locally: z.number().optional(),
+        database_backup_retention_amount_s3: z.number().optional(),
       },
-      async ({ action, database_uuid, backup_uuid, execution_uuid }) => {
+      async (args) => {
+        const { action, database_uuid, backup_uuid, execution_uuid, ...backupData } = args;
         switch (action) {
           case 'list_schedules':
             return wrap(() => this.client.listDatabaseBackups(database_uuid));
@@ -695,6 +715,25 @@ export class CoolifyMcpServer extends McpServer {
             return wrap(() =>
               this.client.getBackupExecution(database_uuid, backup_uuid, execution_uuid),
             );
+          case 'create':
+            if (!args.frequency)
+              return { content: [{ type: 'text' as const, text: 'Error: frequency required' }] };
+            return wrap(() =>
+              this.client.createDatabaseBackup(database_uuid, {
+                ...backupData,
+                frequency: args.frequency!,
+              }),
+            );
+          case 'update':
+            if (!backup_uuid)
+              return { content: [{ type: 'text' as const, text: 'Error: backup_uuid required' }] };
+            return wrap(() =>
+              this.client.updateDatabaseBackup(database_uuid, backup_uuid, backupData),
+            );
+          case 'delete':
+            if (!backup_uuid)
+              return { content: [{ type: 'text' as const, text: 'Error: backup_uuid required' }] };
+            return wrap(() => this.client.deleteDatabaseBackup(database_uuid, backup_uuid));
         }
       },
     );

src/lib/mcp-server.ts

@@ -651,9 +651,23 @@ export interface CreateDatabaseBackupRequest {
   s3_storage_uuid?: string;
   databases_to_backup?: string;
   dump_all?: boolean;
-  backup_now?: boolean;
-  backup_retention?: number;
-  backup_retention_days?: number;
+  database_backup_retention_days_locally?: number;
+  database_backup_retention_days_s3?: number;
+  database_backup_retention_amount_locally?: number;
+  database_backup_retention_amount_s3?: number;
+}
+
+export interface UpdateDatabaseBackupRequest {
+  frequency?: string;
+  enabled?: boolean;
+  save_s3?: boolean;
+  s3_storage_uuid?: string;
+  databases_to_backup?: string;
+  dump_all?: boolean;
+  database_backup_retention_days_locally?: number;
+  database_backup_retention_days_s3?: number;
+  database_backup_retention_amount_locally?: number;
+  database_backup_retention_amount_s3?: number;
 }
 
 export interface BackupExecution {