@donotuse/eas-cli 18.5.0-rc.1

package/build/build/context.d.ts

@@ -0,0 +1,64 @@
+import { ExpoConfig } from '@expo/config';
+import { Platform, Workflow } from '@expo/eas-build-job';
+import { BuildProfile, EasJson } from '@expo/eas-json';
+import { LoggerLevel } from '@expo/logger';
+import { NodePackageManager } from '@expo/package-manager';
+import { LocalBuildOptions } from './local';
+import { Analytics, AnalyticsEventProperties } from '../analytics/AnalyticsManager';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { CredentialsContext } from '../credentials/context';
+import { Target } from '../credentials/ios/types';
+import { BuildResourceClass } from '../graphql/generated';
+import { GradleBuildContext } from '../project/android/gradle';
+import { CustomBuildConfigMetadata } from '../project/customBuildConfig';
+import { XcodeBuildContext } from '../project/ios/scheme';
+import { Actor } from '../user/User';
+import { Client } from '../vcs/vcs';
+export type CommonContext<T extends Platform> = Omit<BuildContext<T>, 'android' | 'ios'>;
+export interface AndroidBuildContext {
+    applicationId: string;
+    gradleContext?: GradleBuildContext;
+    versionCodeOverride?: string;
+}
+export interface IosBuildContext {
+    bundleIdentifier: string;
+    applicationTarget: Target;
+    targets: Target[];
+    xcodeBuildContext: XcodeBuildContext;
+    buildNumberOverride?: string;
+}
+export interface BuildContext<T extends Platform> {
+    accountId: string;
+    accountName: string;
+    easJsonCliConfig: EasJson['cli'];
+    buildProfile: BuildProfile<T>;
+    buildProfileName: string;
+    resourceClass: BuildResourceClass;
+    clearCache: boolean;
+    credentialsCtx: CredentialsContext;
+    exp: ExpoConfig;
+    localBuildOptions: LocalBuildOptions;
+    nonInteractive: boolean;
+    noWait: boolean;
+    runFromCI: boolean;
+    platform: T;
+    projectDir: string;
+    projectId: string;
+    projectName: string;
+    message?: string;
+    analyticsEventProperties: AnalyticsEventProperties;
+    user: Actor;
+    graphqlClient: ExpoGraphqlClient;
+    analytics: Analytics;
+    workflow: Workflow;
+    customBuildConfigMetadata?: CustomBuildConfigMetadata;
+    android: T extends Platform.ANDROID ? AndroidBuildContext : undefined;
+    ios: T extends Platform.IOS ? IosBuildContext : undefined;
+    developmentClient: boolean;
+    requiredPackageManager: NodePackageManager['name'] | null;
+    vcsClient: Client;
+    loggerLevel?: LoggerLevel;
+    isVerboseLoggingEnabled: boolean;
+    whatToTest?: string;
+    env: Record<string, string>;
+}

package/build/build/context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/build/createContext.d.ts

@@ -0,0 +1,35 @@
+import { Platform } from '@expo/eas-build-job';
+import { BuildProfile, EasJson, ResourceClass } from '@expo/eas-json';
+import { LoggerLevel } from '@expo/logger';
+import { BuildContext } from './context';
+import { LocalBuildOptions } from './local';
+import { Analytics } from '../analytics/AnalyticsManager';
+import { DynamicConfigContextFn } from '../commandUtils/context/DynamicProjectConfigContextField';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { CustomBuildConfigMetadata } from '../project/customBuildConfig';
+import { Actor } from '../user/User';
+import { Client } from '../vcs/vcs';
+export declare function createBuildContextAsync<T extends Platform>({ buildProfileName, buildProfile, easJsonCliConfig, clearCache, localBuildOptions, nonInteractive, noWait, platform, projectDir, resourceClassFlag, message, actor, graphqlClient, analytics, vcsClient, getDynamicPrivateProjectConfigAsync, customBuildConfigMetadata, buildLoggerLevel, freezeCredentials, isVerboseLoggingEnabled, whatToTest, env, }: {
+    buildProfileName: string;
+    buildProfile: BuildProfile<T>;
+    easJsonCliConfig: EasJson['cli'];
+    clearCache: boolean;
+    localBuildOptions: LocalBuildOptions;
+    nonInteractive: boolean;
+    noWait: boolean;
+    platform: T;
+    projectDir: string;
+    resourceClassFlag?: ResourceClass;
+    message?: string;
+    actor: Actor;
+    graphqlClient: ExpoGraphqlClient;
+    analytics: Analytics;
+    vcsClient: Client;
+    getDynamicPrivateProjectConfigAsync: DynamicConfigContextFn;
+    customBuildConfigMetadata?: CustomBuildConfigMetadata;
+    buildLoggerLevel?: LoggerLevel;
+    freezeCredentials: boolean;
+    isVerboseLoggingEnabled: boolean;
+    whatToTest?: string;
+    env: Record<string, string>;
+}): Promise<BuildContext<T>>;

package/build/build/createContext.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuildContextAsync = createBuildContextAsync;
+const tslib_1 = require("tslib");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const json_file_1 = tslib_1.__importDefault(require("@expo/json-file"));
+const package_manager_1 = require("@expo/package-manager");
+const getenv_1 = tslib_1.__importDefault(require("getenv"));
+const resolve_from_1 = tslib_1.__importDefault(require("resolve-from"));
+const uuid_1 = require("uuid");
+const build_1 = require("./android/build");
+const build_2 = require("./ios/build");
+const local_1 = require("./local");
+const resourceClass_1 = require("./utils/resourceClass");
+const AnalyticsManager_1 = require("../analytics/AnalyticsManager");
+const context_1 = require("../credentials/context");
+const projectUtils_1 = require("../project/projectUtils");
+const workflow_1 = require("../project/workflow");
+async function createBuildContextAsync({ buildProfileName, buildProfile, easJsonCliConfig, clearCache = false, localBuildOptions, nonInteractive, noWait, platform, projectDir, resourceClassFlag, message, actor, graphqlClient, analytics, vcsClient, getDynamicPrivateProjectConfigAsync, customBuildConfigMetadata, buildLoggerLevel, freezeCredentials, isVerboseLoggingEnabled, whatToTest, env, }) {
+    const { exp, projectId } = await getDynamicPrivateProjectConfigAsync({
+        env,
+    });
+    const projectName = exp.slug;
+    const [account, workflow] = await Promise.all([
+        (0, projectUtils_1.getOwnerAccountForProjectIdAsync)(graphqlClient, projectId),
+        (0, workflow_1.resolveWorkflowAsync)(projectDir, platform, vcsClient),
+    ]);
+    const accountId = account.id;
+    const runFromCI = getenv_1.default.boolish('CI', false);
+    const developmentClient = buildProfile.developmentClient ??
+        (platform === eas_build_job_1.Platform.ANDROID
+            ? buildProfile?.gradleCommand === ':app:assembleDebug'
+            : buildProfile?.buildConfiguration === 'Debug') ??
+        false;
+    const requiredPackageManager = (0, package_manager_1.resolvePackageManager)(projectDir);
+    const credentialsCtx = new context_1.CredentialsContext({
+        projectInfo: { exp, projectId },
+        nonInteractive,
+        projectDir,
+        user: actor,
+        graphqlClient,
+        analytics,
+        env,
+        easJsonCliConfig,
+        vcsClient,
+        freezeCredentials,
+    });
+    const devClientProperties = getDevClientEventProperties({
+        platform,
+        projectDir,
+        buildProfile,
+    });
+    const analyticsEventProperties = {
+        tracking_id: (0, uuid_1.v4)(),
+        platform,
+        ...(exp.sdkVersion && { sdk_version: exp.sdkVersion }),
+        ...(accountId && { account_id: accountId }),
+        project_id: projectId,
+        project_type: workflow,
+        ...devClientProperties,
+        no_wait: noWait,
+        run_from_ci: runFromCI,
+        local: localBuildOptions.localBuildMode === local_1.LocalBuildMode.LOCAL_BUILD_PLUGIN,
+    };
+    analytics.logEvent(AnalyticsManager_1.BuildEvent.BUILD_COMMAND, analyticsEventProperties);
+    const resourceClass = (0, resourceClass_1.resolveBuildResourceClass)(buildProfile, platform, resourceClassFlag);
+    const commonContext = {
+        accountId,
+        accountName: account.name,
+        buildProfile,
+        buildProfileName,
+        resourceClass,
+        easJsonCliConfig,
+        clearCache,
+        credentialsCtx,
+        exp,
+        localBuildOptions,
+        nonInteractive,
+        noWait,
+        platform,
+        projectDir,
+        projectId,
+        projectName,
+        analyticsEventProperties,
+        user: actor,
+        graphqlClient,
+        analytics,
+        vcsClient,
+        workflow,
+        message,
+        runFromCI,
+        customBuildConfigMetadata,
+        developmentClient,
+        requiredPackageManager,
+        loggerLevel: buildLoggerLevel,
+        isVerboseLoggingEnabled,
+        env,
+        whatToTest,
+    };
+    if (platform === eas_build_job_1.Platform.ANDROID) {
+        const common = commonContext;
+        return {
+            ...common,
+            android: await (0, build_1.createAndroidContextAsync)(common),
+        };
+    }
+    else {
+        const common = commonContext;
+        return {
+            ...common,
+            ios: await (0, build_2.createIosContextAsync)(common),
+        };
+    }
+}
+function getDevClientEventProperties({ platform, projectDir, buildProfile, }) {
+    let includesDevClient;
+    const version = tryGetDevClientVersion(projectDir);
+    if (platform === eas_build_job_1.Platform.ANDROID && 'gradleCommand' in buildProfile) {
+        includesDevClient = Boolean(version && buildProfile.gradleCommand?.includes('Debug'));
+    }
+    else if (platform === eas_build_job_1.Platform.IOS && 'buildConfiguration' in buildProfile) {
+        includesDevClient = Boolean(version && buildProfile.buildConfiguration === 'Debug');
+    }
+    else if (buildProfile.developmentClient) {
+        includesDevClient = true;
+    }
+    else {
+        includesDevClient = false;
+    }
+    if (version) {
+        return { dev_client: includesDevClient, dev_client_version: version };
+    }
+    else {
+        return { dev_client: includesDevClient };
+    }
+}
+function tryGetDevClientVersion(projectDir) {
+    try {
+        const pkg = json_file_1.default.read((0, resolve_from_1.default)(projectDir, 'expo-dev-client/package.json'));
+        return pkg.version?.toString() ?? null;
+    }
+    catch {
+        return null;
+    }
+}

package/build/build/errors.d.ts

@@ -0,0 +1,25 @@
+import { EasCommandError } from '../commandUtils/errors';
+export declare class TurtleDeprecatedJobFormatError extends EasCommandError {
+}
+export declare class EasBuildFreeTierDisabledError extends EasCommandError {
+}
+export declare class EasBuildFreeTierDisabledIOSError extends EasCommandError {
+}
+export declare class EasBuildFreeTierDisabledAndroidError extends EasCommandError {
+}
+export declare class EasBuildFreeTierLimitExceededError extends EasCommandError {
+}
+export declare class EasBuildFreeTierIosLimitExceededError extends EasCommandError {
+}
+export declare class EasBuildResourceClassNotAvailableInFreeTierError extends EasCommandError {
+}
+export declare class EasBuildLegacyResourceClassNotAvailableError extends EasCommandError {
+}
+export declare class RequestValidationError extends EasCommandError {
+}
+export declare class EasBuildDownForMaintenanceError extends EasCommandError {
+}
+export declare class EasBuildTooManyPendingBuildsError extends EasCommandError {
+}
+export declare class EasBuildProjectArchiveUploadError extends EasCommandError {
+}

package/build/build/errors.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EasBuildProjectArchiveUploadError = exports.EasBuildTooManyPendingBuildsError = exports.EasBuildDownForMaintenanceError = exports.RequestValidationError = exports.EasBuildLegacyResourceClassNotAvailableError = exports.EasBuildResourceClassNotAvailableInFreeTierError = exports.EasBuildFreeTierIosLimitExceededError = exports.EasBuildFreeTierLimitExceededError = exports.EasBuildFreeTierDisabledAndroidError = exports.EasBuildFreeTierDisabledIOSError = exports.EasBuildFreeTierDisabledError = exports.TurtleDeprecatedJobFormatError = void 0;
+const errors_1 = require("../commandUtils/errors");
+class TurtleDeprecatedJobFormatError extends errors_1.EasCommandError {
+}
+exports.TurtleDeprecatedJobFormatError = TurtleDeprecatedJobFormatError;
+class EasBuildFreeTierDisabledError extends errors_1.EasCommandError {
+}
+exports.EasBuildFreeTierDisabledError = EasBuildFreeTierDisabledError;
+class EasBuildFreeTierDisabledIOSError extends errors_1.EasCommandError {
+}
+exports.EasBuildFreeTierDisabledIOSError = EasBuildFreeTierDisabledIOSError;
+class EasBuildFreeTierDisabledAndroidError extends errors_1.EasCommandError {
+}
+exports.EasBuildFreeTierDisabledAndroidError = EasBuildFreeTierDisabledAndroidError;
+class EasBuildFreeTierLimitExceededError extends errors_1.EasCommandError {
+}
+exports.EasBuildFreeTierLimitExceededError = EasBuildFreeTierLimitExceededError;
+class EasBuildFreeTierIosLimitExceededError extends errors_1.EasCommandError {
+}
+exports.EasBuildFreeTierIosLimitExceededError = EasBuildFreeTierIosLimitExceededError;
+class EasBuildResourceClassNotAvailableInFreeTierError extends errors_1.EasCommandError {
+}
+exports.EasBuildResourceClassNotAvailableInFreeTierError = EasBuildResourceClassNotAvailableInFreeTierError;
+class EasBuildLegacyResourceClassNotAvailableError extends errors_1.EasCommandError {
+}
+exports.EasBuildLegacyResourceClassNotAvailableError = EasBuildLegacyResourceClassNotAvailableError;
+class RequestValidationError extends errors_1.EasCommandError {
+}
+exports.RequestValidationError = RequestValidationError;
+class EasBuildDownForMaintenanceError extends errors_1.EasCommandError {
+}
+exports.EasBuildDownForMaintenanceError = EasBuildDownForMaintenanceError;
+class EasBuildTooManyPendingBuildsError extends errors_1.EasCommandError {
+}
+exports.EasBuildTooManyPendingBuildsError = EasBuildTooManyPendingBuildsError;
+class EasBuildProjectArchiveUploadError extends errors_1.EasCommandError {
+}
+exports.EasBuildProjectArchiveUploadError = EasBuildProjectArchiveUploadError;

package/build/build/evaluateConfigWithEnvVarsAsync.d.ts

@@ -0,0 +1,14 @@
+import { Env } from '@expo/eas-build-job';
+import { BuildProfile } from '@expo/eas-json';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+export declare function evaluateConfigWithEnvVarsAsync<Config extends {
+    projectId: string;
+}, Opts>({ buildProfile, buildProfileName, graphqlClient, getProjectConfig, opts, }: {
+    buildProfile: BuildProfile;
+    buildProfileName: string;
+    graphqlClient: ExpoGraphqlClient | null;
+    opts: Opts;
+    getProjectConfig(opts: Opts): Promise<Config>;
+}): Promise<Config & {
+    env: Env;
+}>;

package/build/build/evaluateConfigWithEnvVarsAsync.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateConfigWithEnvVarsAsync = evaluateConfigWithEnvVarsAsync;
+const tslib_1 = require("tslib");
+const environment_1 = require("./utils/environment");
+const EnvironmentVariablesQuery_1 = require("../graphql/queries/EnvironmentVariablesQuery");
+const log_1 = tslib_1.__importStar(require("../log"));
+async function evaluateConfigWithEnvVarsAsync({ buildProfile, buildProfileName, graphqlClient, getProjectConfig, opts, }) {
+    if (!graphqlClient) {
+        log_1.default.warn('An Expo user account is required to fetch environment variables.');
+        const config = await getProjectConfig(opts);
+        return { env: buildProfile.env ?? {}, ...config };
+    }
+    const { projectId } = await getProjectConfig({ env: buildProfile.env, ...opts });
+    const env = await resolveEnvVarsAsync({
+        buildProfile,
+        buildProfileName,
+        graphqlClient,
+        projectId,
+    });
+    const config = await getProjectConfig({ ...opts, env });
+    return { env, ...config };
+}
+async function resolveEnvVarsAsync({ buildProfile, buildProfileName, graphqlClient, projectId, }) {
+    const environment = buildProfile.environment ??
+        resolveSuggestedEnvironmentForBuildProfileConfiguration(buildProfile);
+    try {
+        const environmentVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdWithSensitiveAsync(graphqlClient, {
+            appId: projectId,
+            environment,
+        });
+        const serverEnvVars = Object.fromEntries(environmentVariables
+            .filter(({ name, value }) => name && value)
+            .map(({ name, value }) => [name, value]));
+        if (Object.keys(serverEnvVars).length > 0) {
+            log_1.default.log(`Environment variables with visibility "Plain text" and "Sensitive" loaded from the "${environment.toLowerCase()}" environment on EAS: ${Object.keys(serverEnvVars).join(', ')}.`);
+        }
+        else {
+            log_1.default.log(`No environment variables with visibility "Plain text" and "Sensitive" found for the "${environment.toLowerCase()}" environment on EAS.`);
+        }
+        if (buildProfile.env && Object.keys(buildProfile.env).length > 0) {
+            log_1.default.log(`Environment variables loaded from the "${buildProfileName}" build profile "env" configuration: ${buildProfile.env && Object.keys(buildProfile.env).join(', ')}.`);
+        }
+        if (buildProfile.env &&
+            Object.keys(buildProfile.env).length > 0 &&
+            Object.keys(serverEnvVars).length > 0) {
+            const overlappingKeys = Object.keys(serverEnvVars).filter(key => buildProfile.env && Object.keys(buildProfile.env).includes(key));
+            if (overlappingKeys.length > 0) {
+                log_1.default.warn(`The following environment variables are defined in both the "${buildProfileName}" build profile "env" configuration and the "${environment.toLowerCase()}" environment on EAS: ${overlappingKeys.join(', ')}. The values from the build profile configuration will be used.`);
+            }
+        }
+        log_1.default.newLine();
+        return { ...serverEnvVars, ...buildProfile.env };
+    }
+    catch (e) {
+        log_1.default.error(`Failed to pull env variables for environment ${environment} from EAS servers`);
+        log_1.default.error(e);
+        log_1.default.error('This can possibly be a bug in EAS/EAS CLI. Report it here: https://github.com/expo/eas-cli/issues');
+        return { ...buildProfile.env };
+    }
+}
+function resolveSuggestedEnvironmentForBuildProfileConfiguration(buildProfile) {
+    const environment = buildProfile.distribution === 'store'
+        ? environment_1.DefaultEnvironment.Production
+        : buildProfile.developmentClient
+            ? environment_1.DefaultEnvironment.Development
+            : environment_1.DefaultEnvironment.Preview;
+    log_1.default.log(`Resolved "${environment}" environment for the build. ${(0, log_1.learnMore)('https://docs.expo.dev/eas/environment-variables/#setting-the-environment-for-your-builds')}`);
+    return environment;
+}

package/build/build/graphql.d.ts

@@ -0,0 +1,13 @@
+import { ArchiveSource, BuildMode, BuildTrigger, Metadata, Workflow } from '@expo/eas-build-job';
+import { LoggerLevel } from '@expo/logger';
+import { BuildIosEnterpriseProvisioning, BuildMetadataInput, BuildWorkflow, FingerprintSourceInput, BuildMode as GraphQLBuildMode, BuildTrigger as GraphQLBuildTrigger, ProjectArchiveSourceInput, WorkerLoggerLevel } from '../graphql/generated';
+export declare function transformProjectArchive(archiveSource: ArchiveSource): ProjectArchiveSourceInput;
+export declare function transformMetadata({ metadata, fingerprintSource, }: {
+    metadata: Metadata;
+    fingerprintSource: FingerprintSourceInput | undefined;
+}): BuildMetadataInput;
+export declare function transformWorkflow(workflow: Workflow): BuildWorkflow;
+export declare function transformIosEnterpriseProvisioning(enterpriseProvisioning: Metadata['iosEnterpriseProvisioning']): BuildIosEnterpriseProvisioning;
+export declare function transformBuildMode(buildMode: BuildMode): GraphQLBuildMode;
+export declare function transformBuildTrigger(buildTrigger: BuildTrigger): GraphQLBuildTrigger;
+export declare const loggerLevelToGraphQLWorkerLoggerLevel: Record<LoggerLevel, WorkerLoggerLevel>;

package/build/build/graphql.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loggerLevelToGraphQLWorkerLoggerLevel = void 0;
+exports.transformProjectArchive = transformProjectArchive;
+exports.transformMetadata = transformMetadata;
+exports.transformWorkflow = transformWorkflow;
+exports.transformIosEnterpriseProvisioning = transformIosEnterpriseProvisioning;
+exports.transformBuildMode = transformBuildMode;
+exports.transformBuildTrigger = transformBuildTrigger;
+const tslib_1 = require("tslib");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const logger_1 = require("@expo/logger");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const generated_1 = require("../graphql/generated");
+function transformProjectArchive(archiveSource) {
+    if (archiveSource.type === eas_build_job_1.ArchiveSourceType.GCS) {
+        return {
+            type: generated_1.ProjectArchiveSourceType.Gcs,
+            bucketKey: archiveSource.bucketKey,
+            metadataLocation: archiveSource.metadataLocation,
+        };
+    }
+    else if (archiveSource.type === eas_build_job_1.ArchiveSourceType.URL) {
+        return {
+            type: generated_1.ProjectArchiveSourceType.Url,
+            url: archiveSource.url,
+        };
+    }
+    else {
+        throw new Error(`Unsupported project archive source type: '${archiveSource.type}'`);
+    }
+}
+function transformMetadata({ metadata, fingerprintSource, }) {
+    return {
+        ...metadata,
+        fingerprintSource,
+        credentialsSource: metadata.credentialsSource && transformCredentialsSource(metadata.credentialsSource),
+        distribution: metadata.distribution && transformDistribution(metadata.distribution),
+        workflow: metadata.workflow && transformWorkflow(metadata.workflow),
+        iosEnterpriseProvisioning: metadata.iosEnterpriseProvisioning &&
+            transformIosEnterpriseProvisioning(metadata.iosEnterpriseProvisioning),
+    };
+}
+function transformCredentialsSource(credentialsSource) {
+    if (credentialsSource === 'local') {
+        return generated_1.BuildCredentialsSource.Local;
+    }
+    else {
+        return generated_1.BuildCredentialsSource.Remote;
+    }
+}
+function transformDistribution(distribution) {
+    if (distribution === 'internal') {
+        return generated_1.DistributionType.Internal;
+    }
+    else if (distribution === 'simulator') {
+        return generated_1.DistributionType.Simulator;
+    }
+    else {
+        return generated_1.DistributionType.Store;
+    }
+}
+function transformWorkflow(workflow) {
+    if (workflow === eas_build_job_1.Workflow.GENERIC) {
+        return generated_1.BuildWorkflow.Generic;
+    }
+    else {
+        return generated_1.BuildWorkflow.Managed;
+    }
+}
+function transformIosEnterpriseProvisioning(enterpriseProvisioning) {
+    if (enterpriseProvisioning === 'adhoc') {
+        return generated_1.BuildIosEnterpriseProvisioning.Adhoc;
+    }
+    else {
+        return generated_1.BuildIosEnterpriseProvisioning.Universal;
+    }
+}
+const buildModeToGraphQLBuildMode = {
+    [eas_build_job_1.BuildMode.BUILD]: generated_1.BuildMode.Build,
+    [eas_build_job_1.BuildMode.CUSTOM]: generated_1.BuildMode.Custom,
+    [eas_build_job_1.BuildMode.RESIGN]: generated_1.BuildMode.Resign,
+    [eas_build_job_1.BuildMode.REPACK]: generated_1.BuildMode.Repack,
+};
+function transformBuildMode(buildMode) {
+    const graphQLBuildMode = buildModeToGraphQLBuildMode[buildMode];
+    (0, assert_1.default)(graphQLBuildMode, `Unsupported build mode: ${buildMode}`);
+    return graphQLBuildMode;
+}
+function transformBuildTrigger(buildTrigger) {
+    if (buildTrigger === eas_build_job_1.BuildTrigger.EAS_CLI) {
+        return generated_1.BuildTrigger.EasCli;
+    }
+    else if (buildTrigger === eas_build_job_1.BuildTrigger.GIT_BASED_INTEGRATION) {
+        return generated_1.BuildTrigger.GitBasedIntegration;
+    }
+    throw new Error('Unknown build trigger');
+}
+exports.loggerLevelToGraphQLWorkerLoggerLevel = {
+    [logger_1.LoggerLevel.TRACE]: generated_1.WorkerLoggerLevel.Trace,
+    [logger_1.LoggerLevel.DEBUG]: generated_1.WorkerLoggerLevel.Debug,
+    [logger_1.LoggerLevel.INFO]: generated_1.WorkerLoggerLevel.Info,
+    [logger_1.LoggerLevel.WARN]: generated_1.WorkerLoggerLevel.Warn,
+    [logger_1.LoggerLevel.ERROR]: generated_1.WorkerLoggerLevel.Error,
+    [logger_1.LoggerLevel.FATAL]: generated_1.WorkerLoggerLevel.Fatal,
+};

package/build/build/ios/build.d.ts

@@ -0,0 +1,5 @@
+import { Platform } from '@expo/eas-build-job';
+import { BuildRequestSender } from '../build';
+import { BuildContext, CommonContext, IosBuildContext } from '../context';
+export declare function createIosContextAsync(ctx: CommonContext<Platform.IOS>): Promise<IosBuildContext>;
+export declare function prepareIosBuildAsync(ctx: BuildContext<Platform.IOS>): Promise<BuildRequestSender>;

package/build/build/ios/build.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIosContextAsync = createIosContextAsync;
+exports.prepareIosBuildAsync = prepareIosBuildAsync;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const eas_json_1 = require("@expo/eas-json");
+const credentials_1 = require("./credentials");
+const graphql_1 = require("./graphql");
+const prepareJob_1 = require("./prepareJob");
+const syncProjectConfiguration_1 = require("./syncProjectConfiguration");
+const version_1 = require("./version");
+const BuildMutation_1 = require("../../graphql/mutations/BuildMutation");
+const bundleIdentifier_1 = require("../../project/ios/bundleIdentifier");
+const exemptEncryption_1 = require("../../project/ios/exemptEncryption");
+const scheme_1 = require("../../project/ios/scheme");
+const target_1 = require("../../project/ios/target");
+const build_1 = require("../build");
+const validate_1 = require("../validate");
+async function createIosContextAsync(ctx) {
+    const { buildProfile, env } = ctx;
+    if (ctx.workflow === eas_build_job_1.Workflow.MANAGED) {
+        await (0, bundleIdentifier_1.ensureBundleIdentifierIsDefinedForManagedProjectAsync)(ctx);
+        await (0, exemptEncryption_1.ensureNonExemptEncryptionIsDefinedForManagedProjectAsync)(ctx);
+    }
+    (0, validate_1.checkNodeEnvVariable)(ctx);
+    await (0, validate_1.checkGoogleServicesFileAsync)(ctx);
+    await (0, validate_1.validatePNGsForManagedProjectAsync)(ctx);
+    const xcodeBuildContext = await (0, scheme_1.resolveXcodeBuildContextAsync)({
+        projectDir: ctx.projectDir,
+        nonInteractive: ctx.nonInteractive,
+        exp: ctx.exp,
+        vcsClient: ctx.vcsClient,
+    }, buildProfile);
+    const targets = await (0, target_1.resolveTargetsAsync)({
+        projectDir: ctx.projectDir,
+        exp: ctx.exp,
+        xcodeBuildContext,
+        env,
+        vcsClient: ctx.vcsClient,
+    });
+    const applicationTarget = (0, target_1.findApplicationTarget)(targets);
+    const buildNumberOverride = ctx.easJsonCliConfig?.appVersionSource === eas_json_1.AppVersionSource.REMOTE
+        ? await (0, version_1.resolveRemoteBuildNumberAsync)(ctx.graphqlClient, {
+            projectDir: ctx.projectDir,
+            projectId: ctx.projectId,
+            exp: ctx.exp,
+            applicationTarget,
+            buildProfile,
+            vcsClient: ctx.vcsClient,
+        })
+        : undefined;
+    return {
+        bundleIdentifier: applicationTarget.bundleIdentifier,
+        applicationTarget,
+        targets,
+        xcodeBuildContext,
+        buildNumberOverride,
+    };
+}
+async function prepareIosBuildAsync(ctx) {
+    return await (0, build_1.prepareBuildRequestForPlatformAsync)({
+        ctx,
+        ensureCredentialsAsync: async (ctx) => {
+            return await (0, credentials_1.ensureIosCredentialsAsync)(ctx, ctx.ios.targets);
+        },
+        syncProjectConfigurationAsync: async () => {
+            await (0, syncProjectConfiguration_1.syncProjectConfigurationAsync)({
+                projectDir: ctx.projectDir,
+                exp: ctx.exp,
+                targets: ctx.ios.targets,
+                localAutoIncrement: ctx.easJsonCliConfig?.appVersionSource === eas_json_1.AppVersionSource.REMOTE
+                    ? false
+                    : ctx.buildProfile.autoIncrement,
+                vcsClient: ctx.vcsClient,
+                env: ctx.env,
+            });
+        },
+        prepareJobAsync: async (ctx, jobData) => {
+            return await (0, prepareJob_1.prepareJobAsync)(ctx, {
+                ...jobData,
+                buildScheme: ctx.ios.xcodeBuildContext.buildScheme,
+            });
+        },
+        sendBuildRequestAsync: async (appId, job, graphqlMetadata, buildParams) => {
+            const graphqlJob = (0, graphql_1.transformJob)(job);
+            return await BuildMutation_1.BuildMutation.createIosBuildAsync(ctx.graphqlClient, {
+                appId,
+                job: graphqlJob,
+                metadata: graphqlMetadata,
+                buildParams,
+            });
+        },
+    });
+}

package/build/build/ios/credentials.d.ts

@@ -0,0 +1,8 @@
+import { Platform } from '@expo/eas-build-job';
+import { BuildProfile } from '@expo/eas-json';
+import { CredentialsContext } from '../../credentials/context';
+import { IosCredentials, Target } from '../../credentials/ios/types';
+import { CredentialsResult } from '../build';
+import { BuildContext } from '../context';
+export declare function ensureIosCredentialsAsync(buildCtx: BuildContext<Platform.IOS>, targets: Target[]): Promise<CredentialsResult<IosCredentials> | undefined>;
+export declare function ensureIosCredentialsForBuildResignAsync(credentialsCtx: CredentialsContext, targets: Target[], buildProfile: BuildProfile<Platform.IOS>): Promise<CredentialsResult<IosCredentials>>;