@outputai/core 0.10.0 → 0.10.1-dev.b7b2fbe.0

package/src/worker/webpack_loaders/workflow_rewriter/collect_target_imports.spec.js

@@ -5,327 +5,130 @@ import { join } from 'node:path';
 import { parse } from '../tools.js';
 import collectTargetImports from './collect_target_imports.js';
 
-function makeAst( source, filename ) {
-  return parse( source, filename );
-}
+const caches = () => ( {
+  stepsNameCache: new Map(),
+  evaluatorsNameCache: new Map(),
+  sharedStepsNameCache: new Map(),
+  sharedEvaluatorsNameCache: new Map()
+} );
+
+const makeAst = ( source, filename ) => parse( source, filename );
 
 describe( 'collect_target_imports', () => {
-  it( 'collects ESM imports for steps and evaluators and leaves workflow imports intact', () => {
+  it( 'collects ESM activity imports and leaves workflow imports intact', () => {
     const dir = mkdtempSync( join( tmpdir(), 'collect-esm-' ) );
-    writeFileSync( join( dir, 'steps.js' ), `
-export const StepA = step({ name: 'step.a' });
-export const StepB = step({ name: 'step.b' });` );
+    writeFileSync( join( dir, 'steps.js' ), 'export const StepA = step({ name: \'step.a\' });' );
     writeFileSync( join( dir, 'evaluators.js' ), 'export const EvalA = evaluator({ name: \'eval.a\' });' );
-    writeFileSync( join( dir, 'workflow.js' ), `
-export const FlowA = workflow({ name: 'flow.a' });
-export default workflow({ name: 'flow.def' });` );
+    writeFileSync( join( dir, 'workflow.js' ), 'export const FlowA = workflow({ name: \'flow.a\' });' );
 
-    const source = `
+    const ast = makeAst( `
 import { StepA } from './steps.js';
 import { EvalA } from './evaluators.js';
-import WF, { FlowA } from './workflow.js';
-const x = 1;`;
+import { FlowA } from './workflow.js';`, join( dir, 'file.js' ) );
 
-    const ast = makeAst( source, join( dir, 'file.js' ) );
-    const { stepImports, evaluatorImports } = collectTargetImports(
-      ast,
-      dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map() }
-    );
-    expect( evaluatorImports ).toEqual( [ { localName: 'EvalA', evaluatorName: 'eval.a' } ] );
+    const { activityImports } = collectTargetImports( ast, dir, caches() );
 
-    expect( stepImports ).toEqual( [ { localName: 'StepA', stepName: 'step.a' } ] );
+    expect( activityImports ).toEqual( [
+      { localName: 'StepA', activityName: 'step.a' },
+      { localName: 'EvalA', activityName: 'eval.a' }
+    ] );
     expect( ast.program.body.find( n => n.type === 'ImportDeclaration' )?.source.value ).toBe( './workflow.js' );
-
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'collects CJS requires for steps and evaluators and leaves workflow requires intact', () => {
+  it( 'collects CJS activity requires and leaves workflow requires intact', () => {
     const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-' ) );
-    writeFileSync( join( dir, 'steps.js' ), 'export const StepB = step({ name: \'step.b\' })' );
-    writeFileSync( join( dir, 'evaluators.js' ), 'export const EvalB = evaluator({ name: \'eval.b\' })' );
-    writeFileSync( join( dir, 'workflow.js' ), 'export default workflow({ name: \'flow.c\' })' );
-
-    const source = `
-const { StepB } = require( './steps.js' );
-const { EvalB } = require( './evaluators.js' );
-const WF = require( './workflow.js' );
-const obj = {};`;
-
-    const ast = makeAst( source, join( dir, 'file.js' ) );
-    const { stepImports, evaluatorImports } = collectTargetImports(
-      ast,
-      dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map() }
-    );
-    expect( evaluatorImports ).toEqual( [ { localName: 'EvalB', evaluatorName: 'eval.b' } ] );
-
-    expect( stepImports ).toEqual( [ { localName: 'StepB', stepName: 'step.b' } ] );
-    // Only non-target require declarators should remain.
-    const hasRequireDecl = ast.program.body.some( n =>
-      n.type === 'VariableDeclaration' && n.declarations.some( d => d.init && d.init.type === 'CallExpression' )
-    );
-    expect( hasRequireDecl ).toBe( true );
-
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'resolves ESM import from evaluators.js regardless of callee name', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-esm-mismatch-eval-' ) );
-    writeFileSync( join( dir, 'evaluators.js' ), 'export const MyExport = step({ name: \'bad\' });' );
-
-    const source = 'import { MyExport } from \'./evaluators.js\';';
-    const ast = makeAst( source, join( dir, 'file.js' ) );
-
-    const { evaluatorImports } = collectTargetImports(
-      ast,
-      dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map() }
-    );
-    expect( evaluatorImports ).toEqual( [ { localName: 'MyExport', evaluatorName: 'bad' } ] );
-
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'resolves ESM import from steps.js regardless of callee name', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-esm-mismatch-step-' ) );
-    writeFileSync( join( dir, 'steps.js' ), 'export const MyExport = evaluator({ name: \'bad\' });' );
-
-    const source = 'import { MyExport } from \'./steps.js\';';
-    const ast = makeAst( source, join( dir, 'file.js' ) );
-
-    const { stepImports } = collectTargetImports(
-      ast,
-      dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map() }
-    );
-    expect( stepImports ).toEqual( [ { localName: 'MyExport', stepName: 'bad' } ] );
-
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'resolves CJS require from evaluators.js regardless of callee name', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-mismatch-eval-' ) );
-    writeFileSync( join( dir, 'evaluators.js' ), 'export const MyExport = step({ name: \'bad\' });' );
-
-    const source = 'const { MyExport } = require( \'./evaluators.js\' );';
-    const ast = makeAst( source, join( dir, 'file.js' ) );
-
-    const { evaluatorImports } = collectTargetImports(
-      ast,
-      dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map() }
-    );
-    expect( evaluatorImports ).toEqual( [ { localName: 'MyExport', evaluatorName: 'bad' } ] );
-
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'resolves CJS require from steps.js regardless of callee name', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-mismatch-step-' ) );
-    writeFileSync( join( dir, 'steps.js' ), 'export const MyExport = evaluator({ name: \'bad\' });' );
-
-    const source = 'const { MyExport } = require( \'./steps.js\' );';
-    const ast = makeAst( source, join( dir, 'file.js' ) );
-
-    const { stepImports } = collectTargetImports(
-      ast,
-      dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map() }
-    );
-    expect( stepImports ).toEqual( [ { localName: 'MyExport', stepName: 'bad' } ] );
-
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'leaves ESM imports from workflow.js alone', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-esm-mismatch-wf-' ) );
-    writeFileSync( join( dir, 'workflow.js' ), 'export const helper = () => 42;' );
-
-    const source = 'import { helper } from \'./workflow.js\';';
-    const ast = makeAst( source, join( dir, 'file.js' ) );
-
-    expect( () => collectTargetImports(
-      ast,
-      dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map() }
-    ) ).not.toThrow();
-    expect( ast.program.body.find( n => n.type === 'ImportDeclaration' )?.source.value ).toBe( './workflow.js' );
-
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'leaves CJS requires from workflow.js alone', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-mismatch-wf-' ) );
+    writeFileSync( join( dir, 'steps.js' ), 'export const StepB = step({ name: \'step.b\' });' );
+    writeFileSync( join( dir, 'evaluators.js' ), 'export const EvalB = evaluator({ name: \'eval.b\' });' );
     writeFileSync( join( dir, 'workflow.js' ), 'export const helper = () => 42;' );
 
-    const source = 'const { helper } = require( \'./workflow.js\' );';
-    const ast = makeAst( source, join( dir, 'file.js' ) );
-
-    expect( () => collectTargetImports(
-      ast,
-      dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map() }
-    ) ).not.toThrow();
-    expect( ast.program.body.some( n => n.type === 'VariableDeclaration' ) ).toBe( true );
-
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'does not collect CJS destructured require from workflow.js', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-wf-destruct-' ) );
-    writeFileSync( join( dir, 'workflow.js' ), 'export const FlowX = workflow({ name: \'flow.x\' });' );
+    const ast = makeAst( `
+const { StepB } = require('./steps.js');
+const { EvalB } = require('./evaluators.js');
+const { helper } = require('./workflow.js');`, join( dir, 'file.js' ) );
 
-    const source = 'const { FlowX } = require( \'./workflow.js\' );\nconst obj = {};';
-    const ast = makeAst( source, join( dir, 'file.js' ) );
+    const { activityImports } = collectTargetImports( ast, dir, caches() );
 
-    collectTargetImports(
-      ast,
-      dir,
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map() }
-    );
+    expect( activityImports ).toEqual( [
+      { localName: 'StepB', activityName: 'step.b' },
+      { localName: 'EvalB', activityName: 'eval.b' }
+    ] );
     expect( ast.program.body.some( n => n.type === 'VariableDeclaration' ) ).toBe( true );
-
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'collects ESM shared evaluator imports', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-esm-shared-eval-' ) );
-    mkdirSync( join( dir, 'shared', 'evaluators' ), { recursive: true } );
-    mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
-    writeFileSync(
-      join( dir, 'shared', 'evaluators', 'common.js' ),
-      'export const SharedEval = evaluator({ name: \'shared.eval\' });'
-    );
-
-    const source = 'import { SharedEval } from \'../../shared/evaluators/common.js\';';
-    const ast = makeAst( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
-
-    const { sharedEvaluatorImports } = collectTargetImports(
-      ast,
-      join( dir, 'workflows', 'my_workflow' ),
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map() }
-    );
-    expect( sharedEvaluatorImports ).toEqual( [ { localName: 'SharedEval', evaluatorName: 'shared.eval' } ] );
-
+  it( 'uses file path to choose component type instead of factory callee name', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-path-scoped-' ) );
+    writeFileSync( join( dir, 'steps.js' ), 'export const StepExport = evaluator({ name: \'from.steps\' });' );
+    writeFileSync( join( dir, 'evaluators.js' ), 'export const EvalExport = step({ name: \'from.evaluators\' });' );
+
+    const esmAst = makeAst( `
+import { StepExport } from './steps.js';
+import { EvalExport } from './evaluators.js';`, join( dir, 'esm.js' ) );
+    const cjsAst = makeAst( `
+const { StepExport } = require('./steps.js');
+const { EvalExport } = require('./evaluators.js');`, join( dir, 'cjs.js' ) );
+
+    expect( collectTargetImports( esmAst, dir, caches() ).activityImports ).toEqual( [
+      { localName: 'StepExport', activityName: 'from.steps' },
+      { localName: 'EvalExport', activityName: 'from.evaluators' }
+    ] );
+    expect( collectTargetImports( cjsAst, dir, caches() ).activityImports ).toEqual( [
+      { localName: 'StepExport', activityName: 'from.steps' },
+      { localName: 'EvalExport', activityName: 'from.evaluators' }
+    ] );
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'collects CJS shared evaluator requires', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-shared-eval-' ) );
+  it( 'collects shared steps and evaluators from ESM and CJS imports', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-shared-' ) );
+    mkdirSync( join( dir, 'shared', 'steps' ), { recursive: true } );
     mkdirSync( join( dir, 'shared', 'evaluators' ), { recursive: true } );
     mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
+    writeFileSync( join( dir, 'shared', 'steps', 'common.js' ), 'export const SharedStep = step({ name: \'shared.step\' });' );
     writeFileSync(
       join( dir, 'shared', 'evaluators', 'common.js' ),
       'export const SharedEval = evaluator({ name: \'shared.eval\' });'
     );
 
-    const source = 'const { SharedEval } = require( \'../../shared/evaluators/common.js\' );';
-    const ast = makeAst( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
-
-    const { sharedEvaluatorImports } = collectTargetImports(
-      ast,
-      join( dir, 'workflows', 'my_workflow' ),
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map() }
-    );
-    expect( sharedEvaluatorImports ).toEqual( [ { localName: 'SharedEval', evaluatorName: 'shared.eval' } ] );
-
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'collects CJS shared steps requires', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-shared-step-' ) );
-    mkdirSync( join( dir, 'shared', 'steps' ), { recursive: true } );
-    mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
-    writeFileSync(
-      join( dir, 'shared', 'steps', 'common.js' ),
-      'export const SharedA = step({ name: \'shared.a\' });'
-    );
-
-    const source = 'const { SharedA } = require( \'../../shared/steps/common.js\' );';
-    const ast = makeAst( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
-
-    const { sharedStepImports } = collectTargetImports(
-      ast,
-      join( dir, 'workflows', 'my_workflow' ),
-      {
-        stepsNameCache: new Map(), sharedStepsNameCache: new Map(),
-        evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map()
-      }
-    );
-    expect( sharedStepImports ).toEqual( [ { localName: 'SharedA', stepName: 'shared.a' } ] );
-
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'resolves CJS shared steps require regardless of callee name', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-shared-step-mismatch-' ) );
-    mkdirSync( join( dir, 'shared', 'steps' ), { recursive: true } );
-    mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
-    writeFileSync(
-      join( dir, 'shared', 'steps', 'common.js' ),
-      'export const MyExport = evaluator({ name: \'bad\' });'
-    );
-
-    const source = 'const { MyExport } = require( \'../../shared/steps/common.js\' );';
-    const ast = makeAst( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
-
-    const { sharedStepImports } = collectTargetImports(
-      ast,
-      join( dir, 'workflows', 'my_workflow' ),
-      {
-        stepsNameCache: new Map(), sharedStepsNameCache: new Map(),
-        evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map()
-      }
-    );
-    expect( sharedStepImports ).toEqual( [ { localName: 'MyExport', stepName: 'bad' } ] );
-
+    const fileDir = join( dir, 'workflows', 'my_workflow' );
+    const esmAst = makeAst( `
+import { SharedStep } from '../../shared/steps/common.js';
+import { SharedEval } from '../../shared/evaluators/common.js';`, join( fileDir, 'workflow.js' ) );
+    const cjsAst = makeAst( `
+const { SharedStep } = require('../../shared/steps/common.js');
+const { SharedEval } = require('../../shared/evaluators/common.js');`, join( fileDir, 'helper.js' ) );
+
+    expect( collectTargetImports( esmAst, fileDir, caches() ).activityImports ).toEqual( [
+      { localName: 'SharedStep', activityName: 'shared.step' },
+      { localName: 'SharedEval', activityName: 'shared.eval' }
+    ] );
+    expect( collectTargetImports( cjsAst, fileDir, caches() ).activityImports ).toEqual( [
+      { localName: 'SharedStep', activityName: 'shared.step' },
+      { localName: 'SharedEval', activityName: 'shared.eval' }
+    ] );
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'resolves CJS shared evaluator require regardless of callee name', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-shared-eval-mismatch-' ) );
-    mkdirSync( join( dir, 'shared', 'evaluators' ), { recursive: true } );
-    mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
-    writeFileSync(
-      join( dir, 'shared', 'evaluators', 'common.js' ),
-      'export const MyExport = step({ name: \'bad\' });'
-    );
-
-    const source = 'const { MyExport } = require( \'../../shared/evaluators/common.js\' );';
-    const ast = makeAst( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
+  it( 'leaves destructured workflow requires untouched', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-workflow-require-' ) );
+    writeFileSync( join( dir, 'workflow.js' ), 'export const FlowX = workflow({ name: \'flow.x\' });' );
 
-    const { sharedEvaluatorImports } = collectTargetImports(
-      ast,
-      join( dir, 'workflows', 'my_workflow' ),
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map() }
-    );
-    expect( sharedEvaluatorImports ).toEqual( [ { localName: 'MyExport', evaluatorName: 'bad' } ] );
+    const ast = makeAst( 'const { FlowX } = require(\'./workflow.js\');', join( dir, 'file.js' ) );
+    const { activityImports } = collectTargetImports( ast, dir, caches() );
 
+    expect( activityImports ).toEqual( [] );
+    expect( ast.program.body.some( n => n.type === 'VariableDeclaration' ) ).toBe( true );
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'resolves ESM shared evaluator import regardless of callee name', () => {
-    const dir = mkdtempSync( join( tmpdir(), 'collect-esm-shared-eval-mismatch-' ) );
-    mkdirSync( join( dir, 'shared', 'evaluators' ), { recursive: true } );
-    mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
-    writeFileSync(
-      join( dir, 'shared', 'evaluators', 'common.js' ),
-      'export const MyExport = step({ name: \'bad\' });'
-    );
-
-    const source = 'import { MyExport } from \'../../shared/evaluators/common.js\';';
-    const ast = makeAst( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
+  it( 'throws when a named activity import cannot be resolved from the target file', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-unresolved-' ) );
+    writeFileSync( join( dir, 'steps.js' ), 'export const StepA = step({ name: \'step.a\' });' );
 
-    const { sharedEvaluatorImports } = collectTargetImports(
-      ast,
-      join( dir, 'workflows', 'my_workflow' ),
-      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), sharedEvaluatorsNameCache: new Map() }
-    );
-    expect( sharedEvaluatorImports ).toEqual( [ { localName: 'MyExport', evaluatorName: 'bad' } ] );
+    const ast = makeAst( 'import { MissingStep } from \'./steps.js\';', join( dir, 'file.js' ) );
 
+    expect( () => collectTargetImports( ast, dir, caches() ) ).toThrow( /Unresolved import 'MissingStep'/ );
     rmSync( dir, { recursive: true, force: true } );
   } );
-
 } );
-

package/src/worker/webpack_loaders/workflow_rewriter/index.mjs

@@ -2,7 +2,7 @@ import { dirname } from 'node:path';
 import generatorModule from '@babel/generator';
 import { parse } from '../tools.js';
 
-import rewriteFnBodies from './rewrite_fn_bodies.js';
+import rewriteActivityCalls from './rewrite_activity_calls.js';
 import collectTargetImports from './collect_target_imports.js';
 
 // Handle CJS/ESM interop for Babel packages when executed as a webpack loader
@@ -15,8 +15,8 @@ const evaluatorsNameCache = new Map(); // path -> Map<exported, evaluatorName>
 const sharedEvaluatorsNameCache = new Map(); // path -> Map<exported, evaluatorName> (shared)
 
 /**
- * Webpack loader that rewrites step/evaluator calls by reading names from
- * the respective modules and transforming `fn` bodies accordingly.
+ * Webpack loader that rewrites imported step/evaluator calls by reading
+ * declared activity names and transforming function-body activity calls accordingly.
  * Preserves sourcemaps.
  *
  * @param {string|Buffer} source - Module source code.
@@ -33,15 +33,14 @@ export default function stepImportRewriterAstLoader( source, inputMap ) {
     const filename = this.resourcePath;
     const ast = parse( String( source ), filename );
     const fileDir = dirname( filename );
-    const { stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports } =
-      collectTargetImports( ast, fileDir, cache, filename );
+    const { activityImports } = collectTargetImports( ast, fileDir, cache );
 
     // No imports
-    if ( [].concat( stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports ).length === 0 ) {
+    if ( activityImports.length === 0 ) {
       return callback( null, source, inputMap );
     }
 
-    const rewrote = rewriteFnBodies( { ast, stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports } );
+    const rewrote = rewriteActivityCalls( { ast, activityImports } );
     // No edits performed
     if ( !rewrote ) {
       return callback( null, source, inputMap );