diff --git a/Cargo.toml b/Cargo.toml index 22ad349..65ff220 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -6,7 +6,7 @@ resolver = "3" members = ["crates/ksp-app-config-desk", "crates/ksp-app-solprices-desk", "crates/ksp-app-wallet-desk", "crates/ksp-config-lib", "crates/ksp-core-lib", "crates/ksp-interface-lib", "crates/ksp-logging-lib", "crates/ksp-offchain-transport-lib", "crates/ksp-onchain-transport-lib", "crates/ksp-program-api", "crates/ksp-store-api", "crates/ksp-store-lib", "crates/ksp-store-postgres-lib", "crates/ksp-wallet-lib"] [workspace.package] -version = "0.3.3-pre.9.fix.1" +version = "0.3.3-pre.9.fix.2" edition = "2024" license = "MIT" repository = "https://git.sasedev.com/Sasedev/khadhroony-solana-project" diff --git a/crates/ksp-store-postgres-lib/tests/postgres_raw_transaction_live.rs b/crates/ksp-store-postgres-lib/tests/postgres_raw_transaction_live.rs index bc25ecf..30cb697 100644 --- a/crates/ksp-store-postgres-lib/tests/postgres_raw_transaction_live.rs +++ b/crates/ksp-store-postgres-lib/tests/postgres_raw_transaction_live.rs @@ -1,5 +1,5 @@ // file: crates/ksp-store-postgres-lib/tests/postgres_raw_transaction_live.rs -// version: 2 +// version: 3 #![warn(missing_docs)] #![deny(unreachable_pub)] @@ -365,8 +365,8 @@ async fn prove_concurrent_identical_insert(uri: &str) -> std::result::Result<(), std::result::Result::Err(error) => return std::result::Result::Err(error), }; let pair = [first_result, second_result]; - let inserted = pair.iter().filter(|value| matches_inserted(value)).count(); - let already = pair.iter().filter(|value| matches_already_present(value)).count(); + let inserted = pair.iter().filter(|value| return matches_inserted(value)).count(); + let already = pair.iter().filter(|value| return matches_already_present(value)).count(); if inserted != 1 || already != 1 { return std::result::Result::Err(LiveFailure::new("concurrent_identical_outcome")); } @@ -385,7 +385,7 @@ async fn prove_concurrent_divergent_insert(admin: &tokio_postgres::Client, uri: std::result::Result::Err(error) => return std::result::Result::Err(error), }; let pair = [first_result, second_result]; - let inserted = pair.iter().filter(|value| matches_inserted(value)).count(); + let inserted = pair.iter().filter(|value| return matches_inserted(value)).count(); let conflicts = pair .iter() .filter(|value| matches!(value, LivePersistResult::BackendError(ksp_store_postgres_lib::PostgresBackendErrorKind::Conflict))) @@ -425,12 +425,12 @@ async fn prove_pagination(backend: &ksp_store_postgres_lib::PostgresBackend) -> } let asc = collect_pages(backend, ksp_store_api::RawSortDirection::Ascending).await; match asc { - std::result::Result::Ok(values) if values == [50, 51, 52, 53, 54] => {}, + std::result::Result::Ok([50, 51, 52, 53, 54]) => {}, _ => return std::result::Result::Err(LiveFailure::new("pagination_ascending")), } let desc = collect_pages(backend, ksp_store_api::RawSortDirection::Descending).await; match desc { - std::result::Result::Ok(values) if values == [54, 53, 52, 51, 50] => {}, + std::result::Result::Ok([54, 53, 52, 51, 50]) => {}, _ => return std::result::Result::Err(LiveFailure::new("pagination_descending")), } let first_query = match page_query(ksp_store_api::RawSortDirection::Ascending, std::option::Option::None, 9_000, 9_002) { @@ -1059,7 +1059,8 @@ async fn open_backend( let opened = open_backend_result(uri, network_name, schema_autocreate, schema_autoupdate).await; return match opened { std::result::Result::Ok(std::result::Result::Ok(value)) => std::result::Result::Ok(value), - _ => std::result::Result::Err(LiveFailure::new("backend_open")), + std::result::Result::Ok(std::result::Result::Err(error)) => std::result::Result::Err(LiveFailure::new(error.phase())), + std::result::Result::Err(error) => std::result::Result::Err(error), }; } diff --git a/deltas/0.3.3/pre.009-fix.002.md b/deltas/0.3.3/pre.009-fix.002.md new file mode 100644 index 0000000..aa43bea --- /dev/null +++ b/deltas/0.3.3/pre.009-fix.002.md @@ -0,0 +1,101 @@ + + + +# Delta `0.3.3-pre.009-fix.002` — Clippy live + phase sûre d’ouverture + +## 1. Base et constat + +Base opérateur : + +```text +0.3.3-pre.9.fix.1 +``` + +Le gate standard du 2026-08-30 confirme que le borrow `E0502` de `pre.009-fix.001` est corrigé : `cargo check --workspace`, les tests `ksp-store-api`, `ksp-store-lib`, `ksp-store-postgres-lib`, `ksp-config-lib` et `cargo check -p ksp-store-lib --no-default-features` passent. + +Clippy bloque encore le nouveau test live sur trois closures soumises à `clippy::implicit_return = deny` et remonte deux `redundant_guards` sur les tableaux de pagination. + +Le premier essai live avec le placeholder littéral `` échoue logiquement à `admin_config` et n'est pas une preuve. Le second essai avec une URI dédiée réelle atteint PostgreSQL 17 puis échoue à `backend_open`. Cette étiquette était trop agrégée : elle supprimait le `phase()` statique, pourtant secret-safe, déjà porté par `PostgresBackendError`. + +## 2. Version + +```text +workspace.package.version = 0.3.3-pre.9.fix.2 +``` + +## 3. Corrections Clippy + +Les trois filtres utilisent désormais un `return` explicite dans leur closure, conformément à la policy KSP : + +```rust +.filter(|value| return matches_inserted(value)) +.filter(|value| return matches_already_present(value)) +``` + +Les deux validations de pagination utilisent directement le pattern tableau : + +```rust +Result::Ok([50, 51, 52, 53, 54]) +Result::Ok([54, 53, 52, 51, 50]) +``` + +Aucune exemption Clippy n'est ajoutée. + +## 4. Diagnostic live secret-safe + +`open_backend` distingue désormais : + +- succès backend ; +- erreur backend : `LiveFailure::new(error.phase())` ; +- erreur locale de préparation : propagation du `LiveFailure` existant. + +`PostgresBackendError::phase()` est une chaîne statique KSP. Elle ne contient ni URI, ni texte serveur PostgreSQL, ni SQL, ni SQLSTATE, ni bind. Le live peut donc identifier une étape telle que `schema_resource_post_apply`, `store_identity_*`, `history_insert`, etc. sans affaiblir la redaction. + +Ce correctif ne modifie volontairement aucune logique de migration tant que la phase réelle n'est pas connue. + +## 5. Hors scope / invariants + +Aucun changement de : + +- production `ksp-store-postgres-lib` ; +- `ksp-store-lib` / `ksp-store-api` / Config ; +- SQL RawTransaction ; +- cursor ; +- rétention ; +- migrations V000/V001 ; +- checksums de migration ; +- scope `RawAccountState`. + +## 6. Fichiers modifiés + +```text +Cargo.toml +crates/ksp-store-postgres-lib/tests/postgres_raw_transaction_live.rs +docs/validation/020-V0_3_3_STORE_POSTGRES_RAW_TRANSACTION.md +deltas/0.3.3/pre.009-fix.002.md +``` + +Aucune suppression. + +## 7. Gate opérateur attendu + +```bash +cargo fmt --all +python3 scripts/audit_rust_workspace_rules.py +python3 scripts/audit_markdown_tables.py README.md RULES.md ROADMAP.md CHANGELOG.md docs prompts crates deltas/0.3.3 +cargo check --workspace +cargo clippy --workspace --all-targets +cargo test -p ksp-store-api +cargo test -p ksp-store-lib +cargo test -p ksp-store-postgres-lib +cargo test -p ksp-config-lib +cargo check -p ksp-store-lib --no-default-features +``` + +Puis, avec une base PostgreSQL dédiée vide de toute table KSP : + +```bash +read -rsp "Dedicated PostgreSQL URI: " KSP_PG_TEST_URI; echo +printf '%s\n' "$KSP_PG_TEST_URI" | cargo test -p ksp-store-postgres-lib --test postgres_raw_transaction_live -- --ignored --nocapture --test-threads=1 +unset KSP_PG_TEST_URI +``` diff --git a/docs/validation/020-V0_3_3_STORE_POSTGRES_RAW_TRANSACTION.md b/docs/validation/020-V0_3_3_STORE_POSTGRES_RAW_TRANSACTION.md index 951453a..a9eb208 100644 --- a/docs/validation/020-V0_3_3_STORE_POSTGRES_RAW_TRANSACTION.md +++ b/docs/validation/020-V0_3_3_STORE_POSTGRES_RAW_TRANSACTION.md @@ -1,5 +1,5 @@ - + # Validation `0.3.3` — Store/PostgreSQL RawTransaction vertical slice @@ -640,8 +640,11 @@ cap 500/1000 dans Store pagination - réouverture finale : COUVERTE ; - premier gate Cargo opérateur : FAIL local de compilation dans le scénario cancellation, car un `Result>` intermédiaire prolongeait l'emprunt mutable de `admin` jusqu'au probe final ; - `pre.009-fix.001` supprime uniquement ce binding intermédiaire et matche directement `admin.transaction().await`, sans modifier la preuve, le SQL, la production ni les migrations ; -- gate Cargo standard de `pre.009-fix.001` : À EXÉCUTER côté opérateur ; -- test PostgreSQL réel `--ignored` : À EXÉCUTER côté opérateur après gate standard vert. +- gate opérateur `pre.009-fix.001` du 2026-08-30 : `cargo check --workspace`, tests API/façade/backend/Config et `--no-default-features` passent, mais Clippy bloque le test live sur trois closures sans `return` explicite et remonte deux guards redondants ; +- live réel `pre.009-fix.001` avec URI dédiée valide : PostgreSQL 17 est joint, puis l'ouverture backend échoue encore sous l'étiquette trop générique `backend_open` ; aucune conclusion sur le schéma n'est tirée sans phase sûre plus précise ; +- `pre.009-fix.002` corrige uniquement les cinq diagnostics Clippy du test et propage `PostgresBackendError::phase()` vers `LiveFailure` lors de `open_backend`, sans rendre le texte PostgreSQL, l'URI, SQLSTATE ou bind ; +- gate Cargo standard de `pre.009-fix.002` : À EXÉCUTER côté opérateur ; +- test PostgreSQL réel `--ignored` : À RELANCER ; si l'ouverture échoue, la phase statique backend doit désormais identifier l'étape exacte. ### `pre.010`