@expo/fingerprint 0.1.0 → 0.2.0

package/src/__tests__/Fingerprint-test.ts

@@ -2,7 +2,7 @@ import { vol } from 'memfs';
 
 import { createFingerprintAsync, diffFingerprintChangesAsync } from '../Fingerprint';
 import type { Fingerprint } from '../Fingerprint.types';
-import { normalizeOptions } from '../Options';
+import { normalizeOptionsAsync } from '../Options';
 
 jest.mock('fs');
 jest.mock('fs/promises');
@@ -15,8 +15,12 @@ describe(diffFingerprintChangesAsync, () => {
 
   it('should return empty array when fingerprint matched', async () => {
     vol.fromJSON(require('../sourcer/__tests__/fixtures/ExpoManaged47Project.json'));
-    const fingerprint = await createFingerprintAsync('/app', normalizeOptions());
-    const diff = await diffFingerprintChangesAsync(fingerprint, '/app', normalizeOptions());
+    const fingerprint = await createFingerprintAsync('/app', await normalizeOptionsAsync('/app'));
+    const diff = await diffFingerprintChangesAsync(
+      fingerprint,
+      '/app',
+      await normalizeOptionsAsync('/app')
+    );
     expect(diff.length).toBe(0);
   });
 
@@ -27,16 +31,21 @@ describe(diffFingerprintChangesAsync, () => {
       hash: '',
     };
 
-    const diff = await diffFingerprintChangesAsync(fingerprint, '/app', normalizeOptions());
+    const diff = await diffFingerprintChangesAsync(
+      fingerprint,
+      '/app',
+      await normalizeOptionsAsync('/app')
+    );
     expect(diff).toMatchInlineSnapshot(`
       [
         {
-          "filePath": "app.json",
-          "hash": "1fd2d92d50dc1da96b41795046b9ea4e30dd2b48",
+          "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": "file",
+          "type": "contents",
         },
       ]
     `);
@@ -46,19 +55,27 @@ describe(diffFingerprintChangesAsync, () => {
     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', normalizeOptions());
+    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', normalizeOptions());
+    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', normalizeOptions());
+    diff = await diffFingerprintChangesAsync(
+      fingerprint,
+      '/app',
+      await normalizeOptionsAsync('/app')
+    );
     jest.dontMock('/app/package.json');
     expect(diff).toMatchInlineSnapshot(`
       [
@@ -77,20 +94,25 @@ describe(diffFingerprintChangesAsync, () => {
 
   it('should return diff from file changes', async () => {
     vol.fromJSON(require('../sourcer/__tests__/fixtures/ExpoManaged47Project.json'));
-    const fingerprint = await createFingerprintAsync('/app', normalizeOptions());
+    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', normalizeOptions());
+    const diff = await diffFingerprintChangesAsync(
+      fingerprint,
+      '/app',
+      await normalizeOptionsAsync('/app')
+    );
     expect(diff).toMatchInlineSnapshot(`
       [
         {
-          "filePath": "app.json",
-          "hash": "9ff1b51ca9b9435e8b849bcc82e3900d70f0feee",
+          "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": "file",
+          "type": "contents",
         },
       ]
     `);
@@ -98,9 +120,13 @@ describe(diffFingerprintChangesAsync, () => {
 
   it('should return diff from dir changes', async () => {
     vol.fromJSON(require('../sourcer/__tests__/fixtures/BareReactNative70Project.json'));
-    const fingerprint = await createFingerprintAsync('/app', normalizeOptions());
+    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', normalizeOptions());
+    const diff = await diffFingerprintChangesAsync(
+      fingerprint,
+      '/app',
+      await normalizeOptionsAsync('/app')
+    );
     expect(diff).toMatchInlineSnapshot(`
       [
         {

package/src/hash/Hash.ts

@@ -82,10 +82,14 @@ export async function createFileHashResultsAsync(
   limiter: pLimit.Limit,
   projectRoot: string,
   options: NormalizedOptions
-): Promise<HashResult> {
+): 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);
@@ -102,7 +106,11 @@ export async function createFileHashResultsAsync(
   */
 
   return limiter(() => {
-    return new Promise<HashResult>((resolve, reject) => {
+    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));
@@ -124,15 +132,28 @@ export async function createFileHashResultsAsync(
 }
 
 /**
- * Indicate the given `dirPath` should be excluded by `dirExcludes`
+ * Indicate the given `filePath` should be excluded by `ignorePaths`
  */
-function isExcludedDir(dirPath: string, dirExcludes: string[]): boolean {
-  for (const exclude of dirExcludes) {
-    if (minimatch(dirPath, exclude)) {
-      return true;
+export function isIgnoredPath(
+  filePath: string,
+  ignorePaths: string[],
+  minimatchOptions: minimatch.IOptions = { dot: true }
+): boolean {
+  const minimatchObjs = ignorePaths.map(
+    (ignorePath) => new minimatch.Minimatch(ignorePath, minimatchOptions)
+  );
+
+  let result = false;
+  for (const minimatchObj of minimatchObjs) {
+    const currMatch = minimatchObj.match(filePath);
+    if (minimatchObj.negate && result && !currMatch) {
+      // Special handler for negate (!pattern).
+      // As long as previous match result is true and not matched from the current negate pattern, we should early return.
+      return false;
     }
+    result ||= currMatch;
   }
-  return false;
+  return result;
 }
 
 /**
@@ -146,7 +167,7 @@ export async function createDirHashResultsAsync(
   options: NormalizedOptions,
   depth: number = 0
 ): Promise<HashResult | null> {
-  if (isExcludedDir(dirPath, options.dirExcludes)) {
+  if (isIgnoredPath(dirPath, options.ignorePaths)) {
     return null;
   }
   const dirents = (await fs.readdir(path.join(projectRoot, dirPath), { withFileTypes: true })).sort(
@@ -164,12 +185,15 @@ export async function createDirHashResultsAsync(
   }
 
   const hasher = createHash(options.hashAlgorithm);
-  const results = await Promise.all(promises);
+  const results = (await Promise.all(promises)).filter(
+    (result): result is HashResult => result != null
+  );
+  if (results.length === 0) {
+    return null;
+  }
   for (const result of results) {
-    if (result != null) {
-      hasher.update(result.id);
-      hasher.update(result.hex);
-    }
+    hasher.update(result.id);
+    hasher.update(result.hex);
   }
   const hex = hasher.digest('hex');
 

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,
@@ -12,6 +12,7 @@ import {
   createFingerprintFromSourcesAsync,
   createFingerprintSourceAsync,
   createSourceId,
+  isIgnoredPath,
 } from '../Hash';
 
 jest.mock('fs');
@@ -23,18 +24,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 +50,10 @@ describe(createFingerprintFromSourcesAsync, () => {
             "type": "contents",
           },
           {
-            "filePath": "app.json",
+            "filePath": "assets/icon.png",
             "hash": "bf21a9e8fbc5a3846fb05b4fa0859e0917b2202f",
             "reasons": [
-              "expoConfig",
+              "icon",
             ],
             "type": "file",
           },
@@ -72,7 +76,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 +90,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 +113,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 +149,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 +163,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': '{}',
@@ -190,3 +237,38 @@ describe(createSourceId, () => {
     expect(createSourceId(source)).toBe('foo');
   });
 });
+
+describe(isIgnoredPath, () => {
+  it('should support file pattern', () => {
+    expect(isIgnoredPath('app.json', ['app.json'])).toBe(true);
+    expect(isIgnoredPath('app.ts', ['*.{js,ts}'])).toBe(true);
+    expect(isIgnoredPath('/dir/app.json', ['/dir/*.json'])).toBe(true);
+  });
+
+  it('should support directory pattern', () => {
+    expect(isIgnoredPath('/app/ios/Podfile', ['**/ios/**/*'])).toBe(true);
+  });
+
+  it('case sensitive by design', () => {
+    expect(isIgnoredPath('app.json', ['APP.JSON'])).toBe(false);
+  });
+
+  it('should include dot files from wildcard pattern', () => {
+    expect(isIgnoredPath('.bashrc', ['*'])).toBe(true);
+  });
+
+  it('no `matchBase` and `partial` by design', () => {
+    expect(isIgnoredPath('/dir/app.json', ['app.json'])).toBe(false);
+  });
+
+  it('match a file inside a dir should use a globstar', () => {
+    expect(isIgnoredPath('/dir/app.ts', ['*'])).toBe(false);
+    expect(isIgnoredPath('/dir/app.ts', ['**/*'])).toBe(true);
+  });
+
+  it('should use `!` to override default ignorePaths', () => {
+    const ignorePaths = ['**/ios/**/*', '!**/ios/Podfile', '**/android/**/*'];
+    expect(isIgnoredPath('/app/ios/Podfile', ignorePaths)).toBe(false);
+    expect(isIgnoredPath('/app/ios/Podfile.lock', ignorePaths)).toBe(true);
+  });
+});

package/src/sourcer/Expo.ts

@@ -6,7 +6,7 @@ import findUp from 'find-up';
 import path from 'path';
 import resolveFrom from 'resolve-from';
 
-import { getFileBasedHashSourceAsync } from './Utils';
+import { getFileBasedHashSourceAsync, stringifyJsonSorted } from './Utils';
 import type { HashSource, NormalizedOptions } from '../Fingerprint.types';
 
 const debug = require('debug')('expo:fingerprint:sourcer:Expo');
@@ -15,32 +15,23 @@ export async function getExpoConfigSourcesAsync(
   projectRoot: string,
   options: NormalizedOptions
 ): Promise<HashSource[]> {
+  const results: HashSource[] = [];
+
   let config: ProjectConfig;
   try {
     const { getConfig } = require(resolveFrom(path.resolve(projectRoot), 'expo/config'));
     config = await getConfig(projectRoot, { skipSDKVersionRequirement: true });
+    results.push({
+      type: 'contents',
+      id: 'expoConfig',
+      contents: normalizeExpoConfig(config.exp),
+      reasons: ['expoConfig'],
+    });
   } 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');
@@ -99,6 +90,14 @@ function findUpPluginRoot(entryFile: string): string {
   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']

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/);