feat(create-cli): add monorepo setup mode (#1265)

Author: hanna-skryl

packages/ci/eslint.config.js

@@ -17,7 +17,7 @@ export default tseslint.config(
     rules: {
       '@nx/dependency-checks': [
         'error',
-        { ignoredDependencies: ['type-fest'] }, // only for internal typings
+        { ignoredDependencies: ['type-fest'] }, // type-only imports not detected by rule
       ],
     },
   },

packages/ci/package.json

@@ -32,7 +32,7 @@
     "ansis": "^3.3.2",
     "glob": "^11.0.1",
     "simple-git": "^3.20.0",
-    "yaml": "^2.5.1",
+    "type-fest": "^4.26.1",
     "zod": "^4.2.1"
   },
   "files": [

packages/ci/src/index.ts

@@ -1,10 +1,5 @@
 export type { SourceFileIssue } from './lib/issues.js';
 export type * from './lib/models.js';
-export {
-  isMonorepoTool,
-  MONOREPO_TOOLS,
-  type MonorepoTool,
-} from './lib/monorepo/index.js';
 export { runInCI } from './lib/run.js';
 export { configPatternsSchema } from './lib/schemas.js';
 export {

packages/ci/src/lib/models.ts

@@ -1,6 +1,6 @@
 import type { Format, PersistConfig, UploadConfig } from '@code-pushup/models';
+import type { MonorepoTool } from '@code-pushup/utils';
 import type { SourceFileIssue } from './issues.js';
-import type { MonorepoTool } from './monorepo/index.js';
 
 /**
  * Customization options for {@link runInCI}

packages/ci/src/lib/monorepo/detect-tool.ts

@@ -1,4 +1,5 @@
-import type { MonorepoTool, MonorepoToolHandler } from '../tools.js';
+import type { MonorepoTool } from '@code-pushup/utils';
+import type { MonorepoToolHandler } from '../tools.js';
 import { npmHandler } from './npm.js';
 import { nxHandler } from './nx.js';
 import { pnpmHandler } from './pnpm.js';

packages/ci/src/lib/monorepo/handlers/index.ts

@@ -1,23 +1,13 @@
-import path from 'node:path';
-import { fileExists } from '@code-pushup/utils';
 import {
   hasCodePushUpDependency,
   hasScript,
-  hasWorkspacesEnabled,
   listWorkspaces,
-} from '../packages.js';
+} from '@code-pushup/utils';
 import type { MonorepoToolHandler } from '../tools.js';
 
 export const npmHandler: MonorepoToolHandler = {
   tool: 'npm',
 
-  async isConfigured(options) {
-    return (
-      (await fileExists(path.join(options.cwd, 'package-lock.json'))) &&
-      (await hasWorkspacesEnabled(options.cwd))
-    );
-  },
-
   async listProjects(options) {
     const { workspaces, rootPackageJson } = await listWorkspaces(options.cwd);
     return workspaces

packages/ci/src/lib/monorepo/handlers/npm.ts

@@ -18,47 +18,6 @@ describe('npmHandler', () => {
   const pkgJsonContent = (content: PackageJson): string =>
     JSON.stringify(content);
 
-  describe('isConfigured', () => {
-    it('should detect NPM workspaces when package-lock.json exists and "workspaces" set in package.json', async () => {
-      vol.fromJSON(
-        {
-          'package.json': pkgJsonContent({
-            private: true,
-            workspaces: ['packages/*'],
-          }),
-          'package-lock.json': '',
-        },
-        MEMFS_VOLUME,
-      );
-      await expect(npmHandler.isConfigured(options)).resolves.toBeTrue();
-    });
-
-    it('should NOT detect NPM workspaces when "workspaces" not set in package.json', async () => {
-      vol.fromJSON(
-        {
-          'package.json': pkgJsonContent({}),
-          'package-lock.json': '',
-        },
-        MEMFS_VOLUME,
-      );
-      await expect(npmHandler.isConfigured(options)).resolves.toBeFalse();
-    });
-
-    it("should NOT detect NPM workspaces when package-lock.json doesn't exist", async () => {
-      vol.fromJSON(
-        {
-          'package.json': pkgJsonContent({
-            private: true,
-            workspaces: ['packages/*'],
-          }),
-          'yarn.lock': '',
-        },
-        MEMFS_VOLUME,
-      );
-      await expect(npmHandler.isConfigured(options)).resolves.toBeFalse();
-    });
-  });
-
   describe('listProjects', () => {
     it('should list all NPM workspaces with code-pushup script', async () => {
       vol.fromJSON(

packages/ci/src/lib/monorepo/handlers/npm.unit.test.ts

@@ -1,7 +1,5 @@
-import path from 'node:path';
 import {
   executeProcess,
-  fileExists,
   interpolate,
   stringifyError,
   toArray,
@@ -11,21 +9,18 @@ import type { MonorepoToolHandler } from '../tools.js';
 export const nxHandler: MonorepoToolHandler = {
   tool: 'nx',
 
-  async isConfigured(options) {
-    return (
-      (await fileExists(path.join(options.cwd, 'nx.json'))) &&
-      (
-        await executeProcess({
-          command: 'npx',
-          args: ['nx', 'report'],
-          cwd: options.cwd,
-          ignoreExitCode: true,
-        })
-      ).code === 0
-    );
-  },
-
   async listProjects({ cwd, task, nxProjectsFilter }) {
+    const { code, stderr } = await executeProcess({
+      command: 'npx',
+      args: ['nx', 'report'],
+      cwd,
+      ignoreExitCode: true,
+    });
+    if (code !== 0) {
+      const suffix = stderr ? ` - ${stderr}` : '';
+      throw new Error(`'nx report' failed with exit code ${code}${suffix}`);
+    }
+
     const { stdout } = await executeProcess({
       command: 'npx',
       args: [

packages/ci/src/lib/monorepo/handlers/nx.ts

@@ -1,4 +1,3 @@
-import { vol } from 'memfs';
 import { MEMFS_VOLUME } from '@code-pushup/test-utils';
 import * as utils from '@code-pushup/utils';
 import type {
@@ -16,42 +15,15 @@ describe('nxHandler', () => {
     nxProjectsFilter: '--with-target={task}',
   };
 
-  describe('isConfigured', () => {
-    it('should detect Nx when nx.json exists and `nx report` succeeds', async () => {
-      vol.fromJSON({ 'nx.json': '{}' }, MEMFS_VOLUME);
-      vi.spyOn(utils, 'executeProcess').mockResolvedValue({
-        code: 0,
-        stdout: 'NX Report complete - copy this into the issue template',
-      } as utils.ProcessResult);
-
-      await expect(nxHandler.isConfigured(options)).resolves.toBeTrue();
-    });
-
-    it("should NOT detect Nx when nx.json doesn't exist", async () => {
-      vol.fromJSON({ 'turbo.json': '{}' }, MEMFS_VOLUME);
-      vi.spyOn(utils, 'executeProcess').mockResolvedValue({
-        code: 0,
-      } as utils.ProcessResult);
-
-      await expect(nxHandler.isConfigured(options)).resolves.toBeFalse();
-    });
-
-    it('should NOT detect Nx when `nx report` fails with non-zero exit code', async () => {
-      vol.fromJSON({ 'nx.json': '' }, MEMFS_VOLUME);
-      vi.spyOn(utils, 'executeProcess').mockResolvedValue({
-        code: 1,
-        stderr: 'Error: ValueExpected in nx.json',
-      } as utils.ProcessResult);
-
-      await expect(nxHandler.isConfigured(options)).resolves.toBeFalse();
-    });
-  });
-
   describe('listProjects', () => {
+    const nxReportSuccess = { code: 0 } as utils.ProcessResult;
+
     beforeEach(() => {
-      vi.spyOn(utils, 'executeProcess').mockResolvedValue({
-        stdout: '["backend","frontend"]',
-      } as utils.ProcessResult);
+      vi.spyOn(utils, 'executeProcess')
+        .mockResolvedValueOnce(nxReportSuccess)
+        .mockResolvedValueOnce({
+          stdout: '["backend","frontend"]',
+        } as utils.ProcessResult);
     });
 
     it('should list projects from `nx show projects`', async () => {
@@ -95,20 +67,39 @@ describe('nxHandler', () => {
       } satisfies utils.ProcessConfig);
     });
 
+    it('should throw if `nx report` fails', async () => {
+      vi.spyOn(utils, 'executeProcess')
+        .mockReset()
+        .mockResolvedValueOnce({
+          code: 1,
+          stderr: 'Error: ValueExpected in nx.json',
+        } as utils.ProcessResult);
+
+      await expect(nxHandler.listProjects(options)).rejects.toThrow(
+        "'nx report' failed with exit code 1 - Error: ValueExpected in nx.json",
+      );
+    });
+
     it('should throw if `nx show projects` outputs invalid JSON', async () => {
-      vi.spyOn(utils, 'executeProcess').mockResolvedValue({
-        stdout: 'backend\nfrontend\n',
-      } as utils.ProcessResult);
+      vi.spyOn(utils, 'executeProcess')
+        .mockReset()
+        .mockResolvedValueOnce(nxReportSuccess)
+        .mockResolvedValueOnce({
+          stdout: 'backend\nfrontend\n',
+        } as utils.ProcessResult);
 
       await expect(nxHandler.listProjects(options)).rejects.toThrow(
         "Invalid non-JSON output from 'nx show projects' - SyntaxError: Unexpected token",
       );
     });
 
     it("should throw if `nx show projects` JSON output isn't array of strings", async () => {
-      vi.spyOn(utils, 'executeProcess').mockResolvedValue({
-        stdout: '"backend"',
-      } as utils.ProcessResult);
+      vi.spyOn(utils, 'executeProcess')
+        .mockReset()
+        .mockResolvedValueOnce(nxReportSuccess)
+        .mockResolvedValueOnce({
+          stdout: '"backend"',
+        } as utils.ProcessResult);
 
       await expect(nxHandler.listProjects(options)).rejects.toThrow(
         'Invalid JSON output from \'nx show projects\', expected array of strings, received "backend"',