[@react-native/community-cli-plugin] Added inference of watchFolders from NPM, Yarn and PNPM workspaces

packages/community-cli-plugin/package.json

@@ -31,9 +31,11 @@
  "metro": "^0.80.3",
  "metro-config": "^0.80.3",
  "metro-core": "^0.80.3",
+ "micromatch": "^4.0.5",
  "node-fetch": "^2.2.0",
  "querystring": "^0.2.1",
- "readline": "^1.3.0"
+ "readline": "^1.3.0",
+ "yaml": "^2.3.4"
  },
  "devDependencies": {
  "metro-resolver": "^0.80.3"

packages/community-cli-plugin/src/utils/__tests__/getWorkspaceRoot-test.js

@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import {getWorkspaceRoot} from '../getWorkspaceRoot';
+import {createTempPackage} from './temporary-package';
+import fs from 'fs';
+import path from 'path';
+
+describe('getWorkspaceRoot', () => {
+ test('returns null if not in a workspace', () => {
+ const tempPackagePath = createTempPackage({
+ name: 'my-app',
+ });
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(null);
+ });
+
+ test('supports an npm workspace', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ workspaces: ['packages/my-app', 'packages/my-lib'],
+ });
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a yarn workspace', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ workspaces: ['packages/*'],
+ });
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a yarn workspace (object style)', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ workspaces: {
+ packages: ['packages/*'],
+ },
+ });
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a pnpm workspace', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ });
+ // Create the pnpm workspace configuration (see https://pnpm.io/pnpm-workspace_yaml)
+ const workspacesConfig = 'packages: ["packages/*"]';
+ fs.writeFileSync(
+ path.join(tempWorkspaceRootPath, 'pnpm-workspace.yaml'),
+ workspacesConfig,
+ 'utf8',
+ );
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a pnpm workspace exclusion', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ });
+ // Create the pnpm workspace configuration (see https://pnpm.io/pnpm-workspace_yaml)
+ const workspacesConfig = 'packages: ["packages/*", "!packages/*-app"]';
+ fs.writeFileSync(
+ path.join(tempWorkspaceRootPath, 'pnpm-workspace.yaml'),
+ workspacesConfig,
+ 'utf8',
+ );
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(null);
+ });
+});

packages/community-cli-plugin/src/utils/__tests__/loadMetroConfig-test.js

@@ -0,0 +1,133 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import loadMetroConfig from '../loadMetroConfig';
+import {createTempPackage} from './temporary-package';
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Resolves a package by its name and creates a symbolic link in a node_modules directory
+ */
+function createPackageLink(nodeModulesPath: string, packageName: string) {
+ // Resolve the packages path on disk
+ const destinationPath = path.dirname(require.resolve(packageName));
+ const packageScope = packageName.includes('/')
+ ? packageName.split('/')[0]
+ : undefined;
+
+ // Create a parent directory for a @scoped package
+ if (typeof packageScope === 'string') {
+ fs.mkdirSync(path.join(nodeModulesPath, packageScope));
+ }
+
+ const sourcePath = path.join(nodeModulesPath, packageName);
+ fs.symlinkSync(destinationPath, sourcePath);
+}
+
+function createTempConfig(projectRoot: string, metroConfig: {...}) {
+ const content = `
+ const {getDefaultConfig, mergeConfig} = require('@react-native/metro-config');
+ const config = ${JSON.stringify(metroConfig)};
+ module.exports = mergeConfig(getDefaultConfig(__dirname), config);
+ `;
+ const configPath = path.join(projectRoot, 'metro.config.js');
+ fs.writeFileSync(configPath, content, 'utf8');
+
+ const nodeModulesPath = path.join(projectRoot, 'node_modules');
+ fs.mkdirSync(nodeModulesPath);
+ // Create a symbolic link to the '@react-native/metro-config' package used by the config
+ createPackageLink(nodeModulesPath, '@react-native/metro-config');
+}
+
+const configLoadingContext = {
+ reactNativePath: path.dirname(require.resolve('react-native/package.json')),
+ platforms: {
+ ios: {npmPackageName: 'temp-package'},
+ android: {npmPackageName: 'temp-package'},
+ },
+};
+
+describe('loadMetroConfig', () => {
+ test('loads an empty config', async () => {
+ const rootPath = createTempPackage({name: 'temp-app'});
+ createTempConfig(rootPath, {});
+
+ const loadedConfig = await loadMetroConfig({
+ root: rootPath,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(rootPath);
+ expect(loadedConfig.watchFolders).toEqual([rootPath]);
+ });
+
+ test('loads watch folders', async () => {
+ const rootPath = createTempPackage({
+ name: 'temp-app',
+ });
+ createTempConfig(rootPath, {
+ watchFolders: ['somewhere-else'],
+ });
+
+ const loadedConfig = await loadMetroConfig({
+ root: rootPath,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(rootPath);
+ expect(loadedConfig.watchFolders).toEqual([rootPath, 'somewhere-else']);
+ });
+
+ test('includes an npm workspace root if no watchFolders are defined', async () => {
+ const rootPath = createTempPackage({
+ name: 'temp-root',
+ workspaces: ['packages/temp-app'],
+ });
+ // Create a config inside a sub-package
+ const projectRoot = createTempPackage(
+ {
+ name: 'temp-app',
+ },
+ path.join(rootPath, 'packages', 'temp-app'),
+ );
+ createTempConfig(projectRoot, {});
+
+ const loadedConfig = await loadMetroConfig({
+ root: projectRoot,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(projectRoot);
+ expect(loadedConfig.watchFolders).toEqual([projectRoot, rootPath]);
+ });
+
+ test('does not resolve an npm workspace root if watchFolders are defined', async () => {
+ const rootPath = createTempPackage({
+ name: 'temp-root',
+ workspaces: ['packages/temp-app'],
+ });
+ // Create a config inside a sub-package
+ const projectRoot = createTempPackage(
+ {
+ name: 'temp-app',
+ },
+ path.join(rootPath, 'packages', 'temp-app'),
+ );
+ createTempConfig(projectRoot, {
+ watchFolders: [],
+ });
+
+ const loadedConfig = await loadMetroConfig({
+ root: projectRoot,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(projectRoot);
+ expect(loadedConfig.watchFolders).toEqual([projectRoot]);
+ });
+});

packages/community-cli-plugin/src/utils/__tests__/temporary-package.js

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+export function createTempPackage(
+ packageJson: {...},
+ packagePath: string = fs.mkdtempSync(
+ path.join(os.tmpdir(), 'rn-metro-config-test-'),
+ ),
+): string {
+ fs.mkdirSync(packagePath, {recursive: true});
+ if (typeof packageJson === 'object') {
+ fs.writeFileSync(
+ path.join(packagePath, 'package.json'),
+ JSON.stringify(packageJson),
+ 'utf8',
+ );
+ }
+
+ // Wrapping path in realpath to resolve any symlinks introduced by mkdtemp
+ return fs.realpathSync(packagePath);
+}

packages/community-cli-plugin/src/utils/getWorkspaceRoot.js

@@ -0,0 +1,86 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ * @oncall react_native
+ */
+
+import {logger} from '@react-native-community/cli-tools';
+import fs from 'fs';
+import micromatch from 'micromatch';
+import path from 'path';
+import yaml from 'yaml';
+
+/**
+ * Get the workspace paths from the path of a potential workspace root.
+ *
+ * This supports:
+ * - [npm workspaces](https://docs.npmjs.com/cli/v10/using-npm/workspaces)
+ * - [yarn workspaces](https://yarnpkg.com/features/workspaces)
+ * - [pnpm workspaces](https://pnpm.io/workspaces)
+ */
+function getWorkspacePaths(packagePath: string): Array<string> {
+ try {
+ // Checking pnpm workspaces first
+ const pnpmWorkspacePath = path.resolve(packagePath, 'pnpm-workspace.yaml');
+ if (fs.existsSync(pnpmWorkspacePath)) {
+ const pnpmWorkspaceConfig = yaml.parse(
+ fs.readFileSync(pnpmWorkspacePath, 'utf8'),
+ );
+ if (
+ typeof pnpmWorkspaceConfig === 'object' &&
+ Array.isArray(pnpmWorkspaceConfig.packages)
+ ) {
+ return pnpmWorkspaceConfig.packages;
+ }
+ }
+ // Falling back to npm / yarn workspaces
+ const packageJsonPath = path.resolve(packagePath, 'package.json');
+ const {workspaces} = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+ if (Array.isArray(workspaces)) {
+ return workspaces;
+ } else if (
+ typeof workspaces === 'object' &&
+ Array.isArray(workspaces.packages)
+ ) {
+ // An alternative way for yarn to declare workspace packages
+ return workspaces.packages;
+ }
+ } catch (err) {
+ if (err.code !== 'ENOENT') {
+ logger.debug(`Failed getting workspace root from ${packagePath}: ${err}`);
+ }
+ }
+ return [];
+}
+
+/**
+ * Resolves the root of an npm or yarn workspace, by traversing the file tree
+ * upwards from a `candidatePath` in the search for
+ * - a directory with a package.json
+ * - which has a `workspaces` array of strings
+ * - which (possibly via a glob) includes the project root
+ */
+export function getWorkspaceRoot(
+ projectRoot: string,
+ candidatePath: string = projectRoot,
+): ?string {
+ const workspacePaths = getWorkspacePaths(candidatePath);
+ // If one of the workspaces match the project root, this is the workspace root
+ // Note: While npm workspaces doesn't currently support globs, yarn does, which is why we use micromatch
+ const relativePath = path.relative(candidatePath, projectRoot);
+ // Using this instead of `micromatch.isMatch` to enable excluding patterns
+ if (micromatch([relativePath], workspacePaths).length > 0) {
+ return candidatePath;
+ }
+ // Try one level up
+ const parentDir = path.dirname(candidatePath);
+ if (parentDir !== candidatePath) {
+ return getWorkspaceRoot(projectRoot, parentDir);
+ }
+ return null;
+}

packages/community-cli-plugin/package.json

@@ -31,9 +31,11 @@
  "metro": "^0.80.3",
  "metro-config": "^0.80.3",
  "metro-core": "^0.80.3",
+ "micromatch": "^4.0.5",
  "node-fetch": "^2.2.0",
  "querystring": "^0.2.1",
- "readline": "^1.3.0"
+ "readline": "^1.3.0",
+ "yaml": "^2.3.4"
  },
  "devDependencies": {
  "metro-resolver": "^0.80.3"

packages/community-cli-plugin/src/utils/__tests__/getWorkspaceRoot-test.js

@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import {getWorkspaceRoot} from '../getWorkspaceRoot';
+import {createTempPackage} from './temporary-package';
+import fs from 'fs';
+import path from 'path';
+
+describe('getWorkspaceRoot', () => {
+ test('returns null if not in a workspace', () => {
+ const tempPackagePath = createTempPackage({
+ name: 'my-app',
+ });
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(null);
+ });
+
+ test('supports an npm workspace', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ workspaces: ['packages/my-app', 'packages/my-lib'],
+ });
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a yarn workspace', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ workspaces: ['packages/*'],
+ });
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a yarn workspace (object style)', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ workspaces: {
+ packages: ['packages/*'],
+ },
+ });
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a pnpm workspace', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ });
+ // Create the pnpm workspace configuration (see https://pnpm.io/pnpm-workspace_yaml)
+ const workspacesConfig = 'packages: ["packages/*"]';
+ fs.writeFileSync(
+ path.join(tempWorkspaceRootPath, 'pnpm-workspace.yaml'),
+ workspacesConfig,
+ 'utf8',
+ );
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a pnpm workspace exclusion', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ });
+ // Create the pnpm workspace configuration (see https://pnpm.io/pnpm-workspace_yaml)
+ const workspacesConfig = 'packages: ["packages/*", "!packages/*-app"]';
+ fs.writeFileSync(
+ path.join(tempWorkspaceRootPath, 'pnpm-workspace.yaml'),
+ workspacesConfig,
+ 'utf8',
+ );
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(null);
+ });
+});

packages/community-cli-plugin/src/utils/__tests__/loadMetroConfig-test.js

@@ -0,0 +1,133 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import loadMetroConfig from '../loadMetroConfig';
+import {createTempPackage} from './temporary-package';
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Resolves a package by its name and creates a symbolic link in a node_modules directory
+ */
+function createPackageLink(nodeModulesPath: string, packageName: string) {
+ // Resolve the packages path on disk
+ const destinationPath = path.dirname(require.resolve(packageName));
+ const packageScope = packageName.includes('/')
+ ? packageName.split('/')[0]
+ : undefined;
+
+ // Create a parent directory for a @scoped package
+ if (typeof packageScope === 'string') {
+ fs.mkdirSync(path.join(nodeModulesPath, packageScope));
+ }
+
+ const sourcePath = path.join(nodeModulesPath, packageName);
+ fs.symlinkSync(destinationPath, sourcePath);
+}
+
+function createTempConfig(projectRoot: string, metroConfig: {...}) {
+ const content = `
+ const {getDefaultConfig, mergeConfig} = require('@react-native/metro-config');
+ const config = ${JSON.stringify(metroConfig)};
+ module.exports = mergeConfig(getDefaultConfig(__dirname), config);
+ `;
+ const configPath = path.join(projectRoot, 'metro.config.js');
+ fs.writeFileSync(configPath, content, 'utf8');
+
+ const nodeModulesPath = path.join(projectRoot, 'node_modules');
+ fs.mkdirSync(nodeModulesPath);
+ // Create a symbolic link to the '@react-native/metro-config' package used by the config
+ createPackageLink(nodeModulesPath, '@react-native/metro-config');
+}
+
+const configLoadingContext = {
+ reactNativePath: path.dirname(require.resolve('react-native/package.json')),
+ platforms: {
+ ios: {npmPackageName: 'temp-package'},
+ android: {npmPackageName: 'temp-package'},
+ },
+};
+
+describe('loadMetroConfig', () => {
+ test('loads an empty config', async () => {
+ const rootPath = createTempPackage({name: 'temp-app'});
+ createTempConfig(rootPath, {});
+
+ const loadedConfig = await loadMetroConfig({
+ root: rootPath,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(rootPath);
+ expect(loadedConfig.watchFolders).toEqual([rootPath]);
+ });
+
+ test('loads watch folders', async () => {
+ const rootPath = createTempPackage({
+ name: 'temp-app',
+ });
+ createTempConfig(rootPath, {
+ watchFolders: ['somewhere-else'],
+ });
+
+ const loadedConfig = await loadMetroConfig({
+ root: rootPath,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(rootPath);
+ expect(loadedConfig.watchFolders).toEqual([rootPath, 'somewhere-else']);
+ });
+
+ test('includes an npm workspace root if no watchFolders are defined', async () => {
+ const rootPath = createTempPackage({
+ name: 'temp-root',
+ workspaces: ['packages/temp-app'],
+ });
+ // Create a config inside a sub-package
+ const projectRoot = createTempPackage(
+ {
+ name: 'temp-app',
+ },
+ path.join(rootPath, 'packages', 'temp-app'),
+ );
+ createTempConfig(projectRoot, {});
+
+ const loadedConfig = await loadMetroConfig({
+ root: projectRoot,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(projectRoot);
+ expect(loadedConfig.watchFolders).toEqual([projectRoot, rootPath]);
+ });
+
+ test('does not resolve an npm workspace root if watchFolders are defined', async () => {
+ const rootPath = createTempPackage({
+ name: 'temp-root',
+ workspaces: ['packages/temp-app'],
+ });
+ // Create a config inside a sub-package
+ const projectRoot = createTempPackage(
+ {
+ name: 'temp-app',
+ },
+ path.join(rootPath, 'packages', 'temp-app'),
+ );
+ createTempConfig(projectRoot, {
+ watchFolders: [],
+ });
+
+ const loadedConfig = await loadMetroConfig({
+ root: projectRoot,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(projectRoot);
+ expect(loadedConfig.watchFolders).toEqual([projectRoot]);
+ });
+});

packages/community-cli-plugin/src/utils/__tests__/temporary-package.js

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+export function createTempPackage(
+ packageJson: {...},
+ packagePath: string = fs.mkdtempSync(
+ path.join(os.tmpdir(), 'rn-metro-config-test-'),
+ ),
+): string {
+ fs.mkdirSync(packagePath, {recursive: true});
+ if (typeof packageJson === 'object') {
+ fs.writeFileSync(
+ path.join(packagePath, 'package.json'),
+ JSON.stringify(packageJson),
+ 'utf8',
+ );
+ }
+
+ // Wrapping path in realpath to resolve any symlinks introduced by mkdtemp
+ return fs.realpathSync(packagePath);
+}

packages/community-cli-plugin/src/utils/getWorkspaceRoot.js

@@ -0,0 +1,86 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ * @oncall react_native
+ */
+
+import {logger} from '@react-native-community/cli-tools';
+import fs from 'fs';
+import micromatch from 'micromatch';
+import path from 'path';
+import yaml from 'yaml';
+
+/**
+ * Get the workspace paths from the path of a potential workspace root.
+ *
+ * This supports:
+ * - [npm workspaces](https://docs.npmjs.com/cli/v10/using-npm/workspaces)
+ * - [yarn workspaces](https://yarnpkg.com/features/workspaces)
+ * - [pnpm workspaces](https://pnpm.io/workspaces)
+ */
+function getWorkspacePaths(packagePath: string): Array<string> {
+ try {
+ // Checking pnpm workspaces first
+ const pnpmWorkspacePath = path.resolve(packagePath, 'pnpm-workspace.yaml');
+ if (fs.existsSync(pnpmWorkspacePath)) {
+ const pnpmWorkspaceConfig = yaml.parse(
+ fs.readFileSync(pnpmWorkspacePath, 'utf8'),
+ );
+ if (
+ typeof pnpmWorkspaceConfig === 'object' &&
+ Array.isArray(pnpmWorkspaceConfig.packages)
+ ) {
+ return pnpmWorkspaceConfig.packages;
+ }
+ }
+ // Falling back to npm / yarn workspaces
+ const packageJsonPath = path.resolve(packagePath, 'package.json');
+ const {workspaces} = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+ if (Array.isArray(workspaces)) {
+ return workspaces;
+ } else if (
+ typeof workspaces === 'object' &&
+ Array.isArray(workspaces.packages)
+ ) {
+ // An alternative way for yarn to declare workspace packages
+ return workspaces.packages;
+ }
+ } catch (err) {
+ if (err.code !== 'ENOENT') {
+ logger.debug(`Failed getting workspace root from ${packagePath}: ${err}`);
+ }
+ }
+ return [];
+}
+
+/**
+ * Resolves the root of an npm or yarn workspace, by traversing the file tree
+ * upwards from a `candidatePath` in the search for
+ * - a directory with a package.json
+ * - which has a `workspaces` array of strings
+ * - which (possibly via a glob) includes the project root
+ */
+export function getWorkspaceRoot(
+ projectRoot: string,
+ candidatePath: string = projectRoot,
+): ?string {
+ const workspacePaths = getWorkspacePaths(candidatePath);
+ // If one of the workspaces match the project root, this is the workspace root
+ // Note: While npm workspaces doesn't currently support globs, yarn does, which is why we use micromatch
+ const relativePath = path.relative(candidatePath, projectRoot);
+ // Using this instead of `micromatch.isMatch` to enable excluding patterns
+ if (micromatch([relativePath], workspacePaths).length > 0) {
+ return candidatePath;
+ }
+ // Try one level up
+ const parentDir = path.dirname(candidatePath);
+ if (parentDir !== candidatePath) {
+ return getWorkspaceRoot(projectRoot, parentDir);
+ }
+ return null;
+}

packages/community-cli-plugin/package.json

@@ -31,9 +31,11 @@
  "metro": "^0.80.3",
  "metro-config": "^0.80.3",
  "metro-core": "^0.80.3",
+ "micromatch": "^4.0.5",
  "node-fetch": "^2.2.0",
  "querystring": "^0.2.1",
- "readline": "^1.3.0"
+ "readline": "^1.3.0",
+ "yaml": "^2.3.4"
  },
  "devDependencies": {
  "metro-resolver": "^0.80.3"

packages/community-cli-plugin/src/utils/__tests__/getWorkspaceRoot-test.js

@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import {getWorkspaceRoot} from '../getWorkspaceRoot';
+import {createTempPackage} from './temporary-package';
+import fs from 'fs';
+import path from 'path';
+
+describe('getWorkspaceRoot', () => {
+ test('returns null if not in a workspace', () => {
+ const tempPackagePath = createTempPackage({
+ name: 'my-app',
+ });
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(null);
+ });
+
+ test('supports an npm workspace', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ workspaces: ['packages/my-app', 'packages/my-lib'],
+ });
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a yarn workspace', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ workspaces: ['packages/*'],
+ });
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a yarn workspace (object style)', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ workspaces: {
+ packages: ['packages/*'],
+ },
+ });
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a pnpm workspace', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ });
+ // Create the pnpm workspace configuration (see https://pnpm.io/pnpm-workspace_yaml)
+ const workspacesConfig = 'packages: ["packages/*"]';
+ fs.writeFileSync(
+ path.join(tempWorkspaceRootPath, 'pnpm-workspace.yaml'),
+ workspacesConfig,
+ 'utf8',
+ );
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a pnpm workspace exclusion', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ });
+ // Create the pnpm workspace configuration (see https://pnpm.io/pnpm-workspace_yaml)
+ const workspacesConfig = 'packages: ["packages/*", "!packages/*-app"]';
+ fs.writeFileSync(
+ path.join(tempWorkspaceRootPath, 'pnpm-workspace.yaml'),
+ workspacesConfig,
+ 'utf8',
+ );
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(null);
+ });
+});

packages/community-cli-plugin/src/utils/__tests__/loadMetroConfig-test.js

@@ -0,0 +1,133 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import loadMetroConfig from '../loadMetroConfig';
+import {createTempPackage} from './temporary-package';
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Resolves a package by its name and creates a symbolic link in a node_modules directory
+ */
+function createPackageLink(nodeModulesPath: string, packageName: string) {
+ // Resolve the packages path on disk
+ const destinationPath = path.dirname(require.resolve(packageName));
+ const packageScope = packageName.includes('/')
+ ? packageName.split('/')[0]
+ : undefined;
+
+ // Create a parent directory for a @scoped package
+ if (typeof packageScope === 'string') {
+ fs.mkdirSync(path.join(nodeModulesPath, packageScope));
+ }
+
+ const sourcePath = path.join(nodeModulesPath, packageName);
+ fs.symlinkSync(destinationPath, sourcePath);
+}
+
+function createTempConfig(projectRoot: string, metroConfig: {...}) {
+ const content = `
+ const {getDefaultConfig, mergeConfig} = require('@react-native/metro-config');
+ const config = ${JSON.stringify(metroConfig)};
+ module.exports = mergeConfig(getDefaultConfig(__dirname), config);
+ `;
+ const configPath = path.join(projectRoot, 'metro.config.js');
+ fs.writeFileSync(configPath, content, 'utf8');
+
+ const nodeModulesPath = path.join(projectRoot, 'node_modules');
+ fs.mkdirSync(nodeModulesPath);
+ // Create a symbolic link to the '@react-native/metro-config' package used by the config
+ createPackageLink(nodeModulesPath, '@react-native/metro-config');
+}
+
+const configLoadingContext = {
+ reactNativePath: path.dirname(require.resolve('react-native/package.json')),
+ platforms: {
+ ios: {npmPackageName: 'temp-package'},
+ android: {npmPackageName: 'temp-package'},
+ },
+};
+
+describe('loadMetroConfig', () => {
+ test('loads an empty config', async () => {
+ const rootPath = createTempPackage({name: 'temp-app'});
+ createTempConfig(rootPath, {});
+
+ const loadedConfig = await loadMetroConfig({
+ root: rootPath,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(rootPath);
+ expect(loadedConfig.watchFolders).toEqual([rootPath]);
+ });
+
+ test('loads watch folders', async () => {
+ const rootPath = createTempPackage({
+ name: 'temp-app',
+ });
+ createTempConfig(rootPath, {
+ watchFolders: ['somewhere-else'],
+ });
+
+ const loadedConfig = await loadMetroConfig({
+ root: rootPath,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(rootPath);
+ expect(loadedConfig.watchFolders).toEqual([rootPath, 'somewhere-else']);
+ });
+
+ test('includes an npm workspace root if no watchFolders are defined', async () => {
+ const rootPath = createTempPackage({
+ name: 'temp-root',
+ workspaces: ['packages/temp-app'],
+ });
+ // Create a config inside a sub-package
+ const projectRoot = createTempPackage(
+ {
+ name: 'temp-app',
+ },
+ path.join(rootPath, 'packages', 'temp-app'),
+ );
+ createTempConfig(projectRoot, {});
+
+ const loadedConfig = await loadMetroConfig({
+ root: projectRoot,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(projectRoot);
+ expect(loadedConfig.watchFolders).toEqual([projectRoot, rootPath]);
+ });
+
+ test('does not resolve an npm workspace root if watchFolders are defined', async () => {
+ const rootPath = createTempPackage({
+ name: 'temp-root',
+ workspaces: ['packages/temp-app'],
+ });
+ // Create a config inside a sub-package
+ const projectRoot = createTempPackage(
+ {
+ name: 'temp-app',
+ },
+ path.join(rootPath, 'packages', 'temp-app'),
+ );
+ createTempConfig(projectRoot, {
+ watchFolders: [],
+ });
+
+ const loadedConfig = await loadMetroConfig({
+ root: projectRoot,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(projectRoot);
+ expect(loadedConfig.watchFolders).toEqual([projectRoot]);
+ });
+});

packages/community-cli-plugin/src/utils/__tests__/temporary-package.js

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+export function createTempPackage(
+ packageJson: {...},
+ packagePath: string = fs.mkdtempSync(
+ path.join(os.tmpdir(), 'rn-metro-config-test-'),
+ ),
+): string {
+ fs.mkdirSync(packagePath, {recursive: true});
+ if (typeof packageJson === 'object') {
+ fs.writeFileSync(
+ path.join(packagePath, 'package.json'),
+ JSON.stringify(packageJson),
+ 'utf8',
+ );
+ }
+
+ // Wrapping path in realpath to resolve any symlinks introduced by mkdtemp
+ return fs.realpathSync(packagePath);
+}

packages/community-cli-plugin/src/utils/getWorkspaceRoot.js

@@ -0,0 +1,86 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ * @oncall react_native
+ */
+
+import {logger} from '@react-native-community/cli-tools';
+import fs from 'fs';
+import micromatch from 'micromatch';
+import path from 'path';
+import yaml from 'yaml';
+
+/**
+ * Get the workspace paths from the path of a potential workspace root.
+ *
+ * This supports:
+ * - [npm workspaces](https://docs.npmjs.com/cli/v10/using-npm/workspaces)
+ * - [yarn workspaces](https://yarnpkg.com/features/workspaces)
+ * - [pnpm workspaces](https://pnpm.io/workspaces)
+ */
+function getWorkspacePaths(packagePath: string): Array<string> {
+ try {
+ // Checking pnpm workspaces first
+ const pnpmWorkspacePath = path.resolve(packagePath, 'pnpm-workspace.yaml');
+ if (fs.existsSync(pnpmWorkspacePath)) {
+ const pnpmWorkspaceConfig = yaml.parse(
+ fs.readFileSync(pnpmWorkspacePath, 'utf8'),
+ );
+ if (
+ typeof pnpmWorkspaceConfig === 'object' &&
+ Array.isArray(pnpmWorkspaceConfig.packages)
+ ) {
+ return pnpmWorkspaceConfig.packages;
+ }
+ }
+ // Falling back to npm / yarn workspaces
+ const packageJsonPath = path.resolve(packagePath, 'package.json');
+ const {workspaces} = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+ if (Array.isArray(workspaces)) {
+ return workspaces;
+ } else if (
+ typeof workspaces === 'object' &&
+ Array.isArray(workspaces.packages)
+ ) {
+ // An alternative way for yarn to declare workspace packages
+ return workspaces.packages;
+ }
+ } catch (err) {
+ if (err.code !== 'ENOENT') {
+ logger.debug(`Failed getting workspace root from ${packagePath}: ${err}`);
+ }
+ }
+ return [];
+}
+
+/**
+ * Resolves the root of an npm or yarn workspace, by traversing the file tree
+ * upwards from a `candidatePath` in the search for
+ * - a directory with a package.json
+ * - which has a `workspaces` array of strings
+ * - which (possibly via a glob) includes the project root
+ */
+export function getWorkspaceRoot(
+ projectRoot: string,
+ candidatePath: string = projectRoot,
+): ?string {
+ const workspacePaths = getWorkspacePaths(candidatePath);
+ // If one of the workspaces match the project root, this is the workspace root
+ // Note: While npm workspaces doesn't currently support globs, yarn does, which is why we use micromatch
+ const relativePath = path.relative(candidatePath, projectRoot);
+ // Using this instead of `micromatch.isMatch` to enable excluding patterns
+ if (micromatch([relativePath], workspacePaths).length > 0) {
+ return candidatePath;
+ }
+ // Try one level up
+ const parentDir = path.dirname(candidatePath);
+ if (parentDir !== candidatePath) {
+ return getWorkspaceRoot(projectRoot, parentDir);
+ }
+ return null;
+}

packages/community-cli-plugin/package.json

@@ -31,9 +31,11 @@
  "metro": "^0.80.3",
  "metro-config": "^0.80.3",
  "metro-core": "^0.80.3",
+ "micromatch": "^4.0.5",
  "node-fetch": "^2.2.0",
  "querystring": "^0.2.1",
- "readline": "^1.3.0"
+ "readline": "^1.3.0",
+ "yaml": "^2.3.4"
  },
  "devDependencies": {
  "metro-resolver": "^0.80.3"

packages/community-cli-plugin/src/utils/__tests__/getWorkspaceRoot-test.js

@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import {getWorkspaceRoot} from '../getWorkspaceRoot';
+import {createTempPackage} from './temporary-package';
+import fs from 'fs';
+import path from 'path';
+
+describe('getWorkspaceRoot', () => {
+ test('returns null if not in a workspace', () => {
+ const tempPackagePath = createTempPackage({
+ name: 'my-app',
+ });
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(null);
+ });
+
+ test('supports an npm workspace', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ workspaces: ['packages/my-app', 'packages/my-lib'],
+ });
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a yarn workspace', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ workspaces: ['packages/*'],
+ });
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a yarn workspace (object style)', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ workspaces: {
+ packages: ['packages/*'],
+ },
+ });
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a pnpm workspace', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ });
+ // Create the pnpm workspace configuration (see https://pnpm.io/pnpm-workspace_yaml)
+ const workspacesConfig = 'packages: ["packages/*"]';
+ fs.writeFileSync(
+ path.join(tempWorkspaceRootPath, 'pnpm-workspace.yaml'),
+ workspacesConfig,
+ 'utf8',
+ );
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a pnpm workspace exclusion', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ });
+ // Create the pnpm workspace configuration (see https://pnpm.io/pnpm-workspace_yaml)
+ const workspacesConfig = 'packages: ["packages/*", "!packages/*-app"]';
+ fs.writeFileSync(
+ path.join(tempWorkspaceRootPath, 'pnpm-workspace.yaml'),
+ workspacesConfig,
+ 'utf8',
+ );
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(null);
+ });
+});

packages/community-cli-plugin/src/utils/__tests__/loadMetroConfig-test.js

@@ -0,0 +1,133 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import loadMetroConfig from '../loadMetroConfig';
+import {createTempPackage} from './temporary-package';
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Resolves a package by its name and creates a symbolic link in a node_modules directory
+ */
+function createPackageLink(nodeModulesPath: string, packageName: string) {
+ // Resolve the packages path on disk
+ const destinationPath = path.dirname(require.resolve(packageName));
+ const packageScope = packageName.includes('/')
+ ? packageName.split('/')[0]
+ : undefined;
+
+ // Create a parent directory for a @scoped package
+ if (typeof packageScope === 'string') {
+ fs.mkdirSync(path.join(nodeModulesPath, packageScope));
+ }
+
+ const sourcePath = path.join(nodeModulesPath, packageName);
+ fs.symlinkSync(destinationPath, sourcePath);
+}
+
+function createTempConfig(projectRoot: string, metroConfig: {...}) {
+ const content = `
+ const {getDefaultConfig, mergeConfig} = require('@react-native/metro-config');
+ const config = ${JSON.stringify(metroConfig)};
+ module.exports = mergeConfig(getDefaultConfig(__dirname), config);
+ `;
+ const configPath = path.join(projectRoot, 'metro.config.js');
+ fs.writeFileSync(configPath, content, 'utf8');
+
+ const nodeModulesPath = path.join(projectRoot, 'node_modules');
+ fs.mkdirSync(nodeModulesPath);
+ // Create a symbolic link to the '@react-native/metro-config' package used by the config
+ createPackageLink(nodeModulesPath, '@react-native/metro-config');
+}
+
+const configLoadingContext = {
+ reactNativePath: path.dirname(require.resolve('react-native/package.json')),
+ platforms: {
+ ios: {npmPackageName: 'temp-package'},
+ android: {npmPackageName: 'temp-package'},
+ },
+};
+
+describe('loadMetroConfig', () => {
+ test('loads an empty config', async () => {
+ const rootPath = createTempPackage({name: 'temp-app'});
+ createTempConfig(rootPath, {});
+
+ const loadedConfig = await loadMetroConfig({
+ root: rootPath,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(rootPath);
+ expect(loadedConfig.watchFolders).toEqual([rootPath]);
+ });
+
+ test('loads watch folders', async () => {
+ const rootPath = createTempPackage({
+ name: 'temp-app',
+ });
+ createTempConfig(rootPath, {
+ watchFolders: ['somewhere-else'],
+ });
+
+ const loadedConfig = await loadMetroConfig({
+ root: rootPath,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(rootPath);
+ expect(loadedConfig.watchFolders).toEqual([rootPath, 'somewhere-else']);
+ });
+
+ test('includes an npm workspace root if no watchFolders are defined', async () => {
+ const rootPath = createTempPackage({
+ name: 'temp-root',
+ workspaces: ['packages/temp-app'],
+ });
+ // Create a config inside a sub-package
+ const projectRoot = createTempPackage(
+ {
+ name: 'temp-app',
+ },
+ path.join(rootPath, 'packages', 'temp-app'),
+ );
+ createTempConfig(projectRoot, {});
+
+ const loadedConfig = await loadMetroConfig({
+ root: projectRoot,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(projectRoot);
+ expect(loadedConfig.watchFolders).toEqual([projectRoot, rootPath]);
+ });
+
+ test('does not resolve an npm workspace root if watchFolders are defined', async () => {
+ const rootPath = createTempPackage({
+ name: 'temp-root',
+ workspaces: ['packages/temp-app'],
+ });
+ // Create a config inside a sub-package
+ const projectRoot = createTempPackage(
+ {
+ name: 'temp-app',
+ },
+ path.join(rootPath, 'packages', 'temp-app'),
+ );
+ createTempConfig(projectRoot, {
+ watchFolders: [],
+ });
+
+ const loadedConfig = await loadMetroConfig({
+ root: projectRoot,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(projectRoot);
+ expect(loadedConfig.watchFolders).toEqual([projectRoot]);
+ });
+});

packages/community-cli-plugin/src/utils/__tests__/temporary-package.js

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+export function createTempPackage(
+ packageJson: {...},
+ packagePath: string = fs.mkdtempSync(
+ path.join(os.tmpdir(), 'rn-metro-config-test-'),
+ ),
+): string {
+ fs.mkdirSync(packagePath, {recursive: true});
+ if (typeof packageJson === 'object') {
+ fs.writeFileSync(
+ path.join(packagePath, 'package.json'),
+ JSON.stringify(packageJson),
+ 'utf8',
+ );
+ }
+
+ // Wrapping path in realpath to resolve any symlinks introduced by mkdtemp
+ return fs.realpathSync(packagePath);
+}

packages/community-cli-plugin/src/utils/getWorkspaceRoot.js

@@ -0,0 +1,86 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ * @oncall react_native
+ */
+
+import {logger} from '@react-native-community/cli-tools';
+import fs from 'fs';
+import micromatch from 'micromatch';
+import path from 'path';
+import yaml from 'yaml';
+
+/**
+ * Get the workspace paths from the path of a potential workspace root.
+ *
+ * This supports:
+ * - [npm workspaces](https://docs.npmjs.com/cli/v10/using-npm/workspaces)
+ * - [yarn workspaces](https://yarnpkg.com/features/workspaces)
+ * - [pnpm workspaces](https://pnpm.io/workspaces)
+ */
+function getWorkspacePaths(packagePath: string): Array<string> {
+ try {
+ // Checking pnpm workspaces first
+ const pnpmWorkspacePath = path.resolve(packagePath, 'pnpm-workspace.yaml');
+ if (fs.existsSync(pnpmWorkspacePath)) {
+ const pnpmWorkspaceConfig = yaml.parse(
+ fs.readFileSync(pnpmWorkspacePath, 'utf8'),
+ );
+ if (
+ typeof pnpmWorkspaceConfig === 'object' &&
+ Array.isArray(pnpmWorkspaceConfig.packages)
+ ) {
+ return pnpmWorkspaceConfig.packages;
+ }
+ }
+ // Falling back to npm / yarn workspaces
+ const packageJsonPath = path.resolve(packagePath, 'package.json');
+ const {workspaces} = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+ if (Array.isArray(workspaces)) {
+ return workspaces;
+ } else if (
+ typeof workspaces === 'object' &&
+ Array.isArray(workspaces.packages)
+ ) {
+ // An alternative way for yarn to declare workspace packages
+ return workspaces.packages;
+ }
+ } catch (err) {
+ if (err.code !== 'ENOENT') {
+ logger.debug(`Failed getting workspace root from ${packagePath}: ${err}`);
+ }
+ }
+ return [];
+}
+
+/**
+ * Resolves the root of an npm or yarn workspace, by traversing the file tree
+ * upwards from a `candidatePath` in the search for
+ * - a directory with a package.json
+ * - which has a `workspaces` array of strings
+ * - which (possibly via a glob) includes the project root
+ */
+export function getWorkspaceRoot(
+ projectRoot: string,
+ candidatePath: string = projectRoot,
+): ?string {
+ const workspacePaths = getWorkspacePaths(candidatePath);
+ // If one of the workspaces match the project root, this is the workspace root
+ // Note: While npm workspaces doesn't currently support globs, yarn does, which is why we use micromatch
+ const relativePath = path.relative(candidatePath, projectRoot);
+ // Using this instead of `micromatch.isMatch` to enable excluding patterns
+ if (micromatch([relativePath], workspacePaths).length > 0) {
+ return candidatePath;
+ }
+ // Try one level up
+ const parentDir = path.dirname(candidatePath);
+ if (parentDir !== candidatePath) {
+ return getWorkspaceRoot(projectRoot, parentDir);
+ }
+ return null;
+}

packages/community-cli-plugin/package.json

@@ -31,9 +31,11 @@
  "metro": "^0.80.3",
  "metro-config": "^0.80.3",
  "metro-core": "^0.80.3",
+ "micromatch": "^4.0.5",
  "node-fetch": "^2.2.0",
  "querystring": "^0.2.1",
- "readline": "^1.3.0"
+ "readline": "^1.3.0",
+ "yaml": "^2.3.4"
  },
  "devDependencies": {
  "metro-resolver": "^0.80.3"

packages/community-cli-plugin/src/utils/__tests__/getWorkspaceRoot-test.js

@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import {getWorkspaceRoot} from '../getWorkspaceRoot';
+import {createTempPackage} from './temporary-package';
+import fs from 'fs';
+import path from 'path';
+
+describe('getWorkspaceRoot', () => {
+ test('returns null if not in a workspace', () => {
+ const tempPackagePath = createTempPackage({
+ name: 'my-app',
+ });
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(null);
+ });
+
+ test('supports an npm workspace', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ workspaces: ['packages/my-app', 'packages/my-lib'],
+ });
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a yarn workspace', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ workspaces: ['packages/*'],
+ });
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a yarn workspace (object style)', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ workspaces: {
+ packages: ['packages/*'],
+ },
+ });
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a pnpm workspace', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ });
+ // Create the pnpm workspace configuration (see https://pnpm.io/pnpm-workspace_yaml)
+ const workspacesConfig = 'packages: ["packages/*"]';
+ fs.writeFileSync(
+ path.join(tempWorkspaceRootPath, 'pnpm-workspace.yaml'),
+ workspacesConfig,
+ 'utf8',
+ );
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a pnpm workspace exclusion', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ });
+ // Create the pnpm workspace configuration (see https://pnpm.io/pnpm-workspace_yaml)
+ const workspacesConfig = 'packages: ["packages/*", "!packages/*-app"]';
+ fs.writeFileSync(
+ path.join(tempWorkspaceRootPath, 'pnpm-workspace.yaml'),
+ workspacesConfig,
+ 'utf8',
+ );
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(null);
+ });
+});

packages/community-cli-plugin/src/utils/__tests__/loadMetroConfig-test.js

@@ -0,0 +1,133 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import loadMetroConfig from '../loadMetroConfig';
+import {createTempPackage} from './temporary-package';
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Resolves a package by its name and creates a symbolic link in a node_modules directory
+ */
+function createPackageLink(nodeModulesPath: string, packageName: string) {
+ // Resolve the packages path on disk
+ const destinationPath = path.dirname(require.resolve(packageName));
+ const packageScope = packageName.includes('/')
+ ? packageName.split('/')[0]
+ : undefined;
+
+ // Create a parent directory for a @scoped package
+ if (typeof packageScope === 'string') {
+ fs.mkdirSync(path.join(nodeModulesPath, packageScope));
+ }
+
+ const sourcePath = path.join(nodeModulesPath, packageName);
+ fs.symlinkSync(destinationPath, sourcePath);
+}
+
+function createTempConfig(projectRoot: string, metroConfig: {...}) {
+ const content = `
+ const {getDefaultConfig, mergeConfig} = require('@react-native/metro-config');
+ const config = ${JSON.stringify(metroConfig)};
+ module.exports = mergeConfig(getDefaultConfig(__dirname), config);
+ `;
+ const configPath = path.join(projectRoot, 'metro.config.js');
+ fs.writeFileSync(configPath, content, 'utf8');
+
+ const nodeModulesPath = path.join(projectRoot, 'node_modules');
+ fs.mkdirSync(nodeModulesPath);
+ // Create a symbolic link to the '@react-native/metro-config' package used by the config
+ createPackageLink(nodeModulesPath, '@react-native/metro-config');
+}
+
+const configLoadingContext = {
+ reactNativePath: path.dirname(require.resolve('react-native/package.json')),
+ platforms: {
+ ios: {npmPackageName: 'temp-package'},
+ android: {npmPackageName: 'temp-package'},
+ },
+};
+
+describe('loadMetroConfig', () => {
+ test('loads an empty config', async () => {
+ const rootPath = createTempPackage({name: 'temp-app'});
+ createTempConfig(rootPath, {});
+
+ const loadedConfig = await loadMetroConfig({
+ root: rootPath,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(rootPath);
+ expect(loadedConfig.watchFolders).toEqual([rootPath]);
+ });
+
+ test('loads watch folders', async () => {
+ const rootPath = createTempPackage({
+ name: 'temp-app',
+ });
+ createTempConfig(rootPath, {
+ watchFolders: ['somewhere-else'],
+ });
+
+ const loadedConfig = await loadMetroConfig({
+ root: rootPath,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(rootPath);
+ expect(loadedConfig.watchFolders).toEqual([rootPath, 'somewhere-else']);
+ });
+
+ test('includes an npm workspace root if no watchFolders are defined', async () => {
+ const rootPath = createTempPackage({
+ name: 'temp-root',
+ workspaces: ['packages/temp-app'],
+ });
+ // Create a config inside a sub-package
+ const projectRoot = createTempPackage(
+ {
+ name: 'temp-app',
+ },
+ path.join(rootPath, 'packages', 'temp-app'),
+ );
+ createTempConfig(projectRoot, {});
+
+ const loadedConfig = await loadMetroConfig({
+ root: projectRoot,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(projectRoot);
+ expect(loadedConfig.watchFolders).toEqual([projectRoot, rootPath]);
+ });
+
+ test('does not resolve an npm workspace root if watchFolders are defined', async () => {
+ const rootPath = createTempPackage({
+ name: 'temp-root',
+ workspaces: ['packages/temp-app'],
+ });
+ // Create a config inside a sub-package
+ const projectRoot = createTempPackage(
+ {
+ name: 'temp-app',
+ },
+ path.join(rootPath, 'packages', 'temp-app'),
+ );
+ createTempConfig(projectRoot, {
+ watchFolders: [],
+ });
+
+ const loadedConfig = await loadMetroConfig({
+ root: projectRoot,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(projectRoot);
+ expect(loadedConfig.watchFolders).toEqual([projectRoot]);
+ });
+});

packages/community-cli-plugin/src/utils/__tests__/temporary-package.js

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+export function createTempPackage(
+ packageJson: {...},
+ packagePath: string = fs.mkdtempSync(
+ path.join(os.tmpdir(), 'rn-metro-config-test-'),
+ ),
+): string {
+ fs.mkdirSync(packagePath, {recursive: true});
+ if (typeof packageJson === 'object') {
+ fs.writeFileSync(
+ path.join(packagePath, 'package.json'),
+ JSON.stringify(packageJson),
+ 'utf8',
+ );
+ }
+
+ // Wrapping path in realpath to resolve any symlinks introduced by mkdtemp
+ return fs.realpathSync(packagePath);
+}

packages/community-cli-plugin/src/utils/getWorkspaceRoot.js

@@ -0,0 +1,86 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ * @oncall react_native
+ */
+
+import {logger} from '@react-native-community/cli-tools';
+import fs from 'fs';
+import micromatch from 'micromatch';
+import path from 'path';
+import yaml from 'yaml';
+
+/**
+ * Get the workspace paths from the path of a potential workspace root.
+ *
+ * This supports:
+ * - [npm workspaces](https://docs.npmjs.com/cli/v10/using-npm/workspaces)
+ * - [yarn workspaces](https://yarnpkg.com/features/workspaces)
+ * - [pnpm workspaces](https://pnpm.io/workspaces)
+ */
+function getWorkspacePaths(packagePath: string): Array<string> {
+ try {
+ // Checking pnpm workspaces first
+ const pnpmWorkspacePath = path.resolve(packagePath, 'pnpm-workspace.yaml');
+ if (fs.existsSync(pnpmWorkspacePath)) {
+ const pnpmWorkspaceConfig = yaml.parse(
+ fs.readFileSync(pnpmWorkspacePath, 'utf8'),
+ );
+ if (
+ typeof pnpmWorkspaceConfig === 'object' &&
+ Array.isArray(pnpmWorkspaceConfig.packages)
+ ) {
+ return pnpmWorkspaceConfig.packages;
+ }
+ }
+ // Falling back to npm / yarn workspaces
+ const packageJsonPath = path.resolve(packagePath, 'package.json');
+ const {workspaces} = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+ if (Array.isArray(workspaces)) {
+ return workspaces;
+ } else if (
+ typeof workspaces === 'object' &&
+ Array.isArray(workspaces.packages)
+ ) {
+ // An alternative way for yarn to declare workspace packages
+ return workspaces.packages;
+ }
+ } catch (err) {
+ if (err.code !== 'ENOENT') {
+ logger.debug(`Failed getting workspace root from ${packagePath}: ${err}`);
+ }
+ }
+ return [];
+}
+
+/**
+ * Resolves the root of an npm or yarn workspace, by traversing the file tree
+ * upwards from a `candidatePath` in the search for
+ * - a directory with a package.json
+ * - which has a `workspaces` array of strings
+ * - which (possibly via a glob) includes the project root
+ */
+export function getWorkspaceRoot(
+ projectRoot: string,
+ candidatePath: string = projectRoot,
+): ?string {
+ const workspacePaths = getWorkspacePaths(candidatePath);
+ // If one of the workspaces match the project root, this is the workspace root
+ // Note: While npm workspaces doesn't currently support globs, yarn does, which is why we use micromatch
+ const relativePath = path.relative(candidatePath, projectRoot);
+ // Using this instead of `micromatch.isMatch` to enable excluding patterns
+ if (micromatch([relativePath], workspacePaths).length > 0) {
+ return candidatePath;
+ }
+ // Try one level up
+ const parentDir = path.dirname(candidatePath);
+ if (parentDir !== candidatePath) {
+ return getWorkspaceRoot(projectRoot, parentDir);
+ }
+ return null;
+}

packages/community-cli-plugin/package.json

@@ -31,9 +31,11 @@
  "metro": "^0.80.3",
  "metro-config": "^0.80.3",
  "metro-core": "^0.80.3",
+ "micromatch": "^4.0.5",
  "node-fetch": "^2.2.0",
  "querystring": "^0.2.1",
- "readline": "^1.3.0"
+ "readline": "^1.3.0",
+ "yaml": "^2.3.4"
  },
  "devDependencies": {
  "metro-resolver": "^0.80.3"

packages/community-cli-plugin/src/utils/__tests__/getWorkspaceRoot-test.js

@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import {getWorkspaceRoot} from '../getWorkspaceRoot';
+import {createTempPackage} from './temporary-package';
+import fs from 'fs';
+import path from 'path';
+
+describe('getWorkspaceRoot', () => {
+ test('returns null if not in a workspace', () => {
+ const tempPackagePath = createTempPackage({
+ name: 'my-app',
+ });
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(null);
+ });
+
+ test('supports an npm workspace', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ workspaces: ['packages/my-app', 'packages/my-lib'],
+ });
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a yarn workspace', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ workspaces: ['packages/*'],
+ });
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a yarn workspace (object style)', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ workspaces: {
+ packages: ['packages/*'],
+ },
+ });
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a pnpm workspace', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ });
+ // Create the pnpm workspace configuration (see https://pnpm.io/pnpm-workspace_yaml)
+ const workspacesConfig = 'packages: ["packages/*"]';
+ fs.writeFileSync(
+ path.join(tempWorkspaceRootPath, 'pnpm-workspace.yaml'),
+ workspacesConfig,
+ 'utf8',
+ );
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a pnpm workspace exclusion', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ });
+ // Create the pnpm workspace configuration (see https://pnpm.io/pnpm-workspace_yaml)
+ const workspacesConfig = 'packages: ["packages/*", "!packages/*-app"]';
+ fs.writeFileSync(
+ path.join(tempWorkspaceRootPath, 'pnpm-workspace.yaml'),
+ workspacesConfig,
+ 'utf8',
+ );
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(null);
+ });
+});

packages/community-cli-plugin/src/utils/__tests__/loadMetroConfig-test.js

@@ -0,0 +1,133 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import loadMetroConfig from '../loadMetroConfig';
+import {createTempPackage} from './temporary-package';
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Resolves a package by its name and creates a symbolic link in a node_modules directory
+ */
+function createPackageLink(nodeModulesPath: string, packageName: string) {
+ // Resolve the packages path on disk
+ const destinationPath = path.dirname(require.resolve(packageName));
+ const packageScope = packageName.includes('/')
+ ? packageName.split('/')[0]
+ : undefined;
+
+ // Create a parent directory for a @scoped package
+ if (typeof packageScope === 'string') {
+ fs.mkdirSync(path.join(nodeModulesPath, packageScope));
+ }
+
+ const sourcePath = path.join(nodeModulesPath, packageName);
+ fs.symlinkSync(destinationPath, sourcePath);
+}
+
+function createTempConfig(projectRoot: string, metroConfig: {...}) {
+ const content = `
+ const {getDefaultConfig, mergeConfig} = require('@react-native/metro-config');
+ const config = ${JSON.stringify(metroConfig)};
+ module.exports = mergeConfig(getDefaultConfig(__dirname), config);
+ `;
+ const configPath = path.join(projectRoot, 'metro.config.js');
+ fs.writeFileSync(configPath, content, 'utf8');
+
+ const nodeModulesPath = path.join(projectRoot, 'node_modules');
+ fs.mkdirSync(nodeModulesPath);
+ // Create a symbolic link to the '@react-native/metro-config' package used by the config
+ createPackageLink(nodeModulesPath, '@react-native/metro-config');
+}
+
+const configLoadingContext = {
+ reactNativePath: path.dirname(require.resolve('react-native/package.json')),
+ platforms: {
+ ios: {npmPackageName: 'temp-package'},
+ android: {npmPackageName: 'temp-package'},
+ },
+};
+
+describe('loadMetroConfig', () => {
+ test('loads an empty config', async () => {
+ const rootPath = createTempPackage({name: 'temp-app'});
+ createTempConfig(rootPath, {});
+
+ const loadedConfig = await loadMetroConfig({
+ root: rootPath,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(rootPath);
+ expect(loadedConfig.watchFolders).toEqual([rootPath]);
+ });
+
+ test('loads watch folders', async () => {
+ const rootPath = createTempPackage({
+ name: 'temp-app',
+ });
+ createTempConfig(rootPath, {
+ watchFolders: ['somewhere-else'],
+ });
+
+ const loadedConfig = await loadMetroConfig({
+ root: rootPath,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(rootPath);
+ expect(loadedConfig.watchFolders).toEqual([rootPath, 'somewhere-else']);
+ });
+
+ test('includes an npm workspace root if no watchFolders are defined', async () => {
+ const rootPath = createTempPackage({
+ name: 'temp-root',
+ workspaces: ['packages/temp-app'],
+ });
+ // Create a config inside a sub-package
+ const projectRoot = createTempPackage(
+ {
+ name: 'temp-app',
+ },
+ path.join(rootPath, 'packages', 'temp-app'),
+ );
+ createTempConfig(projectRoot, {});
+
+ const loadedConfig = await loadMetroConfig({
+ root: projectRoot,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(projectRoot);
+ expect(loadedConfig.watchFolders).toEqual([projectRoot, rootPath]);
+ });
+
+ test('does not resolve an npm workspace root if watchFolders are defined', async () => {
+ const rootPath = createTempPackage({
+ name: 'temp-root',
+ workspaces: ['packages/temp-app'],
+ });
+ // Create a config inside a sub-package
+ const projectRoot = createTempPackage(
+ {
+ name: 'temp-app',
+ },
+ path.join(rootPath, 'packages', 'temp-app'),
+ );
+ createTempConfig(projectRoot, {
+ watchFolders: [],
+ });
+
+ const loadedConfig = await loadMetroConfig({
+ root: projectRoot,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(projectRoot);
+ expect(loadedConfig.watchFolders).toEqual([projectRoot]);
+ });
+});

packages/community-cli-plugin/src/utils/__tests__/temporary-package.js

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+export function createTempPackage(
+ packageJson: {...},
+ packagePath: string = fs.mkdtempSync(
+ path.join(os.tmpdir(), 'rn-metro-config-test-'),
+ ),
+): string {
+ fs.mkdirSync(packagePath, {recursive: true});
+ if (typeof packageJson === 'object') {
+ fs.writeFileSync(
+ path.join(packagePath, 'package.json'),
+ JSON.stringify(packageJson),
+ 'utf8',
+ );
+ }
+
+ // Wrapping path in realpath to resolve any symlinks introduced by mkdtemp
+ return fs.realpathSync(packagePath);
+}

packages/community-cli-plugin/src/utils/getWorkspaceRoot.js

@@ -0,0 +1,86 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ * @oncall react_native
+ */
+
+import {logger} from '@react-native-community/cli-tools';
+import fs from 'fs';
+import micromatch from 'micromatch';
+import path from 'path';
+import yaml from 'yaml';
+
+/**
+ * Get the workspace paths from the path of a potential workspace root.
+ *
+ * This supports:
+ * - [npm workspaces](https://docs.npmjs.com/cli/v10/using-npm/workspaces)
+ * - [yarn workspaces](https://yarnpkg.com/features/workspaces)
+ * - [pnpm workspaces](https://pnpm.io/workspaces)
+ */
+function getWorkspacePaths(packagePath: string): Array<string> {
+ try {
+ // Checking pnpm workspaces first
+ const pnpmWorkspacePath = path.resolve(packagePath, 'pnpm-workspace.yaml');
+ if (fs.existsSync(pnpmWorkspacePath)) {
+ const pnpmWorkspaceConfig = yaml.parse(
+ fs.readFileSync(pnpmWorkspacePath, 'utf8'),
+ );
+ if (
+ typeof pnpmWorkspaceConfig === 'object' &&
+ Array.isArray(pnpmWorkspaceConfig.packages)
+ ) {
+ return pnpmWorkspaceConfig.packages;
+ }
+ }
+ // Falling back to npm / yarn workspaces
+ const packageJsonPath = path.resolve(packagePath, 'package.json');
+ const {workspaces} = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+ if (Array.isArray(workspaces)) {
+ return workspaces;
+ } else if (
+ typeof workspaces === 'object' &&
+ Array.isArray(workspaces.packages)
+ ) {
+ // An alternative way for yarn to declare workspace packages
+ return workspaces.packages;
+ }
+ } catch (err) {
+ if (err.code !== 'ENOENT') {
+ logger.debug(`Failed getting workspace root from ${packagePath}: ${err}`);
+ }
+ }
+ return [];
+}
+
+/**
+ * Resolves the root of an npm or yarn workspace, by traversing the file tree
+ * upwards from a `candidatePath` in the search for
+ * - a directory with a package.json
+ * - which has a `workspaces` array of strings
+ * - which (possibly via a glob) includes the project root
+ */
+export function getWorkspaceRoot(
+ projectRoot: string,
+ candidatePath: string = projectRoot,
+): ?string {
+ const workspacePaths = getWorkspacePaths(candidatePath);
+ // If one of the workspaces match the project root, this is the workspace root
+ // Note: While npm workspaces doesn't currently support globs, yarn does, which is why we use micromatch
+ const relativePath = path.relative(candidatePath, projectRoot);
+ // Using this instead of `micromatch.isMatch` to enable excluding patterns
+ if (micromatch([relativePath], workspacePaths).length > 0) {
+ return candidatePath;
+ }
+ // Try one level up
+ const parentDir = path.dirname(candidatePath);
+ if (parentDir !== candidatePath) {
+ return getWorkspaceRoot(projectRoot, parentDir);
+ }
+ return null;
+}

packages/community-cli-plugin/package.json

@@ -31,9 +31,11 @@
  "metro": "^0.80.3",
  "metro-config": "^0.80.3",
  "metro-core": "^0.80.3",
+ "micromatch": "^4.0.5",
  "node-fetch": "^2.2.0",
  "querystring": "^0.2.1",
- "readline": "^1.3.0"
+ "readline": "^1.3.0",
+ "yaml": "^2.3.4"
  },
  "devDependencies": {
  "metro-resolver": "^0.80.3"

packages/community-cli-plugin/src/utils/__tests__/getWorkspaceRoot-test.js

@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import {getWorkspaceRoot} from '../getWorkspaceRoot';
+import {createTempPackage} from './temporary-package';
+import fs from 'fs';
+import path from 'path';
+
+describe('getWorkspaceRoot', () => {
+ test('returns null if not in a workspace', () => {
+ const tempPackagePath = createTempPackage({
+ name: 'my-app',
+ });
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(null);
+ });
+
+ test('supports an npm workspace', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ workspaces: ['packages/my-app', 'packages/my-lib'],
+ });
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a yarn workspace', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ workspaces: ['packages/*'],
+ });
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a yarn workspace (object style)', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ workspaces: {
+ packages: ['packages/*'],
+ },
+ });
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a pnpm workspace', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ });
+ // Create the pnpm workspace configuration (see https://pnpm.io/pnpm-workspace_yaml)
+ const workspacesConfig = 'packages: ["packages/*"]';
+ fs.writeFileSync(
+ path.join(tempWorkspaceRootPath, 'pnpm-workspace.yaml'),
+ workspacesConfig,
+ 'utf8',
+ );
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a pnpm workspace exclusion', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ });
+ // Create the pnpm workspace configuration (see https://pnpm.io/pnpm-workspace_yaml)
+ const workspacesConfig = 'packages: ["packages/*", "!packages/*-app"]';
+ fs.writeFileSync(
+ path.join(tempWorkspaceRootPath, 'pnpm-workspace.yaml'),
+ workspacesConfig,
+ 'utf8',
+ );
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(null);
+ });
+});

packages/community-cli-plugin/src/utils/__tests__/loadMetroConfig-test.js

@@ -0,0 +1,133 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import loadMetroConfig from '../loadMetroConfig';
+import {createTempPackage} from './temporary-package';
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Resolves a package by its name and creates a symbolic link in a node_modules directory
+ */
+function createPackageLink(nodeModulesPath: string, packageName: string) {
+ // Resolve the packages path on disk
+ const destinationPath = path.dirname(require.resolve(packageName));
+ const packageScope = packageName.includes('/')
+ ? packageName.split('/')[0]
+ : undefined;
+
+ // Create a parent directory for a @scoped package
+ if (typeof packageScope === 'string') {
+ fs.mkdirSync(path.join(nodeModulesPath, packageScope));
+ }
+
+ const sourcePath = path.join(nodeModulesPath, packageName);
+ fs.symlinkSync(destinationPath, sourcePath);
+}
+
+function createTempConfig(projectRoot: string, metroConfig: {...}) {
+ const content = `
+ const {getDefaultConfig, mergeConfig} = require('@react-native/metro-config');
+ const config = ${JSON.stringify(metroConfig)};
+ module.exports = mergeConfig(getDefaultConfig(__dirname), config);
+ `;
+ const configPath = path.join(projectRoot, 'metro.config.js');
+ fs.writeFileSync(configPath, content, 'utf8');
+
+ const nodeModulesPath = path.join(projectRoot, 'node_modules');
+ fs.mkdirSync(nodeModulesPath);
+ // Create a symbolic link to the '@react-native/metro-config' package used by the config
+ createPackageLink(nodeModulesPath, '@react-native/metro-config');
+}
+
+const configLoadingContext = {
+ reactNativePath: path.dirname(require.resolve('react-native/package.json')),
+ platforms: {
+ ios: {npmPackageName: 'temp-package'},
+ android: {npmPackageName: 'temp-package'},
+ },
+};
+
+describe('loadMetroConfig', () => {
+ test('loads an empty config', async () => {
+ const rootPath = createTempPackage({name: 'temp-app'});
+ createTempConfig(rootPath, {});
+
+ const loadedConfig = await loadMetroConfig({
+ root: rootPath,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(rootPath);
+ expect(loadedConfig.watchFolders).toEqual([rootPath]);
+ });
+
+ test('loads watch folders', async () => {
+ const rootPath = createTempPackage({
+ name: 'temp-app',
+ });
+ createTempConfig(rootPath, {
+ watchFolders: ['somewhere-else'],
+ });
+
+ const loadedConfig = await loadMetroConfig({
+ root: rootPath,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(rootPath);
+ expect(loadedConfig.watchFolders).toEqual([rootPath, 'somewhere-else']);
+ });
+
+ test('includes an npm workspace root if no watchFolders are defined', async () => {
+ const rootPath = createTempPackage({
+ name: 'temp-root',
+ workspaces: ['packages/temp-app'],
+ });
+ // Create a config inside a sub-package
+ const projectRoot = createTempPackage(
+ {
+ name: 'temp-app',
+ },
+ path.join(rootPath, 'packages', 'temp-app'),
+ );
+ createTempConfig(projectRoot, {});
+
+ const loadedConfig = await loadMetroConfig({
+ root: projectRoot,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(projectRoot);
+ expect(loadedConfig.watchFolders).toEqual([projectRoot, rootPath]);
+ });
+
+ test('does not resolve an npm workspace root if watchFolders are defined', async () => {
+ const rootPath = createTempPackage({
+ name: 'temp-root',
+ workspaces: ['packages/temp-app'],
+ });
+ // Create a config inside a sub-package
+ const projectRoot = createTempPackage(
+ {
+ name: 'temp-app',
+ },
+ path.join(rootPath, 'packages', 'temp-app'),
+ );
+ createTempConfig(projectRoot, {
+ watchFolders: [],
+ });
+
+ const loadedConfig = await loadMetroConfig({
+ root: projectRoot,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(projectRoot);
+ expect(loadedConfig.watchFolders).toEqual([projectRoot]);
+ });
+});

packages/community-cli-plugin/src/utils/__tests__/temporary-package.js

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+export function createTempPackage(
+ packageJson: {...},
+ packagePath: string = fs.mkdtempSync(
+ path.join(os.tmpdir(), 'rn-metro-config-test-'),
+ ),
+): string {
+ fs.mkdirSync(packagePath, {recursive: true});
+ if (typeof packageJson === 'object') {
+ fs.writeFileSync(
+ path.join(packagePath, 'package.json'),
+ JSON.stringify(packageJson),
+ 'utf8',
+ );
+ }
+
+ // Wrapping path in realpath to resolve any symlinks introduced by mkdtemp
+ return fs.realpathSync(packagePath);
+}

packages/community-cli-plugin/src/utils/getWorkspaceRoot.js

@@ -0,0 +1,86 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ * @oncall react_native
+ */
+
+import {logger} from '@react-native-community/cli-tools';
+import fs from 'fs';
+import micromatch from 'micromatch';
+import path from 'path';
+import yaml from 'yaml';
+
+/**
+ * Get the workspace paths from the path of a potential workspace root.
+ *
+ * This supports:
+ * - [npm workspaces](https://docs.npmjs.com/cli/v10/using-npm/workspaces)
+ * - [yarn workspaces](https://yarnpkg.com/features/workspaces)
+ * - [pnpm workspaces](https://pnpm.io/workspaces)
+ */
+function getWorkspacePaths(packagePath: string): Array<string> {
+ try {
+ // Checking pnpm workspaces first
+ const pnpmWorkspacePath = path.resolve(packagePath, 'pnpm-workspace.yaml');
+ if (fs.existsSync(pnpmWorkspacePath)) {
+ const pnpmWorkspaceConfig = yaml.parse(
+ fs.readFileSync(pnpmWorkspacePath, 'utf8'),
+ );
+ if (
+ typeof pnpmWorkspaceConfig === 'object' &&
+ Array.isArray(pnpmWorkspaceConfig.packages)
+ ) {
+ return pnpmWorkspaceConfig.packages;
+ }
+ }
+ // Falling back to npm / yarn workspaces
+ const packageJsonPath = path.resolve(packagePath, 'package.json');
+ const {workspaces} = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+ if (Array.isArray(workspaces)) {
+ return workspaces;
+ } else if (
+ typeof workspaces === 'object' &&
+ Array.isArray(workspaces.packages)
+ ) {
+ // An alternative way for yarn to declare workspace packages
+ return workspaces.packages;
+ }
+ } catch (err) {
+ if (err.code !== 'ENOENT') {
+ logger.debug(`Failed getting workspace root from ${packagePath}: ${err}`);
+ }
+ }
+ return [];
+}
+
+/**
+ * Resolves the root of an npm or yarn workspace, by traversing the file tree
+ * upwards from a `candidatePath` in the search for
+ * - a directory with a package.json
+ * - which has a `workspaces` array of strings
+ * - which (possibly via a glob) includes the project root
+ */
+export function getWorkspaceRoot(
+ projectRoot: string,
+ candidatePath: string = projectRoot,
+): ?string {
+ const workspacePaths = getWorkspacePaths(candidatePath);
+ // If one of the workspaces match the project root, this is the workspace root
+ // Note: While npm workspaces doesn't currently support globs, yarn does, which is why we use micromatch
+ const relativePath = path.relative(candidatePath, projectRoot);
+ // Using this instead of `micromatch.isMatch` to enable excluding patterns
+ if (micromatch([relativePath], workspacePaths).length > 0) {
+ return candidatePath;
+ }
+ // Try one level up
+ const parentDir = path.dirname(candidatePath);
+ if (parentDir !== candidatePath) {
+ return getWorkspaceRoot(projectRoot, parentDir);
+ }
+ return null;
+}

packages/community-cli-plugin/package.json

@@ -31,9 +31,11 @@
  "metro": "^0.80.3",
  "metro-config": "^0.80.3",
  "metro-core": "^0.80.3",
+ "micromatch": "^4.0.5",
  "node-fetch": "^2.2.0",
  "querystring": "^0.2.1",
- "readline": "^1.3.0"
+ "readline": "^1.3.0",
+ "yaml": "^2.3.4"
  },
  "devDependencies": {
  "metro-resolver": "^0.80.3"

packages/community-cli-plugin/src/utils/__tests__/getWorkspaceRoot-test.js

@@ -0,0 +1,108 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import {getWorkspaceRoot} from '../getWorkspaceRoot';
+import {createTempPackage} from './temporary-package';
+import fs from 'fs';
+import path from 'path';
+
+describe('getWorkspaceRoot', () => {
+ test('returns null if not in a workspace', () => {
+ const tempPackagePath = createTempPackage({
+ name: 'my-app',
+ });
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(null);
+ });
+
+ test('supports an npm workspace', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ workspaces: ['packages/my-app', 'packages/my-lib'],
+ });
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a yarn workspace', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ workspaces: ['packages/*'],
+ });
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a yarn workspace (object style)', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ workspaces: {
+ packages: ['packages/*'],
+ },
+ });
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a pnpm workspace', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ });
+ // Create the pnpm workspace configuration (see https://pnpm.io/pnpm-workspace_yaml)
+ const workspacesConfig = 'packages: ["packages/*"]';
+ fs.writeFileSync(
+ path.join(tempWorkspaceRootPath, 'pnpm-workspace.yaml'),
+ workspacesConfig,
+ 'utf8',
+ );
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(tempWorkspaceRootPath);
+ });
+
+ test('supports a pnpm workspace exclusion', () => {
+ const tempWorkspaceRootPath = createTempPackage({
+ name: 'package-root',
+ });
+ // Create the pnpm workspace configuration (see https://pnpm.io/pnpm-workspace_yaml)
+ const workspacesConfig = 'packages: ["packages/*", "!packages/*-app"]';
+ fs.writeFileSync(
+ path.join(tempWorkspaceRootPath, 'pnpm-workspace.yaml'),
+ workspacesConfig,
+ 'utf8',
+ );
+ const tempPackagePath = createTempPackage(
+ {
+ name: 'my-app',
+ },
+ path.join(tempWorkspaceRootPath, 'packages', 'my-app'),
+ );
+ expect(getWorkspaceRoot(tempPackagePath)).toBe(null);
+ });
+});

packages/community-cli-plugin/src/utils/__tests__/loadMetroConfig-test.js

@@ -0,0 +1,133 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import loadMetroConfig from '../loadMetroConfig';
+import {createTempPackage} from './temporary-package';
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Resolves a package by its name and creates a symbolic link in a node_modules directory
+ */
+function createPackageLink(nodeModulesPath: string, packageName: string) {
+ // Resolve the packages path on disk
+ const destinationPath = path.dirname(require.resolve(packageName));
+ const packageScope = packageName.includes('/')
+ ? packageName.split('/')[0]
+ : undefined;
+
+ // Create a parent directory for a @scoped package
+ if (typeof packageScope === 'string') {
+ fs.mkdirSync(path.join(nodeModulesPath, packageScope));
+ }
+
+ const sourcePath = path.join(nodeModulesPath, packageName);
+ fs.symlinkSync(destinationPath, sourcePath);
+}
+
+function createTempConfig(projectRoot: string, metroConfig: {...}) {
+ const content = `
+ const {getDefaultConfig, mergeConfig} = require('@react-native/metro-config');
+ const config = ${JSON.stringify(metroConfig)};
+ module.exports = mergeConfig(getDefaultConfig(__dirname), config);
+ `;
+ const configPath = path.join(projectRoot, 'metro.config.js');
+ fs.writeFileSync(configPath, content, 'utf8');
+
+ const nodeModulesPath = path.join(projectRoot, 'node_modules');
+ fs.mkdirSync(nodeModulesPath);
+ // Create a symbolic link to the '@react-native/metro-config' package used by the config
+ createPackageLink(nodeModulesPath, '@react-native/metro-config');
+}
+
+const configLoadingContext = {
+ reactNativePath: path.dirname(require.resolve('react-native/package.json')),
+ platforms: {
+ ios: {npmPackageName: 'temp-package'},
+ android: {npmPackageName: 'temp-package'},
+ },
+};
+
+describe('loadMetroConfig', () => {
+ test('loads an empty config', async () => {
+ const rootPath = createTempPackage({name: 'temp-app'});
+ createTempConfig(rootPath, {});
+
+ const loadedConfig = await loadMetroConfig({
+ root: rootPath,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(rootPath);
+ expect(loadedConfig.watchFolders).toEqual([rootPath]);
+ });
+
+ test('loads watch folders', async () => {
+ const rootPath = createTempPackage({
+ name: 'temp-app',
+ });
+ createTempConfig(rootPath, {
+ watchFolders: ['somewhere-else'],
+ });
+
+ const loadedConfig = await loadMetroConfig({
+ root: rootPath,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(rootPath);
+ expect(loadedConfig.watchFolders).toEqual([rootPath, 'somewhere-else']);
+ });
+
+ test('includes an npm workspace root if no watchFolders are defined', async () => {
+ const rootPath = createTempPackage({
+ name: 'temp-root',
+ workspaces: ['packages/temp-app'],
+ });
+ // Create a config inside a sub-package
+ const projectRoot = createTempPackage(
+ {
+ name: 'temp-app',
+ },
+ path.join(rootPath, 'packages', 'temp-app'),
+ );
+ createTempConfig(projectRoot, {});
+
+ const loadedConfig = await loadMetroConfig({
+ root: projectRoot,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(projectRoot);
+ expect(loadedConfig.watchFolders).toEqual([projectRoot, rootPath]);
+ });
+
+ test('does not resolve an npm workspace root if watchFolders are defined', async () => {
+ const rootPath = createTempPackage({
+ name: 'temp-root',
+ workspaces: ['packages/temp-app'],
+ });
+ // Create a config inside a sub-package
+ const projectRoot = createTempPackage(
+ {
+ name: 'temp-app',
+ },
+ path.join(rootPath, 'packages', 'temp-app'),
+ );
+ createTempConfig(projectRoot, {
+ watchFolders: [],
+ });
+
+ const loadedConfig = await loadMetroConfig({
+ root: projectRoot,
+ ...configLoadingContext,
+ });
+ expect(loadedConfig.projectRoot).toEqual(projectRoot);
+ expect(loadedConfig.watchFolders).toEqual([projectRoot]);
+ });
+});

packages/community-cli-plugin/src/utils/__tests__/temporary-package.js

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+export function createTempPackage(
+ packageJson: {...},
+ packagePath: string = fs.mkdtempSync(
+ path.join(os.tmpdir(), 'rn-metro-config-test-'),
+ ),
+): string {
+ fs.mkdirSync(packagePath, {recursive: true});
+ if (typeof packageJson === 'object') {
+ fs.writeFileSync(
+ path.join(packagePath, 'package.json'),
+ JSON.stringify(packageJson),
+ 'utf8',
+ );
+ }
+
+ // Wrapping path in realpath to resolve any symlinks introduced by mkdtemp
+ return fs.realpathSync(packagePath);
+}

packages/community-cli-plugin/src/utils/getWorkspaceRoot.js

@@ -0,0 +1,86 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ * @oncall react_native
+ */
+
+import {logger} from '@react-native-community/cli-tools';
+import fs from 'fs';
+import micromatch from 'micromatch';
+import path from 'path';
+import yaml from 'yaml';
+
+/**
+ * Get the workspace paths from the path of a potential workspace root.
+ *
+ * This supports:
+ * - [npm workspaces](https://docs.npmjs.com/cli/v10/using-npm/workspaces)
+ * - [yarn workspaces](https://yarnpkg.com/features/workspaces)
+ * - [pnpm workspaces](https://pnpm.io/workspaces)
+ */
+function getWorkspacePaths(packagePath: string): Array<string> {
+ try {
+ // Checking pnpm workspaces first
+ const pnpmWorkspacePath = path.resolve(packagePath, 'pnpm-workspace.yaml');
+ if (fs.existsSync(pnpmWorkspacePath)) {
+ const pnpmWorkspaceConfig = yaml.parse(
+ fs.readFileSync(pnpmWorkspacePath, 'utf8'),
+ );
+ if (
+ typeof pnpmWorkspaceConfig === 'object' &&
+ Array.isArray(pnpmWorkspaceConfig.packages)
+ ) {
+ return pnpmWorkspaceConfig.packages;
+ }
+ }
+ // Falling back to npm / yarn workspaces
+ const packageJsonPath = path.resolve(packagePath, 'package.json');
+ const {workspaces} = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+ if (Array.isArray(workspaces)) {
+ return workspaces;
+ } else if (
+ typeof workspaces === 'object' &&
+ Array.isArray(workspaces.packages)
+ ) {
+ // An alternative way for yarn to declare workspace packages
+ return workspaces.packages;
+ }
+ } catch (err) {
+ if (err.code !== 'ENOENT') {
+ logger.debug(`Failed getting workspace root from ${packagePath}: ${err}`);
+ }
+ }
+ return [];
+}
+
+/**
+ * Resolves the root of an npm or yarn workspace, by traversing the file tree
+ * upwards from a `candidatePath` in the search for
+ * - a directory with a package.json
+ * - which has a `workspaces` array of strings
+ * - which (possibly via a glob) includes the project root
+ */
+export function getWorkspaceRoot(
+ projectRoot: string,
+ candidatePath: string = projectRoot,
+): ?string {
+ const workspacePaths = getWorkspacePaths(candidatePath);
+ // If one of the workspaces match the project root, this is the workspace root
+ // Note: While npm workspaces doesn't currently support globs, yarn does, which is why we use micromatch
+ const relativePath = path.relative(candidatePath, projectRoot);
+ // Using this instead of `micromatch.isMatch` to enable excluding patterns
+ if (micromatch([relativePath], workspacePaths).length > 0) {
+ return candidatePath;
+ }
+ // Try one level up
+ const parentDir = path.dirname(candidatePath);
+ if (parentDir !== candidatePath) {
+ return getWorkspaceRoot(projectRoot, parentDir);
+ }
+ return null;
+}