@expo/fingerprint 0.0.1

package/src/sourcer/Expo.ts

@@ -0,0 +1,216 @@
+import spawnAsync from '@expo/spawn-async';
+import assert from 'assert';
+import chalk from 'chalk';
+import { getConfig, type ExpoConfig } from 'expo/config';
+import findUp from 'find-up';
+import path from 'path';
+import resolveFrom from 'resolve-from';
+
+import type { HashSource, NormalizedOptions } from '../Fingerprint.types';
+import { getFileBasedHashSourceAsync } from './Utils';
+
+const debug = require('debug')('expo:fingerprint:sourcer:Expo');
+
+export async function getExpoConfigSourcesAsync(
+  projectRoot: string,
+  options: NormalizedOptions
+): Promise<HashSource[]> {
+  let config;
+  try {
+    config = await getConfig(projectRoot, { skipSDKVersionRequirement: true });
+  } catch (e: unknown) {
+    debug('Cannot get Expo config: ' + e);
+    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');
+  const externalFiles = [
+    // icons
+    config.exp.icon,
+    isAndroid ? config.exp.android?.icon : undefined,
+    isIos ? config.exp.ios?.icon : undefined,
+    isAndroid ? config.exp.android?.adaptiveIcon?.foregroundImage : undefined,
+    isAndroid ? config.exp.android?.adaptiveIcon?.backgroundImage : undefined,
+    config.exp.notification?.icon,
+
+    // splash images
+    config.exp.splash?.image,
+    isAndroid ? config.exp.android?.splash?.image : undefined,
+    isAndroid ? config.exp.android?.splash?.mdpi : undefined,
+    isAndroid ? config.exp.android?.splash?.hdpi : undefined,
+    isAndroid ? config.exp.android?.splash?.xhdpi : undefined,
+    isAndroid ? config.exp.android?.splash?.xxhdpi : undefined,
+    isAndroid ? config.exp.android?.splash?.xxxhdpi : undefined,
+    isIos ? config.exp.ios?.splash?.image : undefined,
+    isIos ? config.exp.ios?.splash?.tabletImage : undefined,
+
+    // google service files
+    isAndroid ? config.exp.android?.googleServicesFile : undefined,
+    isIos ? config.exp.ios?.googleServicesFile : undefined,
+  ].filter(Boolean) as string[];
+  const externalFileSources = (
+    await Promise.all(
+      externalFiles.map(async (file) => {
+        const result = await getFileBasedHashSourceAsync(
+          projectRoot,
+          file,
+          'expoConfigExternalFile'
+        );
+        if (result != null) {
+          debug(`Adding config external file - ${chalk.dim(file)}`);
+        }
+        return result;
+      })
+    )
+  ).filter(Boolean) as HashSource[];
+  results.push(...externalFileSources);
+
+  // config plugins
+  const configPluginSources = getConfigPluginSourcesAsync(projectRoot, config.exp.plugins);
+  results.push(...configPluginSources);
+
+  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 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;
+}
+
+export async function getEasBuildSourcesAsync(projectRoot: string, options: NormalizedOptions) {
+  const files = ['eas.json', '.easignore'];
+  const results = (
+    await Promise.all(
+      files.map(async (file) => {
+        const result = await getFileBasedHashSourceAsync(projectRoot, file, 'easBuild');
+        if (result != null) {
+          debug(`Adding eas file - ${chalk.dim(file)}`);
+        }
+        return result;
+      })
+    )
+  ).filter(Boolean) as HashSource[];
+  return results;
+}
+
+export async function getExpoAutolinkingAndroidSourcesAsync(
+  projectRoot: string,
+  options: NormalizedOptions
+): Promise<HashSource[]> {
+  if (!options.platforms.includes('android')) {
+    return [];
+  }
+
+  try {
+    const reasons = ['expoAutolinkingAndroid'];
+    const results: HashSource[] = [];
+    const { stdout } = await spawnAsync(
+      'npx',
+      ['expo-modules-autolinking', 'resolve', '-p', 'android', '--json'],
+      { cwd: projectRoot }
+    );
+    const config = JSON.parse(stdout);
+    for (const module of config.modules) {
+      for (const project of module.projects) {
+        const filePath = path.relative(projectRoot, project.sourceDir);
+        project.sourceDir = filePath; // use relative path for the dir
+        debug(`Adding expo-modules-autolinking android dir - ${chalk.dim(filePath)}`);
+        results.push({ type: 'dir', filePath, reasons });
+      }
+    }
+    results.push({
+      type: 'contents',
+      id: 'expoAutolinkingConfig:android',
+      contents: JSON.stringify(config),
+      reasons,
+    });
+    return results;
+  } catch {
+    return [];
+  }
+}
+
+export async function getExpoAutolinkingIosSourcesAsync(
+  projectRoot: string,
+  options: NormalizedOptions
+): Promise<HashSource[]> {
+  if (!options.platforms.includes('ios')) {
+    return [];
+  }
+
+  try {
+    const reasons = ['expoAutolinkingIos'];
+    const results: HashSource[] = [];
+    const { stdout } = await spawnAsync(
+      'npx',
+      ['expo-modules-autolinking', 'resolve', '-p', 'ios', '--json'],
+      { cwd: projectRoot }
+    );
+    const config = JSON.parse(stdout);
+    for (const module of config.modules) {
+      for (const pod of module.pods) {
+        const filePath = path.relative(projectRoot, pod.podspecDir);
+        pod.podspecDir = filePath; // use relative path for the dir
+        debug(`Adding expo-modules-autolinking ios dir - ${chalk.dim(filePath)}`);
+        results.push({ type: 'dir', filePath, reasons });
+      }
+    }
+    results.push({
+      type: 'contents',
+      id: 'expoAutolinkingConfig:ios',
+      contents: JSON.stringify(config),
+      reasons,
+    });
+    return results;
+  } catch {
+    return [];
+  }
+}

package/src/sourcer/PatchPackage.ts

@@ -0,0 +1,18 @@
+import chalk from 'chalk';
+
+import type { HashSource, NormalizedOptions } from '../Fingerprint.types';
+import { getFileBasedHashSourceAsync } from './Utils';
+
+const debug = require('debug')('expo:fingerprint:sourcer:PatchPackage');
+
+export async function getPatchPackageSourcesAsync(
+  projectRoot: string,
+  options: NormalizedOptions
+): Promise<HashSource[]> {
+  const result = await getFileBasedHashSourceAsync(projectRoot, 'patches', 'patchPackage');
+  if (result != null) {
+    debug(`Adding dir - ${chalk.dim('patches')}`);
+    return [result];
+  }
+  return [];
+}

package/src/sourcer/Sourcer.ts

@@ -0,0 +1,58 @@
+import chalk from 'chalk';
+
+import type { HashSource, NormalizedOptions } from '../Fingerprint.types';
+import { profile } from '../utils/Profile';
+import {
+  getBareAndroidSourcesAsync,
+  getBareIosSourcesAsync,
+  getPackageJsonScriptSourcesAsync,
+  getGitIgnoreSourcesAsync,
+  getRncliAutolinkingSourcesAsync,
+} from './Bare';
+import {
+  getEasBuildSourcesAsync,
+  getExpoAutolinkingAndroidSourcesAsync,
+  getExpoAutolinkingIosSourcesAsync,
+  getExpoConfigSourcesAsync,
+} from './Expo';
+import { getPatchPackageSourcesAsync } from './PatchPackage';
+
+const debug = require('debug')('expo:fingerprint:sourcer:Sourcer');
+
+export async function getHashSourcesAsync(
+  projectRoot: string,
+  options: NormalizedOptions
+): Promise<HashSource[]> {
+  const results = await Promise.all([
+    // expo
+    profile(getExpoAutolinkingAndroidSourcesAsync)(projectRoot, options),
+    profile(getExpoAutolinkingIosSourcesAsync)(projectRoot, options),
+    profile(getExpoConfigSourcesAsync)(projectRoot, options),
+    profile(getEasBuildSourcesAsync)(projectRoot, options),
+
+    // bare managed files
+    profile(getGitIgnoreSourcesAsync)(projectRoot, options),
+    profile(getPackageJsonScriptSourcesAsync)(projectRoot, options),
+
+    // bare native files
+    profile(getBareAndroidSourcesAsync)(projectRoot, options),
+    profile(getBareIosSourcesAsync)(projectRoot, options),
+
+    // rn-cli autolinking
+    profile(getRncliAutolinkingSourcesAsync)(projectRoot, options),
+
+    // patch-package
+    profile(getPatchPackageSourcesAsync)(projectRoot, options),
+  ]);
+
+  // extra sources
+  if (options.extraSources) {
+    for (const source of options.extraSources) {
+      debug(`Adding extra source - ${chalk.dim(JSON.stringify(source))}`);
+    }
+    results.push(options.extraSources);
+  }
+
+  // flatten results
+  return ([] as HashSource[]).concat(...results);
+}

package/src/sourcer/Utils.ts

@@ -0,0 +1,23 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+import type { HashSource } from '../Fingerprint.types';
+
+export async function getFileBasedHashSourceAsync(
+  projectRoot: string,
+  filePath: string,
+  reason: string
+): Promise<HashSource | null> {
+  let result: HashSource | null = null;
+  try {
+    const stat = await fs.stat(path.join(projectRoot, filePath));
+    result = {
+      type: stat.isDirectory() ? 'dir' : 'file',
+      filePath,
+      reasons: [reason],
+    };
+  } catch {
+    result = null;
+  }
+  return result;
+}

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

@@ -0,0 +1,59 @@
+import spawnAsync from '@expo/spawn-async';
+import fs from 'fs';
+import { vol } from 'memfs';
+import path from 'path';
+
+import { normalizeOptions } from '../../Options';
+import {
+  getBareAndroidSourcesAsync,
+  getBareIosSourcesAsync,
+  getRncliAutolinkingSourcesAsync,
+} from '../Bare';
+
+jest.mock('@expo/spawn-async');
+jest.mock('fs/promises');
+jest.mock('/app/package.json', () => ({}), { virtual: true });
+
+describe('getBareSourcesAsync', () => {
+  afterEach(() => {
+    vol.reset();
+  });
+
+  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());
+    expect(sources).toContainEqual(expect.objectContaining({ filePath: 'android', type: 'dir' }));
+
+    sources = await getBareIosSourcesAsync('/app', normalizeOptions());
+    expect(sources).toContainEqual(expect.objectContaining({ filePath: 'ios', type: 'dir' }));
+  });
+});
+
+describe(getRncliAutolinkingSourcesAsync, () => {
+  afterEach(() => {
+    vol.reset();
+  });
+
+  it('should contain rn-cli autolinking projects', async () => {
+    const mockSpawnAsync = spawnAsync as jest.MockedFunction<typeof spawnAsync>;
+    const fixture = fs.readFileSync(
+      path.join(__dirname, 'fixtures', 'RncliAutoLinking.json'),
+      'utf8'
+    );
+    mockSpawnAsync.mockResolvedValue({
+      stdout: fixture,
+      stderr: '',
+      status: 0,
+      signal: null,
+      output: [fixture, ''],
+    });
+    const sources = await getRncliAutolinkingSourcesAsync('/app', normalizeOptions());
+    expect(sources).toContainEqual(
+      expect.objectContaining({
+        type: 'dir',
+        filePath: 'node_modules/react-native-reanimated',
+      })
+    );
+    expect(sources).toMatchSnapshot();
+  });
+});

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

@@ -0,0 +1,265 @@
+import spawnAsync from '@expo/spawn-async';
+import findUp from 'find-up';
+import fs from 'fs';
+import { vol, fs as volFS } from 'memfs';
+import path from 'path';
+import resolveFrom from 'resolve-from';
+
+import { normalizeOptions } from '../../Options';
+import {
+  getEasBuildSourcesAsync,
+  getExpoAutolinkingAndroidSourcesAsync,
+  getExpoAutolinkingIosSourcesAsync,
+  getExpoConfigSourcesAsync,
+} from '../Expo';
+
+jest.mock('@expo/spawn-async');
+jest.mock('find-up');
+jest.mock('fs/promises');
+jest.mock('resolve-from');
+jest.mock('/app/package.json', () => {}, { virtual: true });
+
+describe(getEasBuildSourcesAsync, () => {
+  afterEach(() => {
+    vol.reset();
+  });
+
+  it('should contains `eas.json` file', async () => {
+    vol.fromJSON(require('./fixtures/ExpoManaged47Project.json'));
+    vol.writeFileSync(
+      '/app/eas.json',
+      `
+{
+  "cli": {
+    "version": ">= 2.6.0"
+  },
+  "build": {
+    "development": {
+      "distribution": "internal",
+      "android": {
+        "gradleCommand": ":app:assembleDebug"
+      },
+      "ios": {
+        "buildConfiguration": "Debug"
+      }
+    },
+    "preview": {
+      "distribution": "internal"
+    },
+    "production": {}
+  },
+  "submit": {
+    "production": {}
+  }
+}`
+    );
+
+    const sources = await getEasBuildSourcesAsync('/app', normalizeOptions());
+    expect(sources).toContainEqual(
+      expect.objectContaining({
+        type: 'file',
+        filePath: 'eas.json',
+      })
+    );
+  });
+});
+
+describe('getExpoAutolinkingSourcesAsync', () => {
+  beforeEach(() => {
+    const mockSpawnAsync = spawnAsync as jest.MockedFunction<typeof spawnAsync>;
+    const fixtureAndroid = fs.readFileSync(
+      path.join(__dirname, 'fixtures', 'ExpoAutolinkingAndroid.json'),
+      'utf8'
+    );
+    const fixtureIos = fs.readFileSync(
+      path.join(__dirname, 'fixtures', 'ExpoAutolinkingIos.json'),
+      'utf8'
+    );
+    mockSpawnAsync.mockResolvedValueOnce({
+      stdout: fixtureAndroid,
+      stderr: '',
+      status: 0,
+      signal: null,
+      output: [fixtureAndroid, ''],
+    });
+    mockSpawnAsync.mockResolvedValueOnce({
+      stdout: fixtureIos,
+      stderr: '',
+      status: 0,
+      signal: null,
+      output: [fixtureIos, ''],
+    });
+  });
+
+  afterEach(() => {
+    vol.reset();
+  });
+
+  it('should contain expo autolinking projects', async () => {
+    let sources = await getExpoAutolinkingAndroidSourcesAsync('/app', normalizeOptions());
+    expect(sources).toContainEqual(
+      expect.objectContaining({
+        type: 'dir',
+        filePath: 'node_modules/expo-modules-core/android',
+      })
+    );
+    expect(sources).toMatchSnapshot();
+
+    sources = await getExpoAutolinkingIosSourcesAsync('/app', normalizeOptions());
+    expect(sources).toContainEqual(
+      expect.objectContaining({ type: 'dir', filePath: 'node_modules/expo-modules-core' })
+    );
+    expect(sources).toMatchSnapshot();
+  });
+
+  it('should not containt absolute path in contents', async () => {
+    let sources = await getExpoAutolinkingAndroidSourcesAsync('/app', normalizeOptions());
+    for (const source of sources) {
+      if (source.type === 'contents') {
+        expect(source.contents.indexOf('/app/')).toBe(-1);
+      }
+    }
+
+    sources = await getExpoAutolinkingIosSourcesAsync('/app', normalizeOptions());
+    for (const source of sources) {
+      if (source.type === 'contents') {
+        expect(source.contents.indexOf('/app/')).toBe(-1);
+      }
+    }
+  });
+});
+
+describe(getExpoConfigSourcesAsync, () => {
+  beforeAll(() => {
+    jest.doMock('fs', () => volFS);
+  });
+
+  afterEach(() => {
+    vol.reset();
+  });
+
+  it('should contain app.json', async () => {
+    vol.fromJSON(require('./fixtures/ExpoManaged47Project.json'));
+    const sources = await getExpoConfigSourcesAsync('/app', normalizeOptions());
+    expect(sources).toContainEqual(
+      expect.objectContaining({
+        type: 'file',
+        filePath: 'app.json',
+      })
+    );
+  });
+
+  it('should contain external icon file in app.json', async () => {
+    vol.fromJSON(require('./fixtures/ExpoManaged47Project.json'));
+    vol.mkdirSync('/app/assets');
+    vol.writeFileSync('/app/assets/icon.png', 'PNG data');
+    const sources = await getExpoConfigSourcesAsync('/app', normalizeOptions());
+    expect(sources).toContainEqual(
+      expect.objectContaining({
+        type: 'file',
+        filePath: './assets/icon.png',
+      })
+    );
+  });
+});
+
+describe(`getExpoConfigSourcesAsync - config-plugins`, () => {
+  let baseAppJson: { expo: any };
+
+  function setupThirdPartyPlugin() {
+    vol.mkdirSync('/app/node_modules/third-party', { recursive: true });
+
+    // package.json
+    vol.writeFileSync('/app/node_modules/third-party/package.json', '{}');
+    const mockFindUpSync = findUp.sync as jest.MockedFunction<typeof findUp.sync>;
+    mockFindUpSync.mockReturnValue('/app/node_modules/third-party/package.json');
+
+    // entry file
+    const withNoopPlugin = (config: any) => config;
+    jest.mock('/app/node_modules/third-party/index.js', () => ({ default: withNoopPlugin }), {
+      virtual: true,
+    });
+    const mockResolveFrom = resolveFrom.silent as jest.MockedFunction<typeof resolveFrom.silent>;
+    mockResolveFrom.mockReturnValue('/app/node_modules/third-party/index.js');
+  }
+
+  beforeEach(() => {
+    jest.doMock('fs', () => volFS);
+    vol.fromJSON(require('./fixtures/ExpoManaged47Project.json'));
+    baseAppJson = JSON.parse(vol.readFileSync('/app/app.json', 'utf8').toString());
+  });
+
+  afterEach(() => {
+    vol.reset();
+    jest.resetAllMocks();
+  });
+
+  it('should contain external config-plugin dir', async () => {
+    setupThirdPartyPlugin();
+
+    vol.writeFileSync(
+      '/app/app.json',
+      JSON.stringify({
+        ...baseAppJson,
+        expo: {
+          ...baseAppJson.expo,
+          plugins: ['third-party'],
+        },
+      })
+    );
+    const sources = await getExpoConfigSourcesAsync('/app', normalizeOptions());
+    expect(sources).toContainEqual(
+      expect.objectContaining({
+        type: 'dir',
+        filePath: 'node_modules/third-party',
+      })
+    );
+  });
+
+  it('should contain external config-plugin dir from plugin with parameters', async () => {
+    setupThirdPartyPlugin();
+
+    vol.writeFileSync(
+      '/app/app.json',
+      JSON.stringify({
+        ...baseAppJson,
+        expo: {
+          ...baseAppJson.expo,
+          plugins: [['third-party', { parameter: 'foo' }]],
+        },
+      })
+    );
+    const sources = await getExpoConfigSourcesAsync('/app', normalizeOptions());
+    expect(sources).toContainEqual(
+      expect.objectContaining({
+        type: 'dir',
+        filePath: 'node_modules/third-party',
+      })
+    );
+  });
+
+  it('should not contain external config-plugin dir from raw function plugins', async () => {
+    vol.writeFileSync(
+      '/app/app.config.js',
+      `\
+export default ({ config }) => {
+  return config;
+};`
+    );
+    const sources = await getExpoConfigSourcesAsync('/app', normalizeOptions());
+
+    vol.writeFileSync(
+      '/app/app.config.js',
+      `\
+export default ({ config }) => {
+  config.plugins ||= [];
+  const withNoopPlugin = (config: any) => config;
+  config.plugins.push(withNoopPlugin);
+  return config;
+};`
+    );
+    const sources2 = await getExpoConfigSourcesAsync('/app', normalizeOptions());
+
+    expect(sources).toEqual(sources2);
+  });
+});

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

@@ -0,0 +1,54 @@
+import { vol } from 'memfs';
+
+import { normalizeOptions } from '../../Options';
+import { getPatchPackageSourcesAsync } from '../PatchPackage';
+import { getHashSourcesAsync } from '../Sourcer';
+
+jest.mock('fs/promises');
+jest.mock('/app/package.json', () => ({}), { virtual: true });
+
+describe(getPatchPackageSourcesAsync, () => {
+  afterEach(() => {
+    vol.reset();
+  });
+
+  it('should contain patch-packages `patches` dir', async () => {
+    vol.fromJSON(require('./fixtures/ExpoManaged47Project.json'));
+    vol.fromJSON(require('./fixtures/PatchPackage.json'));
+
+    const sources = await getPatchPackageSourcesAsync('/app', normalizeOptions());
+    expect(sources).toContainEqual(
+      expect.objectContaining({
+        type: 'dir',
+        filePath: 'patches',
+      })
+    );
+  });
+});
+
+describe('patch-package postinstall', () => {
+  it('should contain `package.json` scripts block for lifecycle patches', async () => {
+    const scriptsBlock = {
+      postinstall: 'npx patch-package',
+    };
+    jest.doMock(
+      '/app/package.json',
+      () => ({
+        name: 'app',
+        private: true,
+        scripts: scriptsBlock,
+      }),
+      { virtual: true }
+    );
+
+    const sources = await getHashSourcesAsync('/app', normalizeOptions());
+    expect(sources).toContainEqual(
+      expect.objectContaining({
+        type: 'contents',
+        id: 'packageJson:scripts',
+        contents: JSON.stringify(scriptsBlock),
+        reasons: ['packageJson:scripts'],
+      })
+    );
+  });
+});