Use credentials types from eas-build-job where possible

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

@@ -6,7 +6,6 @@ import { transformJob } from './graphql';
 import { prepareJobAsync } from './prepareJob';
 import { syncProjectConfigurationAsync } from './syncProjectConfiguration';
 import { resolveRemoteBuildNumberAsync } from './version';
-import { IosCredentials } from '../../credentials/ios/types';
 import { BuildParamsInput } from '../../graphql/generated';
 import { BuildMutation, BuildResult } from '../../graphql/mutations/BuildMutation';
 import { ensureBundleIdentifierIsDefinedForManagedProjectAsync } from '../../project/ios/bundleIdentifier';
@@ -94,7 +93,7 @@ export async function prepareIosBuildAsync(
     },
     prepareJobAsync: async (
       ctx: BuildContext<Platform.IOS>,
-      jobData: JobData<IosCredentials>
+      jobData: JobData<Ios.BuildCredentials>
     ): Promise<Job> => {
       return await prepareJobAsync(ctx, {
         ...jobData,

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

@@ -1,18 +1,18 @@
-import { Platform } from '@expo/eas-build-job';
+import { Ios, Platform } from '@expo/eas-build-job';
 import { BuildProfile } from '@expo/eas-json';
 
 import { CredentialsContext } from '../../credentials/context';
 import IosCredentialsProvider from '../../credentials/ios/IosCredentialsProvider';
 import { getAppFromContextAsync } from '../../credentials/ios/actions/BuildCredentialsUtils';
-import { IosCredentials, Target } from '../../credentials/ios/types';
+import { Target } from '../../credentials/ios/types';
 import { CredentialsResult } from '../build';
 import { BuildContext } from '../context';
 import { logCredentialsSource } from '../utils/credentials';
 
 export async function ensureIosCredentialsAsync(
   buildCtx: BuildContext<Platform.IOS>,
   targets: Target[]
-): Promise<CredentialsResult<IosCredentials> | undefined> {
+): Promise<CredentialsResult<Ios.BuildCredentials> | undefined> {
   if (!shouldProvideCredentials(buildCtx)) {
     return;
   }
@@ -37,7 +37,7 @@ export async function ensureIosCredentialsForBuildResignAsync(
   credentialsCtx: CredentialsContext,
   targets: Target[],
   buildProfile: BuildProfile<Platform.IOS>
-): Promise<CredentialsResult<IosCredentials>> {
+): Promise<CredentialsResult<Ios.BuildCredentials>> {
   const provider = new IosCredentialsProvider(credentialsCtx, {
     app: await getAppFromContextAsync(credentialsCtx),
     targets,

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

@@ -12,15 +12,14 @@ import nullthrows from 'nullthrows';
 import path from 'path';
 import slash from 'slash';
 
-import { IosCredentials, TargetCredentials } from '../../credentials/ios/types';
 import { IosJobSecretsInput } from '../../graphql/generated';
 import { getCustomBuildConfigPath } from '../../project/customBuildConfig';
 import { getUsername } from '../../project/projectUtils';
 import { BuildContext } from '../context';
 
 interface JobData {
   projectArchive: ArchiveSource;
-  credentials?: IosCredentials;
+  credentials?: Ios.BuildCredentials;
   buildScheme: string;
 }
 
@@ -41,7 +40,7 @@ export async function prepareJobAsync(
   if (jobData.credentials) {
     const targetNames = Object.keys(jobData.credentials);
     for (const targetName of targetNames) {
-      buildCredentials[targetName] = prepareTargetCredentials(jobData.credentials[targetName]);
+      buildCredentials[targetName] = jobData.credentials[targetName];
     }
   }
 
@@ -102,28 +101,18 @@ export async function prepareJobAsync(
   return sanitizeJob(job);
 }
 
-export function prepareCredentialsToResign(credentials: IosCredentials): IosJobSecretsInput {
+export function prepareCredentialsToResign(credentials: Ios.BuildCredentials): IosJobSecretsInput {
   const buildCredentials: IosJobSecretsInput['buildCredentials'] = [];
   for (const targetName of Object.keys(credentials ?? {})) {
     buildCredentials.push({
       targetName,
-      provisioningProfileBase64: nullthrows(credentials?.[targetName].provisioningProfile),
+      provisioningProfileBase64: nullthrows(credentials?.[targetName].provisioningProfileBase64),
       distributionCertificate: {
-        dataBase64: nullthrows(credentials?.[targetName].distributionCertificate.certificateP12),
-        password: nullthrows(credentials?.[targetName].distributionCertificate.certificatePassword),
+        dataBase64: nullthrows(credentials?.[targetName].distributionCertificate.dataBase64),
+        password: nullthrows(credentials?.[targetName].distributionCertificate.password),
       },
     });
   }
 
   return { buildCredentials };
 }
-
-function prepareTargetCredentials(targetCredentials: TargetCredentials): Ios.TargetCredentials {
-  return {
-    provisioningProfileBase64: targetCredentials.provisioningProfile,
-    distributionCertificate: {
-      dataBase64: targetCredentials.distributionCertificate.certificateP12,
-      password: targetCredentials.distributionCertificate.certificatePassword,
-    },
-  };
-}

packages/eas-cli/src/credentials/credentialsJson/read.ts

@@ -1,14 +1,12 @@
+import { Ios } from '@expo/eas-build-job';
 import fs from 'fs-extra';
 import path from 'path';
 
 import {
   AndroidCredentials,
   CredentialsJson,
-  CredentialsJsonIosCredentials,
   CredentialsJsonIosTargetCredentials,
   CredentialsJsonSchema,
-  IosCredentials,
-  IosTargetCredentials,
 } from './types';
 import { getCredentialsJsonPath } from './utils';
 import { Target } from '../ios/types';
@@ -32,15 +30,15 @@ export async function readAndroidCredentialsAsync(projectDir: string): Promise<A
 export async function readIosCredentialsAsync(
   projectDir: string,
   applicationTarget: Target
-): Promise<IosCredentials> {
+): Promise<Ios.BuildCredentials> {
   const credentialsJson = await readAsync(projectDir);
   if (!credentialsJson.ios) {
     throw new Error('iOS credentials are missing in credentials.json');
   }
 
   if (isCredentialsMap(credentialsJson.ios)) {
     const targets = Object.keys(credentialsJson.ios);
-    const iosCredentials: IosCredentials = {};
+    const iosCredentials: Ios.BuildCredentials = {};
     for (const target of targets) {
       iosCredentials[target] = await readCredentialsForTargetAsync(
         projectDir,
@@ -60,26 +58,26 @@ export async function readIosCredentialsAsync(
 }
 
 function isCredentialsMap(
-  ios: CredentialsJsonIosTargetCredentials | CredentialsJsonIosCredentials
-): ios is CredentialsJsonIosCredentials {
+  ios: Exclude<CredentialsJson['ios'], undefined>
+): ios is Record<string, CredentialsJsonIosTargetCredentials> {
   return typeof ios.provisioningProfilePath !== 'string';
 }
 
 async function readCredentialsForTargetAsync(
   projectDir: string,
   targetCredentials: CredentialsJsonIosTargetCredentials
-): Promise<IosTargetCredentials> {
+): Promise<Ios.TargetCredentials> {
   return {
-    provisioningProfile: await fs.readFile(
+    provisioningProfileBase64: await fs.readFile(
       getAbsolutePath(projectDir, targetCredentials.provisioningProfilePath),
       'base64'
     ),
     distributionCertificate: {
-      certificateP12: await fs.readFile(
+      dataBase64: await fs.readFile(
         getAbsolutePath(projectDir, targetCredentials.distributionCertificate.path),
         'base64'
       ),
-      certificatePassword: targetCredentials.distributionCertificate.password,
+      password: targetCredentials.distributionCertificate.password,
     },
   };
 }

packages/eas-cli/src/credentials/credentialsJson/types.ts

@@ -2,51 +2,39 @@ import Joi from 'joi';
 
 import { Keystore } from '../android/credentials';
 
-export interface CredentialsJson {
-  android?: CredentialsJsonAndroidCredentials;
-  ios?: CredentialsJsonIosTargetCredentials | CredentialsJsonIosCredentials;
-}
-
-export interface CredentialsJsonAndroidCredentials {
-  keystore: {
-    keystorePath: string;
-    keystorePassword: string;
-    keyAlias: string;
-    keyPassword?: string;
-  };
-}
-
 export interface CredentialsJsonIosTargetCredentials {
   provisioningProfilePath: string;
   distributionCertificate: {
     path: string;
     password: string;
   };
 }
-export type CredentialsJsonIosCredentials = Record<string, CredentialsJsonIosTargetCredentials>;
 
 export interface AndroidCredentials {
   keystore: Keystore;
 }
 
-export interface IosTargetCredentials {
-  provisioningProfile: string;
-  distributionCertificate: {
-    certificateP12: string;
-    certificatePassword: string;
-  };
-}
-export type IosCredentials = Record<string, IosTargetCredentials>;
-
-const CredentialsJsonIosTargetCredentialsSchema = Joi.object({
+const CredentialsJsonIosTargetCredentialsSchema = Joi.object<CredentialsJsonIosTargetCredentials>({
   provisioningProfilePath: Joi.string().required(),
   distributionCertificate: Joi.object({
     path: Joi.string().required(),
     password: Joi.string().allow('').required(),
   }).required(),
 });
 
-export const CredentialsJsonSchema = Joi.object({
+export type CredentialsJson = {
+  android?: {
+    keystore: {
+      keystorePath: string;
+      keystorePassword: string;
+      keyAlias: string;
+      keyPassword?: string;
+    };
+  };
+  ios?: CredentialsJsonIosTargetCredentials | Record<string, CredentialsJsonIosTargetCredentials>;
+};
+
+export const CredentialsJsonSchema = Joi.object<CredentialsJson>({
   android: Joi.object({
     keystore: Joi.object({
       keystorePath: Joi.string().required(),

packages/eas-cli/src/credentials/credentialsJson/update.ts

@@ -1,13 +1,10 @@
+import { Ios } from '@expo/eas-build-job';
 import fs from 'fs-extra';
 import nullthrows from 'nullthrows';
 import path from 'path';
 
 import { readRawAsync } from './read';
-import {
-  CredentialsJson,
-  CredentialsJsonIosCredentials,
-  CredentialsJsonIosTargetCredentials,
-} from './types';
+import { CredentialsJson, CredentialsJsonIosTargetCredentials } from './types';
 import { getCredentialsJsonPath } from './utils';
 import { AndroidAppBuildCredentialsFragment, IosDistributionType } from '../../graphql/generated';
 import Log from '../../log';
@@ -16,7 +13,7 @@ import zipObject from '../../utils/expodash/zipObject';
 import GitClient from '../../vcs/clients/git';
 import { Client } from '../../vcs/vcs';
 import { CredentialsContext } from '../context';
-import { App, Target, TargetCredentials } from '../ios/types';
+import { App, Target } from '../ios/types';
 
 /**
  * Update Android credentials.json with values from www, content of credentials.json
@@ -112,7 +109,7 @@ export async function updateIosCredentialsAsync(
     throw new Error(errorMessage);
   }
 
-  const iosCredentials: CredentialsJsonIosCredentials = {};
+  const iosCredentials: CredentialsJson['ios'] = {};
   const targetCredentialsPathsMap = createTargetCredentialsPathsMap(
     targets,
     rawCredentialsJson.ios
@@ -209,7 +206,7 @@ async function getTargetBuildCredentialsAsync(
   app: App,
   target: Target,
   iosDistributionType: IosDistributionType
-): Promise<TargetCredentials | null> {
+): Promise<Ios.TargetCredentials | null> {
   const appCredentials = await ctx.ios.getIosAppCredentialsWithCommonFieldsAsync(
     ctx.graphqlClient,
     {
@@ -237,12 +234,12 @@ async function getTargetBuildCredentialsAsync(
   }
   return {
     distributionCertificate: {
-      certificateP12: nullthrows(appBuildCredentials.distributionCertificate.certificateP12),
-      certificatePassword: nullthrows(
-        appBuildCredentials.distributionCertificate.certificatePassword
-      ),
+      dataBase64: nullthrows(appBuildCredentials.distributionCertificate.certificateP12),
+      password: nullthrows(appBuildCredentials.distributionCertificate.certificatePassword),
     },
-    provisioningProfile: nullthrows(appBuildCredentials.provisioningProfile.provisioningProfile),
+    provisioningProfileBase64: nullthrows(
+      appBuildCredentials.provisioningProfile.provisioningProfile
+    ),
   };
 }
 
@@ -252,7 +249,7 @@ async function backupTargetCredentialsAsync(
     targetCredentials,
     targetCredentialsPaths,
   }: {
-    targetCredentials: TargetCredentials;
+    targetCredentials: Ios.TargetCredentials;
     targetCredentialsPaths: TargetCredentialsPaths;
   }
 ): Promise<CredentialsJsonIosTargetCredentials> {
@@ -262,20 +259,20 @@ async function backupTargetCredentialsAsync(
   await updateFileAsync(
     ctx.projectDir,
     provisioningProfilePath,
-    targetCredentials.provisioningProfile
+    targetCredentials.provisioningProfileBase64
   );
 
   Log.log(`Writing Distribution Certificate to ${distCertPath}`);
   await updateFileAsync(
     ctx.projectDir,
     distCertPath,
-    targetCredentials.distributionCertificate.certificateP12
+    targetCredentials.distributionCertificate.dataBase64
   );
 
   return {
     distributionCertificate: {
       path: distCertPath,
-      password: targetCredentials.distributionCertificate.certificatePassword,
+      password: targetCredentials.distributionCertificate.password,
     },
     provisioningProfilePath,
   };

packages/eas-cli/src/credentials/credentialsJson/utils.ts

@@ -1,6 +1,6 @@
+import { Ios } from '@expo/eas-build-job';
 import path from 'path';
 
-import { IosCredentials } from './types';
 import { Target } from '../ios/types';
 
 export function getCredentialsJsonPath(projectDir: string): string {
@@ -9,7 +9,7 @@ export function getCredentialsJsonPath(projectDir: string): string {
 
 export function ensureAllTargetsAreConfigured(
   targets: Target[],
-  credentialsJson: IosCredentials
+  credentialsJson: Ios.BuildCredentials
 ): void {
   const notConfiguredTargets: string[] = [];
   for (const target of targets) {