hecks 5.0.0 → 7.0.0

data/rust/build/src/seams_pass.rs

@@ -1,113 +1,63 @@
 //! Rust port of `Exporter::Bindings` (`lib/hecks/projector/exporter/bindings.rb`) and the provider
-//! lookups of `Registry::Providers`: which attached chapter answers each capability the target
-//! domain uses, read from every chapter's own `provides` entries in its IR.
+//! lookups of `Registry::Providers`: which attached bluebook answers each capability the target
+//! domain uses, read from every bluebook's own `provides` entries in its IR.
 
 use crate::json::Json;
 
-/// One capability's exported shape: the keys it exports as qualified verbs, then each derived
-/// `name => verb key` aggregate, in the order `Bindings` builds them, then its optional marks.
+/// One capability the language defines that `rust/host` reads: the keys it exports as qualified
+/// verbs, then each derived `name => verb key` aggregate, in the order `Bindings` builds them.
 struct Seam {
     capability: &'static str,
-    export_as: &'static str,
     verbs: &'static [&'static str],
     aggregates: &'static [(&'static str, &'static str)],
-    marks: &'static [&'static str],
 }
 
 // In `TargetIr::SEAMS` order, which is the order the keys land in `ir.json`.
 const SEAMS: &[Seam] = &[
     Seam {
         capability: "authorization",
-        export_as: "authorization",
-        verbs: &["grant", "assignments"],
+        verbs: &["grant", "assignments", "live_assignments"],
         aggregates: &[("assignment_aggregate", "assignments")],
-        marks: &[],
     },
     Seam {
         capability: "membership",
-        export_as: "membership",
         verbs: &["admit", "grant", "people"],
         aggregates: &[("aggregate", "admit")],
-        marks: &[],
     },
     Seam {
         capability: "identity",
-        export_as: "identity",
         verbs: &["register", "link", "resolve"],
         aggregates: &[],
-        marks: &[],
-    },
-    Seam {
-        capability: "newsletter",
-        export_as: "newsletter",
-        verbs: &["subscribe", "add_name", "confirm", "unsubscribe"],
-        aggregates: &[("aggregate", "subscribe")],
-        marks: &["awaiting_confirmation", "receives_issues", "left"],
-    },
-    Seam {
-        capability: "newsletter_issues",
-        export_as: "newsletter_issues",
-        verbs: &["send_issue", "record_delivery"],
-        aggregates: &[
-            ("issue_aggregate", "send_issue"),
-            ("delivery_aggregate", "record_delivery"),
-        ],
-        marks: &[],
-    },
-    Seam {
-        capability: "payments",
-        export_as: "payments",
-        verbs: &["initiate", "succeeded", "failed"],
-        aggregates: &[("aggregate", "initiate")],
-        marks: &["holds_seat"],
-    },
-    Seam {
-        capability: "registrations",
-        export_as: "registrations",
-        verbs: &["schedule", "request"],
-        aggregates: &[
-            ("event_aggregate", "schedule"),
-            ("registration_aggregate", "request"),
-        ],
-        marks: &["frees_seat"],
-    },
-    Seam {
-        capability: "payment_connection",
-        export_as: "payment_connection",
-        verbs: &[
-            "connect",
-            "reconnect",
-            "disconnect",
-            "suspend",
-            "resume",
-            "enable",
-            "disable",
-        ],
-        aggregates: &[("aggregate", "connect")],
-        marks: &[],
     },
 ];
 
-/// Sets each seam some chapter provides on `target`, leaving it out otherwise, as
-/// `TargetIr#add_seams` does. `members` are the chapters the target attaches, in attach order; the
-/// target itself is searched first.
+/// Every capability the language defines a contract for (`Capabilities::CONTRACTS`); any other
+/// `provides` name is a package's own and exports through `provides`.
+const LANGUAGE_DEFINED: &[&str] = &[
+    "authorization",
+    "membership",
+    "identity",
+    "privacy",
+    "subject_keys",
+];
+
+/// Sets each seam some bluebook provides on `target`, leaving it out otherwise, as
+/// `TargetIr#add_seams` does, then the `provides` map of every capability a package declares.
+/// `members` are the bluebooks the target attaches, in attach order; the target itself is searched
+/// first.
 pub fn run(target: &mut Json, members: &[Json]) -> Result<(), String> {
-    let mut chapters: Vec<Json> = vec![target.clone()];
-    chapters.extend(members.iter().cloned());
+    let mut declarations: Vec<Json> = vec![target.clone()];
+    declarations.extend(members.iter().cloned());
 
     let mut membership = false;
     let mut identity = false;
     for seam in SEAMS {
-        let Some(provider) = chapters
-            .iter()
-            .find(|chapter| provision(chapter, seam.capability).is_some())
-        else {
+        let Some(provider) = provider_of(&declarations, seam.capability) else {
             continue;
         };
-        let exported = export(seam, provider);
         membership |= seam.capability == "membership";
         identity |= seam.capability == "identity";
-        target.set(seam.export_as, exported);
+        target.set(seam.capability, export(seam, provider));
     }
     if membership && !identity {
         return Err(format!(
@@ -116,9 +66,19 @@ pub fn run(target: &mut Json, members: &[Json]) -> Result<(), String> {
             name_of(target)
         ));
     }
+    let provided = package_provides(&declarations);
+    if matches!(&provided, Json::Object(entries) if !entries.is_empty()) {
+        target.set("provides", provided);
+    }
     Ok(())
 }
 
+fn provider_of<'a>(declarations: &'a [Json], capability: &str) -> Option<&'a Json> {
+    declarations
+        .iter()
+        .find(|declaration| provision(declaration, capability).is_some())
+}
+
 fn export(seam: &Seam, provider: &Json) -> Json {
     let name = name_of(provider);
     let entries = provision(provider, seam.capability).unwrap_or_default();
@@ -140,23 +100,93 @@ fn export(seam: &Seam, provider: &Json) -> Json {
             aggregate.map_or(Json::Null, Json::String),
         ));
     }
-    for key in seam.marks {
-        if let Some(states) = marked_states(
-            provider,
-            entries
+    Json::Object(out)
+}
+
+/// `Exporter.provides`: each package-declared capability, sorted by name, as its provider resolves
+/// every key (`Capabilities.resolved_value`).
+fn package_provides(declarations: &[Json]) -> Json {
+    let mut capabilities: Vec<String> = declarations
+        .iter()
+        .flat_map(|declaration| {
+            declaration
+                .get("provides")
+                .map_or(&[][..], Json::each)
                 .iter()
-                .find(|(k, _)| k == key)
-                .map(|(_, v)| v.as_str()),
-        ) {
-            out.push((key.to_string(), states));
+        })
+        .filter_map(|entry| entry.get("capability").and_then(Json::as_str))
+        .filter(|capability| !LANGUAGE_DEFINED.contains(capability))
+        .map(str::to_string)
+        .collect();
+    capabilities.sort();
+    capabilities.dedup();
+
+    let exported = capabilities
+        .into_iter()
+        .filter_map(|capability| {
+            let provider = provider_of(declarations, &capability)?;
+            let name = name_of(provider);
+            let mut out = vec![("provider".to_string(), Json::String(name.clone()))];
+            for (key, verb) in provision(provider, &capability).unwrap_or_default() {
+                out.push((key, resolved_value(provider, &name, &verb)));
+            }
+            Some((capability, Json::Object(out)))
+        })
+        .collect();
+    Json::Object(exported)
+}
+
+/// What a package-declared key's target resolves to: a lifecycle mark's states, an attribute's
+/// `{ attribute, default }`, or else the qualified verb of a command, query or port operation. The
+/// Ruby builder has already refused a target that names nothing or more than one kind.
+fn resolved_value(provider: &Json, name: &str, verb: &str) -> Json {
+    let Some((aggregate_name, member)) = verb.split_once('.') else {
+        return Json::String(format!("{name}::{verb}"));
+    };
+    let aggregate = provider
+        .get("aggregates")
+        .map_or(&[][..], Json::each)
+        .iter()
+        .find(|a| a.get("name").and_then(Json::as_str) == Some(aggregate_name));
+    if let Some(aggregate) = aggregate.filter(|_| !member.contains('.')) {
+        if let Some(states) = aggregate
+            .get("lifecycle")
+            .and_then(|l| l.get("marks"))
+            .and_then(|marks| marks.get(member))
+        {
+            return states.clone();
+        }
+        if let Some(attribute) = aggregate
+            .get("attributes")
+            .map_or(&[][..], Json::each)
+            .iter()
+            .find(|a| a.get("name").and_then(Json::as_str) == Some(member))
+        {
+            return Json::Object(vec![
+                ("attribute".to_string(), Json::String(member.to_string())),
+                (
+                    "default".to_string(),
+                    filled_default(attribute.get("default")),
+                ),
+            ]);
         }
     }
-    Json::Object(out)
+    Json::String(format!("{name}::{verb}"))
+}
+
+/// An attribute's `default:` as the reader sees it: a one-field value object's `{ value: ... }` fill
+/// unwrapped, as `Capabilities::AttributeValues#filled_value` does.
+fn filled_default(default: Option<&Json>) -> Json {
+    match default {
+        Some(object @ Json::Object(_)) => object.get("value").cloned().unwrap_or(Json::Null),
+        Some(value) => value.clone(),
+        None => Json::Null,
+    }
 }
 
-// `[(key, verb)]` this chapter provides under `capability`, or `None` when it provides none.
-fn provision(chapter: &Json, capability: &str) -> Option<Vec<(String, String)>> {
-    let entries: Vec<(String, String)> = chapter
+// `[(key, verb)]` this bluebook provides under `capability`, or `None` when it provides none.
+fn provision(declaration: &Json, capability: &str) -> Option<Vec<(String, String)>> {
+    let entries: Vec<(String, String)> = declaration
         .get("provides")
         .map_or(&[][..], Json::each)
         .iter()
@@ -171,20 +201,8 @@ fn provision(chapter: &Json, capability: &str) -> Option<Vec<(String, String)>>
     (!entries.is_empty()).then_some(entries)
 }
 
-// The states of the aggregate lifecycle mark a `"Aggregate.mark"` entry names; `None` when the
-// entry is not declared or the mark is.
-fn marked_states(provider: &Json, entry: Option<&str>) -> Option<Json> {
-    let (aggregate_name, mark) = entry?.split_once('.')?;
-    let aggregate = provider
-        .get("aggregates")
-        .map(Json::each)?
-        .iter()
-        .find(|a| a.get("name").and_then(Json::as_str) == Some(aggregate_name))?;
-    aggregate.get("lifecycle")?.get("marks")?.get(mark).cloned()
-}
-
-fn name_of(chapter: &Json) -> String {
-    chapter
+fn name_of(declaration: &Json) -> String {
+    declaration
         .get("name")
         .and_then(Json::as_str)
         .unwrap_or_default()

data/rust/build/src/world_pass.rs

@@ -7,31 +7,31 @@ use std::path::Path;
 use crate::json::Json;
 use crate::subprocess;
 
-/// Sets `world` right after `adapters`. With no `.world` file beside the domain it is the empty fact.
+/// The `world` fact for `domain`. With no `.world` file beside the domain it is the empty fact.
 ///
 /// # Errors
 ///
 /// Returns the parser's failure, or a message naming output that is not the JSON array
 /// `hecks-parse world` prints.
-pub fn run(ir: &mut Json, parser_bin: &Path, world: Option<&Path>) -> Result<(), String> {
+pub fn read(domain: &str, parser_bin: &Path, world: Option<&Path>) -> Result<Json, String> {
     let Some(world) = world else {
-        ir.set("world", fact(None));
-        return Ok(());
+        return Ok(fact(None));
     };
-    let domain = ir
-        .get("name")
-        .and_then(Json::as_str)
-        .unwrap_or_default()
-        .to_string();
     let world_arg = world.to_string_lossy();
     let printed = subprocess::run_capture(&parser_bin.to_string_lossy(), &["world", &world_arg])?;
     let parsed = Json::parse(&printed).map_err(|e| format!("parsing hecks-parse world: {e}"))?;
     let entry = parsed
         .each()
         .iter()
-        .find(|w| w.get("domain").and_then(Json::as_str) == Some(domain.as_str()));
-    ir.set("world", fact(entry));
-    Ok(())
+        .find(|w| w.get("domain").and_then(Json::as_str) == Some(domain));
+    Ok(fact(entry))
+}
+
+/// The world's `default_adapter`, when it names one.
+pub fn default_adapter(fact: &Json) -> Option<String> {
+    fact.get("default_adapter")
+        .and_then(Json::as_str)
+        .map(str::to_string)
 }
 
 fn fact(entry: Option<&Json>) -> Json {
@@ -81,6 +81,15 @@ mod tests {
         Json::parse(text).expect("fixture json")
     }
 
+    #[test]
+    fn the_default_adapter_is_read_from_the_fact_or_absent() {
+        let named = fact(Some(&parsed(
+            r#"{"domain":"C","default_adapter":"Heki","bindings":[]}"#,
+        )));
+        assert_eq!(default_adapter(&named), Some("Heki".to_string()));
+        assert_eq!(default_adapter(&fact(None)), None);
+    }
+
     #[test]
     fn fact_keeps_only_persisted_by_bindings_and_the_defaults() {
         let entry = parsed(

data/rust/codegen/Cargo.toml

@@ -20,7 +20,7 @@ path = "src/main.rs"
 debug = 0
 
 # Clippy beyond its defaults: pedantic and nursery, plus the restriction lints that keep a panic
-# out of library code. `hecks gate_run.gate stage=ci only=rust_clippy` makes each of these an error.
+# out of library code. `hecks gate_run.gate! stage=ci only=rust_clippy` makes each of these an error.
 # The same table is in every crate's Cargo.toml; change them together.
 [lints.clippy]
 pedantic = { level = "warn", priority = -1 }

data/rust/codegen/src/domain_generator.rs

@@ -22,7 +22,7 @@ pub struct GeneratedDomain {
     pub aggregate_files: Vec<GeneratedFile>,
     pub registry_rs: String,
     pub mod_rs: String,
-    /// Returned so a multi-chapter caller can union aggregates, queries and read models.
+    /// Returned so a multi-bluebook caller can union aggregates, queries and read models.
     pub registry_aggregates: Vec<AggregateEntry>,
     pub query_defs: Vec<crate::queries::QueryDef>,
     pub read_model_defs: Vec<crate::read_models::ReadModelDef>,
@@ -34,6 +34,15 @@ fn node_name(node: &Json) -> &str {
     node.get("name").and_then(Json::as_str).unwrap_or("")
 }
 
+/// Every role that may run a command when its IR lists several under `roles`; empty otherwise,
+/// when `role` alone says it.
+fn roles_of(command: &Json) -> Vec<String> {
+    match command.get("roles") {
+        Some(Json::Array(roles)) => roles.iter().map(Json::to_s).collect(),
+        _ => Vec::new(),
+    }
+}
+
 fn reference_checks(
     command: &Json,
     aggregates_by_name: &HashMap<String, &Json>,
@@ -58,6 +67,8 @@ fn reference_checks(
                 field: crate::attr::name(attr).to_string(),
                 optional: crate::attr::optional(attr),
                 list_item: None,
+                union_tag: None,
+                settled: false,
                 target_mod: target
                     .get("name")
                     .and_then(Json::as_str)
@@ -144,6 +155,8 @@ fn state_reference_checks(
                 field: accessor,
                 optional: crate::attr::optional(source_attr),
                 list_item,
+                union_tag: None,
+                settled: true,
                 target_mod: target
                     .get("name")
                     .and_then(Json::as_str)
@@ -724,6 +737,7 @@ pub fn generate(
                             &value_objects_by_name,
                         ),
                         role: command.get("role").map(Json::to_s),
+                        roles: roles_of(command),
                         entity_name: entity_name_str.to_string(),
                         entity_identity_reading: entity
                             .get("identified_by")
@@ -843,6 +857,7 @@ pub fn generate(
                         &value_objects_by_name,
                     ),
                     role: command.get("role").map(Json::to_s),
+                    roles: roles_of(command),
                     entity_name: entity
                         .get("name")
                         .and_then(Json::as_str)
@@ -1013,6 +1028,12 @@ pub fn generate(
                         &unsupported_names,
                         &value_objects_by_name,
                     ));
+                    checks.extend(crate::one_of_references::checks(
+                        aggregate,
+                        command,
+                        &aggregates_by_name,
+                        &unsupported_names,
+                    ));
                     checks
                 },
                 tenant_boundary_checks: tenant_boundary_checks(
@@ -1034,6 +1055,7 @@ pub fn generate(
                     &value_objects_by_name,
                 ),
                 role: command.get("role").map(Json::to_s),
+                roles: roles_of(command),
             });
         }
 
@@ -1135,7 +1157,7 @@ pub fn generate(
             entity_commands,
             nested_entity_commands,
             ports: port_operations,
-            chapter_mod: mod_name.to_string(),
+            bluebook_mod: mod_name.to_string(),
             domain_name: domain_name.to_string(),
             reference_specs: crate::reference_specs::reference_specs(
                 domain_name,
@@ -1197,6 +1219,7 @@ pub fn generate(
                 aggregate: format!("{domain_name}::{agg_name}"),
                 arg_checks: queries::query_arg_checks(
                     query,
+                    agg_name,
                     &format!(
                         "crate::generated::{mod_name}::{}",
                         crate::naming::aggregate_module(agg_name)
@@ -1210,6 +1233,7 @@ pub fn generate(
                     .map(|ob| queries::emit_query_order_by(ob, query.get("null_semantics"))),
                 offset: query.get("offset").map(queries::emit_query_offset),
                 limit: query.get("limit").map(queries::emit_query_limit),
+                cursor: query.get("cursor").is_some(),
                 authorization: queries::emit_query_authorization(
                     query_name,
                     query.get("authorization"),
@@ -1259,6 +1283,7 @@ pub fn generate(
                         .map(|ob| queries::emit_query_order_by(ob, query.get("null_semantics"))),
                     offset: query.get("offset").map(queries::emit_query_offset),
                     limit: query.get("limit").map(queries::emit_query_limit),
+                    cursor: false,
                     authorization: None,
                     assignments: false,
                     entity: Some(queries::EntityScope {

data/rust/codegen/src/expr_emitter.rs

@@ -58,6 +58,12 @@ pub fn emit_ast(node: &Json) -> String {
             boxed("predicate"),
             path_of(node, op).iter().map(|segment| ruby_inspect_string(segment)).collect::<Vec<_>>().join(", ")
         ),
+        "sum" => format!(
+            "Expr::Sum {{ receiver: {}, param: {}, predicate: {} }}",
+            boxed("receiver"),
+            text("param"),
+            boxed("predicate")
+        ),
         "array" => format!(
             "Expr::Array(vec![{}])",
             field(node, op, "elements").each().iter().map(emit_ast).collect::<Vec<_>>().join(", ")