@donotuse/eas-cli 18.5.0-rc.1

package/build/graphql/mutations/SubmissionMutation.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubmissionMutation = void 0;
+const tslib_1 = require("tslib");
+const graphql_1 = require("graphql");
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const client_1 = require("../client");
+const Submission_1 = require("../types/Submission");
+exports.SubmissionMutation = {
+    async createAndroidSubmissionAsync(graphqlClient, input) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation CreateAndroidSubmissionMutation(
+              $appId: ID!
+              $config: AndroidSubmissionConfigInput!
+              $submittedBuildId: ID
+              $archiveSource: SubmissionArchiveSourceInput
+            ) {
+              submission {
+                createAndroidSubmission(
+                  input: {
+                    appId: $appId
+                    config: $config
+                    submittedBuildId: $submittedBuildId
+                    archiveSource: $archiveSource
+                  }
+                ) {
+                  submission {
+                    id
+                    ...SubmissionFragment
+                  }
+                }
+              }
+            }
+            ${(0, graphql_1.print)(Submission_1.SubmissionFragmentNode)}
+          `, input)
+            .toPromise());
+        return (0, nullthrows_1.default)(data.submission.createAndroidSubmission.submission);
+    },
+    async createIosSubmissionAsync(graphqlClient, input) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation CreateIosSubmissionMutation(
+              $appId: ID!
+              $config: IosSubmissionConfigInput!
+              $submittedBuildId: ID
+              $archiveSource: SubmissionArchiveSourceInput
+            ) {
+              submission {
+                createIosSubmission(
+                  input: {
+                    appId: $appId
+                    config: $config
+                    submittedBuildId: $submittedBuildId
+                    archiveSource: $archiveSource
+                  }
+                ) {
+                  submission {
+                    id
+                    ...SubmissionFragment
+                  }
+                }
+              }
+            }
+            ${(0, graphql_1.print)(Submission_1.SubmissionFragmentNode)}
+          `, input)
+            .toPromise());
+        return (0, nullthrows_1.default)(data.submission.createIosSubmission.submission);
+    },
+};

package/build/graphql/mutations/UploadSessionMutation.d.ts

@@ -0,0 +1,14 @@
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
+import { AccountUploadSessionType, UploadSessionType } from '../generated';
+export interface SignedUrl {
+    url: string;
+    headers: Record<string, string>;
+    bucketKey: string;
+}
+export declare const UploadSessionMutation: {
+    createUploadSessionAsync(graphqlClient: ExpoGraphqlClient, type: UploadSessionType, filename?: string): Promise<SignedUrl>;
+    createAccountScopedUploadSessionAsync(graphqlClient: ExpoGraphqlClient, { type, accountID, }: {
+        type: AccountUploadSessionType;
+        accountID: string;
+    }): Promise<SignedUrl>;
+};

package/build/graphql/mutations/UploadSessionMutation.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadSessionMutation = void 0;
+const tslib_1 = require("tslib");
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const client_1 = require("../client");
+exports.UploadSessionMutation = {
+    async createUploadSessionAsync(graphqlClient, type, filename) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation CreateUploadSessionMutation($type: UploadSessionType!, $filename: String) {
+              uploadSession {
+                createUploadSession(type: $type, filename: $filename)
+              }
+            }
+          `, {
+            type,
+            filename,
+        })
+            .toPromise());
+        return data.uploadSession.createUploadSession;
+    },
+    async createAccountScopedUploadSessionAsync(graphqlClient, { type, accountID, }) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation CreateAccountScopedUploadSessionMutation(
+              $accountID: ID!
+              $type: AccountUploadSessionType!
+            ) {
+              uploadSession {
+                createAccountScopedUploadSession(accountID: $accountID, type: $type)
+              }
+            }
+          `, {
+            type,
+            accountID,
+        })
+            .toPromise());
+        return data.uploadSession.createAccountScopedUploadSession;
+    },
+};

package/build/graphql/mutations/UserPreferencesMutation.d.ts

@@ -0,0 +1,10 @@
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
+import { UserPreferencesOnboardingInput } from '../generated';
+export declare const UserPreferencesMutation: {
+    markCliDoneInOnboardingUserPreferencesAsync(graphqlClient: ExpoGraphqlClient, userPreferencesData: Partial<UserPreferencesOnboardingInput> & {
+        appId: string;
+    }): Promise<{
+        isCLIDone: boolean;
+        appId: string;
+    }>;
+};

package/build/graphql/mutations/UserPreferencesMutation.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserPreferencesMutation = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const client_1 = require("../client");
+exports.UserPreferencesMutation = {
+    async markCliDoneInOnboardingUserPreferencesAsync(graphqlClient, userPreferencesData) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation MarkCliDoneInOnboardingUserPreferencesMutation($preferences: UserPreferencesInput!) {
+              me {
+                setPreferences(preferences: $preferences) {
+                  onboarding {
+                    appId
+                    isCLIDone
+                  }
+                }
+              }
+            }
+          `, {
+            preferences: {
+                onboarding: {
+                    ...userPreferencesData,
+                    isCLIDone: true,
+                    lastUsed: new Date().toISOString(),
+                },
+            },
+        })
+            .toPromise());
+        const appId = data.me.setPreferences.onboarding?.appId;
+        (0, assert_1.default)(appId, 'App ID must be defined');
+        const isCLIDone = data.me.setPreferences.onboarding?.isCLIDone;
+        (0, assert_1.default)(isCLIDone, 'isCLIDone must be defined and true');
+        return {
+            appId,
+            isCLIDone,
+        };
+    },
+};

package/build/graphql/mutations/WebhookMutation.d.ts

@@ -0,0 +1,7 @@
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
+import { WebhookFragment, WebhookInput } from '../generated';
+export declare const WebhookMutation: {
+    createWebhookAsync(graphqlClient: ExpoGraphqlClient, appId: string, webhookInput: WebhookInput): Promise<WebhookFragment>;
+    updateWebhookAsync(graphqlClient: ExpoGraphqlClient, webhookId: string, webhookInput: WebhookInput): Promise<WebhookFragment>;
+    deleteWebhookAsync(graphqlClient: ExpoGraphqlClient, webhookId: string): Promise<void>;
+};

package/build/graphql/mutations/WebhookMutation.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookMutation = void 0;
+const tslib_1 = require("tslib");
+const graphql_1 = require("graphql");
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const client_1 = require("../client");
+const Webhook_1 = require("../types/Webhook");
+exports.WebhookMutation = {
+    async createWebhookAsync(graphqlClient, appId, webhookInput) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation CreateWebhookMutation($appId: String!, $webhookInput: WebhookInput!) {
+              webhook {
+                createWebhook(appId: $appId, webhookInput: $webhookInput) {
+                  id
+                  ...WebhookFragment
+                }
+              }
+            }
+            ${(0, graphql_1.print)(Webhook_1.WebhookFragmentNode)}
+          `, { appId, webhookInput })
+            .toPromise());
+        return data.webhook.createWebhook;
+    },
+    async updateWebhookAsync(graphqlClient, webhookId, webhookInput) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation UpdateWebhookMutation($webhookId: ID!, $webhookInput: WebhookInput!) {
+              webhook {
+                updateWebhook(webhookId: $webhookId, webhookInput: $webhookInput) {
+                  id
+                  ...WebhookFragment
+                }
+              }
+            }
+            ${(0, graphql_1.print)(Webhook_1.WebhookFragmentNode)}
+          `, { webhookId, webhookInput })
+            .toPromise());
+        return data.webhook.updateWebhook;
+    },
+    async deleteWebhookAsync(graphqlClient, webhookId) {
+        await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation DeleteWebhookMutation($webhookId: ID!) {
+              webhook {
+                deleteWebhook(webhookId: $webhookId) {
+                  id
+                }
+              }
+            }
+          `, { webhookId })
+            .toPromise());
+    },
+};

package/build/graphql/mutations/WorkflowRevisionMutation.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
+import { WorkflowRevision } from '../generated';
+export declare namespace WorkflowRevisionMutation {
+    const ValidationErrorExtensionZ: z.ZodObject<{
+        errorCode: z.ZodLiteral<"VALIDATION_ERROR">;
+        metadata: z.ZodObject<{
+            formErrors: z.ZodArray<z.ZodString>;
+            fieldErrors: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    function getOrCreateWorkflowRevisionFromGitRefAsync(graphqlClient: ExpoGraphqlClient, { appId, fileName, gitRef, }: {
+        appId: string;
+        fileName: string;
+        gitRef: string;
+    }): Promise<WorkflowRevision | undefined>;
+    function validateWorkflowYamlConfigAsync(graphqlClient: ExpoGraphqlClient, { appId, yamlConfig, }: {
+        appId: string;
+        yamlConfig: string;
+    }): Promise<void>;
+}

package/build/graphql/mutations/WorkflowRevisionMutation.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowRevisionMutation = void 0;
+const tslib_1 = require("tslib");
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const zod_1 = require("zod");
+const client_1 = require("../client");
+var WorkflowRevisionMutation;
+(function (WorkflowRevisionMutation) {
+    WorkflowRevisionMutation.ValidationErrorExtensionZ = zod_1.z.object({
+        errorCode: zod_1.z.literal('VALIDATION_ERROR'),
+        metadata: zod_1.z.object({
+            formErrors: zod_1.z.array(zod_1.z.string()),
+            fieldErrors: zod_1.z.record(zod_1.z.string(), zod_1.z.array(zod_1.z.string())),
+        }),
+    });
+    async function getOrCreateWorkflowRevisionFromGitRefAsync(graphqlClient, { appId, fileName, gitRef, }) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation GetOrCreateWorkflowRevisionFromGitRef($appId: ID!, $fileName: String!, $gitRef: String!) {
+              workflowRevision {
+                getOrCreateWorkflowRevisionFromGitRef(appId: $appId, fileName: $fileName, gitRef: $gitRef) {
+                  id
+                  yamlConfig
+                  blobSha
+                  commitSha
+                  createdAt
+                  workflow {
+                    id
+                  }
+                }
+              }
+            }
+          `, {
+            appId,
+            fileName,
+            gitRef,
+        })
+            .toPromise());
+        return (data.workflowRevision?.getOrCreateWorkflowRevisionFromGitRef ??
+            undefined);
+    }
+    WorkflowRevisionMutation.getOrCreateWorkflowRevisionFromGitRefAsync = getOrCreateWorkflowRevisionFromGitRefAsync;
+    async function validateWorkflowYamlConfigAsync(graphqlClient, { appId, yamlConfig, }) {
+        await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation ValidateWorkflowYamlConfig($appId: ID!, $yamlConfig: String!) {
+              workflowRevision {
+                validateWorkflowYamlConfig(appId: $appId, yamlConfig: $yamlConfig)
+              }
+            }
+          `, {
+            appId,
+            yamlConfig,
+        })
+            .toPromise());
+    }
+    WorkflowRevisionMutation.validateWorkflowYamlConfigAsync = validateWorkflowYamlConfigAsync;
+})(WorkflowRevisionMutation || (exports.WorkflowRevisionMutation = WorkflowRevisionMutation = {}));

package/build/graphql/mutations/WorkflowRunMutation.d.ts

@@ -0,0 +1,27 @@
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
+import { WorkflowProjectSourceInput, WorkflowRevisionInput, WorkflowRunInput } from '../generated';
+export declare namespace WorkflowRunMutation {
+    function createWorkflowRunAsync(graphqlClient: ExpoGraphqlClient, { appId, workflowRevisionInput, workflowRunInput, }: {
+        appId: string;
+        workflowRevisionInput: WorkflowRevisionInput;
+        workflowRunInput: WorkflowRunInput;
+    }): Promise<{
+        id: string;
+    }>;
+    function createWorkflowRunFromGitRefAsync(graphqlClient: ExpoGraphqlClient, { workflowRevisionId, gitRef, inputs, }: {
+        workflowRevisionId: string;
+        gitRef: string;
+        inputs?: Record<string, any>;
+    }): Promise<{
+        id: string;
+    }>;
+    function createExpoGoRepackWorkflowRunAsync(graphqlClient: ExpoGraphqlClient, { appId, projectSource, }: {
+        appId: string;
+        projectSource: WorkflowProjectSourceInput;
+    }): Promise<{
+        id: string;
+    }>;
+    function cancelWorkflowRunAsync(graphqlClient: ExpoGraphqlClient, { workflowRunId, }: {
+        workflowRunId: string;
+    }): Promise<void>;
+}

package/build/graphql/mutations/WorkflowRunMutation.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowRunMutation = void 0;
+const tslib_1 = require("tslib");
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const client_1 = require("../client");
+var WorkflowRunMutation;
+(function (WorkflowRunMutation) {
+    async function createWorkflowRunAsync(graphqlClient, { appId, workflowRevisionInput, workflowRunInput, }) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation CreateWorkflowRun(
+              $appId: ID!
+              $workflowRevisionInput: WorkflowRevisionInput!
+              $workflowRunInput: WorkflowRunInput!
+            ) {
+              workflowRun {
+                createWorkflowRun(
+                  appId: $appId
+                  workflowRevisionInput: $workflowRevisionInput
+                  workflowRunInput: $workflowRunInput
+                ) {
+                  id
+                }
+              }
+            }
+          `, {
+            appId,
+            workflowRevisionInput,
+            workflowRunInput,
+        })
+            .toPromise());
+        return { id: data.workflowRun.createWorkflowRun.id };
+    }
+    WorkflowRunMutation.createWorkflowRunAsync = createWorkflowRunAsync;
+    async function createWorkflowRunFromGitRefAsync(graphqlClient, { workflowRevisionId, gitRef, inputs, }) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation CreateWorkflowRunFromGitRef(
+              $workflowRevisionId: ID!
+              $gitRef: String!
+              $inputs: JSONObject
+            ) {
+              workflowRun {
+                createWorkflowRunFromGitRef(
+                  workflowRevisionId: $workflowRevisionId
+                  gitRef: $gitRef
+                  inputs: $inputs
+                ) {
+                  id
+                }
+              }
+            }
+          `, {
+            workflowRevisionId,
+            gitRef,
+            inputs,
+        })
+            .toPromise());
+        return { id: data.workflowRun.createWorkflowRunFromGitRef.id };
+    }
+    WorkflowRunMutation.createWorkflowRunFromGitRefAsync = createWorkflowRunFromGitRefAsync;
+    async function createExpoGoRepackWorkflowRunAsync(graphqlClient, { appId, projectSource, }) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation(
+        /* eslint-disable graphql/template-strings */
+        (0, graphql_tag_1.default) `
+            mutation CreateExpoGoRepackWorkflowRun($appId: ID!, $projectSource: WorkflowProjectSourceInput!) {
+              workflowRun {
+                createExpoGoRepackWorkflowRun(appId: $appId, projectSource: $projectSource) {
+                  id
+                }
+              }
+            }
+          `, 
+        /* eslint-enable graphql/template-strings */
+        { appId, projectSource })
+            .toPromise());
+        return { id: data.workflowRun.createExpoGoRepackWorkflowRun.id };
+    }
+    WorkflowRunMutation.createExpoGoRepackWorkflowRunAsync = createExpoGoRepackWorkflowRunAsync;
+    async function cancelWorkflowRunAsync(graphqlClient, { workflowRunId, }) {
+        await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation CancelWorkflowRun($workflowRunId: ID!) {
+              workflowRun {
+                cancelWorkflowRun(workflowRunId: $workflowRunId) {
+                  id
+                }
+              }
+            }
+          `, {
+            workflowRunId,
+        })
+            .toPromise());
+    }
+    WorkflowRunMutation.cancelWorkflowRunAsync = cancelWorkflowRunAsync;
+})(WorkflowRunMutation || (exports.WorkflowRunMutation = WorkflowRunMutation = {}));

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

@@ -0,0 +1,15 @@
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
+import { AccountFullUsageQuery as AccountFullUsageQueryType, AccountUsageForOverageWarningQuery } from '../generated';
+export type AccountFullUsageData = NonNullable<AccountFullUsageQueryType['account']['byId']>;
+export declare const AccountQuery: {
+    getByNameAsync(graphqlClient: ExpoGraphqlClient, accountName: string): Promise<{
+        id: string;
+        name: string;
+    } | null>;
+    getFullUsageAsync(graphqlClient: ExpoGraphqlClient, accountId: string, currentDate: Date, startDate: Date, endDate: Date): Promise<AccountFullUsageData>;
+    getUsageForOverageWarningAsync(graphqlClient: ExpoGraphqlClient, accountId: string, currentDate: Date): Promise<AccountUsageForOverageWarningQuery["account"]["byId"]>;
+    getBillingPeriodAsync(graphqlClient: ExpoGraphqlClient, accountId: string, currentDate: Date): Promise<{
+        start: Date;
+        end: Date;
+    }>;
+};

package/build/graphql/queries/AccountQuery.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountQuery = void 0;
+const tslib_1 = require("tslib");
+const graphql_1 = require("graphql");
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const client_1 = require("../client");
+const Account_1 = require("../types/Account");
+exports.AccountQuery = {
+    async getByNameAsync(graphqlClient, accountName) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .query((0, graphql_tag_1.default) `
+            query AccountByName($accountName: String!) {
+              account {
+                byName(accountName: $accountName) {
+                  id
+                  name
+                }
+              }
+            }
+          `, { accountName }, { additionalTypenames: ['Account'] })
+            .toPromise());
+        return data.account.byName;
+    },
+    async getFullUsageAsync(graphqlClient, accountId, currentDate, startDate, endDate) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .query((0, graphql_tag_1.default) `
+            query AccountFullUsage(
+              $accountId: String!
+              $currentDate: DateTime!
+              $startDate: DateTime!
+              $endDate: DateTime!
+            ) {
+              account {
+                byId(accountId: $accountId) {
+                  id
+                  name
+                  subscription {
+                    id
+                    ...SubscriptionDetailsFragment
+                  }
+                  billingPeriod(date: $currentDate) {
+                    id
+                    ...BillingPeriodFragment
+                  }
+                  usageMetrics {
+                    MEDIUM_ANDROID_BUILDS: metricsForServiceMetric(
+                      serviceMetric: BUILDS
+                      granularity: TOTAL
+                      timespan: { start: $startDate, end: $endDate }
+                      filterParams: {
+                        platform: "android"
+                        billingResourceClass: ["medium"]
+                        status: ["finished", "errored"]
+                      }
+                    ) {
+                      id
+                      ...AccountUsageMetricFragment
+                    }
+                    LARGE_ANDROID_BUILDS: metricsForServiceMetric(
+                      serviceMetric: BUILDS
+                      granularity: TOTAL
+                      timespan: { start: $startDate, end: $endDate }
+                      filterParams: {
+                        platform: "android"
+                        billingResourceClass: ["large"]
+                        status: ["finished", "errored"]
+                      }
+                    ) {
+                      id
+                      ...AccountUsageMetricFragment
+                    }
+                    MEDIUM_IOS_BUILDS: metricsForServiceMetric(
+                      serviceMetric: BUILDS
+                      granularity: TOTAL
+                      timespan: { start: $startDate, end: $endDate }
+                      filterParams: {
+                        platform: "ios"
+                        billingResourceClass: ["medium"]
+                        status: ["finished", "errored"]
+                      }
+                    ) {
+                      id
+                      ...AccountUsageMetricFragment
+                    }
+                    LARGE_IOS_BUILDS: metricsForServiceMetric(
+                      serviceMetric: BUILDS
+                      granularity: TOTAL
+                      timespan: { start: $startDate, end: $endDate }
+                      filterParams: {
+                        platform: "ios"
+                        billingResourceClass: ["large"]
+                        status: ["finished", "errored"]
+                      }
+                    ) {
+                      id
+                      ...AccountUsageMetricFragment
+                    }
+                    EAS_BUILD: byBillingPeriod(date: $currentDate, service: BUILDS) {
+                      id
+                      ...UsageMetricTotalFragment
+                    }
+                    EAS_UPDATE: byBillingPeriod(date: $currentDate, service: UPDATES) {
+                      id
+                      ...UsageMetricTotalFragment
+                    }
+                  }
+                }
+              }
+            }
+            ${(0, graphql_1.print)(Account_1.SubscriptionDetailsFragmentNode)}
+            ${(0, graphql_1.print)(Account_1.BillingPeriodFragmentNode)}
+            ${(0, graphql_1.print)(Account_1.AccountUsageMetricFragmentNode)}
+            ${(0, graphql_1.print)(Account_1.UsageMetricTotalFragmentNode)}
+          `, {
+            accountId,
+            currentDate: currentDate.toISOString(),
+            startDate: startDate.toISOString(),
+            endDate: endDate.toISOString(),
+        }, {
+            additionalTypenames: [
+                'Account',
+                'AccountUsageMetrics',
+                'UsageMetricTotal',
+                'BillingPeriod',
+                'EstimatedUsage',
+                'EstimatedOverageAndCost',
+            ],
+        })
+            .toPromise());
+        if (!data.account.byId) {
+            throw new Error(`Account with ID ${accountId} not found`);
+        }
+        return data.account.byId;
+    },
+    async getUsageForOverageWarningAsync(graphqlClient, accountId, currentDate) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .query((0, graphql_tag_1.default) `
+            query AccountUsageForOverageWarning($accountId: String!, $currentDate: DateTime!) {
+              account {
+                byId(accountId: $accountId) {
+                  id
+                  name
+                  subscription {
+                    id
+                    name
+                  }
+                  usageMetrics {
+                    EAS_BUILD: byBillingPeriod(date: $currentDate, service: BUILDS) {
+                      id
+                      planMetrics {
+                        id
+                        serviceMetric
+                        value
+                        limit
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          `, { accountId, currentDate: currentDate.toISOString() }, {
+            additionalTypenames: ['Account', 'AccountUsageMetrics', 'UsageMetricTotal'],
+        })
+            .toPromise());
+        return data.account.byId;
+    },
+    async getBillingPeriodAsync(graphqlClient, accountId, currentDate) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .query((0, graphql_tag_1.default) `
+            query AccountBillingPeriod($accountId: String!, $currentDate: DateTime!) {
+              account {
+                byId(accountId: $accountId) {
+                  id
+                  name
+                  billingPeriod(date: $currentDate) {
+                    id
+                    ...BillingPeriodFragment
+                  }
+                }
+              }
+            }
+            ${(0, graphql_1.print)(Account_1.BillingPeriodFragmentNode)}
+          `, { accountId, currentDate: currentDate.toISOString() }, {
+            additionalTypenames: ['Account', 'BillingPeriod'],
+        })
+            .toPromise());
+        const { start, end } = data.account.byId?.billingPeriod ?? {};
+        if (!start || !end) {
+            throw new Error('Billing period data not found');
+        }
+        return {
+            start: new Date(start),
+            end: new Date(end),
+        };
+    },
+};

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

@@ -0,0 +1,8 @@
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
+import { AppFragment, WorkflowFragment, WorkflowRunFragment, WorkflowRunStatus } from '../generated';
+export declare const AppQuery: {
+    byIdAsync(graphqlClient: ExpoGraphqlClient, projectId: string): Promise<AppFragment>;
+    byFullNameAsync(graphqlClient: ExpoGraphqlClient, fullName: string): Promise<AppFragment>;
+    byIdWorkflowsAsync(graphqlClient: ExpoGraphqlClient, appId: string): Promise<WorkflowFragment[]>;
+    byIdWorkflowRunsFilteredByStatusAsync(graphqlClient: ExpoGraphqlClient, appId: string, status?: WorkflowRunStatus, limit?: number): Promise<WorkflowRunFragment[]>;
+};