@outputai/core 0.10.0 → 0.10.1-next.09ed166.0

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

@@ -1,9 +1,18 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi } from 'vitest';
 import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import loader from './index.mjs';
 
+const { invokeActivitySymbolKey } = vi.hoisted( () => ( {
+  invokeActivitySymbolKey: 'test:invoke_activity'
+} ) );
+
+vi.mock( '#consts', async importOriginal => ( {
+  ...await importOriginal(),
+  INVOKE_ACTIVITY_SYMBOL: Symbol.for( invokeActivitySymbolKey )
+} ) );
+
 function runLoader( source, resourcePath ) {
   return new Promise( ( resolve, reject ) => {
     const ctx = {
@@ -16,8 +25,12 @@ function runLoader( source, resourcePath ) {
   } );
 }
 
+const escapeRegExp = value => value.replace( /[.*+?^${}()|[\]\\]/g, '\\$&' );
+const invokeActivityPattern = activityName =>
+  new RegExp( `globalThis\\[globalThis\\.Symbol\\.for\\(([\"'])${escapeRegExp( invokeActivitySymbolKey )}\\1\\)\\]\\('${activityName}'` );
+
 describe( 'workflows_rewriter Webpack loader spec', () => {
-  it( 'rewrites ESM step imports and leaves workflow calls intact', async () => {
+  it( 'rewrites ESM activity imports and leaves workflow imports intact', async () => {
     const dir = mkdtempSync( join( tmpdir(), 'ast-loader-esm-' ) );
     writeFileSync( join( dir, 'steps.js' ), 'export const StepA = step({ name: \'step.a\' });' );
     writeFileSync( join( dir, 'workflow.js' ), `
@@ -29,7 +42,7 @@ import { StepA } from './steps.js';
 import FlowDef, { FlowA } from './workflow.js';
 
 const obj = {
-  fn: async (x) => {
+  fn: async x => {
     StepA(1);
     FlowA(2);
     FlowDef(3);
@@ -40,65 +53,14 @@ const obj = {
 
     expect( code ).not.toMatch( /from '\.\/steps\.js'/ );
     expect( code ).toMatch( /from '\.\/workflow\.js'/ );
-    expect( code ).toMatch( /fn:\s*async function \(x\)/ );
-    expect( code ).toMatch( /this\.invokeStep\('step\.a',\s*1\)/ );
+    expect( code ).toMatch( invokeActivityPattern( 'step\\.a' ) );
+    expect( code ).toMatch( /,\s*1\)/ );
     expect( code ).toMatch( /FlowA\(2\)/ );
     expect( code ).toMatch( /FlowDef\(3\)/ );
-
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'rewrites ESM shared steps imports to invokeSharedStep', async () => {
-    // Create directory structure: shared/steps/common.js
-    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-esm-shared-' ) );
-    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 = `
-import { SharedA } from '../../shared/steps/common.js';
-
-const obj = {
-  fn: async (x) => {
-    SharedA(1);
-  }
-}`;
-
-    const { code } = await runLoader( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
-
-    expect( code ).not.toMatch( /from '\.\.\/\.\.\/shared\/steps\/common\.js'/ );
-    expect( code ).toMatch( /fn:\s*async function \(x\)/ );
-    expect( code ).toMatch( /this\.invokeSharedStep\('shared\.a',\s*1\)/ );
-
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'rewrites CJS shared steps requires to invokeSharedStep', async () => {
-    // Create directory structure: shared/steps/common.js
-    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-cjs-shared-' ) );
-    mkdirSync( join( dir, 'shared', 'steps' ), { recursive: true } );
-    mkdirSync( join( dir, 'workflows', 'my_workflow' ), { recursive: true } );
-    writeFileSync( join( dir, 'shared', 'steps', 'common.js' ), 'export const SharedB = step({ name: \'shared.b\' });' );
-
-    const source = `
-const { SharedB } = require( '../../shared/steps/common.js' );
-
-const obj = {
-  fn: async (y) => {
-    SharedB();
-  }
-}`;
-
-    const { code } = await runLoader( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
-
-    expect( code ).not.toMatch( /require\('\.\.\/\.\.\/shared\/steps\/common\.js'\)/ );
-    expect( code ).toMatch( /fn:\s*async function \(y\)/ );
-    expect( code ).toMatch( /this\.invokeSharedStep\('shared\.b'\)/ );
-
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'rewrites CJS step requires and leaves workflow calls intact', async () => {
+  it( 'rewrites CJS activity requires and leaves workflow requires intact', async () => {
     const dir = mkdtempSync( join( tmpdir(), 'ast-loader-cjs-' ) );
     writeFileSync( join( dir, 'steps.js' ), 'export const StepB = step({ name: \'step.b\' });' );
     writeFileSync( join( dir, 'workflow.js' ), 'export default workflow({ name: \'flow.c\' });' );
@@ -108,8 +70,8 @@ const { StepB } = require( './steps.js' );
 const FlowDefault = require( './workflow.js' );
 
 const obj = {
-  fn: async (y) => {
-    StepB();
+  fn: async y => {
+    StepB(y);
     FlowDefault();
   }
 }`;
@@ -118,97 +80,73 @@ const obj = {
 
     expect( code ).not.toMatch( /require\('\.\/steps\.js'\)/ );
     expect( code ).toMatch( /require\('\.\/workflow\.js'\)/ );
-    expect( code ).toMatch( /fn:\s*async function \(y\)/ );
-    expect( code ).toMatch( /this\.invokeStep\('step\.b'\)/ );
+    expect( code ).toMatch( invokeActivityPattern( 'step\\.b' ) );
+    expect( code ).toMatch( /,\s*y\)/ );
     expect( code ).toMatch( /FlowDefault\(\)/ );
-
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'resolves top-level const name variables', async () => {
-    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-const-' ) );
-    writeFileSync( join( dir, 'steps.js' ), `
-const NAME = 'step.const';
-export const StepC = step({ name: NAME });` );
-    writeFileSync( join( dir, 'workflow.js' ), `
-const WF = 'wf.const';
-export const FlowC = workflow({ name: WF });
-const D = 'wf.def';
-export default workflow({ name: D });` );
-
-    const source = `
-import { StepC } from './steps.js';
-import FlowDef, { FlowC } from './workflow.js';
-const obj = { fn: async () => { StepC(); FlowC(); FlowDef(); } }`;
-
-    const { code } = await runLoader( source, join( dir, 'file.js' ) );
-    expect( code ).toMatch( /this\.invokeStep\('step\.const'\)/ );
-    expect( code ).toMatch( /FlowC\(\)/ );
-    expect( code ).toMatch( /FlowDef\(\)/ );
-    rmSync( dir, { recursive: true, force: true } );
-  } );
-
-  it( 'rewrites ESM shared evaluator imports to invokeSharedEvaluator', async () => {
-    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-esm-shared-eval-' ) );
+  it( 'rewrites shared activity imports from helper modules', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-shared-helper-' ) );
     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\' });' );
+    writeFileSync(
+      join( dir, 'shared', 'evaluators', 'common.js' ),
+      'export const SharedEval = evaluator({ name: \'shared.eval\' });'
+    );
 
     const source = `
 import { SharedEval } from '../../shared/evaluators/common.js';
 
-const obj = {
-  fn: async (x) => {
-    SharedEval(1);
-  }
-}`;
-
-    const { code } = await runLoader( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
+export const helper = async value => SharedEval(value);`;
 
-    expect( code ).not.toMatch( /from '\.\.\/\.\.\/shared\/evaluators\/common\.js'/ );
-    expect( code ).toMatch( /fn:\s*async function \(x\)/ );
-    expect( code ).toMatch( /this\.invokeSharedEvaluator\('shared\.eval',\s*1\)/ );
+    const { code } = await runLoader( source, join( dir, 'workflows', 'my_workflow', 'helper.js' ) );
 
+    expect( code ).not.toMatch( /shared\/evaluators\/common\.js/ );
+    expect( code ).toMatch( invokeActivityPattern( 'shared\\.eval' ) );
+    expect( code ).toMatch( /,\s*value\)/ );
+    expect( code ).toMatch( /export const helper = async value =>/ );
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'rewrites CJS shared evaluator requires to invokeSharedEvaluator', async () => {
-    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-cjs-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\' });' );
+  it( 'resolves top-level const activity names', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-const-' ) );
+    writeFileSync( join( dir, 'steps.js' ), `
+const NAME = 'step.const';
+export const StepC = step({ name: NAME });` );
 
     const source = `
-const { SharedEval } = require( '../../shared/evaluators/common.js' );
+import { StepC } from './steps.js';
+const obj = { fn: async () => StepC() };`;
 
-const obj = {
-  fn: async (y) => {
-    SharedEval();
-  }
-}`;
+    const { code } = await runLoader( source, join( dir, 'file.js' ) );
+    expect( code ).toMatch( invokeActivityPattern( 'step\\.const' ) );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
 
-    const { code } = await runLoader( source, join( dir, 'workflows', 'my_workflow', 'workflow.js' ) );
+  it( 'throws when globalThis is shadowed at a rewritten call site', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-globalthis-shadow-' ) );
+    writeFileSync( join( dir, 'steps.js' ), 'export const StepA = step({ name: \'step.shadow\' });' );
 
-    expect( code ).not.toMatch( /require\('\.\.\/\.\.\/shared\/evaluators\/common\.js'\)/ );
-    expect( code ).toMatch( /fn:\s*async function \(y\)/ );
-    expect( code ).toMatch( /this\.invokeSharedEvaluator\('shared\.eval'\)/ );
+    const source = `
+import { StepA } from './steps.js';
+export function helper(globalThis) {
+  return StepA();
+}`;
 
+    await expect( runLoader( source, join( dir, 'helper.js' ) ) ).rejects.toThrow( /globalThis.*shadowed/ );
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'throws on non-static name', async () => {
+  it( 'propagates errors for non-static activity names', async () => {
     const dir = mkdtempSync( join( tmpdir(), 'ast-loader-error-' ) );
     writeFileSync( join( dir, 'steps.js' ), `
 function n() { return 'x'; }
 export const StepX = step({ name: n() });` );
-    writeFileSync( join( dir, 'workflow.js' ), `
-const base = 'a';
-export default workflow({ name: \`\${base}-b\` });` );
 
     const source = `
 import { StepX } from './steps.js';
-import WF from './workflow.js';
-const obj = { fn: async () => { StepX(); WF(); } }`;
+const obj = { fn: async () => StepX() };`;
 
     await expect( runLoader( source, join( dir, 'file.js' ) ) ).rejects.toThrow( /Invalid step name/ );
     rmSync( dir, { recursive: true, force: true } );

package/src/worker/webpack_loaders/workflow_rewriter/rewrite_activity_calls.js

@@ -0,0 +1,88 @@
+import traverseModule from '@babel/traverse';
+import { INVOKE_ACTIVITY_SYMBOL } from '#consts';
+import {
+  callExpression,
+  identifier,
+  isIdentifier,
+  memberExpression,
+  stringLiteral
+} from '@babel/types';
+
+// Handle CJS/ESM interop for Babel packages when executed as a webpack loader
+const traverse = traverseModule.default ?? traverseModule;
+const invokeActivitySymbolKey = Symbol.keyFor( INVOKE_ACTIVITY_SYMBOL );
+
+if ( !invokeActivitySymbolKey ) {
+  throw new Error( 'INVOKE_ACTIVITY_SYMBOL must be created with Symbol.for().' );
+}
+
+// Only direct function calls are rewritten. Member calls and dynamic callees stay untouched.
+const isIdentifierCallee = cPath => isIdentifier( cPath.node.callee );
+
+// Collapse collected activity imports into local identifier -> declared activity name.
+const buildActivityNameMap = activityImports =>
+  activityImports.reduce( ( map, { localName, activityName } ) => map.set( localName, activityName ), new Map() );
+
+// Ignore calls when the imported binding has been shadowed by a live local binding.
+const hasLiveLocalBinding = ( path, name ) => {
+  const binding = path.scope.getBinding( name );
+  return binding && !binding.path.removed;
+};
+
+const assertGlobalThisIsSafe = path => {
+  if ( hasLiveLocalBinding( path, 'globalThis' ) ) {
+    throw new Error( 'Cannot rewrite activity call because "globalThis" is shadowed in this scope.' );
+  }
+};
+
+// Build the generated dispatcher call, preserving the original call arguments.
+const createInvokeActivityCall = ( activityName, args ) =>
+  callExpression(
+    memberExpression(
+      identifier( 'globalThis' ),
+      callExpression(
+        memberExpression(
+          memberExpression( identifier( 'globalThis' ), identifier( 'Symbol' ) ),
+          identifier( 'for' )
+        ),
+        [ stringLiteral( invokeActivitySymbolKey ) ]
+      ),
+      true
+    ),
+    [ stringLiteral( activityName ), ...args ]
+  );
+
+// Rewrite valid function-body activity calls; top-level call validation belongs to the validator loader.
+const rewriteActivityCallsInFunctions = ( { ast, activityNames } ) => {
+  const state = { rewrote: false };
+
+  traverse( ast, {
+    CallExpression: path => {
+      if ( !path.getFunctionParent() || !isIdentifierCallee( path ) ) {
+        return;
+      }
+
+      const callee = path.node.callee;
+      const activityName = activityNames.get( callee.name );
+      if ( !activityName || hasLiveLocalBinding( path, callee.name ) ) {
+        return;
+      }
+
+      assertGlobalThisIsSafe( path );
+      path.replaceWith( createInvokeActivityCall( activityName, path.node.arguments ) );
+      state.rewrote = true;
+    }
+  } );
+
+  return state.rewrote;
+};
+
+// Entry point: resolve collected component imports into plain dispatcher calls.
+export default function rewriteActivityCalls( { ast, activityImports } ) {
+  const activityNames = buildActivityNameMap( activityImports );
+  if ( activityNames.size === 0 ) {
+    return false;
+  }
+
+  return rewriteActivityCallsInFunctions( { ast, activityNames } );
+};

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

@@ -0,0 +1,165 @@
+import { describe, it, expect, vi } from 'vitest';
+import generatorModule from '@babel/generator';
+import { parse } from '../tools.js';
+import rewriteActivityCalls from './rewrite_activity_calls.js';
+
+const { invokeActivitySymbolKey } = vi.hoisted( () => ( {
+  invokeActivitySymbolKey: 'test:invoke_activity'
+} ) );
+
+vi.mock( '#consts', async importOriginal => ( {
+  ...await importOriginal(),
+  INVOKE_ACTIVITY_SYMBOL: Symbol.for( invokeActivitySymbolKey )
+} ) );
+
+const generate = generatorModule.default ?? generatorModule;
+const escapeRegExp = value => value.replace( /[.*+?^${}()|[\]\\]/g, '\\$&' );
+const invokeActivityPattern = activityName =>
+  new RegExp( `globalThis\\[globalThis\\.Symbol\\.for\\(([\"'])${escapeRegExp( invokeActivitySymbolKey )}\\1\\)\\]\\(([\"'])${activityName}\\2` );
+
+describe( 'rewrite_activity_calls', () => {
+  it( 'rewrites step calls inside functions without changing function shape', () => {
+    const src = `
+const obj = {
+  fn: async x => {
+    StepA( 1 );
+    FlowB( 2 );
+  }
+}`;
+    const ast = parse( src, 'file.js' );
+    const activityImports = [ { localName: 'StepA', activityName: 'step.a' } ];
+
+    const rewrote = rewriteActivityCalls( { ast, activityImports } );
+    expect( rewrote ).toBe( true );
+
+    const { code } = generate( ast, { quotes: 'single' } );
+    expect( code ).not.toMatch( /@outputai\/core\/invoker/ );
+    expect( code ).toMatch( /fn:\s*async x =>/ );
+    expect( code ).toMatch( invokeActivityPattern( 'step\\.a' ) );
+    expect( code ).toMatch( /,\s*1\)/ );
+    expect( code ).toMatch( /FlowB\(2\)/ );
+  } );
+
+  it( 'rewrites evaluator calls to the global activity dispatcher', () => {
+    const src = `
+const obj = {
+  fn: async x => {
+    EvalA(3);
+  }
+};`;
+    const ast = parse( src, 'file.js' );
+    const activityImports = [ { localName: 'EvalA', activityName: 'eval.a' } ];
+    const rewrote = rewriteActivityCalls( { ast, activityImports } );
+    expect( rewrote ).toBe( true );
+    const { code } = generate( ast, { quotes: 'single' } );
+    expect( code ).toMatch( invokeActivityPattern( 'eval\\.a' ) );
+    expect( code ).toMatch( /,\s*3\)/ );
+  } );
+
+  it( 'does nothing when no matching calls are present', () => {
+    const src = [ 'const obj = { fn: function() { other(); } }' ].join( '\n' );
+    const ast = parse( src, 'file.js' );
+    const rewrote = rewriteActivityCalls( { ast, activityImports: [] } );
+    expect( rewrote ).toBe( false );
+  } );
+
+  it( 'rewrites imported activity calls in any function body', () => {
+    const src = `
+const foo = async () => {
+  StepA( 1 );
+};
+
+function bar( x ) {
+  EvalA( x );
+}
+
+const obj = {
+  fn: async x => {
+    foo();
+    bar( 2 );
+  }
+}`;
+
+    const ast = parse( src, 'file.js' );
+    const activityImports = [
+      { localName: 'StepA', activityName: 'step.a' },
+      { localName: 'EvalA', activityName: 'eval.a' }
+    ];
+
+    const rewrote = rewriteActivityCalls( { ast, activityImports } );
+    expect( rewrote ).toBe( true );
+
+    const { code } = generate( ast, { quotes: 'single' } );
+
+    expect( code ).toMatch( invokeActivityPattern( 'step\\.a' ) );
+    expect( code ).toMatch( invokeActivityPattern( 'eval\\.a' ) );
+    expect( code ).toMatch( /,\s*1\)/ );
+    expect( code ).toMatch( /,\s*x\)/ );
+    expect( code ).toMatch( /foo\(\)/ );
+    expect( code ).toMatch( /bar\(2\)/ );
+    expect( code ).toMatch( /const foo = async \(\) =>/ );
+  } );
+
+  it( 'does not rewrite top-level calls', () => {
+    const src = `
+StepA( 1 );
+function helper() {
+  StepA( 2 );
+}`;
+
+    const ast = parse( src, 'file.js' );
+    const activityImports = [ { localName: 'StepA', activityName: 'step.a' } ];
+    const rewrote = rewriteActivityCalls( { ast, activityImports } );
+    expect( rewrote ).toBe( true );
+
+    const { code } = generate( ast, { quotes: 'single' } );
+    expect( code ).toMatch( /StepA\(1\)/ );
+    expect( code ).toMatch( invokeActivityPattern( 'step\\.a' ) );
+    expect( code ).toMatch( /,\s*2\)/ );
+  } );
+
+  it( 'ignores local invoke activity names because globalThis is explicit', () => {
+    const src = `
+const __invokeActivity = () => 'local';
+const _invokeActivity = () => 'local';
+function helper() {
+  StepA();
+}`;
+    const ast = parse( src, 'file.js' );
+    const activityImports = [ { localName: 'StepA', activityName: 'step.a' } ];
+    const rewrote = rewriteActivityCalls( { ast, activityImports } );
+    expect( rewrote ).toBe( true );
+
+    const { code } = generate( ast, { quotes: 'single' } );
+    expect( code ).not.toMatch( /@outputai\/core\/invoker/ );
+    expect( code ).toMatch( /const __invokeActivity = \(\) => 'local'/ );
+    expect( code ).toMatch( /const _invokeActivity = \(\) => 'local'/ );
+    expect( code ).toMatch( invokeActivityPattern( 'step\\.a' ) );
+  } );
+
+  it( 'reads Symbol through globalThis so local Symbol bindings are safe', () => {
+    const src = `
+function helper( Symbol ) {
+  StepA();
+}`;
+    const ast = parse( src, 'file.js' );
+    const activityImports = [ { localName: 'StepA', activityName: 'step.a' } ];
+    const rewrote = rewriteActivityCalls( { ast, activityImports } );
+    expect( rewrote ).toBe( true );
+
+    const { code } = generate( ast, { quotes: 'single' } );
+    expect( code ).toMatch( /function helper\(Symbol\)/ );
+    expect( code ).toMatch( invokeActivityPattern( 'step\\.a' ) );
+  } );
+
+  it( 'throws when globalThis is shadowed at an activity call site', () => {
+    const src = `
+function helper( globalThis ) {
+  StepA();
+}`;
+    const ast = parse( src, 'file.js' );
+    const activityImports = [ { localName: 'StepA', activityName: 'step.a' } ];
+
+    expect( () => rewriteActivityCalls( { ast, activityImports } ) ).toThrow( /globalThis.*shadowed/ );
+  } );
+} );