@outputai/core 0.9.3-next.c318502.0 → 0.10.1-dev.b7b2fbe.0

package/src/worker/webpack_loaders/tools.js

@@ -2,27 +2,14 @@ import parser from '@babel/parser';
 import { resolve as resolvePath } from 'node:path';
 import { readFileSync } from 'node:fs';
 import {
-  blockStatement,
-  callExpression,
-  functionExpression,
-  identifier,
-  isArrowFunctionExpression,
   isAssignmentPattern,
-  isBlockStatement,
   isCallExpression,
   isExportNamedDeclaration,
-  isFunctionExpression,
   isIdentifier,
-  isVariableDeclarator,
   isStringLiteral,
   isVariableDeclaration,
   isObjectExpression,
-  memberExpression,
-  returnStatement,
-  stringLiteral,
-  thisExpression,
-  isExportDefaultDeclaration,
-  isFunctionDeclaration
+  isExportDefaultDeclaration
 } from '@babel/types';
 import { ComponentFile, NodeType } from './consts.js';
 
@@ -100,17 +87,6 @@ export const getLocalNameFromDestructuredProperty = prop => {
   return null;
 };
 
-/**
- * Convert an ArrowFunctionExpression to a FunctionExpression.
- * Wraps expression bodies in a block with a return statement.
- * @param {import('@babel/types').ArrowFunctionExpression} arrow - Arrow function.
- * @returns {import('@babel/types').FunctionExpression} Function expression.
- */
-export const toFunctionExpression = arrow => {
-  const body = isBlockStatement( arrow.body ) ? arrow.body : blockStatement( [ returnStatement( arrow.body ) ] );
-  return functionExpression( null, arrow.params, body, arrow.generator ?? false, arrow.async ?? false );
-};
-
 /**
  * Check if a module specifier or request string points to steps.js or is in a steps folder.
  * Matches: steps.js, /steps.js, /steps/*.js
@@ -231,38 +207,6 @@ export const getFileKind = path => {
   return null;
 };
 
-/**
- * Create a `this.method(literalName, ...args)` CallExpression.
- * @param {string} method - Method name on `this`.
- * @param {string} literalName - First string literal argument.
- * @param {import('@babel/types').Expression[]} args - Remaining call arguments.
- * @returns {import('@babel/types').CallExpression} Call expression node.
- */
-export const createThisMethodCall = ( method, literalName, args ) =>
-  callExpression( memberExpression( thisExpression(), identifier( method ) ), [ stringLiteral( literalName ), ...args ] );
-
-/**
- * Build a CallExpression that binds `this` at the call site:
- *   fn(arg1, arg2) -> fn.call(this, arg1, arg2)
- *
- * When to use:
- * - Inside workflow `fn` rewriting, local call-chain functions must receive the dynamic `this`
- *   so that emitted `this.invokeStep(...)` and similar calls inside them operate correctly.
- *
- * Example:
- *   // Input AST intent:
- *   foo(a, b);
- *
- *   // Rewritten AST:
- *   foo.call(this, a, b);
- *
- * @param {string} calleeName - Identifier name of the function being called (e.g., 'foo').
- * @param {import('@babel/types').Expression[]} args - Original call arguments.
- * @returns {import('@babel/types').CallExpression} CallExpression node representing `callee.call(this, ...args)`.
- */
-export const bindThisAtCallSite = ( calleeName, args ) =>
-  callExpression( memberExpression( identifier( calleeName ), identifier( 'call' ) ), [ thisExpression(), ...args ] );
-
 /**
  * Resolve an options object's name property to a string.
  * Accepts literal strings or top-level const string identifiers.
@@ -466,92 +410,3 @@ export const buildWorkflowNameMap = ( path, cache ) => {
   return result;
 };
 
-/**
- * Determine whether a node represents a function body usable as a workflow `fn`.
- *
- * Why this matters:
- * - Workflow `fn` needs a dynamic `this` so the rewriter can emit calls like `this.invokeStep(...)`.
- * - Arrow functions do not have their own `this`; they capture `this` lexically, which breaks the runtime contract.
- *
- * Accepts:
- * - FunctionExpression (possibly async/generator), e.g.:
- *   const obj = {
- *     fn: async function (input) {
- *       return input;
- *     }
- *   };
- *
- * Rejects:
- * - ArrowFunctionExpression, e.g.:
- *   const obj = {
- *     fn: async (input) => input
- *   };
- *
- * - Any other non-function expression.
- *
- * Notes:
- * - The rewriter will proactively convert arrow `fn` to a FunctionExpression before further processing.
- *
- * @param {import('@babel/types').Expression} v - Candidate node for `fn` value.
- * @returns {boolean} True if `v` is a FunctionExpression and not an arrow function.
- */
-export const isFunction = v => isFunctionExpression( v ) && !isArrowFunctionExpression( v );
-
-/**
- * Determine whether a variable declarator represents a function-like value.
- *
- * Use case:
- * - When `fn` calls a locally-declared function (directly or transitively), we need to:
- *   - propagate `this` to that function call (`callee.call(this, ...)`)
- *   - traverse into that function's body to rewrite imported step/workflow/evaluator calls.
- *
- * Matches patterns like:
- * - Function expression:
- *   const foo = function (x) { return x + 1; };
- *
- * - Async/generator function expression:
- *   const foo = async function (x) { return await work(x); };
- *
- * - Arrow function (will be normalized to FunctionExpression by the rewriter):
- *   const foo = (x) => x + 1;
- *   const foo = async (x) => await work(x);
- *
- * Does not match:
- * - Non-function initializers:
- *   const foo = 42;
- *   const foo = someIdentifier;
- *
- * @param {import('@babel/types').Node} v - AST node (typically a VariableDeclarator).
- * @returns {boolean} True if the declarator's initializer is a function (arrow or function expression).
- */
-export const isVarFunction = v =>
-  isVariableDeclarator( v ) && ( isFunctionExpression( v.init ) || isArrowFunctionExpression( v.init ) );
-
-/**
- * Determine whether a binding node corresponds to a function-like declaration usable
- * as a call-chain function target during workflow rewriting.
- *
- * Matches:
- * - FunctionDeclaration:
- *     function foo(x) { return x + 1; }
- *
- * - VariableDeclarator initialized with a function or arrow (normalized later):
- *     const foo = function (x) { return x + 1; };
- *     const foo = (x) => x + 1;
- *
- * Non-matches:
- * - Any binding that is not a function declaration nor a variable declarator with a function initializer.
- *
- * Why this matters:
- * - The rewriter traverses call chains from the workflow `fn`. It must recognize which local
- *   callees are valid function bodies to rewrite and into which it can propagate `this`.
- *
- * @param {import('@babel/types').Node} node - Binding path node (FunctionDeclaration or VariableDeclarator).
- * @returns {boolean} True if the node represents a function-like binding.
- */
-export const isFunctionLikeBinding = node =>
-  isFunctionDeclaration( node ) ||
-  (
-    isVariableDeclarator( node ) &&
-    ( isFunctionExpression( node.init ) || isArrowFunctionExpression( node.init ) )
-  );

package/src/worker/webpack_loaders/tools.spec.js

@@ -9,7 +9,6 @@ import {
   extractTopLevelStringConsts,
   getObjectKeyName,
   getLocalNameFromDestructuredProperty,
-  toFunctionExpression,
   isStepsPath,
   isSharedStepsPath,
   isAnyStepsPath,
@@ -17,7 +16,6 @@ import {
   isSharedEvaluatorsPath,
   isWorkflowPath,
   isAbsoluteWorkflowJsResource,
-  createThisMethodCall,
   resolveNameFromArg,
   resolveNameFromOptions,
   buildStepsNameMap,
@@ -130,17 +128,6 @@ describe( 'workflow_rewriter tools', () => {
     rmSync( dir, { recursive: true, force: true } );
   } );
 
-  it( 'toFunctionExpression: converts arrow, wraps expression bodies', () => {
-    const arrowExprBody = t.arrowFunctionExpression( [ t.identifier( 'x' ) ], t.identifier( 'x' ) );
-    const arrowBlockBody = t.arrowFunctionExpression( [], t.blockStatement( [ t.returnStatement( t.numericLiteral( 1 ) ) ] ) );
-    const fn1 = toFunctionExpression( arrowExprBody );
-    const fn2 = toFunctionExpression( arrowBlockBody );
-    expect( t.isFunctionExpression( fn1 ) ).toBe( true );
-    expect( t.isBlockStatement( fn1.body ) ).toBe( true );
-    expect( t.isReturnStatement( fn1.body.body[0] ) ).toBe( true );
-    expect( t.isFunctionExpression( fn2 ) ).toBe( true );
-  } );
-
   it( 'isStepsPath: matches LOCAL steps.js (no path traversal)', () => {
     // Local steps (without ../ or /shared/)
     expect( isStepsPath( 'steps.js' ) ).toBe( true );
@@ -226,16 +213,6 @@ describe( 'workflow_rewriter tools', () => {
     expect( isSharedEvaluatorsPath( 'steps.js' ) ).toBe( false );
   } );
 
-  it( 'createThisMethodCall: builds this.method(\'name\', ...args) call', () => {
-    const call = createThisMethodCall( 'invoke', 'n', [ t.numericLiteral( 1 ), t.identifier( 'x' ) ] );
-    expect( t.isCallExpression( call ) ).toBe( true );
-    expect( t.isMemberExpression( call.callee ) ).toBe( true );
-    expect( t.isThisExpression( call.callee.object ) ).toBe( true );
-    expect( t.isIdentifier( call.callee.property, { name: 'invoke' } ) ).toBe( true );
-    expect( t.isStringLiteral( call.arguments[0], { value: 'n' } ) ).toBe( true );
-    expect( call.arguments.length ).toBe( 3 );
-  } );
-
   it( 'buildSharedStepsNameMap: reads names from shared steps module and caches result', () => {
     const dir = mkdtempSync( join( tmpdir(), 'tools-shared-steps-' ) );
     mkdirSync( join( dir, 'shared', 'steps' ), { recursive: true } );

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

@@ -43,7 +43,7 @@ const removeRequireDeclarator = path => {
 
 const collectDestructuredRequires = ( path, absolutePath, req, descriptors ) => {
   const propFilter = p => isObjectProperty( p ) && isIdentifier( p.key );
-  for ( const { match, buildMap, cache, target, valueKey, label } of descriptors ) {
+  for ( const { match, buildMap, cache, label, target } of descriptors ) {
     if ( !match( req ) ) {
       continue;
     }
@@ -54,7 +54,7 @@ const collectDestructuredRequires = ( path, absolutePath, req, descriptors ) =>
       if ( localName ) {
         const resolved = nameMap.get( importedName );
         if ( resolved ) {
-          target.push( { localName, [valueKey]: resolved } );
+          target.push( { localName, activityName: resolved } );
         } else {
           throw unresolvedImportError( importedName, label, absolutePath );
         }
@@ -67,25 +67,26 @@ const collectDestructuredRequires = ( path, absolutePath, req, descriptors ) =>
 
 /**
  * Collect and strip target imports and requires from an AST, producing
- * step/evaluator import mappings for later rewrites.
+ * activity import mappings for later rewrites.
  *
  * Mutates the AST by removing matching import declarations and require declarators.
  *
  * @param {import('@babel/types').File} ast - Parsed file AST.
  * @param {string} fileDir - Absolute directory of the file represented by `ast`.
- * @param {{ stepsNameCache: Map<string,Map<string,string>> }} caches
+ * @param {{
+ *  stepsNameCache: Map<string,Map<string,string>>,
+ *  evaluatorsNameCache: Map<string,Map<string,string>>,
+ *  sharedStepsNameCache: Map<string,Map<string,string>>,
+ *  sharedEvaluatorsNameCache: Map<string,Map<string,string>>
+ * }} caches
  *  Resolved-name caches to avoid re-reading same modules.
- * @returns {{ stepImports: Array<{localName:string,stepName:string}>,
- *  evaluatorImports: Array<{localName:string,evaluatorName:string}> }} Collected info mappings.
+ * @returns {{ activityImports: Array<{localName:string,activityName:string}> }} Collected import mappings.
  */
 export default function collectTargetImports(
   ast, fileDir,
   { stepsNameCache, evaluatorsNameCache, sharedStepsNameCache, sharedEvaluatorsNameCache }
 ) {
-  const stepImports = [];
-  const sharedStepImports = [];
-  const evaluatorImports = [];
-  const sharedEvaluatorImports = [];
+  const activityImports = [];
 
   traverse( ast, {
     ImportDeclaration: path => {
@@ -98,7 +99,7 @@ export default function collectTargetImports(
       }
 
       const absolutePath = toAbsolutePath( fileDir, src );
-      const collectNamedImports = ( match, buildMapFn, cache, targetArr, valueKey, fileLabel ) => {
+      const collectNamedImports = ( match, buildMapFn, cache, fileLabel ) => {
         if ( !match ) {
           return;
         }
@@ -108,22 +109,17 @@ export default function collectTargetImports(
           const localName = s.local.name;
           const value = nameMap.get( importedName );
           if ( value ) {
-            const entry = { localName };
-            entry[valueKey] = value;
-            targetArr.push( entry );
+            activityImports.push( { localName, activityName: value } );
           } else {
             throw unresolvedImportError( importedName, fileLabel, absolutePath );
           }
         }
       };
 
-      collectNamedImports( isStepsPath( src ), buildStepsNameMap, stepsNameCache, stepImports, 'stepName', 'steps' );
-      collectNamedImports( isSharedStepsPath( src ), buildSharedStepsNameMap, sharedStepsNameCache, sharedStepImports, 'stepName', 'shared steps' );
-      collectNamedImports( isEvaluatorsPath( src ), buildEvaluatorsNameMap, evaluatorsNameCache, evaluatorImports, 'evaluatorName', 'evaluators' );
-      collectNamedImports(
-        isSharedEvaluatorsPath( src ), buildSharedEvaluatorsNameMap,
-        sharedEvaluatorsNameCache, sharedEvaluatorImports, 'evaluatorName', 'shared evaluators'
-      );
+      collectNamedImports( isStepsPath( src ), buildStepsNameMap, stepsNameCache, 'steps' );
+      collectNamedImports( isSharedStepsPath( src ), buildSharedStepsNameMap, sharedStepsNameCache, 'shared steps' );
+      collectNamedImports( isEvaluatorsPath( src ), buildEvaluatorsNameMap, evaluatorsNameCache, 'evaluators' );
+      collectNamedImports( isSharedEvaluatorsPath( src ), buildSharedEvaluatorsNameMap, sharedEvaluatorsNameCache, 'shared evaluators' );
       path.remove();
     },
     VariableDeclarator: path => {
@@ -153,25 +149,21 @@ export default function collectTargetImports(
         const cjsDescriptors = [
           {
             match: isStepsPath, buildMap: buildStepsNameMap,
-            cache: stepsNameCache, target: stepImports,
-            valueKey: 'stepName', label: 'steps'
+            cache: stepsNameCache, target: activityImports, label: 'steps'
           },
           {
             match: isSharedStepsPath, buildMap: buildSharedStepsNameMap,
-            cache: sharedStepsNameCache ?? stepsNameCache,
-            target: sharedStepImports,
-            valueKey: 'stepName', label: 'shared steps'
+            cache: sharedStepsNameCache,
+            target: activityImports, label: 'shared steps'
           },
           {
             match: isEvaluatorsPath, buildMap: buildEvaluatorsNameMap,
-            cache: evaluatorsNameCache, target: evaluatorImports,
-            valueKey: 'evaluatorName', label: 'evaluators'
+            cache: evaluatorsNameCache, target: activityImports, label: 'evaluators'
           },
           {
             match: isSharedEvaluatorsPath, buildMap: buildSharedEvaluatorsNameMap,
-            cache: sharedEvaluatorsNameCache ?? evaluatorsNameCache,
-            target: sharedEvaluatorImports,
-            valueKey: 'evaluatorName', label: 'shared evaluators'
+            cache: sharedEvaluatorsNameCache,
+            target: activityImports, label: 'shared evaluators'
           }
         ];
         collectDestructuredRequires(
@@ -182,5 +174,5 @@ export default function collectTargetImports(
     }
   } );
 
-  return { stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports };
+  return { activityImports };
 }