ts-repo-utils 6.1.0 → 7.0.0

package/src/functions/gen-index.mts

@@ -71,12 +71,16 @@ type GenIndexConfigInternal = DeepReadonly<{
  * @param config - Configuration for index file generation
  * @throws Error if any step fails.
  */
-export const genIndex = async (config: GenIndexConfig): Promise<void> => {
-  echo('Starting index file generation...\n');
-
+export const genIndex = async (
+  config: GenIndexConfig,
+): Promise<Result<undefined, unknown>> => {
   // Merge config with defaults
   const filledConfig: GenIndexConfigInternal = fillConfig(config);
 
+  const conditionalEcho = filledConfig.silent ? () => {} : echo;
+
+  conditionalEcho('Starting index file generation...\n');
+
   // Normalize target directories to array
   const targetDirs =
     typeof config.targetDirectory === 'string'
@@ -92,30 +96,32 @@ export const genIndex = async (config: GenIndexConfig): Promise<void> => {
     }
 
     // Step 2: Generate index files
-    echo('Generating index files...');
+    conditionalEcho('Generating index files...');
     for (const dir of targetDirs) {
       const resolvedDir = path.resolve(dir);
       // eslint-disable-next-line no-await-in-loop
       await generateIndexFileForDir(resolvedDir, filledConfig);
     }
-    echo('✓ Index files generated\n');
+    conditionalEcho('✓ Index files generated\n');
 
     // Step 3: Format generated files
     if (filledConfig.formatCommand !== undefined) {
-      echo('Formatting generated files...');
+      conditionalEcho('Formatting generated files...');
       const fmtResult = await $(filledConfig.formatCommand, {
         silent: filledConfig.silent,
       });
       if (Result.isErr(fmtResult)) {
         throw new Error(`Formatting failed: ${fmtResult.value.message}`);
       }
-      echo('✓ Formatting completed\n');
+      conditionalEcho('✓ Formatting completed\n');
     }
 
-    echo('✅ Index file generation completed successfully!\n');
+    conditionalEcho('✅ Index file generation completed successfully!\n');
+
+    return Result.ok(undefined);
   } catch (error) {
-    echo(`❌ Index generation failed: ${String(error)}\n`);
-    throw error;
+    conditionalEcho(`❌ Index generation failed: ${String(error)}\n`);
+    return Result.err(error);
   }
 };
 

package/src/functions/workspace-utils/run-cmd-in-stages.test.mts

@@ -0,0 +1,266 @@
+/* eslint-disable vitest/no-restricted-vi-methods */
+import '../../node-global.mjs';
+import { executeStages } from './execute-parallel.mjs';
+import { getWorkspacePackages } from './get-workspace-packages.mjs';
+import { runCmdInStagesAcrossWorkspaces } from './run-cmd-in-stages.mjs';
+import { type Package } from './types.mjs';
+
+// Mock the dependencies
+vi.mock('./execute-parallel.mjs', () => ({
+  executeStages: vi.fn(),
+}));
+
+vi.mock('./get-workspace-packages.mjs', () => ({
+  getWorkspacePackages: vi.fn(),
+}));
+
+describe('runCmdInStagesAcrossWorkspaces', () => {
+  type MockedSpies = Readonly<{
+    consoleLogSpy: ReturnType<typeof vi.spyOn>;
+    consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+    processExitSpy: ReturnType<typeof vi.spyOn>;
+  }>;
+
+  const setupSpies = (): MockedSpies => {
+    vi.clearAllMocks();
+    const consoleLogSpy = vi
+      .spyOn(console, 'log')
+      .mockImplementation((): void => {});
+    const consoleErrorSpy = vi
+      .spyOn(console, 'error')
+      .mockImplementation((): void => {});
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const processExitSpy = vi
+      .spyOn(process, 'exit')
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      .mockImplementation((): never => undefined as never) as ReturnType<
+      typeof vi.spyOn
+    >;
+
+    return { consoleLogSpy, consoleErrorSpy, processExitSpy };
+  };
+
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  const cleanupSpies = (spies: MockedSpies): void => {
+    spies.consoleLogSpy.mockRestore();
+    spies.consoleErrorSpy.mockRestore();
+    spies.processExitSpy.mockRestore();
+  };
+
+  test('should fail fast and exit immediately when executeStages throws an error', async () => {
+    const spies = setupSpies();
+
+    try {
+      // Mock workspace packages
+      const mockPackages: Package[] = [
+        {
+          name: 'package-a',
+          path: '/test/package-a',
+          packageJson: { name: 'package-a', scripts: { test: 'exit 1' } },
+          dependencies: {},
+        },
+        {
+          name: 'package-b',
+          path: '/test/package-b',
+          packageJson: { name: 'package-b', scripts: { test: 'echo success' } },
+          dependencies: {},
+        },
+        {
+          name: 'package-c',
+          path: '/test/package-c',
+          packageJson: { name: 'package-c', scripts: { test: 'echo success' } },
+          dependencies: {},
+        },
+      ];
+
+      vi.mocked(getWorkspacePackages).mockResolvedValue(mockPackages);
+
+      // Mock executeStages to throw an error (simulating a failed command)
+      const mockError = new Error('package-a exited with code 1');
+      vi.mocked(executeStages).mockRejectedValue(mockError);
+
+      // Record start time
+      const startTime = Date.now();
+
+      // Execute the function
+      await runCmdInStagesAcrossWorkspaces({
+        rootPackageJsonDir: '/test',
+        cmd: 'test',
+        concurrency: 2,
+      });
+
+      // Record end time
+      const endTime = Date.now();
+      const executionTime = endTime - startTime;
+
+      // Verify that execution was fast (fail-fast behavior)
+      // Should complete within 100ms since it should fail immediately
+      expect(executionTime).toBeLessThan(100);
+
+      // Verify executeStages was called
+      expect(executeStages).toHaveBeenCalledWith(mockPackages, 'test', 2);
+
+      // Verify console.error was called with fail-fast message
+      expect(spies.consoleErrorSpy).toHaveBeenCalledWith(
+        '\n❌ test failed (fail-fast mode stopped execution):',
+      );
+      expect(spies.consoleErrorSpy).toHaveBeenCalledWith(
+        'package-a exited with code 1',
+      );
+
+      // Verify process.exit was called with code 1
+      expect(spies.processExitSpy).toHaveBeenCalledWith(1);
+
+      // Verify success message was NOT called
+      expect(spies.consoleLogSpy).not.toHaveBeenCalledWith(
+        expect.stringContaining('✅ test completed successfully'),
+      );
+    } finally {
+      cleanupSpies(spies);
+    }
+  });
+
+  test('should complete successfully when no errors occur', async () => {
+    const spies = setupSpies();
+
+    try {
+      // Mock workspace packages
+      const mockPackages: Package[] = [
+        {
+          name: 'package-a',
+          path: '/test/package-a',
+          packageJson: { name: 'package-a', scripts: { test: 'echo test' } },
+          dependencies: {},
+        },
+        {
+          name: 'package-b',
+          path: '/test/package-b',
+          packageJson: { name: 'package-b', scripts: { test: 'echo test' } },
+          dependencies: {},
+        },
+      ];
+
+      vi.mocked(getWorkspacePackages).mockResolvedValue(mockPackages);
+      vi.mocked(executeStages).mockResolvedValue(undefined);
+
+      // Execute the function
+      await runCmdInStagesAcrossWorkspaces({
+        rootPackageJsonDir: '/test',
+        cmd: 'test',
+        concurrency: 2,
+      });
+
+      // Verify executeStages was called
+      expect(executeStages).toHaveBeenCalledWith(mockPackages, 'test', 2);
+
+      // Verify success messages were called
+      expect(spies.consoleLogSpy).toHaveBeenCalledWith(
+        '\nStarting test across 2 packages (fail-fast mode)...',
+      );
+      expect(spies.consoleLogSpy).toHaveBeenCalledWith(
+        '\n✅ test completed successfully (all stages)',
+      );
+
+      // Verify process.exit was NOT called
+      expect(spies.processExitSpy).not.toHaveBeenCalled();
+
+      // Verify error messages were NOT called
+      expect(spies.consoleErrorSpy).not.toHaveBeenCalled();
+    } finally {
+      cleanupSpies(spies);
+    }
+  });
+
+  test('should apply package filtering correctly', async () => {
+    const spies = setupSpies();
+
+    try {
+      // Mock workspace packages
+      const mockPackages: Package[] = [
+        {
+          name: 'package-a',
+          path: '/test/package-a',
+          packageJson: { name: 'package-a', scripts: { test: 'echo test' } },
+          dependencies: {},
+        },
+        {
+          name: 'package-b',
+          path: '/test/package-b',
+          packageJson: { name: 'package-b', scripts: { test: 'echo test' } },
+          dependencies: {},
+        },
+        {
+          name: 'other-package',
+          path: '/test/other-package',
+          packageJson: {
+            name: 'other-package',
+            scripts: { test: 'echo test' },
+          },
+          dependencies: {},
+        },
+      ];
+
+      vi.mocked(getWorkspacePackages).mockResolvedValue(mockPackages);
+      vi.mocked(executeStages).mockResolvedValue(undefined);
+
+      // Filter to only packages starting with 'package-'
+      const filterFn = (name: string): boolean => name.startsWith('package-');
+
+      // Execute the function with filter
+      await runCmdInStagesAcrossWorkspaces({
+        rootPackageJsonDir: '/test',
+        cmd: 'test',
+        concurrency: 2,
+        filterWorkspacePattern: filterFn,
+      });
+
+      // Verify executeStages was called with filtered packages
+      const expectedFilteredPackages = mockPackages.filter((pkg) =>
+        pkg.name.startsWith('package-'),
+      );
+      expect(executeStages).toHaveBeenCalledWith(
+        expectedFilteredPackages,
+        'test',
+        2,
+      );
+
+      // Verify log shows correct package count
+      expect(spies.consoleLogSpy).toHaveBeenCalledWith(
+        '\nStarting test across 2 packages (fail-fast mode)...',
+      );
+    } finally {
+      cleanupSpies(spies);
+    }
+  });
+
+  test('should handle workspace package loading errors', async () => {
+    const spies = setupSpies();
+
+    try {
+      // Mock getWorkspacePackages to throw an error
+      const mockError = new Error('Failed to load workspace packages');
+      vi.mocked(getWorkspacePackages).mockRejectedValue(mockError);
+
+      // Execute the function
+      await runCmdInStagesAcrossWorkspaces({
+        rootPackageJsonDir: '/test',
+        cmd: 'test',
+        concurrency: 2,
+      });
+
+      // Verify executeStages was NOT called
+      expect(executeStages).not.toHaveBeenCalled();
+
+      // Verify error handling
+      expect(spies.consoleErrorSpy).toHaveBeenCalledWith(
+        '\n❌ test failed (fail-fast mode stopped execution):',
+      );
+      expect(spies.consoleErrorSpy).toHaveBeenCalledWith(
+        'Failed to load workspace packages',
+      );
+      expect(spies.processExitSpy).toHaveBeenCalledWith(1);
+    } finally {
+      cleanupSpies(spies);
+    }
+  });
+});

package/dist/cmd/format-untracked.d.mts

@@ -1,3 +0,0 @@
-#!/usr/bin/env -S npx tsx
-export {};
-//# sourceMappingURL=format-untracked.d.mts.map

package/dist/cmd/format-untracked.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"format-untracked.d.mts","sourceRoot":"","sources":["../../src/cmd/format-untracked.mts"],"names":[],"mappings":""}

package/dist/cmd/format-untracked.mjs

@@ -1,34 +0,0 @@
-#!/usr/bin/env -S npx tsx
-import * as cmd from 'cmd-ts';
-import 'ts-data-forge';
-import '../node-global.mjs';
-import 'node:child_process';
-import { formatUntracked } from '../functions/format.mjs';
-import 'micromatch';
-import 'child_process';
-
-const cmdDef = cmd.command({
-    name: 'format-untracked-cli',
-    version: '6.1.0',
-    args: {
-        silent: cmd.flag({
-            long: 'silent',
-            type: cmd.optional(cmd.boolean),
-            description: 'If true, suppresses output messages (default: false)',
-        }),
-    },
-    handler: (args) => {
-        main(args).catch((error) => {
-            console.error('An error occurred:', error);
-            process.exit(1);
-        });
-    },
-});
-const main = async (args) => {
-    const result = await formatUntracked({ silent: args.silent });
-    if (result === 'err') {
-        process.exit(1);
-    }
-};
-await cmd.run(cmdDef, process.argv.slice(2));
-//# sourceMappingURL=format-untracked.mjs.map

package/dist/cmd/format-untracked.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"format-untracked.mjs","sources":["../../src/cmd/format-untracked.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;AAKA,MAAM,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC;AACzB,IAAA,IAAI,EAAE,sBAAsB;AAC5B,IAAA,OAAO,EAAE,OAAO;AAChB,IAAA,IAAI,EAAE;AACJ,QAAA,MAAM,EAAE,GAAG,CAAC,IAAI,CAAC;AACf,YAAA,IAAI,EAAE,QAAQ;YACd,IAAI,EAAE,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC;AAC/B,YAAA,WAAW,EAAE,sDAAsD;SACpE,CAAC;AACH,KAAA;AACD,IAAA,OAAO,EAAE,CAAC,IAAI,KAAI;QAChB,IAAI,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,KAAI;AACzB,YAAA,OAAO,CAAC,KAAK,CAAC,oBAAoB,EAAE,KAAK,CAAC;AAC1C,YAAA,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;AACjB,QAAA,CAAC,CAAC;IACJ,CAAC;AACF,CAAA,CAAC;AAEF,MAAM,IAAI,GAAG,OAAO,IAAoC,KAAmB;AACzE,IAAA,MAAM,MAAM,GAAG,MAAM,eAAe,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC;AAC7D,IAAA,IAAI,MAAM,KAAK,KAAK,EAAE;AACpB,QAAA,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IACjB;AACF,CAAC;AAED,MAAM,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC"}

package/src/cmd/format-untracked.mts

@@ -1,31 +0,0 @@
-#!/usr/bin/env -S npx tsx
-
-import * as cmd from 'cmd-ts';
-import { formatUntracked } from '../functions/index.mjs';
-
-const cmdDef = cmd.command({
-  name: 'format-untracked-cli',
-  version: '6.1.0',
-  args: {
-    silent: cmd.flag({
-      long: 'silent',
-      type: cmd.optional(cmd.boolean),
-      description: 'If true, suppresses output messages (default: false)',
-    }),
-  },
-  handler: (args) => {
-    main(args).catch((error) => {
-      console.error('An error occurred:', error);
-      process.exit(1);
-    });
-  },
-});
-
-const main = async (args: Readonly<{ silent?: boolean }>): Promise<void> => {
-  const result = await formatUntracked({ silent: args.silent });
-  if (result === 'err') {
-    process.exit(1);
-  }
-};
-
-await cmd.run(cmdDef, process.argv.slice(2));