fix(misc): allow create-nx-workspace . --no-interactive in empty directory (#35281)

Co-authored-by: Claude Opus 4.6 <[email protected]>

Author: cogwirrel

packages/create-nx-workspace/bin/create-nx-workspace.spec.ts

@@ -1,6 +1,7 @@
 import {
   validateWorkspaceName,
   resolveSpecialFolderName,
+  determineFolder,
 } from './create-nx-workspace';
 import { CnwError } from '../src/utils/error-utils';
 import { mkdtempSync, mkdirSync, rmSync, realpathSync } from 'fs';
@@ -43,6 +44,110 @@ describe('validateWorkspaceName', () => {
   });
 });
 
+describe('determineFolder', () => {
+  let originalCwd: string;
+
+  beforeEach(() => {
+    originalCwd = process.cwd();
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+  });
+
+  function makeParsedArgs(
+    overrides: Partial<{
+      name: string;
+      positional: string;
+      interactive: boolean;
+    }> = {}
+  ) {
+    return {
+      _: overrides.positional ? [overrides.positional] : [],
+      $0: 'create-nx-workspace',
+      name: overrides.name ?? '',
+      interactive: overrides.interactive ?? false,
+    } as any;
+  }
+
+  it('should return directory basename for "." in non-interactive mode', async () => {
+    const tmpDir = realpathSync(mkdtempSync(join(tmpdir(), 'cnw-test-')));
+    process.chdir(tmpDir);
+
+    const parsedArgs = makeParsedArgs({ positional: '.', interactive: false });
+    const result = await determineFolder(parsedArgs);
+
+    expect(result).toBe(basename(tmpDir));
+    expect(parsedArgs.workingDir).toBe(dirname(tmpDir));
+
+    rmSync(tmpDir, { recursive: true });
+  });
+
+  it('should return directory basename for "./" in non-interactive mode', async () => {
+    const tmpDir = realpathSync(mkdtempSync(join(tmpdir(), 'cnw-test-')));
+    process.chdir(tmpDir);
+
+    const parsedArgs = makeParsedArgs({ positional: './', interactive: false });
+    const result = await determineFolder(parsedArgs);
+
+    expect(result).toBe(basename(tmpDir));
+    expect(parsedArgs.workingDir).toBe(dirname(tmpDir));
+
+    rmSync(tmpDir, { recursive: true });
+  });
+
+  it('should return directory basename for "." in interactive mode', async () => {
+    const tmpDir = realpathSync(mkdtempSync(join(tmpdir(), 'cnw-test-')));
+    process.chdir(tmpDir);
+
+    const parsedArgs = makeParsedArgs({ positional: '.', interactive: true });
+    const result = await determineFolder(parsedArgs);
+
+    expect(result).toBe(basename(tmpDir));
+
+    rmSync(tmpDir, { recursive: true });
+  });
+
+  it('should default to directory basename when no name given in non-interactive mode', async () => {
+    const tmpDir = realpathSync(mkdtempSync(join(tmpdir(), 'cnw-test-')));
+    process.chdir(tmpDir);
+
+    const parsedArgs = makeParsedArgs({ interactive: false });
+    const result = await determineFolder(parsedArgs);
+
+    expect(result).toBe(basename(tmpDir));
+
+    rmSync(tmpDir, { recursive: true });
+  });
+
+  it('should return the name directly when it does not exist as a directory', async () => {
+    const parsedArgs = makeParsedArgs({
+      positional: 'nonexistent-workspace-name',
+      interactive: false,
+    });
+    const result = await determineFolder(parsedArgs);
+
+    expect(result).toBe('nonexistent-workspace-name');
+  });
+
+  it('should throw DIRECTORY_EXISTS for an existing directory name in non-interactive mode', async () => {
+    const tmpDir = realpathSync(mkdtempSync(join(tmpdir(), 'cnw-test-')));
+    const existing = join(tmpDir, 'existing');
+    mkdirSync(existing);
+    process.chdir(tmpDir);
+
+    const parsedArgs = makeParsedArgs({
+      positional: 'existing',
+      interactive: false,
+    });
+
+    await expect(determineFolder(parsedArgs)).rejects.toThrow(CnwError);
+    await expect(determineFolder(parsedArgs)).rejects.toThrow(/already exists/);
+
+    rmSync(tmpDir, { recursive: true });
+  });
+});
+
 describe('resolveSpecialFolderName', () => {
   let originalCwd: string;
 

packages/create-nx-workspace/bin/create-nx-workspace.ts

@@ -833,6 +833,11 @@ export function validateWorkspaceName(name: string): void {
   }
 }
 
+/** Returns `true` when the folder name refers to the current directory. */
+function isCurrentDirReference(folderName: string): boolean {
+  return folderName === '.' || folderName === './';
+}
+
 /**
  * Resolves special folder name patterns (`.`, `./`, absolute paths) into a
  * workspace name and a `workingDir` override so that downstream functions
@@ -846,8 +851,8 @@ export function validateWorkspaceName(name: string): void {
 export function resolveSpecialFolderName(
   folderName: string
 ): { name: string; workingDir: string } | null {
-  // Handle "." and "./" — user wants to init in the current directory
-  if (folderName === '.' || folderName === './') {
+  // User wants to init in the current directory
+  if (isCurrentDirReference(folderName)) {
     const cwd = resolve(process.cwd());
     if (readdirSync(cwd).length > 0) {
       throw new CnwError(
@@ -876,7 +881,12 @@ export function resolveSpecialFolderName(
   return null;
 }
 
-async function determineFolder(
+/**
+ * Determines the folder name for the new workspace.
+ *
+ * @visibleForTesting
+ */
+export async function determineFolder(
   parsedArgs: yargs.Arguments<Arguments>
 ): Promise<string> {
   const rawFolderName: string = parsedArgs._[0]
@@ -893,8 +903,15 @@ async function determineFolder(
 
     validateWorkspaceName(folderName);
 
+    // When input is "." or "./", resolveSpecialFolderName already validated
+    // the directory is empty. The target always "exists" because it IS the
+    // current working directory, so skip the existsSync check and default
+    // the workspace name to the directory name.
+    if (isCurrentDirReference(rawFolderName)) {
+      return folderName;
+    }
+
     // If directory exists, either re-prompt (interactive) or error (non-interactive)
-    // Check relative to workingDir when set (e.g. absolute path resolved to a different parent)
     const targetDir = resolved?.workingDir
       ? join(resolved.workingDir, folderName)
       : folderName;
@@ -914,6 +931,15 @@ async function determineFolder(
     return folderName;
   }
 
+  // When non-interactive and no name is provided, default to the current
+  // directory name instead of prompting.
+  if (!parsedArgs.interactive || isCI()) {
+    const cwd = resolve(process.cwd());
+    const folderName = basename(cwd);
+    validateWorkspaceName(folderName);
+    return folderName;
+  }
+
   return promptForFolder(parsedArgs);
 }