@output.ai/core 0.0.7 → 0.0.8

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

@@ -0,0 +1,225 @@
+import parser from '@babel/parser';
+import { resolve as resolvePath } from 'node:path';
+import { readFileSync } from 'node:fs';
+import {
+  blockStatement,
+  callExpression,
+  functionExpression,
+  identifier,
+  isAssignmentPattern,
+  isBlockStatement,
+  isCallExpression,
+  isExportNamedDeclaration,
+  isIdentifier,
+  isStringLiteral,
+  isVariableDeclaration,
+  isObjectExpression,
+  memberExpression,
+  returnStatement,
+  stringLiteral,
+  thisExpression,
+  isExportDefaultDeclaration
+} from '@babel/types';
+import { NodeType } from './consts.js';
+
+/**
+ * Resolve a relative module specifier against a base directory.
+ * @param {string} fileDir - Base directory to resolve from.
+ * @param {string} rel - Relative path/specifier.
+ * @returns {string} Absolute path.
+ */
+export const toAbsolutePath = ( fileDir, rel ) => resolvePath( fileDir, rel );
+
+/**
+ * Parse JavaScript/TypeScript source into a Babel AST.
+ * @param {string} source - Source code to parse.
+ * @param {string} filename - Virtual filename for sourcemaps and diagnostics.
+ * @returns {import('@babel/types').File} Parsed AST.
+ */
+export const parse = ( source, filename ) => parser.parse( source, {
+  sourceType: 'module',
+  sourceFilename: filename,
+  plugins: [ 'jsx' ]
+} );
+
+/**
+ * Extract top-level constant string bindings (e.g., const NAME = 'value').
+ * @param {import('@babel/types').File} ast - Parsed file AST.
+ * @returns {Map<string, string>} Map from identifier to string literal value.
+ */
+export const extractTopLevelStringConsts = ast =>
+  ast.program.body
+    .filter( node => isVariableDeclaration( node ) && node.kind === NodeType.CONST )
+    .reduce( ( map, node ) => {
+      node.declarations
+        .filter( dec => isIdentifier( dec.id ) && isStringLiteral( dec.init ) )
+        .forEach( dec => map.set( dec.id.name, dec.init.value ) );
+      return map;
+    }, new Map() );
+
+/**
+ * Resolve an object key name from an Identifier or StringLiteral.
+ * @param {import('@babel/types').Expression} node - Object key node.
+ * @returns {string|null} Key name or null when unsupported.
+ */
+export const getObjectKeyName = node => {
+  if ( isIdentifier( node ) ) { return node.name; }
+  if ( isStringLiteral( node ) ) { return node.value; }
+  return null;
+};
+
+/**
+ * Extract the local identifier name from a destructured ObjectProperty.
+ * Supports: { a } and { a: local } and { a: local = default }.
+ * @param {import('@babel/types').ObjectProperty} prop - Object property.
+ * @returns {string|null} Local identifier name or null.
+ */
+export const getLocalNameFromDestructuredProperty = prop => {
+  if ( isIdentifier( prop.value ) ) { return prop.value.name; }
+  if ( isAssignmentPattern( prop.value ) && isIdentifier( prop.value.left ) ) { return prop.value.left.name; }
+  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.
+ * @param {string} value - Module path or request string.
+ * @returns {boolean} True if it matches steps.js.
+ */
+export const isStepsPath = value => /(^|\/)steps\.js$/.test( value );
+
+/**
+ * Check if a module specifier or request string points to workflow.js.
+ * @param {string} value - Module path or request string.
+ * @returns {boolean} True if it matches workflow.js.
+ */
+export const isWorkflowPath = value => /(^|\/)workflow\.js$/.test( value );
+
+/**
+ * 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 ] );
+
+/**
+ * Resolve an options object's name property to a string.
+ * Accepts literal strings or top-level const string identifiers.
+ * @param {import('@babel/types').Expression} optionsNode - The call options object.
+ * @param {Map<string,string>} consts - Top-level const string bindings.
+ * @param {string} errorMessagePrefix - Prefix used when throwing validation errors.
+ * @returns {string} Resolved name.
+ * @throws {Error} When name is missing or not a supported static form.
+ */
+export const resolveNameFromOptions = ( optionsNode, consts, errorMessagePrefix ) => {
+  // If it is not an object
+  if ( !isObjectExpression( optionsNode ) ) {
+    throw new Error( `${errorMessagePrefix}: Missing properties` );
+  }
+
+  // Look specifically for the 'name' property
+  for ( const prop of optionsNode.properties ) {
+    if ( getObjectKeyName( prop.key ) !== 'name' ) { continue; }
+
+    const val = prop.value;
+    // if it is a string literal: jackpot
+    if ( isStringLiteral( val ) ) { return val.value; }
+
+    // if it is an identifier, it needs to be deterministic (top-level const)
+    if ( isIdentifier( val ) ) {
+      if ( consts.has( val.name ) ) { return consts.get( val.name ); }
+      throw new Error( `${errorMessagePrefix}: Name identifier "${val.name}" is not a top-level const string` );
+    }
+
+    throw new Error( `${errorMessagePrefix}: Name must be a string literal or a top-level const string` );
+  }
+
+  throw new Error( `${errorMessagePrefix}: Missing required name property` ); // No name field found
+};
+
+/**
+ * Build a map from exported step variable name to declared step name.
+ * Parses the steps module and extracts `step({ name: '...' })` names.
+ * @param {string} path - Absolute path to the steps module file.
+ * @param {Map<string, Map<string,string>>} cache - Cache of computed step name maps.
+ * @returns {Map<string,string>} Exported identifier -> step name.
+ * @throws {Error} When a step name is invalid (non-static or missing).
+ */
+export const buildStepsNameMap = ( path, cache ) => {
+  if ( cache.has( path ) ) { return cache.get( path ); }
+  const text = readFileSync( path, 'utf8' );
+  const ast = parse( text, path );
+  const consts = extractTopLevelStringConsts( ast );
+
+  const stepMap = ast.program.body
+    .filter( node => isExportNamedDeclaration( node ) && isVariableDeclaration( node.declaration ) )
+    .reduce( ( map, node ) => {
+
+      node.declaration.declarations
+        .filter( dec => isIdentifier( dec.id ) && isCallExpression( dec.init ) && isIdentifier( dec.init.callee, { name: 'step' } ) )
+        .map( dec => [
+          dec,
+          resolveNameFromOptions( dec.init.arguments[0], consts, `Invalid step name in ${path} for "${dec.id.name}"` )
+        ] )
+        .forEach( ( [ dec, name ] ) => map.set( dec.id.name, name ) );
+      return map;
+    }, new Map() );
+
+  cache.set( path, stepMap );
+  return stepMap;
+};
+
+/**
+ * Build a structure with default and named workflow names from a workflow module.
+ * Extracts names from `workflow({ name: '...' })` calls.
+ * @param {string} path - Absolute path to the workflow module file.
+ * @param {Map<string, {default: (string|null), named: Map<string,string>}>} cache - Cache of workflow names.
+ * @returns {{ default: (string|null), named: Map<string,string> }} Names.
+ * @throws {Error} When a workflow name is invalid (non-static or missing).
+ */
+export const buildWorkflowNameMap = ( path, cache ) => {
+  if ( cache.has( path ) ) { return cache.get( path ); }
+  const text = readFileSync( path, 'utf8' );
+  const ast = parse( text, path );
+  const consts = extractTopLevelStringConsts( ast );
+
+  const result = { default: null, named: new Map() };
+
+  for ( const node of ast.program.body ) {
+
+    // named exports
+    if ( isExportNamedDeclaration( node ) && isVariableDeclaration( node.declaration ) ) {
+
+      for ( const d of node.declaration.declarations ) {
+        if ( isIdentifier( d.id ) && isCallExpression( d.init ) && isIdentifier( d.init.callee, { name: 'workflow' } ) ) {
+          const name = resolveNameFromOptions( d.init.arguments[0], consts, `Invalid workflow name in ${path} for '${d.id.name}` );
+          if ( name ) { result.named.set( d.id.name, name ); }
+        }
+      }
+
+    // default exports
+    } else if (
+      isExportDefaultDeclaration( node ) &&
+      isCallExpression( node.declaration ) &&
+      isIdentifier( node.declaration.callee, { name: 'workflow' } )
+    ) {
+      result.default = resolveNameFromOptions( node.declaration.arguments[0], consts, `Invalid default workflow name in ${path}` );
+    }
+  }
+
+  cache.set( path, result );
+  return result;
+};

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

@@ -0,0 +1,144 @@
+import { describe, it, expect } from 'vitest';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve as resolvePath } from 'node:path';
+import * as t from '@babel/types';
+import {
+  toAbsolutePath,
+  parse,
+  extractTopLevelStringConsts,
+  getObjectKeyName,
+  getLocalNameFromDestructuredProperty,
+  toFunctionExpression,
+  isStepsPath,
+  isWorkflowPath,
+  createThisMethodCall,
+  resolveNameFromOptions,
+  buildStepsNameMap,
+  buildWorkflowNameMap
+} from './tools.js';
+
+describe( 'workflow_rewriter tools', () => {
+  it( 'parse: parses JS with JSX plugin enabled', () => {
+    const ast = parse( 'const A = 1; const C = () => <div />', 'file.js' );
+    expect( ast?.type ).toBe( 'File' );
+    expect( ast.program.body.length ).toBeGreaterThan( 0 );
+  } );
+
+  it( 'toAbsolutePath: resolves relative path against base directory', () => {
+    expect( toAbsolutePath( '/base/dir', './file.js' ) ).toBe( resolvePath( '/base/dir', './file.js' ) );
+  } );
+
+  it( 'extractTopLevelStringConsts: returns only const string bindings', () => {
+    const ast = parse( [
+      'const A = \"a\"; let B = \"b\"; const C = 3;',
+      'const D = `d`; const E = \"e\"'
+    ].join( '\n' ), 'file.js' );
+    const map = extractTopLevelStringConsts( ast );
+    expect( map.get( 'A' ) ).toBe( 'a' );
+    expect( map.has( 'B' ) ).toBe( false );
+    expect( map.has( 'C' ) ).toBe( false );
+    // Template literal is not a StringLiteral
+    expect( map.has( 'D' ) ).toBe( false );
+    expect( map.get( 'E' ) ).toBe( 'e' );
+  } );
+
+  it( 'resolveNameFromOptions: returns literal name from options object', () => {
+    const opts = t.objectExpression( [ t.objectProperty( t.identifier( 'name' ), t.stringLiteral( 'literal.name' ) ) ] );
+    const out = resolveNameFromOptions( opts, new Map(), 'X' );
+    expect( out ).toBe( 'literal.name' );
+  } );
+
+  it( 'getObjectKeyName: resolves from Identifier and StringLiteral', () => {
+    expect( getObjectKeyName( t.identifier( 'name' ) ) ).toBe( 'name' );
+    expect( getObjectKeyName( t.stringLiteral( 'x' ) ) ).toBe( 'x' );
+    expect( getObjectKeyName( t.numericLiteral( 1 ) ) ).toBeNull();
+  } );
+
+  it( 'buildStepsNameMap: reads names from steps module and caches result', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'tools-steps-' ) );
+    const stepsPath = join( dir, 'steps.js' );
+    writeFileSync( stepsPath, [
+      'export const StepA = step({ name: "step.a" })',
+      'export const StepB = step({ name: "step.b" })'
+    ].join( '\n' ) );
+    const cache = new Map();
+    const map1 = buildStepsNameMap( stepsPath, cache );
+    expect( map1.get( 'StepA' ) ).toBe( 'step.a' );
+    expect( map1.get( 'StepB' ) ).toBe( 'step.b' );
+    expect( cache.get( stepsPath ) ).toBe( map1 );
+    const map2 = buildStepsNameMap( stepsPath, cache );
+    expect( map2 ).toBe( map1 );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'getLocalNameFromDestructuredProperty: handles { a }, { a: b }, { a: b = 1 }', () => {
+    // { a }
+    const p1 = t.objectProperty( t.identifier( 'a' ), t.identifier( 'a' ), false, true );
+    expect( getLocalNameFromDestructuredProperty( p1 ) ).toBe( 'a' );
+    // { a: b }
+    const p2 = t.objectProperty( t.identifier( 'a' ), t.identifier( 'b' ) );
+    expect( getLocalNameFromDestructuredProperty( p2 ) ).toBe( 'b' );
+    // { a: b = 1 }
+    const p3 = t.objectProperty( t.identifier( 'a' ), t.assignmentPattern( t.identifier( 'b' ), t.numericLiteral( 1 ) ) );
+    expect( getLocalNameFromDestructuredProperty( p3 ) ).toBe( 'b' );
+    // Unsupported shape
+    const p4 = t.objectProperty( t.identifier( 'a' ), t.arrayExpression( [] ) );
+    expect( getLocalNameFromDestructuredProperty( p4 ) ).toBeNull();
+  } );
+
+  it( 'buildWorkflowNameMap: reads named and default workflow names and caches', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'tools-flow-' ) );
+    const wfPath = join( dir, 'workflow.js' );
+    writeFileSync( wfPath, [
+      'export const FlowA = workflow({ name: "flow.a" })',
+      'export default workflow({ name: "flow.def" })'
+    ].join( '\n' ) );
+    const cache = new Map();
+    const res1 = buildWorkflowNameMap( wfPath, cache );
+    expect( res1.named.get( 'FlowA' ) ).toBe( 'flow.a' );
+    expect( res1.default ).toBe( 'flow.def' );
+    expect( cache.get( wfPath ) ).toBe( res1 );
+    const res2 = buildWorkflowNameMap( wfPath, cache );
+    expect( res2 ).toBe( res1 );
+    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 steps.js at root or subpath', () => {
+    expect( isStepsPath( 'steps.js' ) ).toBe( true );
+    expect( isStepsPath( './steps.js' ) ).toBe( true );
+    expect( isStepsPath( '/a/b/steps.js' ) ).toBe( true );
+    expect( isStepsPath( 'steps.ts' ) ).toBe( false );
+    expect( isStepsPath( 'workflow.js' ) ).toBe( false );
+  } );
+
+  it( 'isWorkflowPath: matches workflow.js at root or subpath', () => {
+    expect( isWorkflowPath( 'workflow.js' ) ).toBe( true );
+    expect( isWorkflowPath( './workflow.js' ) ).toBe( true );
+    expect( isWorkflowPath( '/a/b/workflow.js' ) ).toBe( true );
+    expect( isWorkflowPath( 'workflow.ts' ) ).toBe( false );
+    expect( isWorkflowPath( '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 );
+  } );
+} );
+

package/src/errors.d.ts

@@ -1,3 +0,0 @@
-export declare class FatalError extends Error { }
-
-export declare class ValidationError extends Error { }

package/src/worker/temp/__workflows_entrypoint.js

@@ -1,6 +0,0 @@
-export { default as articleDraftAgentic } from '/app/test-workflows/dist/article-draft-agentic/index.js';
-export { default as httpClientDemo } from '/app/test-workflows/dist/http/index.js';
-export { default as nested } from '/app/test-workflows/dist/nested/index.js';
-export { default as local_prompt } from '/app/test-workflows/dist/prompt/index.js';
-export { default as simple } from '/app/test-workflows/dist/simple/index.js';
-export { default as webhook } from '/app/test-workflows/dist/webhook/index.js';