@soda-gql/swc 0.11.2 → 0.11.4

package/src/transformer.test.ts

@@ -6,6 +6,11 @@
  */
 
 import { describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, realpathSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import type { BuilderArtifact } from "@soda-gql/builder";
+import type { ResolvedSodaGqlConfig } from "@soda-gql/config";
 import { loadTestCases, normalizeCode, type TransformTestCase } from "@soda-gql/tsc/test";
 
 // Check if native module is available before running tests
@@ -207,3 +212,197 @@ describe("swc", async () => {
     });
   }
 });
+
+/**
+ * Helper to write a file, creating parent directories if needed.
+ */
+const writeFile = (filePath: string, content: string): void => {
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, content);
+};
+
+/**
+ * Create a test config with configurable paths.
+ */
+const createStubTestConfig = (options: { outdir: string; scalarsPath: string; adapterPath?: string }): ResolvedSodaGqlConfig => ({
+  analyzer: "ts",
+  outdir: options.outdir,
+  graphqlSystemAliases: ["@/graphql-system"],
+  include: [],
+  exclude: [],
+  schemas: {
+    default: {
+      schema: [],
+      inject: {
+        scalars: options.scalarsPath,
+        adapter: options.adapterPath,
+      },
+      defaultInputDepth: 3,
+      inputDepthOverrides: {},
+    },
+  },
+  styles: { importExtension: false },
+  plugins: {},
+});
+
+/**
+ * Create an empty artifact for testing.
+ */
+const createEmptyArtifact = (): BuilderArtifact => ({
+  elements: {},
+  report: {
+    durationMs: 0,
+    warnings: [],
+    stats: { hits: 0, misses: 0, skips: 0 },
+  },
+});
+
+/**
+ * Create a canonical temp directory path.
+ * On macOS, /var is a symlink to /private/var, so we use realpathSync
+ * to get the canonical path that matches what resolveCanonicalPath produces.
+ */
+const createCanonicalTempDir = (prefix: string): string => {
+  const tmpDir = mkdtempSync(join(tmpdir(), prefix));
+  return realpathSync(tmpDir);
+};
+
+describe("swc internal module stubbing", () => {
+  it.skipIf(!nativeModuleAvailable)("stubs graphql-system/index.ts to export {}", async () => {
+    const tmpDir = createCanonicalTempDir("swc-stub-test-");
+    const outdir = join(tmpDir, "graphql-system");
+    const scalarsPath = join(tmpDir, "scalars.ts");
+    const graphqlSystemPath = join(outdir, "index.ts");
+
+    writeFile(graphqlSystemPath, "export const gql = { default: () => {} };");
+    writeFile(scalarsPath, "export const scalar = {};");
+
+    const config = createStubTestConfig({ outdir, scalarsPath });
+    const transformer = await createTransformer({
+      config,
+      artifact: createEmptyArtifact(),
+    });
+
+    const result = transformer.transform({
+      sourceCode: "export const gql = { default: () => {} };",
+      sourcePath: graphqlSystemPath,
+    });
+
+    expect(result.sourceCode).toBe("export {};");
+  });
+
+  it.skipIf(!nativeModuleAvailable)("stubs scalars file to export {}", async () => {
+    const tmpDir = createCanonicalTempDir("swc-stub-test-");
+    const outdir = join(tmpDir, "graphql-system");
+    const scalarsPath = join(tmpDir, "scalars.ts");
+
+    writeFile(scalarsPath, "export const scalar = { ID: {}, String: {} };");
+
+    const config = createStubTestConfig({ outdir, scalarsPath });
+    const transformer = await createTransformer({
+      config,
+      artifact: createEmptyArtifact(),
+    });
+
+    const result = transformer.transform({
+      sourceCode: "export const scalar = { ID: {}, String: {} };",
+      sourcePath: scalarsPath,
+    });
+
+    expect(result.sourceCode).toBe("export {};");
+  });
+
+  it.skipIf(!nativeModuleAvailable)("stubs adapter file to export {}", async () => {
+    const tmpDir = createCanonicalTempDir("swc-stub-test-");
+    const outdir = join(tmpDir, "graphql-system");
+    const scalarsPath = join(tmpDir, "scalars.ts");
+    const adapterPath = join(tmpDir, "adapter.ts");
+
+    writeFile(scalarsPath, "export const scalar = {};");
+    writeFile(adapterPath, "export const adapter = { fetch: () => {} };");
+
+    const config = createStubTestConfig({ outdir, scalarsPath, adapterPath });
+    const transformer = await createTransformer({
+      config,
+      artifact: createEmptyArtifact(),
+    });
+
+    const result = transformer.transform({
+      sourceCode: "export const adapter = { fetch: () => {} };",
+      sourcePath: adapterPath,
+    });
+
+    expect(result.sourceCode).toBe("export {};");
+  });
+
+  it.skipIf(!nativeModuleAvailable)("does not stub regular source files", async () => {
+    const tmpDir = createCanonicalTempDir("swc-stub-test-");
+    const outdir = join(tmpDir, "graphql-system");
+    const scalarsPath = join(tmpDir, "scalars.ts");
+    const regularPath = join(tmpDir, "regular.ts");
+
+    writeFile(scalarsPath, "export const scalar = {};");
+    writeFile(regularPath, "export const foo = 'bar';");
+
+    const config = createStubTestConfig({ outdir, scalarsPath });
+    const transformer = await createTransformer({
+      config,
+      artifact: createEmptyArtifact(),
+    });
+
+    const result = transformer.transform({
+      sourceCode: "export const foo = 'bar';",
+      sourcePath: regularPath,
+    });
+
+    // Regular files should not be stubbed
+    expect(result.sourceCode).not.toBe("export {};");
+    expect(result.sourceCode).toContain("foo");
+  });
+
+  it.skipIf(!nativeModuleAvailable)("handles multiple schemas with different inject paths", async () => {
+    const tmpDir = createCanonicalTempDir("swc-stub-test-");
+    const outdir = join(tmpDir, "graphql-system");
+    const scalars1 = join(tmpDir, "schema1", "scalars.ts");
+    const scalars2 = join(tmpDir, "schema2", "scalars.ts");
+    const adapter2 = join(tmpDir, "schema2", "adapter.ts");
+
+    writeFile(scalars1, "export const scalar = {};");
+    writeFile(scalars2, "export const scalar = {};");
+    writeFile(adapter2, "export const adapter = {};");
+
+    const config: ResolvedSodaGqlConfig = {
+      analyzer: "ts",
+      outdir,
+      graphqlSystemAliases: ["@/graphql-system"],
+      include: [],
+      exclude: [],
+      schemas: {
+        schema1: {
+          schema: [],
+          inject: { scalars: scalars1 },
+          defaultInputDepth: 3,
+          inputDepthOverrides: {},
+        },
+        schema2: {
+          schema: [],
+          inject: { scalars: scalars2, adapter: adapter2 },
+          defaultInputDepth: 3,
+          inputDepthOverrides: {},
+        },
+      },
+      styles: { importExtension: false },
+      plugins: {},
+    };
+
+    const transformer = await createTransformer({
+      config,
+      artifact: createEmptyArtifact(),
+    });
+
+    // All inject files should be stubbed
+    expect(transformer.transform({ sourceCode: "export const s = {};", sourcePath: scalars1 }).sourceCode).toBe("export {};");
+    expect(transformer.transform({ sourceCode: "export const s = {};", sourcePath: scalars2 }).sourceCode).toBe("export {};");
+    expect(transformer.transform({ sourceCode: "export const a = {};", sourcePath: adapter2 }).sourceCode).toBe("export {};");
+  });
+});

package/src/types/config.rs

@@ -21,6 +21,12 @@ pub struct TransformConfig {
     #[serde(default)]
     pub graphql_system_path: Option<String>,
 
+    /// Canonical paths to inject module files (scalars, adapter).
+    /// When the source file matches any of these paths, it will be stubbed out.
+    /// These are resolved by the TypeScript wrapper and passed to Rust.
+    #[serde(default)]
+    pub inject_paths: Vec<String>,
+
     /// Whether to generate source maps.
     /// If true, a source map will be included in the output.
     #[serde(default)]
@@ -33,6 +39,7 @@ impl Default for TransformConfig {
             graphql_system_aliases: vec!["@/graphql-system".to_string()],
             is_cjs: false,
             graphql_system_path: None,
+            inject_paths: Vec::new(),
             source_map: false,
         }
     }