@react-native-community/cli-config 7.0.1

package/src/__tests__/index-test.ts

@@ -0,0 +1,350 @@
+import path from 'path';
+import slash from 'slash';
+import loadConfig from '..';
+import {cleanup, writeFiles, getTempDirectory} from '../../../../jest/helpers';
+
+let DIR = getTempDirectory('config_test');
+
+jest.dontMock('@react-native-community/cli-tools');
+
+const spy = jest.spyOn(global.console, 'warn').mockImplementation(jest.fn());
+
+const iosPath = slash(
+  require.resolve('@react-native-community/cli-platform-ios'),
+);
+const androidPath = slash(
+  require.resolve('@react-native-community/cli-platform-android'),
+);
+
+const REACT_NATIVE_MOCK = {
+  'node_modules/react-native/package.json': '{}',
+  'node_modules/react-native/react-native.config.js': `
+    const ios = require("${iosPath}");
+    const android = require("${androidPath}");
+    module.exports = {
+      platforms: {
+        ios: {
+          linkConfig: ios.linkConfig,
+          projectConfig: ios.projectConfig,
+          dependencyConfig: ios.dependencyConfig,
+        },
+        android: {
+          linkConfig: android.linkConfig,
+          projectConfig: android.projectConfig,
+          dependencyConfig: android.dependencyConfig,
+        },
+      },
+    };
+  `,
+};
+
+// Removes string from all key/values within an object
+const removeString = (config, str) =>
+  JSON.parse(
+    JSON.stringify(config, (_key, value) =>
+      // In certain cases, `str` (which is a temporary location) will be `/tmp`
+      // which is a symlink to `/private/tmp` on OS X. In this case, tests will fail.
+      // Following RegExp makes sure we strip the entire path.
+      typeof value === 'string'
+        ? slash(value.replace(new RegExp(`(.*)${str}`), '<<REPLACED>>'))
+        : value,
+    ),
+  );
+
+beforeEach(async () => {
+  await cleanup(DIR);
+  jest.resetModules();
+  jest.clearAllMocks();
+});
+
+afterEach(async () => await cleanup(DIR));
+
+test('should have a valid structure by default', () => {
+  DIR = getTempDirectory('config_test_structure');
+  writeFiles(DIR, {
+    'react-native.config.js': `module.exports = {
+      reactNativePath: "."
+    }`,
+  });
+  const config = loadConfig(DIR);
+  expect(removeString(config, DIR)).toMatchSnapshot();
+});
+
+test('should return dependencies from package.json', () => {
+  DIR = getTempDirectory('config_test_deps');
+  writeFiles(DIR, {
+    ...REACT_NATIVE_MOCK,
+    'node_modules/react-native-test/package.json': '{}',
+    'node_modules/react-native-test/ios/HelloWorld.xcodeproj/project.pbxproj':
+      '',
+    'package.json': `{
+      "dependencies": {
+        "react-native": "0.0.1",
+        "react-native-test": "0.0.1"
+      }
+    }`,
+  });
+  const {dependencies} = loadConfig(DIR);
+  expect(removeString(dependencies, DIR)).toMatchSnapshot();
+});
+
+test('should read a config of a dependency and use it to load other settings', () => {
+  DIR = getTempDirectory('config_test_settings');
+  writeFiles(DIR, {
+    ...REACT_NATIVE_MOCK,
+    'node_modules/react-native-test/package.json': '{}',
+    'node_modules/react-native-test/ReactNativeTest.podspec': '',
+    'node_modules/react-native-test/react-native.config.js': `module.exports = {
+      dependency: {
+        platforms: {
+          ios: {
+            project: "./customLocation/customProject.xcodeproj"
+          }
+        }
+      }
+    }`,
+    'package.json': `{
+      "dependencies": {
+        "react-native": "0.0.1",
+        "react-native-test": "0.0.1"
+      }
+    }`,
+  });
+  const {dependencies} = loadConfig(DIR);
+  expect(
+    removeString(dependencies['react-native-test'], DIR),
+  ).toMatchSnapshot();
+});
+
+test('should merge project configuration with default values', () => {
+  DIR = getTempDirectory('config_test_merge');
+  writeFiles(DIR, {
+    ...REACT_NATIVE_MOCK,
+    'node_modules/react-native-test/package.json': '{}',
+    'node_modules/react-native-test/react-native.config.js': `module.exports = {
+      dependency: {
+        assets: ["foo", "baz"]
+      }
+    }`,
+    'node_modules/react-native-test/ios/HelloWorld.xcodeproj/project.pbxproj':
+      '',
+    'package.json': `{
+      "dependencies": {
+        "react-native": "0.0.1",
+        "react-native-test": "0.0.1"
+      }
+    }`,
+    'react-native.config.js': `module.exports = {
+      reactNativePath: ".",
+      dependencies: {
+        "react-native-test": {
+          platforms: {
+            ios: {
+              sourceDir: "./abc"
+            }
+          },
+          assets: ["foo"]
+        }
+      }
+    }`,
+  });
+  const {dependencies} = loadConfig(DIR);
+  expect(removeString(dependencies['react-native-test'], DIR)).toMatchSnapshot(
+    'snapshoting `react-native-test` config',
+  );
+});
+
+test('should load commands from "react-native-foo" and "react-native-bar" packages', () => {
+  DIR = getTempDirectory('config_test_packages');
+  writeFiles(DIR, {
+    'node_modules/react-native-foo/package.json': '{}',
+    'node_modules/react-native-foo/react-native.config.js': `module.exports = {
+      commands: [
+        {
+          name: 'foo-command',
+          func: () => console.log('foo')
+        }
+      ]
+    }`,
+    'node_modules/react-native-bar/package.json': '{}',
+    'node_modules/react-native-bar/react-native.config.js': `module.exports = {
+      commands: [
+        {
+          name: 'bar-command',
+          func: () => console.log('bar')
+        }
+      ]
+    }`,
+    'package.json': `{
+      "dependencies": {
+        "react-native-foo": "0.0.1",
+        "react-native-bar": "0.0.1"
+      }
+    }`,
+  });
+  const {commands} = loadConfig(DIR);
+  expect(commands).toMatchSnapshot();
+});
+
+test('should skip packages that have invalid configuration', () => {
+  process.env.FORCE_COLOR = '0'; // To disable chalk
+  DIR = getTempDirectory('config_test_skip');
+  writeFiles(DIR, {
+    'node_modules/react-native/package.json': '{}',
+    'node_modules/react-native/react-native.config.js': `module.exports = {
+      dependency: {
+        invalidProperty: 5
+      }
+    }`,
+    'package.json': `{
+      "dependencies": {
+        "react-native": "0.0.1"
+      }
+    }`,
+  });
+  const {dependencies} = loadConfig(DIR);
+  expect(dependencies).toMatchSnapshot('dependencies config');
+  expect(spy.mock.calls[0][0]).toMatchSnapshot('logged warning');
+});
+
+test('does not use restricted "react-native" key to resolve config from package.json', () => {
+  DIR = getTempDirectory('config_test_restricted');
+  writeFiles(DIR, {
+    'node_modules/react-native-netinfo/package.json': `{
+      "react-native": "src/index.js"
+    }`,
+    'package.json': `{
+      "dependencies": {
+        "react-native-netinfo": "0.0.1"
+      }
+    }`,
+  });
+  const {dependencies} = loadConfig(DIR);
+  expect(dependencies).toHaveProperty('react-native-netinfo');
+  expect(spy).not.toHaveBeenCalled();
+});
+
+test('supports dependencies from user configuration with custom root and properties', () => {
+  DIR = getTempDirectory('config_test_custom_root');
+  const escapePathSeparator = (value: string) =>
+    path.sep === '\\' ? value.replace(/(\/|\\)/g, '\\\\') : value;
+
+  writeFiles(DIR, {
+    ...REACT_NATIVE_MOCK,
+    'native-libs/local-lib/ios/LocalRNLibrary.xcodeproj/project.pbxproj': '',
+    'react-native.config.js': `
+const path = require('path');
+const root = path.resolve('${escapePathSeparator(
+      DIR,
+    )}', 'native-libs', 'local-lib');
+
+module.exports = {
+  dependencies: {
+    'local-lib': {
+      root,
+      platforms: {
+        ios: {
+          podspecPath: "custom-path"
+        }
+      }
+    },
+  }
+}`,
+    'package.json': `{
+      "dependencies": {
+        "react-native": "0.0.1"
+      }
+    }`,
+  });
+
+  const {dependencies} = loadConfig(DIR);
+  expect(removeString(dependencies['local-lib'], DIR)).toMatchInlineSnapshot(`
+    Object {
+      "assets": Array [],
+      "hooks": Object {},
+      "name": "local-lib",
+      "params": Array [],
+      "platforms": Object {
+        "android": null,
+        "ios": Object {
+          "configurations": Array [],
+          "folder": "<<REPLACED>>/native-libs/local-lib",
+          "libraryFolder": "Libraries",
+          "pbxprojPath": "<<REPLACED>>/native-libs/local-lib/ios/LocalRNLibrary.xcodeproj/project.pbxproj",
+          "plist": Array [],
+          "podfile": null,
+          "podspecPath": "custom-path",
+          "projectName": "LocalRNLibrary.xcodeproj",
+          "projectPath": "<<REPLACED>>/native-libs/local-lib/ios/LocalRNLibrary.xcodeproj",
+          "scriptPhases": Array [],
+          "sharedLibraries": Array [],
+          "sourceDir": "<<REPLACED>>/native-libs/local-lib/ios",
+        },
+      },
+      "root": "<<REPLACED>>/native-libs/local-lib",
+    }
+  `);
+});
+
+test('should apply build types from dependency config', () => {
+  DIR = getTempDirectory('config_test_apply_dependency_config');
+  writeFiles(DIR, {
+    ...REACT_NATIVE_MOCK,
+    'node_modules/react-native-test/package.json': '{}',
+    'node_modules/react-native-test/ios/HelloWorld.xcodeproj/project.pbxproj':
+      '',
+    'node_modules/react-native-test/react-native.config.js': `module.exports = {
+      dependency: {
+        platforms: {
+          ios: {
+            configurations: ["debug"]
+          }
+        }
+      }
+    }`,
+    'package.json': `{
+      "dependencies": {
+        "react-native": "0.0.1",
+        "react-native-test": "0.0.1"
+      }
+    }`,
+  });
+  const {dependencies} = loadConfig(DIR);
+  expect(
+    removeString(dependencies['react-native-test'], DIR),
+  ).toMatchSnapshot();
+});
+
+test('supports dependencies from user configuration with custom build type', () => {
+  DIR = getTempDirectory('config_test_apply_custom_build_config');
+  writeFiles(DIR, {
+    ...REACT_NATIVE_MOCK,
+    'react-native.config.js': `module.exports = {
+  dependencies: {
+    'react-native-test': {
+      platforms: {
+        ios: {
+          configurations: ["custom_build_type"]
+        }
+      }
+    },
+  }
+}`,
+    'node_modules/react-native-test/package.json': '{}',
+    'node_modules/react-native-test/ios/HelloWorld.xcodeproj/project.pbxproj':
+      '',
+    'node_modules/react-native-test/react-native.config.js':
+      'module.exports = {}',
+    'package.json': `{
+      "dependencies": {
+        "react-native": "0.0.1",
+        "react-native-test": "0.0.1"
+      }
+    }`,
+  });
+
+  const {dependencies} = loadConfig(DIR);
+  expect(
+    removeString(dependencies['react-native-test'], DIR),
+  ).toMatchSnapshot();
+});

package/src/assign.ts

@@ -0,0 +1,27 @@
+/**
+ * Source: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
+ *
+ * Similar to Object.assign(), but it doesn't execute getters. This allows us to have
+ * lazy properties on an object and still be able to merge them together
+ *
+ */
+export default function assign(target: Object, ...sources: Object[]) {
+  sources.forEach((source) => {
+    let descriptors = Object.keys(source).reduce((acc, key) => {
+      const propertyDescriptor = Object.getOwnPropertyDescriptor(source, key);
+      if (propertyDescriptor !== undefined) {
+        acc[key] = propertyDescriptor;
+      }
+      return acc;
+    }, {} as PropertyDescriptorMap);
+    // by default, Object.assign copies enumerable Symbols too
+    Object.getOwnPropertySymbols(source).forEach((sym) => {
+      let descriptor = Object.getOwnPropertyDescriptor(source, sym);
+      if (descriptor && descriptor.enumerable) {
+        descriptors[sym.toString()] = descriptor;
+      }
+    });
+    Object.defineProperties(target, descriptors);
+  });
+  return target;
+}

package/src/commands/config.ts

@@ -0,0 +1,30 @@
+import {Config, Dependency} from '@react-native-community/cli-types';
+
+function isValidRNDependency(config: Dependency) {
+  return (
+    Object.keys(config.platforms).filter((key) =>
+      Boolean(config.platforms[key]),
+    ).length !== 0 ||
+    (config.hooks && Object.keys(config.hooks).length !== 0) ||
+    (config.assets && config.assets.length !== 0) ||
+    (config.params && config.params.length !== 0)
+  );
+}
+
+function filterConfig(config: Config) {
+  const filtered = {...config};
+  Object.keys(filtered.dependencies).forEach((item) => {
+    if (!isValidRNDependency(filtered.dependencies[item])) {
+      delete filtered.dependencies[item];
+    }
+  });
+  return filtered;
+}
+
+export default {
+  name: 'config',
+  description: 'Print CLI configuration',
+  func: async (_argv: string[], ctx: Config) => {
+    console.log(JSON.stringify(filterConfig(ctx), null, 2));
+  },
+};

package/src/errors.ts

@@ -0,0 +1,31 @@
+import {CLIError} from '@react-native-community/cli-tools';
+import {ValidationError} from 'joi';
+
+export class JoiError extends CLIError {
+  constructor(joiError: ValidationError) {
+    const message = joiError.details
+      .map((error) => {
+        const name = error.path.join('.');
+        switch (error.type) {
+          case 'object.allowUnknown': {
+            const value = JSON.stringify(error.context && error.context.value);
+            return `
+              Unknown option ${name} with value "${value}" was found.
+              This is either a typing error or a user mistake. Fixing it will remove this message.
+            `;
+          }
+          default:
+            return error.message;
+        }
+      })
+      .join()
+      .trim();
+
+    super(message);
+    this.name = 'Config Validation Error';
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, JoiError);
+    }
+  }
+}

package/src/findAssets.ts

@@ -0,0 +1,28 @@
+import glob from 'glob';
+import path from 'path';
+
+const findAssetsInFolder = (folder: string): string[] => {
+  const assets = glob.sync(path.join(folder, '**'), {nodir: true});
+  if (process.platform === 'win32') {
+    return assets.map((asset) => asset.split('/').join('\\'));
+  }
+  return assets;
+};
+
+/**
+ * Given an array of assets folders, e.g. ['Fonts', 'Images'],
+ * it globs in them to find all files that can be copied.
+ *
+ * It returns an array of absolute paths to files found.
+ */
+export default function findAssets(
+  folder: string,
+  assets: Array<string>,
+): Array<string> {
+  return (assets || [])
+    .map((asset) => path.join(folder, asset))
+    .reduce(
+      (acc, assetPath) => acc.concat(findAssetsInFolder(assetPath)),
+      [] as string[],
+    );
+}

package/src/findDependencies.ts

@@ -0,0 +1,24 @@
+import path from 'path';
+import fs from 'fs';
+
+/**
+ * Returns an array of dependencies from project's package.json
+ */
+export default function findDependencies(root: string): Array<string> {
+  let pjson;
+
+  try {
+    pjson = JSON.parse(
+      fs.readFileSync(path.join(root, 'package.json'), 'UTF-8'),
+    );
+  } catch (e) {
+    return [];
+  }
+
+  const deps = [
+    ...Object.keys(pjson.dependencies || {}),
+    ...Object.keys(pjson.devDependencies || {}),
+  ];
+
+  return deps;
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+import config from './commands/config';
+
+export {default} from './loadConfig';
+
+export const commands = [config];

package/src/loadConfig.ts

@@ -0,0 +1,157 @@
+import path from 'path';
+import chalk from 'chalk';
+import {
+  UserDependencyConfig,
+  ProjectConfig,
+  Dependency,
+  UserConfig,
+  Config,
+} from '@react-native-community/cli-types';
+import {
+  logger,
+  inlineString,
+  findProjectRoot,
+  resolveNodeModuleDir,
+} from '@react-native-community/cli-tools';
+import findDependencies from './findDependencies';
+import resolveReactNativePath from './resolveReactNativePath';
+import findAssets from './findAssets';
+import {
+  readConfigFromDisk,
+  readDependencyConfigFromDisk,
+} from './readConfigFromDisk';
+import assign from './assign';
+import merge from './merge';
+
+function getDependencyConfig(
+  root: string,
+  dependencyName: string,
+  finalConfig: Config,
+  config: UserDependencyConfig,
+  userConfig: UserConfig,
+  isPlatform: boolean,
+): Dependency {
+  return merge(
+    {
+      root,
+      name: dependencyName,
+      platforms: Object.keys(finalConfig.platforms).reduce(
+        (dependency, platform) => {
+          const platformConfig = finalConfig.platforms[platform];
+          dependency[platform] =
+            // Linking platforms is not supported
+            isPlatform || !platformConfig
+              ? null
+              : platformConfig.dependencyConfig(
+                  root,
+                  config.dependency.platforms[platform],
+                );
+          return dependency;
+        },
+        {} as Config['platforms'],
+      ),
+      assets: findAssets(root, config.dependency.assets),
+      hooks: config.dependency.hooks,
+      params: config.dependency.params,
+    },
+    userConfig.dependencies[dependencyName] || {},
+  ) as Dependency;
+}
+
+/**
+ * Loads CLI configuration
+ */
+function loadConfig(projectRoot: string = findProjectRoot()): Config {
+  let lazyProject: ProjectConfig;
+  const userConfig = readConfigFromDisk(projectRoot);
+
+  const initialConfig: Config = {
+    root: projectRoot,
+    get reactNativePath() {
+      return userConfig.reactNativePath
+        ? path.resolve(projectRoot, userConfig.reactNativePath)
+        : resolveReactNativePath(projectRoot);
+    },
+    dependencies: userConfig.dependencies,
+    commands: userConfig.commands,
+    get assets() {
+      return findAssets(projectRoot, userConfig.assets);
+    },
+    healthChecks: [],
+    platforms: userConfig.platforms,
+    get project() {
+      if (lazyProject) {
+        return lazyProject;
+      }
+
+      lazyProject = {};
+      for (const platform in finalConfig.platforms) {
+        const platformConfig = finalConfig.platforms[platform];
+        if (platformConfig) {
+          lazyProject[platform] = platformConfig.projectConfig(
+            projectRoot,
+            userConfig.project[platform] || {},
+          );
+        }
+      }
+
+      return lazyProject;
+    },
+  };
+
+  const finalConfig = Array.from(
+    new Set([
+      ...Object.keys(userConfig.dependencies),
+      ...findDependencies(projectRoot),
+    ]),
+  ).reduce((acc: Config, dependencyName) => {
+    const localDependencyRoot =
+      userConfig.dependencies[dependencyName] &&
+      userConfig.dependencies[dependencyName].root;
+    let root: string;
+    let config: UserDependencyConfig;
+    try {
+      root =
+        localDependencyRoot ||
+        resolveNodeModuleDir(projectRoot, dependencyName);
+      config = readDependencyConfigFromDisk(root);
+    } catch (error) {
+      logger.warn(
+        inlineString(`
+          Package ${chalk.bold(
+            dependencyName,
+          )} has been ignored because it contains invalid configuration.
+
+          Reason: ${chalk.dim(error.message)}`),
+      );
+      return acc;
+    }
+
+    const isPlatform = Object.keys(config.platforms).length > 0;
+
+    return assign({}, acc, {
+      dependencies: assign({}, acc.dependencies, {
+        get [dependencyName](): Dependency {
+          return getDependencyConfig(
+            root,
+            dependencyName,
+            finalConfig,
+            config,
+            userConfig,
+            isPlatform,
+          );
+        },
+      }),
+      commands: [...acc.commands, ...config.commands],
+      platforms: {
+        ...acc.platforms,
+        ...config.platforms,
+      },
+      healthChecks: [...acc.healthChecks, ...config.healthChecks],
+    }) as Config;
+  }, initialConfig);
+
+  return finalConfig;
+}
+
+export default loadConfig;

package/src/merge.ts

@@ -0,0 +1,12 @@
+import deepmerge from 'deepmerge';
+
+/**
+ * `deepmerge` concatenates arrays by default instead of overwriting them.
+ * We define custom merging function for arrays to change that behaviour
+ */
+export default function merge<X, Y>(x: X, y: Y) {
+  return deepmerge(x, y, {
+    arrayMerge: (_destinationArray: any[], sourceArray: any[]): any[] =>
+      sourceArray,
+  });
+}