feat: use Yarn v3 with nodeLinker: node-modules for new projects (#2134)

* feat: use Yarn v3 when creating new project

* fix(ci): use `YARN_ENABLE_IMMUTABLE_INSTALLS` when installing packages

* feat: add to config `nmHoistingLimits: workspaces`

* chore: add more context on why we should specify explicit version

* feat: skip bumping yarn version if project is inside git work tree

* fix: remove condition for yarn classic when bumping version

* fix(e2e): update yarn specific files

Author: szymonrybczak

__e2e__/init.test.ts

@@ -22,6 +22,8 @@ function createCustomTemplateFiles() {
 
 const customTemplateCopiedFiles = [
   '.git',
+  '.yarn',
+  '.yarnrc.yml',
   'dir',
   'file',
   'node_modules',
@@ -155,9 +157,10 @@ test('init uses npm as the package manager with --npm', () => {
 
   const initDirPath = path.join(DIR, PROJECT_NAME);
 
-  // Remove yarn.lock and node_modules
+  // Remove yarn specific files and node_modules
   const filteredFiles = customTemplateCopiedFiles.filter(
-    (file) => !['yarn.lock', 'node_modules'].includes(file),
+    (file) =>
+      !['yarn.lock', 'node_modules', '.yarnrc.yml', '.yarn'].includes(file),
   );
 
   // Add package-lock.json

jest/helpers.ts

@@ -28,6 +28,9 @@ export function runCLI(
   return spawnScript(process.execPath, [CLI_PATH, ...(args || [])], {
     ...options,
     cwd: dir,
+    env: {
+      YARN_ENABLE_IMMUTABLE_INSTALLS: 'false',
+    },
   });
 }
 
@@ -92,6 +95,7 @@ export const getTempDirectory = (name: string) =>
 
 type SpawnOptions = RunOptions & {
   cwd: string;
+  env?: {[key: string]: string | undefined};
 };
 
 type SpawnFunction<T> = (
@@ -117,11 +121,12 @@ function getExecaOptions(options: SpawnOptions) {
 
   const cwd = isRelative ? path.resolve(__dirname, options.cwd) : options.cwd;
 
-  const env = Object.assign({}, process.env, {FORCE_COLOR: '0'});
+  let env = Object.assign({}, process.env, {FORCE_COLOR: '0'}, options.env);
 
   if (options.nodeOptions) {
     env.NODE_OPTIONS = options.nodeOptions;
   }
+
   if (options.nodePath) {
     env.NODE_PATH = options.nodePath;
   }

packages/cli/src/commands/init/createGitRepository.ts renamed to packages/cli/src/commands/init/git.ts

@@ -3,26 +3,31 @@ import execa from 'execa';
 import fs from 'fs';
 import path from 'path';
 
-const createGitRepository = async (folder: string) => {
-  const loader = getLoader();
-
+export const checkGitInstallation = async (): Promise<boolean> => {
   try {
     await execa('git', ['--version'], {stdio: 'ignore'});
+    return true;
   } catch {
-    loader.fail('Unable to initialize Git repo. `git` not in $PATH.');
-    return;
+    return false;
   }
+};
 
+export const checkIfFolderIsGitRepo = async (
+  folder: string,
+): Promise<boolean> => {
   try {
     await execa('git', ['rev-parse', '--is-inside-work-tree'], {
       stdio: 'ignore',
       cwd: folder,
     });
-    loader.succeed(
-      'New project is already inside of a Git repo, skipping git init.',
-    );
-    return;
-  } catch {}
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export const createGitRepository = async (folder: string) => {
+  const loader = getLoader();
 
   loader.start('Initializing Git repository');
 
@@ -63,5 +68,3 @@ const createGitRepository = async (folder: string) => {
     );
   }
 };
-
-export default createGitRepository;

packages/cli/src/commands/init/init.ts

@@ -28,7 +28,13 @@ import {getBunVersionIfAvailable} from '../../tools/bun';
 import {getNpmVersionIfAvailable} from '../../tools/npm';
 import {getYarnVersionIfAvailable} from '../../tools/yarn';
 import {createHash} from 'crypto';
-import createGitRepository from './createGitRepository';
+import {
+  createGitRepository,
+  checkGitInstallation,
+  checkIfFolderIsGitRepo,
+} from './git';
+import semver from 'semver';
+import {executeCommand} from '../../tools/executeCommand';
 
 const DEFAULT_VERSION = 'latest';
 
@@ -49,6 +55,7 @@ type Options = {
 
 interface TemplateOptions {
   projectName: string;
+  shouldBumpYarnVersion: boolean;
   templateUri: string;
   npm?: boolean;
   pm?: PackageManager.PackageManager;
@@ -64,17 +71,38 @@ interface TemplateReturnType {
   didInstallPods?: boolean;
 }
 
+// Here we are defining explicit version of Yarn to be used in the new project because in some cases providing `3.x` don't work.
+const YARN_VERSION = '3.6.4';
+
+const bumpYarnVersion = async (silent: boolean, root: string) => {
+  try {
+    let yarnVersion = semver.parse(getYarnVersionIfAvailable());
+
+    if (yarnVersion) {
+      await executeCommand('yarn', ['set', 'version', YARN_VERSION], {
+        root,
+        silent,
+      });
+
+      // React Native doesn't support PnP, so we need to set nodeLinker to node-modules. Read more here: https://github.com/react-native-community/cli/issues/27#issuecomment-1772626767
+
+      await executeCommand(
+        'yarn',
+        ['config', 'set', 'nodeLinker', 'node-modules'],
+        {root, silent},
+      );
+    }
+  } catch (e) {
+    logger.debug(e as string);
+  }
+};
+
 function doesDirectoryExist(dir: string) {
   return fs.existsSync(dir);
 }
 
 async function setProjectDirectory(directory: string) {
-  if (doesDirectoryExist(directory)) {
-    throw new DirectoryAlreadyExistsError(directory);
-  }
-
   try {
-    fs.mkdirSync(directory, {recursive: true});
     process.chdir(directory);
   } catch (error) {
     throw new CLIError(
@@ -108,6 +136,7 @@ function setEmptyHashForCachedDependencies(projectName: string) {
 
 async function createFromTemplate({
   projectName,
+  shouldBumpYarnVersion,
   templateUri,
   npm,
   pm,
@@ -182,6 +211,11 @@ async function createFromTemplate({
       packageName,
     });
 
+    if (packageManager === 'yarn' && shouldBumpYarnVersion) {
+      await bumpYarnVersion(false, projectDirectory);
+    }
+
+    loader.succeed();
     const {postInitScript} = templateConfig;
     if (postInitScript) {
       loader.info('Executing post init script ');
@@ -310,12 +344,14 @@ async function createProject(
   projectName: string,
   directory: string,
   version: string,
+  shouldBumpYarnVersion: boolean,
   options: Options,
 ): Promise<TemplateReturnType> {
   const templateUri = createTemplateUri(options, version);
 
   return createFromTemplate({
     projectName,
+    shouldBumpYarnVersion,
     templateUri,
     npm: options.npm,
     pm: options.pm,
@@ -361,6 +397,7 @@ export default (async function initialize(
   const version = options.version || DEFAULT_VERSION;
 
   const directoryName = path.relative(root, options.directory || projectName);
+  const projectFolder = path.join(root, directoryName);
 
   if (options.pm && !checkPackageManagerAvailability(options.pm)) {
     logger.error(
@@ -369,16 +406,40 @@ export default (async function initialize(
     return;
   }
 
+  if (doesDirectoryExist(projectFolder)) {
+    throw new DirectoryAlreadyExistsError(directoryName);
+  } else {
+    fs.mkdirSync(projectFolder, {recursive: true});
+  }
+
+  let shouldBumpYarnVersion = true;
+  let shouldCreateGitRepository = false;
+
+  const isGitAvailable = await checkGitInstallation();
+
+  if (isGitAvailable) {
+    const isFolderGitRepo = await checkIfFolderIsGitRepo(projectFolder);
+
+    if (isFolderGitRepo) {
+      shouldBumpYarnVersion = false;
+    } else {
+      shouldCreateGitRepository = true; // Initialize git repo after creating project
+    }
+  } else {
+    logger.warn(
+      'Git is not installed on your system. This might cause some features to work incorrectly.',
+    );
+  }
+
   const {didInstallPods} = await createProject(
     projectName,
     directoryName,
     version,
+    shouldBumpYarnVersion,
     options,
   );
 
-  const projectFolder = path.join(root, directoryName);
-
-  if (!options.skipGitInit) {
+  if (shouldCreateGitRepository && !options.skipGitInit) {
     await createGitRepository(projectFolder);
   }
 

packages/cli/src/commands/init/template.ts

@@ -7,7 +7,7 @@ import replacePathSepForRegex from '../../tools/replacePathSepForRegex';
 import fs from 'fs';
 import chalk from 'chalk';
 import {getYarnVersionIfAvailable} from '../../tools/yarn';
-import {executeCommand} from '../../tools/packageManager';
+import {executeCommand} from '../../tools/executeCommand';
 
 export type TemplateConfig = {
   placeholderName: string;
@@ -29,13 +29,24 @@ export async function installTemplatePackage(
     root,
   });
 
-  // React Native doesn't support PnP, so we need to set nodeLinker to node-modules. Read more here: https://github.com/react-native-community/cli/issues/27#issuecomment-1772626767
-
   if (packageManager === 'yarn' && getYarnVersionIfAvailable() !== null) {
-    executeCommand('yarn', ['config', 'set', 'nodeLinker', 'node-modules'], {
+    const options = {
       root,
       silent: true,
-    });
+    };
+
+    // React Native doesn't support PnP, so we need to set nodeLinker to node-modules. Read more here: https://github.com/react-native-community/cli/issues/27#issuecomment-1772626767
+    executeCommand(
+      'yarn',
+      ['config', 'set', 'nodeLinker', 'node-modules'],
+      options,
+    );
+
+    executeCommand(
+      'yarn',
+      ['config', 'set', 'nmHoistingLimits', 'workspaces'],
+      options,
+    );
   }
 
   return PackageManager.install([templateName], {

packages/cli/src/tools/executeCommand.ts

@@ -0,0 +1,16 @@
+import {logger} from '@react-native-community/cli-tools';
+import execa from 'execa';
+
+export function executeCommand(
+  command: string,
+  args: Array<string>,
+  options: {
+    root: string;
+    silent?: boolean;
+  },
+) {
+  return execa(command, args, {
+    stdio: options.silent && !logger.isVerbose() ? 'pipe' : 'inherit',
+    cwd: options.root,
+  });
+}

packages/cli/src/tools/packageManager.ts

@@ -1,8 +1,7 @@
-import execa from 'execa';
-import {logger} from '@react-native-community/cli-tools';
 import {getYarnVersionIfAvailable, isProjectUsingYarn} from './yarn';
 import {getBunVersionIfAvailable, isProjectUsingBun} from './bun';
 import {getNpmVersionIfAvailable, isProjectUsingNpm} from './npm';
+import {executeCommand} from './executeCommand';
 
 export type PackageManager = keyof typeof packageManagers;
 
@@ -65,20 +64,6 @@ function configurePackageManager(
   return executeCommand(pm, args, options);
 }
 
-export function executeCommand(
-  command: string,
-  args: Array<string>,
-  options: {
-    root: string;
-    silent?: boolean;
-  },
-) {
-  return execa(command, args, {
-    stdio: options.silent && !logger.isVerbose() ? 'pipe' : 'inherit',
-    cwd: options.root,
-  });
-}
-
 export function shouldUseYarn(options: Options) {
   if (options.packageManager === 'yarn') {
     return getYarnVersionIfAvailable();