Report transformation errors during cross file resolve (#480)

Author: Mad-Kat

.changeset/rich-laws-camp.md

@@ -0,0 +1,5 @@
+---
+"next-yak": patch
+---
+
+Report transformation errors during cross file resolve

packages/next-yak/cross-file-resolver/__tests__/parseModule.test.ts

@@ -470,6 +470,48 @@ test("parse .yak module extensions", async () => {
   assert.strictEqual(parsedModule5.type, "regular");
 });
 
+test("wraps errors from extractExports with file path", async () => {
+  const path = "/path/to/module.js";
+
+  await expect(
+    parseModule(
+      {
+        extractExports() {
+          throw new Error("The loaded module contains errors");
+        },
+        getTransformed() {
+          return { code: "" };
+        },
+      },
+      path,
+    ),
+  ).rejects.toThrow(
+    `Error parsing file "${path}"\n  Caused by: The loaded module contains errors`,
+  );
+});
+
+test("wraps errors from getTransformed with file path", async () => {
+  const path = "/path/to/module.js";
+
+  await expect(
+    parseModule(
+      {
+        extractExports() {
+          return { importYak: true, named: {}, all: [] };
+        },
+        getTransformed() {
+          throw new Error(
+            'The shorthand access to the variable "$foo" is not allowed',
+          );
+        },
+      },
+      path,
+    ),
+  ).rejects.toThrow(
+    `Error parsing file "${path}"\n  Caused by: The shorthand access to the variable "$foo" is not allowed`,
+  );
+});
+
 test("parse .yak module with cache multiple times extract/transform/evaluate each time", async () => {
   const path = "/path/to/module.yak.js";
 

packages/next-yak/cross-file-resolver/parseModule.ts

@@ -26,7 +26,7 @@ export async function parseModule(
     }
 
     if (context.cache?.parse === undefined) {
-      return uncachedParseModule(context, modulePath);
+      return await uncachedParseModule(context, modulePath);
     }
 
     const cached = context.cache.parse.get(modulePath);
@@ -45,8 +45,9 @@ export async function parseModule(
 
     return cached;
   } catch (error) {
+    const causeMessage = error instanceof Error ? error.message : String(error);
     throw new Error(
-      `Error parsing file ${modulePath}: ${(error as Error).message}`,
+      `Error parsing file "${modulePath}"\n  Caused by: ${causeMessage}`,
     );
   }
 }

packages/next-yak/loaders/lib/resolveCrossFileSelectors.ts

@@ -66,7 +66,32 @@ function getParseContext(
     async getTransformed(modulePath) {
       const transformedSource = new Promise<string>((resolve, reject) => {
         loader.loadModule(modulePath, (err, source) => {
-          if (err) return reject(err);
+          if (err) {
+            // When webpack reports "The loaded module contains errors",
+            // the actual errors are stored on the module in the compilation.
+            // Extract and report the real errors for better debugging.
+            const compilation = loader._compilation;
+            if (compilation) {
+              try {
+                for (const mod of compilation.modules) {
+                  if ("resource" in mod && mod.resource === modulePath) {
+                    const errors = mod.getErrors();
+                    if (errors) {
+                      const messages = Array.from(errors)
+                        .map((e) => e.message)
+                        .filter(Boolean);
+                      if (messages.length > 0) {
+                        return reject(new Error(messages.join("\n")));
+                      }
+                    }
+                  }
+                }
+              } catch {
+                // Ignore errors while trying to extract module errors
+              }
+            }
+            return reject(err);
+          }
           let sourceString: string;
           if (typeof source === "string") {
             sourceString = source;