[eas-cli] add support for build profiles in fingerprint generation

Author: quinlanj

packages/eas-cli/src/commands/fingerprint/compare.ts

@@ -440,7 +440,8 @@ export async function getFingerprintInfoFromLocalProjectForPlatformsAsync(
   projectDir: string,
   projectId: string,
   vcsClient: Client,
-  platforms: AppPlatform[]
+  platforms: AppPlatform[],
+  { env }: { env?: Record<string, string> } = {}
 ): Promise<Fingerprint> {
   const workflows = await resolveWorkflowPerPlatformAsync(projectDir, vcsClient);
   const optionsFromWorkflow = getFingerprintOptionsFromWorkflow(platforms, workflows);
@@ -449,7 +450,7 @@ export async function getFingerprintInfoFromLocalProjectForPlatformsAsync(
     ...optionsFromWorkflow,
     platforms: platforms.map(appPlatformToString),
     debug: true,
-    env: undefined,
+    env,
   });
   if (!projectFingerprint) {
     throw new Error('Project fingerprints can only be computed for projects with SDK 52 or higher');

packages/eas-cli/src/commands/fingerprint/generate.ts

@@ -1,33 +1,41 @@
+import { Env, Platform } from '@expo/eas-build-job';
+import { EasJsonAccessor } from '@expo/eas-json';
 import { Flags } from '@oclif/core';
 
 import {
   getFingerprintInfoFromLocalProjectForPlatformsAsync,
   stringToAppPlatform,
 } from './compare';
 import { getExpoWebsiteBaseUrl } from '../../api';
+import { evaluateConfigWithEnvVarsAsync } from '../../build/evaluateConfigWithEnvVarsAsync';
 import EasCommand from '../../commandUtils/EasCommand';
 import { EasNonInteractiveAndJsonFlags } from '../../commandUtils/flags';
 import { AppPlatform } from '../../graphql/generated';
 import { AppQuery } from '../../graphql/queries/AppQuery';
 import Log, { link } from '../../log';
 import { promptAsync } from '../../prompts';
 import { enableJsonOutput, printJsonOnlyOutput } from '../../utils/json';
+import { getProfilesAsync } from '../../utils/profiles';
 
 export default class FingerprintGenerate extends EasCommand {
   static override description = 'generate fingerprints from the current project';
   static override strict = false;
   static override hidden = true;
 
   static override examples = [
-    '$ eas fingerprint:generate',
-    '$ eas fingerprint:generate --json --non-interactive -p android',
+    '$ eas fingerprint:generate  \t # Generate fingerprint in interactive mode',
+    '$ eas fingerprint:generate --json --non-interactive --platform android  \t # Output fingerprint json to stdout',
   ];
 
   static override flags = {
     platform: Flags.enum({
       char: 'p',
       options: ['android', 'ios'],
     }),
+    profile: Flags.string({
+      char: 'e',
+      description: 'Name of the build profile from eas.json.',
+    }),
     ...EasNonInteractiveAndJsonFlags,
   };
 
@@ -36,17 +44,24 @@ export default class FingerprintGenerate extends EasCommand {
     ...this.ContextOptions.ProjectConfig,
     ...this.ContextOptions.LoggedIn,
     ...this.ContextOptions.Vcs,
+    ...this.ContextOptions.DynamicProjectConfig,
   };
 
   async runAsync(): Promise<void> {
     const { flags } = await this.parse(FingerprintGenerate);
-    const { json, 'non-interactive': nonInteractive, platform: platformStringFlag } = flags;
+    const {
+      json,
+      'non-interactive': nonInteractive,
+      platform: platformStringFlag,
+      profile: buildProfileName,
+    } = flags;
 
     const {
       projectId,
       privateProjectConfig: { projectDir },
       loggedIn: { graphqlClient },
       vcsClient,
+      getDynamicPrivateProjectConfigAsync,
     } = await this.getContextAsync(FingerprintGenerate, {
       nonInteractive,
       withServerSideEnvironment: null,
@@ -64,12 +79,39 @@ export default class FingerprintGenerate extends EasCommand {
       }
       platform = await selectRequestedPlatformAsync();
     }
+
+    let env: Env | undefined;
+    if (buildProfileName) {
+      const easJsonAccessor = EasJsonAccessor.fromProjectPath(projectDir);
+      const buildProfile = (
+        await getProfilesAsync({
+          type: 'build',
+          easJsonAccessor,
+          platforms: [appPlatformtoPlatform(platform)],
+          profileName: buildProfileName ?? undefined,
+          projectDir,
+        })
+      )[0];
+      if (!buildProfile) {
+        throw new Error(`Build profile ${buildProfile} not found for platform: ${platform}`);
+      }
+      const configResult = await evaluateConfigWithEnvVarsAsync({
+        buildProfile: buildProfile.profile,
+        buildProfileName: buildProfile.profileName,
+        graphqlClient,
+        getProjectConfig: getDynamicPrivateProjectConfigAsync,
+        opts: { env: buildProfile.profile.env },
+      });
+      env = configResult.env;
+    }
+
     const fingerprint = await getFingerprintInfoFromLocalProjectForPlatformsAsync(
       graphqlClient,
       projectDir,
       projectId,
       vcsClient,
-      [platform]
+      [platform],
+      { env }
     );
 
     if (json) {
@@ -101,3 +143,13 @@ export async function selectRequestedPlatformAsync(): Promise<AppPlatform> {
   });
   return requestedPlatform;
 }
+
+function appPlatformtoPlatform(appPlatform: AppPlatform): Platform {
+  if (appPlatform === AppPlatform.Android) {
+    return Platform.ANDROID;
+  } else if (appPlatform === AppPlatform.Ios) {
+    return Platform.IOS;
+  } else {
+    throw new Error('Unsupported platform: ' + appPlatform);
+  }
+}

packages/eas-cli/src/platform.ts

@@ -64,7 +64,7 @@ export async function selectPlatformAsync(platform?: string): Promise<Platform>
   return resolvedPlatform;
 }
 
-export function toPlatforms(requestedPlatform: RequestedPlatform): Platform[] {
+export function toPlatform(requestedPlatform: RequestedPlatform): Platform[] {
   if (requestedPlatform === RequestedPlatform.All) {
     return [Platform.ANDROID, Platform.IOS];
   } else if (requestedPlatform === RequestedPlatform.Android) {

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

@@ -104,7 +104,20 @@ async function createFingerprintWithoutLoggingAsync(
     fingerprintOptions.debug = true;
   }
   // eslint-disable-next-line @typescript-eslint/return-await
-  return await Fingerprint.createFingerprintAsync(projectDir, fingerprintOptions);
+  return await withTemporaryEnv(
+    options.env ?? {},
+    Fingerprint.createFingerprintAsync(projectDir, fingerprintOptions)
+  );
+}
+
+function withTemporaryEnv(envVars: Env, fn: () => Promise<any>): Promise<any> {
+  const originalEnv = { ...process.env };
+
+  Object.assign(process.env, envVars);
+
+  return fn().finally(() => {
+    process.env = originalEnv;
+  });
 }
 
 /**