eas-cli 4.1.1 → 5.0.0

package/build/rollout/actions/EndRollout.d.ts

@@ -1,6 +1,6 @@
 import { EASUpdateAction, EASUpdateContext } from '../../eas-update/utils';
 import { UpdateChannelBasicInfoFragment } from '../../graphql/generated';
-import { UpdateChannelObject } from '../../graphql/queries/ChannelQuery';
+import { UpdateBranchObject, UpdateChannelObject } from '../../graphql/queries/ChannelQuery';
 import { Rollout } from '../branch-mapping';
 export declare enum EndOutcome {
     REPUBLISH_AND_REVERT = "republish-and-revert",
@@ -21,7 +21,7 @@ export declare class EndRollout implements EASUpdateAction<UpdateChannelBasicInf
     constructor(channelInfo: UpdateChannelBasicInfoFragment, options: Partial<NonInteractiveOptions> & GeneralOptions);
     runAsync(ctx: EASUpdateContext): Promise<UpdateChannelBasicInfoFragment>;
     getChannelObjectAsync(ctx: EASUpdateContext): Promise<UpdateChannelObject>;
-    selectOutcomeAsync(rollout: Rollout): Promise<EndOutcome>;
-    performOutcomeAsync(ctx: EASUpdateContext, rollout: Rollout, outcome: EndOutcome): Promise<UpdateChannelBasicInfoFragment>;
-    confirmOutcomeAsync(ctx: EASUpdateContext, selectedOutcome: EndOutcome, rollout: Rollout): Promise<boolean>;
+    selectOutcomeAsync(rollout: Rollout<UpdateBranchObject>): Promise<EndOutcome>;
+    performOutcomeAsync(ctx: EASUpdateContext, rollout: Rollout<UpdateBranchObject>, outcome: EndOutcome): Promise<UpdateChannelBasicInfoFragment>;
+    confirmOutcomeAsync(ctx: EASUpdateContext, selectedOutcome: EndOutcome, rollout: Rollout<UpdateBranchObject>): Promise<boolean>;
 }

package/build/rollout/branch-mapping.d.ts

@@ -1,14 +1,13 @@
 import { BranchMapping, BranchMappingAlwaysTrue } from '../channel/branch-mapping';
-import { UpdateChannelBasicInfoFragment } from '../graphql/generated';
-import { UpdateBranchObject, UpdateChannelObject } from '../graphql/queries/ChannelQuery';
-export type Rollout = LegacyRollout | ConstrainedRollout;
+import { BranchBasicInfo, ChannelBasicInfo, UpdateChannelInfoWithBranches } from '../channel/utils';
+export type Rollout<Branch extends BranchBasicInfo> = LegacyRollout<Branch> | ConstrainedRollout<Branch>;
 export type RolloutInfo = LegacyRolloutInfo | ConstrainedRolloutInfo;
-type ConstrainedRollout = LegacyRollout & {
+type ConstrainedRollout<Branch extends BranchBasicInfo> = LegacyRollout<Branch> & {
     runtimeVersion: string;
 };
-type LegacyRollout = {
-    rolledOutBranch: UpdateBranchObject;
-    defaultBranch: UpdateBranchObject;
+type LegacyRollout<Branch extends BranchBasicInfo> = {
+    rolledOutBranch: Branch;
+    defaultBranch: Branch;
 } & LegacyRolloutInfo;
 type ConstrainedRolloutInfo = LegacyRolloutInfo & {
     runtimeVersion: string;
@@ -58,11 +57,11 @@ export type ConstrainedRolloutBranchMapping = {
 };
 export declare function isLegacyRolloutInfo(rollout: RolloutInfo): rollout is LegacyRolloutInfo;
 export declare function isConstrainedRolloutInfo(rollout: RolloutInfo): rollout is ConstrainedRolloutInfo;
-export declare function isConstrainedRollout(rollout: Rollout): rollout is ConstrainedRollout;
-export declare function getRolloutInfo(basicChannelInfo: UpdateChannelBasicInfoFragment): RolloutInfo;
+export declare function isConstrainedRollout<Branch extends BranchBasicInfo>(rollout: Rollout<Branch>): rollout is ConstrainedRollout<Branch>;
+export declare function getRolloutInfo(basicChannelInfo: ChannelBasicInfo): RolloutInfo;
 export declare function getRolloutInfoFromBranchMapping(branchMapping: RolloutBranchMapping): RolloutInfo;
-export declare function getRollout(channel: UpdateChannelObject): Rollout;
-export declare function composeRollout(rolloutInfo: RolloutInfo, defaultBranch: UpdateBranchObject, rolledOutBranch: UpdateBranchObject): Rollout;
+export declare function getRollout<Branch extends BranchBasicInfo>(channel: UpdateChannelInfoWithBranches<Branch>): Rollout<Branch>;
+export declare function composeRollout<Branch extends BranchBasicInfo>(rolloutInfo: RolloutInfo, defaultBranch: Branch, rolledOutBranch: Branch): Rollout<Branch>;
 export declare function getRolloutBranchMapping(branchMappingString: string): RolloutBranchMapping;
 /**
  * Detect if a branch mapping is a rollout.
@@ -116,7 +115,8 @@ export declare function getRolloutBranchMapping(branchMappingString: string): Ro
   }
  */
 export declare function isRolloutBranchMapping(branchMapping: BranchMapping): branchMapping is RolloutBranchMapping;
-export declare function isRollout(channelInfo: UpdateChannelBasicInfoFragment): boolean;
+export declare function isRollout(channelInfo: ChannelBasicInfo): boolean;
+export declare function doesTargetRollout(branchMapping: RolloutBranchMapping, runtimeVersion: string): boolean;
 export declare function createRolloutBranchMapping({ defaultBranchId, rolloutBranchId, percent, runtimeVersion, }: {
     defaultBranchId: string;
     rolloutBranchId: string;

package/build/rollout/branch-mapping.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertRolloutBranchMapping = exports.editRolloutBranchMapping = exports.createRolloutBranchMapping = exports.isRollout = exports.isRolloutBranchMapping = exports.getRolloutBranchMapping = exports.composeRollout = exports.getRollout = exports.getRolloutInfoFromBranchMapping = exports.getRolloutInfo = exports.isConstrainedRollout = exports.isConstrainedRolloutInfo = exports.isLegacyRolloutInfo = void 0;
-const tslib_1 = require("tslib");
-const assert_1 = tslib_1.__importDefault(require("assert"));
+exports.assertRolloutBranchMapping = exports.editRolloutBranchMapping = exports.createRolloutBranchMapping = exports.doesTargetRollout = exports.isRollout = exports.isRolloutBranchMapping = exports.getRolloutBranchMapping = exports.composeRollout = exports.getRollout = exports.getRolloutInfoFromBranchMapping = exports.getRolloutInfo = exports.isConstrainedRollout = exports.isConstrainedRolloutInfo = exports.isLegacyRolloutInfo = void 0;
 const branch_mapping_1 = require("../channel/branch-mapping");
 const utils_1 = require("../channel/utils");
 function isLegacyRolloutInfo(rollout) {
@@ -30,12 +28,16 @@ function getRolloutInfoFromBranchMapping(branchMapping) {
         (0, branch_mapping_1.assertStatement)(statementNode);
         const nodesFromStatement = (0, branch_mapping_1.getNodesFromStatement)(statementNode);
         const runtimeVersionNode = nodesFromStatement.find(isRuntimeVersionNode);
-        (0, assert_1.default)(runtimeVersionNode, 'Runtime version node must be defined.');
+        if (!runtimeVersionNode) {
+            throw new branch_mapping_1.BranchMappingValidationError('Runtime version node must be defined.');
+        }
         (0, branch_mapping_1.assertNodeObject)(runtimeVersionNode);
         const runtimeVersion = runtimeVersionNode.operand;
         (0, branch_mapping_1.assertString)(runtimeVersion);
         const rolloutNode = nodesFromStatement.find(isRolloutNode);
-        (0, assert_1.default)(rolloutNode, 'Rollout node must be defined.');
+        if (!rolloutNode) {
+            throw new branch_mapping_1.BranchMappingValidationError('Rollout node must be defined.');
+        }
         (0, branch_mapping_1.assertNodeObject)(rolloutNode);
         const operand = rolloutNode.operand;
         (0, branch_mapping_1.assertNumber)(operand);
@@ -149,6 +151,14 @@ function isRollout(channelInfo) {
     return isRolloutBranchMapping(branchMapping);
 }
 exports.isRollout = isRollout;
+function doesTargetRollout(branchMapping, runtimeVersion) {
+    const rolloutInfo = getRolloutInfoFromBranchMapping(branchMapping);
+    if (!isConstrainedRolloutInfo(rolloutInfo)) {
+        return true;
+    }
+    return rolloutInfo.runtimeVersion === runtimeVersion;
+}
+exports.doesTargetRollout = doesTargetRollout;
 function createRolloutBranchMapping({ defaultBranchId, rolloutBranchId, percent, runtimeVersion, }) {
     assertPercent(percent);
     return {
@@ -190,7 +200,9 @@ function editRtvConstrainedRollout(branchMapping, percent) {
     const statementNode = newBranchMapping.data[0].branchMappingLogic;
     const nodesFromStatement = (0, branch_mapping_1.getNodesFromStatement)(statementNode);
     const rolloutNode = nodesFromStatement.find(isRolloutNode);
-    (0, assert_1.default)(rolloutNode, 'Rollout node must be defined.');
+    if (!rolloutNode) {
+        throw new branch_mapping_1.BranchMappingValidationError('Rollout node must be defined.');
+    }
     rolloutNode.operand = percent / 100;
     return newBranchMapping;
 }

package/build/rollout/utils.d.ts

@@ -1,8 +1,8 @@
-import { RuntimeFragment, UpdateFragment } from '../graphql/generated';
+import { RuntimeFragment, UpdateBranchBasicInfoFragment, UpdateFragment } from '../graphql/generated';
 import { UpdateBranchObject, UpdateChannelObject } from '../graphql/queries/ChannelQuery';
 import { Rollout } from './branch-mapping';
 export declare function printRollout(channel: UpdateChannelObject): void;
-export declare function displayRolloutDetails(channelName: string, rollout: Rollout): void;
+export declare function displayRolloutDetails(channelName: string, rollout: Rollout<UpdateBranchBasicInfoFragment>): void;
 export declare function formatBranchWithUpdateGroup(maybeUpdateGroup: UpdateFragment[] | undefined | null, branch: UpdateBranchObject, percentRolledOut: number): string;
 export declare function formatRuntimeWithUpdateGroup(maybeUpdateGroup: UpdateFragment[] | undefined | null, runtime: RuntimeFragment, branchName: string): string;
 export declare function promptForRolloutPercentAsync({ promptMessage, }: {

package/build/update/republish.d.ts

@@ -1,12 +1,12 @@
 import { ExpoConfig } from '@expo/config';
 import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
-import { Update } from '../graphql/generated';
+import { UpdateFragment } from '../graphql/generated';
 import { CodeSigningInfo } from '../utils/code-signing';
 export type UpdateToRepublish = {
     groupId: string;
     branchId: string;
     branchName: string;
-} & Pick<Update, 'message' | 'runtimeVersion' | 'manifestFragment' | 'platform' | 'gitCommitHash' | 'codeSigningInfo'>;
+} & UpdateFragment;
 /**
  * @param updatesToPublish The update group to republish
  * @param targetBranch The branch to repubish the update group on

package/build/update/republish.js

@@ -27,6 +27,8 @@ async function republishAsync({ graphqlClient, app, updatesToPublish, targetBran
         update.branchName === arbitraryUpdate.branchName &&
         update.runtimeVersion === arbitraryUpdate.runtimeVersion;
     (0, assert_1.default)(updatesToPublish.every(isSameGroup), 'All updates must belong to the same update group');
+    (0, assert_1.default)(updatesToPublish.every(u => u.isRollBackToEmbedded) ||
+        updatesToPublish.every(u => !u.isRollBackToEmbedded), 'All updates must either be roll back to embedded updates or not');
     const { runtimeVersion } = arbitraryUpdate;
     // If codesigning was created for the original update, we need to add it to the republish.
     // If one wishes to not sign the republish or sign with a different key, a normal publish should
@@ -47,13 +49,20 @@ async function republishAsync({ graphqlClient, app, updatesToPublish, targetBran
     const publishIndicator = (0, ora_1.ora)('Republishing...').start();
     let updatesRepublished;
     try {
-        const updateInfoGroup = Object.fromEntries(updatesToPublish.map(update => [update.platform, JSON.parse(update.manifestFragment)]));
+        const arbitraryUpdate = updatesToPublish[0];
+        const objectToMergeIn = arbitraryUpdate.isRollBackToEmbedded
+            ? {
+                rollBackToEmbeddedInfoGroup: Object.fromEntries(updatesToPublish.map(update => [update.platform, true])),
+            }
+            : {
+                updateInfoGroup: Object.fromEntries(updatesToPublish.map(update => [update.platform, JSON.parse(update.manifestFragment)])),
+            };
         updatesRepublished = await PublishMutation_1.PublishMutation.publishUpdateGroupAsync(graphqlClient, [
             {
                 branchId: targetBranchId,
                 runtimeVersion,
                 message: updateMessage,
-                updateInfoGroup,
+                ...objectToMergeIn,
                 gitCommitHash: updatesToPublish[0].gitCommitHash,
                 awaitingCodeSigningInfo: !!codeSigningInfo,
             },
@@ -65,13 +74,21 @@ async function republishAsync({ graphqlClient, app, updatesToPublish, targetBran
                     method: 'GET',
                     headers: { accept: 'multipart/mixed' },
                 });
-                const manifestBody = (0, nullthrows_1.default)(await (0, code_signing_1.getManifestBodyAsync)(response));
-                (0, code_signing_1.checkManifestBodyAgainstUpdateInfoGroup)(manifestBody, (0, nullthrows_1.default)((0, nullthrows_1.default)(updateInfoGroup)[newUpdate.platform]));
-                const manifestSignature = (0, code_signing_1.signBody)(manifestBody, codeSigningInfo);
+                let signature;
+                if (newUpdate.isRollBackToEmbedded) {
+                    const directiveBody = (0, nullthrows_1.default)(await (0, code_signing_1.getDirectiveBodyAsync)(response));
+                    (0, code_signing_1.checkDirectiveBodyAgainstUpdateInfoGroup)(directiveBody);
+                    signature = (0, code_signing_1.signBody)(directiveBody, codeSigningInfo);
+                }
+                else {
+                    const manifestBody = (0, nullthrows_1.default)(await (0, code_signing_1.getManifestBodyAsync)(response));
+                    (0, code_signing_1.checkManifestBodyAgainstUpdateInfoGroup)(manifestBody, (0, nullthrows_1.default)((0, nullthrows_1.default)(objectToMergeIn.updateInfoGroup)[newUpdate.platform]));
+                    signature = (0, code_signing_1.signBody)(manifestBody, codeSigningInfo);
+                }
                 await PublishMutation_1.PublishMutation.setCodeSigningInfoAsync(graphqlClient, newUpdate.id, {
                     alg: codeSigningInfo.codeSigningMetadata.alg,
                     keyid: codeSigningInfo.codeSigningMetadata.keyid,
-                    sig: manifestSignature,
+                    sig: signature,
                 });
             }));
         }

package/build/utils/profiles.d.ts

@@ -6,10 +6,11 @@ export type ProfileData<T extends ProfileType> = {
     platform: Platform;
     profileName: string;
 };
-export declare function getProfilesAsync<T extends ProfileType>({ easJsonAccessor, platforms, profileName, type, }: {
+export declare function getProfilesAsync<T extends ProfileType>({ easJsonAccessor, platforms, profileName, type, projectDir, }: {
     easJsonAccessor: EasJsonAccessor;
     platforms: Platform[];
     profileName?: string;
+    projectDir: string;
     type: T;
 }): Promise<ProfileData<T>[]>;
 /**

package/build/utils/profiles.js

@@ -3,14 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.maybePrintBuildProfileDeprecationWarningsAsync = exports.clearHasPrintedDeprecationWarnings = exports.getProfilesAsync = void 0;
 const tslib_1 = require("tslib");
 const eas_json_1 = require("@expo/eas-json");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const semver_1 = tslib_1.__importDefault(require("semver"));
 const log_1 = tslib_1.__importStar(require("../log"));
-async function getProfilesAsync({ easJsonAccessor, platforms, profileName, type, }) {
+async function getProfilesAsync({ easJsonAccessor, platforms, profileName, type, projectDir, }) {
     const results = platforms.map(async function (platform) {
-        const profile = await readProfileAsync({
+        const profile = await readProfileWithOverridesAsync({
             easJsonAccessor,
             platform,
             type,
             profileName,
+            projectDir,
         });
         return {
             profile,
@@ -21,10 +25,38 @@ async function getProfilesAsync({ easJsonAccessor, platforms, profileName, type,
     return await Promise.all(results);
 }
 exports.getProfilesAsync = getProfilesAsync;
-async function readProfileAsync({ easJsonAccessor, platform, type, profileName, }) {
+async function maybeSetNodeVersionFromFileAsync(projectDir, profile) {
+    if (profile === null || profile === void 0 ? void 0 : profile.node) {
+        return;
+    }
+    const nodeVersion = await getNodeVersionFromFileAsync(projectDir);
+    if (nodeVersion) {
+        log_1.default.log(`The EAS build profile does not specify a Node.js version. Using the version specified in .nvmrc: ${nodeVersion} `);
+        profile.node = nodeVersion;
+    }
+}
+async function getNodeVersionFromFileAsync(projectDir) {
+    const nvmrcPath = path_1.default.join(projectDir, '.nvmrc');
+    if (!(await fs_extra_1.default.pathExists(nvmrcPath))) {
+        return;
+    }
+    let nodeVersion;
+    try {
+        nodeVersion = (await fs_extra_1.default.readFile(nvmrcPath, 'utf8')).toString().trim();
+    }
+    catch {
+        return undefined;
+    }
+    if (!semver_1.default.valid(semver_1.default.coerce(nodeVersion))) {
+        throw new Error(`Invalid node version in .nvmrc: ${nodeVersion}`);
+    }
+    return nodeVersion;
+}
+async function readProfileWithOverridesAsync({ easJsonAccessor, platform, type, profileName, projectDir, }) {
     if (type === 'build') {
         const buildProfile = await eas_json_1.EasJsonUtils.getBuildProfileAsync(easJsonAccessor, platform, profileName);
         await maybePrintBuildProfileDeprecationWarningsAsync(easJsonAccessor, platform, profileName);
+        await maybeSetNodeVersionFromFileAsync(projectDir, buildProfile);
         return buildProfile;
     }
     else {