v0.3.3-pre.008

crates/ksp-store-postgres-lib/src/lib.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-postgres-lib/src/lib.rs
-// version: 13
+// version: 14
 
 #![warn(missing_docs)]
 #![deny(unreachable_pub)]
@@ -19,6 +19,8 @@
 //! pagination with a fixed opaque cursor bound to network, range and direction.
 //! `0.3.3-pre.007` adds atomic `Full -> Archived -> Purged` retention transitions
 //! with compare-and-transition outcomes and explicit rejection of `Compacted`.
+//! `0.3.3-pre.008` implements all six `RawTransaction*` capabilities directly on
+//! `PostgresBackend` while preserving the existing narrow backend bridge.
 //!
 //! This crate depends on `ksp-store-api` and never on `ksp-store-lib`. The
 //! common facade consumes only this crate's narrow backend bridge and never

crates/ksp-store-postgres-lib/src/runtime.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-store-postgres-lib/src/runtime.rs
-// version: 9
+// version: 10
 
 const APPLICATION_NAME: &str = "ksp-store";
 const MAX_CONNECTION_URI_BYTES: usize = 4_096;
@@ -428,6 +428,126 @@ impl std::fmt::Debug for PostgresBackend {
     }
 }
 
+impl ksp_store_api::RawTransactionRead for PostgresBackend {
+    fn get_raw_transaction<'a>(
+        &'a self,
+        reference: &'a ksp_store_api::RawTransactionReference,
+    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<std::option::Option<ksp_store_api::RawTransaction>>> {
+        return std::boxed::Box::pin(async move {
+            let result = PostgresBackend::get_raw_transaction(self, reference).await;
+            return result.map_err(map_capability_error);
+        });
+    }
+
+    fn list_raw_transactions<'a>(
+        &'a self,
+        query: &'a ksp_store_api::RawTransactionQuery,
+    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawPage<ksp_store_api::RawTransactionReference>>> {
+        return std::boxed::Box::pin(async move {
+            let result = PostgresBackend::list_raw_transactions(self, query).await;
+            return result.map_err(map_capability_error);
+        });
+    }
+}
+
+impl ksp_store_api::RawTransactionWrite for PostgresBackend {
+    fn persist_raw_transaction_acquisition<'a>(
+        &'a self,
+        transaction: ksp_store_api::RawTransaction,
+        observation: ksp_store_api::RawTransactionObservation,
+        mode: ksp_store_api::RawTransactionAcquisitionMode,
+    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawAcquisitionWriteOutcome>> {
+        return std::boxed::Box::pin(async move {
+            let result = PostgresBackend::persist_raw_transaction_acquisition(self, transaction, observation, mode).await;
+            return result.map_err(map_capability_error);
+        });
+    }
+}
+
+impl ksp_store_api::RawTransactionObservationRead for PostgresBackend {
+    fn get_raw_transaction_observation<'a>(
+        &'a self,
+        observation_key: &'a ksp_store_api::RawObservationKey,
+    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<std::option::Option<ksp_store_api::RawTransactionObservation>>> {
+        return std::boxed::Box::pin(async move {
+            let result = PostgresBackend::get_raw_transaction_observation(self, observation_key).await;
+            return result.map_err(map_capability_error);
+        });
+    }
+}
+
+impl ksp_store_api::RawTransactionObservationWrite for PostgresBackend {
+    fn record_raw_transaction_observation<'a>(
+        &'a self,
+        observation: ksp_store_api::RawTransactionObservation,
+    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawObservationWriteOutcome>> {
+        return std::boxed::Box::pin(async move {
+            let result = PostgresBackend::record_raw_transaction_observation(self, observation).await;
+            return result.map_err(map_capability_error);
+        });
+    }
+}
+
+impl ksp_store_api::RawTransactionRetentionRead for PostgresBackend {
+    fn get_raw_transaction_retention_state<'a>(
+        &'a self,
+        reference: &'a ksp_store_api::RawTransactionReference,
+    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<std::option::Option<ksp_store_api::RawRetentionState>>> {
+        return std::boxed::Box::pin(async move {
+            let result = PostgresBackend::get_raw_transaction_retention_state(self, reference).await;
+            return result.map_err(map_capability_error);
+        });
+    }
+
+    fn get_raw_transaction_tombstone<'a>(
+        &'a self,
+        reference: &'a ksp_store_api::RawTransactionReference,
+    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<std::option::Option<ksp_store_api::RawTransactionTombstone>>> {
+        return std::boxed::Box::pin(async move {
+            let result = PostgresBackend::get_raw_transaction_tombstone(self, reference).await;
+            return result.map_err(map_capability_error);
+        });
+    }
+}
+
+impl ksp_store_api::RawTransactionRetentionWrite for PostgresBackend {
+    fn transition_raw_transaction_retention<'a>(
+        &'a self,
+        transition: ksp_store_api::RawTransactionRetentionTransition,
+    ) -> ksp_store_api::StoreApiFuture<'a, ksp_store_api::Result<ksp_store_api::RawRetentionWriteOutcome>> {
+        return std::boxed::Box::pin(async move {
+            let result = PostgresBackend::transition_raw_transaction_retention(self, transition).await;
+            return result.map_err(map_capability_error);
+        });
+    }
+}
+
+fn map_capability_error(error: crate::PostgresBackendError) -> ksp_store_api::Error {
+    let code = match error.kind() {
+        crate::PostgresBackendErrorKind::ConfigInvalid => ksp_store_api::ErrorCode::new("store", "postgres_config_invalid"),
+        crate::PostgresBackendErrorKind::ConnectFailed => ksp_store_api::ErrorCode::new("store", "postgres_connect_failed"),
+        crate::PostgresBackendErrorKind::Conflict => ksp_store_api::ERROR_CODE_RAW_CONFLICT,
+        crate::PostgresBackendErrorKind::DataInvalid => ksp_store_api::ErrorCode::new("store", "postgres_data_invalid"),
+        crate::PostgresBackendErrorKind::HealthFailed => ksp_store_api::ErrorCode::new("store", "postgres_health_failed"),
+        crate::PostgresBackendErrorKind::MigrationFailed => ksp_store_api::ErrorCode::new("store", "postgres_migration_failed"),
+        crate::PostgresBackendErrorKind::MigrationMismatch => ksp_store_api::ErrorCode::new("store", "postgres_migration_mismatch"),
+        crate::PostgresBackendErrorKind::PageLimitUnsupported => ksp_store_api::ErrorCode::new("store", "postgres_page_limit_unsupported"),
+        crate::PostgresBackendErrorKind::PoolTimeout => ksp_store_api::ErrorCode::new("store", "postgres_pool_timeout"),
+        crate::PostgresBackendErrorKind::QueryInvalid => ksp_store_api::ERROR_CODE_RAW_QUERY_INVALID,
+        crate::PostgresBackendErrorKind::ReadFailed => ksp_store_api::ErrorCode::new("store", "postgres_read_failed"),
+        crate::PostgresBackendErrorKind::ReferenceNotFound => ksp_store_api::ErrorCode::new("store", "raw_reference_not_found"),
+        crate::PostgresBackendErrorKind::RetentionCompactionUnsupported => crate::ERROR_CODE_POSTGRES_RETENTION_COMPACTION_UNSUPPORTED,
+        crate::PostgresBackendErrorKind::SchemaNewer => ksp_store_api::ErrorCode::new("store", "postgres_schema_newer"),
+        crate::PostgresBackendErrorKind::ShutdownTimeout => ksp_store_api::ErrorCode::new("store", "shutdown_timeout"),
+        crate::PostgresBackendErrorKind::TlsFailed => ksp_store_api::ErrorCode::new("store", "postgres_tls_failed"),
+        crate::PostgresBackendErrorKind::WriteFailed => ksp_store_api::ErrorCode::new("store", "postgres_write_failed"),
+        crate::PostgresBackendErrorKind::WrongNetwork => ksp_store_api::ErrorCode::new("store", "wrong_network"),
+    };
+    return ksp_store_api::Error::new(code, "PostgreSQL Store capability operation failed")
+        .with_context("backend", "postgres")
+        .with_context("phase", error.phase());
+}
+
 impl std::ops::Drop for PostgresBackend {
     fn drop(&mut self) {
         self.pool.close();