@donotuse/eas-cli 18.5.0-rc.1

package/build/credentials/android/actions/SetUpBuildCredentialsFromCredentialsJson.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetUpBuildCredentialsFromCredentialsJson = void 0;
+const tslib_1 = require("tslib");
+const DownloadKeystore_1 = require("./DownloadKeystore");
+const generated_1 = require("../../../graphql/generated");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const prompts_1 = require("../../../prompts");
+const read_1 = require("../../credentialsJson/read");
+const SelectAndroidBuildCredentials_1 = require("../../manager/SelectAndroidBuildCredentials");
+const keystoreNew_1 = require("../utils/keystoreNew");
+class SetUpBuildCredentialsFromCredentialsJson {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    async runAsync(ctx) {
+        if (ctx.nonInteractive) {
+            throw new Error('Setting up build credentials from credentials.json is only available in interactive mode');
+        }
+        let localCredentials;
+        try {
+            localCredentials = await (0, read_1.readAndroidCredentialsAsync)(ctx.projectDir);
+        }
+        catch (error) {
+            log_1.default.error('Reading credentials from credentials.json failed. Make sure this file is correct and all credentials are present there.');
+            throw error;
+        }
+        const selectBuildCredentialsResult = await new SelectAndroidBuildCredentials_1.SelectAndroidBuildCredentials(this.app).runAsync(ctx);
+        if (selectBuildCredentialsResult.resultType ===
+            SelectAndroidBuildCredentials_1.SelectAndroidBuildCredentialsResultType.EXISTING_CREDENTIALS &&
+            selectBuildCredentialsResult.result.androidKeystore) {
+            const buildCredentials = selectBuildCredentialsResult.result;
+            const confirmOverwrite = await (0, prompts_1.confirmAsync)({
+                message: `The build configuration ${buildCredentials.name} already has a keystore configured. Overwrite?`,
+            });
+            if (!confirmOverwrite) {
+                return null;
+            }
+            await new DownloadKeystore_1.BackupKeystore(this.app).runAsync(ctx, buildCredentials);
+        }
+        const providedKeystoreWithType = (0, keystoreNew_1.getKeystoreWithType)(localCredentials.keystore);
+        if (providedKeystoreWithType.type === generated_1.AndroidKeystoreType.Unknown) {
+            const confirmKeystoreIsSketchy = await (0, prompts_1.confirmAsync)({
+                message: `The keystore you provided could not be parsed and may be corrupt. Proceed anyway?`,
+            });
+            if (!confirmKeystoreIsSketchy) {
+                return null;
+            }
+        }
+        const keystoreFragment = await ctx.android.createKeystoreAsync(ctx.graphqlClient, this.app.account, providedKeystoreWithType);
+        let buildCredentials;
+        if (selectBuildCredentialsResult.resultType ===
+            SelectAndroidBuildCredentials_1.SelectAndroidBuildCredentialsResultType.CREATE_REQUEST) {
+            buildCredentials = await ctx.android.createAndroidAppBuildCredentialsAsync(ctx.graphqlClient, this.app, {
+                ...selectBuildCredentialsResult.result,
+                androidKeystoreId: keystoreFragment.id,
+            });
+        }
+        else {
+            buildCredentials = await ctx.android.updateAndroidAppBuildCredentialsAsync(ctx.graphqlClient, selectBuildCredentialsResult.result, {
+                androidKeystoreId: keystoreFragment.id,
+            });
+        }
+        log_1.default.succeed('Keystore updated');
+        return buildCredentials;
+    }
+}
+exports.SetUpBuildCredentialsFromCredentialsJson = SetUpBuildCredentialsFromCredentialsJson;

package/build/credentials/android/actions/SetUpGoogleServiceAccountKeyForFcmV1.d.ts

@@ -0,0 +1,10 @@
+import { CommonAndroidAppCredentialsFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+import { AppLookupParams } from '../api/GraphqlClient';
+export declare class SetUpGoogleServiceAccountKeyForFcmV1 {
+    private readonly app;
+    constructor(app: AppLookupParams);
+    runAsync(ctx: CredentialsContext): Promise<CommonAndroidAppCredentialsFragment>;
+    private isGoogleServiceAccountKeySetupAsync;
+    private createOrUseExistingKeyAsync;
+}

package/build/credentials/android/actions/SetUpGoogleServiceAccountKeyForFcmV1.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetUpGoogleServiceAccountKeyForFcmV1 = void 0;
+const tslib_1 = require("tslib");
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const AssignGoogleServiceAccountKeyForFcmV1_1 = require("./AssignGoogleServiceAccountKeyForFcmV1");
+const CreateGoogleServiceAccountKey_1 = require("./CreateGoogleServiceAccountKey");
+const UseExistingGoogleServiceAccountKey_1 = require("./UseExistingGoogleServiceAccountKey");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const prompts_1 = require("../../../prompts");
+const errors_1 = require("../../errors");
+class SetUpGoogleServiceAccountKeyForFcmV1 {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    async runAsync(ctx) {
+        const isKeySetup = await this.isGoogleServiceAccountKeySetupAsync(ctx);
+        if (isKeySetup) {
+            log_1.default.succeed('Google Service Account Key for FCM V1 already set up.');
+            return (0, nullthrows_1.default)(await ctx.android.getAndroidAppCredentialsWithCommonFieldsAsync(ctx.graphqlClient, this.app), 'androidAppCredentials cannot be null if google service account key is already set up');
+        }
+        if (ctx.nonInteractive) {
+            throw new errors_1.MissingCredentialsNonInteractiveError('Google Service Account Keys cannot be set up in --non-interactive mode.');
+        }
+        const keysForAccount = await ctx.android.getGoogleServiceAccountKeysForAccountAsync(ctx.graphqlClient, this.app.account);
+        let googleServiceAccountKey = null;
+        if (keysForAccount.length === 0) {
+            googleServiceAccountKey = await new CreateGoogleServiceAccountKey_1.CreateGoogleServiceAccountKey(this.app.account).runAsync(ctx);
+        }
+        else {
+            googleServiceAccountKey = await this.createOrUseExistingKeyAsync(ctx);
+        }
+        return await new AssignGoogleServiceAccountKeyForFcmV1_1.AssignGoogleServiceAccountKeyForFcmV1(this.app).runAsync(ctx, googleServiceAccountKey);
+    }
+    async isGoogleServiceAccountKeySetupAsync(ctx) {
+        const appCredentials = await ctx.android.getAndroidAppCredentialsWithCommonFieldsAsync(ctx.graphqlClient, this.app);
+        return !!appCredentials?.googleServiceAccountKeyForFcmV1;
+    }
+    async createOrUseExistingKeyAsync(ctx) {
+        const { action } = await (0, prompts_1.promptAsync)({
+            type: 'select',
+            name: 'action',
+            message: 'Select the Google Service Account Key to use for FCM V1:',
+            choices: [
+                {
+                    title: '[Choose an existing key]',
+                    value: 'CHOOSE_EXISTING',
+                },
+                { title: '[Upload a new service account key]', value: 'GENERATE' },
+            ],
+        });
+        if (action === 'GENERATE') {
+            return await new CreateGoogleServiceAccountKey_1.CreateGoogleServiceAccountKey(this.app.account).runAsync(ctx);
+        }
+        return ((await new UseExistingGoogleServiceAccountKey_1.UseExistingGoogleServiceAccountKey(this.app.account).runAsync(ctx)) ??
+            (await this.createOrUseExistingKeyAsync(ctx)));
+    }
+}
+exports.SetUpGoogleServiceAccountKeyForFcmV1 = SetUpGoogleServiceAccountKeyForFcmV1;

package/build/credentials/android/actions/SetUpGoogleServiceAccountKeyForSubmissions.d.ts

@@ -0,0 +1,10 @@
+import { CommonAndroidAppCredentialsFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+import { AppLookupParams } from '../api/GraphqlClient';
+export declare class SetUpGoogleServiceAccountKeyForSubmissions {
+    private readonly app;
+    constructor(app: AppLookupParams);
+    runAsync(ctx: CredentialsContext): Promise<CommonAndroidAppCredentialsFragment>;
+    private isGoogleServiceAccountKeySetupAsync;
+    private createOrUseExistingKeyAsync;
+}

package/build/credentials/android/actions/SetUpGoogleServiceAccountKeyForSubmissions.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetUpGoogleServiceAccountKeyForSubmissions = void 0;
+const tslib_1 = require("tslib");
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const AssignGoogleServiceAccountKeyForSubmissions_1 = require("./AssignGoogleServiceAccountKeyForSubmissions");
+const CreateGoogleServiceAccountKey_1 = require("./CreateGoogleServiceAccountKey");
+const UseExistingGoogleServiceAccountKey_1 = require("./UseExistingGoogleServiceAccountKey");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const prompts_1 = require("../../../prompts");
+const errors_1 = require("../../errors");
+class SetUpGoogleServiceAccountKeyForSubmissions {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    async runAsync(ctx) {
+        const isKeySetup = await this.isGoogleServiceAccountKeySetupAsync(ctx);
+        if (isKeySetup) {
+            log_1.default.succeed('Google Service Account Key already set up.');
+            return (0, nullthrows_1.default)(await ctx.android.getAndroidAppCredentialsWithCommonFieldsAsync(ctx.graphqlClient, this.app), 'androidAppCredentials cannot be null if google service account key is already set up');
+        }
+        if (ctx.nonInteractive) {
+            throw new errors_1.MissingCredentialsNonInteractiveError('Google Service Account Keys cannot be set up in --non-interactive mode.');
+        }
+        const keysForAccount = await ctx.android.getGoogleServiceAccountKeysForAccountAsync(ctx.graphqlClient, this.app.account);
+        let googleServiceAccountKey = null;
+        if (keysForAccount.length === 0) {
+            googleServiceAccountKey = await new CreateGoogleServiceAccountKey_1.CreateGoogleServiceAccountKey(this.app.account).runAsync(ctx);
+        }
+        else {
+            googleServiceAccountKey = await this.createOrUseExistingKeyAsync(ctx);
+        }
+        return await new AssignGoogleServiceAccountKeyForSubmissions_1.AssignGoogleServiceAccountKeyForSubmissions(this.app).runAsync(ctx, googleServiceAccountKey);
+    }
+    async isGoogleServiceAccountKeySetupAsync(ctx) {
+        const appCredentials = await ctx.android.getAndroidAppCredentialsWithCommonFieldsAsync(ctx.graphqlClient, this.app);
+        return !!appCredentials?.googleServiceAccountKeyForSubmissions;
+    }
+    async createOrUseExistingKeyAsync(ctx) {
+        const { action } = await (0, prompts_1.promptAsync)({
+            type: 'select',
+            name: 'action',
+            message: 'Select the Google Service Account Key to use for your project:',
+            choices: [
+                {
+                    title: '[Choose an existing key]',
+                    value: 'CHOOSE_EXISTING',
+                },
+                { title: '[Upload a new service account key]', value: 'GENERATE' },
+            ],
+        });
+        if (action === 'GENERATE') {
+            return await new CreateGoogleServiceAccountKey_1.CreateGoogleServiceAccountKey(this.app.account).runAsync(ctx);
+        }
+        return ((await new UseExistingGoogleServiceAccountKey_1.UseExistingGoogleServiceAccountKey(this.app.account).runAsync(ctx)) ??
+            (await this.createOrUseExistingKeyAsync(ctx)));
+    }
+}
+exports.SetUpGoogleServiceAccountKeyForSubmissions = SetUpGoogleServiceAccountKeyForSubmissions;

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

@@ -0,0 +1,5 @@
+import { AndroidAppBuildCredentialsFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+export declare class UpdateCredentialsJson {
+    runAsync(ctx: CredentialsContext, buildCredentials: AndroidAppBuildCredentialsFragment): Promise<void>;
+}

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

@@ -0,0 +1,14 @@
+"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 {
+    async runAsync(ctx, buildCredentials) {
+        log_1.default.log('Updating Android credentials in credentials.json');
+        await (0, update_1.updateAndroidCredentialsAsync)(ctx, buildCredentials);
+        log_1.default.succeed('Android part of your local credentials.json is synced with values stored on EAS servers.');
+    }
+}
+exports.UpdateCredentialsJson = UpdateCredentialsJson;

package/build/credentials/android/actions/UseExistingGoogleServiceAccountKey.d.ts

@@ -0,0 +1,7 @@
+import { AccountFragment, GoogleServiceAccountKeyFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+export declare class UseExistingGoogleServiceAccountKey {
+    private readonly account;
+    constructor(account: AccountFragment);
+    runAsync(ctx: CredentialsContext): Promise<GoogleServiceAccountKeyFragment | null>;
+}

package/build/credentials/android/actions/UseExistingGoogleServiceAccountKey.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UseExistingGoogleServiceAccountKey = void 0;
+const tslib_1 = require("tslib");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const googleServiceAccountKey_1 = require("../utils/googleServiceAccountKey");
+class UseExistingGoogleServiceAccountKey {
+    account;
+    constructor(account) {
+        this.account = account;
+    }
+    async runAsync(ctx) {
+        if (ctx.nonInteractive) {
+            throw new Error(`Existing Google Service Account Key cannot be chosen in non-interactive mode.`);
+        }
+        const gsaKeyFragments = await ctx.android.getGoogleServiceAccountKeysForAccountAsync(ctx.graphqlClient, this.account);
+        if (gsaKeyFragments.length === 0) {
+            log_1.default.error("There aren't any Google Service Account Keys associated with your account.");
+            return null;
+        }
+        return await (0, googleServiceAccountKey_1.selectGoogleServiceAccountKeyAsync)(gsaKeyFragments);
+    }
+}
+exports.UseExistingGoogleServiceAccountKey = UseExistingGoogleServiceAccountKey;

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

@@ -0,0 +1,41 @@
+import { ExpoGraphqlClient } from '../../../commandUtils/context/contextUtils/createGraphqlClient';
+import { AccountFragment, AndroidAppBuildCredentialsFragment, AndroidFcmFragment, AndroidFcmVersion, AndroidKeystoreFragment, CommonAndroidAppCredentialsFragment, GoogleServiceAccountKeyFragment } from '../../../graphql/generated';
+import { GoogleServiceAccountKey, KeystoreWithType } from '../credentials';
+export interface AppLookupParams {
+    account: AccountFragment;
+    projectName: string;
+    androidApplicationIdentifier: string;
+}
+export declare function getAndroidAppCredentialsWithCommonFieldsAsync(graphqlClient: ExpoGraphqlClient, appLookupParams: AppLookupParams): Promise<CommonAndroidAppCredentialsFragment | null>;
+export declare function getAndroidAppBuildCredentialsListAsync(graphqlClient: ExpoGraphqlClient, appLookupParams: AppLookupParams): Promise<AndroidAppBuildCredentialsFragment[]>;
+export declare function getLegacyAndroidAppCredentialsWithCommonFieldsAsync(graphqlClient: ExpoGraphqlClient, appLookupParams: AppLookupParams): Promise<CommonAndroidAppCredentialsFragment | null>;
+export declare function getLegacyAndroidAppBuildCredentialsAsync(graphqlClient: ExpoGraphqlClient, appLookupParams: AppLookupParams): Promise<AndroidAppBuildCredentialsFragment | null>;
+export declare function createOrGetExistingAndroidAppCredentialsWithBuildCredentialsAsync(graphqlClient: ExpoGraphqlClient, appLookupParams: AppLookupParams): Promise<CommonAndroidAppCredentialsFragment>;
+export declare function updateAndroidAppCredentialsAsync(graphqlClient: ExpoGraphqlClient, appCredentials: CommonAndroidAppCredentialsFragment, { androidFcmId, googleServiceAccountKeyForSubmissionsId, googleServiceAccountKeyForFcmV1Id, }: {
+    androidFcmId?: string;
+    googleServiceAccountKeyForSubmissionsId?: string;
+    googleServiceAccountKeyForFcmV1Id?: string;
+}): Promise<CommonAndroidAppCredentialsFragment>;
+export declare function updateAndroidAppBuildCredentialsAsync(graphqlClient: ExpoGraphqlClient, buildCredentials: AndroidAppBuildCredentialsFragment, { androidKeystoreId, }: {
+    androidKeystoreId: string;
+}): Promise<AndroidAppBuildCredentialsFragment>;
+export declare function setDefaultAndroidAppBuildCredentialsAsync(graphqlClient: ExpoGraphqlClient, buildCredentials: AndroidAppBuildCredentialsFragment): Promise<AndroidAppBuildCredentialsFragment>;
+export declare function createAndroidAppBuildCredentialsAsync(graphqlClient: ExpoGraphqlClient, appLookupParams: AppLookupParams, { name, isDefault, androidKeystoreId, }: {
+    name: string;
+    isDefault: boolean;
+    androidKeystoreId: string;
+}): Promise<AndroidAppBuildCredentialsFragment>;
+export declare function getDefaultAndroidAppBuildCredentialsAsync(graphqlClient: ExpoGraphqlClient, appLookupParams: AppLookupParams): Promise<AndroidAppBuildCredentialsFragment | null>;
+export declare function getAndroidAppBuildCredentialsByNameAsync(graphqlClient: ExpoGraphqlClient, appLookupParams: AppLookupParams, name: string): Promise<AndroidAppBuildCredentialsFragment | null>;
+export declare function createOrUpdateAndroidAppBuildCredentialsByNameAsync(graphqlClient: ExpoGraphqlClient, appLookupParams: AppLookupParams, name: string, { androidKeystoreId, }: {
+    androidKeystoreId: string;
+}): Promise<AndroidAppBuildCredentialsFragment>;
+export declare function createOrUpdateDefaultIosAppBuildCredentialsAsync(): Promise<void>;
+export declare function createKeystoreAsync(graphqlClient: ExpoGraphqlClient, account: AccountFragment, keystore: KeystoreWithType): Promise<AndroidKeystoreFragment>;
+export declare function deleteKeystoreAsync(graphqlClient: ExpoGraphqlClient, keystore: AndroidKeystoreFragment): Promise<void>;
+export declare function createFcmAsync(graphqlClient: ExpoGraphqlClient, account: AccountFragment, fcmApiKey: string, version: AndroidFcmVersion): Promise<AndroidFcmFragment>;
+export declare function deleteFcmAsync(graphqlClient: ExpoGraphqlClient, fcm: AndroidFcmFragment): Promise<void>;
+export declare function createGoogleServiceAccountKeyAsync(graphqlClient: ExpoGraphqlClient, account: AccountFragment, jsonKey: GoogleServiceAccountKey): Promise<GoogleServiceAccountKeyFragment>;
+export declare function deleteGoogleServiceAccountKeyAsync(graphqlClient: ExpoGraphqlClient, googleServiceAccountKey: GoogleServiceAccountKeyFragment): Promise<void>;
+export declare function getGoogleServiceAccountKeysForAccountAsync(graphqlClient: ExpoGraphqlClient, account: AccountFragment): Promise<GoogleServiceAccountKeyFragment[]>;
+export declare const formatProjectFullName: ({ account, projectName }: AppLookupParams) => string;

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

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatProjectFullName = void 0;
+exports.getAndroidAppCredentialsWithCommonFieldsAsync = getAndroidAppCredentialsWithCommonFieldsAsync;
+exports.getAndroidAppBuildCredentialsListAsync = getAndroidAppBuildCredentialsListAsync;
+exports.getLegacyAndroidAppCredentialsWithCommonFieldsAsync = getLegacyAndroidAppCredentialsWithCommonFieldsAsync;
+exports.getLegacyAndroidAppBuildCredentialsAsync = getLegacyAndroidAppBuildCredentialsAsync;
+exports.createOrGetExistingAndroidAppCredentialsWithBuildCredentialsAsync = createOrGetExistingAndroidAppCredentialsWithBuildCredentialsAsync;
+exports.updateAndroidAppCredentialsAsync = updateAndroidAppCredentialsAsync;
+exports.updateAndroidAppBuildCredentialsAsync = updateAndroidAppBuildCredentialsAsync;
+exports.setDefaultAndroidAppBuildCredentialsAsync = setDefaultAndroidAppBuildCredentialsAsync;
+exports.createAndroidAppBuildCredentialsAsync = createAndroidAppBuildCredentialsAsync;
+exports.getDefaultAndroidAppBuildCredentialsAsync = getDefaultAndroidAppBuildCredentialsAsync;
+exports.getAndroidAppBuildCredentialsByNameAsync = getAndroidAppBuildCredentialsByNameAsync;
+exports.createOrUpdateAndroidAppBuildCredentialsByNameAsync = createOrUpdateAndroidAppBuildCredentialsByNameAsync;
+exports.createOrUpdateDefaultIosAppBuildCredentialsAsync = createOrUpdateDefaultIosAppBuildCredentialsAsync;
+exports.createKeystoreAsync = createKeystoreAsync;
+exports.deleteKeystoreAsync = deleteKeystoreAsync;
+exports.createFcmAsync = createFcmAsync;
+exports.deleteFcmAsync = deleteFcmAsync;
+exports.createGoogleServiceAccountKeyAsync = createGoogleServiceAccountKeyAsync;
+exports.deleteGoogleServiceAccountKeyAsync = deleteGoogleServiceAccountKeyAsync;
+exports.getGoogleServiceAccountKeysForAccountAsync = getGoogleServiceAccountKeysForAccountAsync;
+const AndroidAppBuildCredentialsMutation_1 = require("./graphql/mutations/AndroidAppBuildCredentialsMutation");
+const AndroidAppCredentialsMutation_1 = require("./graphql/mutations/AndroidAppCredentialsMutation");
+const AndroidFcmMutation_1 = require("./graphql/mutations/AndroidFcmMutation");
+const AndroidKeystoreMutation_1 = require("./graphql/mutations/AndroidKeystoreMutation");
+const GoogleServiceAccountKeyMutation_1 = require("./graphql/mutations/GoogleServiceAccountKeyMutation");
+const AndroidAppCredentialsQuery_1 = require("./graphql/queries/AndroidAppCredentialsQuery");
+const GoogleServiceAccountKeyQuery_1 = require("./graphql/queries/GoogleServiceAccountKeyQuery");
+const AppQuery_1 = require("../../../graphql/queries/AppQuery");
+async function getAndroidAppCredentialsWithCommonFieldsAsync(graphqlClient, appLookupParams) {
+    const { androidApplicationIdentifier } = appLookupParams;
+    const projectFullName = (0, exports.formatProjectFullName)(appLookupParams);
+    return await AndroidAppCredentialsQuery_1.AndroidAppCredentialsQuery.withCommonFieldsByApplicationIdentifierAsync(graphqlClient, projectFullName, {
+        androidApplicationIdentifier,
+        legacyOnly: false,
+    });
+}
+async function getAndroidAppBuildCredentialsListAsync(graphqlClient, appLookupParams) {
+    const appCredentials = await getAndroidAppCredentialsWithCommonFieldsAsync(graphqlClient, appLookupParams);
+    return appCredentials?.androidAppBuildCredentialsList ?? [];
+}
+/* There is at most one set of legacy android app credentials associated with an Expo App */
+async function getLegacyAndroidAppCredentialsWithCommonFieldsAsync(graphqlClient, appLookupParams) {
+    const projectFullName = (0, exports.formatProjectFullName)(appLookupParams);
+    return await AndroidAppCredentialsQuery_1.AndroidAppCredentialsQuery.withCommonFieldsByApplicationIdentifierAsync(graphqlClient, projectFullName, {
+        legacyOnly: true,
+    });
+}
+/* There is at most one set of legacy android app build credentials associated with an Expo App */
+async function getLegacyAndroidAppBuildCredentialsAsync(graphqlClient, appLookupParams) {
+    const legacyAppCredentials = await getLegacyAndroidAppCredentialsWithCommonFieldsAsync(graphqlClient, appLookupParams);
+    return legacyAppCredentials?.androidAppBuildCredentialsList[0] ?? null;
+}
+async function createOrGetExistingAndroidAppCredentialsWithBuildCredentialsAsync(graphqlClient, appLookupParams) {
+    const maybeAndroidAppCredentials = await getAndroidAppCredentialsWithCommonFieldsAsync(graphqlClient, appLookupParams);
+    if (maybeAndroidAppCredentials) {
+        return maybeAndroidAppCredentials;
+    }
+    else {
+        const app = await getAppAsync(graphqlClient, appLookupParams);
+        return await AndroidAppCredentialsMutation_1.AndroidAppCredentialsMutation.createAndroidAppCredentialsAsync(graphqlClient, {}, app.id, appLookupParams.androidApplicationIdentifier);
+    }
+}
+async function updateAndroidAppCredentialsAsync(graphqlClient, appCredentials, { androidFcmId, googleServiceAccountKeyForSubmissionsId, googleServiceAccountKeyForFcmV1Id, }) {
+    let updatedAppCredentials = appCredentials;
+    if (androidFcmId) {
+        updatedAppCredentials = await AndroidAppCredentialsMutation_1.AndroidAppCredentialsMutation.setFcmKeyAsync(graphqlClient, appCredentials.id, androidFcmId);
+    }
+    if (googleServiceAccountKeyForSubmissionsId) {
+        updatedAppCredentials =
+            await AndroidAppCredentialsMutation_1.AndroidAppCredentialsMutation.setGoogleServiceAccountKeyForSubmissionsAsync(graphqlClient, appCredentials.id, googleServiceAccountKeyForSubmissionsId);
+    }
+    if (googleServiceAccountKeyForFcmV1Id) {
+        updatedAppCredentials =
+            await AndroidAppCredentialsMutation_1.AndroidAppCredentialsMutation.setGoogleServiceAccountKeyForFcmV1Async(graphqlClient, appCredentials.id, googleServiceAccountKeyForFcmV1Id);
+    }
+    return updatedAppCredentials;
+}
+async function updateAndroidAppBuildCredentialsAsync(graphqlClient, buildCredentials, { androidKeystoreId, }) {
+    return await AndroidAppBuildCredentialsMutation_1.AndroidAppBuildCredentialsMutation.setKeystoreAsync(graphqlClient, buildCredentials.id, androidKeystoreId);
+}
+async function setDefaultAndroidAppBuildCredentialsAsync(graphqlClient, buildCredentials) {
+    return await AndroidAppBuildCredentialsMutation_1.AndroidAppBuildCredentialsMutation.setDefaultAndroidAppBuildCredentialsAsync(graphqlClient, buildCredentials.id);
+}
+async function createAndroidAppBuildCredentialsAsync(graphqlClient, appLookupParams, { name, isDefault, androidKeystoreId, }) {
+    const androidAppCredentials = await createOrGetExistingAndroidAppCredentialsWithBuildCredentialsAsync(graphqlClient, appLookupParams);
+    return await AndroidAppBuildCredentialsMutation_1.AndroidAppBuildCredentialsMutation.createAndroidAppBuildCredentialsAsync(graphqlClient, {
+        name,
+        isDefault,
+        keystoreId: androidKeystoreId,
+    }, androidAppCredentials.id);
+}
+async function getDefaultAndroidAppBuildCredentialsAsync(graphqlClient, appLookupParams) {
+    const buildCredentialsList = await getAndroidAppBuildCredentialsListAsync(graphqlClient, appLookupParams);
+    return buildCredentialsList.find(buildCredentials => buildCredentials.isDefault) ?? null;
+}
+async function getAndroidAppBuildCredentialsByNameAsync(graphqlClient, appLookupParams, name) {
+    const buildCredentialsList = await getAndroidAppBuildCredentialsListAsync(graphqlClient, appLookupParams);
+    return buildCredentialsList.find(buildCredentials => buildCredentials.name === name) ?? null;
+}
+async function createOrUpdateAndroidAppBuildCredentialsByNameAsync(graphqlClient, appLookupParams, name, { androidKeystoreId, }) {
+    const existingBuildCredentialsWithName = await getAndroidAppBuildCredentialsByNameAsync(graphqlClient, appLookupParams, name);
+    if (existingBuildCredentialsWithName) {
+        return await updateAndroidAppBuildCredentialsAsync(graphqlClient, existingBuildCredentialsWithName, {
+            androidKeystoreId,
+        });
+    }
+    const defaultBuildCredentialsExist = !!(await getDefaultAndroidAppBuildCredentialsAsync(graphqlClient, appLookupParams));
+    return await createAndroidAppBuildCredentialsAsync(graphqlClient, appLookupParams, {
+        name,
+        isDefault: !defaultBuildCredentialsExist, // make default if none exist
+        androidKeystoreId,
+    });
+}
+async function createOrUpdateDefaultIosAppBuildCredentialsAsync() {
+    throw new Error('This requires user prompting. Look for me in BuildCredentialsUtils');
+}
+async function createKeystoreAsync(graphqlClient, account, keystore) {
+    return await AndroidKeystoreMutation_1.AndroidKeystoreMutation.createAndroidKeystoreAsync(graphqlClient, {
+        base64EncodedKeystore: keystore.keystore,
+        keystorePassword: keystore.keystorePassword,
+        keyAlias: keystore.keyAlias,
+        keyPassword: keystore.keyPassword,
+    }, account.id);
+}
+async function deleteKeystoreAsync(graphqlClient, keystore) {
+    await AndroidKeystoreMutation_1.AndroidKeystoreMutation.deleteAndroidKeystoreAsync(graphqlClient, keystore.id);
+}
+async function createFcmAsync(graphqlClient, account, fcmApiKey, version) {
+    return await AndroidFcmMutation_1.AndroidFcmMutation.createAndroidFcmAsync(graphqlClient, { credential: fcmApiKey, version }, account.id);
+}
+async function deleteFcmAsync(graphqlClient, fcm) {
+    await AndroidFcmMutation_1.AndroidFcmMutation.deleteAndroidFcmAsync(graphqlClient, fcm.id);
+}
+async function createGoogleServiceAccountKeyAsync(graphqlClient, account, jsonKey) {
+    return await GoogleServiceAccountKeyMutation_1.GoogleServiceAccountKeyMutation.createGoogleServiceAccountKeyAsync(graphqlClient, { jsonKey }, account.id);
+}
+async function deleteGoogleServiceAccountKeyAsync(graphqlClient, googleServiceAccountKey) {
+    await GoogleServiceAccountKeyMutation_1.GoogleServiceAccountKeyMutation.deleteGoogleServiceAccountKeyAsync(graphqlClient, googleServiceAccountKey.id);
+}
+async function getGoogleServiceAccountKeysForAccountAsync(graphqlClient, account) {
+    return await GoogleServiceAccountKeyQuery_1.GoogleServiceAccountKeyQuery.getAllForAccountAsync(graphqlClient, account.name);
+}
+async function getAppAsync(graphqlClient, appLookupParams) {
+    const projectFullName = (0, exports.formatProjectFullName)(appLookupParams);
+    return await AppQuery_1.AppQuery.byFullNameAsync(graphqlClient, projectFullName);
+}
+const formatProjectFullName = ({ account, projectName }) => `@${account.name}/${projectName}`;
+exports.formatProjectFullName = formatProjectFullName;

package/build/credentials/android/api/graphql/mutations/AndroidAppBuildCredentialsMutation.d.ts

@@ -0,0 +1,8 @@
+import { ExpoGraphqlClient } from '../../../../../commandUtils/context/contextUtils/createGraphqlClient';
+import { AndroidAppBuildCredentialsFragment, AndroidAppBuildCredentialsInput } from '../../../../../graphql/generated';
+export type AndroidAppBuildCredentialsMetadataInput = Omit<AndroidAppBuildCredentialsInput, 'keystoreId'>;
+export declare const AndroidAppBuildCredentialsMutation: {
+    createAndroidAppBuildCredentialsAsync(graphqlClient: ExpoGraphqlClient, androidAppBuildCredentialsInput: AndroidAppBuildCredentialsInput, androidAppCredentialsId: string): Promise<AndroidAppBuildCredentialsFragment>;
+    setDefaultAndroidAppBuildCredentialsAsync(graphqlClient: ExpoGraphqlClient, androidAppBuildCredentialsId: string): Promise<AndroidAppBuildCredentialsFragment>;
+    setKeystoreAsync(graphqlClient: ExpoGraphqlClient, androidAppBuildCredentialsId: string, keystoreId: string): Promise<AndroidAppBuildCredentialsFragment>;
+};

package/build/credentials/android/api/graphql/mutations/AndroidAppBuildCredentialsMutation.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AndroidAppBuildCredentialsMutation = 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 AndroidAppBuildCredentials_1 = require("../../../../../graphql/types/credentials/AndroidAppBuildCredentials");
+exports.AndroidAppBuildCredentialsMutation = {
+    async createAndroidAppBuildCredentialsAsync(graphqlClient, androidAppBuildCredentialsInput, androidAppCredentialsId) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation CreateAndroidAppBuildCredentialsMutation(
+              $androidAppBuildCredentialsInput: AndroidAppBuildCredentialsInput!
+              $androidAppCredentialsId: ID!
+            ) {
+              androidAppBuildCredentials {
+                createAndroidAppBuildCredentials(
+                  androidAppBuildCredentialsInput: $androidAppBuildCredentialsInput
+                  androidAppCredentialsId: $androidAppCredentialsId
+                ) {
+                  id
+                  ...AndroidAppBuildCredentialsFragment
+                }
+              }
+            }
+            ${(0, graphql_1.print)(AndroidAppBuildCredentials_1.AndroidAppBuildCredentialsFragmentNode)}
+          `, {
+            androidAppBuildCredentialsInput,
+            androidAppCredentialsId,
+        })
+            .toPromise());
+        (0, assert_1.default)(data.androidAppBuildCredentials.createAndroidAppBuildCredentials, 'GraphQL: `createAndroidAppBuildCredentials` not defined in server response');
+        return data.androidAppBuildCredentials.createAndroidAppBuildCredentials;
+    },
+    async setDefaultAndroidAppBuildCredentialsAsync(graphqlClient, androidAppBuildCredentialsId) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation SetDefaultAndroidAppBuildCredentialsMutation(
+              $androidAppBuildCredentialsId: ID!
+              $isDefault: Boolean!
+            ) {
+              androidAppBuildCredentials {
+                setDefault(id: $androidAppBuildCredentialsId, isDefault: $isDefault) {
+                  id
+                  ...AndroidAppBuildCredentialsFragment
+                }
+              }
+            }
+            ${(0, graphql_1.print)(AndroidAppBuildCredentials_1.AndroidAppBuildCredentialsFragmentNode)}
+          `, {
+            androidAppBuildCredentialsId,
+            isDefault: true,
+        })
+            .toPromise());
+        (0, assert_1.default)(data, `GraphQL: 'setDefault' not defined in server response ${JSON.stringify(data)}}`);
+        return data.androidAppBuildCredentials.setDefault;
+    },
+    async setKeystoreAsync(graphqlClient, androidAppBuildCredentialsId, keystoreId) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation SetKeystoreMutation($androidAppBuildCredentialsId: ID!, $keystoreId: ID!) {
+              androidAppBuildCredentials {
+                setKeystore(id: $androidAppBuildCredentialsId, keystoreId: $keystoreId) {
+                  id
+                  ...AndroidAppBuildCredentialsFragment
+                }
+              }
+            }
+            ${(0, graphql_1.print)(AndroidAppBuildCredentials_1.AndroidAppBuildCredentialsFragmentNode)}
+          `, {
+            androidAppBuildCredentialsId,
+            keystoreId,
+        })
+            .toPromise());
+        (0, assert_1.default)(data.androidAppBuildCredentials.setKeystore, 'GraphQL: `setKeystore` not defined in server response');
+        return data.androidAppBuildCredentials.setKeystore;
+    },
+};

package/build/credentials/android/api/graphql/mutations/AndroidAppCredentialsMutation.d.ts

@@ -0,0 +1,10 @@
+import { ExpoGraphqlClient } from '../../../../../commandUtils/context/contextUtils/createGraphqlClient';
+import { CommonAndroidAppCredentialsFragment } from '../../../../../graphql/generated';
+export declare const AndroidAppCredentialsMutation: {
+    createAndroidAppCredentialsAsync(graphqlClient: ExpoGraphqlClient, androidAppCredentialsInput: {
+        fcmId?: string;
+    }, appId: string, applicationIdentifier: string): Promise<CommonAndroidAppCredentialsFragment>;
+    setFcmKeyAsync(graphqlClient: ExpoGraphqlClient, androidAppCredentialsId: string, fcmId: string): Promise<CommonAndroidAppCredentialsFragment>;
+    setGoogleServiceAccountKeyForSubmissionsAsync(graphqlClient: ExpoGraphqlClient, androidAppCredentialsId: string, googleServiceAccountKeyId: string): Promise<CommonAndroidAppCredentialsFragment>;
+    setGoogleServiceAccountKeyForFcmV1Async(graphqlClient: ExpoGraphqlClient, androidAppCredentialsId: string, googleServiceAccountKeyId: string): Promise<CommonAndroidAppCredentialsFragment>;
+};