fix(nx-infra-plugin): handle flat transpile layout in state-manager-optimize and fail fast

Author: chaosmirage

packages/nx-infra-plugin/src/executors/state-manager-optimize/executor.e2e.spec.ts

@@ -1,5 +1,6 @@
 import * as fs from 'fs';
 import * as path from 'path';
+import { logger } from '@nx/devkit';
 import executor from './executor';
 import { StateManagerOptimizeExecutorSchema } from './schema';
 import {
@@ -37,9 +38,9 @@ describe('StateManagerOptimizeExecutor E2E', () => {
   const indexPathFor = (variant: Variant): string =>
     path.join(stateManagerAbsoluteFor(variant), 'index.js');
 
-  const runOptimize = async (): Promise<void> => {
+  const runOptimize = async (): Promise<{ success: boolean }> => {
     const options: StateManagerOptimizeExecutorSchema = { transpiledDirs: [TRANSPILED_DIR] };
-    await executor(options, context);
+    return executor(options, context);
   };
 
   beforeEach(async () => {
@@ -98,4 +99,51 @@ describe('StateManagerOptimizeExecutor E2E', () => {
     const cjsIndexContent = await readFileText(indexPathFor('cjs'));
     expect(cjsIndexContent).toContain('require("./prod/index")');
   }, 30000);
+
+  it('should optimize index.js when state_manager lives at flat root layout (no cjs/esm variant subdir)', async () => {
+    const flatStateManagerDir = path.join(projectDir, TRANSPILED_DIR, STATE_MANAGER_RELATIVE_PATH);
+    await writeFileText(path.join(flatStateManagerDir, 'index.js'), INDEX_DEV_CONTENT);
+    await writeFileText(path.join(flatStateManagerDir, 'dev', 'index.js'), DEV_FILE_CONTENT);
+    await writeFileText(path.join(flatStateManagerDir, 'prod', 'index.js'), PROD_FILE_CONTENT);
+    await writeFileText(
+      path.join(flatStateManagerDir, 'state_manager.test.js'),
+      TOP_LEVEL_NON_INDEX_CONTENT,
+    );
+
+    await runOptimize();
+
+    expect(await readFileText(path.join(flatStateManagerDir, 'index.js'))).toBe(INDEX_PROD_CONTENT);
+    expect(fs.existsSync(path.join(flatStateManagerDir, 'dev'))).toBe(false);
+    expect(fs.existsSync(path.join(flatStateManagerDir, 'state_manager.test.js'))).toBe(false);
+    expect(await readFileText(path.join(flatStateManagerDir, 'prod', 'index.js'))).toBe(
+      PROD_FILE_CONTENT,
+    );
+  }, 30000);
+
+  it('should optimize state_manager at any depth (mixed flat + nested in same tree)', async () => {
+    const flatStateManagerDir = path.join(projectDir, TRANSPILED_DIR, STATE_MANAGER_RELATIVE_PATH);
+    await writeFileText(path.join(flatStateManagerDir, 'index.js'), INDEX_DEV_CONTENT);
+    await writeFileText(path.join(flatStateManagerDir, 'dev', 'index.js'), DEV_FILE_CONTENT);
+    await writeFileText(path.join(flatStateManagerDir, 'prod', 'index.js'), PROD_FILE_CONTENT);
+
+    await runOptimize();
+
+    expect(await readFileText(path.join(flatStateManagerDir, 'index.js'))).toBe(INDEX_PROD_CONTENT);
+    expect(await readFileText(indexPathFor('cjs'))).toContain('require("./prod/index")');
+  }, 30000);
+
+  it('should throw when no state_manager directories are found in any transpiledDir', async () => {
+    const errorSpy = jest.spyOn(logger, 'error').mockImplementation(() => undefined);
+
+    const options: StateManagerOptimizeExecutorSchema = {
+      transpiledDirs: ['./artifacts/transpiled-no-state-manager'],
+    };
+    const result = await executor(options, context);
+
+    expect(result.success).toBe(false);
+    const errorMessage = String(errorSpy.mock.calls[0][0]);
+    expect(errorMessage).toContain('No state_manager/index.js');
+
+    errorSpy.mockRestore();
+  }, 30000);
 });

packages/nx-infra-plugin/src/executors/state-manager-optimize/state-manager-optimize.impl.ts

@@ -1,21 +1,20 @@
-import * as fs from 'fs-extra';
 import * as path from 'path';
 import * as babel from '@babel/core';
+import { glob } from 'glob';
 import { logger } from '@nx/devkit';
 import { createExecutor } from '../../utils/create-executor';
 import { writeFileText } from '../../utils/file-operations';
 import { removeDirectoryRespectingExclusions } from '../clean/clean.impl';
+import { toPosixPath } from '../../utils/path-resolver';
 import { StateManagerOptimizeExecutorSchema } from './schema';
 
 const ESM_REEXPORT = "export * from './prod/index';";
-const STATE_MANAGER_REL_PATH = path.join('__internal', 'core', 'state_manager');
+const STATE_MANAGER_INDEX_GLOB = '**/__internal/core/state_manager/index.js';
 const ERROR_BABEL_NO_CODE = 'Babel returned no code for CJS state_manager index.js';
+const ERROR_NO_STATE_MANAGER_FOUND =
+  'No state_manager/index.js found in any configured transpiledDirs';
 
-const VARIANTS = ['esm', 'cjs'] as const;
-type Variant = (typeof VARIANTS)[number];
-type ContentBuilder = (indexPath: string) => string;
-
-function transformReexportToCjs(indexPath: string): string {
+export function transformReexportToCjs(indexPath: string): string {
   const result = babel.transformSync(ESM_REEXPORT, {
     filename: indexPath,
     plugins: [['@babel/plugin-transform-modules-commonjs']],
@@ -28,33 +27,33 @@ function transformReexportToCjs(indexPath: string): string {
   return result.code;
 }
 
-const CONTENT_BUILDERS: Record<Variant, ContentBuilder> = {
-  esm: () => ESM_REEXPORT,
-  cjs: (indexPath) => transformReexportToCjs(indexPath),
-};
-
-async function optimizeVariant(variant: Variant, transpiledRoot: string): Promise<void> {
-  const stateManagerDir = path.join(transpiledRoot, variant, STATE_MANAGER_REL_PATH);
-
-  if (!fs.existsSync(stateManagerDir)) {
-    logger.verbose(`Skipping ${variant} state_manager: ${stateManagerDir} does not exist`);
-    return;
-  }
+function isCjsFile(filePath: string): boolean {
+  return toPosixPath(filePath).includes('/cjs/');
+}
 
-  const indexPath = path.join(stateManagerDir, 'index.js');
-  if (fs.existsSync(indexPath)) {
-    await writeFileText(indexPath, CONTENT_BUILDERS[variant](indexPath));
-  }
+async function optimizeIndexFile(indexPath: string): Promise<void> {
+  const content = isCjsFile(indexPath) ? transformReexportToCjs(indexPath) : ESM_REEXPORT;
+  await writeFileText(indexPath, content);
 
+  const stateManagerDir = path.dirname(indexPath);
   await removeDirectoryRespectingExclusions(stateManagerDir, [
     indexPath,
     path.join(stateManagerDir, 'prod'),
   ]);
 }
 
-async function optimizeTranspiledDir(transpiledDir: string, projectRoot: string): Promise<void> {
-  const transpiledRoot = path.join(projectRoot, transpiledDir);
-  await Promise.all(VARIANTS.map((variant) => optimizeVariant(variant, transpiledRoot)));
+async function optimizeTranspiledDir(transpiledRoot: string): Promise<number> {
+  const indexFiles = await glob(STATE_MANAGER_INDEX_GLOB, {
+    cwd: toPosixPath(transpiledRoot),
+    absolute: true,
+    nodir: true,
+  });
+
+  logger.verbose(`Found ${indexFiles.length} state_manager index.js file(s) in ${transpiledRoot}`);
+
+  await Promise.all(indexFiles.map(optimizeIndexFile));
+
+  return indexFiles.length;
 }
 
 interface ResolvedStateManagerOptimize {
@@ -73,10 +72,18 @@ export default createExecutor<StateManagerOptimizeExecutorSchema, ResolvedStateM
       `Optimizing state_manager modules in ${resolved.transpiledDirs.length} transpiled tree(s)`,
     );
 
-    await Promise.all(
+    const counts = await Promise.all(
       resolved.transpiledDirs.map((transpiledDir) =>
-        optimizeTranspiledDir(transpiledDir, resolved.projectRoot),
+        optimizeTranspiledDir(path.join(resolved.projectRoot, transpiledDir)),
       ),
     );
+
+    const totalFound = counts.reduce((sum, count) => sum + count, 0);
+
+    if (totalFound === 0) {
+      throw new Error(
+        `${ERROR_NO_STATE_MANAGER_FOUND}: ${resolved.transpiledDirs.join(', ')}. Check transpile output layout or transpiledDirs option.`,
+      );
+    }
   },
 });