@expo/fingerprint 0.1.0 → 0.3.0

package/src/hash/__tests__/Hash-test.ts

@@ -4,7 +4,7 @@ import pLimit from 'p-limit';
 import path from 'path';
 
 import { HashSource } from '../../Fingerprint.types';
-import { normalizeOptions } from '../../Options';
+import { normalizeOptionsAsync } from '../../Options';
 import {
   createContentsHashResultsAsync,
   createDirHashResultsAsync,
@@ -23,18 +23,21 @@ describe(createFingerprintFromSourcesAsync, () => {
   });
 
   it('snapshot', async () => {
+    const filePath = 'assets/icon.png';
     vol.mkdirSync('/app');
-    vol.writeFileSync(path.join('/app', 'app.json'), '{}');
+    vol.mkdirSync('/app/assets');
+    vol.writeFileSync(path.join('/app', filePath), '{}');
 
     const sources: HashSource[] = [
       { type: 'contents', id: 'foo', contents: 'HelloWorld', reasons: ['foo'] },
-      { type: 'file', filePath: 'app.json', reasons: ['expoConfig'] },
+      { type: 'file', filePath, reasons: ['icon'] },
     ];
 
-    expect(await createFingerprintFromSourcesAsync(sources, '/app', normalizeOptions()))
-      .toMatchInlineSnapshot(`
+    expect(
+      await createFingerprintFromSourcesAsync(sources, '/app', await normalizeOptionsAsync('/app'))
+    ).toMatchInlineSnapshot(`
       {
-        "hash": "ec7d81780f735d5e289b27cdcc04a6c99d2621dc",
+        "hash": "ca7d58cd60289daa5cddcf99fcaa1d339bfc2c1a",
         "sources": [
           {
             "contents": "HelloWorld",
@@ -46,10 +49,10 @@ describe(createFingerprintFromSourcesAsync, () => {
             "type": "contents",
           },
           {
-            "filePath": "app.json",
+            "filePath": "assets/icon.png",
             "hash": "bf21a9e8fbc5a3846fb05b4fa0859e0917b2202f",
             "reasons": [
-              "expoConfig",
+              "icon",
             ],
             "type": "file",
           },
@@ -72,7 +75,12 @@ describe(createFingerprintSourceAsync, () => {
       hash: 'db8ac1c259eb89d4a131b253bacfca5f319d54f2',
     };
     expect(
-      await createFingerprintSourceAsync(source, pLimit(1), '/app', normalizeOptions())
+      await createFingerprintSourceAsync(
+        source,
+        pLimit(1),
+        '/app',
+        await normalizeOptionsAsync('/app')
+      )
     ).toEqual(expectedResult);
   });
 });
@@ -81,7 +89,7 @@ describe(createContentsHashResultsAsync, () => {
   it('should return {id, hex} result', async () => {
     const id = 'foo';
     const contents = '{}';
-    const options = normalizeOptions();
+    const options = await normalizeOptionsAsync('/app');
     const result = await createContentsHashResultsAsync(
       {
         type: 'contents',
@@ -104,18 +112,32 @@ describe(createFileHashResultsAsync, () => {
   });
 
   it('should return {id, hex} result', async () => {
-    const filePath = 'app.json';
+    const filePath = 'assets/icon.png';
     const contents = '{}';
     const limiter = pLimit(1);
-    const options = normalizeOptions();
+    const options = await normalizeOptionsAsync('/app');
     vol.mkdirSync('/app');
+    vol.mkdirSync('/app/assets');
     vol.writeFileSync(path.join('/app', filePath), contents);
 
     const result = await createFileHashResultsAsync(filePath, limiter, '/app', options);
 
     const expectHex = createHash(options.hashAlgorithm).update(contents).digest('hex');
-    expect(result.id).toEqual(filePath);
-    expect(result.hex).toEqual(expectHex);
+    expect(result?.id).toEqual(filePath);
+    expect(result?.hex).toEqual(expectHex);
+  });
+
+  it('should ignore file if it is in options.ignorePaths', async () => {
+    const filePath = 'app.json';
+    const contents = '{}';
+    const limiter = pLimit(1);
+    const options = await normalizeOptionsAsync('/app');
+    options.ignorePaths = ['*.json'];
+    vol.mkdirSync('/app');
+    vol.writeFileSync(path.join('/app', filePath), contents);
+
+    const result = await createFileHashResultsAsync(filePath, limiter, '/app', options);
+    expect(result).toBe(null);
   });
 });
 
@@ -126,7 +148,7 @@ describe(createDirHashResultsAsync, () => {
 
   it('should return {id, hex} result', async () => {
     const limiter = pLimit(3);
-    const options = normalizeOptions();
+    const options = await normalizeOptionsAsync('/app');
     const volJSON = {
       '/app/ios/Podfile': '...',
       '/app/eas.json': '{}',
@@ -140,9 +162,33 @@ describe(createDirHashResultsAsync, () => {
     expect(result?.hex).not.toBe('');
   });
 
+  it('should ignore dir if it is in options.ignorePaths', async () => {
+    const limiter = pLimit(3);
+    const options = await normalizeOptionsAsync('/app');
+    options.ignorePaths = ['ios/**/*', 'android/**/*'];
+    const volJSON = {
+      '/app/ios/Podfile': '...',
+      '/app/eas.json': '{}',
+      '/app/app.json': '{}',
+      '/app/android/build.gradle': '...',
+    };
+    vol.fromJSON(volJSON);
+
+    const fingerprint1 = await createDirHashResultsAsync('.', limiter, '/app', options);
+
+    vol.reset();
+    const volJSONIgnoreNativeProjects = {
+      '/app/eas.json': '{}',
+      '/app/app.json': '{}',
+    };
+    vol.fromJSON(volJSONIgnoreNativeProjects);
+    const fingerprint2 = await createDirHashResultsAsync('.', limiter, '/app', options);
+    expect(fingerprint1).toEqual(fingerprint2);
+  });
+
   it('should return stable result from sorted files', async () => {
     const limiter = pLimit(3);
-    const options = normalizeOptions();
+    const options = await normalizeOptionsAsync('/app');
     const volJSON = {
       '/app/ios/Podfile': '...',
       '/app/eas.json': '{}',

package/src/sourcer/Expo.ts

@@ -1,12 +1,13 @@
 import spawnAsync from '@expo/spawn-async';
-import assert from 'assert';
 import chalk from 'chalk';
 import type { ExpoConfig, ProjectConfig } from 'expo/config';
-import findUp from 'find-up';
+import fs from 'fs/promises';
+import os from 'os';
 import path from 'path';
 import resolveFrom from 'resolve-from';
 
-import { getFileBasedHashSourceAsync } from './Utils';
+import { getExpoConfigLoaderPath } from './ExpoConfigLoader';
+import { getFileBasedHashSourceAsync, stringifyJsonSorted } from './Utils';
 import type { HashSource, NormalizedOptions } from '../Fingerprint.types';
 
 const debug = require('debug')('expo:fingerprint:sourcer:Expo');
@@ -15,32 +16,36 @@ export async function getExpoConfigSourcesAsync(
   projectRoot: string,
   options: NormalizedOptions
 ): Promise<HashSource[]> {
+  if (!resolveFrom.silent(path.resolve(projectRoot), 'expo/config')) {
+    return [];
+  }
+
+  const results: HashSource[] = [];
   let config: ProjectConfig;
+  let loadedModules: string[] = [];
+  const ignoredFile = await createTempIgnoredFileAsync(options);
   try {
-    const { getConfig } = require(resolveFrom(path.resolve(projectRoot), 'expo/config'));
-    config = await getConfig(projectRoot, { skipSDKVersionRequirement: true });
+    const { stdout } = await spawnAsync(
+      'node',
+      [getExpoConfigLoaderPath(), path.resolve(projectRoot), ignoredFile],
+      { cwd: __dirname }
+    );
+    const stdoutJson = JSON.parse(stdout);
+    config = stdoutJson.config;
+    loadedModules = stdoutJson.loadedModules;
+    results.push({
+      type: 'contents',
+      id: 'expoConfig',
+      contents: normalizeExpoConfig(config.exp),
+      reasons: ['expoConfig'],
+    });
   } catch (e: unknown) {
-    debug('Cannot get Expo config: ' + e);
+    if (e instanceof Error) {
+      console.warn(`Cannot get Expo config from an Expo project - ${e.message}: `, e.stack);
+    }
     return [];
   }
 
-  const results: HashSource[] = [];
-
-  // app config files
-  const configFiles = ['app.config.ts', 'app.config.js', 'app.config.json', 'app.json'];
-  const configFileSources = (
-    await Promise.all(
-      configFiles.map(async (file) => {
-        const result = await getFileBasedHashSourceAsync(projectRoot, file, 'expoConfig');
-        if (result != null) {
-          debug(`Adding config file - ${chalk.dim(file)}`);
-        }
-        return result;
-      })
-    )
-  ).filter(Boolean) as HashSource[];
-  results.push(...configFileSources);
-
   // external files in config
   const isAndroid = options.platforms.includes('android');
   const isIos = options.platforms.includes('ios');
@@ -86,44 +91,32 @@ export async function getExpoConfigSourcesAsync(
   results.push(...externalFileSources);
 
   // config plugins
-  const configPluginSources = getConfigPluginSourcesAsync(projectRoot, config.exp.plugins);
-  results.push(...configPluginSources);
+  const configPluginModules: HashSource[] = loadedModules.map((modulePath) => ({
+    type: 'file',
+    filePath: modulePath,
+    reasons: ['expoConfigPlugins'],
+  }));
+  results.push(...configPluginModules);
 
   return results;
 }
 
-function findUpPluginRoot(entryFile: string): string {
-  const entryRoot = path.dirname(entryFile);
-  const packageJson = findUp.sync('package.json', { cwd: path.dirname(entryFile) });
-  assert(packageJson, `No package.json found for module "${entryRoot}"`);
-  return path.dirname(packageJson);
+function normalizeExpoConfig(config: ExpoConfig): string {
+  // Deep clone by JSON.parse/stringify that assumes the config is serializable.
+  const normalizedConfig: ExpoConfig = JSON.parse(JSON.stringify(config));
+  delete normalizedConfig.runtimeVersion;
+  delete normalizedConfig._internal;
+  return stringifyJsonSorted(normalizedConfig);
 }
 
-function getConfigPluginSourcesAsync(
-  projectRoot: string,
-  plugins: ExpoConfig['plugins']
-): HashSource[] {
-  if (plugins == null) {
-    return [];
-  }
-
-  const reasons = ['expoConfigPlugins'];
-  const nullableResults: (HashSource | null)[] = plugins.map((plugin) => {
-    const pluginPackageName = Array.isArray(plugin) ? plugin[0] : plugin;
-    if (typeof pluginPackageName === 'string') {
-      const pluginPackageEntryFile = resolveFrom.silent(projectRoot, pluginPackageName);
-      const pluginPackageRoot = pluginPackageEntryFile
-        ? findUpPluginRoot(pluginPackageEntryFile)
-        : null;
-      if (pluginPackageRoot) {
-        debug(`Adding config-plugin root - ${chalk.dim(pluginPackageRoot)}`);
-        return { type: 'dir', filePath: path.relative(projectRoot, pluginPackageRoot), reasons };
-      }
-    }
-    return null;
-  });
-  const results = nullableResults.filter(Boolean) as HashSource[];
-  return results;
+/**
+ * Create a temporary file with ignored paths from options that will be read by the ExpoConfigLoader.
+ */
+async function createTempIgnoredFileAsync(options: NormalizedOptions): Promise<string> {
+  await fs.mkdtemp(path.join(os.tmpdir(), 'expo-fingerprint-'));
+  const ignoredFile = path.join(os.tmpdir(), '.fingerprintignore');
+  await fs.writeFile(ignoredFile, options.ignorePaths.join('\n'));
+  return ignoredFile;
 }
 
 export async function getEasBuildSourcesAsync(projectRoot: string, options: NormalizedOptions) {

package/src/sourcer/ExpoConfigLoader.ts

@@ -0,0 +1,84 @@
+/**
+ * A helper script to load the Expo config and loaded plugins from a project
+ */
+
+import fs from 'fs/promises';
+import module from 'module';
+import path from 'path';
+import resolveFrom from 'resolve-from';
+
+import { DEFAULT_IGNORE_PATHS } from '../Options';
+import { isIgnoredPath } from '../utils/Path';
+
+async function runAsync(programName: string, args: string[] = []) {
+  if (args.length < 1) {
+    console.log(`Usage: ${programName} <projectRoot> [ignoredFile]`);
+    return;
+  }
+
+  const projectRoot = path.resolve(args[0]);
+  const ignoredFile = args[1] ? path.resolve(args[1]) : null;
+
+  // @ts-expect-error: module internal _cache
+  const loadedModulesBefore = new Set(Object.keys(module._cache));
+
+  const { getConfig } = require(resolveFrom(path.resolve(projectRoot), 'expo/config'));
+  const config = await getConfig(projectRoot, { skipSDKVersionRequirement: true });
+  // @ts-expect-error: module internal _cache
+  const loadedModules = Object.keys(module._cache)
+    .filter((modulePath) => !loadedModulesBefore.has(modulePath))
+    .map((modulePath) => path.relative(projectRoot, modulePath));
+
+  const ignoredPaths = await loadIgnoredPathsAsync(ignoredFile);
+  const filteredLoadedModules = loadedModules.filter(
+    (modulePath) => !isIgnoredPath(modulePath, ignoredPaths)
+  );
+  console.log(JSON.stringify({ config, loadedModules: filteredLoadedModules }));
+}
+
+// If running from the command line
+if (require.main?.filename === __filename) {
+  (async () => {
+    const programIndex = process.argv.findIndex((arg) => arg === __filename);
+    try {
+      await runAsync(process.argv[programIndex], process.argv.slice(programIndex + 1));
+    } catch (e) {
+      console.error('Uncaught Error', e);
+      process.exit(1);
+    }
+  })();
+}
+
+/**
+ * Load the generated ignored paths file from caller and remove the file after loading
+ */
+async function loadIgnoredPathsAsync(ignoredFile: string | null) {
+  if (!ignoredFile) {
+    return DEFAULT_IGNORE_PATHS;
+  }
+
+  const ignorePaths = [];
+  try {
+    const fingerprintIgnore = await fs.readFile(ignoredFile, 'utf8');
+    const fingerprintIgnoreLines = fingerprintIgnore.split('\n');
+    for (const line of fingerprintIgnoreLines) {
+      const trimmedLine = line.trim();
+      if (trimmedLine) {
+        ignorePaths.push(trimmedLine);
+      }
+    }
+  } catch {}
+
+  try {
+    await fs.rm(ignoredFile);
+  } catch {}
+
+  return ignorePaths;
+}
+
+/**
+ * Get the path to the ExpoConfigLoader file.
+ */
+export function getExpoConfigLoaderPath() {
+  return path.join(__dirname, 'ExpoConfigLoader.js');
+}

package/src/sourcer/Utils.ts

@@ -21,3 +21,42 @@ export async function getFileBasedHashSourceAsync(
   }
   return result;
 }
+
+/**
+ * A version of `JSON.stringify` that keeps the keys sorted
+ */
+export function stringifyJsonSorted(target: any, space?: string | number | undefined): string {
+  return JSON.stringify(target, (_, value) => sortJson(value), space);
+}
+
+function sortJson(json: any): any {
+  if (Array.isArray(json)) {
+    return json.sort((a, b) => {
+      // Sort array items by their stringified value.
+      // We don't need the array to be sorted in meaningful way, just to be sorted in deterministic.
+      // E.g. `[{ b: '2' }, {}, { a: '3' }, null]` -> `[null, { a : '3' }, { b: '2' }, {}]`
+      // This result is not a perfect solution, but it's good enough for our use case.
+      const stringifiedA = stringifyJsonSorted(a);
+      const stringifiedB = stringifyJsonSorted(b);
+      if (stringifiedA < stringifiedB) {
+        return -1;
+      } else if (stringifiedA > stringifiedB) {
+        return 1;
+      }
+      return 0;
+    });
+  }
+
+  if (json != null && typeof json === 'object') {
+    // Sort object items by keys
+    return Object.keys(json)
+      .sort()
+      .reduce((acc: any, key: string) => {
+        acc[key] = json[key];
+        return acc;
+      }, {});
+  }
+
+  // Return primitives
+  return json;
+}

package/src/sourcer/__tests__/Bare-test.ts

@@ -3,7 +3,7 @@ import fs from 'fs';
 import { vol } from 'memfs';
 import path from 'path';
 
-import { normalizeOptions } from '../../Options';
+import { normalizeOptionsAsync } from '../../Options';
 import {
   getBareAndroidSourcesAsync,
   getBareIosSourcesAsync,
@@ -21,10 +21,10 @@ describe('getBareSourcesAsync', () => {
 
   it('should contain android and ios folders in bare react-native project', async () => {
     vol.fromJSON(require('./fixtures/BareReactNative70Project.json'));
-    let sources = await getBareAndroidSourcesAsync('/app', normalizeOptions());
+    let sources = await getBareAndroidSourcesAsync('/app', await normalizeOptionsAsync('/app'));
     expect(sources).toContainEqual(expect.objectContaining({ filePath: 'android', type: 'dir' }));
 
-    sources = await getBareIosSourcesAsync('/app', normalizeOptions());
+    sources = await getBareIosSourcesAsync('/app', await normalizeOptionsAsync('/app'));
     expect(sources).toContainEqual(expect.objectContaining({ filePath: 'ios', type: 'dir' }));
   });
 });
@@ -47,7 +47,10 @@ describe(getRncliAutolinkingSourcesAsync, () => {
       signal: null,
       output: [fixture, ''],
     });
-    const sources = await getRncliAutolinkingSourcesAsync('/root/apps/demo', normalizeOptions());
+    const sources = await getRncliAutolinkingSourcesAsync(
+      '/root/apps/demo',
+      await normalizeOptionsAsync('/app')
+    );
     expect(sources).toContainEqual(
       expect.objectContaining({
         type: 'dir',
@@ -70,7 +73,10 @@ describe(getRncliAutolinkingSourcesAsync, () => {
       signal: null,
       output: [fixture, ''],
     });
-    const sources = await getRncliAutolinkingSourcesAsync('/root/apps/demo', normalizeOptions());
+    const sources = await getRncliAutolinkingSourcesAsync(
+      '/root/apps/demo',
+      await normalizeOptionsAsync('/app')
+    );
     for (const source of sources) {
       if (source.type === 'dir' || source.type === 'file') {
         expect(source.filePath).not.toMatch(/^\/root/);