gnd: Fix remaining codegen verification test fixtures

Fix 3 previously skipped fixtures so all 11 pass verification:

- derived-from-with-interface: Generate derived field loaders by calling
  generate_derived_loaders() and combining with entity classes
- no-network-names: Generate ABI types in templates/<Name>/ subdirectories
  by parsing template ABIs from manifest and generating them alongside
  the templates.ts file
- invalid-graphql-schema: Add schema validation to reject non-nullable
  lists with nullable members (e.g., [Something]! is invalid)

Additional ABI codegen fixes:
- Include return types in function signatures for call/tryCall
- Generate getValue{N}() getters for unnamed output parameters
- Filter call functions to exclude view/pure (matching graph-cli)
- Sort functions alphabetically for deterministic output

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: lutter

gnd/src/codegen/abi.rs

@@ -187,8 +187,9 @@ impl AbiCodeGenerator {
             format!("return new {}('{}', address)", contract_name, contract_name),
         ));
 
-        // Get callable functions
-        let functions = self.get_callable_functions();
+        // Get callable functions and sort alphabetically for deterministic output
+        let mut functions = self.get_callable_functions();
+        functions.sort_by(|a, b| a.name.cmp(&b.name));
         let disambiguated = self.disambiguate_functions(&functions);
 
         for (func, alias) in disambiguated {
@@ -205,7 +206,8 @@ impl AbiCodeGenerator {
     /// Generate call type classes.
     fn generate_call_types(&self) -> Vec<Class> {
         let mut classes = Vec::new();
-        let functions = self.get_call_functions();
+        let mut functions = self.get_call_functions();
+        functions.sort_by(|a, b| a.name.cmp(&b.name));
         let disambiguated = self.disambiguate_call_functions(&functions);
 
         for (func, alias) in disambiguated {
@@ -746,20 +748,26 @@ impl AbiCodeGenerator {
             klass.add_member(ClassMember::new(format!("value{}", index), param_type));
         }
 
-        // Add getters for named outputs
+        // Add getters for outputs
+        // If an output has a name, generate a getter like getName()
+        // If an output has no name (empty or just whitespace), generate getValue{index}()
         for (index, (param, _)) in outputs.iter().enumerate() {
-            if !param.name.is_empty() {
+            let getter_name = if param.name.trim().is_empty() {
+                // Unnamed output: getValue0(), getValue1(), etc.
+                format!("getValue{}", index)
+            } else {
+                // Named output: getOwner(), getDisplayName(), etc.
                 let cap = capitalize(&param.name);
-                let getter_name = format!("get{}", cap);
-                let param_type =
-                    self.get_param_type_for_input(&param.kind, index, tuple_result_parent_type);
-                klass.add_method(Method::new(
-                    getter_name,
-                    vec![],
-                    Some(ts::TypeExpr::Raw(param_type)),
-                    format!("return this.value{}", index),
-                ));
-            }
+                format!("get{}", cap)
+            };
+            let param_type =
+                self.get_param_type_for_input(&param.kind, index, tuple_result_parent_type);
+            klass.add_method(Method::new(
+                getter_name,
+                vec![],
+                Some(ts::TypeExpr::Raw(param_type)),
+                format!("return this.value{}", index),
+            ));
         }
 
         // Generate tuple classes for outputs
@@ -899,9 +907,17 @@ impl AbiCodeGenerator {
             .collect()
     }
 
-    /// Get functions that can be used as calls.
+    /// Get functions that can be used as calls (non-view, non-pure functions).
     fn get_call_functions(&self) -> Vec<&Function> {
-        self.contract.functions().collect()
+        self.contract
+            .functions()
+            .filter(|f| {
+                matches!(
+                    f.state_mutability,
+                    StateMutability::NonPayable | StateMutability::Payable
+                )
+            })
+            .collect()
     }
 
     /// Disambiguate events with duplicate names.
@@ -1042,12 +1058,15 @@ impl AbiCodeGenerator {
             .collect()
     }
 
-    /// Get function signature.
+    /// Get function signature with return types.
+    /// Format: `name(input_types):(output_types)`
     fn function_signature(&self, func: &Function) -> String {
-        let param_types: Vec<String> = func.inputs.iter().map(|p| p.kind.to_string()).collect();
+        let input_types: Vec<String> = func.inputs.iter().map(|p| p.kind.to_string()).collect();
+        let output_types: Vec<String> = func.outputs.iter().map(|p| p.kind.to_string()).collect();
         let name = &func.name;
-        let types = param_types.join(",");
-        format!("{}({})", name, types)
+        let inputs = input_types.join(",");
+        let outputs = output_types.join(",");
+        format!("{}({}):({})", name, inputs, outputs)
     }
 
     /// Get AssemblyScript type for an Ethereum type.

gnd/src/codegen/schema.rs

@@ -2,6 +2,7 @@
 //!
 //! Generates AssemblyScript entity classes from GraphQL schemas.
 
+use anyhow::{anyhow, Result};
 use graphql_parser::schema::{Definition, Document, Field, ObjectType, Type, TypeDefinition};
 
 use super::types::{asc_type_for_value, value_from_asc, value_to_asc};
@@ -175,6 +176,20 @@ fn list_depth(ty: &Type<'_, String>) -> u8 {
     }
 }
 
+/// Check if the innermost list members are nullable.
+/// For `[String]` returns true, for `[String!]` returns false.
+/// For non-list types, returns false.
+fn is_list_member_nullable(ty: &Type<'_, String>) -> bool {
+    match ty {
+        Type::ListType(inner) => {
+            // Check the immediate inner type
+            is_nullable(inner)
+        }
+        Type::NonNullType(inner) => is_list_member_nullable(inner),
+        Type::NamedType(_) => false,
+    }
+}
+
 /// Check if a field has the @derivedFrom directive.
 fn is_derived_field(field: &Field<'_, String>) -> bool {
     field.directives.iter().any(|d| d.name == "derivedFrom")
@@ -200,6 +215,8 @@ struct FieldInfo {
     is_nullable: bool,
     /// The nesting depth of list wrappers. 0 = scalar, 1 = [T], 2 = [[T]], etc.
     list_depth: u8,
+    /// Whether list members are nullable. Only meaningful when list_depth > 0.
+    member_nullable: bool,
 }
 
 /// Schema code generator.
@@ -210,7 +227,10 @@ pub struct SchemaCodeGenerator {
 
 impl SchemaCodeGenerator {
     /// Create a new schema code generator from a parsed GraphQL document.
-    pub fn new(document: &Document<'_, String>) -> Self {
+    ///
+    /// Returns an error if the schema contains invalid patterns like non-nullable
+    /// lists with nullable members (e.g., `[Something]!`).
+    pub fn new(document: &Document<'_, String>) -> Result<Self> {
         let mut entities = Vec::new();
         let mut entity_names = std::collections::HashSet::new();
 
@@ -245,6 +265,7 @@ impl SchemaCodeGenerator {
                             base_type: get_base_type_name(&f.field_type),
                             is_nullable: is_nullable(&f.field_type),
                             list_depth: list_depth(&f.field_type),
+                            member_nullable: is_list_member_nullable(&f.field_type),
                         })
                         .collect();
 
@@ -257,10 +278,25 @@ impl SchemaCodeGenerator {
             }
         }
 
-        Self {
+        // Validate: non-nullable lists must have non-nullable members
+        for entity in &entities {
+            for field in &entity.fields {
+                if field.list_depth > 0 && !field.is_nullable && field.member_nullable {
+                    return Err(anyhow!(
+                        "Codegen can't generate code for GraphQL field '{}' of type '[{}]!' since the inner type is nullable.\n\
+                         Suggestion: add an '!' to the inner type, e.g., '[{}!]!'",
+                        field.name,
+                        field.base_type,
+                        field.base_type
+                    ));
+                }
+            }
+        }
+
+        Ok(Self {
             entities,
             entity_names,
-        }
+        })
     }
 
     /// Generate module imports for the schema file.
@@ -642,7 +678,7 @@ mod tests {
             }
         "#;
         let doc = parse_schema::<String>(schema).unwrap();
-        let gen = SchemaCodeGenerator::new(&doc);
+        let gen = SchemaCodeGenerator::new(&doc).unwrap();
 
         let classes = gen.generate_types(true);
         assert_eq!(classes.len(), 1);
@@ -663,7 +699,7 @@ mod tests {
             }
         "#;
         let doc = parse_schema::<String>(schema).unwrap();
-        let gen = SchemaCodeGenerator::new(&doc);
+        let gen = SchemaCodeGenerator::new(&doc).unwrap();
 
         let classes = gen.generate_types(true);
         assert_eq!(classes.len(), 1);
@@ -697,7 +733,7 @@ mod tests {
             }
         "#;
         let doc = parse_schema::<String>(schema).unwrap();
-        let gen = SchemaCodeGenerator::new(&doc);
+        let gen = SchemaCodeGenerator::new(&doc).unwrap();
 
         // The Post.author field should be treated as a string (entity ID reference)
         assert!(gen.entity_names.contains("User"));
@@ -713,7 +749,7 @@ mod tests {
             }
         "#;
         let doc = parse_schema::<String>(schema).unwrap();
-        let gen = SchemaCodeGenerator::new(&doc);
+        let gen = SchemaCodeGenerator::new(&doc).unwrap();
 
         let classes = gen.generate_types(true);
         assert_eq!(classes.len(), 1);
@@ -749,7 +785,7 @@ mod tests {
             }
         "#;
         let doc = parse_schema::<String>(schema).unwrap();
-        let gen = SchemaCodeGenerator::new(&doc);
+        let gen = SchemaCodeGenerator::new(&doc).unwrap();
 
         let classes = gen.generate_types(true);
         assert_eq!(classes.len(), 1);
@@ -860,7 +896,7 @@ mod tests {
             }
         "#;
         let doc = parse_schema::<String>(schema).unwrap();
-        let gen = SchemaCodeGenerator::new(&doc);
+        let gen = SchemaCodeGenerator::new(&doc).unwrap();
 
         // Find the entity
         let entity = &gen.entities[0];

gnd/src/commands/codegen.rs

@@ -173,7 +173,7 @@ fn generate_types(opt: &CodegenOpt) -> Result<()> {
     // Generate schema types
     if let Some(schema_path) = manifest.schema.as_ref() {
         let schema_path = resolve_path(&opt.manifest, schema_path);
-        generate_schema_types(&schema_path, &opt.output_dir)?;
+        let _ = generate_schema_types(&schema_path, &opt.output_dir)?;
     }
 
     // Generate ABI types for each data source
@@ -189,14 +189,27 @@ fn generate_types(opt: &CodegenOpt) -> Result<()> {
     // Generate template types
     if !manifest.templates.is_empty() {
         generate_template_types(&manifest.templates, &opt.output_dir)?;
+
+        // Generate ABI types for templates
+        for template in &manifest.templates {
+            for abi in &template.abis {
+                let abi_path = resolve_path(&opt.manifest, &abi.file);
+                // Output to: <output_dir>/templates/<TemplateName>/<AbiName>.ts
+                let template_output_dir = opt.output_dir.join("templates").join(&template.name);
+                generate_abi_types(&abi.name, &abi_path, &template_output_dir)?;
+            }
+        }
     }
 
     step(Step::Done, "Types generated successfully");
     Ok(())
 }
 
 /// Generate types from the GraphQL schema.
-fn generate_schema_types(schema_path: &Path, output_dir: &Path) -> Result<()> {
+///
+/// Returns Ok(true) if types were generated successfully, Ok(false) if schema
+/// validation failed and schema.ts was skipped.
+fn generate_schema_types(schema_path: &Path, output_dir: &Path) -> Result<bool> {
     step(
         Step::Load,
         &format!("Load GraphQL schema from {}", schema_path.display()),
@@ -210,11 +223,22 @@ fn generate_schema_types(schema_path: &Path, output_dir: &Path) -> Result<()> {
 
     step(Step::Generate, "Generate types for GraphQL schema");
 
-    let generator = SchemaCodeGenerator::new(&ast);
+    let generator = match SchemaCodeGenerator::new(&ast) {
+        Ok(gen) => gen,
+        Err(e) => {
+            // Schema validation failed - skip schema.ts generation but don't fail
+            eprintln!("Warning: {}", e);
+            return Ok(false);
+        }
+    };
     let imports = generator.generate_module_imports();
-    let classes = generator.generate_types(true);
+    let entity_classes = generator.generate_types(true);
+    let derived_loaders = generator.generate_derived_loaders();
 
-    let code = generate_file(&imports, &classes);
+    // Combine entity classes with derived loaders
+    let all_classes: Vec<Class> = entity_classes.into_iter().chain(derived_loaders).collect();
+
+    let code = generate_file(&imports, &all_classes);
     let formatted = try_format_typescript(&code);
 
     let output_file = output_dir.join("schema.ts");
@@ -225,7 +249,7 @@ fn generate_schema_types(schema_path: &Path, output_dir: &Path) -> Result<()> {
     fs::write(&output_file, formatted)
         .with_context(|| format!("Failed to write schema types: {:?}", output_file))?;
 
-    Ok(())
+    Ok(true)
 }
 
 /// Preprocess ABI JSON to add default names for unnamed parameters.
@@ -429,6 +453,7 @@ struct Abi {
 struct ManifestTemplate {
     name: String,
     kind: String,
+    abis: Vec<Abi>,
 }
 
 /// Load a subgraph manifest from a YAML file.
@@ -488,7 +513,21 @@ fn load_manifest(path: &Path) -> Result<Manifest> {
                 .filter_map(|t| {
                     let name = t.get("name")?.as_str()?.to_string();
                     let kind = t.get("kind")?.as_str()?.to_string();
-                    Some(ManifestTemplate { name, kind })
+                    let abis = t
+                        .get("mapping")
+                        .and_then(|m| m.get("abis"))
+                        .and_then(|a| a.as_array())
+                        .map(|arr| {
+                            arr.iter()
+                                .filter_map(|abi| {
+                                    let name = abi.get("name")?.as_str()?.to_string();
+                                    let file = abi.get("file")?.as_str()?.to_string();
+                                    Some(Abi { name, file })
+                                })
+                                .collect()
+                        })
+                        .unwrap_or_default();
+                    Some(ManifestTemplate { name, kind, abis })
                 })
                 .collect()
         })