mockforge_http/handlers/
semantic_drift.rs

1//! HTTP handlers for semantic drift incidents
2//!
3//! This module provides endpoints for managing semantic drift incidents.
4
5// ContractDiffAnalyzer stays in core (LLM-bound).
6#![allow(deprecated)]
7
8use axum::{
9    extract::{Path, Query, State},
10    http::StatusCode,
11    response::Json,
12};
13use mockforge_core::ai_contract_diff::{ContractDiffAnalyzer, ContractDiffConfig};
14use mockforge_core::incidents::semantic_manager::{SemanticIncident, SemanticIncidentManager};
15use mockforge_openapi::OpenApiSpec;
16use serde::{Deserialize, Serialize};
17use std::sync::Arc;
18
19#[cfg(feature = "database")]
20use chrono::{DateTime, Utc};
21#[cfg(feature = "database")]
22use uuid::Uuid;
23
24use crate::database::Database;
25
26/// Helper function to map database row to SemanticIncident
27#[cfg(feature = "database")]
28fn map_row_to_semantic_incident(
29    row: &sqlx::postgres::PgRow,
30) -> Result<SemanticIncident, sqlx::Error> {
31    use mockforge_core::incidents::types::{IncidentSeverity, IncidentStatus};
32    use mockforge_foundation::contract_diff_types::SemanticChangeType;
33    use sqlx::Row;
34
35    let id: uuid::Uuid = row.try_get("id")?;
36    let workspace_id: Option<uuid::Uuid> = row.try_get("workspace_id").ok();
37    let endpoint: String = row.try_get("endpoint")?;
38    let method: String = row.try_get("method")?;
39    let semantic_change_type_str: String = row.try_get("semantic_change_type")?;
40    let severity_str: String = row.try_get("severity")?;
41    let status_str: String = row.try_get("status")?;
42    let semantic_confidence: f64 = row.try_get("semantic_confidence")?;
43    let soft_breaking_score: f64 = row.try_get("soft_breaking_score")?;
44    let llm_analysis: serde_json::Value = row.try_get("llm_analysis").unwrap_or_default();
45    let before_semantic_state: serde_json::Value =
46        row.try_get("before_semantic_state").unwrap_or_default();
47    let after_semantic_state: serde_json::Value =
48        row.try_get("after_semantic_state").unwrap_or_default();
49    let details_json: serde_json::Value = row.try_get("details").unwrap_or_default();
50    let related_drift_incident_id: Option<uuid::Uuid> =
51        row.try_get("related_drift_incident_id").ok();
52    let contract_diff_id: Option<String> = row.try_get("contract_diff_id").ok();
53    let external_ticket_id: Option<String> = row.try_get("external_ticket_id").ok();
54    let external_ticket_url: Option<String> = row.try_get("external_ticket_url").ok();
55    let detected_at: DateTime<Utc> = row.try_get("detected_at")?;
56    let created_at: DateTime<Utc> = row.try_get("created_at")?;
57    let acknowledged_at: Option<DateTime<Utc>> = row.try_get("acknowledged_at").ok();
58    let resolved_at: Option<DateTime<Utc>> = row.try_get("resolved_at").ok();
59    let closed_at: Option<DateTime<Utc>> = row.try_get("closed_at").ok();
60    let updated_at: DateTime<Utc> = row.try_get("updated_at")?;
61
62    // Parse semantic change type
63    let semantic_change_type = match semantic_change_type_str.as_str() {
64        "description_change" => SemanticChangeType::DescriptionChange,
65        "enum_narrowing" => SemanticChangeType::EnumNarrowing,
66        "nullability_change" => SemanticChangeType::NullableChange,
67        "error_code_removed" => SemanticChangeType::ErrorCodeRemoved,
68        "meaning_shift" => SemanticChangeType::MeaningShift,
69        _ => SemanticChangeType::MeaningShift, // Default fallback
70    };
71
72    // Parse severity
73    let severity = match severity_str.as_str() {
74        "low" => IncidentSeverity::Low,
75        "medium" => IncidentSeverity::Medium,
76        "high" => IncidentSeverity::High,
77        "critical" => IncidentSeverity::Critical,
78        _ => IncidentSeverity::Medium, // Default fallback
79    };
80
81    // Parse status
82    let status = match status_str.as_str() {
83        "open" => IncidentStatus::Open,
84        "acknowledged" => IncidentStatus::Acknowledged,
85        "resolved" => IncidentStatus::Resolved,
86        "closed" => IncidentStatus::Closed,
87        _ => IncidentStatus::Open, // Default fallback
88    };
89
90    Ok(SemanticIncident {
91        id: id.to_string(),
92        workspace_id: workspace_id.map(|u| u.to_string()),
93        endpoint,
94        method,
95        semantic_change_type,
96        severity,
97        status,
98        semantic_confidence,
99        soft_breaking_score,
100        llm_analysis,
101        before_semantic_state,
102        after_semantic_state,
103        details: details_json,
104        related_drift_incident_id: related_drift_incident_id.map(|u| u.to_string()),
105        contract_diff_id,
106        external_ticket_id,
107        external_ticket_url,
108        detected_at: detected_at.timestamp(),
109        created_at: created_at.timestamp(),
110        acknowledged_at: acknowledged_at.map(|dt| dt.timestamp()),
111        resolved_at: resolved_at.map(|dt| dt.timestamp()),
112        closed_at: closed_at.map(|dt| dt.timestamp()),
113        updated_at: updated_at.timestamp(),
114    })
115}
116
117/// State for semantic drift handlers
118#[derive(Clone)]
119pub struct SemanticDriftState {
120    /// Semantic incident manager
121    pub manager: Arc<SemanticIncidentManager>,
122    /// Database connection (optional)
123    pub database: Option<Database>,
124}
125
126/// Query parameters for listing semantic incidents
127#[derive(Debug, Deserialize)]
128pub struct ListSemanticIncidentsQuery {
129    /// Workspace ID filter
130    pub workspace_id: Option<String>,
131    /// Endpoint filter
132    pub endpoint: Option<String>,
133    /// Method filter
134    pub method: Option<String>,
135    /// Status filter
136    pub status: Option<String>,
137    /// Limit results
138    pub limit: Option<usize>,
139}
140
141/// Response for semantic incident list
142#[derive(Debug, Serialize)]
143pub struct SemanticIncidentListResponse {
144    /// Incidents
145    pub incidents: Vec<SemanticIncident>,
146    /// Total count
147    pub total: usize,
148}
149
150/// List semantic drift incidents
151///
152/// GET /api/v1/semantic-drift/incidents
153pub async fn list_semantic_incidents(
154    State(state): State<SemanticDriftState>,
155    Query(params): Query<ListSemanticIncidentsQuery>,
156) -> Result<Json<SemanticIncidentListResponse>, StatusCode> {
157    // Try database first, fallback to in-memory
158    #[cfg(feature = "database")]
159    if let Some(pool) = state.database.as_ref().and_then(|db| db.pool()) {
160        let mut query = String::from(
161            "SELECT id, workspace_id, endpoint, method, semantic_change_type, severity, status,
162             semantic_confidence, soft_breaking_score, llm_analysis, before_semantic_state,
163             after_semantic_state, details, related_drift_incident_id, contract_diff_id,
164             external_ticket_id, external_ticket_url, detected_at, created_at, acknowledged_at,
165             resolved_at, closed_at, updated_at
166             FROM semantic_drift_incidents WHERE 1=1",
167        );
168
169        let mut bind_index = 1;
170
171        if let Some(_ws_id) = &params.workspace_id {
172            query.push_str(&format!(" AND workspace_id = ${}", bind_index));
173            bind_index += 1;
174        }
175
176        if let Some(_ep) = &params.endpoint {
177            query.push_str(&format!(" AND endpoint = ${}", bind_index));
178            bind_index += 1;
179        }
180
181        if let Some(_m) = &params.method {
182            query.push_str(&format!(" AND method = ${}", bind_index));
183            bind_index += 1;
184        }
185
186        if let Some(_status_str) = &params.status {
187            query.push_str(&format!(" AND status = ${}", bind_index));
188        }
189
190        let limit = params.limit.unwrap_or(100);
191        query.push_str(&format!(" ORDER BY detected_at DESC LIMIT {}", limit));
192
193        // Execute query - use fetch_all for SELECT queries
194        let rows = sqlx::query(&query).fetch_all(pool).await.map_err(|e| {
195            tracing::error!("Failed to query semantic incidents: {}", e);
196            StatusCode::INTERNAL_SERVER_ERROR
197        })?;
198
199        // Map rows to SemanticIncident
200        let mut incidents = Vec::new();
201        for row in rows {
202            match map_row_to_semantic_incident(&row) {
203                Ok(incident) => incidents.push(incident),
204                Err(e) => {
205                    tracing::warn!("Failed to map semantic incident row: {}", e);
206                    continue;
207                }
208            }
209        }
210        if !incidents.is_empty() {
211            return Ok(Json(SemanticIncidentListResponse {
212                total: incidents.len(),
213                incidents,
214            }));
215        }
216        // Fall through to in-memory manager if no database results
217    }
218
219    // Fallback to in-memory manager
220    let status = params.status.as_deref().and_then(|s| match s {
221        "open" => Some(mockforge_core::incidents::types::IncidentStatus::Open),
222        "acknowledged" => Some(mockforge_core::incidents::types::IncidentStatus::Acknowledged),
223        "resolved" => Some(mockforge_core::incidents::types::IncidentStatus::Resolved),
224        "closed" => Some(mockforge_core::incidents::types::IncidentStatus::Closed),
225        _ => None,
226    });
227
228    let incidents = state
229        .manager
230        .list_incidents(
231            params.workspace_id.as_deref(),
232            params.endpoint.as_deref(),
233            params.method.as_deref(),
234            status,
235            params.limit,
236        )
237        .await;
238
239    Ok(Json(SemanticIncidentListResponse {
240        total: incidents.len(),
241        incidents,
242    }))
243}
244
245/// Get a specific semantic incident
246///
247/// GET /api/v1/semantic-drift/incidents/{id}
248pub async fn get_semantic_incident(
249    State(state): State<SemanticDriftState>,
250    Path(id): Path<String>,
251) -> Result<Json<SemanticIncident>, StatusCode> {
252    // Try database first
253    #[cfg(feature = "database")]
254    if let Some(pool) = state.database.as_ref().and_then(|db| db.pool()) {
255        let row = sqlx::query("SELECT * FROM semantic_drift_incidents WHERE id = $1")
256            .bind(&id)
257            .fetch_optional(pool)
258            .await
259            .map_err(|e| {
260                tracing::error!("Failed to query semantic incident: {}", e);
261                StatusCode::INTERNAL_SERVER_ERROR
262            })?;
263
264        if let Some(row) = row {
265            match map_row_to_semantic_incident(&row) {
266                Ok(incident) => return Ok(Json(incident)),
267                Err(e) => {
268                    tracing::warn!("Failed to map semantic incident: {}", e);
269                    // Fall through to in-memory
270                }
271            }
272        }
273    }
274
275    // Fallback to in-memory manager
276    match state.manager.get_incident(&id).await {
277        Some(incident) => Ok(Json(incident)),
278        None => Err(StatusCode::NOT_FOUND),
279    }
280}
281
282/// Request to analyze semantic drift
283#[derive(Debug, Deserialize)]
284pub struct AnalyzeSemanticDriftRequest {
285    /// Before spec (OpenAPI YAML/JSON)
286    pub before_spec: String,
287    /// After spec (OpenAPI YAML/JSON)
288    pub after_spec: String,
289    /// Endpoint path
290    pub endpoint: String,
291    /// HTTP method
292    pub method: String,
293    /// Workspace ID (optional)
294    pub workspace_id: Option<String>,
295}
296
297/// Analyze semantic drift between two specs
298///
299/// POST /api/v1/semantic-drift/analyze
300pub async fn analyze_semantic_drift(
301    State(state): State<SemanticDriftState>,
302    Json(request): Json<AnalyzeSemanticDriftRequest>,
303) -> Result<Json<serde_json::Value>, StatusCode> {
304    // Parse specs
305    let before_spec = OpenApiSpec::from_string(&request.before_spec, None)
306        .map_err(|_| StatusCode::BAD_REQUEST)?;
307    let after_spec =
308        OpenApiSpec::from_string(&request.after_spec, None).map_err(|_| StatusCode::BAD_REQUEST)?;
309
310    // Create analyzer
311    let config = ContractDiffConfig::default();
312    let analyzer =
313        ContractDiffAnalyzer::new(config).map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
314
315    // Run semantic analysis
316    let semantic_result = analyzer
317        .compare_specs(&before_spec, &after_spec, &request.endpoint, &request.method)
318        .await
319        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
320
321    if let Some(result) = semantic_result {
322        // Create semantic incident if threshold met
323        if result.semantic_confidence >= 0.65 {
324            let incident = state
325                .manager
326                .create_incident(
327                    &result,
328                    request.endpoint.clone(),
329                    request.method.clone(),
330                    request.workspace_id.clone(),
331                    None, // related_drift_incident_id
332                    None, // contract_diff_id
333                )
334                .await;
335
336            // Store in database if available
337            #[cfg(feature = "database")]
338            if let Some(pool) = state.database.as_ref().and_then(|db| db.pool()) {
339                if let Err(e) = store_semantic_incident(pool, &incident).await {
340                    tracing::warn!("Failed to store semantic incident in database: {}", e);
341                }
342            }
343
344            return Ok(Json(serde_json::json!({
345                "success": true,
346                "semantic_drift_detected": true,
347                "incident_id": incident.id,
348                "semantic_confidence": result.semantic_confidence,
349                "soft_breaking_score": result.soft_breaking_score,
350                "change_type": format!("{:?}", result.change_type),
351            })));
352        }
353    }
354
355    Ok(Json(serde_json::json!({
356        "success": true,
357        "semantic_drift_detected": false,
358        "message": "No significant semantic drift detected"
359    })))
360}
361
362/// Store semantic incident in database
363#[cfg(feature = "database")]
364async fn store_semantic_incident(
365    pool: &sqlx::PgPool,
366    incident: &SemanticIncident,
367) -> Result<(), sqlx::Error> {
368    let id = Uuid::parse_str(&incident.id).unwrap_or_else(|_| Uuid::new_v4());
369    let workspace_uuid = incident.workspace_id.as_ref().and_then(|id| Uuid::parse_str(id).ok());
370    let related_uuid = incident
371        .related_drift_incident_id
372        .as_ref()
373        .and_then(|id| Uuid::parse_str(id).ok());
374
375    sqlx::query(
376        r#"
377        INSERT INTO semantic_drift_incidents (
378            id, workspace_id, endpoint, method, semantic_change_type, severity, status,
379            semantic_confidence, soft_breaking_score, llm_analysis, before_semantic_state,
380            after_semantic_state, details, related_drift_incident_id, contract_diff_id,
381            external_ticket_id, external_ticket_url, detected_at, created_at, updated_at
382        ) VALUES (
383            $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20
384        )
385        ON CONFLICT (id) DO UPDATE SET
386            status = EXCLUDED.status,
387            acknowledged_at = EXCLUDED.acknowledged_at,
388            resolved_at = EXCLUDED.resolved_at,
389            closed_at = EXCLUDED.closed_at,
390            updated_at = EXCLUDED.updated_at
391        "#,
392    )
393    .bind(id)
394    .bind(workspace_uuid)
395    .bind(&incident.endpoint)
396    .bind(&incident.method)
397    .bind(format!("{:?}", incident.semantic_change_type))
398    .bind(format!("{:?}", incident.severity))
399    .bind(format!("{:?}", incident.status))
400    .bind(incident.semantic_confidence)
401    .bind(incident.soft_breaking_score)
402    .bind(&incident.llm_analysis)
403    .bind(&incident.before_semantic_state)
404    .bind(&incident.after_semantic_state)
405    .bind(&incident.details)
406    .bind(related_uuid)
407    .bind(incident.contract_diff_id.as_deref())
408    .bind(incident.external_ticket_id.as_deref())
409    .bind(incident.external_ticket_url.as_deref())
410    .bind(DateTime::<Utc>::from_timestamp(incident.detected_at, 0).unwrap_or_else(Utc::now))
411    .bind(DateTime::<Utc>::from_timestamp(incident.created_at, 0).unwrap_or_else(Utc::now))
412    .bind(DateTime::<Utc>::from_timestamp(incident.updated_at, 0).unwrap_or_else(Utc::now))
413    .execute(pool)
414    .await?;
415
416    Ok(())
417}
418
419/// Create router for semantic drift endpoints
420pub fn semantic_drift_router(state: SemanticDriftState) -> axum::Router {
421    use axum::routing::{get, post};
422    use axum::Router;
423
424    Router::new()
425        .route("/api/v1/semantic-drift/incidents", get(list_semantic_incidents))
426        .route("/api/v1/semantic-drift/incidents/{id}", get(get_semantic_incident))
427        .route("/api/v1/semantic-drift/analyze", post(analyze_semantic_drift))
428        .with_state(state)
429}
mockforge_http/handlers/semantic_drift.rs

mockforge_http/handlers/
semantic_drift.rs
