@donotuse/eas-cli 18.5.0-rc.1

package/build/commands/update/list.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const queries_1 = require("../../branch/queries");
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
+const pagination_1 = require("../../commandUtils/pagination");
+const generated_1 = require("../../graphql/generated");
+const platform_1 = require("../../platform");
+const queries_2 = require("../../update/queries");
+const json_1 = require("../../utils/json");
+class UpdateList extends EasCommand_1.default {
+    static description = 'view the recent updates';
+    static flags = {
+        branch: core_1.Flags.string({
+            description: 'List updates only on this branch',
+            exclusive: ['all'],
+        }),
+        all: core_1.Flags.boolean({
+            description: 'List updates on all branches',
+            exclusive: ['branch'],
+            default: false,
+        }),
+        platform: core_1.Flags.option({
+            options: Object.values(platform_1.RequestedPlatform),
+            char: 'p',
+            description: 'Filter updates by platform',
+        })(),
+        'runtime-version': core_1.Flags.string({
+            description: 'Filter updates by runtime version',
+        }),
+        ...pagination_1.EasPaginatedQueryFlags,
+        limit: (0, pagination_1.getLimitFlagWithCustomValues)({ defaultTo: 25, limit: 50 }),
+        ...flags_1.EasNonInteractiveAndJsonFlags,
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectId,
+        ...this.ContextOptions.LoggedIn,
+    };
+    async runAsync() {
+        const { flags } = await this.parse(UpdateList);
+        const { branch: branchFlag, all, platform: requestedPlatform } = flags;
+        const { json: jsonFlag, nonInteractive } = (0, flags_1.resolveNonInteractiveAndJsonFlags)(flags);
+        const { projectId, loggedIn: { graphqlClient }, } = await this.getContextAsync(UpdateList, {
+            nonInteractive,
+        });
+        const paginatedQueryOptions = (0, pagination_1.getPaginatedQueryOptions)(flags);
+        if (jsonFlag) {
+            (0, json_1.enableJsonOutput)();
+        }
+        // Build filter object
+        const filter = {
+            platform: toAppPlatform(requestedPlatform),
+            runtimeVersions: flags['runtime-version'] ? [flags['runtime-version']] : undefined,
+        };
+        if (all) {
+            await (0, queries_2.listAndRenderUpdateGroupsOnAppAsync)(graphqlClient, {
+                projectId,
+                filter,
+                paginatedQueryOptions,
+            });
+        }
+        else {
+            if (branchFlag) {
+                await (0, queries_2.listAndRenderUpdateGroupsOnBranchAsync)(graphqlClient, {
+                    projectId,
+                    branchName: branchFlag,
+                    filter,
+                    paginatedQueryOptions,
+                });
+            }
+            else {
+                const validationMessage = 'Branch name may not be empty.';
+                if (nonInteractive) {
+                    throw new Error(validationMessage);
+                }
+                const selectedBranch = await (0, queries_1.selectBranchOnAppAsync)(graphqlClient, {
+                    projectId,
+                    promptTitle: 'Which branch would you like to view?',
+                    displayTextForListItem: updateBranch => ({
+                        title: updateBranch.name,
+                    }),
+                    paginatedQueryOptions: 
+                    // discard limit and offset because this query is not those flag's intended target
+                    {
+                        json: paginatedQueryOptions.json,
+                        nonInteractive: paginatedQueryOptions.nonInteractive,
+                        offset: 0,
+                    },
+                });
+                await (0, queries_2.listAndRenderUpdateGroupsOnBranchAsync)(graphqlClient, {
+                    projectId,
+                    branchName: selectedBranch.name,
+                    filter,
+                    paginatedQueryOptions,
+                });
+            }
+        }
+    }
+}
+exports.default = UpdateList;
+const toAppPlatform = (requestedPlatform) => {
+    if (!requestedPlatform || requestedPlatform === platform_1.RequestedPlatform.All) {
+        return undefined;
+    }
+    else if (requestedPlatform === platform_1.RequestedPlatform.Android) {
+        return generated_1.AppPlatform.Android;
+    }
+    else {
+        return generated_1.AppPlatform.Ios;
+    }
+};

package/build/commands/update/republish.d.ts

@@ -0,0 +1,23 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class UpdateRepublish 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, import("@oclif/core/lib/interfaces").CustomOptions>;
+        branch: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        group: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'destination-channel': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'destination-branch': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        message: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        platform: import("@oclif/core/lib/interfaces").OptionFlag<"android" | "ios" | "all" | "web", import("@oclif/core/lib/interfaces").CustomOptions>;
+        'private-key-path': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'rollout-percentage': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        privateProjectConfig: import("../../commandUtils/context/PrivateProjectConfigContextField").PrivateProjectConfigContextField;
+    };
+    runAsync(): Promise<void>;
+    private sanitizeFlags;
+}

package/build/commands/update/republish.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
+const BranchQuery_1 = require("../../graphql/queries/BranchQuery");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync_1 = require("../../update/getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync");
+const republish_1 = require("../../update/republish");
+const code_signing_1 = require("../../utils/code-signing");
+const json_1 = require("../../utils/json");
+const defaultRepublishPlatforms = ['android', 'ios'];
+class UpdateRepublish extends EasCommand_1.default {
+    static description = 'roll back to an existing update';
+    static flags = {
+        channel: core_1.Flags.string({
+            description: 'Channel name to select an update group to republish from',
+            exclusive: ['branch', 'group'],
+        }),
+        branch: core_1.Flags.string({
+            description: 'Branch name to select an update group to republish from',
+            exclusive: ['channel', 'group'],
+        }),
+        group: core_1.Flags.string({
+            description: 'Update group ID to republish',
+            exclusive: ['branch', 'channel'],
+        }),
+        'destination-channel': core_1.Flags.string({
+            description: 'Channel name to select a branch to republish to if republishing to a different branch',
+            exclusive: ['destination-branch'],
+        }),
+        'destination-branch': core_1.Flags.string({
+            description: 'Branch name to republish to if republishing to a different branch',
+            exclusive: ['destination-channel'],
+        }),
+        message: core_1.Flags.string({
+            char: 'm',
+            description: 'Short message describing the republished update group',
+            required: false,
+        }),
+        platform: core_1.Flags.option({
+            char: 'p',
+            options: [...defaultRepublishPlatforms, 'all'],
+            default: 'all',
+            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,
+        }),
+        'rollout-percentage': core_1.Flags.integer({
+            description: `Percentage of users this update should be immediately available to. Users not in the rollout will be served the previous latest update on the branch, even if that update is itself being rolled out. The specified number must be an integer between 1 and 100. When not specified, this defaults to 100.`,
+            required: false,
+            min: 0,
+            max: 100,
+        }),
+        ...flags_1.EasNonInteractiveAndJsonFlags,
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.ProjectConfig,
+        ...this.ContextOptions.LoggedIn,
+    };
+    async runAsync() {
+        const { flags: rawFlags } = await this.parse(UpdateRepublish);
+        const flags = this.sanitizeFlags(rawFlags);
+        const { privateProjectConfig: { exp, projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(UpdateRepublish, {
+            nonInteractive: flags.nonInteractive,
+            withServerSideEnvironment: null,
+        });
+        if (flags.json) {
+            (0, json_1.enableJsonOutput)();
+        }
+        const codeSigningInfo = await (0, code_signing_1.getCodeSigningInfoAsync)(exp, flags.privateKeyPath);
+        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`);
+        }
+        if (updatesToPublish.length === 0) {
+            throw new Error(`There are no updates on branch "${existingUpdates[0].branchName}" published for the platform(s) "${rawFlags.platform}" with group ID "${flags.groupId ? flags.groupId : updatesToPublish[0].groupId}". Did you mean to publish a new update instead?`);
+        }
+        if (rawFlags.platform !== 'all') {
+            log_1.default.withTick(`The republished update group will appear only on: ${rawFlags.platform}`);
+        }
+        else {
+            const platformsFromUpdates = updatesToPublish.map(update => update.platform);
+            if (platformsFromUpdates.length < defaultRepublishPlatforms.length) {
+                log_1.default.warn(`You are republishing an update group that wasn't published for all platforms.`);
+            }
+            log_1.default.withTick(`The republished update group will appear on the same platforms it was originally published on: ${platformsFromUpdates.join(', ')}`);
+        }
+        const arbitraryUpdate = updatesToPublish[0];
+        const targetBranch = await getOrAskTargetBranchAsync(graphqlClient, projectId, flags, arbitraryUpdate);
+        const updateMessage = await (0, republish_1.getOrAskUpdateMessageAsync)(updatesToPublish, flags);
+        await (0, republish_1.republishAsync)({
+            graphqlClient,
+            app: { exp, projectId },
+            updatesToPublish,
+            targetBranch,
+            updateMessage,
+            codeSigningInfo,
+            json: flags.json,
+            rolloutPercentage: flags.rolloutPercentage,
+        });
+    }
+    sanitizeFlags(rawFlags) {
+        const { json, nonInteractive } = (0, flags_1.resolveNonInteractiveAndJsonFlags)(rawFlags);
+        const branchName = rawFlags.branch;
+        const channelName = rawFlags.channel;
+        const groupId = rawFlags.group;
+        const destinationChannelName = rawFlags['destination-channel'];
+        const destinationBranchName = rawFlags['destination-branch'];
+        const privateKeyPath = rawFlags['private-key-path'];
+        if (nonInteractive && !groupId) {
+            throw new Error('Only --group can be used in non-interactive mode');
+        }
+        const platform = rawFlags.platform === 'all' ? defaultRepublishPlatforms : [rawFlags.platform];
+        return {
+            branchName,
+            channelName,
+            destinationChannelName,
+            destinationBranchName,
+            groupId,
+            platform,
+            updateMessage: rawFlags.message,
+            privateKeyPath,
+            rolloutPercentage: rawFlags['rollout-percentage'],
+            json,
+            nonInteractive,
+        };
+    }
+}
+exports.default = UpdateRepublish;
+async function getOrAskTargetBranchAsync(graphqlClient, projectId, flags, arbitraryUpdate) {
+    // if branch name supplied, use that
+    if (flags.destinationBranchName) {
+        const branch = await BranchQuery_1.BranchQuery.getBranchByNameAsync(graphqlClient, {
+            appId: projectId,
+            name: flags.destinationBranchName,
+        });
+        return { branchId: branch.id, branchName: branch.name };
+    }
+    // if provided channel name but was non-interactive
+    if (flags.destinationChannelName) {
+        return await (0, getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync_1.getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync)(graphqlClient, projectId, flags.destinationChannelName);
+    }
+    // if neither provided, assume republish on same branch
+    return { branchId: arbitraryUpdate.branchId, branchName: arbitraryUpdate.branchName };
+}

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, import("@oclif/core/lib/interfaces").CustomOptions>;
+        branch: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        group: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        message: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'private-key-path': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    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,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nonNullish = nonNullish;
+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;
+}
+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 { json, nonInteractive } = (0, flags_1.resolveNonInteractiveAndJsonFlags)(rawFlags);
+        const branchName = rawFlags.branch;
+        const channelName = rawFlags.channel;
+        const groupId = rawFlags.group;
+        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,
+            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

@@ -0,0 +1,22 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class UpdateRollBackToEmbedded extends EasCommand {
+    static description: string;
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        branch: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        channel: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'runtime-version': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        message: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        platform: import("@oclif/core/lib/interfaces").OptionFlag<"android" | "ios" | "all", import("@oclif/core/lib/interfaces").CustomOptions>;
+        'private-key-path': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static contextDefinition: {
+        vcsClient: import("../../commandUtils/context/VcsClientContextField").default;
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        getDynamicPublicProjectConfigAsync: import("../../commandUtils/context/DynamicProjectConfigContextField").DynamicPublicProjectConfigContextField;
+        getDynamicPrivateProjectConfigAsync: import("../../commandUtils/context/DynamicProjectConfigContextField").DynamicPrivateProjectConfigContextField;
+    };
+    runAsync(): Promise<void>;
+    private sanitizeFlags;
+}