Implement CFG

Author: karthikscale3

Cargo.lock

@@ -46,6 +46,19 @@ export type GraphManifest = {
       }>;
     };
   };
+  debugInfo?: {
+    manifestPresent: boolean;
+    manifestStepFiles: number;
+    importsResolved: number;
+    importsWithKind: number;
+    importDetails: Array<{
+      localName: string;
+      source: string;
+      importedName: string;
+      kind: string | null;
+      lookupCandidates: string[];
+    }>;
+  };
 };
 
 export async function applySwcTransform(
@@ -56,7 +69,8 @@ export async function applySwcTransform(
     paths?: Record<string, string[]>;
     // this must be absolute path
     baseUrl?: string;
-  }
+  },
+  workflowManifest?: WorkflowManifest
 ): Promise<{
   code: string;
   workflowManifest: WorkflowManifest;
@@ -78,7 +92,12 @@ export async function applySwcTransform(
       target: 'es2022',
       experimental: mode
         ? {
-            plugins: [[require.resolve('@workflow/swc-plugin'), { mode }]],
+            plugins: [
+              [
+                require.resolve('@workflow/swc-plugin'),
+                { mode, workflowManifest },
+              ],
+            ],
           }
         : undefined,
       ...jscConfig,

packages/builders/src/apply-swc-transform.ts

@@ -26,6 +26,7 @@ const EMIT_SOURCEMAPS_FOR_DEBUGGING =
  */
 export abstract class BaseBuilder {
   protected config: WorkflowConfig;
+  protected lastWorkflowManifest?: WorkflowManifest;
 
   constructor(config: WorkflowConfig) {
     this.config = config;
@@ -253,6 +254,7 @@ export abstract class BaseBuilder {
    * Steps have full Node.js runtime access and handle side effects, API calls, etc.
    *
    * @param externalizeNonSteps - If true, only bundles step entry points and externalizes other code
+   * @returns Build context (for watch mode) and the collected workflow manifest
    */
   protected async createStepsBundle({
     inputFiles,
@@ -268,7 +270,10 @@ export abstract class BaseBuilder {
     outfile: string;
     format?: 'cjs' | 'esm';
     externalizeNonSteps?: boolean;
-  }): Promise<esbuild.BuildContext | undefined> {
+  }): Promise<{
+    context: esbuild.BuildContext | undefined;
+    manifest: WorkflowManifest;
+  }> {
     // These need to handle watching for dev to scan for
     // new entries and changes to existing ones
     const { discoveredSteps: stepFiles } = await this.discoverEntries(
@@ -389,10 +394,14 @@ export abstract class BaseBuilder {
     // Create .gitignore in .swc directory
     await this.createSwcGitignore();
 
+    // Store the manifest for later use (e.g., graph generation in watch mode)
+    this.lastWorkflowManifest = workflowManifest;
+
     if (this.config.watch) {
-      return esbuildCtx;
+      return { context: esbuildCtx, manifest: workflowManifest };
     }
     await esbuildCtx.dispose();
+    return { context: undefined, manifest: workflowManifest };
   }
 
   /**
@@ -848,11 +857,13 @@ export const OPTIONS = handler;`;
     outfile,
     tsBaseUrl,
     tsPaths,
+    workflowManifest,
   }: {
     inputFiles: string[];
     outfile: string;
     tsBaseUrl?: string;
     tsPaths?: Record<string, string[]>;
+    workflowManifest?: WorkflowManifest;
   }): Promise<void> {
     const graphBuildStart = Date.now();
     console.log('Creating workflow graph manifest...');
@@ -867,6 +878,9 @@ export const OPTIONS = handler;`;
       return;
     }
 
+    // Use provided manifest or fall back to last built manifest
+    const manifest = workflowManifest || this.lastWorkflowManifest;
+
     // Import applySwcTransform dynamically
     const { applySwcTransform } = await import('./apply-swc-transform.js');
 
@@ -896,7 +910,8 @@ export const OPTIONS = handler;`;
           {
             paths: tsPaths,
             baseUrl: tsBaseUrl,
-          }
+          },
+          manifest
         );
 
         if (graphManifest && graphManifest.workflows) {
@@ -905,6 +920,11 @@ export const OPTIONS = handler;`;
             combinedGraphManifest.workflows,
             graphManifest.workflows
           );
+
+          // Preserve debug info from the first workflow file (for debugging)
+          if (graphManifest.debugInfo && !combinedGraphManifest.debugInfo) {
+            combinedGraphManifest.debugInfo = graphManifest.debugInfo;
+          }
         }
       } catch (error) {
         console.warn(

packages/builders/src/base-builder.ts

@@ -10,10 +10,10 @@ export class StandaloneBuilder extends BaseBuilder {
       tsBaseUrl: tsConfig.baseUrl,
       tsPaths: tsConfig.paths,
     };
-    await this.buildStepsBundle(options);
+    const workflowManifest = await this.buildStepsBundle(options);
     await this.buildWorkflowsBundle(options);
     await this.buildWebhookFunction();
-    await this.buildGraphManifest(options);
+    await this.buildGraphManifest({ ...options, workflowManifest });
 
     await this.createClientLibrary();
   }
@@ -26,18 +26,20 @@ export class StandaloneBuilder extends BaseBuilder {
     inputFiles: string[];
     tsBaseUrl?: string;
     tsPaths?: Record<string, string[]>;
-  }): Promise<void> {
+  }) {
     console.log('Creating steps bundle at', this.config.stepsBundlePath);
 
     const stepsBundlePath = this.resolvePath(this.config.stepsBundlePath);
     await this.ensureDirectory(stepsBundlePath);
 
-    await this.createStepsBundle({
+    const { manifest } = await this.createStepsBundle({
       outfile: stepsBundlePath,
       inputFiles,
       tsBaseUrl,
       tsPaths,
     });
+
+    return manifest;
   }
 
   private async buildWorkflowsBundle({
@@ -82,10 +84,12 @@ export class StandaloneBuilder extends BaseBuilder {
     inputFiles,
     tsPaths,
     tsBaseUrl,
+    workflowManifest,
   }: {
     inputFiles: string[];
     tsBaseUrl?: string;
     tsPaths?: Record<string, string[]>;
+    workflowManifest?: import('./apply-swc-transform.js').WorkflowManifest;
   }): Promise<void> {
     const graphManifestPath = this.resolvePath('.swc/graph-manifest.json');
     await this.ensureDirectory(graphManifestPath);
@@ -95,6 +99,7 @@ export class StandaloneBuilder extends BaseBuilder {
       outfile: graphManifestPath,
       tsBaseUrl,
       tsPaths,
+      workflowManifest,
     });
   }
 }

packages/builders/src/standalone.ts

@@ -43,7 +43,8 @@ export async function getNextBuilder() {
         tsPaths: tsConfig.paths,
       };
 
-      const stepsBuildContext = await this.buildStepsFunction(options);
+      const { context: stepsBuildContext, manifest: workflowManifest } =
+        await this.buildStepsFunction(options);
       const workflowsBundle = await this.buildWorkflowsFunction(options);
       await this.buildWebhookRoute({ workflowGeneratedDir });
 
@@ -58,6 +59,7 @@ export async function getNextBuilder() {
         outfile: join(workflowDataDir, 'graph-manifest.json'),
         tsBaseUrl: options.tsBaseUrl,
         tsPaths: options.tsPaths,
+        workflowManifest,
       });
 
       await this.writeFunctionsConfig(outputDir);
@@ -164,7 +166,8 @@ export async function getNextBuilder() {
           options.inputFiles = newInputFiles;
 
           await stepsCtx.dispose();
-          const newStepsCtx = await this.buildStepsFunction(options);
+          const { context: newStepsCtx } =
+            await this.buildStepsFunction(options);
           if (!newStepsCtx) {
             throw new Error(
               'Invariant: expected steps build context after rebuild'

packages/next/src/builder.ts

@@ -9,9 +9,11 @@ use swc_core::{
 use swc_workflow::{StepTransform, TransformMode};
 
 #[derive(Deserialize)]
-#[serde(rename_all = "camelCase", deny_unknown_fields)]
+#[serde(rename_all = "camelCase")]
 struct WasmConfig {
     mode: TransformMode,
+    #[serde(default)]
+    workflow_manifest: Option<swc_workflow::WorkflowManifest>,
 }
 
 #[plugin_transform]
@@ -26,30 +28,33 @@ pub fn process_transform(
     )
     .expect("Should provide plugin config");
 
-    let filename = metadata.get_context(&swc_core::plugin::metadata::TransformPluginMetadataContextKind::Filename)
+    let filename = metadata
+        .get_context(&swc_core::plugin::metadata::TransformPluginMetadataContextKind::Filename)
         .unwrap_or_else(|| "unknown".to_string());
-    
+
     // Try to get cwd and make the path relative
-    let cwd = metadata.get_context(&swc_core::plugin::metadata::TransformPluginMetadataContextKind::Cwd);
-    
+    let cwd =
+        metadata.get_context(&swc_core::plugin::metadata::TransformPluginMetadataContextKind::Cwd);
+
     let relative_filename = if let Some(cwd) = cwd {
         let cwd_path = Path::new(&cwd);
         let file_path = Path::new(&filename);
-        
+
         // Try to strip the cwd prefix to make it relative
         if let Ok(relative) = file_path.strip_prefix(cwd_path) {
             relative.to_string_lossy().to_string()
         } else {
             // Find common ancestor path
             let cwd_components: Vec<_> = cwd_path.components().collect();
             let file_components: Vec<_> = file_path.components().collect();
-            
+
             // Find the longest common prefix
-            let common_len = cwd_components.iter()
+            let common_len = cwd_components
+                .iter()
                 .zip(file_components.iter())
                 .take_while(|(a, b)| a == b)
                 .count();
-            
+
             if common_len > 0 {
                 // Build relative path from the common ancestor
                 let remaining_file: Vec<_> = file_components.into_iter().skip(common_len).collect();
@@ -62,11 +67,15 @@ pub fn process_transform(
     } else {
         filename
     };
-    
+
     // Normalize path separators to forward slashes for consistent workflow IDs across platforms
     let normalized_filename = relative_filename.replace('\\', "/");
-    
-    let mut visitor = StepTransform::new(plugin_config.mode, normalized_filename);
+
+    let mut visitor = StepTransform::new(
+        plugin_config.mode,
+        normalized_filename,
+        plugin_config.workflow_manifest,
+    );
     program.visit_mut_with(&mut visitor);
     program
 }

packages/swc-plugin-workflow/src/lib.rs

@@ -13,7 +13,7 @@ version      = "0.1.0"
 [dependencies]
 serde       = { workspace = true }
 serde_json  = { workspace = true }
-swc_core    = { workspace = true, features = ["ecma_plugin_transform"] }
+swc_core    = { workspace = true, features = ["ecma_plugin_transform", "ecma_parser"] }
 
 [dev-dependencies]
 testing     = { workspace = true }