Revert "Initial MCP implementation (#81770)"

This reverts commit b7a97a0.

# Conflicts:
#	packages/next/errors.json

Author: ijjk

crates/napi/src/next_api/endpoint.rs

@@ -4,25 +4,21 @@ use anyhow::Result;
 use futures_util::TryFutureExt;
 use napi::{JsFunction, bindgen_prelude::External};
 use next_api::{
-    module_graph_snapshot::{ModuleGraphSnapshot, get_module_graph_snapshot},
     operation::OptionEndpoint,
     paths::ServerPath,
     route::{
-        Endpoint, EndpointOutputPaths, endpoint_client_changed_operation,
-        endpoint_server_changed_operation, endpoint_write_to_disk_operation,
+        EndpointOutputPaths, endpoint_client_changed_operation, endpoint_server_changed_operation,
+        endpoint_write_to_disk_operation,
     },
 };
 use tracing::Instrument;
-use turbo_tasks::{
-    Completion, Effects, OperationVc, ReadRef, TryFlatJoinIterExt, TryJoinIterExt, Vc,
-};
-use turbopack_core::{diagnostics::PlainDiagnostic, error::PrettyPrintError, issue::PlainIssue};
+use turbo_tasks::{Completion, Effects, OperationVc, ReadRef, Vc};
+use turbopack_core::{diagnostics::PlainDiagnostic, issue::PlainIssue};
 
 use super::utils::{
     DetachedVc, NapiDiagnostic, NapiIssue, RootTask, TurbopackResult,
     strongly_consistent_catch_collectables, subscribe,
 };
-use crate::next_api::module_graph::NapiModuleGraphSnapshot;
 
 #[napi(object)]
 #[derive(Default)]
@@ -85,11 +81,6 @@ impl From<Option<EndpointOutputPaths>> for NapiWrittenEndpoint {
     }
 }
 
-#[napi(object)]
-pub struct NapiModuleGraphSnapshots {
-    pub module_graphs: Vec<NapiModuleGraphSnapshot>,
-}
-
 // NOTE(alexkirsz) We go through an extra layer of indirection here because of
 // two factors:
 // 1. rustc currently has a bug where using a dyn trait as a type argument to
@@ -164,105 +155,6 @@ pub async fn endpoint_write_to_disk(
     })
 }
 
-#[turbo_tasks::value(serialization = "none")]
-struct ModuleGraphsWithIssues {
-    module_graphs: Option<ReadRef<ModuleGraphSnapshots>>,
-    issues: Arc<Vec<ReadRef<PlainIssue>>>,
-    diagnostics: Arc<Vec<ReadRef<PlainDiagnostic>>>,
-    effects: Arc<Effects>,
-}
-
-#[turbo_tasks::function(operation)]
-async fn get_module_graphs_with_issues_operation(
-    endpoint_op: OperationVc<OptionEndpoint>,
-) -> Result<Vc<ModuleGraphsWithIssues>> {
-    let module_graphs_op = get_module_graphs_operation(endpoint_op);
-    let (module_graphs, issues, diagnostics, effects) =
-        strongly_consistent_catch_collectables(module_graphs_op).await?;
-    Ok(ModuleGraphsWithIssues {
-        module_graphs,
-        issues,
-        diagnostics,
-        effects,
-    }
-    .cell())
-}
-
-#[turbo_tasks::value(transparent)]
-struct ModuleGraphSnapshots(Vec<ReadRef<ModuleGraphSnapshot>>);
-
-#[turbo_tasks::function(operation)]
-async fn get_module_graphs_operation(
-    endpoint_op: OperationVc<OptionEndpoint>,
-) -> Result<Vc<ModuleGraphSnapshots>> {
-    let Some(endpoint) = *endpoint_op.connect().await? else {
-        return Ok(Vc::cell(vec![]));
-    };
-    let graphs = endpoint.module_graphs().await?;
-    let entries = endpoint.entries().await?;
-    let entry_modules = entries.iter().flat_map(|e| e.entries()).collect::<Vec<_>>();
-    let snapshots = graphs
-        .iter()
-        .map(async |&graph| {
-            let module_graph = graph.await?;
-            let entry_modules = entry_modules
-                .iter()
-                .map(async |&m| Ok(module_graph.has_entry(m).await?.then_some(m)))
-                .try_flat_join()
-                .await?;
-            Ok((*graph, entry_modules))
-        })
-        .try_join()
-        .await?
-        .into_iter()
-        .map(|(graph, entry_modules)| (graph, Vc::cell(entry_modules)))
-        .collect::<Vec<_>>()
-        .into_iter()
-        .map(async |(graph, entry_modules)| {
-            get_module_graph_snapshot(graph, Some(entry_modules)).await
-        })
-        .try_join()
-        .await?;
-    Ok(Vc::cell(snapshots))
-}
-
-#[napi]
-pub async fn endpoint_module_graphs(
-    #[napi(ts_arg_type = "{ __napiType: \"Endpoint\" }")] endpoint: External<ExternalEndpoint>,
-) -> napi::Result<TurbopackResult<NapiModuleGraphSnapshots>> {
-    let endpoint_op: OperationVc<OptionEndpoint> = ***endpoint;
-    let (module_graphs, issues, diagnostics) = endpoint
-        .turbopack_ctx()
-        .turbo_tasks()
-        .run_once(async move {
-            let module_graphs_op = get_module_graphs_with_issues_operation(endpoint_op);
-            let ModuleGraphsWithIssues {
-                module_graphs,
-                issues,
-                diagnostics,
-                effects: _,
-            } = &*module_graphs_op.connect().await?;
-            Ok((module_graphs.clone(), issues.clone(), diagnostics.clone()))
-        })
-        .await
-        .map_err(|e| napi::Error::from_reason(PrettyPrintError(&e).to_string()))?;
-
-    Ok(TurbopackResult {
-        result: NapiModuleGraphSnapshots {
-            module_graphs: module_graphs
-                .into_iter()
-                .flat_map(|m| m.into_iter())
-                .map(|m| NapiModuleGraphSnapshot::from(&**m))
-                .collect(),
-        },
-        issues: issues.iter().map(|i| NapiIssue::from(&**i)).collect(),
-        diagnostics: diagnostics
-            .iter()
-            .map(|d| NapiDiagnostic::from(d))
-            .collect(),
-    })
-}
-
 #[napi(ts_return_type = "{ __napiType: \"RootTask\" }")]
 pub fn endpoint_server_changed_subscribe(
     #[napi(ts_arg_type = "{ __napiType: \"Endpoint\" }")] endpoint: External<ExternalEndpoint>,

crates/napi/src/next_api/mod.rs

@@ -1,5 +1,4 @@
 pub mod endpoint;
-pub mod module_graph;
 pub mod project;
 pub mod turbopack_ctx;
 pub mod utils;

crates/napi/src/next_api/module_graph.rs

@@ -9,7 +9,6 @@ use napi::{
 };
 use next_api::{
     entrypoints::Entrypoints,
-    module_graph_snapshot::{ModuleGraphSnapshot, get_module_graph_snapshot},
     operation::{
         EntrypointsOperation, InstrumentationOperation, MiddlewareOperation, OptionEndpoint,
         RouteOperation,
@@ -64,14 +63,13 @@ use url::Url;
 use crate::{
     next_api::{
         endpoint::ExternalEndpoint,
-        module_graph::NapiModuleGraphSnapshot,
         turbopack_ctx::{
             NapiNextTurbopackCallbacks, NapiNextTurbopackCallbacksJsObject, NextTurboTasks,
             NextTurbopackContext, create_turbo_tasks,
         },
         utils::{
             DetachedVc, NapiDiagnostic, NapiIssue, RootTask, TurbopackResult, get_diagnostics,
-            get_issues, strongly_consistent_catch_collectables, subscribe,
+            get_issues, subscribe,
         },
     },
     register,
@@ -989,40 +987,6 @@ async fn output_assets_operation(
     Ok(Vc::cell(output_assets.into_iter().collect()))
 }
 
-#[napi]
-pub async fn project_entrypoints(
-    #[napi(ts_arg_type = "{ __napiType: \"Project\" }")] project: External<ProjectInstance>,
-) -> napi::Result<TurbopackResult<NapiEntrypoints>> {
-    let container = project.container;
-
-    let (entrypoints, issues, diags) = project
-        .turbopack_ctx
-        .turbo_tasks()
-        .run_once(async move {
-            let entrypoints_with_issues_op = get_entrypoints_with_issues_operation(container);
-
-            // Read and compile the files
-            let EntrypointsWithIssues {
-                entrypoints,
-                issues,
-                diagnostics,
-                effects: _,
-            } = &*entrypoints_with_issues_op
-                .read_strongly_consistent()
-                .await?;
-
-            Ok((entrypoints.clone(), issues.clone(), diagnostics.clone()))
-        })
-        .await
-        .map_err(|e| napi::Error::from_reason(PrettyPrintError(&e).to_string()))?;
-
-    Ok(TurbopackResult {
-        result: NapiEntrypoints::from_entrypoints_op(&entrypoints, &project.turbopack_ctx)?,
-        issues: issues.iter().map(|i| NapiIssue::from(&**i)).collect(),
-        diagnostics: diags.iter().map(|d| NapiDiagnostic::from(d)).collect(),
-    })
-}
-
 #[napi(ts_return_type = "{ __napiType: \"RootTask\" }")]
 pub fn project_entrypoints_subscribe(
     #[napi(ts_arg_type = "{ __napiType: \"Project\" }")] project: External<ProjectInstance>,
@@ -1686,70 +1650,3 @@ pub fn project_get_source_map_sync(
         tokio::runtime::Handle::current().block_on(project_get_source_map(project, file_path))
     })
 }
-
-#[napi]
-pub async fn project_module_graph(
-    #[napi(ts_arg_type = "{ __napiType: \"Project\" }")] project: External<ProjectInstance>,
-) -> napi::Result<TurbopackResult<NapiModuleGraphSnapshot>> {
-    let container = project.container;
-    let (module_graph, issues, diagnostics) = project
-        .turbopack_ctx
-        .turbo_tasks()
-        .run_once(async move {
-            let module_graph_op = get_module_graph_with_issues_operation(container);
-            let ModuleGraphWithIssues {
-                module_graph,
-                issues,
-                diagnostics,
-                effects: _,
-            } = &*module_graph_op.connect().await?;
-            Ok((module_graph.clone(), issues.clone(), diagnostics.clone()))
-        })
-        .await
-        .map_err(|e| napi::Error::from_reason(PrettyPrintError(&e).to_string()))?;
-
-    Ok(TurbopackResult {
-        result: module_graph.map_or_else(NapiModuleGraphSnapshot::default, |m| {
-            NapiModuleGraphSnapshot::from(&*m)
-        }),
-        issues: issues.iter().map(|i| NapiIssue::from(&**i)).collect(),
-        diagnostics: diagnostics
-            .iter()
-            .map(|d| NapiDiagnostic::from(d))
-            .collect(),
-    })
-}
-
-#[turbo_tasks::value(serialization = "none")]
-struct ModuleGraphWithIssues {
-    module_graph: Option<ReadRef<ModuleGraphSnapshot>>,
-    issues: Arc<Vec<ReadRef<PlainIssue>>>,
-    diagnostics: Arc<Vec<ReadRef<PlainDiagnostic>>>,
-    effects: Arc<Effects>,
-}
-
-#[turbo_tasks::function(operation)]
-async fn get_module_graph_with_issues_operation(
-    project: ResolvedVc<ProjectContainer>,
-) -> Result<Vc<ModuleGraphWithIssues>> {
-    let module_graph_op = get_module_graph_operation(project);
-    let (module_graph, issues, diagnostics, effects) =
-        strongly_consistent_catch_collectables(module_graph_op).await?;
-    Ok(ModuleGraphWithIssues {
-        module_graph,
-        issues,
-        diagnostics,
-        effects,
-    }
-    .cell())
-}
-
-#[turbo_tasks::function(operation)]
-async fn get_module_graph_operation(
-    project: ResolvedVc<ProjectContainer>,
-) -> Result<Vc<ModuleGraphSnapshot>> {
-    let project = project.project();
-    let graph = project.whole_app_module_graphs().await?.full;
-    let snapshot = get_module_graph_snapshot(*graph, None).resolve().await?;
-    Ok(snapshot)
-}