hecks 4.0.0 → 6.0.0

data/rust/host/src/platform_signin/mapping_tests.rs

@@ -4,18 +4,20 @@
 //! not take is the write that links a member (it needs the compiled domain module); the mapping
 //! logic around it is covered with a fake store in the handler tests.
 
+#[allow(unused_imports)]
+use crate::store::{StoreExt, StoreFixtures};
 use std::path::Path;
 use std::sync::Arc;
 
+use crate::store::Store;
 use serde_json::{json, Value};
-use tokio::sync::Mutex;
-use tokio_postgres::{Client, NoTls};
+use tokio_postgres::NoTls;
 
 use super::extension::PlatformSignin;
 use super::session::{map_member, HostMembers};
 use super::wiring_support::*;
-use crate::journal::LineageConfig;
 use crate::lambda_client::NeverInvoker;
+use crate::store::journal_sql::LineageConfig;
 
 fn domain_ir() -> Value {
     json!({
@@ -26,7 +28,7 @@ fn domain_ir() -> Value {
     })
 }
 
-async fn scratch(name: &str) -> Mutex<Client> {
+async fn scratch(name: &str) -> Store {
     let (admin, conn) = tokio_postgres::connect(&crate::test_pg::conninfo("postgres"), NoTls)
         .await
         .expect("postgres");
@@ -56,11 +58,11 @@ async fn scratch(name: &str) -> Mutex<Client> {
         )
         .await
         .unwrap();
-    Mutex::new(client)
+    crate::store::postgres_store(client)
 }
 
 async fn member(
-    db: &Mutex<Client>,
+    db: &Store,
     email: &str,
     role: Option<&str>,
     identity: Option<&str>,
@@ -73,7 +75,7 @@ async fn member(
     db.lock().await.execute("INSERT INTO acme_member_head_snapshot_1 (id, ordinal, state) VALUES ($1, 1, $2::jsonb)", &[&email, &state]).await.unwrap();
 }
 
-async fn known_identity(db: &Mutex<Client>, issuer: &str, subject: &str, identity: &str) {
+async fn known_identity(db: &Store, issuer: &str, subject: &str, identity: &str) {
     let state =
         json!({"issuer": {"value": issuer}, "subject": {"value": subject}, "identity": identity});
     let id = format!("{issuer}:{subject}");
@@ -81,7 +83,7 @@ async fn known_identity(db: &Mutex<Client>, issuer: &str, subject: &str, identit
 }
 
 struct World {
-    db: Mutex<Client>,
+    db: Store,
     ir: Value,
     config: LineageConfig,
 }
@@ -95,13 +97,14 @@ impl World {
                 domain: "Acme".into(),
                 era: Some(1),
                 mirrored: None,
+                seal_every: None,
             },
         }
     }
 
     fn members(&self) -> HostMembers<'_> {
         HostMembers {
-            client: &self.db,
+            store: &self.db,
             domain_ir: &self.ir,
             wasm_path: Path::new("unused.wasm"),
             config: &self.config,

data/rust/host/src/platform_signin/session.rs

@@ -12,19 +12,18 @@
 //! A member without a role is refused as well. The token's role is compared with the member's
 //! local role and a difference is logged, never written.
 
+use crate::store::Store;
 use std::path::Path;
 
 use async_trait::async_trait;
 use serde_json::Value;
-use tokio::sync::Mutex;
-use tokio_postgres::Client;
 
 use super::settings::SigninSettings;
 use super::verify::VerifiedClaims;
 use super::{cookie, pages};
 use crate::auth::{self, Session};
-use crate::journal::LineageConfig;
 use crate::lambda_client::LambdaInvoker;
+use crate::store::journal_sql::LineageConfig;
 
 /// Where the account lands after a successful sign-in.
 pub const LANDING_PATH: &str = "/admin.html";
@@ -113,7 +112,7 @@ pub fn signed_in(settings: &SigninSettings, session: &Session) -> Value {
 
 /// The host's own member store, reached through the same functions the Google sign-in uses.
 pub struct HostMembers<'a> {
-    pub client: &'a Mutex<Client>,
+    pub store: &'a Store,
     pub domain_ir: &'a Value,
     pub wasm_path: &'a Path,
     pub config: &'a LineageConfig,
@@ -123,18 +122,12 @@ pub struct HostMembers<'a> {
 #[async_trait]
 impl MemberDirectory for HostMembers<'_> {
     async fn identity_for(&self, issuer: &str, subject: &str) -> anyhow::Result<Option<String>> {
-        auth::resolve_identity_anywhere(
-            self.client,
-            self.wasm_path,
-            self.domain_ir,
-            issuer,
-            subject,
-        )
-        .await
+        auth::resolve_identity_anywhere(self.store, self.wasm_path, self.domain_ir, issuer, subject)
+            .await
     }
 
     async fn session_for_identity(&self, identity_id: &str) -> anyhow::Result<Option<Session>> {
-        auth::session_for_member_by_identity(self.client, self.domain_ir, identity_id).await
+        auth::session_for_member_by_identity(self.store, self.domain_ir, identity_id).await
     }
 
     async fn provision(
@@ -144,7 +137,7 @@ impl MemberDirectory for HostMembers<'_> {
         subject: &str,
     ) -> anyhow::Result<Option<Session>> {
         auth::provision(
-            self.client,
+            self.store,
             self.wasm_path,
             self.config,
             self.domain_ir,

data/rust/host/src/platform_signin/verify.rs

@@ -172,7 +172,6 @@ pub struct VerifiedClaims {
     /// The `roles` claim when it is an array; its string members only.
     pub roles: Vec<String>,
     pub nonce: String,
-    pub jti: String,
     pub issued_at: i64,
     pub not_before: i64,
     pub expires_at: i64,
@@ -422,7 +421,6 @@ fn accepted(all: JsonObject) -> VerifiedClaims {
         idp_subject: optional("idp_sub"),
         roles: role_names(&all),
         nonce: text("nonce"),
-        jti: text("jti"),
         issued_at: time("iat"),
         not_before: time("nbf"),
         expires_at: time("exp"),

data/rust/host/src/presentation_tests.rs

@@ -0,0 +1,382 @@
+//! The presentation config read from a real Postgres head view.
+
+#![allow(unused_imports)]
+
+#[cfg(test)]
+mod tests {
+    use crate::journal::LineageConfig;
+    use crate::store::{Store, StoreFixtures};
+    use rust_host_core::presentation::*;
+    use serde_json::json;
+    use serde_json::Value;
+
+    // Row literals below are copied from the real rows the console
+    // app's own database holds, not invented shapes.
+
+    #[test]
+    fn a_collections_four_aggregates_read_back_as_one_entry_and_the_newer_rows_win() {
+        let rows = vec![
+            json!({"agg": {"value": "Invoice"}, "label": {"value": "Invoices"},
+                   "columns": [{"field": "stale"}]}),
+            json!({"agg": {"value": "Invoice"}, "identity_field": {"value": "number"},
+                   "identity_strategy": {"value": "sequence"}}),
+            json!({"agg": {"value": "Invoice"}, "columns": [{"field": "number"}]}),
+            json!({"agg": {"value": "Invoice"}, "preconditions": [], "field_formats": []}),
+        ];
+
+        let entry = &reshape_collections(&rows)["Invoice"];
+
+        assert_eq!(
+            (
+                &entry["label"],
+                &entry["columns"],
+                &entry["identity"]["field"]
+            ),
+            (
+                &json!("Invoices"),
+                &json!([{"field": "number"}]),
+                &json!("number")
+            )
+        );
+    }
+
+    #[test]
+    fn a_state_row_becomes_a_tone_an_attention_flag_and_its_extras() {
+        let rows = vec![
+            json!({"agg": {"value": "Invoice"}, "tone": {"value": "muted"}, "state": {"value": "void"},
+                   "attention": null, "extra_json": {"value": "{\"label\":\"Voided\"}"}}),
+            json!({"agg": {"value": "Invoice"}, "tone": {"value": "danger"}, "state": {"value": "overdue"},
+                   "attention": {"value": "true"}, "extra_json": null}),
+        ];
+
+        assert_eq!(
+            reshape_states(&rows),
+            json!({
+                "Invoice": {
+                    "void": {"tone": "muted", "label": "Voided"},
+                    "overdue": {"tone": "danger", "attention": true}
+                }
+            })
+        );
+    }
+
+    #[test]
+    fn attention_stored_as_the_string_false_reads_back_as_the_boolean_false() {
+        let rows = vec![
+            json!({"agg": {"value": "Client"}, "state": {"value": "active"}, "attention": {"value": "false"}}),
+        ];
+
+        assert_eq!(
+            reshape_states(&rows),
+            json!({"Client": {"active": {"attention": false}}})
+        );
+    }
+
+    #[test]
+    fn a_collection_row_becomes_the_whole_entry_ui_schema_reads() {
+        let rows = vec![json!({
+            "agg": {"value": "Client"}, "key": {"value": "clients"}, "label": {"value": "Clients"},
+            "columns": [{"field": "reference"}, {"field": "name"}, {"field": "__state__"}],
+            "nav_order": {"value": 1},
+            "extra_json": {"value": "{\"noun_sing\":\"client\",\"create_label\":\"Add client\"}"},
+            "list_query": null,
+            "detail_fields": [{"field": "contact_email"}, {"field": "name"}],
+            "field_formats": [], "preconditions": [],
+            "primary_field": {"value": "name"},
+            "identity_field": {"value": "reference"}, "identity_prefix": null,
+            "identity_source": {"value": "name"}, "identity_strategy": {"value": "slug"},
+            "identity_extra_json": null, "detail_field_columns": []
+        })];
+
+        assert_eq!(
+            reshape_collections(&rows),
+            json!({
+                "Client": {
+                    "label": "Clients",
+                    "key": "clients",
+                    "nav_order": 1,
+                    "primary_field": "name",
+                    "identity": {"field": "reference", "strategy": "slug", "source": "name"},
+                    "columns": [{"field": "reference"}, {"field": "name"}, {"field": "__state__"}],
+                    "detail_fields": [{"field": "contact_email"}, {"field": "name"}],
+                    "preconditions": [],
+                    "field_formats": {},
+                    "noun_sing": "client",
+                    "create_label": "Add client"
+                }
+            })
+        );
+    }
+
+    #[test]
+    fn a_precondition_carries_its_state_and_its_extra_message() {
+        let rows = vec![json!({
+            "agg": {"value": "Contract"},
+            "columns": [], "detail_fields": [], "detail_field_columns": [], "field_formats": [],
+            "preconditions": [{"field": "proposal_id", "state": "accepted",
+                               "extra_json": "{\"message\":\"the proposal hasn't been accepted yet\"}"}],
+            "identity_field": {"value": "number"}, "identity_strategy": {"value": "sequence"},
+            "identity_prefix": {"value": "C-"}, "identity_extra_json": {"value": "{\"pad\":3}"}
+        })];
+
+        let config = reshape_collections(&rows);
+        assert_eq!(
+            config["Contract"]["preconditions"],
+            json!([{"field": "proposal_id", "state": "accepted", "message": "the proposal hasn't been accepted yet"}])
+        );
+        // `pad` is not modelled as its own attribute — it rides through
+        // the identity rule's own opaque blob and has to land inside
+        // the identity entry, not beside it.
+        assert_eq!(
+            config["Contract"]["identity"],
+            json!({"field": "number", "strategy": "sequence", "prefix": "C-", "pad": 3})
+        );
+    }
+
+    #[test]
+    fn a_precondition_with_no_state_keeps_an_explicit_null_state() {
+        let rows = vec![json!({
+            "agg": {"value": "Payment"}, "columns": [], "detail_fields": [], "detail_field_columns": [],
+            "field_formats": [], "preconditions": [{"field": "invoice_id"}]
+        })];
+
+        assert_eq!(
+            reshape_collections(&rows)["Payment"]["preconditions"],
+            json!([{"field": "invoice_id", "state": null}])
+        );
+    }
+
+    #[test]
+    fn detail_field_columns_regroup_under_the_field_that_owns_them() {
+        let rows = vec![json!({
+            "agg": {"value": "CampingList"}, "columns": [], "field_formats": [], "preconditions": [],
+            "detail_fields": [
+                {"field": "placements", "display": "rows", "state_filter": "placed"},
+                {"field": "name"}
+            ],
+            "detail_field_columns": [
+                {"field": "placements", "column": "item_id"},
+                {"field": "placements", "column": "position"}
+            ]
+        })];
+
+        assert_eq!(
+            reshape_collections(&rows)["CampingList"]["detail_fields"],
+            json!([
+                {"field": "placements", "display": "rows", "state_filter": "placed", "columns": ["item_id", "position"]},
+                {"field": "name"}
+            ])
+        );
+    }
+
+    #[test]
+    fn a_column_entry_reads_its_sortable_string_back_as_a_boolean_and_keeps_its_head() {
+        let rows = vec![json!({
+            "agg": {"value": "Invoice"}, "detail_fields": [], "detail_field_columns": [],
+            "field_formats": [{"field": "issued_on", "format": "date"}], "preconditions": [],
+            "columns": [{"field": "number", "sortable": "false", "sort_default": "desc", "extra_json": "{\"head\":\"No.\"}"}]
+        })];
+
+        let entry = &reshape_collections(&rows)["Invoice"];
+        assert_eq!(
+            entry["columns"],
+            json!([{"field": "number", "sortable": false, "sort_default": "desc", "head": "No."}])
+        );
+        assert_eq!(entry["field_formats"], json!({"issued_on": "date"}));
+    }
+
+    #[test]
+    fn the_overview_singleton_becomes_stats_with_their_where_clauses_parsed() {
+        let rows = vec![json!({
+            "key": {"value": "overview"},
+            "stats": [
+                {"as": "count", "label": "Active clients", "collection": "clients", "where_json": "{\"state\":\"active\"}"},
+                {"as": "money_sum", "field": "line_items", "label": "Outstanding", "collection": "invoices",
+                 "where_json": "{\"state\":{\"in\":[\"sent\",\"overdue\"]}}"}
+            ]
+        })];
+
+        assert_eq!(
+            reshape_overview(&rows),
+            json!({"stats": [
+                {"label": "Active clients", "collection": "clients", "as": "count", "where": {"state": "active"}},
+                {"label": "Outstanding", "collection": "invoices", "as": "money_sum", "field": "line_items",
+                 "where": {"state": {"in": ["sent", "overdue"]}}}
+            ]})
+        );
+    }
+
+    #[test]
+    fn a_domain_that_has_never_saved_an_overview_reads_back_an_empty_section() {
+        assert_eq!(reshape_overview(&[]), json!({}));
+        assert_eq!(
+            reshape(&[], &[], &[]),
+            json!({"states": {}, "collections": {}, "overview": {}})
+        );
+    }
+
+    #[test]
+    fn an_explicitly_modelled_field_always_beats_the_same_key_in_the_extras_blob() {
+        let rows = vec![
+            json!({"agg": {"value": "Client"}, "tone": {"value": "good"},
+                               "extra_json": {"value": "{\"tone\":\"danger\",\"note\":\"n\"}"},
+                               "state": {"value": "active"}}),
+        ];
+
+        assert_eq!(
+            reshape_states(&rows),
+            json!({"Client": {"active": {"tone": "good", "note": "n"}}})
+        );
+    }
+
+    // What follows needs a real database: which relation this module
+    // reads, and what it does when there isn't one. Same throwaway-db
+    // pattern as dispatch.rs's own tests, uniquely named per test so
+    // `cargo test`'s parallelism doesn't race two against one table.
+
+    async fn scratch_db(name: &str) -> Store {
+        let (admin, conn) =
+            tokio_postgres::connect(&crate::test_pg::conninfo("postgres"), tokio_postgres::NoTls)
+                .await
+                .expect("connect to postgres");
+        tokio::spawn(async move {
+            let _ = conn.await;
+        });
+        admin
+            .batch_execute(&format!("DROP DATABASE IF EXISTS {name} WITH (FORCE)"))
+            .await
+            .unwrap();
+        admin
+            .batch_execute(&format!("CREATE DATABASE {name}"))
+            .await
+            .unwrap();
+
+        let (client, conn) =
+            tokio_postgres::connect(&crate::test_pg::conninfo(name), tokio_postgres::NoTls)
+                .await
+                .expect("connect to scratch db");
+        tokio::spawn(async move {
+            let _ = conn.await;
+        });
+        crate::store::postgres_store(client)
+    }
+
+    // A plain table, not a view — this module only ever SELECTs
+    // `state`, so a relation's real provenance doesn't matter here.
+    /// A domain matching none of these fixtures' relations, so lookup
+    /// falls through to whatever each test seeds directly.
+    fn relations_only() -> LineageConfig {
+        LineageConfig {
+            domain: "Fixtures".to_string(),
+            era: None,
+            mirrored: None,
+            seal_every: None,
+        }
+    }
+
+    async fn seed_head(client: &Store, relation: &str, id: &str, state: Value) {
+        let guard = client.lock().await;
+        guard
+            .batch_execute(&format!(
+                "CREATE TABLE IF NOT EXISTS {relation} (id text primary key, state jsonb)"
+            ))
+            .await
+            .unwrap();
+        guard
+            .execute(
+                &format!("INSERT INTO {relation} (id, state) VALUES ($1, $2)"),
+                &[&id, &state],
+            )
+            .await
+            .unwrap();
+    }
+
+    // Which kind of empty is the one question the instance map alone
+    // can't answer; both tests below run against a real compiled
+    // kernel, since a fixture can't fake "does this wasm know this read model".
+
+    #[tokio::test]
+    async fn a_kernel_that_carries_the_bluebook_but_holds_no_rows_answers_some_empty() {
+        let client = crate::dispatch_tests::tests::memory_store();
+        let wasm = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .join("../dist/checkout_fixture.wasm");
+
+        let rows = kernel_rows(&client, &wasm)
+            .await
+            .expect("a read")
+            .expect("the bluebook is compiled in");
+
+        assert!(rows.states.is_empty());
+        assert!(rows.collections.is_empty());
+        assert!(rows.overview.is_empty());
+    }
+
+    #[tokio::test]
+    async fn a_kernel_without_the_bluebook_answers_none_so_the_relations_are_read_instead() {
+        let client = crate::dispatch_tests::tests::memory_store();
+        let wasm = crate::dispatch_tests::tests::wasm_path();
+
+        assert!(kernel_rows(&client, &wasm).await.expect("a read").is_none());
+    }
+
+    #[tokio::test]
+    async fn load_reads_the_pre_0059_unqualified_relation_the_console_still_writes() {
+        let client = scratch_db("hecks_host_presentation_legacy_relation").await;
+        seed_head(&client, "state_style_head", "Client:active", json!({"agg": {"value": "Client"}, "state": {"value": "active"}, "tone": {"value": "good"}})).await;
+
+        let config = load_from_relations(&client, &relations_only())
+            .await
+            .expect("a config");
+
+        assert_eq!(
+            config["states"],
+            json!({"Client": {"active": {"tone": "good"}}})
+        );
+        assert_eq!(config["collections"], json!({}));
+        assert_eq!(config["overview"], json!({}));
+    }
+
+    #[tokio::test]
+    async fn load_prefers_the_domain_qualified_relation_when_both_exist() {
+        let client = scratch_db("hecks_host_presentation_qualified_wins").await;
+        seed_head(&client, "state_style_head", "Client:active", json!({"agg": {"value": "Client"}, "state": {"value": "active"}, "tone": {"value": "muted"}})).await;
+        seed_head(
+            &client,
+            "console_settings_state_style_head",
+            "Client:active",
+            json!({"agg": {"value": "Client"}, "state": {"value": "active"}, "tone": {"value": "good"}}),
+        )
+        .await;
+
+        let config = load_from_relations(&client, &relations_only())
+            .await
+            .expect("a config");
+
+        assert_eq!(config["states"]["Client"]["active"]["tone"], "good");
+    }
+
+    #[tokio::test]
+    async fn load_answers_an_empty_config_for_a_domain_with_no_console_settings_relations() {
+        let client = scratch_db("hecks_host_presentation_no_relations").await;
+
+        assert_eq!(
+            load_from_relations(&client, &relations_only())
+                .await
+                .expect("a config"),
+            json!({"states": {}, "collections": {}, "overview": {}})
+        );
+    }
+
+    #[test]
+    fn a_malformed_extras_blob_is_ignored_rather_than_failing_the_whole_read() {
+        let rows = vec![
+            json!({"agg": {"value": "Client"}, "state": {"value": "active"},
+                               "tone": {"value": "good"}, "extra_json": {"value": "not json at all"}}),
+        ];
+
+        assert_eq!(
+            reshape_states(&rows),
+            json!({"Client": {"active": {"tone": "good"}}})
+        );
+    }
+}

data/rust/host/src/rate_limit.rs

@@ -1,5 +1,6 @@
 //! Per-address sliding-window rate limits for the public write routes a stranger can abuse,
-//! enforced in `server.rs` before dispatch so a refused request costs no Postgres lock or run.
+//! enforced before dispatch (`server.rs`, in serve and Lambda mode alike) so a refused request costs
+//! no Postgres lock or run.
 
 use crate::crypto::constant_time_eq;
 use crate::extension::RateRule;
@@ -561,8 +562,10 @@ const fn is_private(ip: IpAddr) -> bool {
     }
 }
 
+const TOO_MANY_REQUESTS: &str = "too many requests, please try again later";
+
 pub fn too_many_requests(retry_after_secs: u64) -> Response {
-    let body = json!({ "error": "too many requests, please try again later" }).to_string();
+    let body = json!({ "error": TOO_MANY_REQUESTS }).to_string();
     let mut response = (StatusCode::TOO_MANY_REQUESTS, body).into_response();
     let headers = response.headers_mut();
     headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
@@ -570,6 +573,19 @@ pub fn too_many_requests(retry_after_secs: u64) -> Response {
     response
 }
 
+/// `too_many_requests` as a Function-URL response, for Lambda mode.
+pub fn too_many_requests_event(retry_after_secs: u64) -> serde_json::Value {
+    json!({
+        "statusCode": 429,
+        "headers": {
+            "content-type": "application/json",
+            "retry-after": retry_after_secs.to_string(),
+        },
+        "body": json!({ "error": TOO_MANY_REQUESTS }).to_string(),
+        "isBase64Encoded": false,
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;