Plan: Crate Quality Parity (Backport from Canopy)

/// Maximum results per page (DoS prevention).
const MAX_PER_PAGE: u32 = 500;

/// Pagination request with built-in clamping and overflow protection.
#[derive(Debug, Clone, Deserialize)]
pub struct PageRequest {
    #[serde(default = "default_page")]
    pub page: u32,
    #[serde(default = "default_per_page")]
    pub per_page: u32,
}

impl PageRequest {
    /// Compute the SQL OFFSET value. Uses saturating arithmetic to prevent underflow.
    pub fn offset(&self) -> i64 {
        ((self.page.saturating_sub(1)) as i64) * (self.clamped_per_page() as i64)
    }

    /// Compute the SQL LIMIT value, clamped to MAX_PER_PAGE.
    pub fn limit(&self) -> i64 {
        self.clamped_per_page() as i64
    }

    fn clamped_per_page(&self) -> u32 {
        self.per_page.min(MAX_PER_PAGE)
    }
}

// Before (10+ lines per handler):
let per_page = query.per_page.clamp(1, super::MAX_PER_PAGE);
let limit = per_page as i64;
let offset = (query.page.saturating_sub(1) as i64) * limit;
let total = store::cases::count_cases(pool, &filter).await?;
let cases = store::cases::list_cases_paged(pool, &filter, limit, offset).await?;

// After (2 lines):
let page = PageRequest { page: query.page, per_page: query.per_page };
let (cases, total) = store::cases::list_cases(pool, &filter, &page).await?;

/// List cases matching the filter, with count for pagination.
pub async fn list_cases(
    pool: &PgPool,
    filter: &CaseFilter,
    page: &PageRequest,
) -> Result<(Vec<Case>, i64), sqlx::Error> {
    // Single WHERE clause used for both count and list
    let where_clause = build_case_where_clause(filter);

    let count_sql = format!("SELECT COUNT(*) as count FROM cases {where_clause}");
    let list_sql = format!(
        "SELECT * FROM cases {where_clause} ORDER BY {col} {dir} LIMIT $N OFFSET $M",
        col = filter.validated_sort_column(),
        dir = filter.validated_sort_dir(),
    );

    let total: i64 = sqlx::query_scalar(&count_sql)
        .bind_filter(filter)
        .fetch_one(pool)
        .await?;

    let items: Vec<Case> = sqlx::query_as(&list_sql)
        .bind_filter(filter)
        .bind(page.limit())
        .bind(page.offset())
        .fetch_all(pool)
        .await?;

    Ok((items, total))
}

macro_rules! define_id {
    ($name:ident) => {
        /// Strongly-typed identifier. Wraps UUID v7 to prevent ID mixing at compile time.
        #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash,
                 serde::Serialize, serde::Deserialize, sqlx::Type)]
        #[sqlx(transparent)]
        pub struct $name(pub uuid::Uuid);

        impl $name {
            /// Generate a new ID using UUID v7 (time-sortable).
            pub fn new() -> Self { Self(uuid::Uuid::now_v7()) }
        }

        impl std::fmt::Display for $name {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                self.0.fmt(f)
            }
        }
    };
}

define_id!(CaseId);
define_id!(PersonId);
define_id!(ReferralId);
define_id!(InvestigationId);
define_id!(PlacementId);
define_id!(FosterHomeId);
define_id!(KinshipId);
define_id!(CourtOrderId);
define_id!(ContactId);
define_id!(AllegationId);
define_id!(CasePlanId);
define_id!(CasePlanTaskId);
define_id!(AttachmentId);

// services/craig-cases/src/config.rs
#[derive(Clone)]
pub struct CasesConfig {
    pub admin_unit_label: String,
    pub case_number_prefix: String,
    pub investigation_window_days: u32,
    // ... loaded from rulesets/{jurisdiction}/cases.toml
}

impl CasesConfig {
    pub fn load(rulesets_dir: &Path, jurisdiction: &str) -> Result<Self> {
        let path = rulesets_dir.join(jurisdiction).join("cases.toml");
        let raw = std::fs::read_to_string(&path)?;
        Ok(toml::from_str(&raw)?)
    }
}

let config = CasesConfig::load(&rulesets_dir, &settings.jurisdiction)?;
let router = router.layer(axum::Extension(config));