fixup! gnd: Extract shared manifest and watch modules to reduce duplication

Author: lutter

gnd/src/commands/codegen.rs

@@ -20,7 +20,7 @@ use crate::codegen::{
     TemplateCodeGenerator, TemplateKind, GENERATED_FILE_NOTE,
 };
 use crate::formatter::try_format_typescript;
-use crate::manifest::{load_manifest, resolve_path, Manifest, SubgraphSource, Template};
+use crate::manifest::{load_manifest, resolve_path, DataSource, Manifest, Template};
 use crate::migrations;
 use crate::output::{step, Step};
 use crate::services::IpfsClient;
@@ -142,9 +142,13 @@ async fn generate_types(opt: &CodegenOpt) -> Result<()> {
     }
 
     // Generate types for subgraph data sources
-    if !manifest.subgraph_sources.is_empty() {
-        generate_subgraph_source_types(&manifest.subgraph_sources, &opt.output_dir, &opt.ipfs)
-            .await?;
+    let subgraph_sources: Vec<&DataSource> = manifest
+        .data_sources
+        .iter()
+        .filter(|ds| ds.is_subgraph_source())
+        .collect();
+    if !subgraph_sources.is_empty() {
+        generate_subgraph_source_types(&subgraph_sources, &opt.output_dir, &opt.ipfs).await?;
     }
 
     step(Step::Done, "Types generated successfully");
@@ -401,7 +405,7 @@ fn generate_template_types(templates: &[Template], output_dir: &Path) -> Result<
 /// For each subgraph data source, this fetches the referenced subgraph's schema
 /// from IPFS and generates entity types (without store methods).
 async fn generate_subgraph_source_types(
-    subgraph_sources: &[SubgraphSource],
+    subgraph_sources: &[&DataSource],
     output_dir: &Path,
     ipfs_url: &str,
 ) -> Result<()> {
@@ -421,27 +425,24 @@ async fn generate_subgraph_source_types(
     }
 
     for source in subgraph_sources {
+        // source_address is guaranteed to be Some because of is_subgraph_source() filter
+        let address = source.source_address.as_ref().unwrap();
+
         step(
             Step::Load,
-            &format!(
-                "Fetch schema for subgraph {} ({})",
-                source.name, source.address
-            ),
+            &format!("Fetch schema for subgraph {} ({})", source.name, address),
         );
 
         // Fetch schema from IPFS using block_in_place to allow blocking in async context
-        let schema_str = ipfs_client.fetch_subgraph_schema(&source.address).await?;
+        let schema_str = ipfs_client.fetch_subgraph_schema(address).await?;
 
         // Parse the schema
         let ast: gql::Document<'_, String> = gql::parse_schema(&schema_str)
             .map_err(|e| anyhow::anyhow!("Failed to parse subgraph schema: {}", e))?;
 
         step(
             Step::Generate,
-            &format!(
-                "Generate types for subgraph {} ({})",
-                source.name, source.address
-            ),
+            &format!("Generate types for subgraph {} ({})", source.name, address),
         );
 
         // Generate entity types WITHOUT store methods (false = no store methods)
@@ -450,7 +451,7 @@ async fn generate_subgraph_source_types(
             Err(e) => {
                 eprintln!(
                     "Warning: Failed to create schema generator for subgraph {} ({}): {}",
-                    source.name, source.address, e
+                    source.name, address, e
                 );
                 continue;
             }

gnd/src/manifest.rs

@@ -18,28 +18,19 @@ use crate::output::{step, Step};
 ///
 /// # Data Source Organization
 ///
-/// Data sources from the manifest are stored in two separate fields based
-/// on their kind:
-/// - `data_sources`: Contract-style sources (ethereum/contract, etc.) that
-///   have mappings and ABIs
-/// - `subgraph_sources`: Subgraph references (kind: subgraph) that only
-///   have a name and IPFS address
-///
-/// This separation reflects their different processing needs: contract
-/// sources need compilation and ABI generation, while subgraph sources only
-/// need schema fetching for type generation.
+/// All data sources from the manifest are stored in the `data_sources` field,
+/// regardless of their kind. Subgraph data sources (kind: subgraph) are
+/// identified by `DataSource::is_subgraph_source()` and have the `source_address`
+/// field set to the IPFS deployment ID of the referenced subgraph.
 #[derive(Debug)]
 pub struct Manifest {
     pub spec_version: Version,
     pub schema: Option<String>,
     pub features: Vec<String>,
     pub graft: Option<GraftConfig>,
-    /// Contract-style data sources with mappings and ABIs to compile.
+    /// All data sources, including both contract-style sources and subgraph sources.
     pub data_sources: Vec<DataSource>,
     pub templates: Vec<Template>,
-    /// Subgraph data sources (kind: subgraph) with IPFS addresses.
-    /// Used by codegen to generate types for referenced subgraphs.
-    pub subgraph_sources: Vec<SubgraphSource>,
 }
 
 /// Graft configuration.
@@ -58,6 +49,15 @@ pub struct DataSource {
     pub mapping_file: Option<String>,
     pub api_version: Option<Version>,
     pub abis: Vec<Abi>,
+    /// For subgraph data sources: the IPFS deployment ID of the referenced subgraph.
+    pub source_address: Option<String>,
+}
+
+impl DataSource {
+    /// Returns true if this is a valid subgraph data source (kind: subgraph with address).
+    pub fn is_subgraph_source(&self) -> bool {
+        self.kind == "subgraph" && self.source_address.is_some()
+    }
 }
 
 /// A data source template in the manifest.
@@ -71,20 +71,10 @@ pub struct Template {
     pub abis: Vec<Abi>,
 }
 
-/// A subgraph data source (kind: subgraph).
-/// These reference another subgraph by its IPFS deployment ID.
-#[derive(Debug)]
-pub struct SubgraphSource {
-    /// The data source name from the manifest
-    pub name: String,
-    /// The IPFS hash (deployment ID) of the referenced subgraph
-    pub address: String,
-}
-
 impl Manifest {
-    /// Returns the total count of all data sources (contract + subgraph).
+    /// Returns the total count of all data sources.
     pub fn total_source_count(&self) -> usize {
-        self.data_sources.len() + self.subgraph_sources.len()
+        self.data_sources.len()
     }
 }
 
@@ -143,9 +133,8 @@ pub fn load_manifest(path: &Path) -> Result<Manifest> {
         Some(GraftConfig { base, block })
     });
 
-    // Extract data sources and subgraph sources
+    // Extract data sources (including subgraph sources)
     let mut data_sources = Vec::new();
-    let mut subgraph_sources = Vec::new();
 
     if let Some(ds_array) = value.get("dataSources").and_then(|ds| ds.as_array()) {
         for ds in ds_array {
@@ -154,29 +143,8 @@ pub fn load_manifest(path: &Path) -> Result<Manifest> {
                 .and_then(|k| k.as_str())
                 .unwrap_or("ethereum/contract");
 
-            if kind == "subgraph" {
-                // Subgraph data source - extract for codegen only
-                let name = ds
-                    .get("name")
-                    .and_then(|n| n.as_str())
-                    .unwrap_or("unnamed")
-                    .to_string();
-
-                if let Some(address) = ds
-                    .get("source")
-                    .and_then(|s| s.get("address"))
-                    .and_then(|a| a.as_str())
-                {
-                    subgraph_sources.push(SubgraphSource {
-                        name,
-                        address: address.to_string(),
-                    });
-                }
-            } else {
-                // Regular data source (ethereum/contract, etc.)
-                if let Some(parsed) = parse_data_source(ds, kind) {
-                    data_sources.push(parsed);
-                }
+            if let Some(parsed) = parse_data_source(ds, kind) {
+                data_sources.push(parsed);
             }
         }
     }
@@ -195,7 +163,6 @@ pub fn load_manifest(path: &Path) -> Result<Manifest> {
         graft,
         data_sources,
         templates,
-        subgraph_sources,
     })
 }
 
@@ -214,6 +181,11 @@ fn parse_data_source(ds: &serde_json::Value, kind: &str) -> Option<DataSource> {
         .and_then(|v| v.as_str())
         .and_then(|v| Version::parse(v).ok());
     let abis = parse_abis(ds.get("mapping").and_then(|m| m.get("abis")));
+    let source_address = ds
+        .get("source")
+        .and_then(|s| s.get("address"))
+        .and_then(|a| a.as_str())
+        .map(String::from);
 
     Some(DataSource {
         name,
@@ -222,6 +194,7 @@ fn parse_data_source(ds: &serde_json::Value, kind: &str) -> Option<DataSource> {
         mapping_file,
         api_version,
         abis,
+        source_address,
     })
 }
 
@@ -462,13 +435,21 @@ dataSources:
         fs::write(&manifest_path, manifest_content).unwrap();
 
         let manifest = load_manifest(&manifest_path).unwrap();
-        // Contract sources go to data_sources, subgraph sources go to subgraph_sources
-        assert_eq!(manifest.data_sources.len(), 1);
-        assert_eq!(manifest.data_sources[0].name, "Token");
-        assert_eq!(manifest.data_sources[0].kind, "ethereum/contract");
-        assert_eq!(manifest.subgraph_sources.len(), 1);
-        assert_eq!(manifest.subgraph_sources[0].name, "SourceSubgraph");
-        assert_eq!(manifest.subgraph_sources[0].address, "QmSourceHash123");
+        // All data sources go to data_sources
+        assert_eq!(manifest.data_sources.len(), 2);
+        // First is the subgraph source
+        assert_eq!(manifest.data_sources[0].name, "SourceSubgraph");
+        assert_eq!(manifest.data_sources[0].kind, "subgraph");
+        assert!(manifest.data_sources[0].is_subgraph_source());
+        assert_eq!(
+            manifest.data_sources[0].source_address,
+            Some("QmSourceHash123".to_string())
+        );
+        // Second is the contract source
+        assert_eq!(manifest.data_sources[1].name, "Token");
+        assert_eq!(manifest.data_sources[1].kind, "ethereum/contract");
+        assert!(!manifest.data_sources[1].is_subgraph_source());
+        assert_eq!(manifest.data_sources[1].source_address, None);
         // total_source_count includes both
         assert_eq!(manifest.total_source_count(), 2);
     }

gnd/src/validation/mod.rs

@@ -301,7 +301,6 @@ pub(crate) fn format_manifest_errors(errors: &[ManifestValidationError]) -> Stri
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::manifest::SubgraphSource;
     use std::fs;
     use tempfile::TempDir;
 
@@ -411,7 +410,6 @@ type Post @entity {
             graft: None,
             data_sources,
             templates,
-            subgraph_sources: vec![],
         }
     }
 
@@ -427,6 +425,19 @@ type Post @entity {
             mapping_file: Some(format!("src/{}.ts", name)),
             api_version,
             abis: vec![],
+            source_address: None,
+        }
+    }
+
+    fn create_subgraph_data_source(name: &str, address: &str) -> DataSource {
+        DataSource {
+            name: name.to_string(),
+            kind: "subgraph".to_string(),
+            network: None,
+            mapping_file: None,
+            api_version: None,
+            abis: vec![],
+            source_address: Some(address.to_string()),
         }
     }
 
@@ -455,20 +466,17 @@ type Post @entity {
         .unwrap();
 
         // Manifest with only subgraph sources (no regular data sources)
-        // TODO: We now store subgraph sources twice
-        let subgraph_sources = vec![SubgraphSource {
-            name: "SourceSubgraph".to_string(),
-            address: "QmSourceHash123".to_string(),
-        }];
-        let data_sources = vec![create_data_source("SourceSubgraph", Some("mainnet"), None)];
+        let data_sources = vec![create_subgraph_data_source(
+            "SourceSubgraph",
+            "QmSourceHash123",
+        )];
         let manifest = Manifest {
             spec_version: Version::new(1, 0, 0),
             schema: Some("schema.graphql".to_string()),
             features: vec![],
             graft: None,
             data_sources,
             templates: vec![],
-            subgraph_sources,
         };
 
         let errors = validate_manifest(&manifest, temp_dir.path());