@outputai/core 0.3.3-next.e8eff63.0 → 0.4.0

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

@@ -0,0 +1,374 @@
+import { describe, it, expect } from 'vitest';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { parse } from './tools.js';
+import {
+  isBareNpmSpecifier,
+  resolveBareImportSpecifiersAsWorkflows,
+  resolveBareDestructuredRequireAsWorkflows,
+  resolveBareDefaultRequireAsWorkflow
+} from './npm_workflow_export_resolve.js';
+
+/**
+ * @param {(dir: string) => void} fn
+ */
+const withTempProjectDir = fn => {
+  const dir = mkdtempSync( join( tmpdir(), 'npm-resolve-' ) );
+  try {
+    fn( dir );
+  } finally {
+    rmSync( dir, { recursive: true, force: true } );
+  }
+};
+
+/**
+ * @param {string} source - Single import declaration source line (no newline required).
+ * @returns {import('@babel/types').ImportDeclaration['specifiers']}
+ */
+const importSpecifiersFromSource = source => {
+  const ast = parse( `${source}\n`, 'stub.js' );
+  const decl = ast.program.body[0];
+  if ( decl.type !== 'ImportDeclaration' ) {
+    throw new Error( 'expected ImportDeclaration' );
+  }
+  return decl.specifiers;
+};
+
+/**
+ * @param {string} source - `const { ... } = require('...');`
+ */
+const destructuredRequirePropertiesFromSource = source => {
+  const ast = parse( `${source}\n`, 'stub.js' );
+  const stmt = ast.program.body[0];
+  if ( stmt.type !== 'VariableDeclaration' || !stmt.declarations[0] ) {
+    throw new Error( 'expected VariableDeclaration' );
+  }
+  const pat = stmt.declarations[0].id;
+  if ( pat.type !== 'ObjectPattern' ) {
+    throw new Error( 'expected ObjectPattern' );
+  }
+  return pat.properties;
+};
+
+/**
+ * Writes a minimal package under `root/node_modules/<name>` with given files (relative paths).
+ *
+ * @param {string} root - Project root containing `node_modules`.
+ * @param {string} name - Package name e.g. `@test/catalog`.
+ * @param {string} main - Relative main entry from package root.
+ * @param {Record<string, string>} files - Relative path -> file contents.
+ * @param {object} [extraPackageJson] - Extra fields to merge into package.json.
+ */
+const writeNodeModulesPackage = ( root, name, main, files, extraPackageJson = {} ) => {
+  const pkgRoot = name.startsWith( '@' ) ?
+    join( root, 'node_modules', ...name.split( '/' ) ) :
+    join( root, 'node_modules', name );
+  mkdirSync( pkgRoot, { recursive: true } );
+  writeFileSync(
+    join( pkgRoot, 'package.json' ),
+    JSON.stringify( { name, version: '1.0.0', main, ...extraPackageJson }, null, 2 )
+  );
+  for ( const [ rel, content ] of Object.entries( files ) ) {
+    const abs = join( pkgRoot, rel );
+    mkdirSync( dirname( abs ), { recursive: true } );
+    writeFileSync( abs, content );
+  }
+  return pkgRoot;
+};
+
+describe( 'isBareNpmSpecifier', () => {
+  it( 'returns false for empty or non-string', () => {
+    expect( isBareNpmSpecifier( '' ) ).toBe( false );
+    expect( isBareNpmSpecifier( undefined ) ).toBe( false );
+  } );
+
+  it( 'returns false for relative and absolute paths', () => {
+    expect( isBareNpmSpecifier( './x' ) ).toBe( false );
+    expect( isBareNpmSpecifier( '../x' ) ).toBe( false );
+    expect( isBareNpmSpecifier( '/abs' ) ).toBe( false );
+  } );
+
+  it( 'returns false for node:, file:, data:, http(s):', () => {
+    expect( isBareNpmSpecifier( 'node:fs' ) ).toBe( false );
+    expect( isBareNpmSpecifier( 'file:///x' ) ).toBe( false );
+    expect( isBareNpmSpecifier( 'data:,x' ) ).toBe( false );
+    expect( isBareNpmSpecifier( 'http://x' ) ).toBe( false );
+    expect( isBareNpmSpecifier( 'https://x' ) ).toBe( false );
+  } );
+
+  it( 'returns true for bare package names', () => {
+    expect( isBareNpmSpecifier( 'lodash' ) ).toBe( true );
+    expect( isBareNpmSpecifier( '@scope/pkg' ) ).toBe( true );
+  } );
+} );
+
+describe( 'resolveBareImportSpecifiersAsWorkflows', () => {
+  it( 'returns none when the specifier does not resolve', () => {
+    withTempProjectDir( dir => {
+      const wf = join( dir, 'workflow.js' );
+      writeFileSync( wf, 'export default workflow({ name: \'local\' });\n' );
+
+      const out = resolveBareImportSpecifiersAsWorkflows( {
+        fromAbsoluteFile: wf,
+        specifier: '@missing-scope/missing-pkg-xyz',
+        specifiers: importSpecifiersFromSource( 'import x from \'@missing-scope/missing-pkg-xyz\'' ),
+        workflowNameCache: new Map()
+      } );
+      expect( out ).toEqual( { type: 'none' } );
+    } );
+  } );
+
+  it( 'throws for namespace imports from workflow packages', () => {
+    withTempProjectDir( dir => {
+      const wf = join( dir, 'workflow.js' );
+      writeFileSync( wf, 'export default workflow({ name: \'local\' });\n' );
+      writeNodeModulesPackage( dir, '@test/ns', './index.js', {
+        'index.js': 'export { default as nsWorkflow } from \'./workflow.js\';\n',
+        'workflow.js': 'export default workflow({ name: \'ns.wf\' });\n'
+      } );
+
+      expect( () => resolveBareImportSpecifiersAsWorkflows( {
+        fromAbsoluteFile: wf,
+        specifier: '@test/ns',
+        specifiers: importSpecifiersFromSource( 'import * as ns from \'@test/ns\'' ),
+        workflowNameCache: new Map()
+      } ) ).toThrow(
+        'Namespace imports from workflow package "@test/ns" are not supported. ' +
+        'Use named imports instead, e.g. import { myWorkflow } from \'@test/ns\'.'
+      );
+    } );
+  } );
+
+  it( 'returns none for namespace imports from non-workflow packages', () => {
+    withTempProjectDir( dir => {
+      const wf = join( dir, 'workflow.js' );
+      writeFileSync( wf, 'export default workflow({ name: \'local\' });\n' );
+      writeNodeModulesPackage( dir, '@test/helper', './index.js', {
+        'index.js': 'export const helper = () => 1;\n'
+      } );
+
+      const out = resolveBareImportSpecifiersAsWorkflows( {
+        fromAbsoluteFile: wf,
+        specifier: '@test/helper',
+        specifiers: importSpecifiersFromSource( 'import * as helper from \'@test/helper\'' ),
+        workflowNameCache: new Map()
+      } );
+      expect( out ).toEqual( { type: 'none' } );
+    } );
+  } );
+
+  it( 'resolves default import to the package default workflow name', () => {
+    withTempProjectDir( dir => {
+      const importing = join( dir, 'workflow.js' );
+      writeFileSync( importing, 'export default workflow({ name: \'local\' });\n' );
+      writeNodeModulesPackage( dir, '@test/wfdef', './workflow.js', {
+        'workflow.js': 'export default workflow({ name: \'pkg.default\' });\n'
+      } );
+
+      const out = resolveBareImportSpecifiersAsWorkflows( {
+        fromAbsoluteFile: importing,
+        specifier: '@test/wfdef',
+        specifiers: importSpecifiersFromSource( 'import PkgDef from \'@test/wfdef\'' ),
+        workflowNameCache: new Map()
+      } );
+      expect( out ).toEqual( {
+        type: 'all',
+        bindings: [ { localName: 'PkgDef', workflowName: 'pkg.default' } ]
+      } );
+    } );
+  } );
+
+  it( 'prefers the output workflow bundle export condition over the default entry', () => {
+    withTempProjectDir( dir => {
+      const importing = join( dir, 'workflow.js' );
+      writeFileSync( importing, 'export default workflow({ name: \'local\' });\n' );
+      writeNodeModulesPackage( dir, '@test/conditional', './node-entry.js', {
+        'node-entry.js': 'export const helper = () => 1;\n',
+        'bundle/workflow.js': 'export default workflow({ name: \'bundle.workflow\' });\n'
+      }, {
+        exports: {
+          '.': {
+            'output-workflow-bundle': './bundle/workflow.js',
+            default: './node-entry.js'
+          }
+        }
+      } );
+
+      const out = resolveBareImportSpecifiersAsWorkflows( {
+        fromAbsoluteFile: importing,
+        specifier: '@test/conditional',
+        specifiers: importSpecifiersFromSource( 'import BundleWorkflow from \'@test/conditional\'' ),
+        workflowNameCache: new Map()
+      } );
+      expect( out ).toEqual( {
+        type: 'all',
+        bindings: [ { localName: 'BundleWorkflow', workflowName: 'bundle.workflow' } ]
+      } );
+    } );
+  } );
+
+  it( 'supports root conditional exports without an explicit dot key', () => {
+    withTempProjectDir( dir => {
+      const importing = join( dir, 'workflow.js' );
+      writeFileSync( importing, 'export default workflow({ name: \'local\' });\n' );
+      writeNodeModulesPackage( dir, '@test/root-conditional', './node-entry.js', {
+        'node-entry.js': 'export const helper = () => 1;\n',
+        'workflow.js': 'export default workflow({ name: \'root.conditional\' });\n'
+      }, {
+        exports: {
+          'output-workflow-bundle': './workflow.js',
+          default: './node-entry.js'
+        }
+      } );
+
+      const out = resolveBareImportSpecifiersAsWorkflows( {
+        fromAbsoluteFile: importing,
+        specifier: '@test/root-conditional',
+        specifiers: importSpecifiersFromSource( 'import RootWorkflow from \'@test/root-conditional\'' ),
+        workflowNameCache: new Map()
+      } );
+      expect( out ).toEqual( {
+        type: 'all',
+        bindings: [ { localName: 'RootWorkflow', workflowName: 'root.conditional' } ]
+      } );
+    } );
+  } );
+
+  it( 'uses webpack export condition when workflow bundle condition is absent', () => {
+    withTempProjectDir( dir => {
+      const importing = join( dir, 'workflow.js' );
+      writeFileSync( importing, 'export default workflow({ name: \'local\' });\n' );
+      writeNodeModulesPackage( dir, '@test/webpack-conditional', './node-entry.js', {
+        'node-entry.js': 'export const helper = () => 1;\n',
+        'webpack/workflow.js': 'export default workflow({ name: \'webpack.workflow\' });\n'
+      }, {
+        exports: {
+          '.': {
+            webpack: './webpack/workflow.js',
+            default: './node-entry.js'
+          }
+        }
+      } );
+
+      const out = resolveBareImportSpecifiersAsWorkflows( {
+        fromAbsoluteFile: importing,
+        specifier: '@test/webpack-conditional',
+        specifiers: importSpecifiersFromSource( 'import WebpackWorkflow from \'@test/webpack-conditional\'' ),
+        workflowNameCache: new Map()
+      } );
+      expect( out ).toEqual( {
+        type: 'all',
+        bindings: [ { localName: 'WebpackWorkflow', workflowName: 'webpack.workflow' } ]
+      } );
+    } );
+  } );
+
+  it( 'follows re-exports to workflow.js for a named import', () => {
+    withTempProjectDir( dir => {
+      const importing = join( dir, 'workflow.js' );
+      writeFileSync( importing, 'export default workflow({ name: \'local\' });\n' );
+      writeNodeModulesPackage( dir, '@test/catalog', './src/index.js', {
+        'src/index.js': 'export { default as sumNumbers } from \'./wf/workflow.js\';\n',
+        'src/wf/workflow.js': 'export default workflow({ name: \'sum.numbers\' });\n'
+      } );
+
+      const out = resolveBareImportSpecifiersAsWorkflows( {
+        fromAbsoluteFile: importing,
+        specifier: '@test/catalog',
+        specifiers: importSpecifiersFromSource( 'import { sumNumbers } from \'@test/catalog\'' ),
+        workflowNameCache: new Map()
+      } );
+      expect( out ).toEqual( {
+        type: 'all',
+        bindings: [ { localName: 'sumNumbers', workflowName: 'sum.numbers' } ]
+      } );
+    } );
+  } );
+
+  it( 'returns partial when one named import does not resolve to a workflow', () => {
+    withTempProjectDir( dir => {
+      const importing = join( dir, 'workflow.js' );
+      writeFileSync( importing, 'export default workflow({ name: \'local\' });\n' );
+      writeNodeModulesPackage( dir, '@test/partial', './index.js', {
+        'index.js': 'export { default as Good } from \'./wf/workflow.js\';\n',
+        'wf/workflow.js': 'export default workflow({ name: \'good.def\' });\n'
+      } );
+
+      const out = resolveBareImportSpecifiersAsWorkflows( {
+        fromAbsoluteFile: importing,
+        specifier: '@test/partial',
+        specifiers: importSpecifiersFromSource( 'import { Good, MissingExport } from \'@test/partial\'' ),
+        workflowNameCache: new Map()
+      } );
+      expect( out.type ).toBe( 'partial' );
+    } );
+  } );
+} );
+
+describe( 'resolveBareDestructuredRequireAsWorkflows', () => {
+  it( 'resolves destructured keys to workflow names', () => {
+    withTempProjectDir( dir => {
+      const importing = join( dir, 'workflow.js' );
+      writeFileSync( importing, 'export default workflow({ name: \'local\' });\n' );
+      writeNodeModulesPackage( dir, '@test/destr', './index.js', {
+        'index.js': 'export { default as alpha } from \'./wf/workflow.js\';\n',
+        'wf/workflow.js': 'export default workflow({ name: \'alpha.wf\' });\n'
+      } );
+
+      const props = destructuredRequirePropertiesFromSource(
+        'const { alpha: A } = require(\'@test/destr\');'
+      );
+      const out = resolveBareDestructuredRequireAsWorkflows( {
+        fromAbsoluteFile: importing,
+        specifier: '@test/destr',
+        properties: props,
+        workflowNameCache: new Map()
+      } );
+      expect( out ).toEqual( {
+        type: 'all',
+        bindings: [ { localName: 'A', workflowName: 'alpha.wf' } ]
+      } );
+    } );
+  } );
+} );
+
+describe( 'resolveBareDefaultRequireAsWorkflow', () => {
+  it( 'returns binding when default resolves to a workflow', () => {
+    withTempProjectDir( dir => {
+      const importing = join( dir, 'workflow.js' );
+      writeFileSync( importing, 'export default workflow({ name: \'local\' });\n' );
+      writeNodeModulesPackage( dir, '@test/defreq', './entry.js', {
+        'entry.js': 'export { default } from \'./wf/workflow.js\';\n',
+        'wf/workflow.js': 'export default workflow({ name: \'chain.def\' });\n'
+      } );
+
+      const out = resolveBareDefaultRequireAsWorkflow(
+        importing,
+        '@test/defreq',
+        'Cat',
+        new Map()
+      );
+      expect( out ).toEqual( {
+        type: 'binding',
+        localName: 'Cat',
+        workflowName: 'chain.def'
+      } );
+    } );
+  } );
+
+  it( 'returns none when nothing resolves', () => {
+    withTempProjectDir( dir => {
+      const importing = join( dir, 'workflow.js' );
+      writeFileSync( importing, 'export default workflow({ name: \'local\' });\n' );
+
+      const out = resolveBareDefaultRequireAsWorkflow(
+        importing,
+        '@ghost/no-such-pkg',
+        'X',
+        new Map()
+      );
+      expect( out ).toEqual( { type: 'none' } );
+    } );
+  } );
+} );

package/src/worker/webpack_loaders/tools.js

@@ -195,6 +195,15 @@ export const isAnyEvaluatorsPath = value =>
  */
 export const isWorkflowPath = value => /(^|\/)workflow\.js$/.test( value );
 
+/**
+ * True when `resourcePath` is an absolute path to a `workflow.js` file (slashes normalized).
+ *
+ * @param {string|null|undefined} resourcePath - Webpack `resourcePath` or similar.
+ * @returns {boolean}
+ */
+export const isAbsoluteWorkflowJsResource = resourcePath =>
+  typeof resourcePath === 'string' && isWorkflowPath( resourcePath.replace( /\\/g, '/' ) );
+
 /**
  * Check if a path is a component file (steps, evaluators, or workflow).
  * @param {string} value - Module path or request string.

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

@@ -16,6 +16,7 @@ import {
   isEvaluatorsPath,
   isSharedEvaluatorsPath,
   isWorkflowPath,
+  isAbsoluteWorkflowJsResource,
   createThisMethodCall,
   resolveNameFromArg,
   resolveNameFromOptions,
@@ -191,6 +192,12 @@ describe( 'workflow_rewriter tools', () => {
     expect( isWorkflowPath( 'steps.js' ) ).toBe( false );
   } );
 
+  it( 'isAbsoluteWorkflowJsResource: normalizes slashes', () => {
+    expect( isAbsoluteWorkflowJsResource( '/a/b/workflow.js' ) ).toBe( true );
+    expect( isAbsoluteWorkflowJsResource( 'C:\\\\a\\\\workflow.js' ) ).toBe( true );
+    expect( isAbsoluteWorkflowJsResource( '/a/b/steps.js' ) ).toBe( false );
+  } );
+
   it( 'isEvaluatorsPath: matches local evaluators.js but excludes shared', () => {
     expect( isEvaluatorsPath( 'evaluators.js' ) ).toBe( true );
     expect( isEvaluatorsPath( './evaluators.js' ) ).toBe( true );

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

@@ -1,18 +1,27 @@
+import { join } from 'node:path';
 import traverseModule from '@babel/traverse';
 import {
   buildWorkflowNameMap,
+  buildEvaluatorsNameMap,
+  buildSharedEvaluatorsNameMap,
+  buildSharedStepsNameMap,
+  buildStepsNameMap,
   getLocalNameFromDestructuredProperty,
+  isAbsoluteWorkflowJsResource,
   isEvaluatorsPath,
   isSharedEvaluatorsPath,
   isSharedStepsPath,
   isStepsPath,
   isWorkflowPath,
-  buildStepsNameMap,
-  buildSharedStepsNameMap,
-  buildEvaluatorsNameMap,
-  buildSharedEvaluatorsNameMap,
   toAbsolutePath
 } from '../tools.js';
+import {
+  isBareNpmSpecifier,
+  resolveBareImportSpecifiersAsWorkflows,
+  resolveBareDestructuredRequireAsWorkflows,
+  resolveBareDefaultRequireAsWorkflow
+} from '../npm_workflow_export_resolve.js';
+
 import {
   isCallExpression,
   isIdentifier,
@@ -35,6 +44,12 @@ const unresolvedImportError = ( name, fileLabel, filePath ) =>
     '(e.g. step() in steps files, evaluator() in evaluators files, workflow() in workflow files).'
   );
 
+const mixedBareWorkflowImportError = ( specifier, resourcePath ) => new Error(
+  `Workflow file '${resourcePath}': import from '${specifier}' mixes workflow exports with ` +
+  'non-workflow exports, or could not resolve every binding to a workflow.js module. ' +
+  'Split npm imports so each declaration only imports workflows, or only non-workflows.'
+);
+
 const removeRequireDeclarator = path => {
   if ( isVariableDeclaration( path.parent ) && path.parent.declarations.length === 1 ) {
     path.parentPath.remove();
@@ -77,13 +92,17 @@ const collectDestructuredRequires = ( path, absolutePath, req, descriptors ) =>
  * @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.
+ * @param {string} [resourcePath] - Absolute path of the file being transformed; used to resolve
+ *  npm package imports from `workflow.js` via Node resolution and export following.
  * @returns {{ stepImports: Array<{localName:string,stepName:string}>,
  *  flowImports: Array<{localName:string,workflowName:string}> }} Collected info mappings.
  */
 export default function collectTargetImports(
   ast, fileDir,
-  { stepsNameCache, workflowNameCache, evaluatorsNameCache, sharedStepsNameCache, sharedEvaluatorsNameCache }
+  { stepsNameCache, workflowNameCache, evaluatorsNameCache, sharedStepsNameCache, sharedEvaluatorsNameCache },
+  resourcePath
 ) {
+  const resolutionPath = resourcePath ?? join( fileDir, 'file.js' );
   const stepImports = [];
   const sharedStepImports = [];
   const flowImports = [];
@@ -93,9 +112,29 @@ export default function collectTargetImports(
   traverse( ast, {
     ImportDeclaration: path => {
       const src = path.node.source.value;
-      // Ignore other imports
+
+      if ( isBareNpmSpecifier( src ) && isAbsoluteWorkflowJsResource( resolutionPath ) ) {
+        const outcome = resolveBareImportSpecifiersAsWorkflows( {
+          fromAbsoluteFile: resolutionPath,
+          specifier: src,
+          specifiers: path.node.specifiers,
+          workflowNameCache
+        } );
+        if ( outcome.type === 'partial' ) {
+          throw mixedBareWorkflowImportError( src, resolutionPath );
+        }
+        if ( outcome.type === 'all' ) {
+          for ( const { localName, workflowName } of outcome.bindings ) {
+            flowImports.push( { localName, workflowName } );
+          }
+          path.remove();
+          return;
+        }
+      }
+
       const isTargetImport = isStepsPath( src ) || isSharedStepsPath( src ) ||
-        isWorkflowPath( src ) || isEvaluatorsPath( src ) || isSharedEvaluatorsPath( src );
+        isWorkflowPath( src ) ||
+        isEvaluatorsPath( src ) || isSharedEvaluatorsPath( src );
       if ( !isTargetImport ) {
         return;
       }
@@ -161,15 +200,46 @@ export default function collectTargetImports(
       }
 
       const req = firstArgument.value;
+
+      if ( isBareNpmSpecifier( req ) && isAbsoluteWorkflowJsResource( resolutionPath ) ) {
+        if ( isObjectPattern( path.node.id ) ) {
+          const outcome = resolveBareDestructuredRequireAsWorkflows( {
+            fromAbsoluteFile: resolutionPath,
+            specifier: req,
+            properties: path.node.id.properties,
+            workflowNameCache
+          } );
+          if ( outcome.type === 'partial' ) {
+            throw mixedBareWorkflowImportError( req, resolutionPath );
+          }
+          if ( outcome.type === 'all' ) {
+            for ( const { localName, workflowName } of outcome.bindings ) {
+              flowImports.push( { localName, workflowName } );
+            }
+            removeRequireDeclarator( path );
+            return;
+          }
+        } else if ( isIdentifier( path.node.id ) ) {
+          const outcome = resolveBareDefaultRequireAsWorkflow(
+            resolutionPath, req, path.node.id.name, workflowNameCache
+          );
+          if ( outcome.type === 'binding' ) {
+            flowImports.push( { localName: outcome.localName, workflowName: outcome.workflowName } );
+            removeRequireDeclarator( path );
+            return;
+          }
+        }
+      }
+
       const isTargetRequire = isStepsPath( req ) || isSharedStepsPath( req ) ||
-        isWorkflowPath( req ) || isEvaluatorsPath( req ) || isSharedEvaluatorsPath( req );
+        isWorkflowPath( req ) ||
+        isEvaluatorsPath( req ) || isSharedEvaluatorsPath( req );
       if ( !isTargetRequire ) {
         return;
       }
 
       const absolutePath = toAbsolutePath( fileDir, req );
 
-      // Destructured requires: const { X } = require('./steps.js')
       if ( isObjectPattern( path.node.id ) ) {
         const cjsDescriptors = [
           {
@@ -207,7 +277,6 @@ export default function collectTargetImports(
         return;
       }
 
-      // Default workflow require: const WF = require('./workflow.js')
       if ( isWorkflowPath( req ) && isIdentifier( path.node.id ) ) {
         const { default: defName } = buildWorkflowNameMap( absolutePath, workflowNameCache );
         const localName = path.node.id.name;
@@ -218,4 +287,4 @@ export default function collectTargetImports(
   } );
 
   return { stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports, flowImports };
-};
+}

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

@@ -332,5 +332,72 @@ const obj = {};`;
 
     rmSync( dir, { recursive: true, force: true } );
   } );
+
+  it( 'collects ESM imports from @growthxlabs/workflows_catalog', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-cat-esm-' ) );
+    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: \'cat.flow\' });\n' );
+
+    const fileDir = join( dir, 'consumer' );
+    mkdirSync( fileDir, { recursive: true } );
+    const resourcePath = join( fileDir, 'workflow.js' );
+
+    const source = `
+import { sumNumbers as SN } from '@growthxlabs/workflows_catalog';
+const x = 1;`;
+    const ast = makeAst( source, resourcePath );
+
+    const { flowImports } = collectTargetImports(
+      ast,
+      fileDir,
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() },
+      resourcePath
+    );
+    expect( flowImports ).toEqual( [ { localName: 'SN', workflowName: 'cat.flow' } ] );
+    expect( ast.program.body.find( n => n.type === 'ImportDeclaration' ) ).toBeUndefined();
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
+
+  it( 'collects CJS destructured require from @growthxlabs/workflows_catalog', () => {
+    const dir = mkdtempSync( join( tmpdir(), 'collect-cat-cjs-' ) );
+    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: \'cat.flow2\' });\n' );
+
+    const fileDir = join( dir, 'consumer' );
+    mkdirSync( fileDir, { recursive: true } );
+    const resourcePath = join( fileDir, 'workflow.js' );
+
+    const source = 'const { sumNumbers } = require( \'@growthxlabs/workflows_catalog\' );\nconst x = 1;';
+    const ast = makeAst( source, resourcePath );
+
+    const { flowImports } = collectTargetImports(
+      ast,
+      fileDir,
+      { stepsNameCache: new Map(), evaluatorsNameCache: new Map(), workflowNameCache: new Map() },
+      resourcePath
+    );
+    expect( flowImports ).toEqual( [ { localName: 'sumNumbers', workflowName: 'cat.flow2' } ] );
+
+    rmSync( dir, { recursive: true, force: true } );
+  } );
 } );
 

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

@@ -34,7 +34,8 @@ export default function stepImportRewriterAstLoader( source, inputMap ) {
     const filename = this.resourcePath;
     const ast = parse( String( source ), filename );
     const fileDir = dirname( filename );
-    const { stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports, flowImports } = collectTargetImports( ast, fileDir, cache );
+    const { stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports, flowImports } =
+      collectTargetImports( ast, fileDir, cache, filename );
 
     // No imports
     if ( [].concat( stepImports, sharedStepImports, evaluatorImports, sharedEvaluatorImports, flowImports ).length === 0 ) {