@feltdb/core 0.5.6 → 0.6.0

package/dist/create/server-source/crates/feltdb-server/src/lib.rs

@@ -3,8 +3,12 @@ pub mod application_contract;
 pub mod artifacts;
 pub mod audit;
 pub mod auth;
+pub mod authenticated_principal;
 pub mod authorization;
 pub mod backup;
+pub mod certification_harness;
+pub mod delegation_token;
+pub mod durable_operations;
 pub mod key_management;
 pub mod causal;
 pub mod certification;
@@ -15,6 +19,8 @@ pub mod content;
 pub mod identity;
 pub mod key_provider;
 pub mod leases;
+pub mod managed_diagnostics;
+pub mod membership_policy;
 pub mod metrics;
 pub mod portable_bundle;
 pub mod principals;
@@ -22,6 +28,9 @@ pub mod providers;
 pub mod releases;
 pub mod request_telemetry;
 pub mod sessions;
+pub mod snapshot_cursor;
+pub mod tenant_policies;
 pub mod tenancy;
 pub mod transaction_idempotency;
+pub mod transaction_recovery;
 pub mod versions;

package/dist/create/server-source/crates/feltdb-server/src/main.rs

@@ -9,7 +9,7 @@ use std::{
         atomic::{AtomicU64, Ordering},
         Arc,
     },
-    time::Duration,
+    time::{Duration, Instant},
 };
 
 use axum::{
@@ -64,6 +64,7 @@ use feltdb_server::{
     artifacts::{ArtifactKind, ArtifactLifecycle, ArtifactMetadata, ArtifactStore, ProducerRef},
     audit::{AuditEvent, AuditLog},
     auth::{KeyStore, Principal},
+    authenticated_principal::AuthenticatedPrincipal,
     authorization::{authorize, AuthorizationRequest, Subject},
     backup::{
         create_bundle, create_bundle_with_virtual, restore_bundle, select_bundle_at,
@@ -103,12 +104,18 @@ struct ApiError(StatusCode, String);
 
 impl IntoResponse for ApiError {
     fn into_response(self) -> Response {
-        let body =
-            serde_json::from_str::<Value>(&self.1).unwrap_or_else(|_| json!({ "error": self.1 }));
+        let body = api_error_body(self.0, self.1);
         (self.0, Json(body)).into_response()
     }
 }
 
+fn api_error_body(status: StatusCode, message: String) -> Value {
+    if status == StatusCode::FORBIDDEN {
+        return json!({ "error": "AUTHORIZATION_DENIED" });
+    }
+    serde_json::from_str::<Value>(&message).unwrap_or_else(|_| json!({ "error": message }))
+}
+
 impl From<feltdb::FlowError> for ApiError {
     fn from(error: feltdb::FlowError) -> Self {
         Self(StatusCode::INTERNAL_SERVER_ERROR, error.to_string())
@@ -142,6 +149,19 @@ struct RuntimeResponse {
     features: Value,
 }
 
+#[derive(Serialize)]
+struct ManagedDiagnosticsResponse {
+    engine_version: String,
+    server_commit: String,
+    core_protocol_version: String,
+    authorization_contract: u32,
+    storage_format: u32,
+    promoted_revision: String,
+    environment: String,
+    recovery: String,
+    uptime: String,
+}
+
 #[derive(Serialize)]
 struct RecordResponse {
     id: String,
@@ -2185,6 +2205,38 @@ async fn delete_application_control(
         .map_err(control_error)?;
     Ok(StatusCode::NO_CONTENT)
 }
+
+async fn delete_certification_fixture(
+    State(state): State<AppState>,
+    Path(application_id): Path<String>,
+    headers: HeaderMap,
+) -> Result<Json<Value>, ApiError> {
+    let expected = std::env::var("FELTDB_CERTIFICATION_RECOVERY_TOKEN").map_err(|_| {
+        ApiError(
+            StatusCode::SERVICE_UNAVAILABLE,
+            "certification recovery is not configured".into(),
+        )
+    })?;
+    let provided = headers
+        .get("x-feltdb-certification-recovery")
+        .and_then(|value| value.to_str().ok())
+        .unwrap_or_default();
+    if expected.len() < 32
+        || ring::constant_time::verify_slices_are_equal(expected.as_bytes(), provided.as_bytes())
+            .is_err()
+    {
+        return Err(ApiError(StatusCode::FORBIDDEN, "certification recovery denied".into()));
+    }
+    let tenant_id = state
+        .tenancy
+        .delete_certification_fixture(&application_id)
+        .map_err(control_error)?;
+    Ok(Json(json!({
+        "deleted": true,
+        "tenant_id": tenant_id,
+        "application_id": application_id,
+    })))
+}
 async fn update_application_control(
     State(state): State<AppState>,
     Extension(principal): Extension<Principal>,
@@ -3800,7 +3852,36 @@ async fn commit_application_draft(
         .applications
         .commit(&tenant, &application_id, &draft_id, &principal.key_id)
         .map_err(manifest_error)?;
-    Ok((StatusCode::CREATED, Json(json!(revision))))
+    let encoded_revision = percent_encode_path_segment(&revision.revision_id);
+    let mut response = serde_json::to_value(revision).map_err(|error| {
+        ApiError(StatusCode::INTERNAL_SERVER_ERROR, error.to_string())
+    })?;
+    response
+        .as_object_mut()
+        .expect("application revisions serialize as objects")
+        .insert(
+            "promotion".into(),
+            json!({
+                "status": "ready",
+                "url": format!(
+                    "/api/applications/{application_id}/revisions/{encoded_revision}/promote"
+                ),
+            }),
+        );
+    Ok((StatusCode::CREATED, Json(response)))
+}
+
+fn percent_encode_path_segment(value: &str) -> String {
+    value
+        .bytes()
+        .flat_map(|byte| {
+            if byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_' | b'.' | b'~') {
+                vec![byte as char]
+            } else {
+                format!("%{byte:02X}").chars().collect()
+            }
+        })
+        .collect()
 }
 async fn list_application_revisions(
     State(state): State<AppState>,
@@ -5657,6 +5738,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let provider_store = ProviderStore::load(config.data.with_extension("providers.json"))?;
     let readiness_probe = config.data.with_extension("readiness");
     let state = AppState {
+        started_at: Instant::now(),
         ids: Arc::new(AtomicU64::new(db.sequence()?)),
         db,
         namespace: Arc::from(config.namespace.clone()),
@@ -5749,6 +5831,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             axum::routing::post(construct_application_contract),
         )
         .route("/v1/identity/me", get(identity_me))
+        .route("/v1/diagnostics", get(managed_diagnostics))
         .route("/v1/identity/sessions", get(identity_sessions))
         .route(
             "/v1/identity/sessions/{id}/revoke",
@@ -5773,6 +5856,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             axum::routing::patch(platform_update_application_member),
         )
         .route("/api/tenants/{tenant_id}", get(get_tenant))
+        .route(
+            "/api/certification/fixtures/{application_id}",
+            axum::routing::delete(delete_certification_fixture),
+        )
         .route("/api/keys", get(list_keys).post(create_key))
         .route("/api/keys/{id}", axum::routing::delete(revoke_key))
         .route(
@@ -6298,6 +6385,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .route("/ready", get(readiness))
         .route("/runtime", get(runtime))
         .route("/metrics", get(network_metrics))
+        .route(
+            "/api/certification/fixtures/{application_id}",
+            axum::routing::delete(delete_certification_fixture),
+        )
         .merge(protected)
         .layer(middleware::from_fn(protocol_version))
         .layer(middleware::from_fn_with_state(state.clone(), count_request))
@@ -6493,7 +6584,12 @@ async fn authenticate(
     let human_contract = principal.subject_type == "human"
         && path.starts_with("/v1/applications/")
         && path.split('/').any(|segment| segment == "contract");
-    if !path.starts_with("/api/") && !human_contract && !decision.allowed {
+    let authenticated_diagnostics = path == "/v1/diagnostics";
+    if !path.starts_with("/api/")
+        && !human_contract
+        && !authenticated_diagnostics
+        && !decision.allowed
+    {
         state.metrics.authentication_failure();
         audit(&state, &principal.key_id, required, path, "denied", 403);
         return ApiError(StatusCode::FORBIDDEN, format!("missing scope: {required}"))
@@ -6506,8 +6602,18 @@ async fn authenticate(
     } else {
         state.metrics.state_mutation();
     }
-    request.extensions_mut().insert(principal);
-    let principal = request
+
+    let authenticated = AuthenticatedPrincipal::from_api_key(
+        principal.key_id.clone(),
+        principal.key_id.clone(),
+        state.namespace.to_string(),
+        principal.scopes.clone(),
+    );
+
+    request.extensions_mut().insert(principal.clone());
+    request.extensions_mut().insert(authenticated.clone());
+
+    let principal_id = request
         .extensions()
         .get::<Principal>()
         .expect("principal inserted")
@@ -6518,7 +6624,7 @@ async fn authenticate(
     let status = response.status().as_u16();
     audit(
         &state,
-        &principal,
+        &principal_id,
         required,
         &target,
         if status < 400 { "allowed" } else { "failed" },
@@ -6594,6 +6700,32 @@ async fn health(State(state): State<AppState>) -> Json<HealthResponse<'static>>
     })
 }
 
+async fn managed_diagnostics(
+    State(state): State<AppState>,
+) -> Json<ManagedDiagnosticsResponse> {
+    let recovery = match state.cluster.proposal().map(|value| value.phase) {
+        Some(ProposalPhase::Preparing | ProposalPhase::Prepared) => "recovering",
+        Some(ProposalPhase::Aborted) => "attention-required",
+        _ if !state.lease_clock.is_healthy() => "degraded",
+        _ => "healthy",
+    };
+    let uptime_seconds = state.started_at.elapsed().as_secs();
+
+    Json(ManagedDiagnosticsResponse {
+        engine_version: env!("CARGO_PKG_VERSION").into(),
+        server_commit: option_env!("FELTDB_GIT_COMMIT").unwrap_or("unknown").into(),
+        core_protocol_version: PROTOCOL_VERSION.into(),
+        authorization_contract: 2,
+        storage_format: 1,
+        promoted_revision: std::env::var("FELTDB_PROMOTED_REVISION")
+            .unwrap_or_else(|_| "unknown".into()),
+        environment: std::env::var("FELTDB_ENVIRONMENT")
+            .unwrap_or_else(|_| "development".into()),
+        recovery: recovery.into(),
+        uptime: format!("{uptime_seconds}s"),
+    })
+}
+
 async fn readiness(State(state): State<AppState>) -> Result<Json<Value>, ApiError> {
     if let Some(parent) = state.readiness_probe.parent() {
         std::fs::create_dir_all(parent)
@@ -9114,7 +9246,8 @@ async fn shutdown_signal() {
 
 #[cfg(test)]
 mod authority_gate_tests {
-    use super::{authorize_transaction_collections, state_authorization};
+    use super::{api_error_body, authorize_transaction_collections, state_authorization};
+    use axum::http::StatusCode;
     use feltdb::{
         application::{manifest_hash, ApplicationManifest, ApplicationRevision, PolicyDefinition, RevisionStatus},
         application_runtime::{resolve_runtime, ApplicationRuntimeContract, RuntimeInventory},
@@ -9199,4 +9332,19 @@ mod authority_gate_tests {
         );
         assert!(!allowed);
     }
+
+    #[test]
+    fn every_forbidden_error_uses_the_canonical_wire_contract() {
+        for internal_message in [
+            "forbidden",
+            "tenant access denied",
+            "missing scope: state:read",
+            r#"{"code":"AUTHORIZATION_DENIED","message":"policy denied"}"#,
+        ] {
+            assert_eq!(
+                api_error_body(StatusCode::FORBIDDEN, internal_message.into()),
+                serde_json::json!({ "error": "AUTHORIZATION_DENIED" })
+            );
+        }
+    }
 }