Revert "graph: Remove unneeded methods from StatusStore trait"

This reverts commit a383f5e.

Author: incrypto32

graph/src/components/store/traits.rs

@@ -9,6 +9,7 @@ use super::*;
 use crate::blockchain::block_stream::{EntitySourceOperation, FirehoseCursor};
 use crate::blockchain::{BlockTime, ChainIdentifier, ExtendedBlockPtr};
 use crate::components::metrics::stopwatch::StopwatchMetrics;
+use crate::components::server::index_node::VersionInfo;
 use crate::components::subgraph::SubgraphVersionSwitchingMode;
 use crate::components::transaction_receipt;
 use crate::components::versions::ApiVersion;
@@ -686,6 +687,25 @@ pub trait StatusStore: Send + Sync + 'static {
 
     fn status(&self, filter: status::Filter) -> Result<Vec<status::Info>, StoreError>;
 
+    /// Support for the explorer-specific API
+    fn version_info(&self, version_id: &str) -> Result<VersionInfo, StoreError>;
+
+    /// Support for the explorer-specific API; note that `subgraph_id` must be
+    /// the id of an entry in `subgraphs.subgraph`, not that of a deployment.
+    /// The return values are the ids of the `subgraphs.subgraph_version` for
+    /// the current and pending versions of the subgraph
+    fn versions_for_subgraph_id(
+        &self,
+        subgraph_id: &str,
+    ) -> Result<(Option<String>, Option<String>), StoreError>;
+
+    /// Support for the explorer-specific API. Returns a vector of (name, version) of all
+    /// subgraphs for a given deployment hash.
+    fn subgraphs_for_deployment_hash(
+        &self,
+        deployment_hash: &str,
+    ) -> Result<Vec<(String, String)>, StoreError>;
+
     /// A value of None indicates that the table is not available. Re-deploying
     /// the subgraph fixes this. It is undesirable to force everything to
     /// re-sync from scratch, so existing deployments will continue without a

store/postgres/src/primary.rs

@@ -444,8 +444,8 @@ mod queries {
     use diesel::dsl::{exists, sql};
     use diesel::pg::PgConnection;
     use diesel::prelude::{
-        ExpressionMethods, JoinOnDsl, NullableExpressionMethods, OptionalExtension, QueryDsl,
-        RunQueryDsl,
+        BoolExpressionMethods, ExpressionMethods, JoinOnDsl, NullableExpressionMethods,
+        OptionalExtension, QueryDsl, RunQueryDsl,
     };
     use diesel::sql_types::Text;
     use graph::prelude::NodeId;
@@ -724,6 +724,44 @@ mod queries {
             .first::<(String, String)>(conn)
             .optional()?)
     }
+
+    pub(super) fn versions_for_subgraph_id(
+        conn: &mut PgConnection,
+        subgraph_id: &str,
+    ) -> Result<(Option<String>, Option<String>), StoreError> {
+        Ok(s::table
+            .select((s::current_version.nullable(), s::pending_version.nullable()))
+            .filter(s::id.eq(subgraph_id))
+            .first::<(Option<String>, Option<String>)>(conn)
+            .optional()?
+            .unwrap_or((None, None)))
+    }
+
+    /// Returns all (subgraph_name, version) pairs for a given deployment hash.
+    pub fn subgraphs_by_deployment_hash(
+        conn: &mut PgConnection,
+        deployment_hash: &str,
+    ) -> Result<Vec<(String, String)>, StoreError> {
+        v::table
+                .inner_join(
+                    s::table.on(v::id
+                        .nullable()
+                        .eq(s::current_version)
+                        .or(v::id.nullable().eq(s::pending_version))),
+                )
+                .filter(v::deployment.eq(&deployment_hash))
+                .select((
+                    s::name,
+                    sql::<Text>(
+                        "(case when subgraphs.subgraph.pending_version = subgraphs.subgraph_version.id then 'pending'
+                               when subgraphs.subgraph.current_version = subgraphs.subgraph_version.id then 'current'
+                               else 'unused'
+                         end) as version",
+                    ),
+                ))
+                .get_results(conn)
+                .map_err(Into::into)
+    }
 }
 
 /// A wrapper for a database connection that provides access to functionality
@@ -2079,6 +2117,21 @@ impl Mirror {
         self.read(|conn| queries::version_info(conn, version))
     }
 
+    pub fn versions_for_subgraph_id(
+        &self,
+        subgraph_id: &str,
+    ) -> Result<(Option<String>, Option<String>), StoreError> {
+        self.read(|conn| queries::versions_for_subgraph_id(conn, subgraph_id))
+    }
+
+    /// Returns all (subgraph_name, version) pairs for a given deployment hash.
+    pub fn subgraphs_by_deployment_hash(
+        &self,
+        deployment_hash: &str,
+    ) -> Result<Vec<(String, String)>, StoreError> {
+        self.read(|conn| queries::subgraphs_by_deployment_hash(conn, deployment_hash))
+    }
+
     pub fn find_site_in_shard(
         &self,
         subgraph: &DeploymentHash,

store/postgres/src/store.rs

@@ -50,14 +50,6 @@ impl Store {
     pub fn block_store(&self) -> Arc<BlockStore> {
         self.block_store.cheap_clone()
     }
-
-    pub fn version_info(&self, version_id: &str) -> Result<VersionInfo, StoreError> {
-        let mut info = self.subgraph_store.version_info(version_id)?;
-
-        info.total_ethereum_blocks_count = self.block_store.chain_head_block(&info.network)?;
-
-        Ok(info)
-    }
 }
 
 impl StoreTrait for Store {
@@ -125,6 +117,29 @@ impl StatusStore for Store {
         Ok(infos)
     }
 
+    fn version_info(&self, version_id: &str) -> Result<VersionInfo, StoreError> {
+        let mut info = self.subgraph_store.version_info(version_id)?;
+
+        info.total_ethereum_blocks_count = self.block_store.chain_head_block(&info.network)?;
+
+        Ok(info)
+    }
+
+    fn versions_for_subgraph_id(
+        &self,
+        subgraph_id: &str,
+    ) -> Result<(Option<String>, Option<String>), StoreError> {
+        self.subgraph_store.versions_for_subgraph_id(subgraph_id)
+    }
+
+    fn subgraphs_for_deployment_hash(
+        &self,
+        deployment_hash: &str,
+    ) -> Result<Vec<(String, String)>, StoreError> {
+        self.subgraph_store
+            .subgraphs_for_deployment_hash(deployment_hash)
+    }
+
     async fn get_proof_of_indexing(
         &self,
         subgraph_id: &DeploymentHash,

store/postgres/src/subgraph_store.rs

@@ -1018,6 +1018,20 @@ impl SubgraphStoreInner {
         }
     }
 
+    pub(crate) fn versions_for_subgraph_id(
+        &self,
+        subgraph_id: &str,
+    ) -> Result<(Option<String>, Option<String>), StoreError> {
+        self.mirror.versions_for_subgraph_id(subgraph_id)
+    }
+
+    pub(crate) fn subgraphs_for_deployment_hash(
+        &self,
+        deployment_hash: &str,
+    ) -> Result<Vec<(String, String)>, StoreError> {
+        self.mirror.subgraphs_by_deployment_hash(deployment_hash)
+    }
+
     #[cfg(debug_assertions)]
     pub fn error_count(&self, id: &DeploymentHash) -> Result<usize, StoreError> {
         let (store, _) = self.store(id)?;