foxhunt/WAVE_14_26_FIX_GUIDE.md

# WAVE 14.26: COMPILATION FIX GUIDE

**Mission**: Fix 19 compilation errors in trading_service
**Estimated Time**: 2-4 hours
**Approach**: Systematic, one file at a time, TDD methodology

---

## Error Summary

**Total**: 19 errors in trading_service
**Files Affected**: 4 files
**Root Causes**: Type system migrations (i32→i64, f64→BigDecimal), SQLX schema drift, API changes

---

## Fix Strategy (Priority Order)

### Phase 1: SQLX Schema Sync (15 minutes)

**Problem**: Database schema changed (i32→i64, f64→Decimal) but Rust code not updated

**Command**:
```bash
# Regenerate SQLX metadata
cargo sqlx prepare --workspace --database-url postgresql://foxhunt:foxhunt_dev_password@localhost:5432/foxhunt

# If that fails, try database-first approach
psql postgresql://foxhunt:foxhunt_dev_password@localhost:5432/foxhunt -c "\d+ ensemble_predictions"
psql postgresql://foxhunt:foxhunt_dev_password@localhost:5432/foxhunt -c "\d+ ml_performance_outcomes"
```

**Expected Outcome**: Updated `.sqlx/` metadata files with correct types

---

### Phase 2: Fix ensemble_audit_logger.rs (4 errors) ⏱️ 30-45 min

**File**: `services/trading_service/src/ensemble_audit_logger.rs`

#### Error 1: Line 527 - SQLX query type mismatch

**Error**:
```
error[E0277]: the trait bound `Option<i64>: From<Option<i32>>` is not satisfied
   --> services/trading_service/src/ensemble_audit_logger.rs:527:23
```

**Diagnosis**:
- Database column is `BIGINT` (i64)
- Rust struct expects `Option<i32>`

**Fix**:
```rust
// BEFORE
struct AuditLogEntry {
    inference_latency_us: Option<i32>,
    // ...
}

// AFTER
struct AuditLogEntry {
    inference_latency_us: Option<i64>,  // Match database BIGINT
    // ...
}
```

#### Error 2: Line 527 - SQLX query type mismatch (f64/Decimal)

**Error**:
```
error[E0277]: the trait bound `Option<f64>: From<Option<i64>>` is not satisfied
```

**Diagnosis**:
- Database column might be `NUMERIC` or `BIGINT`
- Rust struct expects `Option<f64>`

**Fix**:
```rust
// Check database schema first
// psql -c "\d+ ensemble_predictions" | grep signal

// If database is NUMERIC/DECIMAL:
use rust_decimal::Decimal;

struct AuditLogEntry {
    dqn_signal: Option<Decimal>,
    // ...
}

// If database is DOUBLE PRECISION (f64):
struct AuditLogEntry {
    dqn_signal: Option<f64>,
    // ...
}
```

#### Error 3: Line 539 - Type mismatch with limit

**Error**:
```
error[E0308]: mismatched types
   --> services/trading_service/src/ensemble_audit_logger.rs:539:13
    |
539 |             limit,
    |             ^^^^^ expected `i64`, found `i32`
```

**Fix**:
```rust
// BEFORE
let limit: i32 = ...;

// AFTER
let limit: i64 = ...;
```

#### Error 4: Related parameter types

**Fix Strategy**:
1. Check all parameter types match database schema
2. Convert i32→i64 where needed
3. Ensure Option<T> types match exactly

**Validation**:
```bash
cargo test -p trading_service --lib ensemble_audit_logger::tests
```

---

### Phase 3: Fix ml_performance_metrics.rs (6 errors) ⏱️ 45-60 min

**File**: `services/trading_service/src/ml_performance_metrics.rs`

#### Error 1: Line 113 - PnL type mismatch

**Error**:
```
error[E0308]: mismatched types
   --> services/trading_service/src/ml_performance_metrics.rs:113:13
    |
113 |             outcome.pnl,
```

**Diagnosis**:
- `outcome.pnl` is `BigDecimal` or `Decimal`
- Expected type is `f64`

**Fix**:
```rust
use rust_decimal::Decimal;
use rust_decimal::prelude::ToPrimitive;

// BEFORE
let pnl = outcome.pnl;  // BigDecimal

// AFTER
let pnl = outcome.pnl.to_f64().unwrap_or(0.0);  // Convert to f64
```

#### Error 2: Line 115 - prediction_id type mismatch

**Error**:
```
error[E0308]: mismatched types
   --> services/trading_service/src/ml_performance_metrics.rs:115:13
    |
115 |             outcome.prediction_id,
```

**Diagnosis**:
- `prediction_id` might be `Option<Uuid>` but expected `Uuid`
- Or type changed from `String` to `Uuid`

**Fix**:
```rust
// If Option<Uuid> → Uuid:
let prediction_id = outcome.prediction_id.unwrap_or_else(|| Uuid::nil());

// If String → Uuid:
let prediction_id = Uuid::parse_str(&outcome.prediction_id).unwrap_or_else(|_| Uuid::nil());
```

#### Error 3: Line 164 - i64.unwrap_or() not found

**Error**:
```
error[E0599]: no method named `unwrap_or` found for type `i64` in the current scope
   --> services/trading_service/src/ml_performance_metrics.rs:164:50
    |
164 |         let correct = result.correct_predictions.unwrap_or(0);
```

**Diagnosis**:
- `correct_predictions` is `i64`, not `Option<i64>`
- Database query changed from nullable to NOT NULL

**Fix**:
```rust
// BEFORE
let correct = result.correct_predictions.unwrap_or(0);  // Error: i64 has no unwrap_or

// AFTER (if database column is NOT NULL):
let correct = result.correct_predictions;  // Already i64

// OR (if still nullable in database):
struct QueryResult {
    correct_predictions: Option<i64>,  // Change struct definition
}
let correct = result.correct_predictions.unwrap_or(0);  // Now works
```

#### Error 4: Line 205 - avg_pnl type mismatch

**Error**:
```
error[E0308]: mismatched types
   --> services/trading_service/src/ml_performance_metrics.rs:205:48
    |
205 |         let avg_pnl = result.avg_pnl.unwrap_or(0.0);
```

**Diagnosis**:
- `avg_pnl` is `Option<Decimal>` but code expects `Option<f64>`

**Fix**:
```rust
use rust_decimal::prelude::ToPrimitive;

// BEFORE
let avg_pnl = result.avg_pnl.unwrap_or(0.0);  // Type mismatch

// AFTER
let avg_pnl = result.avg_pnl
    .and_then(|d| d.to_f64())
    .unwrap_or(0.0);
```

#### Errors 5-6: Related type conversions

**Fix Strategy**:
1. Convert all `Decimal` to `f64` using `.to_f64()`
2. Handle Option<Decimal> with `.and_then(|d| d.to_f64())`
3. Check database schema for nullable columns

**Validation**:
```bash
cargo test -p trading_service --lib ml_performance_metrics::tests
```

---

### Phase 4: Fix orders.rs (8 errors) ⏱️ 60-90 min

**File**: `services/trading_service/src/orders.rs`

#### Error Category 1: BigDecimal Arithmetic (3-4 errors)

**Error**:
```
error[E0277]: cannot multiply `rust_decimal::Decimal` by `f64`
   --> services/trading_service/src/orders.rs:XXX
```

**Diagnosis**:
- Code tries to multiply `BigDecimal * f64`
- Rust requires same types for arithmetic

**Fix Strategy A** (Convert to Decimal):
```rust
use rust_decimal::Decimal;
use std::str::FromStr;

// BEFORE
let total = price * quantity;  // price: Decimal, quantity: f64

// AFTER
let quantity_decimal = Decimal::from_str(&quantity.to_string()).unwrap();
let total = price * quantity_decimal;
```

**Fix Strategy B** (Convert to f64):
```rust
use rust_decimal::prelude::ToPrimitive;

// BEFORE
let total = price * quantity;  // price: Decimal, quantity: f64

// AFTER
let price_f64 = price.to_f64().unwrap_or(0.0);
let total = price_f64 * quantity;
```

**Recommendation**: Use Strategy B (convert to f64) for performance-critical paths

#### Error Category 2: DateTime.and_utc() not found (1 error)

**Error**:
```
error[E0599]: no method named `and_utc` found for struct `chrono::DateTime` in the current scope
   --> services/trading_service/src/orders.rs:XXX
```

**Diagnosis**:
- Chrono API changed
- `DateTime<Utc>.and_utc()` is redundant (already UTC)

**Fix**:
```rust
use chrono::{DateTime, Utc};

// BEFORE
let timestamp = some_naive_datetime.and_utc();  // Method not found

// AFTER (if NaiveDateTime → DateTime<Utc>):
let timestamp = DateTime::from_naive_utc_and_offset(some_naive_datetime, Utc);

// OR (if already DateTime<Utc>):
let timestamp = some_datetime;  // No conversion needed
```

#### Error Category 3: Option<String> to String conversion (2-3 errors)

**Error**:
```
error[E0277]: a value of type `Vec<(String, f64)>` cannot be built from an iterator over elements of type `(Option<String>, f64)`
   --> services/trading_service/src/orders.rs:XXX
```

**Diagnosis**:
- SQLX query returns `Option<String>`
- Code expects `String` (not nullable)

**Fix**:
```rust
// BEFORE
let results: Vec<(String, f64)> = sqlx::query_as!(...)
    .fetch_all(&pool)
    .await?
    .into_iter()
    .collect();  // Error: Option<String> ≠ String

// AFTER (filter out nulls):
let results: Vec<(String, f64)> = sqlx::query_as!(...)
    .fetch_all(&pool)
    .await?
    .into_iter()
    .filter_map(|(opt_str, val)| opt_str.map(|s| (s, val)))
    .collect();

// OR (provide default):
let results: Vec<(String, f64)> = sqlx::query_as!(...)
    .fetch_all(&pool)
    .await?
    .into_iter()
    .map(|(opt_str, val)| (opt_str.unwrap_or_default(), val))
    .collect();
```

#### Error Category 4: Miscellaneous type mismatches (2 errors)

**Fix Strategy**:
1. Read error message carefully
2. Check database schema with `\d+ table_name`
3. Update Rust struct to match database types
4. Handle Option<T> conversions

**Validation**:
```bash
cargo test -p trading_service --lib orders::tests
```

---

### Phase 5: Fix services/trading.rs (1 error) ⏱️ 15-30 min

**File**: `services/trading_service/src/services/trading.rs`

#### Error: Line 1129 - Match arms incompatible types

**Error**:
```
error[E0308]: `match` arms have incompatible types
   --> services/trading_service/src/services/trading.rs:1129:17
    |
1107 |           let predictions = match model_name {
     |  ___________________________-
1108 | |             "DQN" => {...}    // Returns Result<Vec<...>>
1109 | |             "PPO" => {...}    // Returns Vec<...>  ← Type mismatch
     | |_________________________- `match` arms have incompatible types
```

**Diagnosis**:
- One match arm returns `Result<Vec<T>>`
- Another match arm returns `Vec<T>`
- Rust requires all arms to return same type

**Fix**:
```rust
// BEFORE
let predictions = match model_name {
    "DQN" => self.get_dqn_predictions()?,      // Returns Vec<...>
    "PPO" => self.get_ppo_predictions(),       // Returns Vec<...>
    "MAMBA2" => Err(anyhow!("Not found"))?,    // Returns Result
    _ => vec![],
};

// AFTER (all arms return Result):
let predictions = match model_name {
    "DQN" => self.get_dqn_predictions(),       // Returns Result<Vec<...>>
    "PPO" => self.get_ppo_predictions(),       // Returns Result<Vec<...>>
    "MAMBA2" => Err(anyhow!("Not found")),     // Returns Result
    _ => Ok(vec![]),                           // Returns Result
}?;  // Unwrap outside match
```

**Validation**:
```bash
cargo test -p trading_service --lib services::trading::tests
```

---

## Verification Steps

### After Each Phase

```bash
# Compile specific file
cargo build -p trading_service --lib

# Run tests
cargo test -p trading_service --lib

# Check progress
cargo build -p trading_service 2>&1 | grep -c "error"
```

### After All Fixes

```bash
# Full workspace compilation
cargo build --workspace --release

# Should output:
# Finished release [optimized] target(s) in X.XXs
# (NO errors)

# Run all tests
cargo test --workspace

# Should show:
# test result: ok. X passed; 0 failed; Y ignored
```

---

## Common Patterns

### Pattern 1: Database i32 → i64 Migration

```rust
// BEFORE
struct MyStruct {
    count: i32,
    latency_us: Option<i32>,
}

// AFTER
struct MyStruct {
    count: i64,
    latency_us: Option<i64>,
}
```

### Pattern 2: f64 → BigDecimal Migration

```rust
use rust_decimal::Decimal;
use rust_decimal::prelude::ToPrimitive;

// BEFORE
struct Order {
    price: f64,
    quantity: f64,
}

// AFTER
struct Order {
    price: Decimal,
    quantity: Decimal,
}

// Arithmetic:
let total = price.to_f64().unwrap() * quantity.to_f64().unwrap();
```

### Pattern 3: Option<T> Handling

```rust
// Pattern A: Unwrap with default
let value = option_value.unwrap_or(0);

// Pattern B: Convert and unwrap
let value = option_decimal
    .and_then(|d| d.to_f64())
    .unwrap_or(0.0);

// Pattern C: Filter nulls in iterator
let results: Vec<T> = query_results
    .into_iter()
    .filter_map(|opt| opt)
    .collect();
```

---

## Database Schema Reference

### Quick Schema Inspection

```bash
# Connect to database
psql postgresql://foxhunt:foxhunt_dev_password@localhost:5432/foxhunt

# Check table structure
\d+ ensemble_predictions
\d+ ml_performance_outcomes
\d+ orders
\d+ positions

# Check column types
SELECT column_name, data_type, is_nullable
FROM information_schema.columns
WHERE table_name = 'ensemble_predictions';
```

### Common Type Mappings

| PostgreSQL Type | Rust Type | SQLX Mapping |
|----------------|-----------|--------------|
| BIGINT | i64 | i64 |
| INTEGER | i32 | i32 |
| SMALLINT | i16 | i16 |
| NUMERIC/DECIMAL | Decimal | rust_decimal::Decimal |
| DOUBLE PRECISION | f64 | f64 |
| REAL | f32 | f32 |
| TEXT/VARCHAR | String | String |
| BOOLEAN | bool | bool |
| TIMESTAMP | DateTime<Utc> | chrono::DateTime<Utc> |
| UUID | Uuid | uuid::Uuid |

---

## TDD Methodology

### For Each Fix

1. **RED**: Verify error exists
   ```bash
   cargo build -p trading_service 2>&1 | grep "error\[E"
   ```

2. **GREEN**: Apply fix
   ```bash
   # Edit file
   # Save
   cargo build -p trading_service
   ```

3. **REFACTOR**: Run tests
   ```bash
   cargo test -p trading_service --lib
   ```

4. **VALIDATE**: Check overall progress
   ```bash
   cargo build --workspace 2>&1 | grep -c "error"
   ```

---

## Success Criteria

### Phase Completion

- ✅ Phase 1: SQLX metadata regenerated
- ✅ Phase 2: ensemble_audit_logger.rs compiles (0 errors)
- ✅ Phase 3: ml_performance_metrics.rs compiles (0 errors)
- ✅ Phase 4: orders.rs compiles (0 errors)
- ✅ Phase 5: services/trading.rs compiles (0 errors)

### Final Validation

```bash
# Zero compilation errors
cargo build --workspace --release
# Expected: "Finished release [optimized] target(s)"

# High test pass rate
cargo test --workspace
# Expected: >1,200 tests passing (95%+)

# Clean status
cargo clippy --workspace -- -D warnings
# Expected: 0 errors, <50 warnings
```

---

## Troubleshooting

### If SQLX Metadata Generation Fails

```bash
# Check database connection
psql postgresql://foxhunt:foxhunt_dev_password@localhost:5432/foxhunt -c "SELECT 1"

# Regenerate with force
cargo sqlx prepare --workspace --database-url postgresql://foxhunt:foxhunt_dev_password@localhost:5432/foxhunt -- --all-features

# Check .sqlx directory
ls -lh .sqlx/
```

### If Types Still Mismatch After Schema Sync

```bash
# Manually inspect database schema
psql postgresql://foxhunt:foxhunt_dev_password@localhost:5432/foxhunt

# Compare with Rust struct
rg "struct.*Prediction" services/trading_service/src/

# Update Rust struct to match database exactly
```

### If Tests Fail After Compilation Succeeds

```bash
# Run specific test
cargo test -p trading_service --lib test_name -- --nocapture

# Check test logs
cat target/debug/deps/trading_service-*.log

# Debug with prints
# Add println! statements in code
# Recompile and rerun
```

---

## Estimated Timeline

| Phase | Task | Time | Cumulative |
|-------|------|------|------------|
| 1 | SQLX schema sync | 15 min | 15 min |
| 2 | Fix ensemble_audit_logger.rs | 30-45 min | 45-60 min |
| 3 | Fix ml_performance_metrics.rs | 45-60 min | 90-120 min |
| 4 | Fix orders.rs | 60-90 min | 150-210 min |
| 5 | Fix services/trading.rs | 15-30 min | 165-240 min |
| - | **Total** | **2.75-4 hours** | - |

**Target**: Complete all fixes in one session (2-4 hours)

---

## Next Steps After Compilation Succeeds

1. **Run Full Test Suite** (1 hour)
   ```bash
   cargo test --workspace
   ```

2. **Measure Coverage** (1 hour)
   ```bash
   cargo llvm-cov --workspace --html --output-dir coverage_report
   ```

3. **Execute Smoke Tests** (2-3 hours)
   - Start all services
   - Verify health checks
   - Test authentication
   - Test order submission
   - Test ML predictions
   - Test backtesting
   - Test TLI commands

4. **Update Production Readiness** (1 hour)
   - Document test results
   - Update scorecard
   - Create deployment checklist

**Total Time to 95% Production Ready**: 7-12 hours

---

**End of Guide**

**Recommendation**: Follow phases sequentially, validate after each phase, commit working code frequently.