Merge pull request #11 from StuMason/feature/database-management

Feature/database management

Author: StuMason

docs/features/006-database-management.md

@@ -42,28 +42,28 @@ Implementation of database management features through MCP resources, allowing u
 
 ## Implementation Checklist
 
-- [ ] Basic Database Management
-
-  - [ ] List databases resource
-  - [ ] Get database details
-  - [ ] Delete database
-  - [ ] Update database configuration
-
-- [ ] Database Type Support
-
-  - [ ] PostgreSQL configuration
-  - [ ] MariaDB configuration
-  - [ ] MySQL configuration
-  - [ ] MongoDB configuration
-  - [ ] Redis configuration
-  - [ ] KeyDB configuration
-  - [ ] Clickhouse configuration
-  - [ ] Dragonfly configuration
-
-- [ ] Resource Testing
-  - [ ] Unit tests for database operations
-  - [ ] Integration tests with mock data
-  - [ ] Live test with real Coolify instance
+- [x] Basic Database Management
+
+  - [x] List databases resource
+  - [x] Get database details
+  - [x] Delete database
+  - [x] Update database configuration
+
+- [x] Database Type Support
+
+  - [x] PostgreSQL configuration
+  - [x] MariaDB configuration
+  - [x] MySQL configuration
+  - [x] MongoDB configuration
+  - [x] Redis configuration
+  - [x] KeyDB configuration
+  - [x] Clickhouse configuration
+  - [x] Dragonfly configuration
+
+- [x] Resource Testing
+  - [x] Unit tests for database operations
+  - [x] Integration tests with mock data
+  - [x] Live test with real Coolify instance
 
 ## Dependencies
 

src/__tests__/coolify-client.test.ts

@@ -341,4 +341,124 @@ describe('CoolifyClient', () => {
       );
     });
   });
+
+  describe('Database Management', () => {
+    const mockDatabase = {
+      id: 1,
+      uuid: 'test-db-uuid',
+      name: 'test-db',
+      description: 'Test database',
+      type: 'postgresql' as const,
+      status: 'running' as const,
+      created_at: '2024-03-06T12:00:00Z',
+      updated_at: '2024-03-06T12:00:00Z',
+      is_public: false,
+      image: 'postgres:latest',
+      postgres_user: 'postgres',
+      postgres_password: 'test123',
+      postgres_db: 'testdb',
+    };
+
+    beforeEach(() => {
+      mockFetch.mockClear();
+    });
+
+    it('should list databases', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve([mockDatabase]),
+      });
+
+      const result = await client.listDatabases();
+
+      expect(result).toEqual([mockDatabase]);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://test.coolify.io/api/v1/databases',
+        expect.objectContaining({
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: 'Bearer test-token',
+          },
+        }),
+      );
+    });
+
+    it('should get database details', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve(mockDatabase),
+      });
+
+      const result = await client.getDatabase('test-db-uuid');
+
+      expect(result).toEqual(mockDatabase);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://test.coolify.io/api/v1/databases/test-db-uuid',
+        expect.objectContaining({
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: 'Bearer test-token',
+          },
+        }),
+      );
+    });
+
+    it('should update database', async () => {
+      const updateData = {
+        name: 'updated-db',
+        description: 'Updated description',
+      };
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({ ...mockDatabase, ...updateData }),
+      });
+
+      const result = await client.updateDatabase('test-db-uuid', updateData);
+
+      expect(result).toEqual({ ...mockDatabase, ...updateData });
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://test.coolify.io/api/v1/databases/test-db-uuid',
+        expect.objectContaining({
+          method: 'PATCH',
+          body: JSON.stringify(updateData),
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: 'Bearer test-token',
+          },
+        }),
+      );
+    });
+
+    it('should delete database', async () => {
+      const mockResponse = { message: 'Database deleted' };
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve(mockResponse),
+      });
+
+      const result = await client.deleteDatabase('test-db-uuid', {
+        deleteConfigurations: true,
+        deleteVolumes: true,
+      });
+
+      expect(result).toEqual(mockResponse);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://test.coolify.io/api/v1/databases/test-db-uuid?delete_configurations=true&delete_volumes=true',
+        expect.objectContaining({
+          method: 'DELETE',
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: 'Bearer test-token',
+          },
+        }),
+      );
+    });
+
+    it('should handle database errors', async () => {
+      const errorMessage = 'Database not found';
+      mockFetch.mockRejectedValue(new Error(errorMessage));
+
+      await expect(client.getDatabase('invalid-uuid')).rejects.toThrow(errorMessage);
+    });
+  });
 });

src/__tests__/mcp-server.test.ts

@@ -193,4 +193,82 @@ describe('CoolifyMcpServer', () => {
       );
     });
   });
+
+  describe('Database Management', () => {
+    const mockDatabase = {
+      id: 1,
+      uuid: 'test-db-uuid',
+      name: 'test-db',
+      description: 'Test database',
+      type: 'postgresql' as const,
+      status: 'running' as const,
+      created_at: '2024-03-06T12:00:00Z',
+      updated_at: '2024-03-06T12:00:00Z',
+      is_public: false,
+      image: 'postgres:latest',
+      postgres_user: 'postgres',
+      postgres_password: 'test123',
+      postgres_db: 'testdb',
+    };
+
+    it('should list databases', async () => {
+      const spy = jest.spyOn(server['client'], 'listDatabases').mockResolvedValue([mockDatabase]);
+
+      const result = await server.list_databases();
+
+      expect(result).toEqual([mockDatabase]);
+      expect(spy).toHaveBeenCalled();
+    });
+
+    it('should get database details', async () => {
+      const spy = jest.spyOn(server['client'], 'getDatabase').mockResolvedValue(mockDatabase);
+
+      const result = await server.get_database('test-db-uuid');
+
+      expect(result).toEqual(mockDatabase);
+      expect(spy).toHaveBeenCalledWith('test-db-uuid');
+    });
+
+    it('should update database', async () => {
+      const updateData = {
+        name: 'updated-db',
+        description: 'Updated description',
+      };
+      const spy = jest
+        .spyOn(server['client'], 'updateDatabase')
+        .mockResolvedValue({ ...mockDatabase, ...updateData, type: 'postgresql' as const });
+
+      const result = await server.update_database('test-db-uuid', updateData);
+
+      expect(result).toEqual({
+        ...mockDatabase,
+        ...updateData,
+        type: 'postgresql',
+      });
+      expect(spy).toHaveBeenCalledWith('test-db-uuid', updateData);
+    });
+
+    it('should delete database', async () => {
+      const mockResponse = { message: 'Database deleted' };
+      const spy = jest.spyOn(server['client'], 'deleteDatabase').mockResolvedValue(mockResponse);
+
+      const result = await server.delete_database('test-db-uuid', {
+        deleteConfigurations: true,
+        deleteVolumes: true,
+      });
+
+      expect(result).toEqual(mockResponse);
+      expect(spy).toHaveBeenCalledWith('test-db-uuid', {
+        deleteConfigurations: true,
+        deleteVolumes: true,
+      });
+    });
+
+    it('should handle database errors', async () => {
+      const errorMessage = 'Database not found';
+      jest.spyOn(server['client'], 'getDatabase').mockRejectedValue(new Error(errorMessage));
+
+      await expect(server.get_database('invalid-uuid')).rejects.toThrow(errorMessage);
+    });
+  });
 });

src/lib/coolify-client.ts

@@ -10,6 +10,8 @@ import {
   UpdateProjectRequest,
   Environment,
   Deployment,
+  Database,
+  DatabaseUpdateRequest,
 } from '../types/coolify.js';
 
 export class CoolifyClient {
@@ -128,5 +130,53 @@ export class CoolifyClient {
     return response;
   }
 
+  async listDatabases(): Promise<Database[]> {
+    return this.request<Database[]>('/databases');
+  }
+
+  async getDatabase(uuid: string): Promise<Database> {
+    return this.request<Database>(`/databases/${uuid}`);
+  }
+
+  async updateDatabase(uuid: string, data: DatabaseUpdateRequest): Promise<Database> {
+    return this.request<Database>(`/databases/${uuid}`, {
+      method: 'PATCH',
+      body: JSON.stringify(data),
+    });
+  }
+
+  async deleteDatabase(
+    uuid: string,
+    options?: {
+      deleteConfigurations?: boolean;
+      deleteVolumes?: boolean;
+      dockerCleanup?: boolean;
+      deleteConnectedNetworks?: boolean;
+    },
+  ): Promise<{ message: string }> {
+    const queryParams = new URLSearchParams();
+    if (options) {
+      if (options.deleteConfigurations !== undefined) {
+        queryParams.set('delete_configurations', options.deleteConfigurations.toString());
+      }
+      if (options.deleteVolumes !== undefined) {
+        queryParams.set('delete_volumes', options.deleteVolumes.toString());
+      }
+      if (options.dockerCleanup !== undefined) {
+        queryParams.set('docker_cleanup', options.dockerCleanup.toString());
+      }
+      if (options.deleteConnectedNetworks !== undefined) {
+        queryParams.set('delete_connected_networks', options.deleteConnectedNetworks.toString());
+      }
+    }
+
+    const queryString = queryParams.toString();
+    const url = queryString ? `/databases/${uuid}?${queryString}` : `/databases/${uuid}`;
+
+    return this.request<{ message: string }>(url, {
+      method: 'DELETE',
+    });
+  }
+
   // Add more methods as needed for other endpoints
 }