hecks 4.0.0 → 6.0.0

data/rust/build/src/resolve.rs

@@ -1,4 +1,4 @@
-//! Chapter resolution: header names, framework members and vendored packages, found by text
+//! Bluebook resolution: header names, framework members and vendored packages, found by text
 //! scanning and directory listing rather than by executing any DSL.
 
 use std::path::{Path, PathBuf};
@@ -23,7 +23,7 @@ pub fn bluebook_files(directory: &Path) -> Result<Vec<PathBuf>, String> {
 }
 
 // Plain text scan of the `Hecks.bluebook "Name"` line; the file is never executed.
-pub fn header_chapter_name(path: &Path) -> Result<String, String> {
+pub fn header_bluebook_name(path: &Path) -> Result<String, String> {
     let text =
         std::fs::read_to_string(path).map_err(|e| format!("reading {}: {e}", path.display()))?;
     for line in text.lines() {
@@ -77,73 +77,129 @@ pub fn grammar_files(root: &Path) -> Result<Vec<PathBuf>, String> {
     bluebook_files(&dir)
 }
 
-// The names `attaches "Name"` gave, for a chapter the gem carries.
-pub fn resolve_gem_chapters(
+// The names `attaches "Name"` gave, for a bluebook the gem carries.
+pub fn resolve_gem_bluebooks(
     parser_bin: &Path,
-    chapter_name: &str,
+    declaration_name: &str,
     hecksagon_path: &Path,
 ) -> Result<Vec<String>, String> {
-    resolve_json(parser_bin, chapter_name, hecksagon_path, "gem_chapters")
+    resolve_json(
+        parser_bin,
+        declaration_name,
+        hecksagon_path,
+        "gem_bluebooks",
+    )
 }
 
 // The names `attaches "name", from: :vendor` gave, for a vendored package.
 pub fn resolve_vendored_packages(
     parser_bin: &Path,
-    chapter_name: &str,
+    declaration_name: &str,
     hecksagon_path: &Path,
 ) -> Result<Vec<String>, String> {
     resolve_json(
         parser_bin,
-        chapter_name,
+        declaration_name,
         hecksagon_path,
         "vendored_packages",
     )
 }
 
-// Where the gem keeps the chapters other than framework members, relative to `lib/hecks`; the
-// same places `Hecks::Chapters::GLOBS` lists.
-const OTHER_GEM_CHAPTER_DIRS: &[&str] = &[
+// Where the gem keeps the bluebooks other than framework members, relative to `lib/hecks`; the
+// same places `Hecks::Bluebooks::GLOBS` lists.
+const OTHER_GEM_BLUEBOOK_DIRS: &[&str] = &[
     "language",
     "grammar",
     "tenancy/bluebook",
     "deploy/bluebook",
+    "site/bluebook",
+    "tickets/bluebook",
+    "composer/bluebook",
     "quality_control",
+    "bulk/bluebook",
 ];
 
-// The names of the chapters the gem carries beside the framework members, found by reading each
-// file's header. Only the Ruby runtime loads them, so the build uses this list to tell a real
-// gem chapter from a misspelt name.
-pub fn other_gem_chapter_names(root: &Path) -> Result<Vec<String>, String> {
-    fn walk(directory: &Path, names: &mut Vec<String>) -> Result<(), String> {
-        let Ok(entries) = std::fs::read_dir(directory) else {
+// Every bluebook the gem carries beside the framework members, with the bluebook its header names.
+fn other_gem_bluebook_entries(root: &Path) -> Result<Vec<(String, PathBuf)>, String> {
+    fn walk(directory: &Path, entries: &mut Vec<(String, PathBuf)>) -> Result<(), String> {
+        let Ok(listing) = std::fs::read_dir(directory) else {
             return Ok(());
         };
-        for entry in entries {
+        for entry in listing {
             let path = entry
                 .map_err(|e| format!("reading {}: {e}", directory.display()))?
                 .path();
             if path.is_dir() {
-                walk(&path, names)?;
+                walk(&path, entries)?;
             } else if path.extension().and_then(|e| e.to_str()) == Some("bluebook") {
-                if let Ok(name) = header_chapter_name(&path) {
-                    names.push(name);
+                if let Ok(name) = header_bluebook_name(&path) {
+                    entries.push((name, path));
                 }
             }
         }
         Ok(())
     }
-    let mut names = Vec::new();
-    for directory in OTHER_GEM_CHAPTER_DIRS {
-        walk(&root.join("lib/hecks").join(directory), &mut names)?;
+    let mut entries = Vec::new();
+    for directory in OTHER_GEM_BLUEBOOK_DIRS {
+        walk(&root.join("lib/hecks").join(directory), &mut entries)?;
     }
-    names.sort();
+    entries.sort();
+    Ok(entries)
+}
+
+// The names of the bluebooks the gem carries beside the framework members, found by reading each
+// file's header, so the build tells a real gem bluebook from a misspelt name.
+pub fn other_gem_bluebook_names(root: &Path) -> Result<Vec<String>, String> {
+    let mut names: Vec<String> = other_gem_bluebook_entries(root)?
+        .into_iter()
+        .map(|(name, _)| name)
+        .collect();
     names.dedup();
     Ok(names)
 }
 
+// The files that declare one of the gem's other bluebooks, sorted, as `Hecks::Bluebooks` loads them,
+// then the `<snake_name>.ports.hecksagon` beside them that declares the bluebook's ports.
+pub fn other_gem_bluebook_files(root: &Path, declaration: &str) -> Result<Vec<PathBuf>, String> {
+    let mut files: Vec<PathBuf> = other_gem_bluebook_entries(root)?
+        .into_iter()
+        .filter(|(name, _)| name == declaration)
+        .map(|(_, path)| path)
+        .collect();
+    let ports = files
+        .first()
+        .and_then(|first| first.parent())
+        .map(|directory| {
+            directory.join(format!(
+                "{}.ports.hecksagon",
+                crate::hecks_naming::snake(declaration)
+            ))
+        });
+    files.extend(ports.filter(|path| path.is_file()));
+    Ok(files)
+}
+
+// Every `.hecksagon` beside a domain's bluebooks, sorted, as the registry loads them.
+pub fn hecksagon_files(directory: &Path) -> Result<Vec<PathBuf>, String> {
+    let Ok(listing) = std::fs::read_dir(directory) else {
+        return Ok(Vec::new());
+    };
+    let mut files = Vec::new();
+    for entry in listing {
+        let path = entry
+            .map_err(|e| format!("reading {}: {e}", directory.display()))?
+            .path();
+        if path.extension().and_then(|extension| extension.to_str()) == Some("hecksagon") {
+            files.push(path);
+        }
+    }
+    files.sort();
+    Ok(files)
+}
+
 fn resolve_json(
     parser_bin: &Path,
-    chapter_name: &str,
+    declaration_name: &str,
     hecksagon_path: &Path,
     key: &str,
 ) -> Result<Vec<String>, String> {
@@ -151,7 +207,7 @@ fn resolve_json(
     let hecksagon_str = hecksagon_path.to_string_lossy().to_string();
     let out = subprocess::run_capture(
         &parser_bin_str,
-        &["resolve", "--chapter", chapter_name, &hecksagon_str],
+        &["resolve", "--bluebook", declaration_name, &hecksagon_str],
     )?;
     let json = Json::parse(&out)
         .map_err(|e| format!("parsing 'hecks-parse resolve' output: {e}\n{out}"))?;
@@ -164,7 +220,7 @@ fn resolve_json(
 }
 
 /// `/\A[a-z][a-z0-9_]*\z/` — the shape `hecks vendor` accepts for a package directory name.
-/// The name is joined into a path and, through its chapter, into a directory the build deletes,
+/// The name is joined into a path and, through its bluebook, into a directory the build deletes,
 /// so `../x` or an absolute path must never reach either.
 pub fn valid_package_name(name: &str) -> bool {
     let mut chars = name.chars();
@@ -219,7 +275,7 @@ mod tests {
     }
 
     #[test]
-    fn extracts_the_quoted_chapter_name() {
+    fn extracts_the_quoted_bluebook_name() {
         assert_eq!(extract_quoted(r#" "Pizzas""#), Some("Pizzas".to_string()));
         assert_eq!(
             extract_quoted(r#" "Console Settings" do"#),

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/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,7 @@ fn reference_checks(
                 field: crate::attr::name(attr).to_string(),
                 optional: crate::attr::optional(attr),
                 list_item: None,
+                union_tag: None,
                 target_mod: target
                     .get("name")
                     .and_then(Json::as_str)
@@ -144,6 +154,7 @@ fn state_reference_checks(
                 field: accessor,
                 optional: crate::attr::optional(source_attr),
                 list_item,
+                union_tag: None,
                 target_mod: target
                     .get("name")
                     .and_then(Json::as_str)
@@ -724,6 +735,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 +855,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 +1026,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 +1053,7 @@ pub fn generate(
                     &value_objects_by_name,
                 ),
                 role: command.get("role").map(Json::to_s),
+                roles: roles_of(command),
             });
         }
 
@@ -1116,6 +1136,12 @@ pub fn generate(
             }
         }
 
+        puts_blank(&mut out);
+        puts_str(
+            &mut out,
+            &crate::presenters::emit_aggregate_presenter(aggregate, &value_objects_by_name),
+        );
+
         aggregate_files.push(GeneratedFile {
             name: format!("{}.rs", crate::naming::aggregate_module(agg_name)),
             content: out,
@@ -1129,7 +1155,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,
@@ -1204,6 +1230,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"),
@@ -1253,6 +1280,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(", ")