Adds create capability step call

_bruno/Capabilities/Create Capability Step.yml

@@ -0,0 +1,82 @@
+info:
+  name: Create Capability Step
+  type: http
+  seq: 7
+
+http:
+  method: POST
+  url: "{{baseUrl}}/capability-steps"
+  body:
+    type: json
+    data: |-
+      {
+        "flow_step_id": 5,
+        "capability_id": 1,
+        "target": "/api/boats",
+        "protocol": "HTTP"
+      }
+  auth: inherit
+
+runtime:
+  assertions:
+    - expression: res.status
+      operator: eq
+      value: "201"
+
+settings:
+  encodeUrl: true
+  timeout: 0
+  followRedirects: true
+  maxRedirects: 5
+
+examples:
+  - name: example
+    request:
+      url: "{{baseUrl}}/capability-steps"
+      method: POST
+      body:
+        type: json
+        data: |-
+          {
+            "flow_step_id": 5,
+            "capability_id": 1,
+            "target": "/api/boats",
+            "protocol": "HTTP"
+          }
+    response:
+      status: 201
+      statusText: Created
+      headers:
+        - name: content-type
+          value: application/json
+        - name: vary
+          value: Origin, Accept-Encoding
+        - name: date
+          value: Sun, 12 Jul 2026 22:23:36 GMT
+        - name: content-length
+          value: "147"
+      body:
+        type: json
+        data: |-
+          {
+            "id": 1,
+            "capability_id": 1,
+            "flow_step_id": 5,
+            "protocol": "HTTP",
+            "target": "/api/boats",
+            "created_at": "2026-07-12T17:23:36.420794-05:00",
+            "updated_at": "2026-07-12T17:23:36.420794-05:00"
+          }
+
+docs: |-
+  # Create Capability Step
+
+  Creates a new capability step for a capability and flow step
+
+  ## Possible Status Codes
+  | Status Code | Notes |
+  | -- | --|
+  | 201 | Created |
+  | 400 | Invalid body |
+  | 404 | Capability or Flow Step not found | 
+  | 500 | Internal server error |

internal/capability/capabilities.sql

@@ -37,3 +37,17 @@ SELECT name FROM flows WHERE id = @id;
 
 -- name: GetProduct :one
 SELECT name FROM products WHERE id = @id;
+
+-- name: GetFlowStep :one
+SELECT id FROM flow_steps WHERE id = @id;
+
+-- name: CreateCapabilityStep :one
+INSERT INTO capability_steps(capability_id, flow_step_id, protocol, target, created_at, updated_at)
+VALUES(@capability_id, @flow_step_id, @protocol, @target, @timestamp, @timestamp)
+RETURNING *;
+
+-- name: GetCapabilitySteps :many
+SELECT * FROM capability_steps WHERE capability_id = @capability_id;
+
+-- name: DeleteCapabilityStep :execrows
+DELETE FROM capability_steps WHERE capability_id = @capability_id;

internal/capability/handler.go

@@ -154,3 +154,29 @@ func (h *handler) DeleteCapability(w http.ResponseWriter, r *http.Request) {
 	}
 	w.WriteHeader(http.StatusNoContent)
 }
+
+func (h *handler) CreateCapabilityStep(w http.ResponseWriter, r *http.Request) {
+	req := &createCapabilityStepRequest{}
+	if err := json.NewDecoder(r.Body).Decode(req); err != nil {
+		internal.HandleHttpError(w, internal.ErrorEnvelope{Detail: "Invalid Body"}, http.StatusBadRequest)
+		return
+	}
+	err := req.Validate()
+	if err != nil {
+		internal.HandleHttpError(w, internal.ErrorEnvelope{Detail: "Invalid Body"}, http.StatusBadRequest)
+		return
+	}
+	ctxWithTimeout, cancel := context.WithTimeout(r.Context(), 5*time.Second)
+	defer cancel()
+	capStep, err := h.service.CreateCapabilityStep(ctxWithTimeout, *req)
+	if err != nil {
+		if errors.Is(err, internal.NotFoundError{}) {
+			internal.HandleHttpError(w, internal.ErrorEnvelope{Detail: err.Error()}, http.StatusNotFound)
+			return
+		}
+		internal.LoggerFromContext(r.Context()).Error("Failed to create capability step", slog.String("error", err.Error()))
+		internal.HandleHttpError(w, internal.ErrorEnvelope{Detail: "Failed to create capability step"}, http.StatusInternalServerError)
+		return
+	}
+	internal.WriteJSONResponse(w, r, http.StatusCreated, capStep)
+}

internal/capability/handler_command_cap_step_test.go

@@ -0,0 +1,108 @@
+package capability
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"products/internal"
+	"products/internal/capability/db"
+	"testing"
+)
+
+func TestHandler_CreateCapabilityStep(t *testing.T) {
+	tests := []struct {
+		name           string
+		requestBody    any
+		mockSetup      func(m *mockCapabilityService)
+		expectedStatus int
+	}{
+		{
+			name: "Success",
+			requestBody: createCapabilityStepRequest{
+				FlowStepId:   1,
+				CapabilityId: 1,
+				Target:       "Target",
+				Protocol:     "Protocol",
+			},
+			mockSetup: func(m *mockCapabilityService) {
+				m.createCapabilityStepFunc = func(ctx context.Context, req createCapabilityStepRequest) (db.CapabilityStep, error) {
+					return db.CapabilityStep{ID: 1, CapabilityID: req.CapabilityId, FlowStepID: req.FlowStepId}, nil
+				}
+			},
+			expectedStatus: http.StatusCreated,
+		},
+		{
+			name:           "Invalid JSON",
+			requestBody:    "invalid json",
+			mockSetup:      func(m *mockCapabilityService) {},
+			expectedStatus: http.StatusBadRequest,
+		},
+		{
+			name: "Validation Error",
+			requestBody: createCapabilityStepRequest{
+				CapabilityId: 0, // Required
+			},
+			mockSetup:      func(m *mockCapabilityService) {},
+			expectedStatus: http.StatusBadRequest,
+		},
+		{
+			name: "Capability Not Found",
+			requestBody: createCapabilityStepRequest{
+				FlowStepId:   1,
+				CapabilityId: 999,
+				Target:       "Target",
+				Protocol:     "Protocol",
+			},
+			mockSetup: func(m *mockCapabilityService) {
+				m.createCapabilityStepFunc = func(ctx context.Context, req createCapabilityStepRequest) (db.CapabilityStep, error) {
+					return db.CapabilityStep{}, internal.NewNotFoundError(999, "Capability not found")
+				}
+			},
+			expectedStatus: http.StatusNotFound,
+		},
+		{
+			name: "Service Error",
+			requestBody: createCapabilityStepRequest{
+				FlowStepId:   1,
+				CapabilityId: 1,
+				Target:       "Target",
+				Protocol:     "Protocol",
+			},
+			mockSetup: func(m *mockCapabilityService) {
+				m.createCapabilityStepFunc = func(ctx context.Context, req createCapabilityStepRequest) (db.CapabilityStep, error) {
+					return db.CapabilityStep{}, errors.New("service error")
+				}
+			},
+			expectedStatus: http.StatusInternalServerError,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var body []byte
+			if s, ok := tt.requestBody.(string); ok {
+				body = []byte(s)
+			} else {
+				body, _ = json.Marshal(tt.requestBody)
+			}
+
+			req := httptest.NewRequest(http.MethodPost, "/capability-steps", bytes.NewBuffer(body))
+			w := httptest.NewRecorder()
+
+			mockSvc := &mockCapabilityService{}
+			if tt.mockSetup != nil {
+				tt.mockSetup(mockSvc)
+			}
+
+			h := &handler{service: mockSvc}
+			h.CreateCapabilityStep(w, req)
+
+			if w.Code != tt.expectedStatus {
+				t.Errorf("expected status %d, got %d", tt.expectedStatus, w.Code)
+			}
+		})
+	}
+}