@soda-gql/swc-transformer 0.2.0

package/src/transform/imports.rs

@@ -0,0 +1,285 @@
+//! Import management module.
+//!
+//! This module handles:
+//! - Adding the `@soda-gql/runtime` import/require
+//! - Removing the `graphql-system` imports
+
+use swc_core::common::{SyntaxContext, DUMMY_SP};
+use swc_core::ecma::ast::*;
+use swc_core::ecma::visit::{VisitMut, VisitMutWith};
+
+const RUNTIME_MODULE: &str = "@soda-gql/runtime";
+const RUNTIME_IMPORT_NAME: &str = "gqlRuntime";
+const CJS_RUNTIME_NAME: &str = "__soda_gql_runtime";
+
+/// Manages imports for the transformation.
+pub struct ImportManager {
+    needs_runtime_import: bool,
+    is_cjs: bool,
+    graphql_system_aliases: Vec<String>,
+    has_added_import: bool,
+}
+
+impl ImportManager {
+    pub fn new(needs_runtime_import: bool, is_cjs: bool, graphql_system_aliases: &[String]) -> Self {
+        Self {
+            needs_runtime_import,
+            is_cjs,
+            graphql_system_aliases: graphql_system_aliases.to_vec(),
+            has_added_import: false,
+        }
+    }
+
+    /// Check if a specifier is a graphql-system import.
+    fn is_graphql_system_import(&self, specifier: &str) -> bool {
+        self.graphql_system_aliases.iter().any(|alias| {
+            specifier == alias || specifier.starts_with(&format!("{}/", alias))
+        })
+    }
+
+    /// Create the ESM runtime import.
+    fn create_esm_import(&self) -> ModuleItem {
+        // import { gqlRuntime } from "@soda-gql/runtime";
+        ModuleItem::ModuleDecl(ModuleDecl::Import(ImportDecl {
+            span: DUMMY_SP,
+            specifiers: vec![ImportSpecifier::Named(ImportNamedSpecifier {
+                span: DUMMY_SP,
+                local: Ident::new(RUNTIME_IMPORT_NAME.into(), DUMMY_SP, Default::default()),
+                imported: None,
+                is_type_only: false,
+            })],
+            src: Box::new(Str {
+                span: DUMMY_SP,
+                value: RUNTIME_MODULE.into(),
+                raw: None,
+            }),
+            type_only: false,
+            with: None,
+            phase: ImportPhase::Evaluation,
+        }))
+    }
+
+    /// Create the CJS runtime require.
+    fn create_cjs_require(&self) -> ModuleItem {
+        // const __soda_gql_runtime = require("@soda-gql/runtime");
+        ModuleItem::Stmt(Stmt::Decl(Decl::Var(Box::new(VarDecl {
+            span: DUMMY_SP,
+            ctxt: SyntaxContext::empty(),
+            kind: VarDeclKind::Const,
+            declare: false,
+            decls: vec![VarDeclarator {
+                span: DUMMY_SP,
+                name: Pat::Ident(BindingIdent {
+                    id: Ident::new(CJS_RUNTIME_NAME.into(), DUMMY_SP, Default::default()),
+                    type_ann: None,
+                }),
+                init: Some(Box::new(Expr::Call(CallExpr {
+                    span: DUMMY_SP,
+                    ctxt: SyntaxContext::empty(),
+                    callee: Callee::Expr(Box::new(Expr::Ident(Ident::new(
+                        "require".into(),
+                        DUMMY_SP,
+                        Default::default(),
+                    )))),
+                    args: vec![ExprOrSpread {
+                        spread: None,
+                        expr: Box::new(Expr::Lit(Lit::Str(Str {
+                            span: DUMMY_SP,
+                            value: RUNTIME_MODULE.into(),
+                            raw: None,
+                        }))),
+                    }],
+                    type_args: None,
+                }))),
+                definite: false,
+            }],
+        }))))
+    }
+
+    /// Check if a variable declaration is a require for graphql-system.
+    fn is_graphql_system_require(&self, decl: &VarDeclarator) -> bool {
+        if let Some(init) = &decl.init {
+            if let Some(specifier) = extract_require_specifier(init) {
+                return self.is_graphql_system_import(&specifier);
+            }
+        }
+        false
+    }
+
+    /// Check if an import already has the runtime import.
+    fn has_runtime_import(&self, import: &ImportDecl) -> bool {
+        if !wtf8_eq(&import.src.value, RUNTIME_MODULE) {
+            return false;
+        }
+
+        import.specifiers.iter().any(|spec| {
+            if let ImportSpecifier::Named(named) = spec {
+                atom_eq(&named.local.sym, RUNTIME_IMPORT_NAME)
+            } else {
+                false
+            }
+        })
+    }
+}
+
+impl VisitMut for ImportManager {
+    fn visit_mut_module(&mut self, module: &mut Module) {
+        // First, visit children to handle nested transformations
+        module.visit_mut_children_with(self);
+
+        // Collect new body items
+        let mut new_body: Vec<ModuleItem> = Vec::new();
+        let mut import_insert_pos = 0;
+        let mut found_non_import = false;
+        let mut existing_runtime_import_idx: Option<usize> = None;
+
+        for (_idx, item) in module.body.iter().enumerate() {
+            match item {
+                // Handle ESM imports
+                ModuleItem::ModuleDecl(ModuleDecl::Import(import)) => {
+                    let specifier = wtf8_to_string(&import.src.value);
+
+                    // Skip graphql-system imports
+                    if self.is_graphql_system_import(&specifier) {
+                        continue;
+                    }
+
+                    // Check if this is already the runtime import
+                    if specifier == RUNTIME_MODULE {
+                        existing_runtime_import_idx = Some(new_body.len());
+                    }
+
+                    import_insert_pos = new_body.len() + 1;
+                    new_body.push(item.clone());
+                }
+
+                // Handle CJS require statements
+                ModuleItem::Stmt(Stmt::Decl(Decl::Var(var_decl))) => {
+                    // Filter out graphql-system requires
+                    let filtered_decls: Vec<VarDeclarator> = var_decl
+                        .decls
+                        .iter()
+                        .filter(|decl| !self.is_graphql_system_require(decl))
+                        .cloned()
+                        .collect();
+
+                    if filtered_decls.is_empty() {
+                        // All declarations were graphql-system requires, skip
+                        continue;
+                    }
+
+                    if filtered_decls.len() < var_decl.decls.len() {
+                        // Some declarations were filtered
+                        new_body.push(ModuleItem::Stmt(Stmt::Decl(Decl::Var(Box::new(
+                            VarDecl {
+                                span: var_decl.span,
+                                ctxt: var_decl.ctxt,
+                                kind: var_decl.kind,
+                                declare: var_decl.declare,
+                                decls: filtered_decls,
+                            },
+                        )))));
+                    } else {
+                        new_body.push(item.clone());
+                    }
+
+                    if !found_non_import {
+                        import_insert_pos = new_body.len();
+                    }
+                    found_non_import = true;
+                }
+
+                _ => {
+                    if !found_non_import {
+                        import_insert_pos = new_body.len();
+                    }
+                    found_non_import = true;
+                    new_body.push(item.clone());
+                }
+            }
+        }
+
+        // Add runtime import if needed
+        if self.needs_runtime_import && !self.has_added_import {
+            // Check if we already have the runtime import
+            let already_has_import = existing_runtime_import_idx.map_or(false, |idx| {
+                if let ModuleItem::ModuleDecl(ModuleDecl::Import(import)) = &new_body[idx] {
+                    self.has_runtime_import(import)
+                } else {
+                    false
+                }
+            });
+
+            if !already_has_import {
+                if let Some(idx) = existing_runtime_import_idx {
+                    // Merge with existing import
+                    if let ModuleItem::ModuleDecl(ModuleDecl::Import(import)) = &mut new_body[idx] {
+                        let mut specifiers = import.specifiers.clone();
+                        specifiers.push(ImportSpecifier::Named(ImportNamedSpecifier {
+                            span: DUMMY_SP,
+                            local: Ident::new(RUNTIME_IMPORT_NAME.into(), DUMMY_SP, Default::default()),
+                            imported: None,
+                            is_type_only: false,
+                        }));
+                        import.specifiers = specifiers;
+                    }
+                } else {
+                    // Add new import
+                    let runtime_import = if self.is_cjs {
+                        self.create_cjs_require()
+                    } else {
+                        self.create_esm_import()
+                    };
+                    new_body.insert(import_insert_pos, runtime_import);
+                }
+                self.has_added_import = true;
+            }
+        }
+
+        module.body = new_body;
+    }
+}
+
+/// Extract the module specifier from a require() call.
+fn extract_require_specifier(expr: &Expr) -> Option<String> {
+    match expr {
+        Expr::Call(call) => {
+            // Direct require("...")
+            if let Callee::Expr(callee) = &call.callee {
+                if let Expr::Ident(ident) = &**callee {
+                    if atom_eq(&ident.sym, "require") {
+                        if let Some(arg) = call.args.first() {
+                            if let Expr::Lit(Lit::Str(s)) = &*arg.expr {
+                                return Some(wtf8_to_string(&s.value));
+                            }
+                        }
+                    }
+
+                    // __importDefault(require("...")) or __importStar(require("..."))
+                    if atom_eq(&ident.sym, "__importDefault") || atom_eq(&ident.sym, "__importStar") {
+                        if let Some(arg) = call.args.first() {
+                            return extract_require_specifier(&arg.expr);
+                        }
+                    }
+                }
+            }
+            None
+        }
+        _ => None,
+    }
+}
+
+/// Helper to compare an Atom with a string.
+fn atom_eq<T: AsRef<str>>(atom: &T, s: &str) -> bool {
+    atom.as_ref() == s
+}
+
+/// Helper to compare a Wtf8Atom (string literal value) with a string.
+fn wtf8_eq(atom: &swc_core::atoms::Wtf8Atom, s: &str) -> bool {
+    atom.to_string_lossy() == s
+}
+
+/// Helper to convert a Wtf8Atom to String.
+fn wtf8_to_string(atom: &swc_core::atoms::Wtf8Atom) -> String {
+    atom.to_string_lossy().into_owned()
+}

package/src/transform/metadata.rs

@@ -0,0 +1,371 @@
+//! Metadata collection module.
+//!
+//! This module collects metadata about GQL definitions in the source code:
+//! - AST path (canonical path)
+//! - Export bindings
+//! - Scope tracking
+
+use std::collections::HashMap;
+use swc_core::common::Span;
+use swc_core::ecma::ast::*;
+use swc_core::ecma::visit::{Visit, VisitWith};
+
+/// Metadata about a GQL definition.
+#[derive(Debug, Clone)]
+pub struct GqlDefinitionMetadata {
+    /// The AST path for canonical ID resolution.
+    pub ast_path: String,
+    /// Whether this is a top-level definition.
+    #[allow(dead_code)]
+    pub is_top_level: bool,
+    /// Whether this definition is exported.
+    #[allow(dead_code)]
+    pub is_exported: bool,
+    /// The export binding name, if exported.
+    #[allow(dead_code)]
+    pub export_binding: Option<String>,
+}
+
+/// Map from call expression span to metadata.
+pub type MetadataMap = HashMap<Span, GqlDefinitionMetadata>;
+
+/// Map from local name to export name.
+type ExportBindingMap = HashMap<String, String>;
+
+/// Collects metadata about GQL definitions in a module.
+pub struct MetadataCollector {
+    #[allow(dead_code)]
+    source_path: String,
+    export_bindings: ExportBindingMap,
+    scope_stack: Vec<ScopeFrame>,
+    metadata: MetadataMap,
+    anonymous_counters: HashMap<String, usize>,
+    #[allow(dead_code)]
+    definition_counter: usize,
+}
+
+struct ScopeFrame {
+    segment: String,
+    #[allow(dead_code)]
+    kind: String,
+}
+
+impl MetadataCollector {
+    /// Collect metadata from a module.
+    pub fn collect(module: &Module, source_path: &str) -> MetadataMap {
+        let export_bindings = Self::collect_export_bindings(module);
+
+        let mut collector = Self {
+            source_path: source_path.to_string(),
+            export_bindings,
+            scope_stack: Vec::new(),
+            metadata: HashMap::new(),
+            anonymous_counters: HashMap::new(),
+            definition_counter: 0,
+        };
+
+        module.visit_with(&mut collector);
+        collector.metadata
+    }
+
+    /// Collect export bindings from the module.
+    fn collect_export_bindings(module: &Module) -> ExportBindingMap {
+        let mut bindings = HashMap::new();
+
+        for item in &module.body {
+            match item {
+                // ESM: export { foo }
+                ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(export)) => {
+                    if export.src.is_none() {
+                        for spec in &export.specifiers {
+                            if let ExportSpecifier::Named(named) = spec {
+                                let local = match &named.orig {
+                                    ModuleExportName::Ident(id) => atom_to_string(&id.sym),
+                                    ModuleExportName::Str(s) => wtf8_to_string(&s.value),
+                                };
+                                let exported = match &named.exported {
+                                    Some(ModuleExportName::Ident(id)) => atom_to_string(&id.sym),
+                                    Some(ModuleExportName::Str(s)) => wtf8_to_string(&s.value),
+                                    None => local.clone(),
+                                };
+                                bindings.insert(local, exported);
+                            }
+                        }
+                    }
+                }
+
+                // ESM: export const foo = ...
+                ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(export)) => {
+                    if let Decl::Var(var_decl) = &export.decl {
+                        for decl in &var_decl.decls {
+                            if let Pat::Ident(ident) = &decl.name {
+                                let name = atom_to_string(&ident.id.sym);
+                                bindings.insert(name.clone(), name);
+                            }
+                        }
+                    } else if let Decl::Fn(fn_decl) = &export.decl {
+                        let name = atom_to_string(&fn_decl.ident.sym);
+                        bindings.insert(name.clone(), name);
+                    } else if let Decl::Class(class_decl) = &export.decl {
+                        let name = atom_to_string(&class_decl.ident.sym);
+                        bindings.insert(name.clone(), name);
+                    }
+                }
+
+                // CommonJS: exports.foo = ... or module.exports.foo = ...
+                ModuleItem::Stmt(Stmt::Expr(expr_stmt)) => {
+                    if let Expr::Assign(assign) = &*expr_stmt.expr {
+                        if let Some(name) = get_commonjs_export_name(&assign.left) {
+                            bindings.insert(name.clone(), name);
+                        }
+                    }
+                }
+
+                _ => {}
+            }
+        }
+
+        bindings
+    }
+
+    /// Get the current AST path.
+    fn get_ast_path(&self) -> String {
+        self.scope_stack
+            .iter()
+            .map(|f| f.segment.clone())
+            .collect::<Vec<_>>()
+            .join(".")
+    }
+
+    /// Get an anonymous name for a scope kind (not currently used but kept for future).
+    #[allow(dead_code)]
+    fn get_anonymous_name(&mut self, kind: &str) -> String {
+        let count = self.anonymous_counters.entry(kind.to_string()).or_insert(0);
+        let name = format!("{}#{}", kind, count);
+        *count += 1;
+        name
+    }
+
+    /// Register a definition and get its AST path.
+    /// The AST path is the scope segments joined by `.`, with `$N` suffix for duplicates.
+    fn register_definition(&mut self) -> String {
+        let base_path = self.get_ast_path();
+
+        // Track occurrences for uniqueness
+        let count = self.anonymous_counters.entry(base_path.clone()).or_insert(0);
+        let path = if *count == 0 {
+            base_path.clone()
+        } else {
+            format!("{}${}", base_path, count)
+        };
+        *count += 1;
+        path
+    }
+
+    /// Enter a scope.
+    fn enter_scope(&mut self, segment: String, kind: &str) {
+        self.scope_stack.push(ScopeFrame {
+            segment,
+            kind: kind.to_string(),
+        });
+    }
+
+    /// Exit a scope.
+    fn exit_scope(&mut self) {
+        self.scope_stack.pop();
+    }
+
+    /// Check if a call expression is a GQL definition call.
+    fn is_gql_definition_call(&self, call: &CallExpr) -> bool {
+        // Check if callee is gql.* pattern
+        if let Callee::Expr(expr) = &call.callee {
+            if let Expr::Member(member) = &**expr {
+                if is_gql_reference(&member.obj) {
+                    // Check if first argument is an arrow function or function expression
+                    if let Some(first_arg) = call.args.first() {
+                        return matches!(&*first_arg.expr, Expr::Arrow(_) | Expr::Fn(_));
+                    }
+                }
+            }
+        }
+        false
+    }
+
+    /// Resolve top-level export info for a call.
+    fn resolve_export_info(&self, _call: &CallExpr) -> Option<String> {
+        // This is a simplified version - in practice, you'd need to track
+        // parent nodes to find the variable declaration or assignment
+        // For now, we'll look at the scope stack
+        if self.scope_stack.len() == 1 {
+            let binding_name = &self.scope_stack[0].segment;
+            self.export_bindings.get(binding_name).cloned()
+        } else {
+            None
+        }
+    }
+}
+
+impl Visit for MetadataCollector {
+    fn visit_var_declarator(&mut self, decl: &VarDeclarator) {
+        if let Pat::Ident(ident) = &decl.name {
+            let name = atom_to_string(&ident.id.sym);
+            self.enter_scope(name, "variable");
+            decl.visit_children_with(self);
+            self.exit_scope();
+        } else {
+            decl.visit_children_with(self);
+        }
+    }
+
+    fn visit_fn_decl(&mut self, decl: &FnDecl) {
+        let name = atom_to_string(&decl.ident.sym);
+        self.enter_scope(name, "function");
+        decl.visit_children_with(self);
+        self.exit_scope();
+    }
+
+    fn visit_fn_expr(&mut self, expr: &FnExpr) {
+        let name = expr
+            .ident
+            .as_ref()
+            .map(|i| atom_to_string(&i.sym))
+            .unwrap_or_else(|| self.get_anonymous_name("function"));
+        self.enter_scope(name, "function");
+        expr.visit_children_with(self);
+        self.exit_scope();
+    }
+
+    fn visit_arrow_expr(&mut self, expr: &ArrowExpr) {
+        let name = self.get_anonymous_name("arrow");
+        self.enter_scope(name, "function");
+        expr.visit_children_with(self);
+        self.exit_scope();
+    }
+
+    fn visit_class_decl(&mut self, decl: &ClassDecl) {
+        let name = atom_to_string(&decl.ident.sym);
+        self.enter_scope(name, "class");
+        decl.visit_children_with(self);
+        self.exit_scope();
+    }
+
+    fn visit_class_method(&mut self, method: &ClassMethod) {
+        if let PropName::Ident(ident) = &method.key {
+            let name = atom_to_string(&ident.sym);
+            self.enter_scope(name, "method");
+            method.visit_children_with(self);
+            self.exit_scope();
+        } else {
+            method.visit_children_with(self);
+        }
+    }
+
+    fn visit_key_value_prop(&mut self, prop: &KeyValueProp) {
+        let name = match &prop.key {
+            PropName::Ident(ident) => Some(atom_to_string(&ident.sym)),
+            PropName::Str(s) => Some(wtf8_to_string(&s.value)),
+            _ => None,
+        };
+
+        if let Some(name) = name {
+            self.enter_scope(name, "property");
+            prop.visit_children_with(self);
+            self.exit_scope();
+        } else {
+            prop.visit_children_with(self);
+        }
+    }
+
+    fn visit_assign_expr(&mut self, expr: &AssignExpr) {
+        // Handle CommonJS exports: exports.foo = ...
+        if let Some(name) = get_commonjs_export_name(&expr.left) {
+            self.enter_scope(name, "variable");
+            expr.visit_children_with(self);
+            self.exit_scope();
+        } else {
+            expr.visit_children_with(self);
+        }
+    }
+
+    fn visit_call_expr(&mut self, call: &CallExpr) {
+        if self.is_gql_definition_call(call) {
+            let ast_path = self.register_definition();
+            let is_top_level = self.scope_stack.len() <= 1;
+            let export_binding = self.resolve_export_info(call);
+
+            self.metadata.insert(
+                call.span,
+                GqlDefinitionMetadata {
+                    ast_path,
+                    is_top_level,
+                    is_exported: export_binding.is_some(),
+                    export_binding,
+                },
+            );
+
+            // Don't visit children of GQL calls
+            return;
+        }
+
+        call.visit_children_with(self);
+    }
+}
+
+/// 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) => {
+            if let MemberProp::Ident(ident) = &member.prop {
+                if atom_eq(&ident.sym, "gql") {
+                    return true;
+                }
+            }
+            is_gql_reference(&member.obj)
+        }
+        _ => false,
+    }
+}
+
+/// Get the export name from a CommonJS export pattern.
+fn get_commonjs_export_name(target: &AssignTarget) -> Option<String> {
+    match target {
+        AssignTarget::Simple(SimpleAssignTarget::Member(member)) => {
+            // Check for exports.foo or module.exports.foo
+            let is_exports = matches!(&*member.obj, Expr::Ident(ident) if atom_eq(&ident.sym, "exports"));
+            let is_module_exports = if let Expr::Member(inner) = &*member.obj {
+                matches!(&*inner.obj, Expr::Ident(ident) if atom_eq(&ident.sym, "module"))
+                    && matches!(&inner.prop, MemberProp::Ident(ident) if atom_eq(&ident.sym, "exports"))
+            } else {
+                false
+            };
+
+            if !is_exports && !is_module_exports {
+                return None;
+            }
+
+            // Extract property name
+            if let MemberProp::Ident(ident) = &member.prop {
+                Some(atom_to_string(&ident.sym))
+            } else {
+                None
+            }
+        }
+        _ => None,
+    }
+}
+
+/// Helper to compare an Atom with a string.
+fn atom_eq<T: AsRef<str>>(atom: &T, s: &str) -> bool {
+    atom.as_ref() == s
+}
+
+/// Helper to convert an Atom to String.
+fn atom_to_string<T: AsRef<str>>(atom: &T) -> String {
+    atom.as_ref().to_string()
+}
+
+/// Helper to convert a Wtf8Atom (string literal value) to String.
+fn wtf8_to_string(atom: &swc_core::atoms::Wtf8Atom) -> String {
+    atom.to_string_lossy().into_owned()
+}

package/src/transform/mod.rs

@@ -0,0 +1,7 @@
+//! Transformation modules for the SWC transformer.
+
+pub mod analysis;
+pub mod imports;
+pub mod metadata;
+pub mod runtime;
+pub mod transformer;