eas-cli 16.13.3 → 16.14.0

package/build/commands/env/create.d.ts

@@ -15,7 +15,6 @@ export default class EnvCreate extends EasCommand {
         visibility: import("@oclif/core/lib/interfaces").OptionFlag<"plaintext" | "sensitive" | "secret" | undefined>;
         name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
         value: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
-        link: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         type: import("@oclif/core/lib/interfaces").OptionFlag<"string" | "file" | undefined>;
     };

package/build/commands/env/create.js

@@ -31,10 +31,6 @@ class EnvCreate extends EasCommand_1.default {
         value: core_1.Flags.string({
             description: 'Text value or the variable',
         }),
-        link: core_1.Flags.boolean({
-            description: 'Link account-wide variable to the current project',
-            hidden: true, // every account-wide variable is global for now so it's not user facing
-        }),
         force: core_1.Flags.boolean({
             description: 'Overwrite existing variable',
             default: false,
@@ -56,7 +52,7 @@ class EnvCreate extends EasCommand_1.default {
     async runAsync() {
         const { args, flags } = await this.parse(EnvCreate);
         const validatedFlags = this.sanitizeFlags(flags);
-        const { name, value, scope, 'non-interactive': nonInteractive, environment: environments, visibility, link, force, type, fileName, } = await this.promptForMissingFlagsAsync(validatedFlags, args);
+        const { name, value, scope, 'non-interactive': nonInteractive, environment: environments, visibility, force, type, fileName, } = await this.promptForMissingFlagsAsync(validatedFlags, args);
         const { projectId, loggedIn: { graphqlClient }, } = await this.getContextAsync(EnvCreate, {
             nonInteractive,
         });
@@ -81,18 +77,6 @@ class EnvCreate extends EasCommand_1.default {
                     });
                     overwrite = true;
                 }
-                if (existingVariable.scope === generated_1.EnvironmentVariableScope.Shared) {
-                    await this.promptForOverwriteAsync({
-                        nonInteractive,
-                        force,
-                        message: `Account-wide variable with ${name} name already exists on this account.`,
-                        suggestion: 'Do you want to unlink it first?',
-                    });
-                    log_1.default.withTick(`Unlinking account-wide variable ${chalk_1.default.bold(name)} on project ${chalk_1.default.bold(projectDisplayName)}.`);
-                    await (0, variableUtils_1.performForEnvironmentsAsync)(environments, async (environment) => {
-                        await EnvironmentVariableMutation_1.EnvironmentVariableMutation.unlinkSharedEnvironmentVariableAsync(graphqlClient, existingVariable.id, projectId, environment);
-                    });
-                }
             }
             const variable = overwrite && existingVariable
                 ? await EnvironmentVariableMutation_1.EnvironmentVariableMutation.updateAsync(graphqlClient, {
@@ -153,13 +137,6 @@ class EnvCreate extends EasCommand_1.default {
                 throw new Error(`Could not create variable with name ${name} on account ${ownerAccount.name}`);
             }
             log_1.default.withTick(`Created a new variable ${chalk_1.default.bold(name)} on account ${chalk_1.default.bold(ownerAccount.name)}.`);
-            if (link) {
-                log_1.default.withTick(`Linking account-wide variable ${chalk_1.default.bold(name)} to project ${chalk_1.default.bold(projectDisplayName)}.`);
-                await (0, variableUtils_1.performForEnvironmentsAsync)(environments, async (environment) => {
-                    await EnvironmentVariableMutation_1.EnvironmentVariableMutation.linkSharedEnvironmentVariableAsync(graphqlClient, variable.id, projectId, environment);
-                });
-                log_1.default.withTick(`Linked account-wide variable ${chalk_1.default.bold(name)} to project ${chalk_1.default.bold(projectDisplayName)}.`);
-            }
         }
     }
     async promptForOverwriteAsync({ nonInteractive, force, message, suggestion, }) {
@@ -231,7 +208,6 @@ class EnvCreate extends EasCommand_1.default {
             value,
             environment: newEnvironments,
             visibility: newVisibility,
-            link: rest.link ?? false,
             force: rest.force ?? false,
             'non-interactive': nonInteractive,
             type: newType,
@@ -240,9 +216,6 @@ class EnvCreate extends EasCommand_1.default {
         };
     }
     sanitizeFlags(flags) {
-        if (flags.scope !== 'account' && flags.link) {
-            throw new Error(`Unexpected argument: --link can only be used when creating account-wide variables`);
-        }
         return {
             ...flags,
             scope: flags.scope === 'account'

package/build/commands/update/delete.js

@@ -2,31 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
 const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
 const flags_1 = require("../../commandUtils/flags");
-const client_1 = require("../../graphql/client");
-const BackgroundJobReceipt_1 = require("../../graphql/types/BackgroundJobReceipt");
 const log_1 = tslib_1.__importDefault(require("../../log"));
 const prompts_1 = require("../../prompts");
+const delete_1 = require("../../update/delete");
 const json_1 = require("../../utils/json");
 const pollForBackgroundJobReceiptAsync_1 = require("../../utils/pollForBackgroundJobReceiptAsync");
-async function scheduleUpdateGroupDeletionAsync(graphqlClient, { group, }) {
-    const result = await (0, client_1.withErrorHandlingAsync)(graphqlClient
-        .mutation((0, graphql_tag_1.default) `
-          mutation ScheduleUpdateGroupDeletion($group: ID!) {
-            update {
-              scheduleUpdateGroupDeletion(group: $group) {
-                id
-                ...BackgroundJobReceiptData
-              }
-            }
-          }
-          ${BackgroundJobReceipt_1.BackgroundJobReceiptNode}
-        `, { group })
-        .toPromise());
-    return result.update.scheduleUpdateGroupDeletion;
-}
 class UpdateDelete extends EasCommand_1.default {
     static description = 'delete all the updates in an update group';
     static args = [
@@ -61,7 +43,7 @@ class UpdateDelete extends EasCommand_1.default {
                 return;
             }
         }
-        const receipt = await scheduleUpdateGroupDeletionAsync(graphqlClient, { group });
+        const receipt = await (0, delete_1.scheduleUpdateGroupDeletionAsync)(graphqlClient, { group });
         const successfulReceipt = await (0, pollForBackgroundJobReceiptAsync_1.pollForBackgroundJobReceiptAsync)(graphqlClient, receipt);
         log_1.default.debug('Deletion result', { successfulReceipt });
         if (jsonFlag) {

package/build/commands/update/republish.js

@@ -2,19 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const core_1 = require("@oclif/core");
-const queries_1 = require("../../branch/queries");
-const queries_2 = require("../../channel/queries");
 const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
 const flags_1 = require("../../commandUtils/flags");
-const pagination_1 = require("../../commandUtils/pagination");
 const BranchQuery_1 = require("../../graphql/queries/BranchQuery");
-const UpdateQuery_1 = require("../../graphql/queries/UpdateQuery");
 const log_1 = tslib_1.__importDefault(require("../../log"));
-const prompts_1 = require("../../prompts");
 const getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync_1 = require("../../update/getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync");
-const queries_3 = require("../../update/queries");
 const republish_1 = require("../../update/republish");
-const utils_1 = require("../../update/utils");
 const code_signing_1 = require("../../utils/code-signing");
 const json_1 = require("../../utils/json");
 const defaultRepublishPlatforms = ['android', 'ios'];
@@ -79,7 +72,7 @@ class UpdateRepublish extends EasCommand_1.default {
             (0, json_1.enableJsonOutput)();
         }
         const codeSigningInfo = await (0, code_signing_1.getCodeSigningInfoAsync)(exp, flags.privateKeyPath);
-        const existingUpdates = await getOrAskUpdatesAsync(graphqlClient, projectId, flags);
+        const existingUpdates = await (0, republish_1.getUpdateGroupOrAskForUpdateGroupAsync)(graphqlClient, projectId, flags);
         const updatesToPublish = existingUpdates.filter(update => flags.platform.includes(update.platform));
         if (existingUpdates.length === 0) {
             throw new Error(`There are no published updates found`);
@@ -99,7 +92,7 @@ class UpdateRepublish extends EasCommand_1.default {
         }
         const arbitraryUpdate = updatesToPublish[0];
         const targetBranch = await getOrAskTargetBranchAsync(graphqlClient, projectId, flags, arbitraryUpdate);
-        const updateMessage = await getOrAskUpdateMessageAsync(updatesToPublish, flags);
+        const updateMessage = await (0, republish_1.getOrAskUpdateMessageAsync)(updatesToPublish, flags);
         await (0, republish_1.republishAsync)({
             graphqlClient,
             app: { exp, projectId },
@@ -155,133 +148,3 @@ async function getOrAskTargetBranchAsync(graphqlClient, projectId, flags, arbitr
     // if neither provided, assume republish on same branch
     return { branchId: arbitraryUpdate.branchId, branchName: arbitraryUpdate.branchName };
 }
-/** Retrieve the update group from either the update group id, or select from branch name. */
-async function getOrAskUpdatesAsync(graphqlClient, projectId, flags) {
-    if (flags.groupId) {
-        const updateGroup = await UpdateQuery_1.UpdateQuery.viewUpdateGroupAsync(graphqlClient, {
-            groupId: flags.groupId,
-        });
-        return updateGroup.map(update => ({
-            ...update,
-            groupId: update.group,
-            branchId: update.branch.id,
-            branchName: update.branch.name,
-        }));
-    }
-    if (flags.nonInteractive) {
-        throw new Error('Must supply --group when in non-interactive mode');
-    }
-    if (flags.branchName) {
-        return await askUpdatesFromBranchNameAsync(graphqlClient, {
-            ...flags,
-            branchName: flags.branchName,
-            projectId,
-        });
-    }
-    if (flags.channelName) {
-        return await askUpdatesFromChannelNameAsync(graphqlClient, {
-            ...flags,
-            channelName: flags.channelName,
-            projectId,
-        });
-    }
-    const { choice } = await (0, prompts_1.promptAsync)({
-        type: 'select',
-        message: 'Find update by branch or channel?',
-        name: 'choice',
-        choices: [
-            { title: 'Branch', value: 'branch' },
-            { title: 'Channel', value: 'channel' },
-        ],
-    });
-    if (choice === 'channel') {
-        const { name } = await (0, queries_2.selectChannelOnAppAsync)(graphqlClient, {
-            projectId,
-            selectionPromptTitle: 'Select a channel to view',
-            paginatedQueryOptions: {
-                json: flags.json,
-                nonInteractive: flags.nonInteractive,
-                offset: 0,
-            },
-        });
-        return await askUpdatesFromChannelNameAsync(graphqlClient, {
-            ...flags,
-            channelName: name,
-            projectId,
-        });
-    }
-    else if (choice === 'branch') {
-        const { name } = await (0, queries_1.selectBranchOnAppAsync)(graphqlClient, {
-            projectId,
-            promptTitle: 'Select branch from which to choose update',
-            displayTextForListItem: updateBranch => ({
-                title: updateBranch.name,
-            }),
-            // discard limit and offset because this query is not their intended target
-            paginatedQueryOptions: {
-                json: flags.json,
-                nonInteractive: flags.nonInteractive,
-                offset: 0,
-            },
-        });
-        return await askUpdatesFromBranchNameAsync(graphqlClient, {
-            ...flags,
-            branchName: name,
-            projectId,
-        });
-    }
-    else {
-        throw new Error('Must choose update via channel or branch');
-    }
-}
-/** Ask the user which update needs to be republished by branch name, this requires interactive mode */
-async function askUpdatesFromBranchNameAsync(graphqlClient, { projectId, branchName, json, nonInteractive, }) {
-    const updateGroup = await (0, queries_3.selectUpdateGroupOnBranchAsync)(graphqlClient, {
-        projectId,
-        branchName,
-        paginatedQueryOptions: (0, pagination_1.getPaginatedQueryOptions)({ json, 'non-interactive': nonInteractive }),
-    });
-    return updateGroup.map(update => ({
-        ...update,
-        groupId: update.group,
-        branchId: update.branch.id,
-        branchName: update.branch.name,
-    }));
-}
-/** Ask the user which update needs to be republished by channel name, this requires interactive mode */
-async function askUpdatesFromChannelNameAsync(graphqlClient, { projectId, channelName, json, nonInteractive, }) {
-    const { branchName } = await (0, getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync_1.getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync)(graphqlClient, projectId, channelName);
-    return await askUpdatesFromBranchNameAsync(graphqlClient, {
-        projectId,
-        branchName,
-        json,
-        nonInteractive,
-    });
-}
-/** Get or ask the user for the update (group) message for the republish */
-async function getOrAskUpdateMessageAsync(updates, flags) {
-    if (flags.updateMessage) {
-        return sanitizeUpdateMessage(flags.updateMessage);
-    }
-    if (flags.nonInteractive || flags.json) {
-        throw new Error('Must supply --message when in non-interactive mode');
-    }
-    // This command only uses a single update group to republish, meaning these values are always identical
-    const oldGroupId = updates[0].groupId;
-    const oldUpdateMessage = updates[0].message;
-    const { updateMessage } = await (0, prompts_1.promptAsync)({
-        type: 'text',
-        name: 'updateMessage',
-        message: 'Provide an update message.',
-        initial: `Republish "${oldUpdateMessage}" - group: ${oldGroupId}`,
-        validate: (value) => (value ? true : 'Update message may not be empty.'),
-    });
-    return sanitizeUpdateMessage(updateMessage);
-}
-function sanitizeUpdateMessage(updateMessage) {
-    if (updateMessage !== (0, utils_1.truncateString)(updateMessage, 1024)) {
-        log_1.default.warn('Update message exceeds the allowed 1024 character limit, truncated update message.');
-        return (0, utils_1.truncateString)(updateMessage, 1024);
-    }
-    return updateMessage;
-}

package/build/commands/update/revert-update-rollout.d.ts

@@ -0,0 +1,24 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export declare function nonNullish<TValue>(value: TValue | null | undefined): value is NonNullable<TValue>;
+export default class UpdateRevertUpdateRollout extends EasCommand {
+    static description: string;
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        channel: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        branch: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        group: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        message: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        'private-key-path': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+    };
+    static contextDefinition: {
+        vcsClient: import("../../commandUtils/context/VcsClientContextField").default;
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        privateProjectConfig: import("../../commandUtils/context/PrivateProjectConfigContextField").PrivateProjectConfigContextField;
+    };
+    runAsync(): Promise<void>;
+    private deleteRolloutUpdateGroupAndRepublishControlUpdatesAsync;
+    private deleteRolloutUpdateGroupAndPublishRollBackToEmbeddedAsync;
+    private deleteRolloutUpdateGroupAsync;
+    private sanitizeFlags;
+}

package/build/commands/update/revert-update-rollout.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nonNullish = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
+const log_1 = tslib_1.__importStar(require("../../log"));
+const projectUtils_1 = require("../../project/projectUtils");
+const publish_1 = require("../../project/publish");
+const prompts_1 = require("../../prompts");
+const delete_1 = require("../../update/delete");
+const republish_1 = require("../../update/republish");
+const roll_back_to_embedded_1 = require("../../update/roll-back-to-embedded");
+const code_signing_1 = require("../../utils/code-signing");
+const json_1 = require("../../utils/json");
+const pollForBackgroundJobReceiptAsync_1 = require("../../utils/pollForBackgroundJobReceiptAsync");
+function nonNullish(value) {
+    return value !== null && value !== undefined;
+}
+exports.nonNullish = nonNullish;
+class UpdateRevertUpdateRollout extends EasCommand_1.default {
+    static description = 'revert a rollout update for a project';
+    static flags = {
+        channel: core_1.Flags.string({
+            description: 'Channel name to select an update group to revert the rollout update from',
+            exclusive: ['branch', 'group'],
+        }),
+        branch: core_1.Flags.string({
+            description: 'Branch name to select an update group to revert the rollout update from',
+            exclusive: ['channel', 'group'],
+        }),
+        group: core_1.Flags.string({
+            description: 'Rollout update group ID to revert',
+            exclusive: ['branch', 'channel'],
+        }),
+        message: core_1.Flags.string({
+            char: 'm',
+            description: 'Short message describing the revert',
+            required: false,
+        }),
+        'private-key-path': core_1.Flags.string({
+            description: `File containing the PEM-encoded private key corresponding to the certificate in expo-updates' configuration. Defaults to a file named "private-key.pem" in the certificate's directory. Only relevant if you are using code signing: https://docs.expo.dev/eas-update/code-signing/`,
+            required: false,
+        }),
+        ...flags_1.EasNonInteractiveAndJsonFlags,
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectConfig,
+        ...this.ContextOptions.LoggedIn,
+        ...this.ContextOptions.Vcs,
+    };
+    async runAsync() {
+        const { flags: rawFlags } = await this.parse(UpdateRevertUpdateRollout);
+        const flags = this.sanitizeFlags(rawFlags);
+        const { privateProjectConfig: { exp, projectId, projectDir }, loggedIn: { graphqlClient }, vcsClient, } = await this.getContextAsync(UpdateRevertUpdateRollout, {
+            nonInteractive: flags.nonInteractive,
+            withServerSideEnvironment: null,
+        });
+        if (flags.json) {
+            (0, json_1.enableJsonOutput)();
+        }
+        const codeSigningInfo = await (0, code_signing_1.getCodeSigningInfoAsync)(exp, flags.privateKeyPath);
+        let updateGroupToRepublish;
+        if (flags.groupId) {
+            const updateGroup = await (0, republish_1.getUpdateGroupAsync)(graphqlClient, flags.groupId);
+            if (!updateGroupIsRolloutUpdateGroup(updateGroup)) {
+                throw new Error(`The update group with ID "${flags.groupId}" is not a rollout update group.`);
+            }
+            updateGroupToRepublish = updateGroup;
+        }
+        else {
+            const latestUpdateGroupForEachPublishPlatform = await (0, republish_1.askUpdateGroupForEachPublishPlatformFilteringByRuntimeVersionAsync)(graphqlClient, projectId, flags);
+            const uniqueUpdateGroups = getUniqueUpdateGroups(Object.values(latestUpdateGroupForEachPublishPlatform).filter(nonNullish));
+            const rolloutUpdateGroups = uniqueUpdateGroups.filter(updateGroupIsRolloutUpdateGroup);
+            if (rolloutUpdateGroups.length === 0) {
+                throw new Error(`No rollout update groups found.`);
+            }
+            if (rolloutUpdateGroups.length === 1) {
+                updateGroupToRepublish = rolloutUpdateGroups[0];
+            }
+            else {
+                const { choice: chosenId } = await (0, prompts_1.promptAsync)({
+                    type: 'select',
+                    message: 'Which rollout update group would you like to revert?',
+                    name: 'choice',
+                    choices: rolloutUpdateGroups.map(ug => ({
+                        title: `Rollout update group ID: ${ug[0].groupId}, Platform: ${ug[0].platform}, Rollout Percentage: ${ug[0].rolloutPercentage}`,
+                        value: ug[0].groupId,
+                    })),
+                });
+                if (!chosenId) {
+                    throw new Error('No rollout update group selected.');
+                }
+                const chosenUpdateGroup = rolloutUpdateGroups.find(ug => ug[0].groupId === chosenId);
+                if (!chosenUpdateGroup) {
+                    throw new Error('No rollout update group selected.');
+                }
+                updateGroupToRepublish = chosenUpdateGroup;
+            }
+        }
+        const rolloutUpdateGroupWithControlUpdates = updateGroupIsUpdateGroupWithControlUpdate(updateGroupToRepublish)
+            ? updateGroupToRepublish
+            : null;
+        if (rolloutUpdateGroupWithControlUpdates) {
+            await this.deleteRolloutUpdateGroupAndRepublishControlUpdatesAsync({
+                graphqlClient,
+                exp,
+                projectId,
+                rolloutUpdateGroupWithControlUpdates,
+                codeSigningInfo,
+                flags,
+            });
+        }
+        else {
+            await this.deleteRolloutUpdateGroupAndPublishRollBackToEmbeddedAsync({
+                graphqlClient,
+                vcsClient,
+                exp,
+                projectDir,
+                projectId,
+                rolloutUpdateGroup: updateGroupToRepublish,
+                codeSigningInfo,
+                flags,
+            });
+        }
+    }
+    async deleteRolloutUpdateGroupAndRepublishControlUpdatesAsync({ graphqlClient, exp, projectId, rolloutUpdateGroupWithControlUpdates, codeSigningInfo, flags, }) {
+        const controlUpdateGroupIdsToRepublish = Array.from(new Set(rolloutUpdateGroupWithControlUpdates.map(update => update.rolloutControlUpdate.group)));
+        const updateGroupsToRepublish = await Promise.all(controlUpdateGroupIdsToRepublish.map(controlUpdateGroupIdToRepublish => (0, republish_1.getUpdateGroupAsync)(graphqlClient, controlUpdateGroupIdToRepublish)));
+        const updateGroupOrGroupsClause = controlUpdateGroupIdsToRepublish.length > 1
+            ? `control update groups (IDs: ${controlUpdateGroupIdsToRepublish
+                .map(id => `"${id}"`)
+                .join(', ')})`
+            : `control update group (ID: "${controlUpdateGroupIdsToRepublish[0]}")`;
+        if (!flags.nonInteractive) {
+            const confirmMessage = `Are you sure you want to revert the rollout update group with ID "${rolloutUpdateGroupWithControlUpdates[0].groupId}"? This will delete the rollout update group and republish the ${updateGroupOrGroupsClause}.`;
+            const didConfirm = await (0, prompts_1.confirmAsync)({ message: confirmMessage });
+            if (!didConfirm) {
+                throw new Error('Aborting...');
+            }
+        }
+        const updateMessages = [];
+        for (const updateGroup of updateGroupsToRepublish) {
+            updateMessages.push(await (0, republish_1.getOrAskUpdateMessageAsync)(updateGroup, flags));
+        }
+        // assert all updateGroupsToRepublish have the same branch name and id
+        const branchNames = updateGroupsToRepublish.flatMap(updateGroup => updateGroup[0].branchName);
+        const branchIds = updateGroupsToRepublish.map(updateGroup => updateGroup[0].branchId);
+        (0, assert_1.default)(branchNames.every(name => name === branchNames[0]), 'All update groups being republished must belong to the same branch.');
+        (0, assert_1.default)(branchIds.every(id => id === branchIds[0]), 'All update groups being republished must belong to the same branch.');
+        const targetBranch = {
+            branchName: branchNames[0],
+            branchId: branchIds[0],
+        };
+        await this.deleteRolloutUpdateGroupAsync({
+            graphqlClient,
+            rolloutUpdateGroup: rolloutUpdateGroupWithControlUpdates,
+        });
+        for (let i = 0; i < updateGroupsToRepublish.length; i++) {
+            const updateGroupToRepublish = updateGroupsToRepublish[i];
+            const updateMessage = updateMessages[i];
+            await (0, republish_1.republishAsync)({
+                graphqlClient,
+                app: { exp, projectId },
+                updatesToPublish: updateGroupToRepublish,
+                targetBranch,
+                updateMessage,
+                codeSigningInfo,
+                json: flags.json,
+            });
+        }
+    }
+    async deleteRolloutUpdateGroupAndPublishRollBackToEmbeddedAsync({ graphqlClient, vcsClient, exp, projectDir, projectId, rolloutUpdateGroup, codeSigningInfo, flags, }) {
+        const rolloutUpdateGroupId = rolloutUpdateGroup[0].groupId;
+        if (!flags.nonInteractive) {
+            const confirmMessage = `Are you sure you want to revert the rollout update group with ID "${rolloutUpdateGroupId}"? This will delete the rollout update group and publish a new roll-back-to-embedded update (no control update to roll back to), whose behavior may not be a true revert depending on the previous state of the branch. ${(0, log_1.learnMore)('https://expo.fyi/eas-update-update-rollouts', { learnMoreMessage: 'More info' })})`;
+            const didConfirm = await (0, prompts_1.confirmAsync)({ message: confirmMessage });
+            if (!didConfirm) {
+                throw new Error('Aborting...');
+            }
+        }
+        // check that the expo-updates package version supports roll back to embedded
+        await (0, projectUtils_1.enforceRollBackToEmbeddedUpdateSupportAsync)(projectDir);
+        const updateMessage = await (0, publish_1.getUpdateMessageForCommandAsync)(vcsClient, {
+            updateMessageArg: flags.updateMessage,
+            autoFlag: false,
+            nonInteractive: flags.nonInteractive,
+            jsonFlag: flags.json,
+        });
+        await this.deleteRolloutUpdateGroupAsync({
+            graphqlClient,
+            rolloutUpdateGroup,
+        });
+        const platforms = rolloutUpdateGroup.map(update => update.platform);
+        const runtimeVersion = rolloutUpdateGroup[0].runtimeVersion;
+        const targetBranch = {
+            name: rolloutUpdateGroup[0].branchName,
+            id: rolloutUpdateGroup[0].branchId,
+        };
+        await (0, roll_back_to_embedded_1.publishRollBackToEmbeddedUpdateAsync)({
+            graphqlClient,
+            projectId,
+            exp,
+            updateMessage,
+            branch: targetBranch,
+            codeSigningInfo,
+            platforms,
+            runtimeVersion,
+            json: flags.json,
+        });
+    }
+    async deleteRolloutUpdateGroupAsync({ graphqlClient, rolloutUpdateGroup, }) {
+        const rolloutUpdateGroupId = rolloutUpdateGroup[0].groupId;
+        const updateGroupDeletionReceipt = await (0, delete_1.scheduleUpdateGroupDeletionAsync)(graphqlClient, {
+            group: rolloutUpdateGroupId,
+        });
+        const successfulReceipt = await (0, pollForBackgroundJobReceiptAsync_1.pollForBackgroundJobReceiptAsync)(graphqlClient, updateGroupDeletionReceipt);
+        log_1.default.debug('Rollout update group deletion result', { successfulReceipt });
+    }
+    sanitizeFlags(rawFlags) {
+        const branchName = rawFlags.branch;
+        const channelName = rawFlags.channel;
+        const groupId = rawFlags.group;
+        const nonInteractive = rawFlags['non-interactive'];
+        const privateKeyPath = rawFlags['private-key-path'];
+        if (nonInteractive && !groupId) {
+            throw new Error('Only --group can be used in non-interactive mode');
+        }
+        return {
+            branchName,
+            channelName,
+            groupId,
+            updateMessage: rawFlags.message,
+            privateKeyPath,
+            json: rawFlags.json ?? false,
+            nonInteractive,
+        };
+    }
+}
+exports.default = UpdateRevertUpdateRollout;
+function getUniqueUpdateGroups(updateGroups) {
+    const uniqueUpdateGroups = new Map();
+    for (const updateGroup of updateGroups) {
+        const groupId = updateGroup[0].groupId;
+        if (!uniqueUpdateGroups.has(groupId)) {
+            uniqueUpdateGroups.set(groupId, updateGroup);
+        }
+    }
+    return Array.from(uniqueUpdateGroups.values());
+}
+function updateGroupIsRolloutUpdateGroup(updateGroup) {
+    return updateGroup.every(updateIsRolloutUpdate);
+}
+function updateIsRolloutUpdate(updateGroup) {
+    return updateGroup.rolloutPercentage !== undefined && updateGroup.rolloutPercentage !== null;
+}
+function updateGroupIsUpdateGroupWithControlUpdate(updateGroup) {
+    return updateGroup.every(updateIsRolloutWithControlUpdate);
+}
+function updateIsRolloutWithControlUpdate(updateGroup) {
+    return !!updateGroup.rolloutControlUpdate;
+}

package/build/commands/update/roll-back-to-embedded.d.ts

@@ -18,7 +18,5 @@ export default class UpdateRollBackToEmbedded extends EasCommand {
         getDynamicPrivateProjectConfigAsync: import("../../commandUtils/context/DynamicProjectConfigContextField").DynamicPrivateProjectConfigContextField;
     };
     runAsync(): Promise<void>;
-    private publishRollbacksAsync;
-    private static selectRuntimeAsync;
     private sanitizeFlags;
 }