eas-cli 2.9.0 → 3.0.0

package/build/commands/update/index.js

@@ -19,7 +19,6 @@ const pagination_1 = require("../../commandUtils/pagination");
 const fetch_1 = tslib_1.__importDefault(require("../../fetch"));
 const generated_1 = require("../../graphql/generated");
 const PublishMutation_1 = require("../../graphql/mutations/PublishMutation");
-const UpdateQuery_1 = require("../../graphql/queries/UpdateQuery");
 const log_1 = tslib_1.__importStar(require("../../log"));
 const ora_1 = require("../../ora");
 const platform_1 = require("../../platform");
@@ -28,7 +27,6 @@ const publish_1 = require("../../project/publish");
 const workflow_1 = require("../../project/workflow");
 const prompts_1 = require("../../prompts");
 const configure_1 = require("../../update/configure");
-const queries_3 = require("../../update/queries");
 const utils_2 = require("../../update/utils");
 const code_signing_1 = require("../../utils/code-signing");
 const uniqBy_1 = tslib_1.__importDefault(require("../../utils/expodash/uniqBy"));
@@ -53,10 +51,10 @@ function getRequestedPlatform(platform) {
 }
 class UpdatePublish extends EasCommand_1.default {
     async runAsync() {
-        var _b, _c, _d;
+        var _b, _c;
         const { flags: rawFlags } = await this.parse(UpdatePublish);
         const paginatedQueryOptions = (0, pagination_1.getPaginatedQueryOptions)(rawFlags);
-        let { auto: autoFlag, platform: platformFlag, branchName, updateMessage, republish, groupId, inputDir, skipBundler, privateKeyPath, json: jsonFlag, nonInteractive, } = this.sanitizeFlags(rawFlags);
+        let { auto: autoFlag, platform: platformFlag, branchName, updateMessage, inputDir, skipBundler, privateKeyPath, json: jsonFlag, nonInteractive, } = this.sanitizeFlags(rawFlags);
         const { getDynamicProjectConfigAsync, loggedIn: { graphqlClient }, } = await this.getContextAsync(UpdatePublish, {
             nonInteractive,
         });
@@ -90,7 +88,7 @@ class UpdatePublish extends EasCommand_1.default {
                 try {
                     const branch = await (0, queries_1.selectBranchOnAppAsync)(graphqlClient, {
                         projectId,
-                        promptTitle: `Which branch would you like to ${republish ? 'republish' : 'publish'} on?`,
+                        promptTitle: `Which branch would you like to publish on?`,
                         displayTextForListItem: updateBranch => `${updateBranch.name} ${chalk_1.default.grey(`- current update: ${(0, utils_2.formatUpdateMessage)(updateBranch.updates[0])}`)}`,
                         paginatedQueryOptions,
                     });
@@ -109,131 +107,62 @@ class UpdatePublish extends EasCommand_1.default {
                 (0, assert_1.default)(branchName, 'Branch name must be specified.');
             }
         }
-        let unsortedUpdateInfoGroups = {};
-        let oldMessage, oldRuntimeVersion;
-        let uploadedAssetCount = 0;
-        let assetLimitPerUpdateGroup = 0;
-        if (republish) {
-            // If we are republishing, we don't need to worry about building the bundle or uploading the assets.
-            // Instead we get the `updateInfoGroup` from the update we wish to republish.
-            let updatesToRepublish;
-            if (groupId) {
-                const updatesByGroup = await UpdateQuery_1.UpdateQuery.viewUpdateGroupAsync(graphqlClient, {
-                    groupId,
-                });
-                updatesToRepublish = updatesByGroup;
-            }
-            else {
-                if (nonInteractive) {
-                    throw new Error('Must supply --group when in non-interactive mode');
-                }
-                updatesToRepublish = await (0, queries_3.selectUpdateGroupOnBranchAsync)(graphqlClient, {
-                    projectId,
-                    branchName,
-                    paginatedQueryOptions,
-                });
-            }
-            const updatesToRepublishFilteredByPlatform = updatesToRepublish.filter(
-            // Only republish to the specified platforms
-            update => platformFlag === 'all' || update.platform === platformFlag);
-            if (updatesToRepublishFilteredByPlatform.length === 0) {
-                throw new Error(`There are no updates on branch "${branchName}" published for the platform(s) "${platformFlag}" with group ID "${groupId ? groupId : updatesToRepublish[0].group}". Did you mean to publish a new update instead?`);
-            }
-            let publicationPlatformMessage;
-            if (platformFlag === 'all') {
-                if (updatesToRepublishFilteredByPlatform.length < exports.defaultPublishPlatforms.length) {
-                    log_1.default.warn(`You are republishing an update that wasn't published for all platforms.`);
-                }
-                publicationPlatformMessage = `The republished update will appear on the same platforms it was originally published on: ${updatesToRepublishFilteredByPlatform
-                    .map(update => update.platform)
-                    .join(', ')}`;
-            }
-            else {
-                publicationPlatformMessage = `The republished update will appear only on: ${platformFlag}`;
-            }
-            log_1.default.withTick(publicationPlatformMessage);
-            for (const update of updatesToRepublishFilteredByPlatform) {
-                const { manifestFragment } = update;
-                const platform = update.platform;
-                unsortedUpdateInfoGroups[platform] = JSON.parse(manifestFragment);
-            }
-            realizedPlatforms = updatesToRepublishFilteredByPlatform.map(update => update.platform);
-            // These are the same for each member of an update group
-            groupId = updatesToRepublishFilteredByPlatform[0].group;
-            oldMessage = (_b = updatesToRepublishFilteredByPlatform[0].message) !== null && _b !== void 0 ? _b : '';
-            oldRuntimeVersion = updatesToRepublishFilteredByPlatform[0].runtimeVersion;
-            if (!updateMessage) {
-                if (nonInteractive) {
-                    throw new Error('Must supply --message when in non-interactive mode');
-                }
-                const validationMessage = 'publish message may not be empty.';
-                if (jsonFlag) {
-                    throw new Error(validationMessage);
-                }
-                ({ updateMessage } = await (0, prompts_1.promptAsync)({
-                    type: 'text',
-                    name: 'updateMessage',
-                    message: `Provide an update message.`,
-                    initial: `Republish "${oldMessage}" - group: ${groupId}`,
-                    validate: (value) => (value ? true : validationMessage),
-                }));
-            }
+        if (!updateMessage && autoFlag) {
+            updateMessage = (_b = (await (0, vcs_1.getVcsClient)().getLastCommitMessageAsync())) === null || _b === void 0 ? void 0 : _b.trim();
         }
-        else {
-            if (!updateMessage && autoFlag) {
-                updateMessage = (_c = (await (0, vcs_1.getVcsClient)().getLastCommitMessageAsync())) === null || _c === void 0 ? void 0 : _c.trim();
-            }
-            if (!updateMessage) {
-                if (nonInteractive) {
-                    throw new Error('Must supply --message or use --auto when in non-interactive mode');
-                }
-                const validationMessage = 'publish message may not be empty.';
-                if (jsonFlag) {
-                    throw new Error(validationMessage);
-                }
-                ({ updateMessage } = await (0, prompts_1.promptAsync)({
-                    type: 'text',
-                    name: 'updateMessage',
-                    message: `Provide an update message.`,
-                    initial: (_d = (await (0, vcs_1.getVcsClient)().getLastCommitMessageAsync())) === null || _d === void 0 ? void 0 : _d.trim(),
-                    validate: (value) => (value ? true : validationMessage),
-                }));
+        if (!updateMessage) {
+            if (nonInteractive) {
+                throw new Error('Must supply --message or use --auto when in non-interactive mode');
             }
-            // build bundle and upload assets for a new publish
-            if (!skipBundler) {
-                const bundleSpinner = (0, ora_1.ora)().start('Exporting...');
-                try {
-                    await (0, publish_1.buildBundlesAsync)({ projectDir, inputDir, exp, platformFlag });
-                    bundleSpinner.succeed('Exported bundle(s)');
-                }
-                catch (e) {
-                    bundleSpinner.fail('Export failed');
-                    throw e;
-                }
+            const validationMessage = 'publish message may not be empty.';
+            if (jsonFlag) {
+                throw new Error(validationMessage);
             }
-            // After possibly bundling, assert that the input directory can be found.
-            const distRoot = await (0, publish_1.resolveInputDirectoryAsync)(inputDir, { skipBundler });
-            const assetSpinner = (0, ora_1.ora)().start('Uploading...');
+            ({ updateMessage } = await (0, prompts_1.promptAsync)({
+                type: 'text',
+                name: 'updateMessage',
+                message: `Provide an update message.`,
+                initial: (_c = (await (0, vcs_1.getVcsClient)().getLastCommitMessageAsync())) === null || _c === void 0 ? void 0 : _c.trim(),
+                validate: (value) => (value ? true : validationMessage),
+            }));
+        }
+        // build bundle and upload assets for a new publish
+        if (!skipBundler) {
+            const bundleSpinner = (0, ora_1.ora)().start('Exporting...');
             try {
-                const collectedAssets = await (0, publish_1.collectAssetsAsync)(distRoot);
-                const assets = (0, publish_1.filterExportedPlatformsByFlag)(collectedAssets, platformFlag);
-                realizedPlatforms = Object.keys(assets);
-                const uploadResults = await (0, publish_1.uploadAssetsAsync)(graphqlClient, assets, projectId, (totalAssets, missingAssets) => {
-                    assetSpinner.text = `Uploading (${totalAssets - missingAssets}/${totalAssets})`;
-                });
-                uploadedAssetCount = uploadResults.uniqueUploadedAssetCount;
-                assetLimitPerUpdateGroup = uploadResults.assetLimitPerUpdateGroup;
-                unsortedUpdateInfoGroups = await (0, publish_1.buildUnsortedUpdateInfoGroupAsync)(assets, exp);
-                const uploadAssetSuccessMessage = uploadedAssetCount
-                    ? `Uploaded ${uploadedAssetCount} ${uploadedAssetCount === 1 ? 'platform' : 'platforms'}`
-                    : `Uploaded: No changes detected`;
-                assetSpinner.succeed(uploadAssetSuccessMessage);
+                await (0, publish_1.buildBundlesAsync)({ projectDir, inputDir, exp, platformFlag });
+                bundleSpinner.succeed('Exported bundle(s)');
             }
             catch (e) {
-                assetSpinner.fail('Failed to upload');
+                bundleSpinner.fail('Export failed');
                 throw e;
             }
         }
+        // After possibly bundling, assert that the input directory can be found.
+        const distRoot = await (0, publish_1.resolveInputDirectoryAsync)(inputDir, { skipBundler });
+        const assetSpinner = (0, ora_1.ora)().start('Uploading...');
+        let unsortedUpdateInfoGroups = {};
+        let uploadedAssetCount = 0;
+        let assetLimitPerUpdateGroup = 0;
+        try {
+            const collectedAssets = await (0, publish_1.collectAssetsAsync)(distRoot);
+            const assets = (0, publish_1.filterExportedPlatformsByFlag)(collectedAssets, platformFlag);
+            realizedPlatforms = Object.keys(assets);
+            const uploadResults = await (0, publish_1.uploadAssetsAsync)(graphqlClient, assets, projectId, (totalAssets, missingAssets) => {
+                assetSpinner.text = `Uploading (${totalAssets - missingAssets}/${totalAssets})`;
+            });
+            uploadedAssetCount = uploadResults.uniqueUploadedAssetCount;
+            assetLimitPerUpdateGroup = uploadResults.assetLimitPerUpdateGroup;
+            unsortedUpdateInfoGroups = await (0, publish_1.buildUnsortedUpdateInfoGroupAsync)(assets, exp);
+            const uploadAssetSuccessMessage = uploadedAssetCount
+                ? `Uploaded ${uploadedAssetCount} ${uploadedAssetCount === 1 ? 'platform' : 'platforms'}`
+                : `Uploaded: No changes detected`;
+            assetSpinner.succeed(uploadAssetSuccessMessage);
+        }
+        catch (e) {
+            assetSpinner.fail('Failed to upload');
+            throw e;
+        }
         const truncatedMessage = (0, utils_2.truncateString)(updateMessage, 1024);
         if (truncatedMessage !== updateMessage) {
             log_1.default.warn('Update message exceeds the allowed 1024 character limit. Truncating message...');
@@ -269,13 +198,10 @@ class UpdatePublish extends EasCommand_1.default {
                 platform,
                 unsortedUpdateInfoGroups[platform],
             ]));
-            if (republish && !oldRuntimeVersion) {
-                throw new Error('Cannot find the runtime version of the update group that is being republished.');
-            }
             return {
                 branchId,
                 updateInfoGroup: localUpdateInfoGroup,
-                runtimeVersion: republish ? oldRuntimeVersion : runtimeVersion,
+                runtimeVersion,
                 message: truncatedMessage,
                 gitCommitHash,
                 isGitWorkingTreeDirty,
@@ -380,17 +306,22 @@ class UpdatePublish extends EasCommand_1.default {
         if (nonInteractive && !auto && !(branchName && updateMessage)) {
             core_1.Errors.error('--auto or both --branch and --message are required when updating in non-interactive mode', { exit: 1 });
         }
-        const groupId = flags.group;
-        const republish = flags.republish || !!groupId; // When --group is defined, we are republishing
-        if (nonInteractive && republish && !groupId) {
-            core_1.Errors.error(`--group is required when updating in non-interactive mode`, { exit: 1 });
+        if (flags.group || flags.republish) {
+            // Pick the first flag set that is defined, in this specific order
+            const args = [
+                ['--group', flags.group],
+                ['--branch', flags.branch],
+            ].filter(([_, value]) => value)[0];
+            log_1.default.newLine();
+            log_1.default.warn('The --group and --republish flags are deprecated, use the republish command instead:');
+            log_1.default.warn(`  ${chalk_1.default.bold([`eas update:republish`, ...(args !== null && args !== void 0 ? args : [])].join(' '))}`);
+            log_1.default.newLine();
+            core_1.Errors.error('--group and --republish flags are deprecated', { exit: 1 });
         }
         return {
             auto,
             branchName,
             updateMessage,
-            groupId,
-            republish,
             inputDir: flags['input-dir'],
             skipBundler: flags['skip-bundler'],
             platform: flags.platform,
@@ -413,11 +344,11 @@ UpdatePublish.flags = {
         required: false,
     }),
     republish: core_1.Flags.boolean({
-        description: 'Republish an update group',
+        description: 'Republish an update group (deprecated, see republish command)',
         exclusive: ['input-dir', 'skip-bundler'],
     }),
     group: core_1.Flags.string({
-        description: 'Update group to republish',
+        description: 'Update group to republish (deprecated, see republish command)',
         exclusive: ['input-dir', 'skip-bundler'],
     }),
     'input-dir': core_1.Flags.string({

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

@@ -0,0 +1,36 @@
+import { Platform } from '@expo/config';
+import EasCommand from '../../commandUtils/EasCommand';
+declare type UpdateRepublishRawFlags = {
+    branch?: string;
+    group?: string;
+    message?: string;
+    platform: string;
+    'non-interactive': boolean;
+    json?: boolean;
+};
+declare type UpdateRepublishFlags = {
+    branchName?: string;
+    groupId?: string;
+    updateMessage?: string;
+    platform: Platform[];
+    nonInteractive: boolean;
+    json: boolean;
+};
+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>;
+        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>;
+        platform: import("@oclif/core/lib/interfaces").OptionFlag<string>;
+    };
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+        projectConfig: import("../../commandUtils/context/ProjectConfigContextField").default;
+    };
+    runAsync(): Promise<void>;
+    sanitizeFlags(rawFlags: UpdateRepublishRawFlags): UpdateRepublishFlags;
+}
+export {};

package/build/commands/update/republish.js

@@ -0,0 +1,218 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const url_1 = require("../../build/utils/url");
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
+const pagination_1 = require("../../commandUtils/pagination");
+const PublishMutation_1 = require("../../graphql/mutations/PublishMutation");
+const UpdateQuery_1 = require("../../graphql/queries/UpdateQuery");
+const log_1 = tslib_1.__importStar(require("../../log"));
+const ora_1 = require("../../ora");
+const projectUtils_1 = require("../../project/projectUtils");
+const prompts_1 = require("../../prompts");
+const queries_1 = require("../../update/queries");
+const utils_1 = require("../../update/utils");
+const formatFields_1 = tslib_1.__importDefault(require("../../utils/formatFields"));
+const json_1 = require("../../utils/json");
+const defaultRepublishPlatforms = ['android', 'ios'];
+class UpdateRepublish extends EasCommand_1.default {
+    async runAsync() {
+        const { flags: rawFlags } = await this.parse(UpdateRepublish);
+        const flags = this.sanitizeFlags(rawFlags);
+        const { projectConfig: { exp, projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(UpdateRepublish, {
+            nonInteractive: flags.nonInteractive,
+        });
+        if (flags.json) {
+            (0, json_1.enableJsonOutput)();
+        }
+        const existingUpdates = await getOrAskUpdatesAsync(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 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 that wasn't published for all platforms.`);
+            }
+            log_1.default.withTick(`The republished update will appear on the same platforms it was originally published on: ${platformsFromUpdates.join(', ')}`);
+        }
+        // This command only republishes a single update group
+        // The update group properties are the same for all updates
+        const { branchId, branchName, runtimeVersion } = updatesToPublish[0];
+        const updateMessage = await getOrAskUpdateMessageAsync(updatesToPublish, flags);
+        // If codesigning was created for the original update, we need to add it to the republish
+        const shouldRepublishWithCodesigning = updatesToPublish.some(update => update.codeSigningInfo);
+        if (shouldRepublishWithCodesigning) {
+            log_1.default.withTick(`The republished update will be signed with the same codesigning as the original update.`);
+        }
+        const publishIndicator = (0, ora_1.ora)('Republishing...').start();
+        let updatesRepublished;
+        try {
+            updatesRepublished = await PublishMutation_1.PublishMutation.publishUpdateGroupAsync(graphqlClient, [
+                {
+                    branchId,
+                    runtimeVersion,
+                    message: updateMessage,
+                    updateInfoGroup: Object.fromEntries(updatesToPublish.map(update => [update.platform, JSON.parse(update.manifestFragment)])),
+                    gitCommitHash: updatesToPublish[0].gitCommitHash,
+                    awaitingCodeSigningInfo: shouldRepublishWithCodesigning,
+                },
+            ]);
+            if (shouldRepublishWithCodesigning) {
+                const codeSigningByPlatform = Object.fromEntries(updatesToPublish.map(update => [update.platform, update.codeSigningInfo]));
+                await Promise.all(updatesRepublished.map(async (update) => {
+                    const codeSigning = codeSigningByPlatform[update.platform];
+                    if (codeSigning) {
+                        await PublishMutation_1.PublishMutation.setCodeSigningInfoAsync(graphqlClient, update.id, codeSigning);
+                    }
+                }));
+            }
+            publishIndicator.succeed('Republished update');
+        }
+        catch (error) {
+            publishIndicator.fail('Failed to republish update');
+            throw error;
+        }
+        if (flags.json) {
+            return (0, json_1.printJsonOnlyOutput)(updatesRepublished);
+        }
+        const updatesRepublishedByPlatform = Object.fromEntries(updatesRepublished.map(update => [update.platform, update]));
+        const updateGroupUrl = (0, url_1.getUpdateGroupUrl)((await (0, projectUtils_1.getOwnerAccountForProjectIdAsync)(graphqlClient, projectId)).name, exp.slug, updatesRepublished[0].group);
+        log_1.default.addNewLineIfNone();
+        log_1.default.log((0, formatFields_1.default)([
+            { label: 'Branch', value: branchName },
+            { label: 'Runtime version', value: updatesRepublished[0].runtimeVersion },
+            { label: 'Platform', value: updatesRepublished.map(update => update.platform).join(', ') },
+            { label: 'Update Group ID', value: updatesRepublished[0].id },
+            ...(updatesRepublishedByPlatform.android
+                ? [{ label: 'Android update ID', value: updatesRepublishedByPlatform.android.id }]
+                : []),
+            ...(updatesRepublishedByPlatform.ios
+                ? [{ label: 'iOS update ID', value: updatesRepublishedByPlatform.ios.id }]
+                : []),
+            { label: 'Message', value: updateMessage },
+            { label: 'Website link', value: (0, log_1.link)(updateGroupUrl, { dim: false }) },
+        ]));
+    }
+    sanitizeFlags(rawFlags) {
+        var _b;
+        const branchName = rawFlags.branch;
+        const groupId = rawFlags.group;
+        if (!branchName && !groupId) {
+            throw new Error('Either --branch or --group must be specified');
+        }
+        const platform = rawFlags.platform === 'all' ? defaultRepublishPlatforms : [rawFlags.platform];
+        return {
+            branchName,
+            groupId,
+            platform,
+            updateMessage: rawFlags.message,
+            json: (_b = rawFlags.json) !== null && _b !== void 0 ? _b : false,
+            nonInteractive: rawFlags['non-interactive'],
+        };
+    }
+}
+exports.default = UpdateRepublish;
+_a = UpdateRepublish;
+UpdateRepublish.description = 'rollback to an existing update';
+UpdateRepublish.flags = {
+    branch: core_1.Flags.string({
+        description: 'Branch name to select an update to republish from',
+        exclusive: ['group'],
+    }),
+    group: core_1.Flags.string({
+        description: 'Update group ID to republish',
+        exclusive: ['branch'],
+    }),
+    message: core_1.Flags.string({
+        description: 'Short message describing the republished update',
+        required: false,
+    }),
+    platform: core_1.Flags.enum({
+        char: 'p',
+        options: [...defaultRepublishPlatforms, 'all'],
+        default: 'all',
+        required: false,
+    }),
+    ...flags_1.EasNonInteractiveAndJsonFlags,
+};
+UpdateRepublish.contextDefinition = {
+    ..._a.ContextOptions.ProjectConfig,
+    ..._a.ContextOptions.LoggedIn,
+};
+/** 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 updateGroups = await UpdateQuery_1.UpdateQuery.viewUpdateGroupAsync(graphqlClient, {
+            groupId: flags.groupId,
+        });
+        return updateGroups.map(group => ({
+            ...group,
+            groupId: group.group,
+            branchId: group.branch.id,
+            branchName: group.branch.name,
+        }));
+    }
+    if (flags.branchName) {
+        return await askUpdatesFromBranchNameAsync(graphqlClient, {
+            ...flags,
+            branchName: flags.branchName,
+            projectId,
+        });
+    }
+    throw new Error('Must supply --group 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, }) {
+    if (nonInteractive) {
+        throw new Error('Must supply --group when in non-interactive mode');
+    }
+    const updateGroups = await (0, queries_1.selectUpdateGroupOnBranchAsync)(graphqlClient, {
+        projectId,
+        branchName,
+        paginatedQueryOptions: (0, pagination_1.getPaginatedQueryOptions)({ json, 'non-interactive': nonInteractive }),
+    });
+    return updateGroups.map(group => ({
+        ...group,
+        groupId: group.id,
+        branchId: group.branch.id,
+        branchName: group.branch.name,
+    }));
+}
+/** 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;
+}