converter fixes

Author: clavery

packages/b2c-cli/src/commands/pipeline/convert.ts

@@ -13,10 +13,17 @@ import {convertPipeline, type ConvertResult} from '@salesforce/b2c-tooling-sdk/o
 import {glob} from 'glob';
 import {t} from '../../i18n/index.js';
 
+interface ConvertError {
+  pipelineName: string;
+  error: string;
+}
+
 interface ConvertResponse {
   results: ConvertResult[];
+  errors: ConvertError[];
   totalPipelines: number;
   successCount: number;
+  failureCount: number;
   warningCount: number;
 }
 
@@ -78,8 +85,10 @@ export default class PipelineConvert extends BaseCommand<typeof PipelineConvert>
 
     const response: ConvertResponse = {
       results: conversionResults.results,
+      errors: conversionResults.errors,
       totalPipelines: inputFiles.length,
       successCount: conversionResults.successCount,
+      failureCount: conversionResults.failureCount,
       warningCount: conversionResults.warningCount,
     };
 
@@ -89,12 +98,26 @@ export default class PipelineConvert extends BaseCommand<typeof PipelineConvert>
 
     if (!dryRun) {
       this.log('');
-      this.log(
-        t('commands.pipeline.convert.summary', 'Converted {{count}} pipeline(s) with {{warnings}} warning(s)', {
-          count: conversionResults.successCount,
-          warnings: conversionResults.warningCount,
-        }),
-      );
+      if (conversionResults.failureCount > 0) {
+        this.log(
+          t(
+            'commands.pipeline.convert.summaryWithFailures',
+            'Converted {{success}} pipeline(s), {{failures}} failed, {{warnings}} warning(s)',
+            {
+              success: conversionResults.successCount,
+              failures: conversionResults.failureCount,
+              warnings: conversionResults.warningCount,
+            },
+          ),
+        );
+      } else {
+        this.log(
+          t('commands.pipeline.convert.summary', 'Converted {{count}} pipeline(s) with {{warnings}} warning(s)', {
+            count: conversionResults.successCount,
+            warnings: conversionResults.warningCount,
+          }),
+        );
+      }
     }
 
     return response;
@@ -107,7 +130,7 @@ export default class PipelineConvert extends BaseCommand<typeof PipelineConvert>
     inputFile: string,
     output: string | undefined,
     dryRun: boolean,
-  ): Promise<{result: ConvertResult; success: boolean}> {
+  ): Promise<{result?: ConvertResult; success: boolean; error?: ConvertError}> {
     const pipelineName = basename(inputFile, '.xml');
 
     if (!dryRun) {
@@ -125,37 +148,52 @@ export default class PipelineConvert extends BaseCommand<typeof PipelineConvert>
         ? join(output, `${pipelineName}.js`)
         : join(dirname(inputFile), `${pipelineName}.js`);
 
-    const result = await this.operations.convertPipeline(inputFile, {
-      outputPath,
-      dryRun,
-    });
+    try {
+      const result = await this.operations.convertPipeline(inputFile, {
+        outputPath,
+        dryRun,
+      });
 
-    if (result.warnings.length > 0) {
-      for (const warning of result.warnings) {
-        this.warn(warning);
+      if (result.warnings.length > 0) {
+        for (const warning of result.warnings) {
+          this.warn(warning);
+        }
       }
-    }
 
-    let success = false;
-    if (dryRun) {
-      // In dry-run mode, output the generated code
-      if (!this.jsonEnabled()) {
-        ux.stdout(`\n// === ${pipelineName}.js ===\n`);
-        ux.stdout(result.code);
-        ux.stdout('\n');
+      let success = false;
+      if (dryRun) {
+        // In dry-run mode, output the generated code
+        if (!this.jsonEnabled()) {
+          ux.stdout(`\n// === ${pipelineName}.js ===\n`);
+          ux.stdout(result.code);
+          ux.stdout('\n');
+        }
+        success = true;
+      } else if (outputPath) {
+        // Write the file
+        await writeFile(outputPath, result.code, 'utf8');
+        this.log(
+          t('commands.pipeline.convert.generated', 'Generated: {{path}}', {
+            path: outputPath,
+          }),
+        );
+        success = true;
       }
-    } else if (outputPath) {
-      // Write the file
-      await writeFile(outputPath, result.code, 'utf8');
-      this.log(
-        t('commands.pipeline.convert.generated', 'Generated: {{path}}', {
-          path: outputPath,
+
+      return {result, success};
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      this.logToStderr(
+        t('commands.pipeline.convert.failed', 'Failed to convert {{name}}: {{error}}', {
+          name: pipelineName,
+          error: errorMessage,
         }),
       );
-      success = true;
+      return {
+        success: false,
+        error: {pipelineName, error: errorMessage},
+      };
     }
-
-    return {result, success};
   }
 
   /**
@@ -165,21 +203,37 @@ export default class PipelineConvert extends BaseCommand<typeof PipelineConvert>
     inputFiles: string[],
     output: string | undefined,
     dryRun: boolean,
-  ): Promise<{results: ConvertResult[]; successCount: number; warningCount: number}> {
+  ): Promise<{
+    results: ConvertResult[];
+    errors: ConvertError[];
+    successCount: number;
+    failureCount: number;
+    warningCount: number;
+  }> {
     const results: ConvertResult[] = [];
+    const errors: ConvertError[] = [];
     let successCount = 0;
+    let failureCount = 0;
     let warningCount = 0;
 
     // Process files sequentially to maintain order and avoid concurrent file operations
     for (const inputFile of inputFiles) {
       // eslint-disable-next-line no-await-in-loop
       const fileResult = await this.processFile(inputFile, output, dryRun);
-      results.push(fileResult.result);
-      successCount += fileResult.success ? 1 : 0;
-      warningCount += fileResult.result.warnings.length;
+      if (fileResult.result) {
+        results.push(fileResult.result);
+        warningCount += fileResult.result.warnings.length;
+      }
+      if (fileResult.error) {
+        errors.push(fileResult.error);
+        failureCount++;
+      }
+      if (fileResult.success) {
+        successCount++;
+      }
     }
 
-    return {results, successCount, warningCount};
+    return {results, errors, successCount, failureCount, warningCount};
   }
 
   /**

packages/b2c-tooling-sdk/src/operations/pipeline/analyzer.ts

@@ -43,6 +43,8 @@ interface AnalysisContext {
   requiredImports: Set<string>;
   /** Warnings accumulated during analysis. */
   warnings: string[];
+  /** Stop node ID - analysis stops when reaching this node (for branch convergence). */
+  stopAtNodeId?: string;
 }
 
 /**
@@ -119,6 +121,11 @@ function analyzeFromNode(nodeId: string, context: AnalysisContext): ControlFlowB
   let currentId: string | undefined = nodeId;
 
   while (currentId) {
+    // Stop if we've reached the convergence point
+    if (context.stopAtNodeId && currentId === context.stopAtNodeId) {
+      break;
+    }
+
     // Cycle detection
     if (context.visited.has(currentId)) {
       context.warnings.push(`Cycle detected at node ${currentId}`);
@@ -208,18 +215,21 @@ function analyzeDecisionNode(node: DecisionNodeIR, context: AnalysisContext): If
   const yesTransition = node.transitions.find((t) => t.connector === 'yes');
   const noTransition = node.transitions.find((t) => t.connector === 'no');
 
+  // Find convergence point to limit branch analysis
+  const convergencePoint = findConvergencePoint(node, context);
+
   let thenBlock: ControlFlowBlock = {type: 'sequence', blocks: []};
   let elseBlock: ControlFlowBlock | undefined;
 
   if (yesTransition) {
-    const branchContext = createBranchContext(context);
+    const branchContext = createBranchContext(context, convergencePoint);
     thenBlock = analyzeFromNode(yesTransition.targetId, branchContext);
     context.warnings.push(...branchContext.warnings);
     mergeImports(context, branchContext);
   }
 
   if (noTransition) {
-    const branchContext = createBranchContext(context);
+    const branchContext = createBranchContext(context, convergencePoint);
     elseBlock = analyzeFromNode(noTransition.targetId, branchContext);
     context.warnings.push(...branchContext.warnings);
     mergeImports(context, branchContext);
@@ -296,20 +306,24 @@ function analyzePipeletWithError(node: PipeletNodeIR, context: AnalysisContext):
   const errorTransition = node.transitions.find((t) => t.connector === 'error');
   const successTransition = node.transitions.find((t) => !t.connector || t.connector === 'next');
 
-  // Try block: the pipelet + success path
+  // Find convergence point to limit branch analysis
+  const convergencePoint = findConvergencePoint(node, context);
+
+  // Try block: the pipelet only (success path analyzed separately after try-catch)
   const tryBlocks: ControlFlowBlock[] = [createStatement(node.id)];
-  if (successTransition) {
-    const successContext = createBranchContext(context);
+  if (successTransition && convergencePoint) {
+    // Only analyze the success path up to convergence point
+    const successContext = createBranchContext(context, convergencePoint);
     const successBlock = analyzeFromNode(successTransition.targetId, successContext);
     tryBlocks.push(successBlock);
     context.warnings.push(...successContext.warnings);
     mergeImports(context, successContext);
   }
 
-  // Catch block: error path
+  // Catch block: error path up to convergence point
   let catchBlock: ControlFlowBlock = {type: 'sequence', blocks: []};
   if (errorTransition) {
-    const errorContext = createBranchContext(context);
+    const errorContext = createBranchContext(context, convergencePoint);
     catchBlock = analyzeFromNode(errorTransition.targetId, errorContext);
     context.warnings.push(...errorContext.warnings);
     mergeImports(context, errorContext);
@@ -356,12 +370,13 @@ function buildInteractionContinueHandler(node: InteractionContinueNodeIR, contex
 /**
  * Creates a branch context for analyzing nested control flow.
  */
-function createBranchContext(parent: AnalysisContext): AnalysisContext {
+function createBranchContext(parent: AnalysisContext, stopAtNodeId?: string): AnalysisContext {
   return {
     pipeline: parent.pipeline,
     visited: new Set(parent.visited),
     requiredImports: new Set(),
     warnings: [],
+    stopAtNodeId,
   };
 }
 

packages/b2c-tooling-sdk/src/operations/pipeline/generator/nodes.ts

@@ -179,6 +179,11 @@ function generateEndNode(node: EndNodeIR, context: GeneratorContext): string {
 function generateCallNode(node: CallNodeIR, context: GeneratorContext): string {
   const ind = indent(context.indent);
 
+  // Dynamic dispatch - target determined at runtime from site preference
+  if (node.isDynamic && node.dynamicKey) {
+    return `${ind}// TODO: Dynamic pipeline call - target resolved from key: ${node.dynamicKey}\n${ind}// Original: call-node start-name-key="${node.dynamicKey}"`;
+  }
+
   if (node.pipelineName === context.pipelineName) {
     // Same pipeline - direct function call
     return `${ind}${node.startName}();`;
@@ -194,6 +199,11 @@ function generateCallNode(node: CallNodeIR, context: GeneratorContext): string {
 function generateJumpNode(node: JumpNodeIR, context: GeneratorContext): string {
   const ind = indent(context.indent);
 
+  // Dynamic dispatch - target determined at runtime from site preference
+  if (node.isDynamic && node.dynamicKey) {
+    return `${ind}// TODO: Dynamic pipeline jump - target resolved from key: ${node.dynamicKey}\n${ind}// Original: jump-node start-name-key="${node.dynamicKey}"`;
+  }
+
   // Convert Pipeline-Start to Controller-Action URL
   return `${ind}response.redirect(URLUtils.url('${node.pipelineName}-${node.startName}'));`;
 }

packages/b2c-tooling-sdk/src/operations/pipeline/index.ts

@@ -54,7 +54,50 @@ import {basename} from 'path';
 import {analyzePipeline} from './analyzer.js';
 import {generateController} from './generator/index.js';
 import {parsePipeline} from './parser.js';
-import type {ConvertOptions, ConvertResult} from './types.js';
+import {getUnconvertablePipelet} from './pipelets/index.js';
+import type {ConvertOptions, ConvertResult, PipelineIR, PipeletNodeIR} from './types.js';
+
+/**
+ * Error thrown when a pipeline contains unconvertable pipelets.
+ */
+export class UnconvertablePipelineError extends Error {
+  constructor(
+    public readonly pipelineName: string,
+    public readonly unconvertablePipelets: Array<{name: string; reason: string}>,
+  ) {
+    const pipeletList = unconvertablePipelets.map((p) => `  - ${p.name}: ${p.reason}`).join('\n');
+    super(`Pipeline "${pipelineName}" contains unconvertable pipelets:\n${pipeletList}`);
+    this.name = 'UnconvertablePipelineError';
+  }
+}
+
+/**
+ * Validates a pipeline for unconvertable pipelets.
+ * @throws UnconvertablePipelineError if any unconvertable pipelets are found
+ */
+function validatePipeline(pipeline: PipelineIR): void {
+  const unconvertable: Array<{name: string; reason: string}> = [];
+
+  for (const node of pipeline.nodes.values()) {
+    if (node.type === 'pipelet') {
+      const pipeletNode = node as PipeletNodeIR;
+      const info = getUnconvertablePipelet(pipeletNode.pipeletName);
+      if (info) {
+        // Only add if not already in the list
+        if (!unconvertable.some((p) => p.name === pipeletNode.pipeletName)) {
+          unconvertable.push({
+            name: pipeletNode.pipeletName,
+            reason: info.unconvertableReason ?? 'No script API equivalent',
+          });
+        }
+      }
+    }
+  }
+
+  if (unconvertable.length > 0) {
+    throw new UnconvertablePipelineError(pipeline.name, unconvertable);
+  }
+}
 
 // Re-export all types
 export type {
@@ -91,7 +134,14 @@ export {analyzePipeline} from './analyzer.js';
 export {generateController} from './generator/index.js';
 
 // Re-export pipelet utilities
-export {getPipeletMapping, isPipeletMapped, PIPELET_MAPPINGS} from './pipelets/index.js';
+export {
+  getPipeletMapping,
+  getUnconvertablePipelet,
+  isPipeletMapped,
+  isUnconvertablePipelet,
+  PIPELET_MAPPINGS,
+  UNCONVERTABLE_PIPELETS,
+} from './pipelets/index.js';
 export type {PipeletMapping} from './pipelets/index.js';
 
 /**
@@ -122,6 +172,9 @@ export async function convertPipeline(inputPath: string, options: ConvertOptions
   // Parse
   const pipeline = await parsePipeline(xml, pipelineName);
 
+  // Validate for unconvertable pipelets
+  validatePipeline(pipeline);
+
   // Analyze
   const analysis = analyzePipeline(pipeline);
 
@@ -161,6 +214,7 @@ export async function convertPipeline(inputPath: string, options: ConvertOptions
  */
 export async function convertPipelineContent(xml: string, pipelineName: string): Promise<ConvertResult> {
   const pipeline = await parsePipeline(xml, pipelineName);
+  validatePipeline(pipeline);
   const analysis = analyzePipeline(pipeline);
   const code = generateController(pipeline, analysis);