@soda-gql/swc-transformer 0.2.0

package/src/lib.rs

@@ -0,0 +1,87 @@
+//! SWC-based transformer for soda-gql GraphQL code generation.
+//!
+//! This crate provides a native Node.js module using napi-rs that transforms
+//! `gql.default()` calls into `gqlRuntime.*` calls at build time.
+
+mod transform;
+mod types;
+
+use napi::bindgen_prelude::*;
+use napi_derive::napi;
+use types::config::{TransformConfig, TransformInput, TransformInputRef};
+use types::BuilderArtifact;
+
+/// Transform a single source file.
+///
+/// # Arguments
+/// * `input_json` - JSON-serialized TransformInput containing source code, file path, artifact, and config
+///
+/// # Returns
+/// JSON-serialized TransformResult containing the transformed code
+#[napi]
+pub fn transform(input_json: String) -> Result<String> {
+    let input: TransformInput = serde_json::from_str(&input_json)
+        .map_err(|e| Error::from_reason(format!("Failed to parse input: {}", e)))?;
+
+    let result = transform::transformer::transform_source(&input)
+        .map_err(|e| Error::from_reason(e))?;
+
+    serde_json::to_string(&result)
+        .map_err(|e| Error::from_reason(format!("Failed to serialize result: {}", e)))
+}
+
+/// Stateful transformer that caches artifact and config for multiple file transformations.
+///
+/// The artifact is parsed once in the constructor and reused for all subsequent
+/// transform calls, avoiding repeated JSON parsing overhead.
+#[napi]
+pub struct SwcTransformer {
+    /// Pre-parsed BuilderArtifact (parsed once in constructor)
+    artifact: BuilderArtifact,
+    config: TransformConfig,
+}
+
+#[napi]
+impl SwcTransformer {
+    /// Create a new transformer instance.
+    ///
+    /// # Arguments
+    /// * `artifact_json` - JSON-serialized BuilderArtifact
+    /// * `config_json` - JSON-serialized TransformConfig
+    #[napi(constructor)]
+    pub fn new(artifact_json: String, config_json: String) -> Result<Self> {
+        let config: TransformConfig = serde_json::from_str(&config_json)
+            .map_err(|e| Error::from_reason(format!("Failed to parse config: {}", e)))?;
+
+        // Parse artifact once in constructor to avoid repeated parsing
+        let artifact: BuilderArtifact = serde_json::from_str(&artifact_json)
+            .map_err(|e| Error::from_reason(format!("Failed to parse artifact: {}", e)))?;
+
+        Ok(SwcTransformer { artifact, config })
+    }
+
+    /// Transform a single source file.
+    ///
+    /// # Arguments
+    /// * `source_code` - The source code to transform
+    /// * `source_path` - The file path of the source
+    ///
+    /// # Returns
+    /// JSON-serialized TransformResult
+    #[napi]
+    pub fn transform(&self, source_code: String, source_path: String) -> Result<String> {
+        // Use pre-parsed artifact reference instead of re-parsing JSON
+        let input = TransformInputRef {
+            source_code,
+            source_path,
+            artifact: &self.artifact,
+            config: self.config.clone(),
+        };
+
+        let result = transform::transformer::transform_source_ref(&input)
+            .map_err(|e| Error::from_reason(e))?;
+
+        serde_json::to_string(&result)
+            .map_err(|e| Error::from_reason(format!("Failed to serialize result: {}", e)))
+    }
+}

package/src/native/index.d.ts

@@ -0,0 +1,42 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/* auto-generated by NAPI-RS */
+
+/**
+ * Transform a single source file.
+ *
+ * # Arguments
+ * * `input_json` - JSON-serialized TransformInput containing source code, file path, artifact, and config
+ *
+ * # Returns
+ * JSON-serialized TransformResult containing the transformed code
+ */
+export declare function transform(inputJson: string): string
+/**
+ * Stateful transformer that caches artifact and config for multiple file transformations.
+ *
+ * The artifact is parsed once in the constructor and reused for all subsequent
+ * transform calls, avoiding repeated JSON parsing overhead.
+ */
+export declare class SwcTransformer {
+  /**
+   * Create a new transformer instance.
+   *
+   * # Arguments
+   * * `artifact_json` - JSON-serialized BuilderArtifact
+   * * `config_json` - JSON-serialized TransformConfig
+   */
+  constructor(artifactJson: string, configJson: string)
+  /**
+   * Transform a single source file.
+   *
+   * # Arguments
+   * * `source_code` - The source code to transform
+   * * `source_path` - The file path of the source
+   *
+   * # Returns
+   * JSON-serialized TransformResult
+   */
+  transform(sourceCode: string, sourcePath: string): string
+}

package/src/native/index.js

@@ -0,0 +1,316 @@
+/* tslint:disable */
+/* eslint-disable */
+/* prettier-ignore */
+
+/* auto-generated by NAPI-RS */
+
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
+
+const { platform, arch } = process
+
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
+
+function isMusl() {
+  // For Node 10
+  if (!process.report || typeof process.report.getReport !== 'function') {
+    try {
+      const lddPath = require('child_process').execSync('which ldd').toString().trim()
+      return readFileSync(lddPath, 'utf8').includes('musl')
+    } catch (e) {
+      return true
+    }
+  } else {
+    const { glibcVersionRuntime } = process.report.getReport().header
+    return !glibcVersionRuntime
+  }
+}
+
+switch (platform) {
+  case 'android':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'swc-transformer.android-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./swc-transformer.'.slice(0) + 'android-arm64.node')
+          } else {
+            nativeBinding = require('@soda-gql/swc-transformer-'.slice(0) + 'android-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'swc-transformer.android-arm-eabi.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./swc-transformer.'.slice(0) + 'android-arm-eabi.node')
+          } else {
+            nativeBinding = require('@soda-gql/swc-transformer-'.slice(0) + 'android-arm-eabi')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Android ${arch}`)
+    }
+    break
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(
+          join(__dirname, 'swc-transformer.win32-x64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./swc-transformer.'.slice(0) + 'win32-x64-msvc.node')
+          } else {
+            nativeBinding = require('@soda-gql/swc-transformer-'.slice(0) + 'win32-x64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(
+          join(__dirname, 'swc-transformer.win32-ia32-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./swc-transformer.'.slice(0) + 'win32-ia32-msvc.node')
+          } else {
+            nativeBinding = require('@soda-gql/swc-transformer-'.slice(0) + 'win32-ia32-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'swc-transformer.win32-arm64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./swc-transformer.'.slice(0) + 'win32-arm64-msvc.node')
+          } else {
+            nativeBinding = require('@soda-gql/swc-transformer-'.slice(0) + 'win32-arm64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`)
+    }
+    break
+  case 'darwin':
+    localFileExisted = existsSync(join(__dirname, 'swc-transformer.darwin-universal.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./swc-transformer.'.slice(0) + 'darwin-universal.node')
+      } else {
+        nativeBinding = require('@soda-gql/swc-transformer-'.slice(0) + 'darwin-universal')
+      }
+      break
+    } catch {}
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'swc-transformer.darwin-x64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./swc-transformer.'.slice(0) + 'darwin-x64.node')
+          } else {
+            nativeBinding = require('@soda-gql/swc-transformer-'.slice(0) + 'darwin-x64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'swc-transformer.darwin-arm64.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./swc-transformer.'.slice(0) + 'darwin-arm64.node')
+          } else {
+            nativeBinding = require('@soda-gql/swc-transformer-'.slice(0) + 'darwin-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on macOS: ${arch}`)
+    }
+    break
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
+    }
+    localFileExisted = existsSync(join(__dirname, 'swc-transformer.freebsd-x64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./swc-transformer.'.slice(0) + 'freebsd-x64.node')
+      } else {
+        nativeBinding = require('@soda-gql/swc-transformer-'.slice(0) + 'freebsd-x64')
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'swc-transformer.linux-x64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./swc-transformer.'.slice(0) + 'linux-x64-musl.node')
+            } else {
+              nativeBinding = require('@soda-gql/swc-transformer-'.slice(0) + 'linux-x64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'swc-transformer.linux-x64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./swc-transformer.'.slice(0) + 'linux-x64-gnu.node')
+            } else {
+              nativeBinding = require('@soda-gql/swc-transformer-'.slice(0) + 'linux-x64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'swc-transformer.linux-arm64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./swc-transformer.'.slice(0) + 'linux-arm64-musl.node')
+            } else {
+              nativeBinding = require('@soda-gql/swc-transformer-'.slice(0) + 'linux-arm64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'swc-transformer.linux-arm64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./swc-transformer.'.slice(0) + 'linux-arm64-gnu.node')
+            } else {
+              nativeBinding = require('@soda-gql/swc-transformer-'.slice(0) + 'linux-arm64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'swc-transformer.linux-arm-musleabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./swc-transformer.'.slice(0) + 'linux-arm-musleabihf.node')
+            } else {
+              nativeBinding = require('@soda-gql/swc-transformer-'.slice(0) + 'linux-arm-musleabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'swc-transformer.linux-arm-gnueabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./swc-transformer.'.slice(0) + 'linux-arm-gnueabihf.node')
+            } else {
+              nativeBinding = require('@soda-gql/swc-transformer-'.slice(0) + 'linux-arm-gnueabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'riscv64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'swc-transformer.linux-riscv64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./swc-transformer.'.slice(0) + 'linux-riscv64-musl.node')
+            } else {
+              nativeBinding = require('@soda-gql/swc-transformer-'.slice(0) + 'linux-riscv64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'swc-transformer.linux-riscv64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./swc-transformer.'.slice(0) + 'linux-riscv64-gnu.node')
+            } else {
+              nativeBinding = require('@soda-gql/swc-transformer-'.slice(0) + 'linux-riscv64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 's390x':
+        localFileExisted = existsSync(
+          join(__dirname, 'swc-transformer.linux-s390x-gnu.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./swc-transformer.'.slice(0) + 'linux-s390x-gnu.node')
+          } else {
+            nativeBinding = require('@soda-gql/swc-transformer-'.slice(0) + 'linux-s390x-gnu')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Linux: ${arch}`)
+    }
+    break
+  default:
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
+}
+
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+const { transform, SwcTransformer } = nativeBinding
+
+module.exports.transform = transform
+module.exports.SwcTransformer = SwcTransformer

package/src/transform/analysis.rs

@@ -0,0 +1,240 @@
+//! GQL call analysis module.
+//!
+//! This module is responsible for:
+//! - Detecting `gql.default()` call patterns
+//! - Extracting the inner builder call
+//! - Mapping calls to their corresponding artifacts
+
+use std::collections::HashMap;
+use swc_core::common::Span;
+use swc_core::ecma::ast::*;
+use swc_core::ecma::visit::{Visit, VisitWith};
+
+use crate::types::{BuilderArtifact, BuilderArtifactElement, CanonicalId, PluginError};
+
+use super::metadata::MetadataMap;
+
+/// Information about a detected GQL call that needs to be transformed.
+#[allow(dead_code)]
+#[derive(Debug, Clone)]
+pub struct GqlCallInfo {
+    /// The canonical ID for this call
+    pub canonical_id: CanonicalId,
+    /// The artifact element from the builder
+    pub artifact: BuilderArtifactElement,
+    /// Span of the original gql.default() call
+    pub call_span: Span,
+    /// The inner builder call (e.g., fragment.User(), query.slice())
+    pub builder_call_args: Vec<ExprOrSpread>,
+}
+
+/// Replacement information for a GQL call.
+#[derive(Debug)]
+pub struct GqlReplacement {
+    #[allow(dead_code)]
+    pub canonical_id: CanonicalId,
+    pub artifact: BuilderArtifactElement,
+    pub builder_args: Vec<ExprOrSpread>,
+}
+
+/// Finds GQL calls in the AST and prepares them for transformation.
+pub struct GqlCallFinder<'a> {
+    artifact: &'a BuilderArtifact,
+    metadata: &'a MetadataMap,
+    source_path: &'a str,
+    /// Map from call span to replacement info
+    replacements: HashMap<Span, GqlReplacement>,
+    has_transforms: bool,
+    /// Errors encountered during analysis
+    errors: Vec<PluginError>,
+}
+
+impl<'a> GqlCallFinder<'a> {
+    pub fn new(artifact: &'a BuilderArtifact, metadata: &'a MetadataMap, source_path: &'a str) -> Self {
+        Self {
+            artifact,
+            metadata,
+            source_path,
+            replacements: HashMap::new(),
+            has_transforms: false,
+            errors: Vec::new(),
+        }
+    }
+
+    /// Check if any transformations were found.
+    pub fn has_transformations(&self) -> bool {
+        self.has_transforms
+    }
+
+    /// Get the replacement for a call expression if it should be transformed.
+    pub fn get_replacement(&self, call: &CallExpr) -> Option<&GqlReplacement> {
+        self.replacements.get(&call.span)
+    }
+
+    /// Take collected errors.
+    pub fn take_errors(&mut self) -> Vec<PluginError> {
+        std::mem::take(&mut self.errors)
+    }
+
+    /// Process a potential GQL call expression.
+    fn process_call(&mut self, call: &CallExpr) {
+        // Check if this is a gql.default() or gql.* call
+        if let Some(builder_call) = find_gql_builder_call(call) {
+            // Get metadata for this call
+            if let Some(meta) = self.metadata.get(&call.span) {
+                let canonical_id = resolve_canonical_id(self.source_path, &meta.ast_path);
+
+                // Look up the artifact
+                if let Some(artifact) = self.artifact.get(&canonical_id) {
+                    self.replacements.insert(
+                        call.span,
+                        GqlReplacement {
+                            canonical_id,
+                            artifact: artifact.clone(),
+                            builder_args: builder_call.args.clone(),
+                        },
+                    );
+                    self.has_transforms = true;
+                } else {
+                    let error = PluginError::artifact_not_found(self.source_path, &canonical_id);
+                    eprintln!("[swc-transformer] {}", error.format());
+                    self.errors.push(error);
+                }
+            } else {
+                let error = PluginError::metadata_not_found(self.source_path);
+                eprintln!("[swc-transformer] {}", error.format());
+                self.errors.push(error);
+            }
+        }
+    }
+}
+
+impl Visit for GqlCallFinder<'_> {
+    fn visit_call_expr(&mut self, call: &CallExpr) {
+        // First check this call
+        self.process_call(call);
+
+        // Then visit children
+        call.visit_children_with(self);
+    }
+}
+
+/// Find the inner builder call from a gql.default() call.
+///
+/// Supports both arrow functions and function expressions:
+/// - `gql.default(({ fragment }) => fragment.User(...))`
+/// - `gql.default(function({ fragment }) { return fragment.User(...); })`
+///
+/// Returns: The inner builder call expression (e.g., `fragment.User(...)`)
+fn find_gql_builder_call(call: &CallExpr) -> Option<&CallExpr> {
+    // Check if callee is gql.* pattern
+    if !is_gql_member_expression(&call.callee) {
+        return None;
+    }
+
+    // Should have exactly one argument
+    if call.args.len() != 1 {
+        return None;
+    }
+
+    // The argument should be an arrow function or function expression
+    let arg = &call.args[0];
+    if arg.spread.is_some() {
+        return None;
+    }
+
+    match &*arg.expr {
+        Expr::Arrow(arrow) => extract_builder_call_from_arrow(arrow),
+        Expr::Fn(fn_expr) => extract_builder_call_from_fn(fn_expr),
+        _ => None,
+    }
+}
+
+/// Check if the callee is a gql.* member expression.
+fn is_gql_member_expression(callee: &Callee) -> bool {
+    match callee {
+        Callee::Expr(expr) => {
+            if let Expr::Member(member) = &**expr {
+                is_gql_reference(&member.obj)
+            } else {
+                false
+            }
+        }
+        _ => false,
+    }
+}
+
+/// Recursively check if an expression is a reference to `gql`.
+fn is_gql_reference(expr: &Expr) -> bool {
+    match expr {
+        Expr::Ident(ident) => atom_eq(&ident.sym, "gql"),
+        Expr::Member(member) => {
+            // Check if property is "gql"
+            if let MemberProp::Ident(ident) = &member.prop {
+                if atom_eq(&ident.sym, "gql") {
+                    return true;
+                }
+            }
+            // Recursively check the object
+            is_gql_reference(&member.obj)
+        }
+        _ => false,
+    }
+}
+
+/// Helper to compare an atom with a string.
+fn atom_eq<T: AsRef<str>>(atom: &T, s: &str) -> bool {
+    atom.as_ref() == s
+}
+
+/// Extract the builder call from an arrow function body.
+fn extract_builder_call_from_arrow(arrow: &ArrowExpr) -> Option<&CallExpr> {
+    match &*arrow.body {
+        BlockStmtOrExpr::Expr(expr) => {
+            if let Expr::Call(call) = &**expr {
+                Some(call)
+            } else {
+                None
+            }
+        }
+        BlockStmtOrExpr::BlockStmt(block) => extract_call_from_block(block),
+    }
+}
+
+/// Extract the builder call from a function expression body.
+fn extract_builder_call_from_fn(fn_expr: &FnExpr) -> Option<&CallExpr> {
+    // Function body is Option<BlockStmt>
+    fn_expr
+        .function
+        .body
+        .as_ref()
+        .and_then(|block| extract_call_from_block(block))
+}
+
+/// Extract a call expression from a block statement (shared by arrow and fn).
+fn extract_call_from_block(block: &BlockStmt) -> Option<&CallExpr> {
+    // Look for a return statement with a call expression
+    for stmt in &block.stmts {
+        if let Stmt::Return(ret) = stmt {
+            if let Some(arg) = &ret.arg {
+                if let Expr::Call(call) = &**arg {
+                    return Some(call);
+                }
+            }
+        }
+    }
+    None
+}
+
+/// Resolve a canonical ID from file path and AST path.
+/// The canonical ID format is: {normalizedAbsPath}::{astPath}
+///
+/// This mirrors the TypeScript implementation in @soda-gql/common:
+/// - Normalizes path separators to forward slashes (cross-platform)
+/// - Format matches builder artifact keys exactly
+fn resolve_canonical_id(file_path: &str, ast_path: &str) -> CanonicalId {
+    // Normalize path separators to forward slashes for cross-platform compatibility
+    // This matches the TypeScript normalizePath function behavior
+    let normalized_path = file_path.replace('\\', "/");
+    format!("{}::{}", normalized_path, ast_path)
+}