@expo/fingerprint 0.4.1 → 0.6.0

package/src/Sort.ts

@@ -1,22 +0,0 @@
-import type { HashSource } from './Fingerprint.types';
-
-export function sortSources<T extends HashSource>(sources: T[]): T[] {
-  const typeOrder = {
-    file: 0,
-    dir: 1,
-    contents: 2,
-  };
-  return sources.sort((a, b) => {
-    const typeResult = typeOrder[a.type] - typeOrder[b.type];
-    if (typeResult === 0) {
-      if (a.type === 'file' && b.type === 'file') {
-        return a.filePath.localeCompare(b.filePath);
-      } else if (a.type === 'dir' && b.type === 'dir') {
-        return a.filePath.localeCompare(b.filePath);
-      } else if (a.type === 'contents' && b.type === 'contents') {
-        return a.id.localeCompare(b.id);
-      }
-    }
-    return typeResult;
-  });
-}

package/src/__tests__/Dedup-test.ts

@@ -1,177 +0,0 @@
-import { dedupSources } from '../Dedup';
-import type { HashSource } from '../Fingerprint.types';
-
-describe(dedupSources, () => {
-  it('should dedup descendant dir - ancestor coming first', () => {
-    const sources: HashSource[] = [
-      {
-        type: 'dir',
-        filePath: 'android',
-        reasons: ['root'],
-      },
-      {
-        type: 'dir',
-        filePath: 'android/app',
-        reasons: ['subfolder'],
-      },
-    ];
-
-    expect(dedupSources(sources, '/app')).toEqual([
-      {
-        type: 'dir',
-        filePath: 'android',
-        reasons: ['root', 'subfolder'],
-      },
-    ]);
-  });
-
-  it('should dedup descendant dir - ancestor coming later', () => {
-    const sources: HashSource[] = [
-      {
-        type: 'dir',
-        filePath: 'android/app',
-        reasons: ['subfolder'],
-      },
-      {
-        type: 'dir',
-        filePath: 'android',
-        reasons: ['root'],
-      },
-    ];
-
-    expect(dedupSources(sources, '/app')).toEqual([
-      {
-        type: 'dir',
-        filePath: 'android',
-        reasons: ['root', 'subfolder'],
-      },
-    ]);
-  });
-
-  it('should dedup descendant file - file coming first', () => {
-    const sources: HashSource[] = [
-      {
-        type: 'file',
-        filePath: 'android/app/build.gradle',
-        reasons: ['file'],
-      },
-      {
-        type: 'dir',
-        filePath: 'android',
-        reasons: ['root'],
-      },
-    ];
-
-    expect(dedupSources(sources, '/app')).toEqual([
-      {
-        type: 'dir',
-        filePath: 'android',
-        reasons: ['root', 'file'],
-      },
-    ]);
-  });
-
-  it('should dedup descendant file - file coming later', () => {
-    const sources: HashSource[] = [
-      {
-        type: 'dir',
-        filePath: 'android',
-        reasons: ['root'],
-      },
-      {
-        type: 'file',
-        filePath: 'android/app/build.gradle',
-        reasons: ['file'],
-      },
-    ];
-
-    expect(dedupSources(sources, '/app')).toEqual([
-      {
-        type: 'dir',
-        filePath: 'android',
-        reasons: ['root', 'file'],
-      },
-    ]);
-  });
-
-  it('should dedup slibings dir', () => {
-    const sources: HashSource[] = [
-      {
-        type: 'dir',
-        filePath: 'node_modules/expo',
-        reasons: ['expo'],
-      },
-      {
-        type: 'dir',
-        filePath: 'node_modules/expo-modules-core',
-        reasons: ['expo-modules-core'],
-      },
-    ];
-
-    expect(dedupSources(sources, '/app')).toEqual([
-      {
-        type: 'dir',
-        filePath: 'node_modules/expo',
-        reasons: ['expo'],
-      },
-      {
-        type: 'dir',
-        filePath: 'node_modules/expo-modules-core',
-        reasons: ['expo-modules-core'],
-      },
-    ]);
-  });
-
-  it('should keep unique contents by its id', () => {
-    const sources: HashSource[] = [
-      {
-        type: 'contents',
-        id: 'foo',
-        contents: 'foo:1',
-        reasons: ['foo:1'],
-      },
-      {
-        type: 'dir',
-        filePath: 'android',
-        reasons: ['root'],
-      },
-      {
-        type: 'contents',
-        id: 'foo',
-        contents: 'foo:2',
-        reasons: ['foo:2'],
-      },
-    ];
-
-    expect(dedupSources(sources, '/app')).toEqual([
-      {
-        type: 'contents',
-        id: 'foo',
-        contents: 'foo:1',
-        reasons: ['foo:1', 'foo:2'],
-      },
-      {
-        type: 'dir',
-        filePath: 'android',
-        reasons: ['root'],
-      },
-    ]);
-  });
-
-  it('should throw error when a dir is descendant of a file', () => {
-    const sources: HashSource[] = [
-      {
-        type: 'file',
-        filePath: 'android',
-        reasons: ['file'],
-      },
-      {
-        type: 'dir',
-        filePath: 'android/app',
-        reasons: ['dir'],
-      },
-    ];
-
-    expect(() => dedupSources(sources, '/app')).toThrow();
-  });
-});

package/src/__tests__/Fingerprint-test.ts

@@ -1,143 +0,0 @@
-import { vol } from 'memfs';
-
-import { createFingerprintAsync, diffFingerprintChangesAsync } from '../Fingerprint';
-import type { Fingerprint } from '../Fingerprint.types';
-import { normalizeOptionsAsync } from '../Options';
-
-jest.mock('fs');
-jest.mock('fs/promises');
-jest.mock('resolve-from');
-
-describe(diffFingerprintChangesAsync, () => {
-  afterEach(() => {
-    vol.reset();
-  });
-
-  it('should return empty array when fingerprint matched', async () => {
-    vol.fromJSON(require('../sourcer/__tests__/fixtures/ExpoManaged47Project.json'));
-    const fingerprint = await createFingerprintAsync('/app', await normalizeOptionsAsync('/app'));
-    const diff = await diffFingerprintChangesAsync(
-      fingerprint,
-      '/app',
-      await normalizeOptionsAsync('/app')
-    );
-    expect(diff.length).toBe(0);
-  });
-
-  it('should return diff from new item', async () => {
-    vol.fromJSON(require('../sourcer/__tests__/fixtures/ExpoManaged47Project.json'));
-    const fingerprint: Fingerprint = {
-      sources: [],
-      hash: '',
-    };
-
-    const diff = await diffFingerprintChangesAsync(
-      fingerprint,
-      '/app',
-      await normalizeOptionsAsync('/app')
-    );
-    expect(diff).toMatchInlineSnapshot(`
-      [
-        {
-          "contents": "{"android":{"adaptiveIcon":{"backgroundColor":"#FFFFFF","foregroundImage":"./assets/adaptive-icon.png"}},"assetBundlePatterns":["**/*"],"icon":"./assets/icon.png","ios":{"supportsTablet":true},"name":"sdk47","orientation":"portrait","platforms":["android","ios","web"],"slug":"sdk47","splash":{"backgroundColor":"#ffffff","image":"./assets/splash.png","resizeMode":"contain"},"updates":{"fallbackToCacheTimeout":0},"userInterfaceStyle":"light","version":"1.0.0","web":{"favicon":"./assets/favicon.png"}}",
-          "hash": "33b2b95de3b0b474810630e51527a2c0a6e5de9c",
-          "id": "expoConfig",
-          "reasons": [
-            "expoConfig",
-          ],
-          "type": "contents",
-        },
-      ]
-    `);
-  });
-
-  it('should return diff from contents changes', async () => {
-    vol.fromJSON(require('../sourcer/__tests__/fixtures/ExpoManaged47Project.json'));
-    const packageJson = JSON.parse(vol.readFileSync('/app/package.json', 'utf8').toString());
-    jest.doMock('/app/package.json', () => packageJson, { virtual: true });
-    const fingerprint = await createFingerprintAsync('/app', await normalizeOptionsAsync('/app'));
-
-    // first round for bumping package version which should not cause changes
-    packageJson.version = '111.111.111';
-    jest.doMock('/app/package.json', () => packageJson, { virtual: true });
-    let diff = await diffFingerprintChangesAsync(
-      fingerprint,
-      '/app',
-      await normalizeOptionsAsync('/app')
-    );
-    expect(diff.length).toBe(0);
-
-    // second round to update scripts section and it should cause changes
-    packageJson.scripts ||= {};
-    packageJson.scripts.postinstall = 'echo "hello"';
-    jest.doMock('/app/package.json', () => packageJson, { virtual: true });
-    diff = await diffFingerprintChangesAsync(
-      fingerprint,
-      '/app',
-      await normalizeOptionsAsync('/app')
-    );
-    jest.dontMock('/app/package.json');
-    expect(diff).toMatchInlineSnapshot(`
-      [
-        {
-          "contents": "{"start":"expo start","android":"expo start --android","ios":"expo start --ios","web":"expo start --web","postinstall":"echo \\"hello\\""}",
-          "hash": "47f4d7bae018eb17440153f09977113501eace30",
-          "id": "packageJson:scripts",
-          "reasons": [
-            "packageJson:scripts",
-          ],
-          "type": "contents",
-        },
-      ]
-    `);
-  });
-
-  it('should return diff from file changes', async () => {
-    vol.fromJSON(require('../sourcer/__tests__/fixtures/ExpoManaged47Project.json'));
-    const fingerprint = await createFingerprintAsync('/app', await normalizeOptionsAsync('/app'));
-    const config = JSON.parse(vol.readFileSync('/app/app.json', 'utf8').toString());
-    config.expo.jsEngine = 'jsc';
-    vol.writeFileSync('/app/app.json', JSON.stringify(config, null, 2));
-    const diff = await diffFingerprintChangesAsync(
-      fingerprint,
-      '/app',
-      await normalizeOptionsAsync('/app')
-    );
-    expect(diff).toMatchInlineSnapshot(`
-      [
-        {
-          "contents": "{"android":{"adaptiveIcon":{"backgroundColor":"#FFFFFF","foregroundImage":"./assets/adaptive-icon.png"}},"assetBundlePatterns":["**/*"],"icon":"./assets/icon.png","ios":{"supportsTablet":true},"jsEngine":"jsc","name":"sdk47","orientation":"portrait","platforms":["android","ios","web"],"slug":"sdk47","splash":{"backgroundColor":"#ffffff","image":"./assets/splash.png","resizeMode":"contain"},"updates":{"fallbackToCacheTimeout":0},"userInterfaceStyle":"light","version":"1.0.0","web":{"favicon":"./assets/favicon.png"}}",
-          "hash": "7068a4234e7312c6ac54b776ea4dfad0ac789b2a",
-          "id": "expoConfig",
-          "reasons": [
-            "expoConfig",
-          ],
-          "type": "contents",
-        },
-      ]
-    `);
-  });
-
-  it('should return diff from dir changes', async () => {
-    vol.fromJSON(require('../sourcer/__tests__/fixtures/BareReactNative70Project.json'));
-    const fingerprint = await createFingerprintAsync('/app', await normalizeOptionsAsync('/app'));
-    vol.writeFileSync('/app/ios/README.md', '# Adding new file in ios dir');
-    const diff = await diffFingerprintChangesAsync(
-      fingerprint,
-      '/app',
-      await normalizeOptionsAsync('/app')
-    );
-    expect(diff).toMatchInlineSnapshot(`
-      [
-        {
-          "filePath": "ios",
-          "hash": "a1d299fe057e87bb79dfd0eb6e33cee98d626aa1",
-          "reasons": [
-            "bareNativeDir",
-          ],
-          "type": "dir",
-        },
-      ]
-    `);
-  });
-});

package/src/__tests__/Sort-test.ts

@@ -1,56 +0,0 @@
-import type { FingerprintSource, HashSource } from '../Fingerprint.types';
-import { sortSources } from '../Sort';
-
-describe(sortSources, () => {
-  it(`should sort sources by type in 'file > dir > contents' order`, () => {
-    const sources: HashSource[] = [
-      { type: 'contents', id: 'foo', contents: 'HelloWorld', reasons: ['foo'] },
-      { type: 'file', filePath: '/app/app.json', reasons: ['expoConfig'] },
-      { type: 'dir', filePath: '/app/ios', reasons: ['bareNativeDir'] },
-    ];
-
-    expect(sortSources(sources)).toEqual([
-      { type: 'file', filePath: '/app/app.json', reasons: ['expoConfig'] },
-      { type: 'dir', filePath: '/app/ios', reasons: ['bareNativeDir'] },
-      { type: 'contents', id: 'foo', contents: 'HelloWorld', reasons: ['foo'] },
-    ]);
-  });
-
-  it(`should sort id or filePath when item types are the same`, () => {
-    const sources: HashSource[] = [
-      { type: 'file', filePath: '/app/eas.json', reasons: ['easBuild'] },
-      { type: 'contents', id: 'foo', contents: 'HelloWorld', reasons: ['foo'] },
-      { type: 'dir', filePath: '/app/ios', reasons: ['bareNativeDir'] },
-      { type: 'file', filePath: '/app/app.json', reasons: ['expoConfig'] },
-      { type: 'contents', id: 'bar', contents: 'bartender', reasons: ['bar'] },
-      { type: 'dir', filePath: '/app/android', reasons: ['bareNativeDir'] },
-    ];
-
-    expect(sortSources(sources)).toEqual([
-      { type: 'file', filePath: '/app/app.json', reasons: ['expoConfig'] },
-      { type: 'file', filePath: '/app/eas.json', reasons: ['easBuild'] },
-      { type: 'dir', filePath: '/app/android', reasons: ['bareNativeDir'] },
-      { type: 'dir', filePath: '/app/ios', reasons: ['bareNativeDir'] },
-      { type: 'contents', id: 'bar', contents: 'bartender', reasons: ['bar'] },
-      { type: 'contents', id: 'foo', contents: 'HelloWorld', reasons: ['foo'] },
-    ]);
-  });
-
-  it(`should support both HashSource and FingerprintSource types`, () => {
-    const sources: HashSource[] = [
-      { type: 'contents', id: 'foo', contents: 'HelloWorld', reasons: ['foo'] },
-    ];
-    const fingerprintSources: FingerprintSource[] = [
-      {
-        type: 'contents',
-        id: 'foo',
-        contents: 'HelloWorld',
-        reasons: ['foo'],
-        hash: 'bc9faaae1e35d52f3dea9651da12cd36627b8403',
-      },
-    ];
-
-    expect(sortSources(sources)).toEqual(sources);
-    expect(sortSources(fingerprintSources)).toEqual(fingerprintSources);
-  });
-});

package/src/hash/Hash.ts

@@ -1,203 +0,0 @@
-import { createHash } from 'crypto';
-import { createReadStream } from 'fs';
-import fs from 'fs/promises';
-import pLimit from 'p-limit';
-import path from 'path';
-
-import type {
-  Fingerprint,
-  FingerprintSource,
-  HashResult,
-  HashSource,
-  HashSourceContents,
-  NormalizedOptions,
-} from '../Fingerprint.types';
-import { isIgnoredPath } from '../utils/Path';
-import { profile } from '../utils/Profile';
-
-/**
- * Create a `Fingerprint` from `HashSources` array
- */
-export async function createFingerprintFromSourcesAsync(
-  sources: HashSource[],
-  projectRoot: string,
-  options: NormalizedOptions
-): Promise<Fingerprint> {
-  const limiter = pLimit(options.concurrentIoLimit);
-  const fingerprintSources = await Promise.all(
-    sources.map((source) => createFingerprintSourceAsync(source, limiter, projectRoot, options))
-  );
-
-  const hasher = createHash(options.hashAlgorithm);
-  for (const source of fingerprintSources) {
-    if (source.hash != null) {
-      hasher.update(createSourceId(source));
-      hasher.update(source.hash);
-    }
-  }
-  const hash = hasher.digest('hex');
-
-  return {
-    sources: fingerprintSources,
-    hash,
-  };
-}
-
-/**
- * Create a `FingerprintSource` from a `HashSource`
- * This function will get a hash value and merge back to original source
- */
-export async function createFingerprintSourceAsync(
-  source: HashSource,
-  limiter: pLimit.Limit,
-  projectRoot: string,
-  options: NormalizedOptions
-): Promise<FingerprintSource> {
-  let result: HashResult | null = null;
-  switch (source.type) {
-    case 'contents':
-      result = await createContentsHashResultsAsync(source, options);
-      break;
-    case 'file':
-      result = await createFileHashResultsAsync(source.filePath, limiter, projectRoot, options);
-      break;
-    case 'dir':
-      result = await profile(
-        createDirHashResultsAsync,
-        `createDirHashResultsAsync(${source.filePath})`
-      )(source.filePath, limiter, projectRoot, options);
-      break;
-    default:
-      throw new Error('Unsupported source type');
-  }
-
-  return { ...source, hash: result?.hex ?? null };
-}
-
-/**
- * Create a `HashResult` from a file
- */
-export async function createFileHashResultsAsync(
-  filePath: string,
-  limiter: pLimit.Limit,
-  projectRoot: string,
-  options: NormalizedOptions
-): Promise<HashResult | null> {
-  // Backup code for faster hashing
-  /*
-  return limiter(async () => {
-    if (isIgnoredPath(filePath, options.ignorePaths)) {
-      return null;
-    }
-
-    const hasher = createHash(options.hashAlgorithm);
-
-    const stat = await fs.stat(filePath);
-    hasher.update(`${stat.size}`);
-
-    const buffer = Buffer.alloc(4096);
-    const fd = await fs.open(filePath, 'r');
-    await fd.read(buffer, 0, buffer.length, 0);
-    await fd.close();
-    hasher.update(buffer);
-    console.log('stat', filePath, stat.size);
-    return { id: path.relative(projectRoot, filePath), hex: hasher.digest('hex') };
-  });
-  */
-
-  return limiter(() => {
-    return new Promise<HashResult | null>((resolve, reject) => {
-      if (isIgnoredPath(filePath, options.ignorePaths)) {
-        return resolve(null);
-      }
-
-      let resolved = false;
-      const hasher = createHash(options.hashAlgorithm);
-      const stream = createReadStream(path.join(projectRoot, filePath));
-      stream.on('close', () => {
-        if (!resolved) {
-          const hex = hasher.digest('hex');
-          resolve({ id: filePath, hex });
-          resolved = true;
-        }
-      });
-      stream.on('error', (e) => {
-        reject(e);
-      });
-      stream.on('data', (chunk) => {
-        hasher.update(chunk);
-      });
-    });
-  });
-}
-
-/**
- * Create `HashResult` for a dir.
- * If the dir is excluded, returns null rather than a HashResult
- */
-export async function createDirHashResultsAsync(
-  dirPath: string,
-  limiter: pLimit.Limit,
-  projectRoot: string,
-  options: NormalizedOptions,
-  depth: number = 0
-): Promise<HashResult | null> {
-  if (isIgnoredPath(dirPath, options.ignorePaths)) {
-    return null;
-  }
-  const dirents = (await fs.readdir(path.join(projectRoot, dirPath), { withFileTypes: true })).sort(
-    (a, b) => a.name.localeCompare(b.name)
-  );
-  const promises: Promise<HashResult | null>[] = [];
-  for (const dirent of dirents) {
-    if (dirent.isDirectory()) {
-      const filePath = path.join(dirPath, dirent.name);
-      promises.push(createDirHashResultsAsync(filePath, limiter, projectRoot, options, depth + 1));
-    } else if (dirent.isFile()) {
-      const filePath = path.join(dirPath, dirent.name);
-      promises.push(createFileHashResultsAsync(filePath, limiter, projectRoot, options));
-    }
-  }
-
-  const hasher = createHash(options.hashAlgorithm);
-  const results = (await Promise.all(promises)).filter(
-    (result): result is HashResult => result != null
-  );
-  if (results.length === 0) {
-    return null;
-  }
-  for (const result of results) {
-    hasher.update(result.id);
-    hasher.update(result.hex);
-  }
-  const hex = hasher.digest('hex');
-
-  return { id: dirPath, hex };
-}
-
-/**
- * Create `HashResult` for a `HashSourceContents`
- */
-export async function createContentsHashResultsAsync(
-  source: HashSourceContents,
-  options: NormalizedOptions
-): Promise<HashResult> {
-  const hex = createHash(options.hashAlgorithm).update(source.contents).digest('hex');
-  return { id: source.id, hex };
-}
-
-/**
- * Create id from given source
- */
-export function createSourceId(source: HashSource): string {
-  switch (source.type) {
-    case 'contents':
-      return source.id;
-    case 'file':
-      return source.filePath;
-    case 'dir':
-      return source.filePath;
-    default:
-      throw new Error('Unsupported source type');
-  }
-}