eas-cli 2.3.0 → 2.4.1

package/build/graphql/queries/AppQuery.d.ts

@@ -1,5 +1,6 @@
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
 import { AppFragment } from '../generated';
 export declare const AppQuery: {
-    byIdAsync(projectId: string): Promise<AppFragment>;
-    byFullNameAsync(fullName: string): Promise<AppFragment>;
+    byIdAsync(graphqlClient: ExpoGraphqlClient, projectId: string): Promise<AppFragment>;
+    byFullNameAsync(graphqlClient: ExpoGraphqlClient, fullName: string): Promise<AppFragment>;
 };

package/build/graphql/queries/AppQuery.js

@@ -8,8 +8,8 @@ const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
 const client_1 = require("../client");
 const App_1 = require("../types/App");
 exports.AppQuery = {
-    async byIdAsync(projectId) {
-        const data = await (0, client_1.withErrorHandlingAsync)(client_1.graphqlClient
+    async byIdAsync(graphqlClient, projectId) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `
             query AppByIdQuery($appId: String!) {
               app {
@@ -27,8 +27,8 @@ exports.AppQuery = {
         (0, assert_1.default)(data.app, 'GraphQL: `app` not defined in server response');
         return data.app.byId;
     },
-    async byFullNameAsync(fullName) {
-        const data = await (0, client_1.withErrorHandlingAsync)(client_1.graphqlClient
+    async byFullNameAsync(graphqlClient, fullName) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `
             query AppByFullNameQuery($fullName: String!) {
               app {

package/build/graphql/queries/AppVersionQuery.d.ts

@@ -1,4 +1,5 @@
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
 import { AppPlatform, AppVersion } from '../generated';
 export declare const AppVersionQuery: {
-    latestVersionAsync(appId: string, platform: AppPlatform, applicationIdentifier: string): Promise<Pick<AppVersion, 'storeVersion' | 'buildVersion'> | null>;
+    latestVersionAsync(graphqlClient: ExpoGraphqlClient, appId: string, platform: AppPlatform, applicationIdentifier: string): Promise<Pick<AppVersion, 'storeVersion' | 'buildVersion'> | null>;
 };

package/build/graphql/queries/AppVersionQuery.js

@@ -5,9 +5,9 @@ const tslib_1 = require("tslib");
 const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
 const client_1 = require("../client");
 exports.AppVersionQuery = {
-    async latestVersionAsync(appId, platform, applicationIdentifier) {
+    async latestVersionAsync(graphqlClient, appId, platform, applicationIdentifier) {
         var _a;
-        const data = await (0, client_1.withErrorHandlingAsync)(client_1.graphqlClient
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `
             query LatestAppVersion(
               $appId: String!

package/build/graphql/queries/BranchQuery.d.ts

@@ -1,7 +1,8 @@
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
 import { BranchesByAppQueryVariables, UpdateBranchFragment, ViewBranchQuery, ViewBranchQueryVariables, ViewBranchesOnUpdateChannelQuery, ViewBranchesOnUpdateChannelQueryVariables } from '../generated';
 export declare type UpdateBranchOnChannelObject = NonNullable<ViewBranchesOnUpdateChannelQuery['app']['byId']['updateChannelByName']>['updateBranches'][number];
 export declare const BranchQuery: {
-    getBranchByNameAsync({ appId, name, }: ViewBranchQueryVariables): Promise<NonNullable<ViewBranchQuery['app']['byId']['updateBranchByName']>>;
-    listBranchesOnAppAsync({ appId, limit, offset, }: BranchesByAppQueryVariables): Promise<UpdateBranchFragment[]>;
-    listBranchesOnChannelAsync({ appId, channelName, offset, limit, }: ViewBranchesOnUpdateChannelQueryVariables): Promise<UpdateBranchOnChannelObject[]>;
+    getBranchByNameAsync(graphqlClient: ExpoGraphqlClient, { appId, name }: ViewBranchQueryVariables): Promise<NonNullable<ViewBranchQuery['app']['byId']['updateBranchByName']>>;
+    listBranchesOnAppAsync(graphqlClient: ExpoGraphqlClient, { appId, limit, offset }: BranchesByAppQueryVariables): Promise<UpdateBranchFragment[]>;
+    listBranchesOnChannelAsync(graphqlClient: ExpoGraphqlClient, { appId, channelName, offset, limit }: ViewBranchesOnUpdateChannelQueryVariables): Promise<UpdateBranchOnChannelObject[]>;
 };

package/build/graphql/queries/BranchQuery.js

@@ -9,8 +9,8 @@ const client_1 = require("../client");
 const Update_1 = require("../types/Update");
 const UpdateBranch_1 = require("../types/UpdateBranch");
 exports.BranchQuery = {
-    async getBranchByNameAsync({ appId, name, }) {
-        const response = await (0, client_1.withErrorHandlingAsync)(client_1.graphqlClient
+    async getBranchByNameAsync(graphqlClient, { appId, name }) {
+        const response = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `
             query ViewBranch($appId: String!, $name: String!) {
               app {
@@ -34,9 +34,9 @@ exports.BranchQuery = {
         }
         return updateBranchByName;
     },
-    async listBranchesOnAppAsync({ appId, limit, offset, }) {
+    async listBranchesOnAppAsync(graphqlClient, { appId, limit, offset }) {
         var _a, _b;
-        const data = await (0, client_1.withErrorHandlingAsync)(client_1.graphqlClient
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `
             query BranchesByAppQuery($appId: String!, $limit: Int!, $offset: Int!) {
               app {
@@ -58,8 +58,8 @@ exports.BranchQuery = {
             .toPromise());
         return (_b = (_a = data === null || data === void 0 ? void 0 : data.app) === null || _a === void 0 ? void 0 : _a.byId.updateBranches) !== null && _b !== void 0 ? _b : [];
     },
-    async listBranchesOnChannelAsync({ appId, channelName, offset, limit, }) {
-        const response = await (0, client_1.withErrorHandlingAsync)(client_1.graphqlClient
+    async listBranchesOnChannelAsync(graphqlClient, { appId, channelName, offset, limit }) {
+        const response = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `
             query ViewBranchesOnUpdateChannel(
               $appId: String!

package/build/graphql/queries/BuildQuery.d.ts

@@ -1,10 +1,11 @@
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
 import { BuildFragment, BuildWithSubmissionsFragment, ViewBuildsOnAppQueryVariables } from '../generated';
 export declare const BuildQuery: {
-    byIdAsync(buildId: string, { useCache }?: {
+    byIdAsync(graphqlClient: ExpoGraphqlClient, buildId: string, { useCache }?: {
         useCache?: boolean | undefined;
     }): Promise<BuildFragment>;
-    withSubmissionsByIdAsync(buildId: string, { useCache }?: {
+    withSubmissionsByIdAsync(graphqlClient: ExpoGraphqlClient, buildId: string, { useCache }?: {
         useCache?: boolean | undefined;
     }): Promise<BuildWithSubmissionsFragment>;
-    viewBuildsOnAppAsync({ appId, limit, offset, filter, }: ViewBuildsOnAppQueryVariables): Promise<BuildFragment[]>;
+    viewBuildsOnAppAsync(graphqlClient: ExpoGraphqlClient, { appId, limit, offset, filter }: ViewBuildsOnAppQueryVariables): Promise<BuildFragment[]>;
 };

package/build/graphql/queries/BuildQuery.js

@@ -7,8 +7,8 @@ const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
 const client_1 = require("../client");
 const Build_1 = require("../types/Build");
 exports.BuildQuery = {
-    async byIdAsync(buildId, { useCache = true } = {}) {
-        const data = await (0, client_1.withErrorHandlingAsync)(client_1.graphqlClient
+    async byIdAsync(graphqlClient, buildId, { useCache = true } = {}) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `
             query BuildsByIdQuery($buildId: ID!) {
               builds {
@@ -26,8 +26,8 @@ exports.BuildQuery = {
             .toPromise());
         return data.builds.byId;
     },
-    async withSubmissionsByIdAsync(buildId, { useCache = true } = {}) {
-        const data = await (0, client_1.withErrorHandlingAsync)(client_1.graphqlClient
+    async withSubmissionsByIdAsync(graphqlClient, buildId, { useCache = true } = {}) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `
             query BuildsWithSubmissionsByIdQuery($buildId: ID!) {
               builds {
@@ -45,9 +45,9 @@ exports.BuildQuery = {
             .toPromise());
         return data.builds.byId;
     },
-    async viewBuildsOnAppAsync({ appId, limit, offset, filter, }) {
+    async viewBuildsOnAppAsync(graphqlClient, { appId, limit, offset, filter }) {
         var _a, _b;
-        const data = await (0, client_1.withErrorHandlingAsync)(client_1.graphqlClient
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query(
         // TODO: Change $appId: String! to ID! when fixed server-side schema
         (0, graphql_tag_1.default) `

package/build/graphql/queries/ChannelQuery.d.ts

@@ -1,7 +1,8 @@
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
 import { ViewUpdateChannelOnAppQuery, ViewUpdateChannelOnAppQueryVariables, ViewUpdateChannelsOnAppQuery, ViewUpdateChannelsOnAppQueryVariables } from '../generated';
 export declare type UpdateChannelObject = NonNullable<ViewUpdateChannelsOnAppQuery['app']['byId']['updateChannels']>[number];
 export declare type UpdateChannelByNameObject = NonNullable<ViewUpdateChannelOnAppQuery['app']['byId']['updateChannelByName']>;
 export declare const ChannelQuery: {
-    viewUpdateChannelAsync({ appId, channelName, }: ViewUpdateChannelOnAppQueryVariables): Promise<UpdateChannelByNameObject>;
-    viewUpdateChannelsOnAppAsync({ appId, limit, offset, }: ViewUpdateChannelsOnAppQueryVariables): Promise<UpdateChannelObject[]>;
+    viewUpdateChannelAsync(graphqlClient: ExpoGraphqlClient, { appId, channelName }: ViewUpdateChannelOnAppQueryVariables): Promise<UpdateChannelByNameObject>;
+    viewUpdateChannelsOnAppAsync(graphqlClient: ExpoGraphqlClient, { appId, limit, offset }: ViewUpdateChannelsOnAppQueryVariables): Promise<UpdateChannelObject[]>;
 };

package/build/graphql/queries/ChannelQuery.js

@@ -7,8 +7,8 @@ const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
 const client_1 = require("../client");
 const Update_1 = require("../types/Update");
 exports.ChannelQuery = {
-    async viewUpdateChannelAsync({ appId, channelName, }) {
-        const response = await (0, client_1.withErrorHandlingAsync)(client_1.graphqlClient
+    async viewUpdateChannelAsync(graphqlClient, { appId, channelName }) {
+        const response = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `
             query ViewUpdateChannelOnApp($appId: String!, $channelName: String!) {
               app {
@@ -40,8 +40,8 @@ exports.ChannelQuery = {
         }
         return updateChannelByName;
     },
-    async viewUpdateChannelsOnAppAsync({ appId, limit, offset, }) {
-        const response = await (0, client_1.withErrorHandlingAsync)(client_1.graphqlClient
+    async viewUpdateChannelsOnAppAsync(graphqlClient, { appId, limit, offset }) {
+        const response = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `
             query ViewUpdateChannelsOnApp($appId: String!, $offset: Int!, $limit: Int!) {
               app {

package/build/graphql/queries/EnvironmentSecretsQuery.d.ts

@@ -1,3 +1,4 @@
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
 import { EnvironmentSecretFragment } from '../generated';
 export declare enum EnvironmentSecretScope {
     ACCOUNT = "account",
@@ -7,9 +8,9 @@ export declare type EnvironmentSecretWithScope = EnvironmentSecretFragment & {
     scope: EnvironmentSecretScope;
 };
 export declare const EnvironmentSecretsQuery: {
-    byAppIdAsync(appId: string): Promise<{
+    byAppIdAsync(graphqlClient: ExpoGraphqlClient, appId: string): Promise<{
         accountSecrets: EnvironmentSecretFragment[];
         appSecrets: EnvironmentSecretFragment[];
     }>;
-    allAsync(projectId: string): Promise<EnvironmentSecretWithScope[]>;
+    allAsync(graphqlClient: ExpoGraphqlClient, projectId: string): Promise<EnvironmentSecretWithScope[]>;
 };

package/build/graphql/queries/EnvironmentSecretsQuery.js

@@ -12,9 +12,9 @@ var EnvironmentSecretScope;
     EnvironmentSecretScope["PROJECT"] = "project";
 })(EnvironmentSecretScope = exports.EnvironmentSecretScope || (exports.EnvironmentSecretScope = {}));
 exports.EnvironmentSecretsQuery = {
-    async byAppIdAsync(appId) {
+    async byAppIdAsync(graphqlClient, appId) {
         var _a, _b, _c, _d;
-        const data = await (0, client_1.withErrorHandlingAsync)(client_1.graphqlClient
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `
             query EnvironmentSecretsByAppId($appId: String!) {
               app {
@@ -42,8 +42,8 @@ exports.EnvironmentSecretsQuery = {
             appSecrets: (_d = (_c = data.app) === null || _c === void 0 ? void 0 : _c.byId.environmentSecrets) !== null && _d !== void 0 ? _d : [],
         };
     },
-    async allAsync(projectId) {
-        const { accountSecrets, appSecrets } = await this.byAppIdAsync(projectId);
+    async allAsync(graphqlClient, projectId) {
+        const { accountSecrets, appSecrets } = await this.byAppIdAsync(graphqlClient, projectId);
         return [
             ...appSecrets.map(s => ({ ...s, scope: EnvironmentSecretScope.PROJECT })),
             ...accountSecrets.map(s => ({ ...s, scope: EnvironmentSecretScope.ACCOUNT })),

package/build/graphql/queries/PublishQuery.d.ts

@@ -1,5 +1,6 @@
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
 import { AssetMetadataResult, GetAssetLimitPerUpdateGroupForAppQuery } from '../generated';
 export declare const PublishQuery: {
-    getAssetMetadataAsync(storageKeys: string[]): Promise<AssetMetadataResult[]>;
-    getAssetLimitPerUpdateGroupAsync(appId: string): Promise<GetAssetLimitPerUpdateGroupForAppQuery['app']['byId']['assetLimitPerUpdateGroup']>;
+    getAssetMetadataAsync(graphqlClient: ExpoGraphqlClient, storageKeys: string[]): Promise<AssetMetadataResult[]>;
+    getAssetLimitPerUpdateGroupAsync(graphqlClient: ExpoGraphqlClient, appId: string): Promise<GetAssetLimitPerUpdateGroupForAppQuery['app']['byId']['assetLimitPerUpdateGroup']>;
 };

package/build/graphql/queries/PublishQuery.js

@@ -5,8 +5,8 @@ const tslib_1 = require("tslib");
 const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
 const client_1 = require("../client");
 exports.PublishQuery = {
-    async getAssetMetadataAsync(storageKeys) {
-        const data = await (0, client_1.withErrorHandlingAsync)(client_1.graphqlClient
+    async getAssetMetadataAsync(graphqlClient, storageKeys) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `
             query GetAssetMetadataQuery($storageKeys: [String!]!) {
               asset {
@@ -26,8 +26,8 @@ exports.PublishQuery = {
             .toPromise());
         return data.asset.metadata;
     },
-    async getAssetLimitPerUpdateGroupAsync(appId) {
-        const data = await (0, client_1.withErrorHandlingAsync)(client_1.graphqlClient
+    async getAssetLimitPerUpdateGroupAsync(graphqlClient, appId) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `
             query GetAssetLimitPerUpdateGroupForApp($appId: String!) {
               app {

package/build/graphql/queries/StatuspageServiceQuery.d.ts

@@ -1,4 +1,5 @@
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
 import { StatuspageServiceFragment, StatuspageServiceName } from '../generated';
 export declare const StatuspageServiceQuery: {
-    statuspageServicesAsync(serviceNames: StatuspageServiceName[]): Promise<StatuspageServiceFragment[]>;
+    statuspageServicesAsync(graphqlClient: ExpoGraphqlClient, serviceNames: StatuspageServiceName[]): Promise<StatuspageServiceFragment[]>;
 };

package/build/graphql/queries/StatuspageServiceQuery.js

@@ -7,8 +7,8 @@ const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
 const client_1 = require("../client");
 const StatuspageService_1 = require("../types/StatuspageService");
 exports.StatuspageServiceQuery = {
-    async statuspageServicesAsync(serviceNames) {
-        const data = await (0, client_1.withErrorHandlingAsync)(client_1.graphqlClient
+    async statuspageServicesAsync(graphqlClient, serviceNames) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `
             query StatuspageServiceByServiceNamesQuery($serviceNames: [StatuspageServiceName!]!) {
               statuspageService {

package/build/graphql/queries/SubmissionQuery.d.ts

@@ -1,3 +1,4 @@
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
 import { AppPlatform, SubmissionFragment, SubmissionStatus } from '../generated';
 declare type Filters = {
     platform?: AppPlatform;
@@ -6,9 +7,9 @@ declare type Filters = {
     limit?: number;
 };
 export declare const SubmissionQuery: {
-    byIdAsync(submissionId: string, { useCache }?: {
+    byIdAsync(graphqlClient: ExpoGraphqlClient, submissionId: string, { useCache }?: {
         useCache?: boolean | undefined;
     }): Promise<SubmissionFragment>;
-    allForAppAsync(appId: string, { limit, offset, status, platform }: Filters): Promise<SubmissionFragment[]>;
+    allForAppAsync(graphqlClient: ExpoGraphqlClient, appId: string, { limit, offset, status, platform }: Filters): Promise<SubmissionFragment[]>;
 };
 export {};

package/build/graphql/queries/SubmissionQuery.js

@@ -7,8 +7,8 @@ const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
 const client_1 = require("../client");
 const Submission_1 = require("../types/Submission");
 exports.SubmissionQuery = {
-    async byIdAsync(submissionId, { useCache = true } = {}) {
-        const data = await (0, client_1.withErrorHandlingAsync)(client_1.graphqlClient
+    async byIdAsync(graphqlClient, submissionId, { useCache = true } = {}) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `
             query SubmissionsByIdQuery($submissionId: ID!) {
               submissions {
@@ -26,9 +26,9 @@ exports.SubmissionQuery = {
             .toPromise());
         return data.submissions.byId;
     },
-    async allForAppAsync(appId, { limit = 10, offset = 0, status, platform }) {
+    async allForAppAsync(graphqlClient, appId, { limit = 10, offset = 0, status, platform }) {
         var _a, _b;
-        const data = await (0, client_1.withErrorHandlingAsync)(client_1.graphqlClient
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `
             query GetAllSubmissionsForApp(
               $appId: String!

package/build/graphql/queries/UpdateQuery.d.ts

@@ -1,6 +1,7 @@
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
 import { UpdateFragment, ViewUpdateGroupsOnAppQueryVariables, ViewUpdateGroupsOnBranchQueryVariables, ViewUpdatesByGroupQueryVariables } from '../generated';
 export declare const UpdateQuery: {
-    viewUpdateGroupAsync({ groupId, }: ViewUpdatesByGroupQueryVariables): Promise<UpdateFragment[]>;
-    viewUpdateGroupsOnBranchAsync({ limit, offset, appId, branchName, filter, }: ViewUpdateGroupsOnBranchQueryVariables): Promise<UpdateFragment[][]>;
-    viewUpdateGroupsOnAppAsync({ limit, offset, appId, filter, }: ViewUpdateGroupsOnAppQueryVariables): Promise<UpdateFragment[][]>;
+    viewUpdateGroupAsync(graphqlClient: ExpoGraphqlClient, { groupId }: ViewUpdatesByGroupQueryVariables): Promise<UpdateFragment[]>;
+    viewUpdateGroupsOnBranchAsync(graphqlClient: ExpoGraphqlClient, { limit, offset, appId, branchName, filter }: ViewUpdateGroupsOnBranchQueryVariables): Promise<UpdateFragment[][]>;
+    viewUpdateGroupsOnAppAsync(graphqlClient: ExpoGraphqlClient, { limit, offset, appId, filter }: ViewUpdateGroupsOnAppQueryVariables): Promise<UpdateFragment[][]>;
 };

package/build/graphql/queries/UpdateQuery.js

@@ -7,8 +7,8 @@ const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
 const client_1 = require("../client");
 const Update_1 = require("../types/Update");
 exports.UpdateQuery = {
-    async viewUpdateGroupAsync({ groupId, }) {
-        const { updatesByGroup } = await (0, client_1.withErrorHandlingAsync)(client_1.graphqlClient
+    async viewUpdateGroupAsync(graphqlClient, { groupId }) {
+        const { updatesByGroup } = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `
             query ViewUpdatesByGroup($groupId: ID!) {
               updatesByGroup(group: $groupId) {
@@ -26,8 +26,8 @@ exports.UpdateQuery = {
         }
         return updatesByGroup;
     },
-    async viewUpdateGroupsOnBranchAsync({ limit, offset, appId, branchName, filter, }) {
-        const response = await (0, client_1.withErrorHandlingAsync)(client_1.graphqlClient
+    async viewUpdateGroupsOnBranchAsync(graphqlClient, { limit, offset, appId, branchName, filter }) {
+        const response = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `
             query ViewUpdateGroupsOnBranch(
               $appId: String!
@@ -64,8 +64,8 @@ exports.UpdateQuery = {
         }
         return branch.updateGroups;
     },
-    async viewUpdateGroupsOnAppAsync({ limit, offset, appId, filter, }) {
-        const response = await (0, client_1.withErrorHandlingAsync)(client_1.graphqlClient
+    async viewUpdateGroupsOnAppAsync(graphqlClient, { limit, offset, appId, filter }) {
+        const response = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `
             query ViewUpdateGroupsOnApp(
               $appId: String!

package/build/graphql/queries/UserQuery.d.ts

@@ -1,4 +1,5 @@
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
 import { CurrentUserQuery } from '../generated';
 export declare const UserQuery: {
-    currentUserAsync(): Promise<CurrentUserQuery['meActor']>;
+    currentUserAsync(graphqlClient: ExpoGraphqlClient): Promise<CurrentUserQuery['meActor']>;
 };

package/build/graphql/queries/UserQuery.js

@@ -7,8 +7,8 @@ const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
 const client_1 = require("../client");
 const Account_1 = require("../types/Account");
 exports.UserQuery = {
-    async currentUserAsync() {
-        const data = await (0, client_1.withErrorHandlingAsync)(client_1.graphqlClient
+    async currentUserAsync(graphqlClient) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `
             query CurrentUser {
               meActor {

package/build/graphql/queries/WebhookQuery.d.ts

@@ -1,5 +1,6 @@
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
 import { WebhookFilter, WebhookFragment } from '../generated';
 export declare const WebhookQuery: {
-    byAppIdAsync(appId: string, webhookFilter?: WebhookFilter): Promise<WebhookFragment[]>;
-    byIdAsync(webhookId: string): Promise<WebhookFragment>;
+    byAppIdAsync(graphqlClient: ExpoGraphqlClient, appId: string, webhookFilter?: WebhookFilter): Promise<WebhookFragment[]>;
+    byIdAsync(graphqlClient: ExpoGraphqlClient, webhookId: string): Promise<WebhookFragment>;
 };

package/build/graphql/queries/WebhookQuery.js

@@ -7,9 +7,9 @@ const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
 const client_1 = require("../client");
 const Webhook_1 = require("../types/Webhook");
 exports.WebhookQuery = {
-    async byAppIdAsync(appId, webhookFilter) {
+    async byAppIdAsync(graphqlClient, appId, webhookFilter) {
         var _a, _b;
-        const data = await (0, client_1.withErrorHandlingAsync)(client_1.graphqlClient
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `
             query WebhooksByAppId($appId: String!, $webhookFilter: WebhookFilter) {
               app {
@@ -29,8 +29,8 @@ exports.WebhookQuery = {
             .toPromise());
         return (_b = (_a = data.app) === null || _a === void 0 ? void 0 : _a.byId.webhooks) !== null && _b !== void 0 ? _b : [];
     },
-    async byIdAsync(webhookId) {
-        const data = await (0, client_1.withErrorHandlingAsync)(client_1.graphqlClient
+    async byIdAsync(graphqlClient, webhookId) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `
             query WebhookById($webhookId: ID!) {
               webhook {

package/build/project/fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync.d.ts

@@ -1,3 +1,4 @@
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
 import { AppPrivacy } from '../graphql/generated';
 import { Actor } from '../user/User';
 /**
@@ -6,7 +7,7 @@ import { Actor } from '../user/User';
  * 2. If no existing project is found, ask the user whether they would like to register a new one.
  *    If yes, register and return that. If not, throw.
  */
-export declare function fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync(projectInfo: {
+export declare function fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync(graphqlClient: ExpoGraphqlClient, projectInfo: {
     accountName: string;
     projectName: string;
     privacy?: AppPrivacy;
@@ -19,4 +20,4 @@ export declare function fetchOrCreateProjectIDForWriteToConfigWithConfirmationAs
  * @param slug project slug
  * @returns A promise resolving to Project ID, null if it doesn't exist
  */
-export declare function findProjectIdByAccountNameAndSlugNullableAsync(accountName: string, slug: string): Promise<string | null>;
+export declare function findProjectIdByAccountNameAndSlugNullableAsync(graphqlClient: ExpoGraphqlClient, accountName: string, slug: string): Promise<string | null>;

package/build/project/fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync.js

@@ -16,7 +16,7 @@ const prompts_1 = require("../prompts");
  * 2. If no existing project is found, ask the user whether they would like to register a new one.
  *    If yes, register and return that. If not, throw.
  */
-async function fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync(projectInfo, options, actor) {
+async function fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync(graphqlClient, projectInfo, options, actor) {
     var _a;
     const { accountName, projectName } = projectInfo;
     const projectFullName = `@${accountName}/${projectName}`;
@@ -31,7 +31,7 @@ async function fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync(proje
     if (!account) {
         throw new Error(`You must have access to the ${accountName} account to configure this EAS project.`);
     }
-    const projectIdOnServer = await findProjectIdByAccountNameAndSlugNullableAsync(accountName, projectName);
+    const projectIdOnServer = await findProjectIdByAccountNameAndSlugNullableAsync(graphqlClient, accountName, projectName);
     if (projectIdOnServer) {
         const affirmedLink = await (0, prompts_1.confirmAsync)({
             message: `Existing EAS project found for ${projectFullName} (id = ${projectIdOnServer}). Configure this project?`,
@@ -57,7 +57,7 @@ async function fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync(proje
     });
     const spinner = (0, ora_1.ora)(`Creating ${chalk_1.default.bold(projectFullName)} on Expo`).start();
     try {
-        const id = await AppMutation_1.AppMutation.createAppAsync({
+        const id = await AppMutation_1.AppMutation.createAppAsync(graphqlClient, {
             accountId: account.id,
             projectName,
             privacy: (_a = projectInfo.privacy) !== null && _a !== void 0 ? _a : generated_1.AppPrivacy.Public,
@@ -77,10 +77,10 @@ exports.fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync = fetchOrCre
  * @param slug project slug
  * @returns A promise resolving to Project ID, null if it doesn't exist
  */
-async function findProjectIdByAccountNameAndSlugNullableAsync(accountName, slug) {
+async function findProjectIdByAccountNameAndSlugNullableAsync(graphqlClient, accountName, slug) {
     var _a;
     try {
-        const { id } = await AppQuery_1.AppQuery.byFullNameAsync(`@${accountName}/${slug}`);
+        const { id } = await AppQuery_1.AppQuery.byFullNameAsync(graphqlClient, `@${accountName}/${slug}`);
         return id;
     }
     catch (err) {

package/build/project/projectUtils.d.ts

@@ -1,4 +1,5 @@
 import { ExpoConfig } from '@expo/config';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
 import { AccountFragment, AppPrivacy } from '../graphql/generated';
 import { Actor } from '../user/User';
 export declare function getUsername(exp: ExpoConfig, user: Actor): string | undefined;
@@ -15,5 +16,5 @@ export declare function isExpoUpdatesInstalled(projectDir: string): boolean;
 export declare function isExpoUpdatesInstalledOrAvailable(projectDir: string, sdkVersion?: string): boolean;
 export declare function validateAppVersionRuntimePolicySupportAsync(projectDir: string, exp: ExpoConfig): Promise<void>;
 export declare function installExpoUpdatesAsync(projectDir: string): Promise<void>;
-export declare function getOwnerAccountForProjectIdAsync(projectId: string): Promise<AccountFragment>;
-export declare function getDisplayNameForProjectIdAsync(projectId: string): Promise<string>;
+export declare function getOwnerAccountForProjectIdAsync(graphqlClient: ExpoGraphqlClient, projectId: string): Promise<AccountFragment>;
+export declare function getDisplayNameForProjectIdAsync(graphqlClient: ExpoGraphqlClient, projectId: string): Promise<string>;

package/build/project/projectUtils.js

@@ -96,13 +96,13 @@ async function installExpoUpdatesAsync(projectDir) {
     log_1.default.newLine();
 }
 exports.installExpoUpdatesAsync = installExpoUpdatesAsync;
-async function getOwnerAccountForProjectIdAsync(projectId) {
-    const app = await AppQuery_1.AppQuery.byIdAsync(projectId);
+async function getOwnerAccountForProjectIdAsync(graphqlClient, projectId) {
+    const app = await AppQuery_1.AppQuery.byIdAsync(graphqlClient, projectId);
     return app.ownerAccount;
 }
 exports.getOwnerAccountForProjectIdAsync = getOwnerAccountForProjectIdAsync;
-async function getDisplayNameForProjectIdAsync(projectId) {
-    const app = await AppQuery_1.AppQuery.byIdAsync(projectId);
+async function getDisplayNameForProjectIdAsync(graphqlClient, projectId) {
+    const app = await AppQuery_1.AppQuery.byIdAsync(graphqlClient, projectId);
     return app.fullName;
 }
 exports.getDisplayNameForProjectIdAsync = getDisplayNameForProjectIdAsync;

package/build/project/publish.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import { ExpoConfig, Platform } from '@expo/config';
 import Joi from 'joi';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
 import { PartialManifestAsset } from '../graphql/generated';
 export declare type PublishPlatform = Extract<'android' | 'ios', Platform>;
 declare type Metadata = {
@@ -67,7 +68,7 @@ export declare function collectAssetsAsync({ inputDir, platforms, }: {
     inputDir: string;
     platforms: PublishPlatform[];
 }): Promise<CollectedAssets>;
-export declare function filterOutAssetsThatAlreadyExistAsync(uniqueAssetsWithStorageKey: (RawAsset & {
+export declare function filterOutAssetsThatAlreadyExistAsync(graphqlClient: ExpoGraphqlClient, uniqueAssetsWithStorageKey: (RawAsset & {
     storageKey: string;
 })[]): Promise<(RawAsset & {
     storageKey: string;
@@ -78,6 +79,6 @@ declare type AssetUploadResult = {
     uniqueUploadedAssetCount: number;
     assetLimitPerUpdateGroup: number;
 };
-export declare function uploadAssetsAsync(assetsForUpdateInfoGroup: CollectedAssets, projectId: string, updateSpinnerText?: (totalAssets: number, missingAssets: number) => void): Promise<AssetUploadResult>;
+export declare function uploadAssetsAsync(graphqlClient: ExpoGraphqlClient, assetsForUpdateInfoGroup: CollectedAssets, projectId: string, updateSpinnerText?: (totalAssets: number, missingAssets: number) => void): Promise<AssetUploadResult>;
 export declare function isUploadedAssetCountAboveWarningThreshold(uploadedAssetCount: number, assetLimitPerUpdateGroup: number): boolean;
 export {};

package/build/project/publish.js

@@ -174,8 +174,8 @@ async function collectAssetsAsync({ inputDir, platforms, }) {
     return assetsFinal;
 }
 exports.collectAssetsAsync = collectAssetsAsync;
-async function filterOutAssetsThatAlreadyExistAsync(uniqueAssetsWithStorageKey) {
-    const assetMetadata = await PublishQuery_1.PublishQuery.getAssetMetadataAsync(uniqueAssetsWithStorageKey.map(asset => asset.storageKey));
+async function filterOutAssetsThatAlreadyExistAsync(graphqlClient, uniqueAssetsWithStorageKey) {
+    const assetMetadata = await PublishQuery_1.PublishQuery.getAssetMetadataAsync(graphqlClient, uniqueAssetsWithStorageKey.map(asset => asset.storageKey));
     const missingAssetKeys = assetMetadata
         .filter(result => result.status !== generated_1.AssetMetadataStatus.Exists)
         .map(result => result.storageKey);
@@ -185,7 +185,7 @@ async function filterOutAssetsThatAlreadyExistAsync(uniqueAssetsWithStorageKey)
     return missingAssets;
 }
 exports.filterOutAssetsThatAlreadyExistAsync = filterOutAssetsThatAlreadyExistAsync;
-async function uploadAssetsAsync(assetsForUpdateInfoGroup, projectId, updateSpinnerText) {
+async function uploadAssetsAsync(graphqlClient, assetsForUpdateInfoGroup, projectId, updateSpinnerText) {
     let assets = [];
     let platform;
     for (platform in assetsForUpdateInfoGroup) {
@@ -204,18 +204,18 @@ async function uploadAssetsAsync(assetsForUpdateInfoGroup, projectId, updateSpin
     const uniqueAssets = (0, uniqBy_1.default)(assetsWithStorageKey, asset => asset.storageKey);
     const totalAssets = uniqueAssets.length;
     updateSpinnerText === null || updateSpinnerText === void 0 ? void 0 : updateSpinnerText(totalAssets, totalAssets);
-    let missingAssets = await filterOutAssetsThatAlreadyExistAsync(uniqueAssets);
+    let missingAssets = await filterOutAssetsThatAlreadyExistAsync(graphqlClient, uniqueAssets);
     const uniqueUploadedAssetCount = missingAssets.length;
     const missingAssetChunks = (0, chunk_1.default)(missingAssets, 100);
     const specifications = [];
     for (const missingAssets of missingAssetChunks) {
-        const { specifications: chunkSpecifications } = await PublishMutation_1.PublishMutation.getUploadURLsAsync(missingAssets.map(ma => ma.contentType));
+        const { specifications: chunkSpecifications } = await PublishMutation_1.PublishMutation.getUploadURLsAsync(graphqlClient, missingAssets.map(ma => ma.contentType));
         specifications.push(...chunkSpecifications);
     }
     updateSpinnerText === null || updateSpinnerText === void 0 ? void 0 : updateSpinnerText(totalAssets, missingAssets.length);
     const assetUploadPromiseLimit = (0, promise_limit_1.default)(15);
     const [assetLimitPerUpdateGroup] = await Promise.all([
-        PublishQuery_1.PublishQuery.getAssetLimitPerUpdateGroupAsync(projectId),
+        PublishQuery_1.PublishQuery.getAssetLimitPerUpdateGroupAsync(graphqlClient, projectId),
         missingAssets.map((missingAsset, i) => {
             assetUploadPromiseLimit(async () => {
                 const presignedPost = JSON.parse(specifications[i]);
@@ -226,7 +226,7 @@ async function uploadAssetsAsync(assetsForUpdateInfoGroup, projectId, updateSpin
     let timeout = 1;
     while (missingAssets.length > 0) {
         const timeoutPromise = new Promise(resolve => setTimeout(resolve, Math.min(timeout * 1000, 5000))); // linear backoff
-        missingAssets = await filterOutAssetsThatAlreadyExistAsync(missingAssets);
+        missingAssets = await filterOutAssetsThatAlreadyExistAsync(graphqlClient, missingAssets);
         await timeoutPromise; // await after filterOutAssetsThatAlreadyExistAsync for easy mocking with jest.runAllTimers
         timeout += 1;
         updateSpinnerText === null || updateSpinnerText === void 0 ? void 0 : updateSpinnerText(totalAssets, missingAssets.length);

package/build/submit/ArchiveSource.d.ts

@@ -1,4 +1,5 @@
 import { Platform } from '@expo/eas-build-job';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
 import { BuildFragment } from '../graphql/generated';
 export declare const BUILD_LIST_ITEM_COUNT = 4;
 export declare enum ArchiveSourceType {
@@ -42,6 +43,6 @@ export interface Archive {
     url?: string;
 }
 export declare type ArchiveSource = ArchiveUrlSource | ArchiveLatestSource | ArchivePathSource | ArchiveBuildIdSource | ArchiveBuildListSource | ArchivePromptSource;
-export declare function getArchiveAsync(source: ArchiveSource): Promise<Archive>;
+export declare function getArchiveAsync(graphqlClient: ExpoGraphqlClient, source: ArchiveSource): Promise<Archive>;
 export declare function isUuidV4(s: string): boolean;
 export {};