[eas-cli] compute fingerprint on each build (#2663)

* Temporary Commit at 11/4/2024, 4:33:33 PM

* Temporary Commit at 11/5/2024, 4:17:31 PM

* Temporary Commit at 11/5/2024, 4:22:18 PM

CHANGELOG.md

@@ -8,6 +8,8 @@ This is the log of notable changes to EAS CLI and related packages.
 
 ### 🎉 New features
 
+- Compute fingerprint for builds with SDK 52 and higher ([#2663](https://github.com/expo/eas-cli/pull/2663) by [@quinlanj](https://github.com/quinlanj))
+
 ### 🐛 Bug fixes
 
 ### 🧹 Chores

packages/eas-cli/src/build/build.ts

@@ -66,6 +66,7 @@ import { maybeUploadFingerprintAsync } from '../project/maybeUploadFingerprintAs
 import { resolveRuntimeVersionAsync } from '../project/resolveRuntimeVersionAsync';
 import { uploadFileAtPathToGCSAsync } from '../uploads';
 import { formatBytes } from '../utils/files';
+import { createFingerprintAsync } from '../utils/fingerprintCli';
 import { printJsonOnlyOutput } from '../utils/json';
 import { createProgressTracker } from '../utils/progress';
 import { sleepAsync } from '../utils/promise';
@@ -174,8 +175,9 @@ export async function prepareBuildRequestForPlatformAsync<
   }
   assert(projectArchive);
 
-  const runtimeMetadata = await createAndMaybeUploadFingerprintAsync(ctx);
-  const metadata = await collectMetadataAsync(ctx, runtimeMetadata);
+  const runtimeAndFingerprintMetadata =
+    await computeAndMaybeUploadRuntimeAndFingerprintMetadataAsync(ctx);
+  const metadata = await collectMetadataAsync(ctx, runtimeAndFingerprintMetadata);
   const buildParams = resolveBuildParamsInput(ctx, metadata);
   const job = await builder.prepareJobAsync(ctx, {
     projectArchive,
@@ -660,11 +662,38 @@ function formatAccountBillingUrl(accountName: string): string {
   return new URL(`/accounts/${accountName}/settings/billing`, getExpoWebsiteBaseUrl()).toString();
 }
 
-async function createAndMaybeUploadFingerprintAsync<T extends Platform>(
+async function computeAndMaybeUploadRuntimeAndFingerprintMetadataAsync<T extends Platform>(
+  ctx: BuildContext<T>
+): Promise<{
+  runtimeVersion?: string | undefined;
+  fingerprintHash?: string | undefined;
+  fingerprintSource?: FingerprintSource | undefined;
+}> {
+  const runtimeAndFingerprintMetadata =
+    await computeAndMaybeUploadFingerprintFromExpoUpdatesAsync(ctx);
+  if (!runtimeAndFingerprintMetadata?.fingerprint) {
+    const fingerprint = await computeAndMaybeUploadFingerprintWithoutExpoUpdatesAsync(ctx);
+    return {
+      ...runtimeAndFingerprintMetadata,
+      ...fingerprint,
+    };
+  } else {
+    return {
+      ...runtimeAndFingerprintMetadata,
+      fingerprintHash: runtimeAndFingerprintMetadata.runtimeVersion,
+    };
+  }
+}
+
+async function computeAndMaybeUploadFingerprintFromExpoUpdatesAsync<T extends Platform>(
   ctx: BuildContext<T>
 ): Promise<{
   runtimeVersion?: string;
   fingerprintSource?: FingerprintSource;
+  fingerprint?: {
+    fingerprintSources: object[];
+    isDebugFingerprintSource: boolean;
+  };
 }> {
   const resolvedRuntimeVersion = await resolveRuntimeVersionAsync({
     exp: ctx.exp,
@@ -689,10 +718,45 @@ async function createAndMaybeUploadFingerprintAsync<T extends Platform>(
     };
   }
 
-  return await maybeUploadFingerprintAsync({
-    runtimeVersion: resolvedRuntimeVersion.runtimeVersion,
+  const uploadedFingerprint = await maybeUploadFingerprintAsync({
+    hash: resolvedRuntimeVersion.runtimeVersion,
     fingerprint: resolvedRuntimeVersion.fingerprint,
     graphqlClient: ctx.graphqlClient,
     localBuildMode: ctx.localBuildOptions.localBuildMode,
   });
+  return {
+    runtimeVersion: uploadedFingerprint.hash,
+    fingerprintSource: uploadedFingerprint.fingerprintSource,
+    fingerprint: resolvedRuntimeVersion.fingerprint,
+  };
+}
+
+async function computeAndMaybeUploadFingerprintWithoutExpoUpdatesAsync<T extends Platform>(
+  ctx: BuildContext<T>,
+  { debug }: { debug?: boolean } = {}
+): Promise<{
+  fingerprintHash?: string;
+  fingerprintSource?: FingerprintSource;
+}> {
+  const fingerprint = await createFingerprintAsync(ctx.projectDir, {
+    workflow: ctx.workflow,
+    platform: ctx.platform,
+    env: ctx.env,
+  });
+  if (!fingerprint) {
+    return {};
+  }
+  const uploadedFingerprint = await maybeUploadFingerprintAsync({
+    hash: fingerprint.hash,
+    fingerprint: {
+      fingerprintSources: fingerprint.sources,
+      isDebugFingerprintSource: debug ?? false,
+    },
+    graphqlClient: ctx.graphqlClient,
+    localBuildMode: ctx.localBuildOptions.localBuildMode,
+  });
+  return {
+    fingerprintHash: uploadedFingerprint.hash,
+    fingerprintSource: uploadedFingerprint.fingerprintSource,
+  };
 }

packages/eas-cli/src/build/metadata.ts

@@ -16,8 +16,9 @@ import { easCliVersion } from '../utils/easCli';
 
 export async function collectMetadataAsync<T extends Platform>(
   ctx: BuildContext<T>,
-  runtimeMetadata: {
+  runtimeAndFingerprintMetadata: {
     runtimeVersion?: string | undefined;
+    fingerprintHash?: string | undefined;
     fingerprintSource?: FingerprintSource | undefined;
   }
 ): Promise<Metadata> {
@@ -30,8 +31,9 @@ export async function collectMetadataAsync<T extends Platform>(
     workflow: ctx.workflow,
     credentialsSource: ctx.buildProfile.credentialsSource,
     sdkVersion: ctx.exp.sdkVersion,
-    runtimeVersion: runtimeMetadata?.runtimeVersion,
-    fingerprintSource: runtimeMetadata?.fingerprintSource,
+    runtimeVersion: runtimeAndFingerprintMetadata?.runtimeVersion,
+    fingerprintHash: runtimeAndFingerprintMetadata?.fingerprintHash,
+    fingerprintSource: runtimeAndFingerprintMetadata?.fingerprintSource,
     reactNativeVersion: await getReactNativeVersionAsync(ctx.projectDir),
     ...channelObject,
     distribution,

packages/eas-cli/src/commands/update/index.ts

@@ -413,7 +413,7 @@ export default class UpdatePublish extends EasCommand {
           fingerprintSource: info.fingerprint
             ? (
                 await maybeUploadFingerprintAsync({
-                  runtimeVersion: info.runtimeVersion,
+                  hash: info.runtimeVersion,
                   fingerprint: info.fingerprint,
                   graphqlClient,
                 })

packages/eas-cli/src/project/maybeUploadFingerprintAsync.ts

@@ -11,33 +11,33 @@ import { uploadFileAtPathToGCSAsync } from '../uploads';
 import { getTmpDirectory } from '../utils/paths';
 
 export async function maybeUploadFingerprintAsync({
-  runtimeVersion,
+  hash,
   fingerprint,
   graphqlClient,
   localBuildMode,
 }: {
-  runtimeVersion: string;
+  hash: string;
   fingerprint: {
     fingerprintSources: object[];
     isDebugFingerprintSource: boolean;
   };
   graphqlClient: ExpoGraphqlClient;
   localBuildMode?: LocalBuildMode;
 }): Promise<{
-  runtimeVersion: string;
+  hash: string;
   fingerprintSource?: FingerprintSource;
 }> {
   await fs.mkdirp(getTmpDirectory());
   const fingerprintLocation = path.join(getTmpDirectory(), `${uuidv4()}-runtime-fingerprint.json`);
 
   await fs.writeJSON(fingerprintLocation, {
-    hash: runtimeVersion,
+    hash,
     sources: fingerprint.fingerprintSources,
   });
 
   if (localBuildMode === LocalBuildMode.LOCAL_BUILD_PLUGIN) {
     return {
-      runtimeVersion,
+      hash,
       fingerprintSource: {
         type: FingerprintSourceType.PATH,
         path: fingerprintLocation,
@@ -62,14 +62,14 @@ export async function maybeUploadFingerprintAsync({
 
     Log.warn(errMessage);
     return {
-      runtimeVersion,
+      hash,
     };
   } finally {
     await fs.remove(fingerprintLocation);
   }
 
   return {
-    runtimeVersion,
+    hash,
     fingerprintSource: {
       type: FingerprintSourceType.GCS,
       bucketKey: fingerprintGCSBucketKey,

packages/eas-cli/src/utils/fingerprintCli.ts

@@ -0,0 +1,36 @@
+import { Env, Workflow } from '@expo/eas-build-job';
+import { silent as silentResolveFrom } from 'resolve-from';
+
+export async function createFingerprintAsync(
+  projectDir: string,
+  options: {
+    workflow: Workflow;
+    platform: string;
+    debug?: boolean;
+    env: Env | undefined;
+    cwd?: string;
+  }
+): Promise<{
+  hash: string;
+  sources: object[];
+  isDebugSource: boolean;
+} | null> {
+  // @expo/fingerprint is exported in the expo package for SDK 52+
+  const fingerprintPath = silentResolveFrom(projectDir, 'expo/fingerprint');
+  if (!fingerprintPath) {
+    return null;
+  }
+  const Fingerprint = require(fingerprintPath);
+  const fingerprintOptions: Record<string, any> = {};
+  if (options.platform) {
+    fingerprintOptions.platforms = [options.platform];
+  }
+  if (options.workflow === Workflow.MANAGED) {
+    fingerprintOptions.ignorePaths = ['android/**/*', 'ios/**/*'];
+  }
+  if (options.debug) {
+    fingerprintOptions.debug = true;
+  }
+  // eslint-disable-next-line @typescript-eslint/return-await
+  return await Fingerprint.createFingerprintAsync(projectDir, fingerprintOptions);
+}