@expo/fingerprint 0.1.0 → 0.3.0

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

@@ -1,11 +1,12 @@
 import spawnAsync from '@expo/spawn-async';
-import findUp from 'find-up';
+import { getConfig } from 'expo/config';
 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 { HashSourceContents } from '../../Fingerprint.types';
+import { normalizeOptionsAsync } from '../../Options';
 import {
   getEasBuildSourcesAsync,
   getExpoAutolinkingAndroidSourcesAsync,
@@ -55,7 +56,7 @@ describe(getEasBuildSourcesAsync, () => {
 }`
     );
 
-    const sources = await getEasBuildSourcesAsync('/app', normalizeOptions());
+    const sources = await getEasBuildSourcesAsync('/app', await normalizeOptionsAsync('/app'));
     expect(sources).toContainEqual(
       expect.objectContaining({
         type: 'file',
@@ -97,7 +98,10 @@ describe('getExpoAutolinkingSourcesAsync', () => {
   });
 
   it('should contain expo autolinking projects', async () => {
-    let sources = await getExpoAutolinkingAndroidSourcesAsync('/app', normalizeOptions());
+    let sources = await getExpoAutolinkingAndroidSourcesAsync(
+      '/app',
+      await normalizeOptionsAsync('/app')
+    );
     expect(sources).toContainEqual(
       expect.objectContaining({
         type: 'dir',
@@ -106,7 +110,7 @@ describe('getExpoAutolinkingSourcesAsync', () => {
     );
     expect(sources).toMatchSnapshot();
 
-    sources = await getExpoAutolinkingIosSourcesAsync('/app', normalizeOptions());
+    sources = await getExpoAutolinkingIosSourcesAsync('/app', await normalizeOptionsAsync('/app'));
     expect(sources).toContainEqual(
       expect.objectContaining({ type: 'dir', filePath: 'node_modules/expo-modules-core' })
     );
@@ -114,14 +118,17 @@ describe('getExpoAutolinkingSourcesAsync', () => {
   });
 
   it('should not containt absolute path in contents', async () => {
-    let sources = await getExpoAutolinkingAndroidSourcesAsync('/app', normalizeOptions());
+    let sources = await getExpoAutolinkingAndroidSourcesAsync(
+      '/app',
+      await normalizeOptionsAsync('/app')
+    );
     for (const source of sources) {
       if (source.type === 'contents') {
         expect(source.contents.indexOf('/app/')).toBe(-1);
       }
     }
 
-    sources = await getExpoAutolinkingIosSourcesAsync('/app', normalizeOptions());
+    sources = await getExpoAutolinkingIosSourcesAsync('/app', await normalizeOptionsAsync('/app'));
     for (const source of sources) {
       if (source.type === 'contents') {
         expect(source.contents.indexOf('/app/')).toBe(-1);
@@ -141,32 +148,73 @@ describe(getExpoConfigSourcesAsync, () => {
 
   it('should return empty array when expo package is not installed', async () => {
     vol.fromJSON(require('./fixtures/BareReactNative70Project.json'));
-    const mockedResolveFrom = resolveFrom as jest.MockedFunction<typeof resolveFrom>;
+    const mockedResolveFrom = resolveFrom.silent as jest.MockedFunction<typeof resolveFrom.silent>;
     mockedResolveFrom.mockImplementationOnce((fromDirectory: string, moduleId: string) => {
-      const actualResolver = jest.requireActual('resolve-from');
+      const actualResolver = jest.requireActual('resolve-from').silent;
       // To fake the case as no expo installed, trying to resolve as **nonexist/expo/config** module
       return actualResolver(fromDirectory, 'nonexist/expo/config');
     });
-    const sources = await getExpoConfigSourcesAsync('/app', normalizeOptions());
+    const sources = await getExpoConfigSourcesAsync('/app', await normalizeOptionsAsync('/app'));
     expect(sources.length).toBe(0);
   });
 
-  it('should contain app.json', async () => {
+  it('should contain expo config', async () => {
     vol.fromJSON(require('./fixtures/ExpoManaged47Project.json'));
-    const sources = await getExpoConfigSourcesAsync('/app', normalizeOptions());
-    expect(sources).toContainEqual(
-      expect.objectContaining({
-        type: 'file',
-        filePath: 'app.json',
-      })
+    const appJson = JSON.parse(vol.readFileSync('/app/app.json', 'utf8').toString());
+    const sources = await getExpoConfigSourcesAsync('/app', await normalizeOptionsAsync('/app'));
+    const expoConfigSource = sources.find<HashSourceContents>(
+      (source): source is HashSourceContents =>
+        source.type === 'contents' && source.id === 'expoConfig'
     );
+    const expoConfig = JSON.parse(expoConfigSource?.contents?.toString() ?? 'null');
+    expect(expoConfig).not.toBeNull();
+    expect(expoConfig.name).toEqual(appJson.expo.name);
+  });
+
+  it('should not contain runtimeVersion in expo config', async () => {
+    vol.fromJSON(require('./fixtures/ExpoManaged47Project.json'));
+    vol.writeFileSync(
+      '/app/app.config.js',
+      `\
+export default ({ config }) => {
+  config.runtimeVersion = '1.0.0';
+  return config;
+};`
+    );
+    const sources = await getExpoConfigSourcesAsync('/app', await normalizeOptionsAsync('/app'));
+    const expoConfigSource = sources.find<HashSourceContents>(
+      (source): source is HashSourceContents =>
+        source.type === 'contents' && source.id === 'expoConfig'
+    );
+    const expoConfig = JSON.parse(expoConfigSource?.contents?.toString() ?? 'null');
+    expect(expoConfig).not.toBeNull();
+    expect(expoConfig.runtimeVersion).toBeUndefined();
+  });
+
+  it('should keep expo config contents in deterministic order', async () => {
+    vol.fromJSON(require('./fixtures/ExpoManaged47Project.json'));
+    const sources = await getExpoConfigSourcesAsync('/app', await normalizeOptionsAsync('/app'));
+
+    const appJsonContents = vol.readFileSync('/app/app.json', 'utf8').toString();
+    const appJson = JSON.parse(appJsonContents);
+    const { name } = appJson.expo;
+    // Re-insert name to change the object order
+    delete appJson.expo.name;
+    appJson.expo.name = name;
+    const newAppJsonContents = JSON.stringify(appJson);
+    expect(newAppJsonContents).not.toEqual(appJsonContents);
+    vol.writeFileSync('/app/app.json', newAppJsonContents);
+
+    // Even new app.json contents changed its order, the source contents should be the same.
+    const sources2 = await getExpoConfigSourcesAsync('/app', await normalizeOptionsAsync('/app'));
+    expect(sources).toEqual(sources2);
   });
 
   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());
+    const sources = await getExpoConfigSourcesAsync('/app', await normalizeOptionsAsync('/app'));
     expect(sources).toContainEqual(
       expect.objectContaining({
         type: 'file',
@@ -174,108 +222,39 @@ describe(getExpoConfigSourcesAsync, () => {
       })
     );
   });
-});
-
-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);
+  it('should contain extra files from config plugins', async () => {
     vol.fromJSON(require('./fixtures/ExpoManaged47Project.json'));
-    baseAppJson = JSON.parse(vol.readFileSync('/app/app.json', 'utf8').toString());
-  });
-
-  afterEach(() => {
-    vol.reset();
-    const mockResolveFrom = resolveFrom.silent as jest.MockedFunction<typeof resolveFrom.silent>;
-    mockResolveFrom.mockReset();
-  });
-
-  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());
+    const config = await getConfig('/app', { skipSDKVersionRequirement: true });
+    const mockSpawnAsync = spawnAsync as jest.MockedFunction<typeof spawnAsync>;
+    const stdout = JSON.stringify({
+      config,
+      loadedModules: [
+        'node_modules/third-party/index.js',
+        'node_modules/third-party/node_modules/transitive-third-party/index.js',
+      ],
+    });
+    mockSpawnAsync.mockResolvedValueOnce({
+      output: [],
+      stdout,
+      stderr: '',
+      signal: null,
+      status: 0,
+    });
+    const sources = await getExpoConfigSourcesAsync('/app', await normalizeOptionsAsync('/app'));
     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' }]],
-        },
+        type: 'file',
+        filePath: 'node_modules/third-party/index.js',
       })
     );
-    const sources = await getExpoConfigSourcesAsync('/app', normalizeOptions());
     expect(sources).toContainEqual(
       expect.objectContaining({
-        type: 'dir',
-        filePath: 'node_modules/third-party',
+        type: 'file',
+        filePath: 'node_modules/third-party/node_modules/transitive-third-party/index.js',
       })
     );
   });
-
-  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);
-  });
 });
 
 describe('sortExpoAutolinkingConfig', () => {

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

@@ -1,9 +1,11 @@
 import { vol } from 'memfs';
 
-import { normalizeOptions } from '../../Options';
+import { normalizeOptionsAsync } from '../../Options';
 import { getPatchPackageSourcesAsync } from '../PatchPackage';
 import { getHashSourcesAsync } from '../Sourcer';
 
+jest.mock('@expo/spawn-async');
+jest.mock('fs');
 jest.mock('fs/promises');
 jest.mock('/app/package.json', () => ({}), { virtual: true });
 
@@ -16,7 +18,7 @@ describe(getPatchPackageSourcesAsync, () => {
     vol.fromJSON(require('./fixtures/ExpoManaged47Project.json'));
     vol.fromJSON(require('./fixtures/PatchPackage.json'));
 
-    const sources = await getPatchPackageSourcesAsync('/app', normalizeOptions());
+    const sources = await getPatchPackageSourcesAsync('/app', await normalizeOptionsAsync('/app'));
     expect(sources).toContainEqual(
       expect.objectContaining({
         type: 'dir',
@@ -28,6 +30,7 @@ describe(getPatchPackageSourcesAsync, () => {
 
 describe('patch-package postinstall', () => {
   it('should contain `package.json` scripts block for lifecycle patches', async () => {
+    vol.fromJSON(require('./fixtures/ExpoManaged47Project.json'));
     const scriptsBlock = {
       postinstall: 'npx patch-package',
     };
@@ -41,7 +44,7 @@ describe('patch-package postinstall', () => {
       { virtual: true }
     );
 
-    const sources = await getHashSourcesAsync('/app', normalizeOptions());
+    const sources = await getHashSourcesAsync('/app', await normalizeOptionsAsync('/app'));
     expect(sources).toContainEqual(
       expect.objectContaining({
         type: 'contents',

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

@@ -1,11 +1,18 @@
-import { normalizeOptions } from '../../Options';
+import { vol } from 'memfs';
+
+import { normalizeOptionsAsync } from '../../Options';
 import { getHashSourcesAsync } from '../Sourcer';
 
+jest.mock('@expo/spawn-async');
+jest.mock('fs');
+jest.mock('fs/promises');
+
 describe(getHashSourcesAsync, () => {
   it('should include `extraSources` from input parameter', async () => {
+    vol.fromJSON(require('./fixtures/ExpoManaged47Project.json'));
     const sources = await getHashSourcesAsync(
       '/app',
-      normalizeOptions({
+      await normalizeOptionsAsync('/app', {
         extraSources: [{ type: 'dir', filePath: '/app/scripts', reasons: ['extra'] }],
       })
     );

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

@@ -0,0 +1,41 @@
+import { stringifyJsonSorted } from '../Utils';
+
+describe(stringifyJsonSorted, () => {
+  it('should support primitive types', () => {
+    expect(stringifyJsonSorted(1)).toEqual('1');
+    expect(stringifyJsonSorted('s')).toEqual('"s"');
+    expect(stringifyJsonSorted(true)).toEqual('true');
+    expect(stringifyJsonSorted(false)).toEqual('false');
+    expect(stringifyJsonSorted(null)).toEqual('null');
+  });
+
+  it('should sort array', () => {
+    expect(stringifyJsonSorted([])).toEqual('[]');
+    expect(stringifyJsonSorted([2, 'a', 1, false, 6, 4, 5, 's', 3, 0, true, 1, 1])).toEqual(
+      '["a","s",0,1,1,1,2,3,4,5,6,false,true]'
+    );
+  });
+
+  it('should sort object by keys', () => {
+    expect(stringifyJsonSorted({})).toEqual('{}');
+    expect(stringifyJsonSorted({ c: '1', a: '3', b: '2' })).toEqual('{"a":"3","b":"2","c":"1"}');
+    expect(
+      stringifyJsonSorted({ c: '1', a: '3', b: '2', nested: { c: '1', a: '3', b: '2' } })
+    ).toEqual('{"a":"3","b":"2","c":"1","nested":{"a":"3","b":"2","c":"1"}}');
+  });
+
+  it('should support mixed array/object', () => {
+    expect(stringifyJsonSorted([{ b: '2' }, { c: '1' }, { a: '3' }])).toEqual(
+      '[{"a":"3"},{"b":"2"},{"c":"1"}]'
+    );
+    expect(stringifyJsonSorted([{ b: '2' }, {}, { a: '3' }, null])).toEqual(
+      '[null,{"a":"3"},{"b":"2"},{}]'
+    );
+    expect(
+      stringifyJsonSorted({
+        array: [3, 2, 1],
+        nestedData: { nestedArray: [{ b: '2' }, { c: '1' }, { a: '3' }] },
+      })
+    ).toEqual('{"array":[1,2,3],"nestedData":{"nestedArray":[{"a":"3"},{"b":"2"},{"c":"1"}]}}');
+  });
+});

package/src/utils/Path.ts

@@ -0,0 +1,26 @@
+import minimatch from 'minimatch';
+
+/**
+ * Indicate the given `filePath` should be excluded by `ignorePaths`
+ */
+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 result;
+}

package/src/utils/__tests__/Path-test.ts

@@ -0,0 +1,36 @@
+import { isIgnoredPath } from '../Path';
+
+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);
+  });
+});