node: Add graphman chain rebuild-storage command

Adds the rebuild-storage subcommand to graphman chain. Looks up the
chain in public.chains, rejects shared-storage chains, prompts for
confirmation when storage already exists (--force skips the prompt),
then delegates to BlockStore::rebuild_chain_storage.

Author: dimitrovmaksim

node/src/bin/manager.rs

@@ -603,6 +603,20 @@ pub enum ChainCommand {
         /// The block number to ingest
         number: BlockNumber,
     },
+
+    /// Rebuild a chain's storage schema and reset head metadata.
+    ///
+    /// If the storage schema is missing, rebuilds it silently.
+    /// If the storage already exists, prompts for confirmation before
+    /// dropping and rebuilding it (use --force to skip the prompt).
+    RebuildStorage {
+        /// Chain name (must be an existing chain, see 'chain list')
+        #[clap(value_parser = clap::builder::NonEmptyStringValueParser::new())]
+        chain_name: String,
+        /// Skip confirmation prompt when storage already exists
+        #[clap(long, short)]
+        force: bool,
+    },
 }
 
 #[derive(Clone, Debug, Subcommand)]
@@ -1581,6 +1595,10 @@ async fn main() -> anyhow::Result<()> {
                         ctx.chain_store_and_adapter(&name).await?;
                     commands::chain::ingest(&logger, chain_store, ethereum_adapter, number).await
                 }
+                RebuildStorage { chain_name, force } => {
+                    let (block_store, primary) = ctx.block_store_and_primary_pool().await;
+                    commands::chain::rebuild_storage(primary, block_store, chain_name, force).await
+                }
             }
         }
         Stats(cmd) => {

node/src/manager/commands/chain.rs

@@ -10,6 +10,7 @@ use graph::cheap_clone::CheapClone;
 use graph::components::network_provider::ChainName;
 use graph::components::store::ChainIdStore;
 use graph::components::store::StoreError;
+use graph::prelude::anyhow::Context as _;
 use graph::prelude::BlockNumber;
 use graph::prelude::ChainStore as _;
 use graph::prelude::LightEthereumBlock;
@@ -30,8 +31,10 @@ use graph_store_postgres::ChainStore;
 use graph_store_postgres::PoolCoordinator;
 use graph_store_postgres::ScopedFutureExt;
 use graph_store_postgres::Shard;
+use graph_store_postgres::Storage;
 use graph_store_postgres::{command_support::catalog::block_store, ConnectionPool};
 
+use crate::manager::prompt::prompt_for_confirmation;
 use crate::network_setup::Networks;
 
 pub async fn list(primary: ConnectionPool, store: BlockStore) -> Result<(), Error> {
@@ -329,3 +332,55 @@ pub async fn ingest(
     }
     Ok(())
 }
+
+pub async fn rebuild_storage(
+    primary: ConnectionPool,
+    store: BlockStore,
+    name: String,
+    force: bool,
+) -> Result<(), Error> {
+    let mut conn = primary.get().await?;
+
+    let chain = block_store::find_chain(&mut conn, &name)
+        .await?
+        .ok_or_else(|| {
+            anyhow!(
+                "Chain {} not found in public.chains.\n\
+                 This command only supports chains already present in metadata.",
+                name
+            )
+        })?;
+
+    if matches!(chain.storage, Storage::Shared) {
+        bail!(
+            "Chain {} uses shared storage public and cannot be rebuilt with this command.",
+            name
+        );
+    }
+
+    let namespace = chain.storage.to_string();
+    let shard = &chain.shard;
+    let ident = chain.network_identifier()?;
+
+    if store.has_namespace(&chain).await? {
+        let prompt = format!(
+            "Storage {namespace} for chain {name} already exists on shard {shard}.\n\
+             This will drop and rebuild chain storage. All cached blocks and call cache \
+             data in that namespace will be permanently deleted.\n\
+             Proceed?"
+        );
+        if !force && !prompt_for_confirmation(&prompt)? {
+            println!("Aborting.");
+            return Ok(());
+        }
+    }
+
+    store
+        .rebuild_chain_storage(&name, &ident)
+        .await
+        .with_context(|| format!("Failed to rebuild storage {namespace} for chain {name}"))?;
+
+    println!("Successfully rebuilt storage {namespace} for chain {name} on shard {shard}.");
+
+    Ok(())
+}