@outputai/core 0.3.3-next.32f4d87.0 → 0.3.3-next.7ccc4fe.0

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

@@ -1,7 +1,7 @@
 import { describe, it, expect } from 'vitest';
 import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import loader from './index.mjs';
 
 function runLoader( source, resourcePath ) {
@@ -196,6 +196,78 @@ const obj = {
     rmSync( dir, { recursive: true, force: true } );
   } );
 
+  it( 'rewrites ESM imports from @growthxlabs/workflows_catalog to startWorkflow', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-catalog-' ) );
+    const pkgRoot = join( dir, 'node_modules', '@growthxlabs', 'workflows_catalog' );
+    const srcDir = join( pkgRoot, 'src' );
+    mkdirSync( join( srcDir, 'workflows', 'wf' ), { recursive: true } );
+    writeFileSync( join( pkgRoot, 'package.json' ), JSON.stringify( {
+      name: '@growthxlabs/workflows_catalog',
+      type: 'module',
+      main: './src/index.js',
+      dependencies: { '@outputai/core': '1.0.0' }
+    } ) );
+    writeFileSync( join( srcDir, 'index.js' ), 'export { default as sumNumbers } from \'./workflows/wf/workflow.js\';\n' );
+    writeFileSync( join( srcDir, 'workflows', 'wf', 'workflow.js' ), 'export default workflow({ name: \'nest.cat\' });\n' );
+
+    const resourcePath = join( dir, 'workflows', 'mine', 'workflow.js' );
+    mkdirSync( dirname( resourcePath ), { recursive: true } );
+
+    const source = `
+import { sumNumbers } from '@growthxlabs/workflows_catalog';
+
+const obj = {
+  fn: async () => {
+    sumNumbers( 1 );
+  }
+}`;
+
+    const { code } = await runLoader( source, resourcePath );
+
+    expect( code ).not.toMatch( /@growthxlabs\/workflows_catalog/ );
+    expect( code ).toMatch( /this\.startWorkflow\('nest\.cat',\s*1\)/ );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'rewrites imports through the output workflow bundle export condition', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'ast-loader-catalog-condition-' ) );
+    const pkgRoot = join( dir, 'node_modules', '@test', 'conditional_catalog' );
+    mkdirSync( join( pkgRoot, 'bundle' ), { recursive: true } );
+    writeFileSync( join( pkgRoot, 'package.json' ), JSON.stringify( {
+      name: '@test/conditional_catalog',
+      type: 'module',
+      main: './node-entry.js',
+      exports: {
+        '.': {
+          'output-workflow-bundle': './bundle/workflow.js',
+          default: './node-entry.js'
+        }
+      }
+    } ) );
+    writeFileSync( join( pkgRoot, 'node-entry.js' ), 'export const helper = () => 1;\n' );
+    writeFileSync( join( pkgRoot, 'bundle', 'workflow.js' ), 'export default workflow({ name: \'bundle.cat\' });\n' );
+
+    const resourcePath = join( dir, 'workflows', 'mine', 'workflow.js' );
+    mkdirSync( dirname( resourcePath ), { recursive: true } );
+
+    const source = `
+import BundleCatalog from '@test/conditional_catalog';
+
+const obj = {
+  fn: async () => {
+    BundleCatalog( 1 );
+  }
+}`;
+
+    const { code } = await runLoader( source, resourcePath );
+
+    expect( code ).not.toMatch( /@test\/conditional_catalog/ );
+    expect( code ).toMatch( /this\.startWorkflow\('bundle\.cat',\s*1\)/ );
+
+    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' ), `

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

@@ -1,6 +1,33 @@
 import traverseModule from '@babel/traverse';
 import { dirname } from 'node:path';
-import { parse, toAbsolutePath, getFileKind, isAnyStepsPath, isAnyEvaluatorsPath, isWorkflowPath } from '../tools.js';
+import {
+  parse,
+  toAbsolutePath,
+  getFileKind,
+  isAnyStepsPath,
+  isAnyEvaluatorsPath,
+  isWorkflowPath,
+  isAbsoluteWorkflowJsResource
+} from '../tools.js';
+
+/**
+ * Files where a bare npm import may bind to child workflows (catalog packages, etc.).
+ * Matches {@link collectTargetImports} for `workflow.js`; steps/evaluators need the same
+ * binding knowledge for fn-body validation only.
+ * @param {string} filename - Absolute resource path.
+ * @returns {boolean}
+ */
+const fileMayBindBareNpmWorkflowImports = filename => {
+  const n = filename.replace( /\\/g, '/' );
+  return isAbsoluteWorkflowJsResource( filename ) ||
+    isAnyStepsPath( n ) || isAnyEvaluatorsPath( n );
+};
+import {
+  isBareNpmSpecifier,
+  resolveBareImportSpecifiersAsWorkflows,
+  resolveBareDestructuredRequireAsWorkflows,
+  resolveBareDefaultRequireAsWorkflow
+} from '../npm_workflow_export_resolve.js';
 import { ComponentFile } from '../consts.js';
 import {
   isCallExpression,
@@ -95,6 +122,21 @@ export default function workflowValidatorLoader( source, inputMap ) {
       ImportDeclaration: path => {
         const specifier = path.node.source.value;
 
+        if ( isBareNpmSpecifier( specifier ) && fileMayBindBareNpmWorkflowImports( filename ) ) {
+          const outcome = resolveBareImportSpecifiersAsWorkflows( {
+            fromAbsoluteFile: filename,
+            specifier,
+            specifiers: path.node.specifiers,
+            workflowNameCache: new Map()
+          } );
+          if ( outcome.type === 'all' ) {
+            for ( const { localName } of outcome.bindings ) {
+              importedWorkflowIds.add( localName );
+            }
+          }
+          return;
+        }
+
         // Collect imported identifiers for later call checks
         const importedKind = getFileKind( specifier );
         const accumulator = ( {
@@ -141,6 +183,29 @@ export default function workflowValidatorLoader( source, inputMap ) {
           }
           const req = firstArg.value;
 
+          if ( isBareNpmSpecifier( req ) && fileMayBindBareNpmWorkflowImports( filename ) ) {
+            if ( isObjectPattern( path.node.id ) ) {
+              const outcome = resolveBareDestructuredRequireAsWorkflows( {
+                fromAbsoluteFile: filename,
+                specifier: req,
+                properties: path.node.id.properties,
+                workflowNameCache: new Map()
+              } );
+              if ( outcome.type === 'all' ) {
+                for ( const { localName } of outcome.bindings ) {
+                  importedWorkflowIds.add( localName );
+                }
+              }
+            } else if ( isIdentifier( path.node.id ) ) {
+              const outcome = resolveBareDefaultRequireAsWorkflow(
+                filename, req, path.node.id.name, new Map()
+              );
+              if ( outcome.type === 'binding' ) {
+                importedWorkflowIds.add( outcome.localName );
+              }
+            }
+          }
+
           // Collect imported identifiers from require patterns
           const reqType = getFileKind( toAbsolutePath( fileDir, req ) );
           if ( reqType === ComponentFile.STEPS && isObjectPattern( path.node.id ) ) {

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

@@ -4,6 +4,28 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import validatorLoader from './index.mjs';
 
+/**
+ * Minimal published catalog under `dir/node_modules` so `require.resolve` / export following works.
+ * @param {string} dir - Temp project root containing `steps.js` / `workflow.js` under test.
+ * @param {string} workflowName - Declared workflow `name` in the leaf `workflow.js`.
+ */
+const writeMockGrowthxlabsCatalog = ( dir, workflowName ) => {
+  const pkgRoot = join( dir, 'node_modules', '@growthxlabs', 'workflows_catalog' );
+  const srcDir = join( pkgRoot, 'src' );
+  mkdirSync( join( srcDir, 'workflows', 'wf' ), { recursive: true } );
+  writeFileSync( join( pkgRoot, 'package.json' ), JSON.stringify( {
+    name: '@growthxlabs/workflows_catalog',
+    type: 'module',
+    main: './src/index.js',
+    dependencies: { '@outputai/core': '1.0.0' }
+  } ) );
+  writeFileSync( join( srcDir, 'index.js' ), 'export { default as sumNumbers } from \'./workflows/wf/workflow.js\';\n' );
+  writeFileSync(
+    join( srcDir, 'workflows', 'wf', 'workflow.js' ),
+    `export default workflow({ name: '${workflowName}' });\n`
+  );
+};
+
 function runLoader( filename, source ) {
   return new Promise( ( resolve, reject ) => {
     const warnings = [];
@@ -76,6 +98,46 @@ describe( 'workflow_validator loader', () => {
     rmSync( dir, { recursive: true, force: true } );
   } );
 
+  it( 'steps.js: warns when calling imported catalog workflow inside fn', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'steps-catalog-warn-' ) );
+    writeMockGrowthxlabsCatalog( dir, 'cat.warn' );
+    const src = [
+      'import { sumNumbers } from "@growthxlabs/workflows_catalog";',
+      'const A = step({ name: "a", fn: async () => ({}) });',
+      'const obj = { fn: function() { sumNumbers(); } };'
+    ].join( '\n' );
+    const result = await runLoader( join( dir, 'steps.js' ), src );
+    expect( result.warnings ).toHaveLength( 1 );
+    expect( result.warnings[0].message ).toMatch( /Invalid call in .*steps\.js fn: calling a workflow/ );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'evaluators.js: warns when calling catalog workflow inside fn (require)', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'evals-catalog-warn-' ) );
+    writeMockGrowthxlabsCatalog( dir, 'cat.warn.req' );
+    const src = [
+      'const { sumNumbers } = require("@growthxlabs/workflows_catalog");',
+      'const E = evaluator({ name: "e", fn: async () => ({ value: 1 }) });',
+      'const obj = { fn: function() { sumNumbers(); } };'
+    ].join( '\n' );
+    const result = await runLoader( join( dir, 'evaluators.js' ), src );
+    expect( result.warnings ).toHaveLength( 1 );
+    expect( result.warnings[0].message ).toMatch( /Invalid call in .*evaluators\.js fn: calling a workflow/ );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'workflow.js: allows import from @growthxlabs/workflows_catalog', async () => {
+    const dir = mkdtempSync( join( tmpdir(), 'wf-catalog-allow-' ) );
+    writeMockGrowthxlabsCatalog( dir, 'cat.allow' );
+    const src = [
+      'import { sumNumbers } from "@growthxlabs/workflows_catalog";',
+      'const x = 1;'
+    ].join( '\n' );
+    const result = await runLoader( join( dir, 'workflow.js' ), src );
+    expect( result.warnings ).toHaveLength( 0 );
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
   it( 'steps.js: warns when calling another step inside fn', async () => {
     const dir = mkdtempSync( join( tmpdir(), 'steps-call-reject-' ) );
     // Can only test same-type components since cross-type declarations are now blocked by instantiation validation