+1

crates/relay/src/app.rs

··· 77 77 pub struct AppState { 78 78 pub config: Arc<Config>, 79 79 pub db: sqlx::SqlitePool, 80 80 + #[allow(dead_code)] 80 81 pub http_client: Client, 81 82 } 82 83

+5 -6

crates/relay/src/db/mod.rs

··· 734 734 let pool = in_memory_pool().await; 735 735 run_migrations(&pool).await.unwrap(); 736 736 737 737 - let plan: Vec<(i64, i64, i64, String)> = sqlx::query_as( 738 738 - "EXPLAIN QUERY PLAN SELECT * FROM devices WHERE account_id = 'acct1'", 739 739 - ) 740 740 - .fetch_all(&pool) 741 741 - .await 742 742 - .unwrap(); 737 737 + let plan: Vec<(i64, i64, i64, String)> = 738 738 + sqlx::query_as("EXPLAIN QUERY PLAN SELECT * FROM devices WHERE account_id = 'acct1'") 739 739 + .fetch_all(&pool) 740 740 + .await 741 741 + .unwrap(); 743 742 744 743 let detail = plan 745 744 .iter()

+97 -52

crates/relay/src/routes/create_mobile_account.rs

··· 263 263 .inspect_err(|e| { 264 264 tracing::error!(error = %e, "failed to classify claim code status"); 265 265 }) 266 266 - .map_err(|_| { 267 267 - ApiError::new(ErrorCode::InternalError, "failed to create account") 268 268 - })?; 266 266 + .map_err(|_| ApiError::new(ErrorCode::InternalError, "failed to create account"))?; 269 267 270 268 return Err(match row { 271 269 Some((Some(_),)) => ApiError::new( 272 270 ErrorCode::ClaimCodeRedeemed, 273 271 "claim code has already been redeemed", 274 272 ), 275 275 - _ => ApiError::new( 276 276 - ErrorCode::NotFound, 277 277 - "claim code is invalid or has expired", 278 278 - ), 273 273 + _ => ApiError::new(ErrorCode::NotFound, "claim code is invalid or has expired"), 279 274 }); 280 275 } 281 276 ··· 359 354 ); 360 355 } 361 356 if msg.contains("pending_accounts.handle") { 362 362 - return ApiError::new( 363 363 - ErrorCode::HandleTaken, 364 364 - "this handle is already claimed", 365 365 - ); 357 357 + return ApiError::new(ErrorCode::HandleTaken, "this handle is already claimed"); 366 358 } 367 359 // Unknown unique constraint — log the name so it surfaces in traces. 368 360 tracing::error!( ··· 438 430 .unwrap(); 439 431 440 432 assert_eq!(response.status(), StatusCode::CREATED); 441 441 - let body = axum::body::to_bytes(response.into_body(), 4096).await.unwrap(); 433 433 + let body = axum::body::to_bytes(response.into_body(), 4096) 434 434 + .await 435 435 + .unwrap(); 442 436 let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); 443 437 444 444 - assert!(json["accountId"].as_str().is_some(), "accountId must be present"); 445 445 - assert!(json["deviceId"].as_str().is_some(), "deviceId must be present"); 446 446 - assert!(json["deviceToken"].as_str().is_some(), "deviceToken must be present"); 447 447 - assert!(json["sessionToken"].as_str().is_some(), "sessionToken must be present"); 438 438 + assert!( 439 439 + json["accountId"].as_str().is_some(), 440 440 + "accountId must be present" 441 441 + ); 442 442 + assert!( 443 443 + json["deviceId"].as_str().is_some(), 444 444 + "deviceId must be present" 445 445 + ); 446 446 + assert!( 447 447 + json["deviceToken"].as_str().is_some(), 448 448 + "deviceToken must be present" 449 449 + ); 450 450 + assert!( 451 451 + json["sessionToken"].as_str().is_some(), 452 452 + "sessionToken must be present" 453 453 + ); 448 454 assert_eq!(json["nextStep"], "did_creation"); 449 455 } 450 456 ··· 458 464 .await 459 465 .unwrap(); 460 466 461 461 - let body = axum::body::to_bytes(response.into_body(), 4096).await.unwrap(); 467 467 + let body = axum::body::to_bytes(response.into_body(), 4096) 468 468 + .await 469 469 + .unwrap(); 462 470 let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); 463 471 464 472 uuid::Uuid::parse_str(json["accountId"].as_str().unwrap()) ··· 477 485 .await 478 486 .unwrap(); 479 487 480 480 - let body = axum::body::to_bytes(response.into_body(), 4096).await.unwrap(); 488 488 + let body = axum::body::to_bytes(response.into_body(), 4096) 489 489 + .await 490 490 + .unwrap(); 481 491 let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); 482 492 483 493 for field in ["deviceToken", "sessionToken"] { 484 494 let token = json[field].as_str().unwrap(); 485 495 assert!( 486 486 - token.chars().all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_'), 496 496 + token 497 497 + .chars() 498 498 + .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_'), 487 499 "{field} must be base64url without padding; got: {token}" 488 500 ); 489 501 assert_eq!( ··· 507 519 .unwrap(); 508 520 509 521 assert_eq!(response.status(), StatusCode::CREATED); 510 510 - let body = axum::body::to_bytes(response.into_body(), 4096).await.unwrap(); 522 522 + let body = axum::body::to_bytes(response.into_body(), 4096) 523 523 + .await 524 524 + .unwrap(); 511 525 let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); 512 526 513 527 let account_id = json["accountId"].as_str().unwrap(); ··· 528 542 assert_eq!(code, claim_code); 529 543 530 544 // devices row 531 531 - let (dev_account_id, platform, public_key): (String, String, String) = sqlx::query_as( 532 532 - "SELECT account_id, platform, public_key FROM devices WHERE id = ?", 533 533 - ) 534 534 - .bind(device_id) 535 535 - .fetch_one(&db) 536 536 - .await 537 537 - .expect("devices row must exist"); 545 545 + let (dev_account_id, platform, public_key): (String, String, String) = 546 546 + sqlx::query_as("SELECT account_id, platform, public_key FROM devices WHERE id = ?") 547 547 + .bind(device_id) 548 548 + .fetch_one(&db) 549 549 + .await 550 550 + .expect("devices row must exist"); 538 551 539 552 assert_eq!(dev_account_id, account_id); 540 553 assert_eq!(platform, "ios"); ··· 571 584 .await 572 585 .unwrap(); 573 586 574 574 - assert!(redeemed_at.is_some(), "claim code must have redeemed_at set"); 587 587 + assert!( 588 588 + redeemed_at.is_some(), 589 589 + "claim code must have redeemed_at set" 590 590 + ); 575 591 } 576 592 577 593 #[tokio::test] ··· 588 604 .await 589 605 .unwrap(); 590 606 591 591 - let body = axum::body::to_bytes(response.into_body(), 4096).await.unwrap(); 607 607 + let body = axum::body::to_bytes(response.into_body(), 4096) 608 608 + .await 609 609 + .unwrap(); 592 610 let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); 593 611 594 612 let device_id = json["deviceId"].as_str().unwrap(); 595 613 let account_id = json["accountId"].as_str().unwrap(); 596 614 597 615 // device token hash 598 598 - let device_token_bytes = 599 599 - URL_SAFE_NO_PAD.decode(json["deviceToken"].as_str().unwrap()).unwrap(); 616 616 + let device_token_bytes = URL_SAFE_NO_PAD 617 617 + .decode(json["deviceToken"].as_str().unwrap()) 618 618 + .unwrap(); 600 619 let expected_device_hash: String = Sha256::digest(&device_token_bytes) 601 620 .iter() 602 621 .map(|b| format!("{b:02x}")) ··· 608 627 .fetch_one(&db) 609 628 .await 610 629 .unwrap(); 611 611 - assert_eq!(stored_device_hash, expected_device_hash, "device_token_hash mismatch"); 630 630 + assert_eq!( 631 631 + stored_device_hash, expected_device_hash, 632 632 + "device_token_hash mismatch" 633 633 + ); 612 634 613 635 // session token hash 614 614 - let session_token_bytes = 615 615 - URL_SAFE_NO_PAD.decode(json["sessionToken"].as_str().unwrap()).unwrap(); 636 636 + let session_token_bytes = URL_SAFE_NO_PAD 637 637 + .decode(json["sessionToken"].as_str().unwrap()) 638 638 + .unwrap(); 616 639 let expected_session_hash: String = Sha256::digest(&session_token_bytes) 617 640 .iter() 618 641 .map(|b| format!("{b:02x}")) 619 642 .collect(); 620 643 621 621 - let (stored_session_hash,): (String,) = sqlx::query_as( 622 622 - "SELECT token_hash FROM pending_sessions WHERE account_id = ?", 623 623 - ) 624 624 - .bind(account_id) 625 625 - .fetch_one(&db) 626 626 - .await 627 627 - .unwrap(); 628 628 - assert_eq!(stored_session_hash, expected_session_hash, "session token_hash mismatch"); 644 644 + let (stored_session_hash,): (String,) = 645 645 + sqlx::query_as("SELECT token_hash FROM pending_sessions WHERE account_id = ?") 646 646 + .bind(account_id) 647 647 + .fetch_one(&db) 648 648 + .await 649 649 + .unwrap(); 650 650 + assert_eq!( 651 651 + stored_session_hash, expected_session_hash, 652 652 + "session token_hash mismatch" 653 653 + ); 629 654 } 630 655 631 656 // ── Claim code errors ───────────────────────────────────────────────────── ··· 641 666 .unwrap(); 642 667 643 668 assert_eq!(response.status(), StatusCode::NOT_FOUND); 644 644 - let body = axum::body::to_bytes(response.into_body(), 4096).await.unwrap(); 669 669 + let body = axum::body::to_bytes(response.into_body(), 4096) 670 670 + .await 671 671 + .unwrap(); 645 672 let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); 646 673 assert_eq!(json["error"]["code"], "NOT_FOUND"); 647 674 } ··· 670 697 .unwrap(); 671 698 672 699 assert_eq!(response.status(), StatusCode::NOT_FOUND); 673 673 - let body = axum::body::to_bytes(response.into_body(), 4096).await.unwrap(); 700 700 + let body = axum::body::to_bytes(response.into_body(), 4096) 701 701 + .await 702 702 + .unwrap(); 674 703 let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); 675 704 assert_eq!(json["error"]["code"], "NOT_FOUND"); 676 705 } ··· 699 728 .unwrap(); 700 729 701 730 assert_eq!(second.status(), StatusCode::CONFLICT); 702 702 - let body = axum::body::to_bytes(second.into_body(), 4096).await.unwrap(); 731 731 + let body = axum::body::to_bytes(second.into_body(), 4096) 732 732 + .await 733 733 + .unwrap(); 703 734 let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); 704 735 assert_eq!(json["error"]["code"], "CLAIM_CODE_REDEEMED"); 705 736 } ··· 775 806 .unwrap(); 776 807 777 808 assert_eq!(response.status(), StatusCode::CONFLICT); 778 778 - let body = axum::body::to_bytes(response.into_body(), 4096).await.unwrap(); 809 809 + let body = axum::body::to_bytes(response.into_body(), 4096) 810 810 + .await 811 811 + .unwrap(); 779 812 let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); 780 813 assert_eq!(json["error"]["code"], "HANDLE_TAKEN"); 781 814 ··· 843 876 .unwrap(); 844 877 845 878 assert_eq!(response.status(), StatusCode::CONFLICT); 846 846 - let body = axum::body::to_bytes(response.into_body(), 4096).await.unwrap(); 879 879 + let body = axum::body::to_bytes(response.into_body(), 4096) 880 880 + .await 881 881 + .unwrap(); 847 882 let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); 848 883 assert_eq!(json["error"]["code"], "ACCOUNT_EXISTS"); 849 884 } ··· 905 940 .unwrap(); 906 941 907 942 assert_eq!(response.status(), StatusCode::CONFLICT); 908 908 - let body = axum::body::to_bytes(response.into_body(), 4096).await.unwrap(); 943 943 + let body = axum::body::to_bytes(response.into_body(), 4096) 944 944 + .await 945 945 + .unwrap(); 909 946 let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); 910 947 assert_eq!(json["error"]["code"], "HANDLE_TAKEN"); 911 948 } ··· 922 959 .unwrap(); 923 960 924 961 assert_eq!(response.status(), StatusCode::BAD_REQUEST); 925 925 - let body = axum::body::to_bytes(response.into_body(), 4096).await.unwrap(); 962 962 + let body = axum::body::to_bytes(response.into_body(), 4096) 963 963 + .await 964 964 + .unwrap(); 926 965 let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); 927 966 assert_eq!(json["error"]["code"], "INVALID_CLAIM"); 928 967 } ··· 954 993 .unwrap(); 955 994 956 995 assert_eq!(response.status(), StatusCode::BAD_REQUEST); 957 957 - let body = axum::body::to_bytes(response.into_body(), 4096).await.unwrap(); 996 996 + let body = axum::body::to_bytes(response.into_body(), 4096) 997 997 + .await 998 998 + .unwrap(); 958 999 let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); 959 1000 assert_eq!(json["error"]["code"], "INVALID_CLAIM"); 960 1001 } ··· 973 1014 .unwrap(); 974 1015 975 1016 assert_eq!(response.status(), StatusCode::BAD_REQUEST); 976 976 - let body = axum::body::to_bytes(response.into_body(), 4096).await.unwrap(); 1017 1017 + let body = axum::body::to_bytes(response.into_body(), 4096) 1018 1018 + .await 1019 1019 + .unwrap(); 977 1020 let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); 978 1021 assert_eq!(json["error"]["code"], "INVALID_CLAIM"); 979 1022 } ··· 1019 1062 .unwrap(); 1020 1063 1021 1064 assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR); 1022 1022 - let body = axum::body::to_bytes(response.into_body(), 4096).await.unwrap(); 1065 1065 + let body = axum::body::to_bytes(response.into_body(), 4096) 1066 1066 + .await 1067 1067 + .unwrap(); 1023 1068 let json: serde_json::Value = serde_json::from_slice(&body).unwrap(); 1024 1069 assert_eq!(json["error"]["code"], "INTERNAL_ERROR"); 1025 1070 }