@donotuse/eas-cli 18.5.0-rc.1

package/build/submit/ios/AppProduce.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureAppStoreConnectAppExistsAsync = ensureAppStoreConnectAppExistsAsync;
+const tslib_1 = require("tslib");
+const apple_utils_1 = require("@expo/apple-utils");
+const language_1 = require("./utils/language");
+const authenticate_1 = require("../../credentials/ios/appstore/authenticate");
+const ensureAppExists_1 = require("../../credentials/ios/appstore/ensureAppExists");
+const ensureTestFlightGroup_1 = require("../../credentials/ios/appstore/ensureTestFlightGroup");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const bundleIdentifier_1 = require("../../project/ios/bundleIdentifier");
+const prompts_1 = require("../../prompts");
+async function ensureAppStoreConnectAppExistsAsync(ctx) {
+    const { exp } = ctx;
+    const { appName, language } = ctx.profile;
+    const options = {
+        ...ctx.profile,
+        bundleIdentifier: ctx.applicationIdentifierOverride ??
+            ctx.profile.bundleIdentifier ??
+            (await (0, bundleIdentifier_1.getBundleIdentifierAsync)(ctx.projectDir, exp, ctx.vcsClient)),
+        appName: appName ?? exp.name ?? (await promptForAppNameAsync()),
+        language: (0, language_1.sanitizeLanguage)(language),
+    };
+    return await createAppStoreConnectAppAsync(ctx, options);
+}
+async function isProvisioningAvailableAsync(requestCtx) {
+    const session = apple_utils_1.Session.getAnySessionInfo();
+    // TODO: Investigate if username and email can be different
+    const username = session?.user.emailAddress;
+    const [user] = await apple_utils_1.User.getAsync(requestCtx, { query: { filter: { username } } });
+    return user.attributes.provisioningAllowed;
+}
+async function createAppStoreConnectAppAsync(ctx, options) {
+    const { appleId, appleTeamId, bundleIdentifier: bundleId, appName, language, companyName, sku, } = options;
+    const userAuthCtx = await ctx.credentialsCtx.appStore.ensureUserAuthenticatedAsync({
+        appleId,
+        teamId: appleTeamId,
+    });
+    const requestCtx = (0, authenticate_1.getRequestContext)(userAuthCtx);
+    log_1.default.addNewLineIfNone();
+    if (await isProvisioningAvailableAsync(requestCtx)) {
+        await (0, ensureAppExists_1.ensureBundleIdExistsWithNameAsync)(userAuthCtx, {
+            name: appName,
+            bundleIdentifier: bundleId,
+        });
+    }
+    else {
+        log_1.default.warn(`Provisioning is not available for Apple User: ${userAuthCtx.appleId}, skipping bundle identifier check.`);
+    }
+    const app = await (0, ensureAppExists_1.ensureAppExistsAsync)(userAuthCtx, {
+        name: appName,
+        language,
+        companyName,
+        bundleIdentifier: bundleId,
+        sku,
+    });
+    try {
+        await (0, ensureTestFlightGroup_1.ensureTestFlightGroupExistsAsync)(app);
+    }
+    catch (error) {
+        // This process is not critical to the app submission so we shouldn't let it fail the entire process.
+        log_1.default.error('Failed to create an internal TestFlight group. This can be done manually in the App Store Connect website.');
+        log_1.default.error(error);
+    }
+    return {
+        ascAppIdentifier: app.id,
+    };
+}
+async function promptForAppNameAsync() {
+    const { appName } = await (0, prompts_1.promptAsync)({
+        type: 'text',
+        name: 'appName',
+        message: 'What would you like to name your app?',
+        validate: (val) => val !== '' || 'App name cannot be empty!',
+    });
+    return appName;
+}

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

@@ -0,0 +1,20 @@
+import { Platform } from '@expo/eas-build-job';
+import { SubmissionContext } from '../context';
+export declare enum AppSpecificPasswordSourceType {
+    userDefined = 0
+}
+interface AppSpecificPasswordSourceBase {
+    sourceType: AppSpecificPasswordSourceType;
+}
+interface AppSpecificPasswordUserDefinedSource extends AppSpecificPasswordSourceBase {
+    sourceType: AppSpecificPasswordSourceType.userDefined;
+    appSpecificPassword: string;
+}
+export interface AppSpecificPasswordCredentials {
+    password: string;
+    appleIdUsername: string;
+}
+export type AppSpecificPasswordSource = AppSpecificPasswordUserDefinedSource;
+export declare function getAppSpecificPasswordLocallyAsync(ctx: SubmissionContext<Platform.IOS>, source: AppSpecificPasswordSource): Promise<AppSpecificPasswordCredentials>;
+export declare function getAppleIdUsernameAsync(ctx: SubmissionContext<Platform.IOS>): Promise<string>;
+export {};

package/build/submit/ios/AppSpecificPasswordSource.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppSpecificPasswordSourceType = void 0;
+exports.getAppSpecificPasswordLocallyAsync = getAppSpecificPasswordLocallyAsync;
+exports.getAppleIdUsernameAsync = getAppleIdUsernameAsync;
+const tslib_1 = require("tslib");
+const getenv_1 = tslib_1.__importDefault(require("getenv"));
+const authenticate_1 = require("../../credentials/ios/appstore/authenticate");
+const prompts_1 = require("../../prompts");
+const UserSettings_1 = tslib_1.__importDefault(require("../../user/UserSettings"));
+var AppSpecificPasswordSourceType;
+(function (AppSpecificPasswordSourceType) {
+    AppSpecificPasswordSourceType[AppSpecificPasswordSourceType["userDefined"] = 0] = "userDefined";
+})(AppSpecificPasswordSourceType || (exports.AppSpecificPasswordSourceType = AppSpecificPasswordSourceType = {}));
+async function getAppSpecificPasswordLocallyAsync(ctx, source) {
+    if (source.sourceType === AppSpecificPasswordSourceType.userDefined) {
+        return {
+            password: source.appSpecificPassword,
+            appleIdUsername: await getAppleIdUsernameAsync(ctx),
+        };
+    }
+    else {
+        // exhaustive -- should never happen
+        throw new Error(`Unknown app specific password source type "${source?.sourceType}"`);
+    }
+}
+async function getAppleIdUsernameAsync(ctx) {
+    if (ctx.profile.appleId) {
+        return ctx.profile.appleId;
+    }
+    const envAppleId = getenv_1.default.string('EXPO_APPLE_ID', '');
+    if (envAppleId) {
+        return envAppleId;
+    }
+    if ((0, authenticate_1.isUserAuthCtx)(ctx.credentialsCtx.appStore.authCtx)) {
+        return ctx.credentialsCtx.appStore.authCtx.appleId;
+    }
+    // Get the email address that was last used and set it as
+    // the default value for quicker authentication.
+    const lastAppleId = await UserSettings_1.default.getAsync('appleId', null);
+    if (ctx.nonInteractive) {
+        if (lastAppleId) {
+            return lastAppleId;
+        }
+        else {
+            throw new Error('Set appleId in the submit profile (eas.json).');
+        }
+    }
+    const { appleId } = await (0, prompts_1.promptAsync)({
+        type: 'text',
+        name: 'appleId',
+        message: `Enter your Apple ID:`,
+        validate: (val) => !!val,
+        initial: lastAppleId ?? undefined,
+    });
+    return appleId;
+}

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

@@ -0,0 +1,39 @@
+import { Platform } from '@expo/eas-build-job';
+import { AscApiKeyPath, MinimalAscApiKey } from '../../credentials/ios/credentials';
+import { SubmissionContext } from '../context';
+export declare enum AscApiKeySourceType {
+    path = 0,
+    prompt = 1,
+    credentialsService = 2
+}
+interface AscApiKeySourceBase {
+    sourceType: AscApiKeySourceType;
+}
+interface AscApiKeyCredentialsServiceSource extends AscApiKeySourceBase {
+    sourceType: AscApiKeySourceType.credentialsService;
+}
+interface AscApiKeyPromptSource extends AscApiKeySourceBase {
+    sourceType: AscApiKeySourceType.prompt;
+}
+interface AscApiKeyEnvVarSource extends AscApiKeySourceBase {
+    sourceType: AscApiKeySourceType.path;
+    path: AscApiKeyPath;
+}
+export type AscApiKeySource = AscApiKeyEnvVarSource | AscApiKeyPromptSource | AscApiKeyCredentialsServiceSource;
+type AscApiKeySummary = {
+    source: 'local' | 'EAS servers';
+    path?: string;
+    keyId: string;
+    name?: string;
+};
+export type AscApiKeyFromExpoServers = {
+    ascApiKeyId: string;
+};
+export type AscApiKeyResult = {
+    result: MinimalAscApiKey | AscApiKeyFromExpoServers;
+    summary: AscApiKeySummary;
+};
+export declare function getAscApiKeyResultAsync(ctx: SubmissionContext<Platform.IOS>, source: AscApiKeySource): Promise<AscApiKeyResult>;
+export declare function getAscApiKeyLocallyAsync(ctx: SubmissionContext<Platform.IOS>, source: AscApiKeySource): Promise<AscApiKeyResult>;
+export declare function getAscApiKeyPathAsync(ctx: SubmissionContext<Platform.IOS>, source: AscApiKeySource): Promise<AscApiKeyPath>;
+export {};

package/build/submit/ios/AscApiKeySource.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AscApiKeySourceType = void 0;
+exports.getAscApiKeyResultAsync = getAscApiKeyResultAsync;
+exports.getAscApiKeyLocallyAsync = getAscApiKeyLocallyAsync;
+exports.getAscApiKeyPathAsync = getAscApiKeyPathAsync;
+const tslib_1 = require("tslib");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const AscApiKeyUtils_1 = require("../../credentials/ios/actions/AscApiKeyUtils");
+const SetUpAscApiKey_1 = require("../../credentials/ios/actions/SetUpAscApiKey");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const bundleIdentifier_1 = require("../../project/ios/bundleIdentifier");
+const prompts_1 = require("../../prompts");
+const files_1 = require("../utils/files");
+var AscApiKeySourceType;
+(function (AscApiKeySourceType) {
+    AscApiKeySourceType[AscApiKeySourceType["path"] = 0] = "path";
+    AscApiKeySourceType[AscApiKeySourceType["prompt"] = 1] = "prompt";
+    AscApiKeySourceType[AscApiKeySourceType["credentialsService"] = 2] = "credentialsService";
+})(AscApiKeySourceType || (exports.AscApiKeySourceType = AscApiKeySourceType = {}));
+async function getAscApiKeyResultAsync(ctx, source) {
+    if (source.sourceType === AscApiKeySourceType.credentialsService) {
+        return await getAscApiKeyFromCredentialsServiceAsync(ctx);
+    }
+    else {
+        return await getAscApiKeyLocallyAsync(ctx, source);
+    }
+}
+async function maybeGetIosBundleIdentifierAsync(ctx) {
+    try {
+        return await (0, bundleIdentifier_1.getBundleIdentifierAsync)(ctx.projectDir, ctx.exp, ctx.vcsClient);
+    }
+    catch (error) {
+        if (error instanceof bundleIdentifier_1.AmbiguousBundleIdentifierError) {
+            log_1.default.warn('bundleIdentifier in the Xcode project is ambiguous, specify it via "bundleIdentifier" field in the submit profile in the eas.json.');
+            return null;
+        }
+        throw new Error(`Failed to resolve bundleIdentifier in the Xcode project: ${error.message}.`);
+    }
+}
+async function promptForBundleIdentifierAsync() {
+    const { bundleIdentifier } = await (0, prompts_1.promptAsync)({
+        name: 'bundleIdentifier',
+        message: 'Bundle identifier:',
+        type: 'text',
+        validate: value => ((0, bundleIdentifier_1.isBundleIdentifierValid)(value) ? true : bundleIdentifier_1.INVALID_BUNDLE_IDENTIFIER_MESSAGE),
+    });
+    return bundleIdentifier;
+}
+async function getAscApiKeyFromCredentialsServiceAsync(ctx) {
+    const bundleIdentifier = ctx.applicationIdentifierOverride ??
+        ctx.profile.bundleIdentifier ??
+        (await maybeGetIosBundleIdentifierAsync(ctx)) ??
+        (await promptForBundleIdentifierAsync());
+    log_1.default.log(`Looking up credentials configuration for ${bundleIdentifier}...`);
+    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,
+        bundleIdentifier,
+    };
+    const setupAscApiKeyAction = new SetUpAscApiKey_1.SetUpAscApiKey(appLookupParams, AscApiKeyUtils_1.AppStoreApiKeyPurpose.SUBMISSION_SERVICE);
+    const iosAppCredentials = await setupAscApiKeyAction.runAsync(ctx.credentialsCtx);
+    const ascKeyForSubmissions = (0, nullthrows_1.default)(iosAppCredentials.appStoreConnectApiKeyForSubmissions, `An EAS Submit ASC Api Key could not be found for ${iosAppCredentials.appleAppIdentifier.bundleIdentifier}`);
+    const { id, keyIdentifier, name } = ascKeyForSubmissions;
+    log_1.default.log(`Using Api Key ID: ${keyIdentifier}${name ? ` (${name})` : ''}`);
+    return {
+        result: {
+            ascApiKeyId: id,
+        },
+        summary: {
+            source: 'EAS servers',
+            keyId: keyIdentifier,
+            name: name ?? undefined,
+        },
+    };
+}
+async function getAscApiKeyLocallyAsync(ctx, source) {
+    const ascApiKeyPath = await getAscApiKeyPathAsync(ctx, source);
+    const { keyP8Path, keyId, issuerId } = ascApiKeyPath;
+    const keyP8 = await fs_extra_1.default.readFile(keyP8Path, 'utf-8');
+    return {
+        result: { keyP8, keyId, issuerId },
+        summary: {
+            source: 'local',
+            path: keyP8Path,
+            keyId,
+        },
+    };
+}
+async function getAscApiKeyPathAsync(ctx, source) {
+    switch (source.sourceType) {
+        case AscApiKeySourceType.path:
+            return await handlePathSourceAsync(ctx, source);
+        case AscApiKeySourceType.prompt:
+            return await handlePromptSourceAsync(ctx, source);
+        case AscApiKeySourceType.credentialsService:
+            throw new Error(`AscApiKeySourceType ${source} does not return a path.`);
+    }
+}
+async function handlePathSourceAsync(ctx, source) {
+    const { keyP8Path } = source.path;
+    if (!(await (0, files_1.isExistingFileAsync)(keyP8Path))) {
+        log_1.default.warn(`File ${keyP8Path} doesn't exist.`);
+        return await getAscApiKeyPathAsync(ctx, { sourceType: AscApiKeySourceType.prompt });
+    }
+    return source.path;
+}
+async function handlePromptSourceAsync(ctx, _source) {
+    const ascApiKeyPath = await (0, AscApiKeyUtils_1.promptForAscApiKeyPathAsync)(ctx.credentialsCtx);
+    return await getAscApiKeyPathAsync(ctx, {
+        sourceType: AscApiKeySourceType.path,
+        path: ascApiKeyPath,
+    });
+}

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

@@ -0,0 +1,14 @@
+import { Platform } from '@expo/eas-build-job';
+import IosSubmitter from './IosSubmitter';
+import { SubmissionContext } from '../context';
+export default class IosSubmitCommand {
+    private ctx;
+    constructor(ctx: SubmissionContext<Platform.IOS>);
+    runAsync(): Promise<IosSubmitter>;
+    private resolveSubmissionOptionsAsync;
+    private resolveCredentialSubmissionOptionsAsync;
+    private resolveAppSpecificPasswordSource;
+    private resolveAscApiKeySource;
+    private resolveArchiveSource;
+    private resolveAscAppIdentifierAsync;
+}

package/build/submit/ios/IosSubmitCommand.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const results_1 = require("@expo/results");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const getenv_1 = tslib_1.__importDefault(require("getenv"));
+const wrap_ansi_1 = tslib_1.__importDefault(require("wrap-ansi"));
+const AppProduce_1 = require("./AppProduce");
+const AppSpecificPasswordSource_1 = require("./AppSpecificPasswordSource");
+const AscApiKeySource_1 = require("./AscApiKeySource");
+const IosSubmitter_1 = tslib_1.__importDefault(require("./IosSubmitter"));
+const errors_1 = require("../../credentials/errors");
+const log_1 = tslib_1.__importStar(require("../../log"));
+const ArchiveSource_1 = require("../ArchiveSource");
+const commons_1 = require("../commons");
+class IosSubmitCommand {
+    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.IOS,
+            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 options = await this.resolveSubmissionOptionsAsync(archiveSourceValue);
+        const submitter = new IosSubmitter_1.default(this.ctx, options, archive);
+        return submitter;
+    }
+    async resolveSubmissionOptionsAsync(archiveSource) {
+        const credentialsSource = await this.resolveCredentialSubmissionOptionsAsync();
+        const maybeAppSpecificPasswordSource = 'appSpecificPasswordSource' in credentialsSource
+            ? credentialsSource.appSpecificPasswordSource
+            : null;
+        const maybeAscApiKeySource = 'ascApiKeySource' in credentialsSource ? credentialsSource.ascApiKeySource : null;
+        const ascAppIdentifier = await this.resolveAscAppIdentifierAsync();
+        const errored = [
+            ...(maybeAppSpecificPasswordSource ? [maybeAppSpecificPasswordSource] : []),
+            ...(maybeAscApiKeySource ? [maybeAscApiKeySource] : []),
+            ascAppIdentifier,
+        ].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,
+            ascAppIdentifier: ascAppIdentifier.enforceValue(),
+            archiveSource,
+            ...(maybeAppSpecificPasswordSource
+                ? {
+                    appSpecificPasswordSource: maybeAppSpecificPasswordSource.enforceValue(),
+                }
+                : null),
+            ...(maybeAscApiKeySource
+                ? {
+                    ascApiKeySource: maybeAscApiKeySource.enforceValue(),
+                }
+                : null),
+        };
+    }
+    async resolveCredentialSubmissionOptionsAsync() {
+        // if an App Specific Password env var is not specified, use ASC Api Key
+        const appSpecificPasswordSource = this.resolveAppSpecificPasswordSource();
+        const shouldSkipAppSpecificPasswordSource = !appSpecificPasswordSource.ok &&
+            appSpecificPasswordSource.enforceError() instanceof errors_1.MissingCredentialsError;
+        if (!shouldSkipAppSpecificPasswordSource) {
+            return { appSpecificPasswordSource: this.resolveAppSpecificPasswordSource() };
+        }
+        const ascApiKeySource = this.resolveAscApiKeySource();
+        return { ascApiKeySource };
+    }
+    resolveAppSpecificPasswordSource() {
+        const envAppSpecificPassword = getenv_1.default.string('EXPO_APPLE_APP_SPECIFIC_PASSWORD', '');
+        if (envAppSpecificPassword) {
+            if (!/^[a-z]{4}-[a-z]{4}-[a-z]{4}-[a-z]{4}$/.test(envAppSpecificPassword)) {
+                throw new Error('EXPO_APPLE_APP_SPECIFIC_PASSWORD must be in the format xxxx-xxxx-xxxx-xxxx, where x is a lowercase letter.');
+            }
+            return (0, results_1.result)({
+                sourceType: AppSpecificPasswordSource_1.AppSpecificPasswordSourceType.userDefined,
+                appSpecificPassword: envAppSpecificPassword,
+            });
+        }
+        return (0, results_1.result)(new errors_1.MissingCredentialsError('The EXPO_APPLE_APP_SPECIFIC_PASSWORD environment variable must be set.'));
+    }
+    resolveAscApiKeySource() {
+        const { ascApiKeyPath, ascApiKeyIssuerId, ascApiKeyId } = this.ctx.profile;
+        if (ascApiKeyPath && ascApiKeyIssuerId && ascApiKeyId) {
+            return (0, results_1.result)({
+                sourceType: AscApiKeySource_1.AscApiKeySourceType.path,
+                path: {
+                    keyP8Path: ascApiKeyPath,
+                    issuerId: ascApiKeyIssuerId,
+                    keyId: ascApiKeyId,
+                },
+            });
+        }
+        // interpret this to mean the user had some intention of passing in ASC Api key
+        if (ascApiKeyPath || ascApiKeyIssuerId || ascApiKeyId) {
+            const message = `ascApiKeyPath, ascApiKeyIssuerId and ascApiKeyId must all be defined in eas.json`;
+            // in non-interactive mode, we should fail
+            if (this.ctx.nonInteractive) {
+                throw new Error(message);
+            }
+            log_1.default.warn(message);
+            return (0, results_1.result)({
+                sourceType: AscApiKeySource_1.AscApiKeySourceType.prompt,
+            });
+        }
+        return (0, results_1.result)({ sourceType: AscApiKeySource_1.AscApiKeySourceType.credentialsService });
+    }
+    resolveArchiveSource() {
+        try {
+            return (0, results_1.result)((0, commons_1.resolveArchiveSource)(this.ctx));
+        }
+        catch (err) {
+            return (0, results_1.result)(err);
+        }
+    }
+    async resolveAscAppIdentifierAsync() {
+        const { ascAppId } = this.ctx.profile;
+        if (ascAppId) {
+            return (0, results_1.result)(ascAppId);
+        }
+        else if (this.ctx.nonInteractive) {
+            return (0, results_1.result)(new Error('Set ascAppId in the submit profile (eas.json) or re-run this command in interactive mode.'));
+        }
+        else {
+            log_1.default.log((0, wrap_ansi_1.default)(`Ensuring your app exists on App Store Connect. This step can be skipped by providing ${chalk_1.default.bold(`ascAppId`)} in the submit profile. ${(0, log_1.learnMore)('https://expo.fyi/asc-app-id')}`, process.stdout.columns || 80));
+            log_1.default.addNewLineIfNone();
+            try {
+                const { ascAppIdentifier } = await (0, AppProduce_1.ensureAppStoreConnectAppExistsAsync)(this.ctx);
+                return (0, results_1.result)(ascAppIdentifier);
+            }
+            catch (err) {
+                return (0, results_1.result)(err);
+            }
+        }
+    }
+}
+exports.default = IosSubmitCommand;

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

@@ -0,0 +1,31 @@
+import { Platform } from '@expo/eas-build-job';
+import { AppSpecificPasswordCredentials, AppSpecificPasswordSource } from './AppSpecificPasswordSource';
+import { AscApiKeyResult, AscApiKeySource } from './AscApiKeySource';
+import { IosSubmissionConfigInput, SubmissionFragment } from '../../graphql/generated';
+import { ArchiveSource, ResolvedArchiveSource } from '../ArchiveSource';
+import BaseSubmitter, { SubmissionInput } from '../BaseSubmitter';
+import { SubmissionContext } from '../context';
+export interface IosSubmissionOptions extends Pick<IosSubmissionConfigInput, 'appleIdUsername' | 'ascAppIdentifier'> {
+    projectId: string;
+    archiveSource: ArchiveSource;
+    appSpecificPasswordSource?: AppSpecificPasswordSource;
+    ascApiKeySource?: AscApiKeySource;
+    isVerboseFastlaneEnabled?: boolean;
+}
+interface ResolvedSourceOptions {
+    archive: ResolvedArchiveSource;
+    credentials: {
+        appSpecificPassword?: AppSpecificPasswordCredentials;
+        ascApiKeyResult?: AscApiKeyResult;
+    };
+}
+export default class IosSubmitter extends BaseSubmitter<Platform.IOS, ResolvedSourceOptions, IosSubmissionOptions> {
+    constructor(ctx: SubmissionContext<Platform.IOS>, options: IosSubmissionOptions, archive: ResolvedArchiveSource);
+    createSubmissionInputAsync(resolvedSourceOptions: ResolvedSourceOptions): Promise<SubmissionInput<Platform.IOS>>;
+    protected createPlatformSubmissionAsync({ projectId, submissionConfig, buildId, archiveSource, }: SubmissionInput<Platform.IOS>): Promise<SubmissionFragment>;
+    private formatSubmissionConfig;
+    private formatAppSpecificPassword;
+    private formatAscApiKeyResult;
+    private prepareSummaryData;
+}
+export {};

package/build/submit/ios/IosSubmitter.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const AppSpecificPasswordSource_1 = require("./AppSpecificPasswordSource");
+const AscApiKeySource_1 = require("./AscApiKeySource");
+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 IosSubmitter 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
+            credentials: async () => {
+                const maybeAppSpecificPassword = this.options.appSpecificPasswordSource
+                    ? await (0, AppSpecificPasswordSource_1.getAppSpecificPasswordLocallyAsync)(this.ctx, this.options.appSpecificPasswordSource)
+                    : null;
+                const maybeAppStoreConnectApiKey = this.options.ascApiKeySource
+                    ? await (0, AscApiKeySource_1.getAscApiKeyResultAsync)(this.ctx, this.options.ascApiKeySource)
+                    : null;
+                return {
+                    ...(maybeAppSpecificPassword ? { appSpecificPassword: maybeAppSpecificPassword } : null),
+                    ...(maybeAppStoreConnectApiKey ? { ascApiKeyResult: maybeAppStoreConnectApiKey } : null),
+                };
+            },
+        };
+        const sourceOptionsAnalytics = {
+            archive: {
+                attemptEvent: AnalyticsManager_1.SubmissionEvent.GATHER_ARCHIVE_ATTEMPT,
+                successEvent: AnalyticsManager_1.SubmissionEvent.GATHER_ARCHIVE_SUCCESS,
+                failureEvent: AnalyticsManager_1.SubmissionEvent.GATHER_ARCHIVE_FAIL,
+            },
+            credentials: {
+                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.createIosSubmissionAsync(this.ctx.graphqlClient, {
+            appId: projectId,
+            config: submissionConfig,
+            submittedBuildId: buildId,
+            archiveSource,
+        });
+    }
+    formatSubmissionConfig(options, { credentials }) {
+        const { appSpecificPassword, ascApiKeyResult } = credentials;
+        const { appleIdUsername, ascAppIdentifier } = options;
+        const { isVerboseFastlaneEnabled, groups, whatToTest } = this.ctx;
+        return {
+            ascAppIdentifier,
+            appleIdUsername,
+            isVerboseFastlaneEnabled,
+            groups,
+            changelog: whatToTest,
+            ...(appSpecificPassword ? this.formatAppSpecificPassword(appSpecificPassword) : null),
+            ...(ascApiKeyResult?.result ? this.formatAscApiKeyResult(ascApiKeyResult.result) : null),
+        };
+    }
+    formatAppSpecificPassword(appSpecificPassword) {
+        return {
+            appleAppSpecificPassword: appSpecificPassword.password,
+            appleIdUsername: appSpecificPassword.appleIdUsername,
+        };
+    }
+    formatAscApiKeyResult(result) {
+        return 'ascApiKeyId' in result
+            ? { ascApiKeyId: result.ascApiKeyId }
+            : {
+                ascApiKey: {
+                    keyP8: result.keyP8,
+                    keyIdentifier: result.keyId,
+                    issuerIdentifier: result.issuerId,
+                },
+            };
+    }
+    prepareSummaryData(options, { archive, credentials }) {
+        const { ascApiKeyResult, appSpecificPassword } = credentials;
+        const { ascAppIdentifier, projectId } = options;
+        // structuring order affects table rows order
+        return {
+            ascAppIdentifier,
+            projectId,
+            ...(appSpecificPassword ? { appleIdUsername: appSpecificPassword.appleIdUsername } : null),
+            ...(ascApiKeyResult ? { formattedAscApiKey: formatAscApiKeySummary(ascApiKeyResult) } : null),
+            ...(0, summary_1.formatArchiveSourceSummary)(archive),
+        };
+    }
+}
+exports.default = IosSubmitter;
+const SummaryHumanReadableKeys = {
+    ascAppIdentifier: 'ASC App ID',
+    appleIdUsername: 'Apple ID',
+    projectId: 'Project ID',
+    archiveUrl: 'Archive URL',
+    archivePath: 'Archive Path',
+    formattedBuild: 'Build',
+    formattedAscApiKey: 'App Store Connect API Key',
+};
+function formatAscApiKeySummary({ summary }) {
+    const { source, path, keyId, name } = summary;
+    const fields = [
+        {
+            label: 'Key Name',
+            value: name,
+        },
+        {
+            label: 'Key ID',
+            value: keyId,
+        },
+        {
+            label: 'Key Source',
+            value: source,
+        },
+        {
+            label: 'Key Path',
+            value: path,
+        },
+    ];
+    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/ios/utils/language.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Sanitizes language for App Store Connect.
+ * @param lang Language to sanitize
+ * @returns Provided language if valid
+ * @throws Error if language is invalid.s
+ */
+export declare function sanitizeLanguage(lang?: string, { defaultLang }?: {
+    defaultLang?: string;
+}): string;