feat(api): Add validation for DatabaseConfigRequest

Add Validate() method to DatabaseConfigRequest that validates:
- Database type (mysql, postgres, mariadb, mongodb, redis)
- Mode (shared, create, existing, external)
- Required fields based on mode:
  - existing mode requires existing_container
  - external mode requires external_host and positive external_port

Validation is called in createDeployment handler before processing
databases array.

Signed-off-by: nfebe <fenn25.fn@gmail.com>

Author: nfebe

internal/api/multi_database_test.go

@@ -111,11 +111,12 @@ func TestGenerateDatabaseEnvVars(t *testing.T) {
 	}
 }
 
-func TestDatabaseConfigRequest_Validation(t *testing.T) {
+func TestDatabaseConfigRequest_Validate(t *testing.T) {
 	tests := []struct {
 		name    string
 		req     DatabaseConfigRequest
 		wantErr bool
+		errMsg  string
 	}{
 		{
 			name: "valid shared database config",
@@ -150,23 +151,131 @@ func TestDatabaseConfigRequest_Validation(t *testing.T) {
 			},
 			wantErr: false,
 		},
+		{
+			name: "valid create mode config",
+			req: DatabaseConfigRequest{
+				Alias: "newdb",
+				Type:  "mariadb",
+				Mode:  "create",
+			},
+			wantErr: false,
+		},
+		{
+			name: "invalid database type",
+			req: DatabaseConfigRequest{
+				Alias: "test",
+				Type:  "oracle",
+				Mode:  "shared",
+			},
+			wantErr: true,
+			errMsg:  "invalid database type",
+		},
+		{
+			name: "invalid mode",
+			req: DatabaseConfigRequest{
+				Alias: "test",
+				Type:  "mysql",
+				Mode:  "invalid",
+			},
+			wantErr: true,
+			errMsg:  "invalid database mode",
+		},
+		{
+			name: "existing mode missing container",
+			req: DatabaseConfigRequest{
+				Alias: "test",
+				Type:  "mysql",
+				Mode:  "existing",
+			},
+			wantErr: true,
+			errMsg:  "existing_container is required",
+		},
+		{
+			name: "external mode missing host",
+			req: DatabaseConfigRequest{
+				Alias:        "test",
+				Type:         "postgres",
+				Mode:         "external",
+				ExternalPort: 5432,
+			},
+			wantErr: true,
+			errMsg:  "external_host is required",
+		},
+		{
+			name: "external mode missing port",
+			req: DatabaseConfigRequest{
+				Alias:        "test",
+				Type:         "postgres",
+				Mode:         "external",
+				ExternalHost: "db.example.com",
+			},
+			wantErr: true,
+			errMsg:  "external_port must be a positive integer",
+		},
+		{
+			name: "external mode with zero port",
+			req: DatabaseConfigRequest{
+				Alias:        "test",
+				Type:         "postgres",
+				Mode:         "external",
+				ExternalHost: "db.example.com",
+				ExternalPort: 0,
+			},
+			wantErr: true,
+			errMsg:  "external_port must be a positive integer",
+		},
+		{
+			name: "external mode with negative port",
+			req: DatabaseConfigRequest{
+				Alias:        "test",
+				Type:         "postgres",
+				Mode:         "external",
+				ExternalHost: "db.example.com",
+				ExternalPort: -1,
+			},
+			wantErr: true,
+			errMsg:  "external_port must be a positive integer",
+		},
+		{
+			name: "valid mongodb config",
+			req: DatabaseConfigRequest{
+				Alias: "mongo",
+				Type:  "mongodb",
+				Mode:  "shared",
+			},
+			wantErr: false,
+		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if tt.req.Alias == "" && !tt.wantErr {
-				t.Error("alias should not be empty for valid config")
-			}
-			if tt.req.Type == "" && !tt.wantErr {
-				t.Error("type should not be empty for valid config")
-			}
-			if tt.req.Mode == "" && !tt.wantErr {
-				t.Error("mode should not be empty for valid config")
+			err := tt.req.Validate()
+			if tt.wantErr {
+				if err == nil {
+					t.Errorf("Validate() expected error containing %q, got nil", tt.errMsg)
+					return
+				}
+				if tt.errMsg != "" && !containsSubstring(err.Error(), tt.errMsg) {
+					t.Errorf("Validate() error = %q, want error containing %q", err.Error(), tt.errMsg)
+				}
+			} else {
+				if err != nil {
+					t.Errorf("Validate() unexpected error: %v", err)
+				}
 			}
 		})
 	}
 }
 
+func containsSubstring(s, substr string) bool {
+	for i := 0; i <= len(s)-len(substr); i++ {
+		if s[i:i+len(substr)] == substr {
+			return true
+		}
+	}
+	return false
+}
+
 func TestMultipleDatabaseConfigs(t *testing.T) {
 	metadata := &models.ServiceMetadata{
 		Name: "myapp",

internal/api/server.go

@@ -591,6 +591,39 @@ type DatabaseConfigRequest struct {
 	EnvPrefix         string `json:"env_prefix,omitempty"`
 }
 
+func (d *DatabaseConfigRequest) Validate() error {
+	validTypes := map[string]bool{
+		"mysql": true, "postgres": true, "mariadb": true,
+		"mongodb": true, "redis": true,
+	}
+	if !validTypes[d.Type] {
+		return fmt.Errorf("invalid database type: %s (must be mysql, postgres, mariadb, mongodb, or redis)", d.Type)
+	}
+
+	validModes := map[string]bool{
+		"shared": true, "create": true, "existing": true, "external": true,
+	}
+	if !validModes[d.Mode] {
+		return fmt.Errorf("invalid database mode: %s (must be shared, create, existing, or external)", d.Mode)
+	}
+
+	switch d.Mode {
+	case "existing":
+		if d.ExistingContainer == "" {
+			return fmt.Errorf("existing_container is required for mode 'existing'")
+		}
+	case "external":
+		if d.ExternalHost == "" {
+			return fmt.Errorf("external_host is required for mode 'external'")
+		}
+		if d.ExternalPort <= 0 {
+			return fmt.Errorf("external_port must be a positive integer for mode 'external'")
+		}
+	}
+
+	return nil
+}
+
 func (s *Server) createDeployment(c *gin.Context) {
 	var req struct {
 		Name                      string                  `json:"name" binding:"required"`
@@ -694,6 +727,15 @@ func (s *Server) createDeployment(c *gin.Context) {
 	var databaseConfigs []models.DatabaseConfig
 
 	if len(req.Databases) > 0 {
+		for i, dbReq := range req.Databases {
+			if err := dbReq.Validate(); err != nil {
+				c.JSON(http.StatusBadRequest, gin.H{
+					"error": fmt.Sprintf("invalid database configuration at index %d: %s", i, err.Error()),
+				})
+				return
+			}
+		}
+
 		envVars, configs, err := s.createDatabasesForDeployment(req.Name, req.Databases)
 		if err != nil {
 			c.JSON(http.StatusInternalServerError, gin.H{