feat: return graph errors as diagnostics

src/mod.test.ts

@@ -11,9 +11,10 @@ Deno.test("should resolve, load and get graph", async () => {
     nodeConditions: undefined, // ensure doesn't error
   });
   const modFileUrl = import.meta.resolve("./mod.ts");
-  const loader = await workspace.createLoader({
+  const { loader, diagnostics } = await workspace.createLoader({
     entrypoints: [modFileUrl],
   });
+  assertEquals(diagnostics.length, 0);
   const graph = loader.getGraphUnstable();
   assertEquals((graph as any).roots[0], modFileUrl);
   const resolvedUrl = loader.resolve(
@@ -51,9 +52,10 @@ Deno.test("should resolve, load and get graph", async () => {
 Deno.test("resolving a jsr specifier should fail with explanatory message", async () => {
   const workspace = new Workspace({});
   const modFileUrl = import.meta.resolve("./mod.ts");
-  const loader = await workspace.createLoader({
+  const { loader, diagnostics } = await workspace.createLoader({
     entrypoints: [modFileUrl],
   });
+  assertEquals(diagnostics.length, 0);
   assertRejects(
     async () => {
       await loader.load(

src/mod.ts

@@ -10,9 +10,12 @@
  * const workspace = new Workspace({
  *   // optional options
  * });
- * const loader = await workspace.createLoader({
+ * const { loader, diagnostics } = await workspace.createLoader({
  *   entrypoints: ["./mod.ts"]
  * });
+ * if (diagnostics.length > 0) {
+ *   throw new Error(diagnostics[0].message);
+ * }
  * const resolvedUrl = loader.resolve(
  *   "./mod.test.ts",
  *   "https://deno.land/mod.ts", // referrer
@@ -146,7 +149,9 @@ export class Workspace implements Disposable {
   }
 
   /** Creates a loader that uses this this workspace. */
-  async createLoader(options: LoaderOptions): Promise<Loader> {
+  async createLoader(
+    options: LoaderOptions,
+  ): Promise<{ loader: Loader; diagnostics: EntrypointDiagnostic[] }> {
     if (this.#debug) {
       console.error(
         `Creating loader for entrypoints:\n  ${
@@ -156,8 +161,8 @@ export class Workspace implements Disposable {
     }
     const wasmLoader = await this.#inner.create_loader();
     const loader = new Loader(wasmLoader, this.#debug);
-    await loader.addEntrypoints(options.entrypoints);
-    return loader;
+    const diagnostics = await loader.addEntrypoints(options.entrypoints);
+    return { loader, diagnostics };
   }
 }
 
@@ -168,6 +173,10 @@ export enum RequestedModuleType {
   Bytes = 3,
 }
 
+export interface EntrypointDiagnostic {
+  message: string;
+}
+
 /** A loader for resolving and loading urls. */
 export class Loader implements Disposable {
   #inner: WasmLoader;
@@ -192,8 +201,11 @@ export class Loader implements Disposable {
    * stored in the internal module graph on the fly, which will allow
    * it to be synchronously resolved.
    */
-  addEntrypoints(entrypoints: string[]): Promise<void> {
-    return this.#inner.add_entrypoints(entrypoints);
+  async addEntrypoints(
+    entrypoints: string[],
+  ): Promise<EntrypointDiagnostic[]> {
+    const messages = await this.#inner.add_entrypoints(entrypoints);
+    return messages.map((message) => ({ message }));
   }
 
   /** Resolves a specifier using the given referrer and resolution mode. */

src/rs_lib/lib.rs

@@ -10,9 +10,12 @@ use deno_ast::ModuleKind;
 use deno_cache_dir::file_fetcher::CacheSetting;
 use deno_cache_dir::file_fetcher::NullBlobStore;
 use deno_error::JsErrorBox;
+use deno_graph::CheckJsOption;
+use deno_graph::GraphKind;
 use deno_graph::MediaType;
 use deno_graph::ModuleGraph;
 use deno_graph::Position;
+use deno_graph::WalkOptions;
 use deno_graph::analysis::ModuleAnalyzer;
 use deno_graph::ast::CapturingEsParser;
 use deno_graph::ast::DefaultEsParser;
@@ -336,7 +339,7 @@ impl DenoLoader {
   pub async fn add_entrypoints(
     &mut self,
     entrypoints: Vec<String>,
-  ) -> Result<(), JsValue> {
+  ) -> Result<Vec<String>, JsValue> {
     // only allow one async task to modify the graph at a time
     let task_queue = self.task_queue.clone();
     task_queue
@@ -352,7 +355,7 @@ impl DenoLoader {
   async fn add_entrypoints_internal(
     &mut self,
     entrypoints: Vec<String>,
-  ) -> Result<(), anyhow::Error> {
+  ) -> Result<Vec<String>, anyhow::Error> {
     let roots = entrypoints
       .into_iter()
       .map(|e| self.resolve_entrypoint(e))
@@ -393,7 +396,7 @@ impl DenoLoader {
     self
       .graph
       .build(
-        roots,
+        roots.clone(),
         Vec::new(),
         &loader,
         deno_graph::BuildOptions {
@@ -414,8 +417,21 @@ impl DenoLoader {
         },
       )
       .await;
-    self.graph.valid()?;
-    Ok(())
+    let errors = self
+      .graph
+      .walk(
+        roots.iter(),
+        WalkOptions {
+          check_js: CheckJsOption::True,
+          kind: GraphKind::CodeOnly,
+          follow_dynamic: false,
+          prefer_fast_check_graph: false,
+        },
+      )
+      .errors()
+      .map(|e| e.to_string_with_range())
+      .collect();
+    Ok(errors)
   }
 
   pub fn resolve(

tests/helpers.ts

@@ -12,12 +12,28 @@ export * from "@deno/loader";
 export async function createLoader(
   workspaceOptions: WorkspaceOptions,
   loaderOptions: LoaderOptions,
+) {
+  const { loader, workspace, diagnostics } = await createLoaderWithDiagnostics(
+    workspaceOptions,
+    loaderOptions,
+  );
+  assertEquals(diagnostics, []);
+  return {
+    loader,
+    workspace,
+  };
+}
+
+export async function createLoaderWithDiagnostics(
+  workspaceOptions: WorkspaceOptions,
+  loaderOptions: LoaderOptions,
 ) {
   const workspace = new Workspace(workspaceOptions);
-  const loader = await workspace.createLoader(loaderOptions);
+  const { loader, diagnostics } = await workspace.createLoader(loaderOptions);
   return {
     loader,
     workspace,
+    diagnostics,
   };
 }
 

tests/invalid_graph/main.test.ts

@@ -0,0 +1,19 @@
+import { assertEquals } from "@std/assert";
+import { createLoaderWithDiagnostics } from "../helpers.ts";
+
+Deno.test("loads linked entrypoint", async () => {
+  const mainFile = import.meta.dirname + "/testdata/main.ts";
+  const { diagnostics } = await createLoaderWithDiagnostics({
+    configPath: import.meta.dirname + "/testdata/deno.json",
+  }, {
+    entrypoints: [mainFile],
+  });
+
+  assertEquals(diagnostics.length, 1);
+  const expectedMessage =
+    'Relative import path "unknown" not prefixed with / or ./ or ../';
+  assertEquals(
+    diagnostics[0].message.substring(0, expectedMessage.length),
+    expectedMessage,
+  );
+});

tests/invalid_graph/testdata/deno.json

@@ -0,0 +1,2 @@
+{
+}

tests/invalid_graph/testdata/main.ts

@@ -0,0 +1 @@
+import "unknown";

tests/jsx/main.test.ts

@@ -5,7 +5,7 @@ import {
   ResolutionMode,
   type WorkspaceOptions,
 } from "../helpers.ts";
-import { assert } from "@std/assert";
+import { assert, assertEquals } from "@std/assert";
 
 Deno.test("loads jsx transpiled", async () => {
   const mainJsx = import.meta.dirname + "/testdata/main.jsx";
@@ -47,9 +47,10 @@ ${mainJsxSourceMappingURL}`,
 
   {
     const { workspace } = await createWorkspace({ preserveJsx: true });
-    const newLoader = await workspace.createLoader({
+    const { loader: newLoader, diagnostics } = await workspace.createLoader({
       entrypoints: [mainJsx, mainTsxUrl],
     });
+    assertEquals(diagnostics, []);
     assertResponseText(
       await newLoader.load(mainJsxUrl, RequestedModuleType.Default),
       "console.log(<div />);\n",
@@ -61,9 +62,10 @@ ${mainJsxSourceMappingURL}`,
   }
   {
     const { workspace } = await createWorkspace({ noTranspile: true });
-    const newLoader = await workspace.createLoader({
+    const { loader: newLoader, diagnostics } = await workspace.createLoader({
       entrypoints: [mainJsx, mainTsx],
     });
+    assertEquals(diagnostics, []);
     assertResponseText(
       await newLoader.load(mainJsxUrl, RequestedModuleType.Default),
       `console.log(<div />);\n`,