@donotuse/eas-cli 18.5.0-rc.1

package/build/credentials/ios/actions/SetUpTargetBuildCredentialsFromCredentialsJson.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetUpTargetBuildCredentialsFromCredentialsJson = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const BuildCredentialsUtils_1 = require("./BuildCredentialsUtils");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const prompts_1 = require("../../../prompts");
+const printCredentials_1 = require("../utils/printCredentials");
+const provisioningProfile_1 = require("../utils/provisioningProfile");
+class SetUpTargetBuildCredentialsFromCredentialsJson {
+    app;
+    distributionType;
+    targetCredentials;
+    constructor(app, distributionType, targetCredentials) {
+        this.app = app;
+        this.distributionType = distributionType;
+        this.targetCredentials = targetCredentials;
+    }
+    async runAsync(ctx) {
+        // currently configured credentials
+        const buildCredentials = await (0, BuildCredentialsUtils_1.getBuildCredentialsAsync)(ctx, this.app, this.distributionType);
+        const currentDistributionCertificate = await (0, BuildCredentialsUtils_1.getDistributionCertificateAsync)(ctx, this.app, this.distributionType);
+        const currentProfile = await (0, BuildCredentialsUtils_1.getProvisioningProfileAsync)(ctx, this.app, this.distributionType);
+        const appInfo = `@${this.app.account.name}/${this.app.projectName} (${this.app.bundleIdentifier})`;
+        // new credentials from local json
+        const appleTeamFromProvisioningProfile = (0, provisioningProfile_1.readAppleTeam)(this.targetCredentials.provisioningProfile);
+        const appleTeam = await ctx.ios.createOrGetExistingAppleTeamAndUpdateNameIfChangedAsync(ctx.graphqlClient, this.app.account.id, {
+            appleTeamIdentifier: appleTeamFromProvisioningProfile.teamId,
+            appleTeamName: appleTeamFromProvisioningProfile.teamName,
+        });
+        const distributionCertificateToAssign = await this.getDistributionCertificateToAssignAsync(ctx, appleTeam, currentDistributionCertificate);
+        const provisioningProfileToAssign = await this.getProvisioningProfileToAssignAsync(ctx, appleTeam, currentProfile);
+        const didCredentialsChange = !currentDistributionCertificate ||
+            !currentProfile ||
+            currentDistributionCertificate.id !== distributionCertificateToAssign.id ||
+            currentProfile.id !== provisioningProfileToAssign.id;
+        if (!didCredentialsChange) {
+            log_1.default.log('Credentials have already been configured to your credentials json.');
+            return (0, nullthrows_1.default)(buildCredentials, 'buildCredentials should have been defined.');
+        }
+        if (buildCredentials) {
+            log_1.default.log('Currently configured credentials:');
+            displaySingleTargetProjectCredentials(this.app, buildCredentials);
+            if (!ctx.nonInteractive) {
+                const confirm = await (0, prompts_1.confirmAsync)({
+                    message: `Would you like to replace this configuration with credentials from credentials json?`,
+                });
+                if (!confirm) {
+                    throw new Error('Aborting setup of build credentials from credentials json');
+                }
+            }
+        }
+        log_1.default.log(`Assigning credentials from credentials json to ${appInfo}...`);
+        const newBuildCredentials = await (0, BuildCredentialsUtils_1.assignBuildCredentialsAsync)(ctx, this.app, this.distributionType, distributionCertificateToAssign, provisioningProfileToAssign, appleTeam);
+        log_1.default.log('New credentials configuration:');
+        displaySingleTargetProjectCredentials(this.app, newBuildCredentials);
+        log_1.default.newLine();
+        log_1.default.log(chalk_1.default.green(`All credentials are ready to build ${appInfo}`));
+        log_1.default.newLine();
+        return newBuildCredentials;
+    }
+    async getDistributionCertificateToAssignAsync(ctx, appleTeam, currentDistributionCertificate) {
+        const { certificateP12, certificatePassword } = this.targetCredentials.distributionCertificate;
+        if (!currentDistributionCertificate) {
+            return await ctx.ios.createDistributionCertificateAsync(ctx.graphqlClient, this.app.account, {
+                certP12: certificateP12,
+                certPassword: certificatePassword,
+                teamId: appleTeam.appleTeamIdentifier,
+                teamName: appleTeam.appleTeamName ?? undefined,
+            });
+        }
+        const isSameCertificate = currentDistributionCertificate.certificateP12 === certificateP12;
+        if (!isSameCertificate) {
+            return await ctx.ios.createDistributionCertificateAsync(ctx.graphqlClient, this.app.account, {
+                certP12: certificateP12,
+                certPassword: certificatePassword,
+                teamId: appleTeam.appleTeamIdentifier,
+                teamName: appleTeam.appleTeamName ?? undefined,
+            });
+        }
+        // If the configured Distribution Certificate is the same as the new one, just use the currently configured certificate
+        return currentDistributionCertificate;
+    }
+    async getProvisioningProfileToAssignAsync(ctx, appleTeam, currentProvisioningProfile) {
+        const { provisioningProfile } = this.targetCredentials;
+        if (!currentProvisioningProfile) {
+            return await this.createNewProvisioningProfileAsync(ctx, appleTeam);
+        }
+        const isSameProfile = currentProvisioningProfile.provisioningProfile === provisioningProfile;
+        if (!isSameProfile) {
+            return await this.createNewProvisioningProfileAsync(ctx, appleTeam);
+        }
+        // If the configured Provisioning Profile is the same as the new one, just use the currently configured profile
+        return currentProvisioningProfile;
+    }
+    async createNewProvisioningProfileAsync(ctx, appleTeam) {
+        const { provisioningProfile } = this.targetCredentials;
+        const appleAppIdentifier = await ctx.ios.createOrGetExistingAppleAppIdentifierAsync(ctx.graphqlClient, this.app, appleTeam);
+        return await ctx.ios.createProvisioningProfileAsync(ctx.graphqlClient, this.app, appleAppIdentifier, {
+            appleProvisioningProfile: provisioningProfile,
+        });
+    }
+}
+exports.SetUpTargetBuildCredentialsFromCredentialsJson = SetUpTargetBuildCredentialsFromCredentialsJson;
+function displaySingleTargetProjectCredentials(app, buildCredentials) {
+    const targetName = app.projectName;
+    (0, printCredentials_1.displayProjectCredentials)(app, { [targetName]: buildCredentials }, [
+        { targetName, bundleIdentifier: app.bundleIdentifier },
+    ]);
+}

package/build/credentials/ios/actions/UpdateCredentialsJson.d.ts

@@ -0,0 +1,10 @@
+import { IosDistributionType } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+import { App, Target } from '../types';
+export declare class UpdateCredentialsJson {
+    private readonly app;
+    private readonly targets;
+    private readonly distributionType;
+    constructor(app: App, targets: Target[], distributionType: IosDistributionType);
+    runAsync(ctx: CredentialsContext): Promise<void>;
+}

package/build/credentials/ios/actions/UpdateCredentialsJson.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateCredentialsJson = void 0;
+const tslib_1 = require("tslib");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const update_1 = require("../../credentialsJson/update");
+class UpdateCredentialsJson {
+    app;
+    targets;
+    distributionType;
+    constructor(app, targets, distributionType) {
+        this.app = app;
+        this.targets = targets;
+        this.distributionType = distributionType;
+    }
+    async runAsync(ctx) {
+        log_1.default.log('Updating iOS credentials in credentials.json');
+        await (0, update_1.updateIosCredentialsAsync)(ctx, this.app, this.targets, this.distributionType);
+        log_1.default.succeed('iOS part of your local credentials.json is synced with values stored on EAS servers.');
+    }
+}
+exports.UpdateCredentialsJson = UpdateCredentialsJson;

package/build/credentials/ios/api/GraphqlClient.d.ts

@@ -0,0 +1,60 @@
+import { AppleDistributionCertificateMutationResult } from './graphql/mutations/AppleDistributionCertificateMutation';
+import { AppleProvisioningProfileMutationResult } from './graphql/mutations/AppleProvisioningProfileMutation';
+import { AppleProvisioningProfileQueryResult } from './graphql/queries/AppleProvisioningProfileQuery';
+import { AppLookupParams } from './graphql/types/AppLookupParams';
+import { ExpoGraphqlClient } from '../../../commandUtils/context/contextUtils/createGraphqlClient';
+import { AccountFragment, AppStoreConnectApiKeyFragment, AppleAppIdentifierFragment, AppleDeviceFragment, AppleDistributionCertificateFragment, ApplePushKeyFragment, AppleTeamFragment, CommonIosAppCredentialsFragment, IosAppBuildCredentialsFragment, IosDistributionType } from '../../../graphql/generated';
+import { DistributionCertificate, PushKey } from '../appstore/Credentials.types';
+import { MinimalAscApiKey } from '../credentials';
+export declare function createOrUpdateIosAppBuildCredentialsAsync(graphqlClient: ExpoGraphqlClient, appLookupParams: AppLookupParams, { appleTeam, appleAppIdentifierId, iosDistributionType, appleProvisioningProfileId, appleDistributionCertificateId, }: {
+    appleTeam: AppleTeamFragment;
+    appleAppIdentifierId: string;
+    iosDistributionType: IosDistributionType;
+    appleProvisioningProfileId: string;
+    appleDistributionCertificateId: string;
+}): Promise<IosAppBuildCredentialsFragment>;
+export declare function getIosAppCredentialsWithBuildCredentialsAsync(graphqlClient: ExpoGraphqlClient, appLookupParams: AppLookupParams, { iosDistributionType }: {
+    iosDistributionType?: IosDistributionType;
+}): Promise<CommonIosAppCredentialsFragment | null>;
+export declare function getIosAppCredentialsWithCommonFieldsAsync(graphqlClient: ExpoGraphqlClient, appLookupParams: AppLookupParams): Promise<CommonIosAppCredentialsFragment | null>;
+export declare function createOrGetIosAppCredentialsWithCommonFieldsAsync(graphqlClient: ExpoGraphqlClient, appLookupParams: AppLookupParams, { appleTeam, }: {
+    appleTeam?: AppleTeamFragment;
+}): Promise<CommonIosAppCredentialsFragment>;
+export declare function updateIosAppCredentialsAsync(graphqlClient: ExpoGraphqlClient, appCredentials: CommonIosAppCredentialsFragment, { applePushKeyId, ascApiKeyIdForSubmissions, }: {
+    applePushKeyId?: string;
+    ascApiKeyIdForSubmissions?: string;
+}): Promise<CommonIosAppCredentialsFragment>;
+export declare function createOrGetExistingAppleTeamAndUpdateNameIfChangedAsync(graphqlClient: ExpoGraphqlClient, accountId: string, { appleTeamIdentifier, appleTeamName }: {
+    appleTeamIdentifier: string;
+    appleTeamName?: string;
+}): Promise<AppleTeamFragment>;
+export declare function createOrGetExistingAppleAppIdentifierAsync(graphqlClient: ExpoGraphqlClient, { account, projectName, bundleIdentifier, parentBundleIdentifier }: AppLookupParams, appleTeam: AppleTeamFragment | null): Promise<AppleAppIdentifierFragment>;
+export declare function getDevicesForAppleTeamAsync(graphqlClient: ExpoGraphqlClient, { account }: AppLookupParams, { appleTeamIdentifier }: AppleTeamFragment, { useCache }?: {
+    useCache?: boolean;
+}): Promise<AppleDeviceFragment[]>;
+export declare function createProvisioningProfileAsync(graphqlClient: ExpoGraphqlClient, { account }: AppLookupParams, appleAppIdentifier: AppleAppIdentifierFragment, appleProvisioningProfileInput: {
+    appleProvisioningProfile: string;
+    developerPortalIdentifier?: string;
+}): Promise<AppleProvisioningProfileMutationResult>;
+export declare function getProvisioningProfileAsync(graphqlClient: ExpoGraphqlClient, appLookupParams: AppLookupParams, iosDistributionType: IosDistributionType, { appleTeam }?: {
+    appleTeam: AppleTeamFragment | null;
+}): Promise<AppleProvisioningProfileQueryResult | null>;
+export declare function updateProvisioningProfileAsync(graphqlClient: ExpoGraphqlClient, appleProvisioningProfileId: string, appleProvisioningProfileInput: {
+    appleProvisioningProfile: string;
+    developerPortalIdentifier?: string;
+}): Promise<AppleProvisioningProfileMutationResult>;
+export declare function deleteProvisioningProfilesAsync(graphqlClient: ExpoGraphqlClient, appleProvisioningProfileIds: string[]): Promise<void>;
+export declare function getDistributionCertificateForAppAsync(graphqlClient: ExpoGraphqlClient, appLookupParams: AppLookupParams, iosDistributionType: IosDistributionType, { appleTeam }?: {
+    appleTeam: AppleTeamFragment | null;
+}): Promise<AppleDistributionCertificateFragment | null>;
+export declare function getDistributionCertificatesForAccountAsync(graphqlClient: ExpoGraphqlClient, account: AccountFragment): Promise<AppleDistributionCertificateFragment[]>;
+export declare function createDistributionCertificateAsync(graphqlClient: ExpoGraphqlClient, account: AccountFragment, distCert: DistributionCertificate): Promise<AppleDistributionCertificateMutationResult>;
+export declare function deleteDistributionCertificateAsync(graphqlClient: ExpoGraphqlClient, distributionCertificateId: string): Promise<void>;
+export declare function createPushKeyAsync(graphqlClient: ExpoGraphqlClient, account: AccountFragment, pushKey: PushKey): Promise<ApplePushKeyFragment>;
+export declare function getPushKeysForAccountAsync(graphqlClient: ExpoGraphqlClient, account: AccountFragment): Promise<ApplePushKeyFragment[]>;
+export declare function getPushKeyForAppAsync(graphqlClient: ExpoGraphqlClient, appLookupParams: AppLookupParams): Promise<ApplePushKeyFragment | null>;
+export declare function deletePushKeyAsync(graphqlClient: ExpoGraphqlClient, pushKeyId: string): Promise<void>;
+export declare function createAscApiKeyAsync(graphqlClient: ExpoGraphqlClient, account: AccountFragment, ascApiKey: MinimalAscApiKey): Promise<AppStoreConnectApiKeyFragment>;
+export declare function getAscApiKeysForAccountAsync(graphqlClient: ExpoGraphqlClient, account: AccountFragment): Promise<AppStoreConnectApiKeyFragment[]>;
+export declare function getAscApiKeyForAppSubmissionsAsync(graphqlClient: ExpoGraphqlClient, appLookupParams: AppLookupParams): Promise<AppStoreConnectApiKeyFragment | null>;
+export declare function deleteAscApiKeyAsync(graphqlClient: ExpoGraphqlClient, ascApiKeyId: string): Promise<void>;

package/build/credentials/ios/api/GraphqlClient.js

@@ -0,0 +1,300 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOrUpdateIosAppBuildCredentialsAsync = createOrUpdateIosAppBuildCredentialsAsync;
+exports.getIosAppCredentialsWithBuildCredentialsAsync = getIosAppCredentialsWithBuildCredentialsAsync;
+exports.getIosAppCredentialsWithCommonFieldsAsync = getIosAppCredentialsWithCommonFieldsAsync;
+exports.createOrGetIosAppCredentialsWithCommonFieldsAsync = createOrGetIosAppCredentialsWithCommonFieldsAsync;
+exports.updateIosAppCredentialsAsync = updateIosAppCredentialsAsync;
+exports.createOrGetExistingAppleTeamAndUpdateNameIfChangedAsync = createOrGetExistingAppleTeamAndUpdateNameIfChangedAsync;
+exports.createOrGetExistingAppleAppIdentifierAsync = createOrGetExistingAppleAppIdentifierAsync;
+exports.getDevicesForAppleTeamAsync = getDevicesForAppleTeamAsync;
+exports.createProvisioningProfileAsync = createProvisioningProfileAsync;
+exports.getProvisioningProfileAsync = getProvisioningProfileAsync;
+exports.updateProvisioningProfileAsync = updateProvisioningProfileAsync;
+exports.deleteProvisioningProfilesAsync = deleteProvisioningProfilesAsync;
+exports.getDistributionCertificateForAppAsync = getDistributionCertificateForAppAsync;
+exports.getDistributionCertificatesForAccountAsync = getDistributionCertificatesForAccountAsync;
+exports.createDistributionCertificateAsync = createDistributionCertificateAsync;
+exports.deleteDistributionCertificateAsync = deleteDistributionCertificateAsync;
+exports.createPushKeyAsync = createPushKeyAsync;
+exports.getPushKeysForAccountAsync = getPushKeysForAccountAsync;
+exports.getPushKeyForAppAsync = getPushKeyForAppAsync;
+exports.deletePushKeyAsync = deletePushKeyAsync;
+exports.createAscApiKeyAsync = createAscApiKeyAsync;
+exports.getAscApiKeysForAccountAsync = getAscApiKeysForAccountAsync;
+exports.getAscApiKeyForAppSubmissionsAsync = getAscApiKeyForAppSubmissionsAsync;
+exports.deleteAscApiKeyAsync = deleteAscApiKeyAsync;
+const tslib_1 = require("tslib");
+const apple_utils_1 = require("@expo/apple-utils");
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const AppStoreConnectApiKeyMutation_1 = require("./graphql/mutations/AppStoreConnectApiKeyMutation");
+const AppleAppIdentifierMutation_1 = require("./graphql/mutations/AppleAppIdentifierMutation");
+const AppleDistributionCertificateMutation_1 = require("./graphql/mutations/AppleDistributionCertificateMutation");
+const AppleProvisioningProfileMutation_1 = require("./graphql/mutations/AppleProvisioningProfileMutation");
+const ApplePushKeyMutation_1 = require("./graphql/mutations/ApplePushKeyMutation");
+const AppleTeamMutation_1 = require("./graphql/mutations/AppleTeamMutation");
+const IosAppBuildCredentialsMutation_1 = require("./graphql/mutations/IosAppBuildCredentialsMutation");
+const IosAppCredentialsMutation_1 = require("./graphql/mutations/IosAppCredentialsMutation");
+const AppStoreConnectApiKeyQuery_1 = require("./graphql/queries/AppStoreConnectApiKeyQuery");
+const AppleAppIdentifierQuery_1 = require("./graphql/queries/AppleAppIdentifierQuery");
+const AppleDeviceQuery_1 = require("./graphql/queries/AppleDeviceQuery");
+const AppleDistributionCertificateQuery_1 = require("./graphql/queries/AppleDistributionCertificateQuery");
+const AppleProvisioningProfileQuery_1 = require("./graphql/queries/AppleProvisioningProfileQuery");
+const ApplePushKeyQuery_1 = require("./graphql/queries/ApplePushKeyQuery");
+const AppleTeamQuery_1 = require("./graphql/queries/AppleTeamQuery");
+const IosAppCredentialsQuery_1 = require("./graphql/queries/IosAppCredentialsQuery");
+const generated_1 = require("../../../graphql/generated");
+const AppQuery_1 = require("../../../graphql/queries/AppQuery");
+const bundleIdentifier_1 = require("../../../project/ios/bundleIdentifier");
+const errors_1 = require("../errors");
+async function getAppAsync(graphqlClient, appLookupParams) {
+    const projectFullName = formatProjectFullName(appLookupParams);
+    return await AppQuery_1.AppQuery.byFullNameAsync(graphqlClient, projectFullName);
+}
+async function createOrUpdateIosAppBuildCredentialsAsync(graphqlClient, appLookupParams, { appleTeam, appleAppIdentifierId, iosDistributionType, appleProvisioningProfileId, appleDistributionCertificateId, }) {
+    const iosAppCredentials = await createOrGetExistingIosAppCredentialsWithBuildCredentialsAsync(graphqlClient, appLookupParams, {
+        appleTeam,
+        appleAppIdentifierId,
+        iosDistributionType,
+    });
+    const iosAppBuildCredentials = iosAppCredentials.iosAppBuildCredentialsList?.[0];
+    if (!iosAppBuildCredentials) {
+        return await IosAppBuildCredentialsMutation_1.IosAppBuildCredentialsMutation.createIosAppBuildCredentialsAsync(graphqlClient, {
+            iosDistributionType,
+            distributionCertificateId: appleDistributionCertificateId,
+            provisioningProfileId: appleProvisioningProfileId,
+        }, iosAppCredentials.id);
+    }
+    else {
+        await IosAppBuildCredentialsMutation_1.IosAppBuildCredentialsMutation.setDistributionCertificateAsync(graphqlClient, iosAppBuildCredentials.id, appleDistributionCertificateId);
+        return await IosAppBuildCredentialsMutation_1.IosAppBuildCredentialsMutation.setProvisioningProfileAsync(graphqlClient, iosAppBuildCredentials.id, appleProvisioningProfileId);
+    }
+}
+async function getIosAppCredentialsWithBuildCredentialsAsync(graphqlClient, appLookupParams, { iosDistributionType }) {
+    const { account, bundleIdentifier } = appLookupParams;
+    const appleAppIdentifier = await AppleAppIdentifierQuery_1.AppleAppIdentifierQuery.byBundleIdentifierAsync(graphqlClient, account.name, bundleIdentifier);
+    if (!appleAppIdentifier) {
+        return null;
+    }
+    const projectFullName = formatProjectFullName(appLookupParams);
+    return await IosAppCredentialsQuery_1.IosAppCredentialsQuery.withBuildCredentialsByAppIdentifierIdAsync(graphqlClient, projectFullName, {
+        appleAppIdentifierId: appleAppIdentifier.id,
+        iosDistributionType,
+    });
+}
+async function getIosAppCredentialsWithCommonFieldsAsync(graphqlClient, appLookupParams) {
+    const { account, bundleIdentifier } = appLookupParams;
+    const appleAppIdentifier = await AppleAppIdentifierQuery_1.AppleAppIdentifierQuery.byBundleIdentifierAsync(graphqlClient, account.name, bundleIdentifier);
+    if (!appleAppIdentifier) {
+        return null;
+    }
+    const projectFullName = formatProjectFullName(appLookupParams);
+    return await IosAppCredentialsQuery_1.IosAppCredentialsQuery.withCommonFieldsByAppIdentifierIdAsync(graphqlClient, projectFullName, {
+        appleAppIdentifierId: appleAppIdentifier.id,
+    });
+}
+async function createOrGetIosAppCredentialsWithCommonFieldsAsync(graphqlClient, appLookupParams, { appleTeam, }) {
+    const maybeIosAppCredentials = await getIosAppCredentialsWithCommonFieldsAsync(graphqlClient, appLookupParams);
+    if (maybeIosAppCredentials) {
+        return maybeIosAppCredentials;
+    }
+    const [app, appleAppIdentifier] = await Promise.all([
+        getAppAsync(graphqlClient, appLookupParams),
+        createOrGetExistingAppleAppIdentifierAsync(graphqlClient, appLookupParams, appleTeam ?? null),
+    ]);
+    return await IosAppCredentialsMutation_1.IosAppCredentialsMutation.createIosAppCredentialsAsync(graphqlClient, { appleTeamId: appleTeam?.id }, app.id, appleAppIdentifier.id);
+}
+async function updateIosAppCredentialsAsync(graphqlClient, appCredentials, { applePushKeyId, ascApiKeyIdForSubmissions, }) {
+    let updatedAppCredentials = appCredentials;
+    if (applePushKeyId) {
+        updatedAppCredentials = await IosAppCredentialsMutation_1.IosAppCredentialsMutation.setPushKeyAsync(graphqlClient, updatedAppCredentials.id, applePushKeyId);
+    }
+    if (ascApiKeyIdForSubmissions) {
+        updatedAppCredentials =
+            await IosAppCredentialsMutation_1.IosAppCredentialsMutation.setAppStoreConnectApiKeyForSubmissionsAsync(graphqlClient, updatedAppCredentials.id, ascApiKeyIdForSubmissions);
+    }
+    return updatedAppCredentials;
+}
+async function createOrGetExistingIosAppCredentialsWithBuildCredentialsAsync(graphqlClient, appLookupParams, { appleTeam, appleAppIdentifierId, iosDistributionType, }) {
+    const maybeIosAppCredentials = await getIosAppCredentialsWithBuildCredentialsAsync(graphqlClient, appLookupParams, {
+        iosDistributionType,
+    });
+    if (maybeIosAppCredentials) {
+        return maybeIosAppCredentials;
+    }
+    else {
+        const [app, appleAppIdentifier] = await Promise.all([
+            getAppAsync(graphqlClient, appLookupParams),
+            createOrGetExistingAppleAppIdentifierAsync(graphqlClient, appLookupParams, appleTeam ?? null),
+        ]);
+        await IosAppCredentialsMutation_1.IosAppCredentialsMutation.createIosAppCredentialsAsync(graphqlClient, { appleTeamId: appleTeam?.id }, app.id, appleAppIdentifier.id);
+        const projectFullName = formatProjectFullName(appLookupParams);
+        return (0, nullthrows_1.default)(await IosAppCredentialsQuery_1.IosAppCredentialsQuery.withBuildCredentialsByAppIdentifierIdAsync(graphqlClient, projectFullName, {
+            appleAppIdentifierId,
+            iosDistributionType,
+        }));
+    }
+}
+async function createOrGetExistingAppleTeamAndUpdateNameIfChangedAsync(graphqlClient, accountId, { appleTeamIdentifier, appleTeamName }) {
+    const appleTeam = await AppleTeamQuery_1.AppleTeamQuery.getByAppleTeamIdentifierAsync(graphqlClient, accountId, appleTeamIdentifier);
+    if (appleTeam) {
+        const didAppleTeamNameChange = appleTeamName && appleTeam && appleTeamName !== appleTeam.appleTeamName;
+        if (didAppleTeamNameChange) {
+            return await AppleTeamMutation_1.AppleTeamMutation.updateAppleTeamAsync(graphqlClient, {
+                appleTeamName,
+            }, appleTeam.id);
+        }
+        return appleTeam;
+    }
+    else {
+        return await AppleTeamMutation_1.AppleTeamMutation.createAppleTeamAsync(graphqlClient, { appleTeamIdentifier, appleTeamName }, accountId);
+    }
+}
+async function createOrGetExistingAppleAppIdentifierAsync(graphqlClient, { account, projectName, bundleIdentifier, parentBundleIdentifier }, appleTeam) {
+    const appleAppIdentifier = await AppleAppIdentifierQuery_1.AppleAppIdentifierQuery.byBundleIdentifierAsync(graphqlClient, account.name, bundleIdentifier);
+    if (appleAppIdentifier) {
+        return appleAppIdentifier;
+    }
+    else {
+        if ((0, bundleIdentifier_1.isWildcardBundleIdentifier)(bundleIdentifier) && !appleTeam) {
+            throw new errors_1.AppleTeamMissingError(`An Apple Team is required for wildcard bundle identifier: ${bundleIdentifier}`);
+        }
+        const parentAppleAppIdentifier = parentBundleIdentifier
+            ? await createOrGetExistingAppleAppIdentifierAsync(graphqlClient, { account, projectName, bundleIdentifier: parentBundleIdentifier }, appleTeam)
+            : null;
+        return await AppleAppIdentifierMutation_1.AppleAppIdentifierMutation.createAppleAppIdentifierAsync(graphqlClient, {
+            bundleIdentifier,
+            appleTeamId: appleTeam?.id,
+            parentAppleAppId: parentAppleAppIdentifier?.id,
+        }, account.id);
+    }
+}
+async function getDevicesForAppleTeamAsync(graphqlClient, { account }, { appleTeamIdentifier }, { useCache = true } = {}) {
+    return await AppleDeviceQuery_1.AppleDeviceQuery.getAllByAppleTeamIdentifierAsync(graphqlClient, account.name, appleTeamIdentifier, {
+        useCache,
+    });
+}
+async function createProvisioningProfileAsync(graphqlClient, { account }, appleAppIdentifier, appleProvisioningProfileInput) {
+    return await AppleProvisioningProfileMutation_1.AppleProvisioningProfileMutation.createAppleProvisioningProfileAsync(graphqlClient, appleProvisioningProfileInput, account.id, appleAppIdentifier.id);
+}
+async function getProvisioningProfileAsync(graphqlClient, appLookupParams, iosDistributionType, { appleTeam } = { appleTeam: null }) {
+    const projectFullName = formatProjectFullName(appLookupParams);
+    const appleAppIdentifier = await createOrGetExistingAppleAppIdentifierAsync(graphqlClient, appLookupParams, appleTeam);
+    return await AppleProvisioningProfileQuery_1.AppleProvisioningProfileQuery.getForAppAsync(graphqlClient, projectFullName, {
+        appleAppIdentifierId: appleAppIdentifier.id,
+        iosDistributionType,
+    });
+}
+async function updateProvisioningProfileAsync(graphqlClient, appleProvisioningProfileId, appleProvisioningProfileInput) {
+    return await AppleProvisioningProfileMutation_1.AppleProvisioningProfileMutation.updateAppleProvisioningProfileAsync(graphqlClient, appleProvisioningProfileId, appleProvisioningProfileInput);
+}
+async function deleteProvisioningProfilesAsync(graphqlClient, appleProvisioningProfileIds) {
+    await AppleProvisioningProfileMutation_1.AppleProvisioningProfileMutation.deleteAppleProvisioningProfilesAsync(graphqlClient, appleProvisioningProfileIds);
+}
+async function getDistributionCertificateForAppAsync(graphqlClient, appLookupParams, iosDistributionType, { appleTeam } = { appleTeam: null }) {
+    const projectFullName = formatProjectFullName(appLookupParams);
+    const appleAppIdentifier = await createOrGetExistingAppleAppIdentifierAsync(graphqlClient, appLookupParams, appleTeam);
+    return await AppleDistributionCertificateQuery_1.AppleDistributionCertificateQuery.getForAppAsync(graphqlClient, projectFullName, {
+        appleAppIdentifierId: appleAppIdentifier.id,
+        iosDistributionType,
+    });
+}
+async function getDistributionCertificatesForAccountAsync(graphqlClient, account) {
+    return await AppleDistributionCertificateQuery_1.AppleDistributionCertificateQuery.getAllForAccountAsync(graphqlClient, account.name);
+}
+async function createDistributionCertificateAsync(graphqlClient, account, distCert) {
+    const appleTeam = await createOrGetExistingAppleTeamAndUpdateNameIfChangedAsync(graphqlClient, account.id, {
+        appleTeamIdentifier: distCert.teamId,
+        appleTeamName: distCert.teamName,
+    });
+    return await AppleDistributionCertificateMutation_1.AppleDistributionCertificateMutation.createAppleDistributionCertificateAsync(graphqlClient, {
+        certP12: distCert.certP12,
+        certPassword: distCert.certPassword,
+        certPrivateSigningKey: distCert.certPrivateSigningKey,
+        developerPortalIdentifier: distCert.certId,
+        appleTeamId: appleTeam.id,
+    }, account.id);
+}
+async function deleteDistributionCertificateAsync(graphqlClient, distributionCertificateId) {
+    await AppleDistributionCertificateMutation_1.AppleDistributionCertificateMutation.deleteAppleDistributionCertificateAsync(graphqlClient, distributionCertificateId);
+}
+async function createPushKeyAsync(graphqlClient, account, pushKey) {
+    const appleTeam = await createOrGetExistingAppleTeamAndUpdateNameIfChangedAsync(graphqlClient, account.id, {
+        appleTeamIdentifier: pushKey.teamId,
+        appleTeamName: pushKey.teamName,
+    });
+    return await ApplePushKeyMutation_1.ApplePushKeyMutation.createApplePushKeyAsync(graphqlClient, {
+        keyP8: pushKey.apnsKeyP8,
+        keyIdentifier: pushKey.apnsKeyId,
+        appleTeamId: appleTeam.id,
+    }, account.id);
+}
+async function getPushKeysForAccountAsync(graphqlClient, account) {
+    return await ApplePushKeyQuery_1.ApplePushKeyQuery.getAllForAccountAsync(graphqlClient, account.name);
+}
+async function getPushKeyForAppAsync(graphqlClient, appLookupParams) {
+    const maybeIosAppCredentials = await getIosAppCredentialsWithCommonFieldsAsync(graphqlClient, appLookupParams);
+    return maybeIosAppCredentials?.pushKey ?? null;
+}
+async function deletePushKeyAsync(graphqlClient, pushKeyId) {
+    await ApplePushKeyMutation_1.ApplePushKeyMutation.deleteApplePushKeyAsync(graphqlClient, pushKeyId);
+}
+async function createAscApiKeyAsync(graphqlClient, account, ascApiKey) {
+    const maybeAppleTeam = ascApiKey.teamId
+        ? await createOrGetExistingAppleTeamAndUpdateNameIfChangedAsync(graphqlClient, account.id, {
+            appleTeamIdentifier: ascApiKey.teamId,
+            appleTeamName: ascApiKey.teamName,
+        })
+        : null;
+    return await AppStoreConnectApiKeyMutation_1.AppStoreConnectApiKeyMutation.createAppStoreConnectApiKeyAsync(graphqlClient, {
+        issuerIdentifier: ascApiKey.issuerId,
+        keyIdentifier: ascApiKey.keyId,
+        keyP8: ascApiKey.keyP8,
+        name: ascApiKey.name ?? null,
+        roles: ascApiKey.roles?.map(role => convertUserRoleToGraphqlType(role)) ?? null,
+        appleTeamId: maybeAppleTeam ? maybeAppleTeam.id : null,
+    }, account.id);
+}
+async function getAscApiKeysForAccountAsync(graphqlClient, account) {
+    return await AppStoreConnectApiKeyQuery_1.AppStoreConnectApiKeyQuery.getAllForAccountAsync(graphqlClient, account.name);
+}
+async function getAscApiKeyForAppSubmissionsAsync(graphqlClient, appLookupParams) {
+    const maybeIosAppCredentials = await getIosAppCredentialsWithCommonFieldsAsync(graphqlClient, appLookupParams);
+    return maybeIosAppCredentials?.appStoreConnectApiKeyForSubmissions ?? null;
+}
+async function deleteAscApiKeyAsync(graphqlClient, ascApiKeyId) {
+    await AppStoreConnectApiKeyMutation_1.AppStoreConnectApiKeyMutation.deleteAppStoreConnectApiKeyAsync(graphqlClient, ascApiKeyId);
+}
+function convertUserRoleToGraphqlType(userRole) {
+    switch (userRole) {
+        case apple_utils_1.UserRole.ADMIN:
+            return generated_1.AppStoreConnectUserRole.Admin;
+        case apple_utils_1.UserRole.ACCESS_TO_REPORTS:
+            return generated_1.AppStoreConnectUserRole.AccessToReports;
+        case apple_utils_1.UserRole.ACCOUNT_HOLDER:
+            return generated_1.AppStoreConnectUserRole.AccountHolder;
+        case apple_utils_1.UserRole.APP_MANAGER:
+            return generated_1.AppStoreConnectUserRole.AppManager;
+        case apple_utils_1.UserRole.CLOUD_MANAGED_APP_DISTRIBUTION:
+            return generated_1.AppStoreConnectUserRole.CloudManagedAppDistribution;
+        case apple_utils_1.UserRole.CLOUD_MANAGED_DEVELOPER_ID:
+            return generated_1.AppStoreConnectUserRole.CloudManagedDeveloperId;
+        case apple_utils_1.UserRole.CREATE_APPS:
+            return generated_1.AppStoreConnectUserRole.CreateApps;
+        case apple_utils_1.UserRole.CUSTOMER_SUPPORT:
+            return generated_1.AppStoreConnectUserRole.CustomerSupport;
+        case apple_utils_1.UserRole.DEVELOPER:
+            return generated_1.AppStoreConnectUserRole.Developer;
+        case apple_utils_1.UserRole.FINANCE:
+            return generated_1.AppStoreConnectUserRole.Finance;
+        case apple_utils_1.UserRole.MARKETING:
+            return generated_1.AppStoreConnectUserRole.Marketing;
+        case apple_utils_1.UserRole.READ_ONLY:
+            return generated_1.AppStoreConnectUserRole.ReadOnly;
+        case apple_utils_1.UserRole.SALES:
+            return generated_1.AppStoreConnectUserRole.Sales;
+        case apple_utils_1.UserRole.TECHNICAL:
+            return generated_1.AppStoreConnectUserRole.Technical;
+    }
+}
+const formatProjectFullName = ({ account, projectName }) => `@${account.name}/${projectName}`;

package/build/credentials/ios/api/graphql/mutations/AppStoreConnectApiKeyMutation.d.ts

@@ -0,0 +1,6 @@
+import { ExpoGraphqlClient } from '../../../../../commandUtils/context/contextUtils/createGraphqlClient';
+import { AppStoreConnectApiKeyFragment, AppStoreConnectApiKeyInput } from '../../../../../graphql/generated';
+export declare const AppStoreConnectApiKeyMutation: {
+    createAppStoreConnectApiKeyAsync(graphqlClient: ExpoGraphqlClient, appStoreConnectApiKeyInput: AppStoreConnectApiKeyInput, accountId: string): Promise<AppStoreConnectApiKeyFragment>;
+    deleteAppStoreConnectApiKeyAsync(graphqlClient: ExpoGraphqlClient, appStoreConnectApiKeyId: string): Promise<void>;
+};

package/build/credentials/ios/api/graphql/mutations/AppStoreConnectApiKeyMutation.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppStoreConnectApiKeyMutation = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const graphql_1 = require("graphql");
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const client_1 = require("../../../../../graphql/client");
+const AppStoreConnectApiKey_1 = require("../../../../../graphql/types/credentials/AppStoreConnectApiKey");
+exports.AppStoreConnectApiKeyMutation = {
+    async createAppStoreConnectApiKeyAsync(graphqlClient, appStoreConnectApiKeyInput, accountId) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation CreateAppStoreConnectApiKeyMutation(
+              $appStoreConnectApiKeyInput: AppStoreConnectApiKeyInput!
+              $accountId: ID!
+            ) {
+              appStoreConnectApiKey {
+                createAppStoreConnectApiKey(
+                  appStoreConnectApiKeyInput: $appStoreConnectApiKeyInput
+                  accountId: $accountId
+                ) {
+                  id
+                  ...AppStoreConnectApiKeyFragment
+                }
+              }
+            }
+            ${(0, graphql_1.print)(AppStoreConnectApiKey_1.AppStoreConnectApiKeyFragmentNode)}
+          `, {
+            appStoreConnectApiKeyInput,
+            accountId,
+        })
+            .toPromise());
+        (0, assert_1.default)(data.appStoreConnectApiKey.createAppStoreConnectApiKey, 'GraphQL: `createAppStoreConnectApiKey` not defined in server response');
+        return data.appStoreConnectApiKey.createAppStoreConnectApiKey;
+    },
+    async deleteAppStoreConnectApiKeyAsync(graphqlClient, appStoreConnectApiKeyId) {
+        await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation DeleteAppStoreConnectApiKeyMutation($appStoreConnectApiKeyId: ID!) {
+              appStoreConnectApiKey {
+                deleteAppStoreConnectApiKey(id: $appStoreConnectApiKeyId) {
+                  id
+                }
+              }
+            }
+          `, {
+            appStoreConnectApiKeyId,
+        }, {
+            additionalTypenames: ['AppStoreConnectApiKey', 'IosAppCredentials'],
+        })
+            .toPromise());
+    },
+};

package/build/credentials/ios/api/graphql/mutations/AppleAppIdentifierMutation.d.ts

@@ -0,0 +1,5 @@
+import { ExpoGraphqlClient } from '../../../../../commandUtils/context/contextUtils/createGraphqlClient';
+import { AppleAppIdentifierFragment, AppleAppIdentifierInput } from '../../../../../graphql/generated';
+export declare const AppleAppIdentifierMutation: {
+    createAppleAppIdentifierAsync(graphqlClient: ExpoGraphqlClient, appleAppIdentifierInput: AppleAppIdentifierInput, accountId: string): Promise<AppleAppIdentifierFragment>;
+};

package/build/credentials/ios/api/graphql/mutations/AppleAppIdentifierMutation.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppleAppIdentifierMutation = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const graphql_1 = require("graphql");
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const client_1 = require("../../../../../graphql/client");
+const AppleAppIdentifier_1 = require("../../../../../graphql/types/credentials/AppleAppIdentifier");
+exports.AppleAppIdentifierMutation = {
+    async createAppleAppIdentifierAsync(graphqlClient, appleAppIdentifierInput, accountId) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation CreateAppleAppIdentifierMutation(
+              $appleAppIdentifierInput: AppleAppIdentifierInput!
+              $accountId: ID!
+            ) {
+              appleAppIdentifier {
+                createAppleAppIdentifier(
+                  appleAppIdentifierInput: $appleAppIdentifierInput
+                  accountId: $accountId
+                ) {
+                  id
+                  ...AppleAppIdentifierFragment
+                }
+              }
+            }
+            ${(0, graphql_1.print)(AppleAppIdentifier_1.AppleAppIdentifierFragmentNode)}
+          `, {
+            appleAppIdentifierInput,
+            accountId,
+        })
+            .toPromise());
+        (0, assert_1.default)(data.appleAppIdentifier.createAppleAppIdentifier, 'GraphQL: `createAppleAppIdentifier` not defined in server response');
+        return data.appleAppIdentifier.createAppleAppIdentifier;
+    },
+};

package/build/credentials/ios/api/graphql/mutations/AppleDeviceMutation.d.ts

@@ -0,0 +1,7 @@
+import { ExpoGraphqlClient } from '../../../../../commandUtils/context/contextUtils/createGraphqlClient';
+import { AppleDeviceFragment, AppleDeviceInput, AppleDeviceUpdateInput } from '../../../../../graphql/generated';
+export declare const AppleDeviceMutation: {
+    createAppleDeviceAsync(graphqlClient: ExpoGraphqlClient, appleDeviceInput: AppleDeviceInput, accountId: string): Promise<AppleDeviceFragment>;
+    deleteAppleDeviceAsync(graphqlClient: ExpoGraphqlClient, deviceId: string): Promise<string>;
+    updateAppleDeviceAsync(graphqlClient: ExpoGraphqlClient, id: string, appleDeviceUpdateInput: AppleDeviceUpdateInput): Promise<AppleDeviceFragment>;
+};