core, graph : Refactor LinkResolver trait

Author: incrypto32

chain/substreams/src/data_source.rs

@@ -331,7 +331,7 @@ mod test {
         blockchain::{DataSource as _, UnresolvedDataSource as _},
         components::link_resolver::LinkResolver,
         data::subgraph::LATEST_VERSION,
-        prelude::{async_trait, serde_yaml, DeploymentHash, JsonValueStream, Link},
+        prelude::{async_trait, serde_yaml, JsonValueStream, Link},
         slog::{o, Discard, Logger},
         substreams::{
             module::{
@@ -705,10 +705,7 @@ mod test {
             unimplemented!()
         }
 
-        fn for_deployment(
-            &self,
-            _deployment: DeploymentHash,
-        ) -> Result<Box<dyn LinkResolver>, Error> {
+        fn for_manifest(&self, _manifest_path: &str) -> Result<Box<dyn LinkResolver>, Error> {
             unimplemented!()
         }
 

core/src/subgraph/instance_manager.rs

@@ -289,7 +289,7 @@ impl<S: SubgraphStore> SubgraphInstanceManager<S> {
         // Allow for infinite retries for subgraph definition files.
         let link_resolver = Arc::from(
             self.link_resolver
-                .for_deployment(deployment.hash.clone())
+                .for_manifest(&deployment.hash.to_string())
                 .map_err(SubgraphRegistrarError::Unknown)?
                 .with_retries(),
         );

core/src/subgraph/provider.rs

@@ -88,7 +88,7 @@ impl<I: SubgraphInstanceManager> SubgraphAssignmentProviderTrait for SubgraphAss
 
         let link_resolver = self
             .link_resolver
-            .for_deployment(loc.hash.clone())
+            .for_manifest(&loc.hash.to_string())
             .map_err(SubgraphAssignmentProviderError::ResolveError)?;
 
         let file_bytes = link_resolver

core/src/subgraph/registrar.rs

@@ -289,7 +289,7 @@ where
 
         let resolver: Arc<dyn LinkResolver> = Arc::from(
             self.resolver
-                .for_deployment(hash.clone())
+                .for_manifest(&hash.to_string())
                 .map_err(SubgraphRegistrarError::Unknown)?,
         );
 

graph/src/components/link_resolver/file.rs

@@ -7,7 +7,7 @@ use async_trait::async_trait;
 use slog::Logger;
 
 use crate::data::subgraph::Link;
-use crate::prelude::{DeploymentHash, Error, JsonValueStream, LinkResolver as LinkResolverTrait};
+use crate::prelude::{Error, JsonValueStream, LinkResolver as LinkResolverTrait};
 
 #[derive(Clone, Debug)]
 pub struct FileLinkResolver {
@@ -72,20 +72,19 @@ impl FileLinkResolver {
     /// It will set the base directory to the parent directory of the manifest path
     /// This is required because paths mentioned in the subgraph manifest are relative paths
     /// and we need a new resolver with the right base directory for the specific subgraph
-    fn clone_for_deployment(&self, deployment: DeploymentHash) -> Result<Self, Error> {
+    fn clone_for_manifest(&self, manifest_path_str: &str) -> Result<Self, Error> {
         let mut resolver = self.clone();
 
-        let deployment_str = deployment.to_string();
-
         // Create a path to the manifest based on the current resolver's
         // base directory or default to using the deployment string as path
         // If the deployment string is an alias, use the aliased path
-        let manifest_path = if let Some(aliased) = self.aliases.get(&deployment_str) {
+        let manifest_path = if let Some(aliased) = self.aliases.get(&manifest_path_str.to_string())
+        {
             aliased.clone()
         } else {
             match &resolver.base_dir {
-                Some(dir) => dir.join(&deployment_str),
-                None => PathBuf::from(deployment_str),
+                Some(dir) => dir.join(&manifest_path_str),
+                None => PathBuf::from(manifest_path_str),
             }
         };
 
@@ -143,11 +142,8 @@ impl LinkResolverTrait for FileLinkResolver {
         }
     }
 
-    fn for_deployment(
-        &self,
-        deployment: DeploymentHash,
-    ) -> Result<Box<dyn LinkResolverTrait>, Error> {
-        Ok(Box::new(self.clone_for_deployment(deployment)?))
+    fn for_manifest(&self, manifest_path: &str) -> Result<Box<dyn LinkResolverTrait>, Error> {
+        Ok(Box::new(self.clone_for_manifest(manifest_path)?))
     }
 
     async fn get_block(&self, _logger: &Logger, _link: &Link) -> Result<Vec<u8>, Error> {
@@ -325,8 +321,7 @@ mod tests {
         assert_eq!(result2, test_content2);
 
         // Test that the alias works in for_deployment as well
-        let deployment = DeploymentHash::new("deployment-id").unwrap();
-        let deployment_resolver = resolver.clone_for_deployment(deployment).unwrap();
+        let deployment_resolver = resolver.clone_for_manifest("deployment-id").unwrap();
 
         let expected_dir = test_file1_path.parent().unwrap();
         let deployment_base_dir = deployment_resolver.base_dir.clone().unwrap();

graph/src/components/link_resolver/ipfs.rs

@@ -74,10 +74,7 @@ impl LinkResolverTrait for IpfsResolver {
         Box::new(s)
     }
 
-    fn for_deployment(
-        &self,
-        _deployment: DeploymentHash,
-    ) -> Result<Box<dyn LinkResolverTrait>, Error> {
+    fn for_manifest(&self, _manifest_path: &str) -> Result<Box<dyn LinkResolverTrait>, Error> {
         Ok(Box::new(self.cheap_clone()))
     }
 

graph/src/components/link_resolver/mod.rs

@@ -3,7 +3,7 @@ use std::time::Duration;
 use slog::Logger;
 
 use crate::data::subgraph::Link;
-use crate::prelude::{DeploymentHash, Error};
+use crate::prelude::Error;
 use std::fmt::Debug;
 
 mod arweave;
@@ -30,12 +30,19 @@ pub trait LinkResolver: Send + Sync + 'static + Debug {
     /// Fetches the IPLD block contents as bytes.
     async fn get_block(&self, logger: &Logger, link: &Link) -> Result<Vec<u8>, Error>;
 
-    /// Creates a new resolver that is scoped to a specific subgraph
-    /// This is used by FileLinkResolver to create a new resolver for a specific subgraph
-    /// For other resolvers, this method will simply return the current resolver
-    /// This is required because paths mentioned in the subgraph manifest are relative paths
-    /// and we need a new resolver with the right base directory for the specific subgraph
-    fn for_deployment(&self, deployment: DeploymentHash) -> Result<Box<dyn LinkResolver>, Error>;
+    /// Creates a new resolver scoped to a specific subgraph manifest.
+    ///
+    /// For FileLinkResolver, this sets the base directory to the manifest's parent directory.
+    /// Note the manifest here is the manifest in the build directory, not the manifest in the source directory
+    /// to properly resolve relative paths referenced in the manifest (schema, mappings, etc.).
+    /// For other resolvers (IPFS/Arweave), this simply returns a clone since they use
+    /// absolute content identifiers.
+    ///
+    /// The `manifest_path` parameter can be a filesystem path or an alias. Aliases are used
+    /// in development environments (via `gnd --sources`) to map user-defined
+    /// aliases to actual subgraph paths, enabling local development with file-based
+    /// subgraphs that reference each other.
+    fn for_manifest(&self, manifest_path: &str) -> Result<Box<dyn LinkResolver>, Error>;
 
     /// Read the contents of `link` and deserialize them into a stream of JSON
     /// values. The values must each be on a single line; newlines are significant

graph/src/data_source/subgraph.rs

@@ -260,7 +260,7 @@ impl UnresolvedDataSource {
         logger: &Logger,
     ) -> Result<Arc<SubgraphManifest<C>>, Error> {
         let resolver: Arc<dyn LinkResolver> =
-            Arc::from(resolver.for_deployment(self.source.address.clone())?);
+            Arc::from(resolver.for_manifest(&self.source.address.to_string())?);
         let source_raw = resolver
             .cat(logger, &self.source.address.to_ipfs_link())
             .await
@@ -284,7 +284,7 @@ impl UnresolvedDataSource {
         ))?;
 
         let resolver: Arc<dyn LinkResolver> =
-            Arc::from(resolver.for_deployment(self.source.address.clone())?);
+            Arc::from(resolver.for_manifest(&self.source.address.to_string())?);
         source_manifest
             .resolve(&resolver, logger, LATEST_VERSION.clone())
             .await

store/test-store/tests/chain/ethereum/manifest.rs

@@ -91,9 +91,9 @@ impl LinkResolverTrait for TextResolver {
         Box::new(self.clone())
     }
 
-    fn for_deployment(
+    fn for_manifest(
         &self,
-        _deployment: DeploymentHash,
+        _manifest_path: &str,
     ) -> Result<Box<dyn LinkResolverTrait>, anyhow::Error> {
         Ok(Box::new(self.clone()))
     }