@output.ai/core 0.0.7 → 0.0.8

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

@@ -0,0 +1,117 @@
+import traverseModule from '@babel/traverse';
+import {
+  buildWorkflowNameMap,
+  getLocalNameFromDestructuredProperty,
+  isStepsPath,
+  isWorkflowPath,
+  buildStepsNameMap,
+  toAbsolutePath
+} from './tools.js';
+import {
+  isCallExpression,
+  isIdentifier,
+  isImportDefaultSpecifier,
+  isImportSpecifier,
+  isObjectPattern,
+  isObjectProperty,
+  isStringLiteral,
+  isVariableDeclaration
+} from '@babel/types';
+
+// Handle CJS/ESM interop for Babel packages when executed as a webpack loader
+const traverse = traverseModule.default ?? traverseModule;
+
+/**
+ * Collect and strip target imports and requires from an AST, producing
+ * step/workflow 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>>, workflowNameCache: Map<string,{default:(string|null),named:Map<string,string>}> }} caches
+ *  Resolved-name caches to avoid re-reading same modules.
+ * @returns {{ stepImports: Array<{localName:string,stepName:string}>,
+ *  flowImports: Array<{localName:string,workflowName:string}> }} Collected info mappings.
+ */
+export default function collectTargetImports( ast, fileDir, { stepsNameCache, workflowNameCache } ) {
+  const stepImports = [];
+  const flowImports = [];
+
+  traverse( ast, {
+    ImportDeclaration: path => {
+      const src = path.node.source.value;
+      // Ignore other imports
+      if ( !isStepsPath( src ) && !isWorkflowPath( src ) ) { return; }
+
+      const absolutePath = toAbsolutePath( fileDir, src );
+      if ( isStepsPath( src ) ) {
+        const nameMap = buildStepsNameMap( absolutePath, stepsNameCache );
+        for ( const s of path.node.specifiers.filter( s => isImportSpecifier( s ) ) ) {
+          const importedName = s.imported.name;
+          const localName = s.local.name;
+          const stepName = nameMap.get( importedName );
+          if ( stepName ) { stepImports.push( { localName, stepName } ); }
+        }
+      }
+      if ( isWorkflowPath( src ) ) {
+        const { named, default: defName } = buildWorkflowNameMap( absolutePath, workflowNameCache );
+        for ( const s of path.node.specifiers ) {
+          if ( isImportDefaultSpecifier( s ) ) {
+            const localName = s.local.name;
+            flowImports.push( { localName, workflowName: defName ?? localName } );
+          } else if ( isImportSpecifier( s ) ) {
+            const importedName = s.imported.name;
+            const localName = s.local.name;
+            const workflowName = named.get( importedName );
+            if ( workflowName ) { flowImports.push( { localName, workflowName } ); }
+          }
+        }
+      }
+      path.remove();
+    },
+    VariableDeclarator: path => {
+      const init = path.node.init;
+      // Not a require call
+      if ( !isCallExpression( init ) ) { return; }
+      // Different callee
+      if ( !isIdentifier( init.callee, { name: 'require' } ) ) { return; }
+      const firstArgument = init.arguments[0];
+      // Dynamic require is not supported
+      if ( !isStringLiteral( firstArgument ) ) { return; }
+
+      const req = firstArgument.value;
+      // Must be steps/workflows module
+      if ( !isStepsPath( req ) && !isWorkflowPath( req ) ) { return; }
+
+      const absolutePath = toAbsolutePath( fileDir, req );
+      if ( isStepsPath( req ) && isObjectPattern( path.node.id ) ) {
+        const nameMap = buildStepsNameMap( absolutePath, stepsNameCache );
+        for ( const prop of path.node.id.properties.filter( prop => isObjectProperty( prop ) && isIdentifier( prop.key ) ) ) {
+          const importedName = prop.key.name;
+          const localName = getLocalNameFromDestructuredProperty( prop );
+          if ( localName ) {
+            const stepName = nameMap.get( importedName );
+            if ( stepName ) { stepImports.push( { localName, stepName } ); }
+          }
+        }
+        if ( isVariableDeclaration( path.parent ) && path.parent.declarations.length === 1 ) {
+          path.parentPath.remove();
+        } else {
+          path.remove();
+        }
+      } else if ( isWorkflowPath( req ) && isIdentifier( path.node.id ) ) {
+        const { default: defName } = buildWorkflowNameMap( absolutePath, workflowNameCache );
+        const localName = path.node.id.name;
+        flowImports.push( { localName, workflowName: defName ?? localName } );
+        if ( isVariableDeclaration( path.parent ) && path.parent.declarations.length === 1 ) {
+          path.parentPath.remove();
+        } else {
+          path.remove();
+        }
+      }
+    }
+  } );
+
+  return { stepImports, flowImports };
+};

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

@@ -0,0 +1,77 @@
+import { describe, it, expect } from 'vitest';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+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 );
+}
+
+describe( 'collect_target_imports', () => {
+  it( 'collects ESM imports for steps and workflows and flags changes', () => {
+    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" })'
+    ].join( '\n' ) );
+    writeFileSync( join( dir, 'workflow.js' ), [
+      'export const FlowA = workflow({ name: "flow.a" })',
+      'export default workflow({ name: "flow.def" })'
+    ].join( '\n' ) );
+
+    const source = [
+      'import { StepA } from "./steps.js";',
+      'import WF, { FlowA } from "./workflow.js";',
+      'const x = 1;'
+    ].join( '\n' );
+
+    const ast = makeAst( source, join( dir, 'file.js' ) );
+    const { stepImports, flowImports } = collectTargetImports(
+      ast,
+      dir,
+      { stepsNameCache: new Map(), workflowNameCache: new Map() }
+    );
+
+    expect( stepImports ).toEqual( [ { localName: 'StepA', stepName: 'step.a' } ] );
+    expect( flowImports ).toEqual( [
+      { localName: 'WF', workflowName: 'flow.def' },
+      { localName: 'FlowA', workflowName: 'flow.a' }
+    ] );
+    // Import declarations should have been removed
+    expect( ast.program.body.find( n => n.type === 'ImportDeclaration' ) ).toBeUndefined();
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'collects CJS requires and removes declarators (steps + default workflow)', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-cjs-' ) );
+    writeFileSync( join( dir, 'steps.js' ), 'export const StepB = step({ name: "step.b" })\n' );
+    writeFileSync( join( dir, 'workflow.js' ), 'export default workflow({ name: "flow.c" })\n' );
+
+    const source = [
+      'const { StepB } = require("./steps.js");',
+      'const WF = require("./workflow.js");',
+      'const obj = {};'
+    ].join( '\n' );
+
+    const ast = makeAst( source, join( dir, 'file.js' ) );
+    const { stepImports, flowImports } = collectTargetImports(
+      ast,
+      dir,
+      { stepsNameCache: new Map(), workflowNameCache: new Map() }
+    );
+
+    expect( stepImports ).toEqual( [ { localName: 'StepB', stepName: 'step.b' } ] );
+    expect( flowImports ).toEqual( [ { localName: 'WF', workflowName: 'flow.c' } ] );
+    // All require-based declarators should have been removed (only non-require decls may remain)
+    const hasRequireDecl = ast.program.body.some( n =>
+      n.type === 'VariableDeclaration' && n.declarations.some( d => d.init && d.init.type === 'CallExpression' )
+    );
+    expect( hasRequireDecl ).toBe( false );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+} );
+

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

@@ -0,0 +1,3 @@
+export const NodeType = {
+  CONST: 'const'
+};

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

@@ -0,0 +1,56 @@
+import { dirname } from 'node:path';
+import generatorModule from '@babel/generator';
+import { parse } from './tools.js';
+
+import rewriteFnBodies from './rewrite_fn_bodies.js';
+import collectTargetImports from './collect_target_imports.js';
+
+// Handle CJS/ESM interop for Babel packages when executed as a webpack loader
+const generate = generatorModule.default ?? generatorModule;
+
+// Caches to avoid re-reading files during a build
+const stepsNameCache = new Map(); // path -> Map<exported, stepName>
+const workflowNameCache = new Map(); // path -> { default?: name, named: Map<exported, flowName> }
+
+/**
+ * Webpack loader that rewrites step/workflow calls by reading names from
+ * the respective modules and transforming `fn` bodies accordingly.
+ * Preserves sourcemaps.
+ *
+ * @param {string|Buffer} source - Module source code.
+ * @param {any} inputMap - Incoming source map.
+ * @this {import('webpack').LoaderContext<{}>}
+ * @returns {void}
+ */
+export default function stepImportRewriterAstLoader( source, inputMap ) {
+  this.cacheable?.( true );
+  const callback = this.async?.() ?? this.callback;
+  const cache = { stepsNameCache, workflowNameCache };
+
+  try {
+    const filename = this.resourcePath;
+    const ast = parse( String( source ), filename );
+    const fileDir = dirname( filename );
+    const { stepImports, flowImports } = collectTargetImports( ast, fileDir, cache );
+
+    // No imports
+    if ( stepImports.length + flowImports.length === 0 ) {
+      return callback( null, source, inputMap );
+    }
+
+    const rewrote = rewriteFnBodies( ast, stepImports, flowImports );
+    // No edits performed
+    if ( !rewrote ) { return callback( null, source, inputMap ); }
+
+    const { code, map } = generate( ast, {
+      sourceMaps: true,
+      sourceFileName: filename,
+      quotes: 'single',
+      jsescOption: { quotes: 'single' }
+    }, String( source ) );
+    return callback( null, code, map ?? inputMap );
+  } catch ( err ) {
+    // Fail gracefully as loader error
+    return callback( err );
+  }
+};

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

@@ -0,0 +1,129 @@
+import { describe, it, expect } from 'vitest';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import loader from './index.mjs';
+
+function runLoader( source, resourcePath ) {
+  return new Promise( ( resolve, reject ) => {
+    const ctx = {
+      resourcePath,
+      cacheable: () => {},
+      async: () => ( err, code, map ) => ( err ? reject( err ) : resolve( { code, map } ) ),
+      callback: ( err, code, map ) => ( err ? reject( err ) : resolve( { code, map } ) )
+    };
+    loader.call( ctx, source, null );
+  } );
+}
+
+describe( 'workflows_rewriter Webpack loader spec', () => {
+  it( 'rewrites ESM imports and converts fn arrow to function', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-esm-' ) );
+    writeFileSync( join( dir, 'steps.js' ), 'export const StepA = step({ name: \'step.a\' })\n' );
+    writeFileSync( join( dir, 'workflow.js' ), [
+      'export const FlowA = workflow({ name: \'flow.a\' })',
+      'export default workflow({ name: \'flow.def\' })'
+    ].join( '\n' ) );
+
+    const source = [
+      'import { StepA } from \'./steps.js\';',
+      'import FlowDef, { FlowA } from \'./workflow.js\';',
+      '',
+      'const obj = {',
+      '  fn: async (x) => {',
+      '    StepA(1);',
+      '    FlowA(2);',
+      '    FlowDef(3);',
+      '  }',
+      '}',
+      ''
+    ].join( '\n' );
+
+    const { code } = await runLoader( source, join( dir, 'file.js' ) );
+
+    expect( code ).not.toMatch( /from '\.\/steps\.js'/ );
+    expect( code ).not.toMatch( /from '\.\/workflow\.js'/ );
+    expect( code ).toMatch( /fn:\s*async function \(x\)/ );
+    expect( code ).toMatch( /this\.invokeStep\('step\.a',\s*1\)/ );
+    expect( code ).toMatch( /this\.startWorkflow\('flow\.a',\s*2\)/ );
+    expect( code ).toMatch( /this\.startWorkflow\('flow\.def',\s*3\)/ );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'rewrites CJS requires and converts fn arrow to function', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-cjs-' ) );
+    writeFileSync( join( dir, 'steps.js' ), 'export const StepB = step({ name: \'step.b\' })\n' );
+    writeFileSync( join( dir, 'workflow.js' ), 'export default workflow({ name: \'flow.c\' })\n' );
+
+    const source = [
+      'const { StepB } = require(\'./steps.js\');',
+      'const FlowDefault = require(\'./workflow.js\');',
+      '',
+      'const obj = {',
+      '  fn: async (y) => {',
+      '    StepB();',
+      '    FlowDefault();',
+      '  }',
+      '}',
+      ''
+    ].join( '\n' );
+
+    const { code } = await runLoader( source, join( dir, 'file.js' ) );
+
+    expect( code ).not.toMatch( /require\('\.\/steps\.js'\)/ );
+    expect( code ).not.toMatch( /require\('\.\/workflow\.js'\)/ );
+    expect( code ).toMatch( /fn:\s*async function \(y\)/ );
+    expect( code ).toMatch( /this\.invokeStep\('step\.b'\)/ );
+    expect( code ).toMatch( /this\.startWorkflow\('flow\.c'\)/ );
+
+    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 })'
+    ].join( '\n' ) );
+    writeFileSync( join( dir, 'workflow.js' ), [
+      'const WF = \'wf.const\'',
+      'export const FlowC = workflow({ name: WF })',
+      'const D = \'wf.def\'',
+      'export default workflow({ name: D })'
+    ].join( '\n' ) );
+
+    const source = [
+      'import { StepC } from \'./steps.js\';',
+      'import FlowDef, { FlowC } from \'./workflow.js\';',
+      'const obj = { fn: async () => { StepC(); FlowC(); FlowDef(); } }'
+    ].join( '\n' );
+
+    const { code } = await runLoader( source, join( dir, 'file.js' ) );
+    expect( code ).toMatch( /this\.invokeStep\('step\.const'\)/ );
+    expect( code ).toMatch( /this\.startWorkflow\('wf\.const'\)/ );
+    expect( code ).toMatch( /this\.startWorkflow\('wf\.def'\)/ );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'throws on non-static name', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-error-' ) );
+    writeFileSync( join( dir, 'steps.js' ), [
+      'function n() { return \'x\' }',
+      'export const StepX = step({ name: n() })'
+    ].join( '\n' ) );
+    writeFileSync( join( dir, 'workflow.js' ), [
+      'const base = \'a\'',
+      'export default workflow({ name: `${base}-b` })'
+    ].join( '\n' ) );
+
+    const source = [
+      'import { StepX } from \'./steps.js\';',
+      'import WF from \'./workflow.js\';',
+      'const obj = { fn: async () => { StepX(); WF(); } }'
+    ].join( '\n' );
+
+    await expect( runLoader( source, join( dir, 'file.js' ) ) ).rejects.toThrow( /Invalid (step|default workflow) name/ );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+} );

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

@@ -0,0 +1,64 @@
+import traverseModule from '@babel/traverse';
+import {
+  isArrowFunctionExpression,
+  isIdentifier,
+  isFunctionExpression
+} from '@babel/types';
+import { toFunctionExpression, createThisMethodCall } from './tools.js';
+
+// Handle CJS/ESM interop for Babel packages when executed as a webpack loader
+const traverse = traverseModule.default ?? traverseModule;
+
+/**
+ * Rewrite calls to imported steps/workflows within `fn` object properties.
+ * Converts arrow fns to functions and replaces `StepX(...)` with
+ * `this.invokeStep('name', ...)` and `FlowY(...)` with
+ * `this.startWorkflow('name', ...)`.
+ *
+ * @param {import('@babel/types').File} ast - Parsed file AST.
+ * @param {Array<{localName:string,stepName:string}>} stepImports - Step imports.
+ * @param {Array<{localName:string,workflowName:string}>} flowImports - Workflow imports.
+ * @returns {boolean} True if the AST was modified; false otherwise.
+ */
+export default function rewriteFnBodies( ast, stepImports, flowImports ) {
+  const state = { rewrote: false };
+  traverse( ast, {
+    ObjectProperty: path => {
+      // If it is not fn property: skip
+      if ( !isIdentifier( path.node.key, { name: 'fn' } ) ) { return; }
+
+      const val = path.node.value;
+
+      // if it is not function, return
+      if ( !isFunctionExpression( val ) && !isArrowFunctionExpression( val ) ) { return; }
+
+      // replace arrow fn in favor of a function
+      if ( isArrowFunctionExpression( val ) ) {
+        const func = toFunctionExpression( val );
+        path.get( 'value' ).replaceWith( func );
+        state.rewrote = true;
+      }
+
+      path.get( 'value.body' ).traverse( {
+        CallExpression: cPath => {
+          const callee = cPath.node.callee;
+          if ( !isIdentifier( callee ) ) { return; } // Skip: complex callee not supported
+          const step = stepImports.find( x => x.localName === callee.name );
+          if ( step ) {
+            const args = cPath.node.arguments;
+            cPath.replaceWith( createThisMethodCall( 'invokeStep', step.stepName, args ) );
+            state.rewrote = true;
+            return; // Stop after rewriting as step call
+          }
+          const flow = flowImports.find( x => x.localName === callee.name );
+          if ( flow ) {
+            const args = cPath.node.arguments;
+            cPath.replaceWith( createThisMethodCall( 'startWorkflow', flow.workflowName, args ) );
+            state.rewrote = true;
+          }
+        }
+      } );
+    }
+  } );
+  return state.rewrote;
+};

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

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import { parse } from './tools.js';
+import rewriteFnBodies from './rewrite_fn_bodies.js';
+
+describe( 'rewrite_fn_bodies', () => {
+  it( 'converts arrow to function and rewrites step/workflow calls', () => {
+    const src = [
+      'const obj = {',
+      '  fn: async (x) => {',
+      '    StepA(1);',
+      '    FlowB(2);',
+      '  }',
+      '}'
+    ].join( '\n' );
+    const ast = parse( src, 'file.js' );
+    const stepImports = [ { localName: 'StepA', stepName: 'step.a' } ];
+    const flowImports = [ { localName: 'FlowB', workflowName: 'flow.b' } ];
+
+    const rewrote = rewriteFnBodies( ast, stepImports, flowImports );
+    expect( rewrote ).toBe( true );
+
+    const code = ast.program.body.map( n => n.type ).length; // smoke: ast mutated
+    expect( code ).toBeGreaterThan( 0 );
+  } );
+
+  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 = rewriteFnBodies( ast, [], [] );
+    expect( rewrote ).toBe( false );
+  } );
+} );
+