@expo/fingerprint 0.4.1 → 0.5.0

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

@@ -1,238 +0,0 @@
-import { createHash } from 'crypto';
-import { vol } from 'memfs';
-import pLimit from 'p-limit';
-import path from 'path';
-
-import { HashSource } from '../../Fingerprint.types';
-import { normalizeOptionsAsync } from '../../Options';
-import {
-  createContentsHashResultsAsync,
-  createDirHashResultsAsync,
-  createFileHashResultsAsync,
-  createFingerprintFromSourcesAsync,
-  createFingerprintSourceAsync,
-  createSourceId,
-} from '../Hash';
-
-jest.mock('fs');
-jest.mock('fs/promises');
-
-describe(createFingerprintFromSourcesAsync, () => {
-  afterEach(() => {
-    vol.reset();
-  });
-
-  it('snapshot', async () => {
-    const filePath = 'assets/icon.png';
-    vol.mkdirSync('/app');
-    vol.mkdirSync('/app/assets');
-    vol.writeFileSync(path.join('/app', filePath), '{}');
-
-    const sources: HashSource[] = [
-      { type: 'contents', id: 'foo', contents: 'HelloWorld', reasons: ['foo'] },
-      { type: 'file', filePath, reasons: ['icon'] },
-    ];
-
-    expect(
-      await createFingerprintFromSourcesAsync(sources, '/app', await normalizeOptionsAsync('/app'))
-    ).toMatchInlineSnapshot(`
-      {
-        "hash": "ca7d58cd60289daa5cddcf99fcaa1d339bfc2c1a",
-        "sources": [
-          {
-            "contents": "HelloWorld",
-            "hash": "db8ac1c259eb89d4a131b253bacfca5f319d54f2",
-            "id": "foo",
-            "reasons": [
-              "foo",
-            ],
-            "type": "contents",
-          },
-          {
-            "filePath": "assets/icon.png",
-            "hash": "bf21a9e8fbc5a3846fb05b4fa0859e0917b2202f",
-            "reasons": [
-              "icon",
-            ],
-            "type": "file",
-          },
-        ],
-      }
-    `);
-  });
-});
-
-describe(createFingerprintSourceAsync, () => {
-  it('should merge hash value to original source', async () => {
-    const source: HashSource = {
-      type: 'contents',
-      id: 'foo',
-      contents: 'HelloWorld',
-      reasons: ['foo'],
-    };
-    const expectedResult = {
-      ...source,
-      hash: 'db8ac1c259eb89d4a131b253bacfca5f319d54f2',
-    };
-    expect(
-      await createFingerprintSourceAsync(
-        source,
-        pLimit(1),
-        '/app',
-        await normalizeOptionsAsync('/app')
-      )
-    ).toEqual(expectedResult);
-  });
-});
-
-describe(createContentsHashResultsAsync, () => {
-  it('should return {id, hex} result', async () => {
-    const id = 'foo';
-    const contents = '{}';
-    const options = await normalizeOptionsAsync('/app');
-    const result = await createContentsHashResultsAsync(
-      {
-        type: 'contents',
-        id,
-        contents,
-        reasons: [id],
-      },
-      options
-    );
-
-    const expectHex = createHash(options.hashAlgorithm).update(contents).digest('hex');
-    expect(result.id).toEqual(id);
-    expect(result.hex).toEqual(expectHex);
-  });
-});
-
-describe(createFileHashResultsAsync, () => {
-  afterEach(() => {
-    vol.reset();
-  });
-
-  it('should return {id, hex} result', async () => {
-    const filePath = 'assets/icon.png';
-    const contents = '{}';
-    const limiter = pLimit(1);
-    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);
-  });
-
-  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);
-  });
-});
-
-describe(createDirHashResultsAsync, () => {
-  afterEach(() => {
-    vol.reset();
-  });
-
-  it('should return {id, hex} result', async () => {
-    const limiter = pLimit(3);
-    const options = await normalizeOptionsAsync('/app');
-    const volJSON = {
-      '/app/ios/Podfile': '...',
-      '/app/eas.json': '{}',
-      '/app/app.json': '{}',
-      '/app/android/build.gradle': '...',
-    };
-    vol.fromJSON(volJSON);
-    const result = await createDirHashResultsAsync('.', limiter, '/app', options);
-
-    expect(result?.id).toEqual('.');
-    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 = await normalizeOptionsAsync('/app');
-    const volJSON = {
-      '/app/ios/Podfile': '...',
-      '/app/eas.json': '{}',
-      '/app/app.json': '{}',
-      '/app/android/build.gradle': '...',
-    };
-    vol.fromJSON(volJSON);
-    const result = await createDirHashResultsAsync('.', limiter, '/app', options);
-
-    vol.reset();
-    const sortedVolJSON = {
-      '/app/app.json': '{}',
-      '/app/eas.json': '{}',
-      '/app/android/build.gradle': '...',
-      '/app/ios/Podfile': '...',
-    };
-    vol.fromJSON(sortedVolJSON);
-    const sortedResult = await createDirHashResultsAsync('.', limiter, '/app', options);
-
-    expect(result?.id).toEqual(sortedResult?.id);
-    expect(result?.hex).toEqual(sortedResult?.hex);
-  });
-});
-
-describe(createSourceId, () => {
-  it(`should use filePath as id for file or dir`, () => {
-    const fileSource: HashSource = {
-      type: 'file',
-      filePath: '/app/app.json',
-      reasons: ['expoConfig'],
-    };
-    expect(createSourceId(fileSource)).toBe('/app/app.json');
-
-    const dirSource: HashSource = { type: 'dir', filePath: '/app/ios', reasons: ['bareNativeDir'] };
-    expect(createSourceId(dirSource)).toBe('/app/ios');
-  });
-
-  it(`should use given id for contents`, () => {
-    const source: HashSource = {
-      type: 'contents',
-      id: 'foo',
-      contents: 'HelloWorld',
-      reasons: ['foo'],
-    };
-    expect(createSourceId(source)).toBe('foo');
-  });
-});

package/src/index.ts

@@ -1,2 +0,0 @@
-export * from './Fingerprint';
-export * from './Fingerprint.types';

package/src/sourcer/Bare.ts

@@ -1,115 +0,0 @@
-import spawnAsync from '@expo/spawn-async';
-import assert from 'assert';
-import chalk from 'chalk';
-import path from 'path';
-import resolveFrom from 'resolve-from';
-
-import { getFileBasedHashSourceAsync } from './Utils';
-import type { HashSource, NormalizedOptions } from '../Fingerprint.types';
-
-const debug = require('debug')('expo:fingerprint:sourcer:Bare');
-
-export async function getBareAndroidSourcesAsync(
-  projectRoot: string,
-  options: NormalizedOptions
-): Promise<HashSource[]> {
-  if (options.platforms.includes('android')) {
-    const result = await getFileBasedHashSourceAsync(projectRoot, 'android', 'bareNativeDir');
-    if (result != null) {
-      debug(`Adding bare native dir - ${chalk.dim('android')}`);
-      return [result];
-    }
-  }
-  return [];
-}
-
-export async function getBareIosSourcesAsync(
-  projectRoot: string,
-  options: NormalizedOptions
-): Promise<HashSource[]> {
-  if (options.platforms.includes('ios')) {
-    const result = await getFileBasedHashSourceAsync(projectRoot, 'ios', 'bareNativeDir');
-    if (result != null) {
-      debug(`Adding bare native dir - ${chalk.dim('ios')}`);
-      return [result];
-    }
-  }
-  return [];
-}
-
-export async function getPackageJsonScriptSourcesAsync(
-  projectRoot: string,
-  options: NormalizedOptions
-) {
-  let packageJson;
-  try {
-    packageJson = require(resolveFrom(path.resolve(projectRoot), './package.json'));
-  } catch (e: unknown) {
-    debug(`Unable to read package.json from ${path.resolve(projectRoot)}/package.json: ` + e);
-    return [];
-  }
-  const results: HashSource[] = [];
-  if (packageJson.scripts) {
-    debug(`Adding package.json contents - ${chalk.dim('scripts')}`);
-    const id = 'packageJson:scripts';
-    results.push({
-      type: 'contents',
-      id,
-      contents: JSON.stringify(packageJson.scripts),
-      reasons: [id],
-    });
-  }
-  return results;
-}
-
-export async function getGitIgnoreSourcesAsync(projectRoot: string, options: NormalizedOptions) {
-  const result = await getFileBasedHashSourceAsync(projectRoot, '.gitignore', 'bareGitIgnore');
-  if (result != null) {
-    debug(`Adding file - ${chalk.dim('.gitignore')}`);
-    return [result];
-  }
-  return [];
-}
-
-export async function getRncliAutolinkingSourcesAsync(
-  projectRoot: string,
-  options: NormalizedOptions
-): Promise<HashSource[]> {
-  try {
-    const results: HashSource[] = [];
-    const { stdout } = await spawnAsync('npx', ['react-native', 'config'], { cwd: projectRoot });
-    const config = JSON.parse(stdout);
-    const { root } = config;
-    const reasons = ['bareRncliAutolinking'];
-    const autolinkingConfig: Record<string, any> = {};
-    for (const [depName, depData] of Object.entries<any>(config.dependencies)) {
-      stripRncliAutolinkingAbsolutePaths(depData, root);
-      const filePath = depData.root;
-      debug(`Adding react-native-cli autolinking dir - ${chalk.dim(filePath)}`);
-      results.push({ type: 'dir', filePath, reasons });
-
-      autolinkingConfig[depName] = depData;
-    }
-
-    results.push({
-      type: 'contents',
-      id: 'rncliAutolinkingConfig',
-      contents: JSON.stringify(autolinkingConfig),
-      reasons,
-    });
-    return results;
-  } catch {
-    return [];
-  }
-}
-
-function stripRncliAutolinkingAbsolutePaths(dependency: any, root: string): void {
-  assert(dependency.root);
-  const dependencyRoot = dependency.root;
-  dependency.root = path.relative(root, dependencyRoot);
-  for (const platformData of Object.values<any>(dependency.platforms)) {
-    for (const [key, value] of Object.entries<any>(platformData)) {
-      platformData[key] = value.startsWith?.(dependencyRoot) ? path.relative(root, value) : value;
-    }
-  }
-}

package/src/sourcer/Expo.ts

@@ -1,223 +0,0 @@
-import spawnAsync from '@expo/spawn-async';
-import chalk from 'chalk';
-import type { ExpoConfig, ProjectConfig } from 'expo/config';
-import fs from 'fs/promises';
-import os from 'os';
-import path from 'path';
-import resolveFrom from 'resolve-from';
-
-import { getExpoConfigLoaderPath } from './ExpoConfigLoader';
-import { getFileBasedHashSourceAsync, stringifyJsonSorted } from './Utils';
-import type { HashSource, NormalizedOptions } from '../Fingerprint.types';
-
-const debug = require('debug')('expo:fingerprint:sourcer:Expo');
-
-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 { 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) {
-    if (e instanceof Error) {
-      console.warn(`Cannot get Expo config from an Expo project - ${e.message}: `, e.stack);
-    }
-    return [];
-  }
-
-  // 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 configPluginModules: HashSource[] = loadedModules.map((modulePath) => ({
-    type: 'file',
-    filePath: modulePath,
-    reasons: ['expoConfigPlugins'],
-  }));
-  results.push(...configPluginModules);
-
-  return results;
-}
-
-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);
-}
-
-/**
- * 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) {
-  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 = sortExpoAutolinkingAndroidConfig(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 [];
-  }
-}
-
-/**
- * Sort the expo-modules-autolinking android config to make it stable from hashing.
- */
-export function sortExpoAutolinkingAndroidConfig(config: Record<string, any>): Record<string, any> {
-  for (const module of config.modules) {
-    // Sort the projects by project.name
-    module.projects.sort((a: Record<string, any>, b: Record<string, any>) =>
-      a.name < b.name ? -1 : a.name > b.name ? 1 : 0
-    );
-  }
-  return config;
-}

package/src/sourcer/ExpoConfigLoader.ts

@@ -1,84 +0,0 @@
-/**
- * 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/PatchPackage.ts

@@ -1,18 +0,0 @@
-import chalk from 'chalk';
-
-import { getFileBasedHashSourceAsync } from './Utils';
-import type { HashSource, NormalizedOptions } from '../Fingerprint.types';
-
-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 [];
-}