fix(graphql-codegen-client-preset): handle Windows-style paths in WASM runtime (#595)

The SWC plugin runs inside a WASM runtime which always uses Unix path
semantics, but on Windows the host passes paths with backslashes (e.g.
`C:\Users\user\project\src\gql`). `PathBuf` in WASM does not treat
backslashes as separators, so path computation was silently wrong and
produced invalid relative import paths.

Fix by:
1. Normalizing all input paths (`cwd`, `filename`, `artifactDirectory`)
by replacing backslashes with forward slashes before any `PathBuf`
usage.
2. Replacing the `Path::is_absolute()` check with an explicit helper
that also recognises Windows drive-letter paths (`C:/...`) as absolute,
since `Path::is_absolute()` returns false for those under WASM/Unix
semantics.

Closes #524

Generated with [Claude Code](https://claude.ai/code)

Co-authored-by: claude[bot] <41898282+claude[bot]@users.noreply.github.com>
Co-authored-by: Donny/강동윤 <kdy1@users.noreply.github.com>

Author: kdy1

contrib/graphql-codegen-client-preset/src/lib.rs

@@ -1,4 +1,4 @@
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 
 use graphql_parser::query::parse_query;
 use pathdiff::diff_paths;
@@ -88,6 +88,27 @@ fn apply_naming_convention(s: &str, naming_convention: &str) -> String {
     }
 }
 
+/// Returns true if `path` is an absolute path on either Unix (`/foo`) or
+/// Windows (`C:/foo`, `C:\foo`).  We cannot rely on `Path::is_absolute()`
+/// because when the plugin runs inside a WASM runtime it always uses Unix
+/// path semantics, so Windows absolute paths would be misclassified as
+/// relative.
+fn is_absolute_path(path: &str) -> bool {
+    // Unix absolute path
+    if path.starts_with('/') {
+        return true;
+    }
+    // Windows absolute path: starts with a drive letter followed by ':' and a
+    // slash/backslash, e.g. "C:/..." or "C:\..."
+    let mut chars = path.chars();
+    if let (Some(drive), Some(':'), Some(sep)) = (chars.next(), chars.next(), chars.next()) {
+        if drive.is_ascii_alphabetic() && (sep == '/' || sep == '\\') {
+            return true;
+        }
+    }
+    false
+}
+
 #[cfg(test)]
 mod tests;
 
@@ -118,21 +139,30 @@ impl GraphQLVisitor {
     }
 
     fn get_relative_import_path(&self, path_end: &str) -> String {
+        // Normalize Windows-style backslashes to forward slashes so that PathBuf
+        // works correctly when the plugin runs in a WASM context (which always uses
+        // Unix path semantics) but receives Windows paths from the host.
+        let cwd = self.options.cwd.replace('\\', "/");
+        let filename = self.options.filename.replace('\\', "/");
+        let artifact_directory = self.options.artifact_directory.replace('\\', "/");
+
         // using PathBuf to add the relative path to the artifact directory
-        let mut file_full_path = PathBuf::from(&self.options.cwd);
-        file_full_path.push(&self.options.filename);
+        let mut file_full_path = PathBuf::from(&cwd);
+        file_full_path.push(&filename);
         let file_s_dirname = file_full_path.parent().unwrap();
 
         // The resolved artifact directory as seen from the current running SWC plugin
-        // working directory
-        let resolved_artifact_directory =
-            if Path::new(&self.options.artifact_directory).is_relative() {
-                let mut cwd = PathBuf::from(&self.options.cwd);
-                cwd.push(&self.options.artifact_directory);
-                cwd.to_string_lossy().to_string()
-            } else {
-                self.options.artifact_directory.to_string()
-            };
+        // working directory.
+        // We check for absolute paths ourselves instead of relying on
+        // Path::is_absolute(), because on WASM (Unix semantics) a Windows absolute
+        // path such as "C:/project/src" would be considered relative.
+        let resolved_artifact_directory = if is_absolute_path(&artifact_directory) {
+            artifact_directory.to_string()
+        } else {
+            let mut cwd_path = PathBuf::from(&cwd);
+            cwd_path.push(&artifact_directory);
+            cwd_path.to_string_lossy().to_string()
+        };
 
         let mut relative = diff_paths(resolved_artifact_directory, file_s_dirname).unwrap();
 

contrib/graphql-codegen-client-preset/src/tests.rs

@@ -92,6 +92,33 @@ fn import_files_from_other_directory(input_path: PathBuf) {
     );
 }
 
+fn get_windows_path_visitor() -> GraphQLVisitor {
+    // Simulate a Windows environment where cwd and artifact_directory use backslashes.
+    // The WASM plugin runs with Unix path semantics, so it must normalize these.
+    GraphQLVisitor::new(GraphQLCodegenOptions {
+        filename: "src\\App.tsx".to_string(),
+        cwd: "C:\\Users\\user\\project".to_string(),
+        artifact_directory: "C:\\Users\\user\\project\\src\\gql".to_string(),
+        gql_tag_name: "gql".to_string(),
+        naming_convention: "change-case-all#pascalCase".to_string(),
+    })
+}
+
+test!(
+    Default::default(),
+    |_| visit_mut_pass(get_windows_path_visitor()),
+    windows_absolute_paths_produce_valid_relative_import,
+    r#"import gql from "gql-tag";
+
+const GetUser = gql(`
+  query GetUser {
+    user {
+      id
+    }
+  }
+`);"#
+);
+
 test!(
     Default::default(),
     |_| visit_mut_pass(get_test_code_visitor()),

contrib/graphql-codegen-client-preset/tests/__swc_snapshots__/src/tests.rs/windows_absolute_paths_produce_valid_relative_import.js

@@ -0,0 +1,3 @@
+import { GetUserDocument } from "./gql/graphql";
+import gql from "gql-tag";
+const GetUser = GetUserDocument;