[config] Create dynamic config "app.config.js"

packages/config/__mocks__/resolve-from.js

@@ -1,21 +1,21 @@
-module.exports = {
-  silent: (fromDirectory, request) => {
-    const fs = require('fs');
-    const path = require('path');
+module.exports = require(require.resolve('resolve-from'));
 
-    try {
-      fromDirectory = fs.realpathSync(fromDirectory);
-    } catch (error) {
-      if (error.code === 'ENOENT') {
-        fromDirectory = path.resolve(fromDirectory);
-      } else {
-        return;
-      }
-    }
+module.exports.silent = (fromDirectory, request) => {
+  const fs = require('fs');
+  const path = require('path');
 
-    const outputPath = path.join(fromDirectory, 'node_modules', request);
-    if (fs.existsSync(outputPath)) {
-      return outputPath;
+  try {
+    fromDirectory = fs.realpathSync(fromDirectory);
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      fromDirectory = path.resolve(fromDirectory);
+    } else {
+      return;
     }
-  },
+  }
+
+  const outputPath = path.join(fromDirectory, 'node_modules', request);
+  if (fs.existsSync(outputPath)) {
+    return outputPath;
+  }
 };

packages/config/package.json

@@ -45,7 +45,6 @@
   ],
   "dependencies": {
     "@expo/json-file": "^8.2.4",
-    "@types/invariant": "^2.2.30",
     "find-yarn-workspace-root": "^1.2.1",
     "fs-extra": "^7.0.1",
     "invariant": "^2.2.4",
@@ -54,6 +53,7 @@
   },
   "devDependencies": {
     "@expo/babel-preset-cli": "^0.2.4",
+    "@types/invariant": "^2.2.30",
     "memfs": "^2.15.5"
   },
   "publishConfig": {

packages/config/src/Config.ts

@@ -1,12 +1,118 @@
 import JsonFile, { JSONObject } from '@expo/json-file';
-import fs from 'fs-extra';
 import path from 'path';
 import slug from 'slugify';
 
-import { AppJSONConfig, ExpRc, ExpoConfig, PackageJSONConfig, ProjectConfig } from './Config.types';
+import {
+  AppJSONConfig,
+  ConfigContext,
+  ExpRc,
+  ExpoConfig,
+  PackageJSONConfig,
+  Platform,
+  ProjectConfig,
+} from './Config.types';
 import { ConfigError } from './Errors';
+import { findAndEvalConfig } from './getConfig';
+import { getRootPackageJsonPath, projectHasModule } from './Modules';
 import { getExpoSDKVersion } from './Project';
 
+/**
+ * Get all platforms that a project is currently capable of running.
+ *
+ * @param projectRoot
+ * @param exp
+ */
+function getSupportedPlatforms(
+  projectRoot: string,
+  exp: Pick<ExpoConfig, 'nodeModulesPath'>
+): Platform[] {
+  const platforms: Platform[] = [];
+  if (projectHasModule('react-native', projectRoot, exp)) {
+    platforms.push('ios', 'android');
+  }
+  if (projectHasModule('react-native-web', projectRoot, exp)) {
+    platforms.push('web');
+  }
+  return platforms;
+}
+
+type GetConfigOptions = {
+  mode: 'development' | 'production';
+  configPath?: string;
+  skipSDKVersionRequirement?: boolean;
+};
+
+function getConfigContext(
+  projectRoot: string,
+  options: GetConfigOptions
+): { context: ConfigContext; pkg: JSONObject } {
+  // TODO(Bacon): This doesn't support changing the location of the package.json
+  const packageJsonPath = getRootPackageJsonPath(projectRoot, {});
+  const pkg = JsonFile.read(packageJsonPath);
+
+  const configPath = options.configPath || customConfigPaths[projectRoot];
+
+  // If the app.json exists, we'll read it and pass it to the app.config.js for further modification
+  const { configPath: appJsonConfigPath } = findConfigFile(projectRoot);
+  let rawConfig: JSONObject = {};
+  try {
+    rawConfig = JsonFile.read(appJsonConfigPath, { json5: true });
+  } catch (_) {}
+
+  const { exp: configFromPkg } = ensureConfigHasDefaultValues(projectRoot, rawConfig, pkg, true);
+
+  return {
+    pkg,
+    context: {
+      mode: options.mode,
+      projectRoot,
+      configPath,
+      config: configFromPkg,
+    },
+  };
+}
+
+/**
+ * Evaluate the config for an Expo project.
+ * If a function is exported from the `app.config.js` then a partial config will be passed as an argument.
+ * The partial config is composed from any existing app.json, and certain fields from the `package.json` like name and description.
+ *
+ * You should use the supplied `mode` option in an `app.config.js` instead of `process.env.NODE_ENV`
+ *
+ * **Example**
+ * ```js
+ * module.exports = function({ config, mode }) {
+ *   // mutate the config before returning it.
+ *   config.slug = 'new slug'
+ *   return config;
+ * }
+ *
+ * **Supports**
+ * - `app.config.js`
+ * - `app.config.json`
+ * - `app.json`
+ *
+ * @param projectRoot the root folder containing all of your application code
+ * @param options enforce criteria for a project config
+ */
+export function getConfig(projectRoot: string, options: GetConfigOptions): ProjectConfig {
+  if (!['development', 'production'].includes(options.mode)) {
+    throw new ConfigError(
+      `Invalid mode "${options.mode}" was used to evaluate the project config.`,
+      'INVALID_MODE'
+    );
+  }
+
+  const { context, pkg } = getConfigContext(projectRoot, options);
+
+  const config = findAndEvalConfig(context) ?? context.config;
+
+  return {
+    ...ensureConfigHasDefaultValues(projectRoot, config, pkg, options.skipSDKVersionRequirement),
+    rootConfig: config as AppJSONConfig,
+  };
+}
+
 export function readConfigJson(
   projectRoot: string,
   skipValidation: boolean = false,
@@ -115,25 +221,11 @@ function parseAndValidateRootConfig(
   };
 }
 
-function getRootPackageJsonPath(projectRoot: string, exp: ExpoConfig): string {
-  const packageJsonPath =
-    'nodeModulesPath' in exp && typeof exp.nodeModulesPath === 'string'
-      ? path.join(path.resolve(projectRoot, exp.nodeModulesPath), 'package.json')
-      : path.join(projectRoot, 'package.json');
-  if (!fs.existsSync(packageJsonPath)) {
-    throw new ConfigError(
-      `The expected package.json path: ${packageJsonPath} does not exist`,
-      'MODULE_NOT_FOUND'
-    );
-  }
-  return packageJsonPath;
-}
-
 function ensureConfigHasDefaultValues(
   projectRoot: string,
   exp: ExpoConfig,
   pkg: JSONObject,
-  skipNativeValidation: boolean = false
+  skipSDKVersionRequirement: boolean = false
 ): { exp: ExpoConfig; pkg: PackageJSONConfig } {
   if (!exp) exp = {};
 
@@ -160,11 +252,11 @@ function ensureConfigHasDefaultValues(
   try {
     exp.sdkVersion = getExpoSDKVersion(projectRoot, exp);
   } catch (error) {
-    if (!skipNativeValidation) throw error;
+    if (!skipSDKVersionRequirement) throw error;
   }
 
   if (!exp.platforms) {
-    exp.platforms = ['android', 'ios'];
+    exp.platforms = getSupportedPlatforms(projectRoot, exp);
   }
 
   return { exp, pkg };

packages/config/src/Config.types.ts

@@ -915,4 +915,17 @@ export type ExpoConfig = {
 };
 export type ExpRc = { [key: string]: any };
 export type Platform = 'android' | 'ios' | 'web';
-export type ConfigErrorCode = 'NO_APP_JSON' | 'NOT_OBJECT' | 'NO_EXPO' | 'MODULE_NOT_FOUND';
+export type ConfigErrorCode =
+  | 'NO_APP_JSON'
+  | 'NOT_OBJECT'
+  | 'NO_EXPO'
+  | 'MODULE_NOT_FOUND'
+  | 'INVALID_MODE'
+  | 'INVALID_CONFIG';
+
+export type ConfigContext = {
+  projectRoot: string;
+  configPath?: string;
+  config: Partial<ExpoConfig>;
+  mode: 'development' | 'production';
+};

packages/config/src/Modules.ts

@@ -1,6 +1,8 @@
 import resolveFrom from 'resolve-from';
 import { stat, statSync } from 'fs-extra';
+import { join, resolve } from 'path';
 import { ExpoConfig } from './Config.types';
+import { ConfigError } from './Errors';
 
 export function resolveModule(
   request: string,
@@ -47,3 +49,20 @@ export function fileExists(file: string): boolean {
     return false;
   }
 }
+
+export function getRootPackageJsonPath(
+  projectRoot: string,
+  exp: Pick<ExpoConfig, 'nodeModulesPath'>
+): string {
+  const packageJsonPath =
+    'nodeModulesPath' in exp && typeof exp.nodeModulesPath === 'string'
+      ? join(resolve(projectRoot, exp.nodeModulesPath), 'package.json')
+      : join(projectRoot, 'package.json');
+  if (!fileExists(packageJsonPath)) {
+    throw new ConfigError(
+      `The expected package.json path: ${packageJsonPath} does not exist`,
+      'MODULE_NOT_FOUND'
+    );
+  }
+  return packageJsonPath;
+}

packages/config/src/Project.ts

@@ -16,7 +16,10 @@ export function isUsingYarn(projectRoot: string): boolean {
   }
 }
 
-export function getExpoSDKVersion(projectRoot: string, exp: ExpoConfig): string {
+export function getExpoSDKVersion(
+  projectRoot: string,
+  exp: Pick<ExpoConfig, 'sdkVersion' | 'nodeModulesPath'>
+): string {
   if (exp && exp.sdkVersion) {
     return exp.sdkVersion;
   }

packages/config/src/__tests__/Config-test.js

@@ -1,67 +1,10 @@
 import { vol } from 'memfs';
 
-import { readConfigJson } from '../Config';
-import { getWebOutputPath } from '../Web';
+import { getConfig, readConfigJson } from '../Config';
 
 jest.mock('fs');
 jest.mock('resolve-from');
 
-describe('getWebOutputPath', () => {
-  beforeAll(() => {
-    const packageJson = JSON.stringify(
-      {
-        name: 'testing123',
-        version: '0.1.0',
-        main: 'index.js',
-      },
-      null,
-      2
-    );
-
-    const appJson = {
-      name: 'testing 123',
-      version: '0.1.0',
-      slug: 'testing-123',
-      sdkVersion: '100.0.0',
-    };
-
-    vol.fromJSON({
-      '/standard/package.json': JSON.stringify(packageJson),
-      '/standard/app.json': JSON.stringify({ expo: appJson }),
-      '/custom/package.json': JSON.stringify(packageJson),
-      '/custom/app.json': JSON.stringify({
-        expo: { ...appJson, web: { build: { output: 'defined-in-config' } } },
-      }),
-    });
-  });
-  afterAll(() => vol.reset());
-
-  it('uses the default output build path for web', () => {
-    const { exp } = readConfigJson('/standard');
-    const outputPath = getWebOutputPath(exp);
-    expect(outputPath).toBe('web-build');
-  });
-
-  it('uses a custom output build path from the config', () => {
-    const { exp } = readConfigJson('/custom');
-    const outputPath = getWebOutputPath(exp);
-    expect(outputPath).toBe('defined-in-config');
-  });
-
-  beforeEach(() => {
-    delete process.env.WEBPACK_BUILD_OUTPUT_PATH;
-  });
-  it('uses an env variable for the web build path', () => {
-    process.env.WEBPACK_BUILD_OUTPUT_PATH = 'custom-env-path';
-
-    for (const project of ['/custom', '/standard']) {
-      const { exp } = readConfigJson(project);
-      const outputPath = getWebOutputPath(exp);
-      expect(outputPath).toBe('custom-env-path');
-    }
-  });
-});
-
 describe('readConfigJson', () => {
   describe('sdkVersion', () => {
     beforeAll(() => {
@@ -155,12 +98,20 @@ describe('readConfigJson', () => {
 
     it(`will throw if the app.json is missing`, () => {
       expect(() => readConfigJson('/no-config')).toThrow(/does not contain a valid app\.json/);
+      // No config is required for new method
+      expect(() => getConfig('/no-config', { mode: 'development' })).not.toThrow();
     });
 
     it(`will throw if the expo package is missing`, () => {
       expect(() => readConfigJson('/no-package', true)).toThrow(
         /Cannot determine which native SDK version your project uses/
       );
+      expect(() =>
+        getConfig('/no-package', { mode: 'development', skipSDKVersionRequirement: false })
+      ).toThrow(/Cannot determine which native SDK version your project uses/);
+    });
+    it(`will throw if an invalid mode is used to get the config`, () => {
+      expect(() => getConfig('/no-config', { mode: 'invalid' })).toThrow(/Invalid mode/);
     });
   });
 });