eas-cli 2.3.0 → 2.4.1

package/build/commands/webhook/create.js

@@ -12,13 +12,13 @@ const input_1 = require("../../webhooks/input");
 class WebhookCreate extends EasCommand_1.default {
     async runAsync() {
         const { flags } = await this.parse(WebhookCreate);
-        const { projectConfig: { projectId }, } = await this.getContextAsync(WebhookCreate, {
+        const { projectConfig: { projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(WebhookCreate, {
             nonInteractive: flags['non-interactive'],
         });
         const webhookInputParams = await (0, input_1.prepareInputParamsAsync)(flags);
         const spinner = (0, ora_1.ora)('Creating a webhook').start();
         try {
-            await WebhookMutation_1.WebhookMutation.createWebhookAsync(projectId, webhookInputParams);
+            await WebhookMutation_1.WebhookMutation.createWebhookAsync(graphqlClient, projectId, webhookInputParams);
             spinner.succeed('Successfully created a webhook');
         }
         catch (err) {
@@ -45,4 +45,5 @@ WebhookCreate.flags = {
 };
 WebhookCreate.contextDefinition = {
     ..._a.ContextOptions.ProjectConfig,
+    ..._a.ContextOptions.LoggedIn,
 };

package/build/commands/webhook/delete.d.ts

@@ -10,6 +10,7 @@ export default class WebhookDelete extends EasCommand {
         'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
         projectConfig: import("../../commandUtils/context/ProjectConfigContextField").default;
     };
     runAsync(): Promise<void>;

package/build/commands/webhook/delete.js

@@ -16,12 +16,12 @@ const formatWebhook_1 = require("../../webhooks/formatWebhook");
 class WebhookDelete extends EasCommand_1.default {
     async runAsync() {
         let { args: { ID: webhookId }, flags: { 'non-interactive': nonInteractive }, } = await this.parse(WebhookDelete);
-        const { projectConfig: { projectId }, } = await this.getContextAsync(WebhookDelete, {
+        const { projectConfig: { projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(WebhookDelete, {
             nonInteractive,
         });
-        let webhook = webhookId && (await WebhookQuery_1.WebhookQuery.byIdAsync(webhookId));
+        let webhook = webhookId && (await WebhookQuery_1.WebhookQuery.byIdAsync(graphqlClient, webhookId));
         if (!webhookId) {
-            const webhooks = await fetchWebhooksByAppIdAsync(projectId);
+            const webhooks = await fetchWebhooksByAppIdAsync(graphqlClient, projectId);
             if (webhooks.length === 0) {
                 process.exit(1);
             }
@@ -56,7 +56,7 @@ class WebhookDelete extends EasCommand_1.default {
         }
         const spinner = (0, ora_1.ora)('Deleting the webhook').start();
         try {
-            await WebhookMutation_1.WebhookMutation.deleteWebhookAsync(webhookId);
+            await WebhookMutation_1.WebhookMutation.deleteWebhookAsync(graphqlClient, webhookId);
             spinner.succeed('Successfully deleted the webhook');
         }
         catch (err) {
@@ -80,11 +80,12 @@ WebhookDelete.flags = {
 };
 WebhookDelete.contextDefinition = {
     ..._a.ContextOptions.ProjectConfig,
+    ..._a.ContextOptions.LoggedIn,
 };
-async function fetchWebhooksByAppIdAsync(appId) {
+async function fetchWebhooksByAppIdAsync(graphqlClient, appId) {
     const spinner = (0, ora_1.ora)('Fetching webhooks').start();
     try {
-        const webhooks = await WebhookQuery_1.WebhookQuery.byAppIdAsync(appId);
+        const webhooks = await WebhookQuery_1.WebhookQuery.byAppIdAsync(graphqlClient, appId);
         if (webhooks.length === 0) {
             spinner.fail('There are no webhooks on the project');
             return [];

package/build/commands/webhook/list.d.ts

@@ -6,6 +6,7 @@ export default class WebhookList extends EasCommand {
         event: import("@oclif/core/lib/interfaces").OptionFlag<WebhookType>;
     };
     static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
         projectConfig: import("../../commandUtils/context/ProjectConfigContextField").default;
     };
     runAsync(): Promise<void>;

package/build/commands/webhook/list.js

@@ -14,13 +14,13 @@ const formatWebhook_1 = require("../../webhooks/formatWebhook");
 class WebhookList extends EasCommand_1.default {
     async runAsync() {
         const { flags: { event }, } = await this.parse(WebhookList);
-        const { projectConfig: { projectId }, } = await this.getContextAsync(WebhookList, {
+        const { projectConfig: { projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(WebhookList, {
             nonInteractive: true,
         });
-        const projectDisplayName = await (0, projectUtils_1.getDisplayNameForProjectIdAsync)(projectId);
+        const projectDisplayName = await (0, projectUtils_1.getDisplayNameForProjectIdAsync)(graphqlClient, projectId);
         const spinner = (0, ora_1.ora)(`Fetching the list of webhook on project ${projectDisplayName}`).start();
         try {
-            const webhooks = await WebhookQuery_1.WebhookQuery.byAppIdAsync(projectId, event && { event });
+            const webhooks = await WebhookQuery_1.WebhookQuery.byAppIdAsync(graphqlClient, projectId, event && { event });
             if (webhooks.length === 0) {
                 spinner.fail(`There are no webhooks on project ${projectDisplayName}`);
             }
@@ -49,4 +49,5 @@ WebhookList.flags = {
 };
 WebhookList.contextDefinition = {
     ..._a.ContextOptions.ProjectConfig,
+    ..._a.ContextOptions.LoggedIn,
 };

package/build/commands/webhook/update.d.ts

@@ -9,5 +9,8 @@ export default class WebhookUpdate extends EasCommand {
         url: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
         secret: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
     };
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+    };
     runAsync(): Promise<void>;
 }

package/build/commands/webhook/update.js

@@ -1,4 +1,5 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const core_1 = require("@oclif/core");
@@ -13,12 +14,13 @@ const input_1 = require("../../webhooks/input");
 class WebhookUpdate extends EasCommand_1.default {
     async runAsync() {
         const { flags } = await this.parse(WebhookUpdate);
+        const { loggedIn: { graphqlClient }, } = await this.getContextAsync(WebhookUpdate, { nonInteractive: flags['non-interactive'] });
         const webhookId = flags.id;
-        const webhook = await WebhookQuery_1.WebhookQuery.byIdAsync(webhookId);
+        const webhook = await WebhookQuery_1.WebhookQuery.byIdAsync(graphqlClient, webhookId);
         const webhookInputParams = await (0, input_1.prepareInputParamsAsync)((0, pick_1.default)(flags, ['event', 'url', 'secret', 'non-interactive']), webhook);
         const spinner = (0, ora_1.ora)('Updating a webhook').start();
         try {
-            await WebhookMutation_1.WebhookMutation.updateWebhookAsync(webhookId, webhookInputParams);
+            await WebhookMutation_1.WebhookMutation.updateWebhookAsync(graphqlClient, webhookId, webhookInputParams);
             spinner.succeed('Successfully updated a webhook');
         }
         catch (err) {
@@ -28,6 +30,7 @@ class WebhookUpdate extends EasCommand_1.default {
     }
 }
 exports.default = WebhookUpdate;
+_a = WebhookUpdate;
 WebhookUpdate.description = 'update a webhook';
 WebhookUpdate.flags = {
     id: core_1.Flags.string({
@@ -46,3 +49,6 @@ WebhookUpdate.flags = {
     }),
     ...flags_1.EASNonInteractiveFlag,
 };
+WebhookUpdate.contextDefinition = {
+    ..._a.ContextOptions.LoggedIn,
+};

package/build/commands/webhook/view.d.ts

@@ -6,5 +6,8 @@ export default class WebhookView extends EasCommand {
         required: boolean;
         description: string;
     }[];
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+    };
     runAsync(): Promise<void>;
 }

package/build/commands/webhook/view.js

@@ -1,4 +1,5 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
@@ -9,9 +10,10 @@ const formatWebhook_1 = require("../../webhooks/formatWebhook");
 class WebhookView extends EasCommand_1.default {
     async runAsync() {
         const { args: { ID: webhookId }, } = await this.parse(WebhookView);
+        const { loggedIn: { graphqlClient }, } = await this.getContextAsync(WebhookView, { nonInteractive: true });
         const spinner = (0, ora_1.ora)(`Fetching the webhook details for ID ${webhookId}`).start();
         try {
-            const webhook = await WebhookQuery_1.WebhookQuery.byIdAsync(webhookId);
+            const webhook = await WebhookQuery_1.WebhookQuery.byIdAsync(graphqlClient, webhookId);
             spinner.succeed(`Found the webhook details`);
             log_1.default.log(`\n${(0, formatWebhook_1.formatWebhook)(webhook)}`);
         }
@@ -22,6 +24,7 @@ class WebhookView extends EasCommand_1.default {
     }
 }
 exports.default = WebhookView;
+_a = WebhookView;
 WebhookView.description = 'view a webhook';
 WebhookView.args = [
     {
@@ -30,3 +33,6 @@ WebhookView.args = [
         description: 'ID of the webhook to view',
     },
 ];
+WebhookView.contextDefinition = {
+    ..._a.ContextOptions.LoggedIn,
+};

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

@@ -8,8 +8,8 @@ class AssignFcm {
         this.app = app;
     }
     async runAsync(ctx, fcm) {
-        const appCredentials = await ctx.android.createOrGetExistingAndroidAppCredentialsWithBuildCredentialsAsync(this.app);
-        const updatedAppCredentials = await ctx.android.updateAndroidAppCredentialsAsync(appCredentials, {
+        const appCredentials = await ctx.android.createOrGetExistingAndroidAppCredentialsWithBuildCredentialsAsync(ctx.graphqlClient, this.app);
+        const updatedAppCredentials = await ctx.android.updateAndroidAppCredentialsAsync(ctx.graphqlClient, appCredentials, {
             androidFcmId: fcm.id,
         });
         log_1.default.succeed(`FCM API Key assigned to ${this.app.androidApplicationIdentifier}`);

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

@@ -8,8 +8,8 @@ class AssignGoogleServiceAccountKey {
         this.app = app;
     }
     async runAsync(ctx, googleServiceAccountKey) {
-        const appCredentials = await ctx.android.createOrGetExistingAndroidAppCredentialsWithBuildCredentialsAsync(this.app);
-        const updatedAppCredentials = await ctx.android.updateAndroidAppCredentialsAsync(appCredentials, {
+        const appCredentials = await ctx.android.createOrGetExistingAndroidAppCredentialsWithBuildCredentialsAsync(ctx.graphqlClient, this.app);
+        const updatedAppCredentials = await ctx.android.updateAndroidAppCredentialsAsync(ctx.graphqlClient, appCredentials, {
             googleServiceAccountKeyForSubmissionsId: googleServiceAccountKey.id,
         });
         log_1.default.succeed(`Google Service Account Key assigned to ${this.app.androidApplicationIdentifier} for submissions`);

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

@@ -13,11 +13,11 @@ const prompts_1 = require("../../../prompts");
  * EAS credentials set up yet
  */
 async function canCopyLegacyCredentialsAsync(ctx, app) {
-    const appCredentials = await ctx.android.getAndroidAppCredentialsWithCommonFieldsAsync(app);
+    const appCredentials = await ctx.android.getAndroidAppCredentialsWithCommonFieldsAsync(ctx.graphqlClient, app);
     if (appCredentials) {
         return false; // modern credentials already exist
     }
-    const legacyAppCredentials = await ctx.android.getLegacyAndroidAppCredentialsWithCommonFieldsAsync(app);
+    const legacyAppCredentials = await ctx.android.getLegacyAndroidAppCredentialsWithCommonFieldsAsync(ctx.graphqlClient, app);
     return !!legacyAppCredentials; // user has some legacy credentials
 }
 exports.canCopyLegacyCredentialsAsync = canCopyLegacyCredentialsAsync;
@@ -26,22 +26,22 @@ async function promptUserAndCopyLegacyCredentialsAsync(ctx, app) {
     (0, assert_1.default)(await canCopyLegacyCredentialsAsync(ctx, app), 'User not eligible to copy classic build credentials to EAS');
     const spinner = (0, ora_1.ora)('Classic credentials detected, copying to EAS...').start();
     try {
-        const legacyAppCredentials = await ctx.android.getLegacyAndroidAppCredentialsWithCommonFieldsAsync(app);
+        const legacyAppCredentials = await ctx.android.getLegacyAndroidAppCredentialsWithCommonFieldsAsync(ctx.graphqlClient, app);
         if (!legacyAppCredentials) {
             return;
         }
-        const appCredentials = await ctx.android.createOrGetExistingAndroidAppCredentialsWithBuildCredentialsAsync(app);
+        const appCredentials = await ctx.android.createOrGetExistingAndroidAppCredentialsWithBuildCredentialsAsync(ctx.graphqlClient, app);
         const legacyFcm = legacyAppCredentials.androidFcm;
         if (legacyFcm) {
-            const clonedFcm = await ctx.android.createFcmAsync(app.account, legacyFcm.credential, legacyFcm.version);
-            await ctx.android.updateAndroidAppCredentialsAsync(appCredentials, {
+            const clonedFcm = await ctx.android.createFcmAsync(ctx.graphqlClient, app.account, legacyFcm.credential, legacyFcm.version);
+            await ctx.android.updateAndroidAppCredentialsAsync(ctx.graphqlClient, appCredentials, {
                 androidFcmId: clonedFcm.id,
             });
         }
-        const legacyBuildCredentials = await ctx.android.getLegacyAndroidAppBuildCredentialsAsync(app);
+        const legacyBuildCredentials = await ctx.android.getLegacyAndroidAppBuildCredentialsAsync(ctx.graphqlClient, app);
         const legacyKeystore = (_a = legacyBuildCredentials === null || legacyBuildCredentials === void 0 ? void 0 : legacyBuildCredentials.androidKeystore) !== null && _a !== void 0 ? _a : null;
         if (legacyKeystore) {
-            const clonedKeystore = await ctx.android.createKeystoreAsync(app.account, {
+            const clonedKeystore = await ctx.android.createKeystoreAsync(ctx.graphqlClient, app.account, {
                 keystore: legacyKeystore.keystore,
                 keystorePassword: legacyKeystore.keystorePassword,
                 keyAlias: legacyKeystore.keyAlias,
@@ -64,7 +64,7 @@ async function getAppLookupParamsFromContextAsync(ctx, gradleContext) {
     ctx.ensureProjectContext();
     const projectName = ctx.exp.slug;
     const projectId = ctx.projectId;
-    const account = await (0, projectUtils_1.getOwnerAccountForProjectIdAsync)(projectId);
+    const account = await (0, projectUtils_1.getOwnerAccountForProjectIdAsync)(ctx.graphqlClient, projectId);
     const androidApplicationIdentifier = await (0, applicationId_1.getApplicationIdAsync)(ctx.projectDir, ctx.exp, gradleContext);
     if (!androidApplicationIdentifier) {
         throw new Error(`android.package needs to be defined in your ${(0, projectUtils_1.getProjectConfigDescription)(ctx.projectDir)} file`);
@@ -74,11 +74,11 @@ async function getAppLookupParamsFromContextAsync(ctx, gradleContext) {
 exports.getAppLookupParamsFromContextAsync = getAppLookupParamsFromContextAsync;
 async function createOrUpdateDefaultAndroidAppBuildCredentialsAsync(ctx, appLookupParams, { androidKeystoreId, }) {
     (0, assert_1.default)(!ctx.nonInteractive, 'createOrUpdateDefaultAndroidAppBuildCredentialsAsync must be run in interactive mode');
-    const existingDefaultBuildCredentials = await ctx.android.getDefaultAndroidAppBuildCredentialsAsync(appLookupParams);
+    const existingDefaultBuildCredentials = await ctx.android.getDefaultAndroidAppBuildCredentialsAsync(ctx.graphqlClient, appLookupParams);
     if (existingDefaultBuildCredentials) {
-        return await ctx.android.updateAndroidAppBuildCredentialsAsync(existingDefaultBuildCredentials, { androidKeystoreId });
+        return await ctx.android.updateAndroidAppBuildCredentialsAsync(ctx.graphqlClient, existingDefaultBuildCredentials, { androidKeystoreId });
     }
-    return await ctx.android.createAndroidAppBuildCredentialsAsync(appLookupParams, {
+    return await ctx.android.createAndroidAppBuildCredentialsAsync(ctx.graphqlClient, appLookupParams, {
         name: generateRandomName(),
         isDefault: true,
         androidKeystoreId,

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

@@ -21,7 +21,7 @@ class CreateFcm {
                 validate: (value) => value.length > 0 || "FCM API Key can't be empty",
             },
         ]);
-        const fcmFragment = await ctx.android.createFcmAsync(this.account, fcmApiKey, generated_1.AndroidFcmVersion.Legacy);
+        const fcmFragment = await ctx.android.createFcmAsync(ctx.graphqlClient, this.account, fcmApiKey, generated_1.AndroidFcmVersion.Legacy);
         log_1.default.succeed('Uploaded FCM API Key');
         return fcmFragment;
     }

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

@@ -16,7 +16,7 @@ class CreateGoogleServiceAccountKey {
             throw new Error(`New Google Service Account Key cannot be created in non-interactive mode.`);
         }
         const jsonKeyObject = await this.provideAsync(ctx);
-        const gsaKeyFragment = await ctx.android.createGoogleServiceAccountKeyAsync(this.account, jsonKeyObject);
+        const gsaKeyFragment = await ctx.android.createGoogleServiceAccountKeyAsync(ctx.graphqlClient, this.account, jsonKeyObject);
         log_1.default.succeed('Uploaded Google Service Account Key.');
         return gsaKeyFragment;
     }

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

@@ -16,19 +16,19 @@ class CreateKeystore {
             throw new Error(`New keystore cannot be created in non-interactive mode.`);
         }
         const projectId = ctx.projectId;
-        const keystore = await this.provideOrGenerateAsync(projectId);
-        const keystoreFragment = await ctx.android.createKeystoreAsync(this.account, keystore);
+        const keystore = await this.provideOrGenerateAsync(ctx.graphqlClient, projectId);
+        const keystoreFragment = await ctx.android.createKeystoreAsync(ctx.graphqlClient, this.account, keystore);
         log_1.default.succeed('Created keystore');
         return keystoreFragment;
     }
-    async provideOrGenerateAsync(projectId) {
+    async provideOrGenerateAsync(graphqlClient, projectId) {
         const providedKeystore = await (0, promptForCredentials_1.askForUserProvidedAsync)(credentials_1.keystoreSchema);
         if (providedKeystore) {
             const providedKeystoreWithType = (0, keystoreNew_1.getKeystoreWithType)(providedKeystore);
             (0, keystoreNew_1.validateKeystore)(providedKeystoreWithType);
             return providedKeystoreWithType;
         }
-        return await (0, keystore_1.generateRandomKeystoreAsync)(projectId);
+        return await (0, keystore_1.generateRandomKeystoreAsync)(graphqlClient, projectId);
     }
 }
 exports.CreateKeystore = CreateKeystore;

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

@@ -13,7 +13,7 @@ class RemoveFcm {
         if (ctx.nonInteractive) {
             throw new Error("Deleting an FCM API Key is a destructive operation. Start the CLI without the '--non-interactive' flag to delete the credentials.");
         }
-        const appCredentials = await ctx.android.getAndroidAppCredentialsWithCommonFieldsAsync(this.app);
+        const appCredentials = await ctx.android.getAndroidAppCredentialsWithCommonFieldsAsync(ctx.graphqlClient, this.app);
         const fcm = appCredentials === null || appCredentials === void 0 ? void 0 : appCredentials.androidFcm;
         if (!fcm) {
             log_1.default.warn(`There is no valid FCM API Key defined for ${(0, GraphqlClient_1.formatProjectFullName)(this.app)}, ${this.app.androidApplicationIdentifier}`);
@@ -26,7 +26,7 @@ class RemoveFcm {
         if (!confirm) {
             return;
         }
-        await ctx.android.deleteFcmAsync(fcm);
+        await ctx.android.deleteFcmAsync(ctx.graphqlClient, fcm);
         log_1.default.succeed('FCM API Key removed');
     }
 }

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

@@ -13,7 +13,7 @@ class SelectAndRemoveGoogleServiceAccountKey {
         if (ctx.nonInteractive) {
             throw new Error(`Cannot select and remove Google Service Account Keys in non-interactive mode.`);
         }
-        const gsaKeyFragments = await ctx.android.getGoogleServiceAccountKeysForAccountAsync(this.account);
+        const gsaKeyFragments = await ctx.android.getGoogleServiceAccountKeysForAccountAsync(ctx.graphqlClient, this.account);
         if (gsaKeyFragments.length === 0) {
             log_1.default.warn("There aren't any Google Service Account Keys associated with your account.");
             return;
@@ -42,7 +42,7 @@ class RemoveGoogleServiceAccountKey {
             return;
         }
         log_1.default.log('Removing Google Service Account Key.');
-        await ctx.android.deleteGoogleServiceAccountKeyAsync(this.googleServiceAccountKey);
+        await ctx.android.deleteGoogleServiceAccountKeyAsync(ctx.graphqlClient, this.googleServiceAccountKey);
     }
 }
 exports.RemoveGoogleServiceAccountKey = RemoveGoogleServiceAccountKey;

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

@@ -28,7 +28,7 @@ class RemoveKeystore {
             return;
         }
         await new DownloadKeystore_1.BackupKeystore(this.app).runAsync(ctx, buildCredentials);
-        await ctx.android.deleteKeystoreAsync(keystore);
+        await ctx.android.deleteKeystoreAsync(ctx.graphqlClient, keystore);
         log_1.default.succeed('Keystore removed');
     }
     displayWarning() {

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

@@ -40,7 +40,7 @@ class SetUpBuildCredentials {
     }
     async assignBuildCredentialsAsync({ ctx, app, name, keystore, }) {
         if (name) {
-            return await ctx.android.createOrUpdateAndroidAppBuildCredentialsByNameAsync(app, name, {
+            return await ctx.android.createOrUpdateAndroidAppBuildCredentialsByNameAsync(ctx.graphqlClient, app, name, {
                 androidKeystoreId: keystore.id,
             });
         }
@@ -53,7 +53,7 @@ class SetUpBuildCredentials {
         if (name) {
             return await this.getFullySetupBuildCredentialsByNameAsync({ ctx, app, name });
         }
-        const defaultBuildCredentials = await ctx.android.getDefaultAndroidAppBuildCredentialsAsync(app);
+        const defaultBuildCredentials = await ctx.android.getDefaultAndroidAppBuildCredentialsAsync(ctx.graphqlClient, app);
         const defaultKeystore = (_a = defaultBuildCredentials === null || defaultBuildCredentials === void 0 ? void 0 : defaultBuildCredentials.androidKeystore) !== null && _a !== void 0 ? _a : null;
         if (defaultKeystore) {
             (0, ora_1.ora)(`Using Keystore from configuration: ${(0, nullthrows_1.default)(defaultBuildCredentials).name} (default)`).succeed();
@@ -63,7 +63,7 @@ class SetUpBuildCredentials {
     }
     async getFullySetupBuildCredentialsByNameAsync({ ctx, app, name, }) {
         var _a;
-        const maybeBuildCredentials = await ctx.android.getAndroidAppBuildCredentialsByNameAsync(app, name);
+        const maybeBuildCredentials = await ctx.android.getAndroidAppBuildCredentialsByNameAsync(ctx.graphqlClient, app, name);
         const keystore = (_a = maybeBuildCredentials === null || maybeBuildCredentials === void 0 ? void 0 : maybeBuildCredentials.androidKeystore) !== null && _a !== void 0 ? _a : null;
         if (keystore) {
             const buildCredentials = (0, nullthrows_1.default)(maybeBuildCredentials);

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

@@ -47,17 +47,17 @@ class SetUpBuildCredentialsFromCredentialsJson {
                 return null;
             }
         }
-        const keystoreFragment = await ctx.android.createKeystoreAsync(this.app.account, providedKeystoreWithType);
+        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(this.app, {
+            buildCredentials = await ctx.android.createAndroidAppBuildCredentialsAsync(ctx.graphqlClient, this.app, {
                 ...selectBuildCredentialsResult.result,
                 androidKeystoreId: keystoreFragment.id,
             });
         }
         else {
-            buildCredentials = await ctx.android.updateAndroidAppBuildCredentialsAsync(selectBuildCredentialsResult.result, {
+            buildCredentials = await ctx.android.updateAndroidAppBuildCredentialsAsync(ctx.graphqlClient, selectBuildCredentialsResult.result, {
                 androidKeystoreId: keystoreFragment.id,
             });
         }

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

@@ -17,12 +17,12 @@ class SetUpGoogleServiceAccountKey {
         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(this.app), 'androidAppCredentials cannot be null if google service account key is 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(this.app.account);
+        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);
@@ -33,7 +33,7 @@ class SetUpGoogleServiceAccountKey {
         return await new AssignGoogleServiceAccountKey_1.AssignGoogleServiceAccountKey(this.app).runAsync(ctx, googleServiceAccountKey);
     }
     async isGoogleServiceAccountKeySetupAsync(ctx) {
-        const appCredentials = await ctx.android.getAndroidAppCredentialsWithCommonFieldsAsync(this.app);
+        const appCredentials = await ctx.android.getAndroidAppCredentialsWithCommonFieldsAsync(ctx.graphqlClient, this.app);
         return !!(appCredentials === null || appCredentials === void 0 ? void 0 : appCredentials.googleServiceAccountKeyForSubmissions);
     }
     async createOrUseExistingKeyAsync(ctx) {

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

@@ -12,7 +12,7 @@ class UseExistingGoogleServiceAccountKey {
         if (ctx.nonInteractive) {
             throw new Error(`Existing Google Service Account Key cannot be chosen in non-interactive mode.`);
         }
-        const gsaKeyFragments = await ctx.android.getGoogleServiceAccountKeysForAccountAsync(this.account);
+        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;

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

@@ -1,3 +1,4 @@
+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 {
@@ -5,34 +6,34 @@ export interface AppLookupParams {
     projectName: string;
     androidApplicationIdentifier: string;
 }
-export declare function getAndroidAppCredentialsWithCommonFieldsAsync(appLookupParams: AppLookupParams): Promise<CommonAndroidAppCredentialsFragment | null>;
-export declare function getAndroidAppBuildCredentialsListAsync(appLookupParams: AppLookupParams): Promise<AndroidAppBuildCredentialsFragment[]>;
-export declare function getLegacyAndroidAppCredentialsWithCommonFieldsAsync(appLookupParams: AppLookupParams): Promise<CommonAndroidAppCredentialsFragment | null>;
-export declare function getLegacyAndroidAppBuildCredentialsAsync(appLookupParams: AppLookupParams): Promise<AndroidAppBuildCredentialsFragment | null>;
-export declare function createOrGetExistingAndroidAppCredentialsWithBuildCredentialsAsync(appLookupParams: AppLookupParams): Promise<CommonAndroidAppCredentialsFragment>;
-export declare function updateAndroidAppCredentialsAsync(appCredentials: CommonAndroidAppCredentialsFragment, { androidFcmId, googleServiceAccountKeyForSubmissionsId, }: {
+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, }: {
     androidFcmId?: string;
     googleServiceAccountKeyForSubmissionsId?: string;
 }): Promise<CommonAndroidAppCredentialsFragment>;
-export declare function updateAndroidAppBuildCredentialsAsync(buildCredentials: AndroidAppBuildCredentialsFragment, { androidKeystoreId, }: {
+export declare function updateAndroidAppBuildCredentialsAsync(graphqlClient: ExpoGraphqlClient, buildCredentials: AndroidAppBuildCredentialsFragment, { androidKeystoreId, }: {
     androidKeystoreId: string;
 }): Promise<AndroidAppBuildCredentialsFragment>;
-export declare function createAndroidAppBuildCredentialsAsync(appLookupParams: AppLookupParams, { name, isDefault, androidKeystoreId, }: {
+export declare function createAndroidAppBuildCredentialsAsync(graphqlClient: ExpoGraphqlClient, appLookupParams: AppLookupParams, { name, isDefault, androidKeystoreId, }: {
     name: string;
     isDefault: boolean;
     androidKeystoreId: string;
 }): Promise<AndroidAppBuildCredentialsFragment>;
-export declare function getDefaultAndroidAppBuildCredentialsAsync(appLookupParams: AppLookupParams): Promise<AndroidAppBuildCredentialsFragment | null>;
-export declare function getAndroidAppBuildCredentialsByNameAsync(appLookupParams: AppLookupParams, name: string): Promise<AndroidAppBuildCredentialsFragment | null>;
-export declare function createOrUpdateAndroidAppBuildCredentialsByNameAsync(appLookupParams: AppLookupParams, name: string, { androidKeystoreId, }: {
+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(account: AccountFragment, keystore: KeystoreWithType): Promise<AndroidKeystoreFragment>;
-export declare function deleteKeystoreAsync(keystore: AndroidKeystoreFragment): Promise<void>;
-export declare function createFcmAsync(account: AccountFragment, fcmApiKey: string, version: AndroidFcmVersion): Promise<AndroidFcmFragment>;
-export declare function deleteFcmAsync(fcm: AndroidFcmFragment): Promise<void>;
-export declare function createGoogleServiceAccountKeyAsync(account: AccountFragment, jsonKey: GoogleServiceAccountKey): Promise<GoogleServiceAccountKeyFragment>;
-export declare function deleteGoogleServiceAccountKeyAsync(googleServiceAccountKey: GoogleServiceAccountKeyFragment): Promise<void>;
-export declare function getGoogleServiceAccountKeysForAccountAsync(account: AccountFragment): Promise<GoogleServiceAccountKeyFragment[]>;
+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;