@donotuse/eas-cli 18.5.0-rc.1

package/build/submit/android/AndroidSubmitCommand.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const eas_json_1 = require("@expo/eas-json");
+const results_1 = require("@expo/results");
+const AndroidSubmitter_1 = tslib_1.__importDefault(require("./AndroidSubmitter"));
+const ServiceAccountSource_1 = require("./ServiceAccountSource");
+const generated_1 = require("../../graphql/generated");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const applicationId_1 = require("../../project/android/applicationId");
+const capitalize_1 = tslib_1.__importDefault(require("../../utils/expodash/capitalize"));
+const ArchiveSource_1 = require("../ArchiveSource");
+const commons_1 = require("../commons");
+class AndroidSubmitCommand {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    async runAsync() {
+        log_1.default.addNewLineIfNone();
+        const archiveSource = this.resolveArchiveSource();
+        if (!archiveSource.ok) {
+            log_1.default.error(archiveSource.reason?.message);
+            throw new Error('Submission failed');
+        }
+        const archiveSourceValue = archiveSource.enforceValue();
+        const archive = await (0, ArchiveSource_1.getArchiveAsync)({
+            graphqlClient: this.ctx.graphqlClient,
+            platform: eas_build_job_1.Platform.ANDROID,
+            projectId: this.ctx.projectId,
+            nonInteractive: this.ctx.nonInteractive,
+        }, archiveSourceValue);
+        const archiveProfile = archive.sourceType === ArchiveSource_1.ArchiveSourceType.build ? archive.build.buildProfile : undefined;
+        if (archiveProfile && !this.ctx.specifiedProfile) {
+            this.ctx = await (0, commons_1.refreshContextSubmitProfileAsync)(this.ctx, archiveProfile);
+        }
+        const submissionOptions = await this.getAndroidSubmissionOptionsAsync(archiveSourceValue);
+        const submitter = new AndroidSubmitter_1.default(this.ctx, submissionOptions, archive);
+        return submitter;
+    }
+    async getAndroidSubmissionOptionsAsync(archiveSource) {
+        const track = this.ctx.profile.track || 'internal';
+        const releaseStatus = this.resolveReleaseStatus();
+        const rollout = this.resolveRollout();
+        const serviceAccountSource = await this.resolveServiceAccountSourceAsync();
+        const errored = [releaseStatus, serviceAccountSource, rollout].filter(r => !r.ok);
+        if (errored.length > 0) {
+            const message = errored.map(err => err.reason?.message).join('\n');
+            log_1.default.error(message);
+            throw new Error('Submission failed');
+        }
+        return {
+            projectId: this.ctx.projectId,
+            track,
+            releaseStatus: releaseStatus.enforceValue(),
+            rollout: rollout.enforceValue(),
+            archiveSource,
+            serviceAccountSource: serviceAccountSource.enforceValue(),
+            changesNotSentForReview: this.ctx.profile.changesNotSentForReview,
+        };
+    }
+    async maybeGetAndroidPackageFromCurrentProjectAsync() {
+        try {
+            return (0, results_1.result)(await (0, applicationId_1.getApplicationIdAsync)(this.ctx.projectDir, this.ctx.exp, this.ctx.vcsClient));
+        }
+        catch (error) {
+            if (error instanceof applicationId_1.AmbiguousApplicationIdError) {
+                log_1.default.warn('"applicationId" is ambiguous, specify it via "applicationId" field in the submit profile in the eas.json.');
+                return (0, results_1.result)(null);
+            }
+            return (0, results_1.result)(new Error(`Failed to resolve applicationId in Android project: ${error.message}.`));
+        }
+    }
+    resolveReleaseStatus() {
+        const { releaseStatus } = this.ctx.profile;
+        if (!releaseStatus) {
+            return (0, results_1.result)(generated_1.SubmissionAndroidReleaseStatus.Completed);
+        }
+        const capitalizedReleaseStatus = (0, capitalize_1.default)(releaseStatus);
+        if (capitalizedReleaseStatus in generated_1.SubmissionAndroidReleaseStatus) {
+            return (0, results_1.result)(generated_1.SubmissionAndroidReleaseStatus[capitalizedReleaseStatus]);
+        }
+        else {
+            return (0, results_1.result)(new Error(`Unsupported release status: ${releaseStatus} (valid options: ${Object.keys(eas_json_1.AndroidReleaseStatus).join(', ')})`));
+        }
+    }
+    resolveRollout() {
+        const { rollout } = this.ctx.profile;
+        return (0, results_1.result)(rollout);
+    }
+    resolveArchiveSource() {
+        try {
+            return (0, results_1.result)((0, commons_1.resolveArchiveSource)(this.ctx));
+        }
+        catch (err) {
+            return (0, results_1.result)(err);
+        }
+    }
+    async resolveServiceAccountSourceAsync() {
+        const { serviceAccountKeyPath } = this.ctx.profile;
+        if (serviceAccountKeyPath) {
+            return (0, results_1.result)({
+                sourceType: ServiceAccountSource_1.ServiceAccountSourceType.path,
+                path: serviceAccountKeyPath,
+            });
+        }
+        let androidApplicationIdentifier = this.ctx.applicationIdentifierOverride ?? this.ctx.profile.applicationId;
+        if (!androidApplicationIdentifier) {
+            const androidApplicationIdentifierResult = await this.maybeGetAndroidPackageFromCurrentProjectAsync();
+            if (!androidApplicationIdentifierResult.ok) {
+                return (0, results_1.result)(androidApplicationIdentifierResult.reason);
+            }
+            const androidApplicationIdentifierValue = androidApplicationIdentifierResult.enforceValue();
+            if (androidApplicationIdentifierValue) {
+                androidApplicationIdentifier = androidApplicationIdentifierValue;
+            }
+        }
+        return (0, results_1.result)({
+            sourceType: ServiceAccountSource_1.ServiceAccountSourceType.credentialsService,
+            androidApplicationIdentifier,
+        });
+    }
+}
+exports.default = AndroidSubmitCommand;

package/build/submit/android/AndroidSubmitter.d.ts

@@ -0,0 +1,23 @@
+import { Platform } from '@expo/eas-build-job';
+import { ServiceAccountKeyResult, ServiceAccountSource } from './ServiceAccountSource';
+import { AndroidSubmissionConfigInput, SubmissionFragment } from '../../graphql/generated';
+import { ArchiveSource, ResolvedArchiveSource } from '../ArchiveSource';
+import BaseSubmitter, { SubmissionInput } from '../BaseSubmitter';
+import { SubmissionContext } from '../context';
+export interface AndroidSubmissionOptions extends Pick<AndroidSubmissionConfigInput, 'track' | 'releaseStatus' | 'changesNotSentForReview' | 'rollout'> {
+    projectId: string;
+    archiveSource: ArchiveSource;
+    serviceAccountSource: ServiceAccountSource;
+}
+interface ResolvedSourceOptions {
+    archive: ResolvedArchiveSource;
+    serviceAccountKeyResult: ServiceAccountKeyResult;
+}
+export default class AndroidSubmitter extends BaseSubmitter<Platform.ANDROID, ResolvedSourceOptions, AndroidSubmissionOptions> {
+    constructor(ctx: SubmissionContext<Platform.ANDROID>, options: AndroidSubmissionOptions, archive: ResolvedArchiveSource);
+    createSubmissionInputAsync(resolvedSourceOptions: ResolvedSourceOptions): Promise<SubmissionInput<Platform.ANDROID>>;
+    protected createPlatformSubmissionAsync({ projectId, submissionConfig, buildId, archiveSource, }: SubmissionInput<Platform.ANDROID>): Promise<SubmissionFragment>;
+    private formatSubmissionConfig;
+    private prepareSummaryData;
+}
+export {};

package/build/submit/android/AndroidSubmitter.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const ServiceAccountSource_1 = require("./ServiceAccountSource");
+const AnalyticsManager_1 = require("../../analytics/AnalyticsManager");
+const SubmissionMutation_1 = require("../../graphql/mutations/SubmissionMutation");
+const formatFields_1 = tslib_1.__importDefault(require("../../utils/formatFields"));
+const BaseSubmitter_1 = tslib_1.__importDefault(require("../BaseSubmitter"));
+const summary_1 = require("../utils/summary");
+class AndroidSubmitter extends BaseSubmitter_1.default {
+    constructor(ctx, options, archive) {
+        const sourceOptionsResolver = {
+            // eslint-disable-next-line async-protect/async-suffix
+            archive: async () => archive,
+            // eslint-disable-next-line async-protect/async-suffix
+            serviceAccountKeyResult: async () => {
+                return await (0, ServiceAccountSource_1.getServiceAccountKeyResultAsync)(this.ctx, this.options.serviceAccountSource);
+            },
+        };
+        const sourceOptionsAnalytics = {
+            archive: {
+                attemptEvent: AnalyticsManager_1.SubmissionEvent.GATHER_ARCHIVE_ATTEMPT,
+                successEvent: AnalyticsManager_1.SubmissionEvent.GATHER_ARCHIVE_SUCCESS,
+                failureEvent: AnalyticsManager_1.SubmissionEvent.GATHER_ARCHIVE_FAIL,
+            },
+            serviceAccountKeyResult: {
+                attemptEvent: AnalyticsManager_1.SubmissionEvent.GATHER_CREDENTIALS_ATTEMPT,
+                successEvent: AnalyticsManager_1.SubmissionEvent.GATHER_CREDENTIALS_SUCCESS,
+                failureEvent: AnalyticsManager_1.SubmissionEvent.GATHER_CREDENTIALS_FAIL,
+            },
+        };
+        super(ctx, options, sourceOptionsResolver, sourceOptionsAnalytics);
+    }
+    async createSubmissionInputAsync(resolvedSourceOptions) {
+        const submissionConfig = this.formatSubmissionConfig(this.options, resolvedSourceOptions);
+        (0, summary_1.printSummary)(this.prepareSummaryData(this.options, resolvedSourceOptions), SummaryHumanReadableKeys);
+        return {
+            projectId: this.options.projectId,
+            submissionConfig,
+            ...this.formatArchive(resolvedSourceOptions.archive),
+        };
+    }
+    async createPlatformSubmissionAsync({ projectId, submissionConfig, buildId, archiveSource, }) {
+        return await SubmissionMutation_1.SubmissionMutation.createAndroidSubmissionAsync(this.ctx.graphqlClient, {
+            appId: projectId,
+            config: submissionConfig,
+            submittedBuildId: buildId,
+            archiveSource,
+        });
+    }
+    formatSubmissionConfig(options, { serviceAccountKeyResult }) {
+        const { track, releaseStatus, changesNotSentForReview, rollout } = options;
+        return {
+            track,
+            changesNotSentForReview,
+            releaseStatus,
+            rollout,
+            isVerboseFastlaneEnabled: this.ctx.isVerboseFastlaneEnabled,
+            ...serviceAccountKeyResult.result,
+        };
+    }
+    prepareSummaryData(options, { archive, serviceAccountKeyResult }) {
+        const { projectId, track, releaseStatus, changesNotSentForReview, rollout } = options;
+        // structuring order affects table rows order
+        return {
+            projectId,
+            track,
+            changesNotSentForReview: changesNotSentForReview ?? undefined,
+            releaseStatus: releaseStatus ?? undefined,
+            formattedServiceAccount: formatServiceAccountSummary(serviceAccountKeyResult),
+            rollout: rollout ?? undefined,
+            ...(0, summary_1.formatArchiveSourceSummary)(archive),
+        };
+    }
+}
+exports.default = AndroidSubmitter;
+const SummaryHumanReadableKeys = {
+    archivePath: 'Archive path',
+    archiveUrl: 'Download URL',
+    changesNotSentForReview: 'Changes not sent for a review',
+    formattedBuild: 'Build',
+    formattedServiceAccount: 'Google Service Account Key',
+    projectId: 'Project ID',
+    releaseStatus: 'Release status',
+    rollout: 'Rollout',
+    track: 'Release track',
+};
+function formatServiceAccountSummary({ summary }) {
+    const { email: serviceAccountEmail, path: serviceAccountKeyPath, source: serviceAccountKeySource, } = summary;
+    const fields = [
+        {
+            label: 'Key Source',
+            value: serviceAccountKeySource,
+        },
+        {
+            label: 'Key Path',
+            value: serviceAccountKeyPath,
+        },
+        {
+            label: 'Account Email',
+            value: serviceAccountEmail,
+        },
+    ];
+    const filteredFields = fields.filter(({ value }) => value !== undefined && value !== null);
+    return ('\n' +
+        (0, formatFields_1.default)(filteredFields, {
+            labelFormat: label => `    ${chalk_1.default.dim(label)}:`,
+        }));
+}

package/build/submit/android/ServiceAccountSource.d.ts

@@ -0,0 +1,41 @@
+import { Platform } from '@expo/eas-build-job';
+import { SubmissionContext } from '../context';
+export declare enum ServiceAccountSourceType {
+    path = 0,
+    prompt = 1,
+    credentialsService = 2
+}
+interface ServiceAccountSourceBase {
+    sourceType: ServiceAccountSourceType;
+}
+interface ServiceAccountPathSource extends ServiceAccountSourceBase {
+    sourceType: ServiceAccountSourceType.path;
+    path: string;
+}
+interface ServiceAccountPromptSource extends ServiceAccountSourceBase {
+    sourceType: ServiceAccountSourceType.prompt;
+}
+export interface ServiceAccountCredentialsServiceSource extends ServiceAccountSourceBase {
+    sourceType: ServiceAccountSourceType.credentialsService;
+    androidApplicationIdentifier?: string;
+}
+export type ServiceAccountKeyResult = {
+    result: ServiceAccountKeyFile | ServiceAccountKeyFromExpoServers;
+    summary: ServiceAccountKeySummary;
+};
+type ServiceAccountKeySummary = {
+    source: 'local' | 'EAS servers';
+    path?: string;
+    email: string;
+};
+type ServiceAccountKeyFile = {
+    googleServiceAccountKeyJson: string;
+};
+type ServiceAccountKeyFromExpoServers = {
+    googleServiceAccountKeyId: string;
+};
+export type ServiceAccountSource = ServiceAccountPathSource | ServiceAccountPromptSource | ServiceAccountCredentialsServiceSource;
+export declare function getServiceAccountKeyResultAsync(ctx: SubmissionContext<Platform.ANDROID>, source: ServiceAccountSource): Promise<ServiceAccountKeyResult>;
+export declare function getServiceAccountKeyPathAsync(source: ServiceAccountSource): Promise<string>;
+export declare function getServiceAccountFromCredentialsServiceAsync(ctx: SubmissionContext<Platform.ANDROID>, source: ServiceAccountCredentialsServiceSource): Promise<ServiceAccountKeyResult>;
+export {};

package/build/submit/android/ServiceAccountSource.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceAccountSourceType = void 0;
+exports.getServiceAccountKeyResultAsync = getServiceAccountKeyResultAsync;
+exports.getServiceAccountKeyPathAsync = getServiceAccountKeyPathAsync;
+exports.getServiceAccountFromCredentialsServiceAsync = getServiceAccountFromCredentialsServiceAsync;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const SetUpGoogleServiceAccountKeyForSubmissions_1 = require("../../credentials/android/actions/SetUpGoogleServiceAccountKeyForSubmissions");
+const googleServiceAccountKey_1 = require("../../credentials/android/utils/googleServiceAccountKey");
+const log_1 = tslib_1.__importStar(require("../../log"));
+const applicationId_1 = require("../../project/android/applicationId");
+const prompts_1 = require("../../prompts");
+const files_1 = require("../utils/files");
+var ServiceAccountSourceType;
+(function (ServiceAccountSourceType) {
+    ServiceAccountSourceType[ServiceAccountSourceType["path"] = 0] = "path";
+    ServiceAccountSourceType[ServiceAccountSourceType["prompt"] = 1] = "prompt";
+    ServiceAccountSourceType[ServiceAccountSourceType["credentialsService"] = 2] = "credentialsService";
+})(ServiceAccountSourceType || (exports.ServiceAccountSourceType = ServiceAccountSourceType = {}));
+async function getServiceAccountKeyResultAsync(ctx, source) {
+    if (source.sourceType === ServiceAccountSourceType.credentialsService) {
+        return await getServiceAccountFromCredentialsServiceAsync(ctx, source);
+    }
+    else {
+        return await getServiceAccountLocallyAsync(source);
+    }
+}
+async function getServiceAccountLocallyAsync(source) {
+    const serviceAccountKeyPath = await getServiceAccountKeyPathAsync(source);
+    const serviceAccountKey = (0, googleServiceAccountKey_1.readAndValidateServiceAccountKey)(serviceAccountKeyPath);
+    return {
+        result: { googleServiceAccountKeyJson: await fs_extra_1.default.readFile(serviceAccountKeyPath, 'utf-8') },
+        summary: {
+            source: 'local',
+            path: serviceAccountKeyPath,
+            email: serviceAccountKey.client_email,
+        },
+    };
+}
+async function getServiceAccountKeyPathAsync(source) {
+    switch (source.sourceType) {
+        case ServiceAccountSourceType.path:
+            return await handlePathSourceAsync(source);
+        case ServiceAccountSourceType.prompt:
+            return await handlePromptSourceAsync(source);
+        case ServiceAccountSourceType.credentialsService: {
+            throw new Error(`ServiceAccountSource ${source} does not return a path.`);
+        }
+    }
+}
+async function promptForApplicationIdAsync() {
+    const { androidPackage } = await (0, prompts_1.promptAsync)({
+        name: 'androidPackage',
+        message: 'Android package name:',
+        type: 'text',
+        validate: value => ((0, applicationId_1.isApplicationIdValid)(value) ? true : applicationId_1.INVALID_APPLICATION_ID_MESSAGE),
+    });
+    return androidPackage;
+}
+async function getServiceAccountFromCredentialsServiceAsync(ctx, source) {
+    const appLookupParams = {
+        account: (0, nullthrows_1.default)(ctx.user.accounts.find(a => a.name === ctx.accountName), `You do not have access to account: ${ctx.accountName}`),
+        projectName: ctx.projectName,
+        androidApplicationIdentifier: source.androidApplicationIdentifier ?? (await promptForApplicationIdAsync()),
+    };
+    log_1.default.log(`Looking up credentials configuration for ${appLookupParams.androidApplicationIdentifier}...`);
+    const setupGoogleServiceAccountKeyAction = new SetUpGoogleServiceAccountKeyForSubmissions_1.SetUpGoogleServiceAccountKeyForSubmissions(appLookupParams);
+    const androidAppCredentials = await setupGoogleServiceAccountKeyAction.runAsync(ctx.credentialsCtx);
+    const googleServiceAccountKey = (0, nullthrows_1.default)(androidAppCredentials.googleServiceAccountKeyForSubmissions, 'Credentials Service must provide a valid GoogleServiceAccountKey');
+    return {
+        result: {
+            googleServiceAccountKeyId: googleServiceAccountKey.id,
+        },
+        summary: {
+            source: 'EAS servers',
+            email: googleServiceAccountKey.clientEmail,
+        },
+    };
+}
+async function handlePathSourceAsync(source) {
+    if (!(await (0, files_1.isExistingFileAsync)(source.path))) {
+        log_1.default.warn(`File ${source.path} doesn't exist.`);
+        return await getServiceAccountKeyPathAsync({ sourceType: ServiceAccountSourceType.prompt });
+    }
+    return source.path;
+}
+async function handlePromptSourceAsync(_source) {
+    const path = await askForServiceAccountPathAsync();
+    return await getServiceAccountKeyPathAsync({
+        sourceType: ServiceAccountSourceType.path,
+        path,
+    });
+}
+async function askForServiceAccountPathAsync() {
+    log_1.default.log(`${chalk_1.default.bold('A Google Service Account JSON key is required to upload your app to Google Play Store')}.\n` +
+        `If you're not sure what this is or how to create one, ${(0, log_1.learnMore)('https://expo.fyi/creating-google-service-account', { learnMoreMessage: 'learn more' })}`);
+    const { filePath } = await (0, prompts_1.promptAsync)({
+        name: 'filePath',
+        message: 'Path to Google Service Account file:',
+        initial: 'api-0000000000000000000-111111-aaaaaabbbbbb.json',
+        type: 'text',
+        // eslint-disable-next-line async-protect/async-suffix
+        validate: async (filePath) => {
+            try {
+                const stats = await fs_extra_1.default.stat(filePath);
+                if (stats.isFile()) {
+                    return true;
+                }
+                return 'Input is not a file.';
+            }
+            catch {
+                return 'File does not exist.';
+            }
+        },
+    });
+    return filePath;
+}

package/build/submit/commons.d.ts

@@ -0,0 +1,5 @@
+import { Platform } from '@expo/eas-build-job';
+import { ArchiveSource } from './ArchiveSource';
+import { SubmissionContext } from './context';
+export declare function resolveArchiveSource<T extends Platform>(ctx: SubmissionContext<T>): ArchiveSource;
+export declare function refreshContextSubmitProfileAsync<T extends Platform>(ctx: SubmissionContext<T>, archiveProfile: string): Promise<SubmissionContext<T>>;

package/build/submit/commons.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveArchiveSource = resolveArchiveSource;
+exports.refreshContextSubmitProfileAsync = refreshContextSubmitProfileAsync;
+const tslib_1 = require("tslib");
+const eas_json_1 = require("@expo/eas-json");
+const errors_1 = require("@expo/eas-json/build/errors");
+const ArchiveSource_1 = require("./ArchiveSource");
+const log_1 = tslib_1.__importDefault(require("../log"));
+function resolveArchiveSource(ctx) {
+    const { url, path, id, latest } = ctx.archiveFlags;
+    const chosenOptions = [url, path, id, latest];
+    if (chosenOptions.filter(opt => opt).length > 1) {
+        throw new Error(`Pass only one of: --url, --path, --id, --latest`);
+    }
+    if (url) {
+        return {
+            sourceType: ArchiveSource_1.ArchiveSourceType.url,
+            url,
+        };
+    }
+    else if (path) {
+        return {
+            sourceType: ArchiveSource_1.ArchiveSourceType.path,
+            path,
+        };
+    }
+    else if (id) {
+        if (!(0, ArchiveSource_1.isUuidV4)(id)) {
+            throw new Error(`${id} is not a valid ID`);
+        }
+        return {
+            sourceType: ArchiveSource_1.ArchiveSourceType.buildId,
+            id,
+        };
+    }
+    else if (latest) {
+        return {
+            sourceType: ArchiveSource_1.ArchiveSourceType.latest,
+        };
+    }
+    else if (ctx.nonInteractive) {
+        throw new Error('You need to specify the archive source when running in non-interactive mode ');
+    }
+    else {
+        return {
+            sourceType: ArchiveSource_1.ArchiveSourceType.prompt,
+        };
+    }
+}
+async function refreshContextSubmitProfileAsync(ctx, archiveProfile) {
+    try {
+        ctx.profile = (await eas_json_1.EasJsonUtils.getSubmitProfileAsync(eas_json_1.EasJsonAccessor.fromProjectPath(ctx.projectDir), ctx.platform, archiveProfile ? archiveProfile : 'production'));
+    }
+    catch (err) {
+        if (err instanceof errors_1.MissingProfileError) {
+            log_1.default.log(`Selected build uses "${archiveProfile}" build profile but a submit profile with the same name is missing in eas.json. Using default ("production") profile`);
+        }
+        else {
+            throw err;
+        }
+    }
+    return ctx;
+}

package/build/submit/context.d.ts

@@ -0,0 +1,56 @@
+import { ExpoConfig } from '@expo/config';
+import { Platform } from '@expo/eas-build-job';
+import { SubmitProfile } from '@expo/eas-json';
+import { Analytics, AnalyticsEventProperties } from '../analytics/AnalyticsManager';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { CredentialsContext } from '../credentials/context';
+import { Actor } from '../user/User';
+import { Client } from '../vcs/vcs';
+export interface SubmissionContext<T extends Platform> {
+    accountName: string;
+    archiveFlags: SubmitArchiveFlags;
+    credentialsCtx: CredentialsContext;
+    analyticsEventProperties: AnalyticsEventProperties;
+    exp: ExpoConfig;
+    nonInteractive: boolean;
+    isVerboseFastlaneEnabled: boolean;
+    groups: T extends Platform.IOS ? string[] : undefined;
+    platform: T;
+    profile: SubmitProfile<T>;
+    projectDir: string;
+    projectId: string;
+    projectName: string;
+    user: Actor;
+    graphqlClient: ExpoGraphqlClient;
+    analytics: Analytics;
+    vcsClient: Client;
+    applicationIdentifierOverride?: string;
+    whatToTest?: string;
+    specifiedProfile?: string;
+}
+export interface SubmitArchiveFlags {
+    latest?: boolean;
+    id?: string;
+    path?: string;
+    url?: string;
+}
+export declare function createSubmissionContextAsync<T extends Platform>(params: {
+    archiveFlags: SubmitArchiveFlags;
+    credentialsCtx?: CredentialsContext;
+    env?: Record<string, string>;
+    nonInteractive: boolean;
+    isVerboseFastlaneEnabled: boolean;
+    groups: string[] | undefined;
+    platform: T;
+    profile: SubmitProfile<T>;
+    projectDir: string;
+    applicationIdentifier?: string;
+    actor: Actor;
+    graphqlClient: ExpoGraphqlClient;
+    analytics: Analytics;
+    exp: ExpoConfig;
+    projectId: string;
+    vcsClient: Client;
+    whatToTest?: string;
+    specifiedProfile?: string;
+}): Promise<SubmissionContext<T>>;

package/build/submit/context.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSubmissionContextAsync = createSubmissionContextAsync;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const uuid_1 = require("uuid");
+const AnalyticsManager_1 = require("../analytics/AnalyticsManager");
+const context_1 = require("../credentials/context");
+const projectUtils_1 = require("../project/projectUtils");
+async function createSubmissionContextAsync(params) {
+    const { applicationIdentifier, projectDir, nonInteractive, actor, exp, projectId, graphqlClient, analytics, vcsClient, profile, groups: groupsFromParams, platform, } = params;
+    const { env, ...rest } = params;
+    const projectName = exp.slug;
+    const account = await (0, projectUtils_1.getOwnerAccountForProjectIdAsync)(graphqlClient, projectId);
+    const accountId = account.id;
+    let credentialsCtx = params.credentialsCtx;
+    if (!credentialsCtx) {
+        credentialsCtx = new context_1.CredentialsContext({
+            projectDir,
+            user: actor,
+            graphqlClient,
+            analytics,
+            projectInfo: { exp, projectId },
+            nonInteractive,
+            vcsClient,
+        });
+    }
+    let groups;
+    if (platform === eas_build_job_1.Platform.IOS) {
+        groups = (groupsFromParams ??
+            profile.groups ??
+            []);
+    }
+    else {
+        groups = undefined;
+    }
+    const analyticsEventProperties = {
+        tracking_id: (0, uuid_1.v4)(),
+        platform: params.platform,
+        ...(accountId && { account_id: accountId }),
+        project_id: projectId,
+    };
+    rest.analytics.logEvent(AnalyticsManager_1.SubmissionEvent.SUBMIT_COMMAND, analyticsEventProperties);
+    return {
+        ...rest,
+        accountName: account.name,
+        credentialsCtx,
+        groups,
+        projectName,
+        user: actor,
+        analyticsEventProperties,
+        applicationIdentifierOverride: applicationIdentifier,
+    };
+}

package/build/submit/ios/AppProduce.d.ts

@@ -0,0 +1,7 @@
+import { Platform } from '@expo/eas-build-job';
+import { SubmissionContext } from '../context';
+type AppStoreResult = {
+    ascAppIdentifier: string;
+};
+export declare function ensureAppStoreConnectAppExistsAsync(ctx: SubmissionContext<Platform.IOS>): Promise<AppStoreResult>;
+export {};