eas-cli 16.13.4 → 16.14.0

package/build/graphql/mutations/EnvironmentVariableMutation.js

@@ -7,54 +7,6 @@ const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
 const client_1 = require("../client");
 const EnvironmentVariable_1 = require("../types/EnvironmentVariable");
 exports.EnvironmentVariableMutation = {
-    async linkSharedEnvironmentVariableAsync(graphqlClient, environmentVariableId, appId, environment) {
-        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
-            .mutation((0, graphql_tag_1.default) `
-            mutation LinkSharedEnvironmentVariable(
-              $appId: ID!
-              $environment: EnvironmentVariableEnvironment
-              $environmentVariableId: ID!
-            ) {
-              environmentVariable {
-                linkSharedEnvironmentVariable(
-                  appId: $appId
-                  environmentVariableId: $environmentVariableId
-                  environment: $environment
-                ) {
-                  id
-                  ...EnvironmentVariableFragment
-                }
-              }
-            }
-            ${(0, graphql_1.print)(EnvironmentVariable_1.EnvironmentVariableFragmentNode)}
-          `, { appId, environment, environmentVariableId })
-            .toPromise());
-        return data.environmentVariable.linkSharedEnvironmentVariable;
-    },
-    async unlinkSharedEnvironmentVariableAsync(graphqlClient, environmentVariableId, appId, environment) {
-        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
-            .mutation((0, graphql_tag_1.default) `
-            mutation UnlinkSharedEnvironmentVariable(
-              $appId: ID!
-              $environment: EnvironmentVariableEnvironment
-              $environmentVariableId: ID!
-            ) {
-              environmentVariable {
-                unlinkSharedEnvironmentVariable(
-                  appId: $appId
-                  environmentVariableId: $environmentVariableId
-                  environment: $environment
-                ) {
-                  id
-                  ...EnvironmentVariableFragment
-                }
-              }
-            }
-            ${(0, graphql_1.print)(EnvironmentVariable_1.EnvironmentVariableFragmentNode)}
-          `, { appId, environment, environmentVariableId })
-            .toPromise());
-        return data.environmentVariable.unlinkSharedEnvironmentVariable;
-    },
     async createSharedVariableAsync(graphqlClient, input, accountId) {
         const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .mutation((0, graphql_tag_1.default) `

package/build/graphql/types/Update.js

@@ -39,6 +39,7 @@ exports.UpdateFragmentNode = (0, graphql_tag_1.default) `
     rolloutPercentage
     rolloutControlUpdate {
       id
+      group
     }
     fingerprint {
       id

package/build/project/publish.js

@@ -644,6 +644,7 @@ async function getRuntimeToUpdateRolloutInfoGroupMappingAsync(graphqlClient, { a
 }
 exports.getRuntimeToUpdateRolloutInfoGroupMappingAsync = getRuntimeToUpdateRolloutInfoGroupMappingAsync;
 async function getUpdateRolloutInfoGroupAsync(graphqlClient, { appId, branchName, rolloutPercentage, runtimeVersion, platforms, }) {
+    // note that this could return control updates in different update groups if the update groups only have a single platform
     return Object.fromEntries(await Promise.all(platforms.map(async (platform) => {
         const updateIdForPlatform = await BranchQuery_1.BranchQuery.getLatestUpdateIdOnBranchAsync(graphqlClient, {
             appId,

package/build/update/delete.d.ts

@@ -0,0 +1,5 @@
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { BackgroundJobReceiptDataFragment } from '../graphql/generated';
+export declare function scheduleUpdateGroupDeletionAsync(graphqlClient: ExpoGraphqlClient, { group, }: {
+    group: string;
+}): Promise<BackgroundJobReceiptDataFragment>;

package/build/update/delete.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scheduleUpdateGroupDeletionAsync = void 0;
+const tslib_1 = require("tslib");
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const client_1 = require("../graphql/client");
+const BackgroundJobReceipt_1 = require("../graphql/types/BackgroundJobReceipt");
+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;
+}
+exports.scheduleUpdateGroupDeletionAsync = scheduleUpdateGroupDeletionAsync;

package/build/update/queries.d.ts

@@ -1,8 +1,10 @@
 import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
 import { PaginatedQueryOptions } from '../commandUtils/pagination';
-import { UpdateFragment } from '../graphql/generated';
+import { RuntimeFragment, UpdateFragment } from '../graphql/generated';
+import { UpdatePublishPlatform } from '../project/publish';
 export declare const UPDATES_LIMIT = 50;
 export declare const UPDATE_GROUPS_LIMIT = 25;
+export declare const RUNTIME_VERSIONS_LIMIT = 25;
 export declare function listAndRenderUpdateGroupsOnAppAsync(graphqlClient: ExpoGraphqlClient, { projectId, paginatedQueryOptions, }: {
     projectId: string;
     paginatedQueryOptions: PaginatedQueryOptions;
@@ -12,8 +14,18 @@ export declare function listAndRenderUpdateGroupsOnBranchAsync(graphqlClient: Ex
     branchName: string;
     paginatedQueryOptions: PaginatedQueryOptions;
 }): Promise<void>;
+export declare function selectRuntimeAndGetLatestUpdateGroupForEachPublishPlatformOnBranchAsync(graphqlClient: ExpoGraphqlClient, { projectId, branchName, paginatedQueryOptions, }: {
+    projectId: string;
+    branchName: string;
+    paginatedQueryOptions: PaginatedQueryOptions;
+}): Promise<Record<UpdatePublishPlatform, UpdateFragment[] | undefined>>;
 export declare function selectUpdateGroupOnBranchAsync(graphqlClient: ExpoGraphqlClient, { projectId, branchName, paginatedQueryOptions, }: {
     projectId: string;
     branchName: string;
     paginatedQueryOptions: PaginatedQueryOptions;
 }): Promise<UpdateFragment[]>;
+export declare function selectRuntimeOnBranchAsync(graphqlClient: ExpoGraphqlClient, { appId, branchName, batchSize, }: {
+    appId: string;
+    branchName: string;
+    batchSize?: number;
+}): Promise<RuntimeFragment | null>;

package/build/update/queries.js

@@ -1,17 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.selectUpdateGroupOnBranchAsync = exports.listAndRenderUpdateGroupsOnBranchAsync = exports.listAndRenderUpdateGroupsOnAppAsync = exports.UPDATE_GROUPS_LIMIT = exports.UPDATES_LIMIT = void 0;
+exports.selectRuntimeOnBranchAsync = exports.selectUpdateGroupOnBranchAsync = exports.selectRuntimeAndGetLatestUpdateGroupForEachPublishPlatformOnBranchAsync = exports.listAndRenderUpdateGroupsOnBranchAsync = exports.listAndRenderUpdateGroupsOnAppAsync = exports.RUNTIME_VERSIONS_LIMIT = exports.UPDATE_GROUPS_LIMIT = exports.UPDATES_LIMIT = void 0;
 const tslib_1 = require("tslib");
 const assert_1 = tslib_1.__importDefault(require("assert"));
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const utils_1 = require("./utils");
+const generated_1 = require("../graphql/generated");
+const RuntimeQuery_1 = require("../graphql/queries/RuntimeQuery");
 const UpdateQuery_1 = require("../graphql/queries/UpdateQuery");
 const log_1 = tslib_1.__importDefault(require("../log"));
 const formatFields_1 = tslib_1.__importDefault(require("../utils/formatFields"));
 const json_1 = require("../utils/json");
 const queries_1 = require("../utils/queries");
+const relay_1 = require("../utils/relay");
 exports.UPDATES_LIMIT = 50;
 exports.UPDATE_GROUPS_LIMIT = 25;
+exports.RUNTIME_VERSIONS_LIMIT = 25;
 async function listAndRenderUpdateGroupsOnAppAsync(graphqlClient, { projectId, paginatedQueryOptions, }) {
     if (paginatedQueryOptions.nonInteractive) {
         const updateGroups = await queryUpdateGroupsOnAppAsync(graphqlClient, {
@@ -66,6 +70,41 @@ async function listAndRenderUpdateGroupsOnBranchAsync(graphqlClient, { projectId
     }
 }
 exports.listAndRenderUpdateGroupsOnBranchAsync = listAndRenderUpdateGroupsOnBranchAsync;
+async function selectRuntimeAndGetLatestUpdateGroupForEachPublishPlatformOnBranchAsync(graphqlClient, { projectId, branchName, paginatedQueryOptions, }) {
+    if (paginatedQueryOptions.nonInteractive) {
+        throw new Error('Unable to select an update in non-interactive mode.');
+    }
+    const runtimeVersion = await selectRuntimeOnBranchAsync(graphqlClient, {
+        appId: projectId,
+        branchName,
+    });
+    if (!runtimeVersion) {
+        throw new Error('No runtime version selected.');
+    }
+    return {
+        ios: (await queryUpdateGroupsOnBranchAsync(graphqlClient, {
+            appId: projectId,
+            branchName,
+            limit: 1,
+            offset: 0,
+            filter: {
+                runtimeVersions: [runtimeVersion.version],
+                platform: generated_1.AppPlatform.Ios,
+            },
+        }))[0],
+        android: (await queryUpdateGroupsOnBranchAsync(graphqlClient, {
+            appId: projectId,
+            branchName,
+            limit: 1,
+            offset: 0,
+            filter: {
+                runtimeVersions: [runtimeVersion.version],
+                platform: generated_1.AppPlatform.Android,
+            },
+        }))[0],
+    };
+}
+exports.selectRuntimeAndGetLatestUpdateGroupForEachPublishPlatformOnBranchAsync = selectRuntimeAndGetLatestUpdateGroupForEachPublishPlatformOnBranchAsync;
 async function selectUpdateGroupOnBranchAsync(graphqlClient, { projectId, branchName, paginatedQueryOptions, }) {
     if (paginatedQueryOptions.nonInteractive) {
         throw new Error('Unable to select an update in non-interactive mode.');
@@ -140,3 +179,25 @@ function renderUpdateGroupsOnApp({ updateGroups, paginatedQueryOptions: { json }
     }))
         .join(`\n\n${chalk_1.default.dim('———')}\n\n`));
 }
+async function selectRuntimeOnBranchAsync(graphqlClient, { appId, branchName, batchSize = 5, }) {
+    const queryAsync = async (queryParams) => {
+        return await RuntimeQuery_1.RuntimeQuery.getRuntimesOnBranchAsync(graphqlClient, {
+            appId,
+            name: branchName,
+            first: queryParams.first,
+            after: queryParams.after,
+            last: queryParams.last,
+            before: queryParams.before,
+        });
+    };
+    const getTitleAsync = async (runtime) => {
+        return runtime.version;
+    };
+    return await (0, relay_1.selectPaginatedAsync)({
+        queryAsync,
+        getTitleAsync,
+        printedType: 'target runtime',
+        pageSize: batchSize,
+    });
+}
+exports.selectRuntimeOnBranchAsync = selectRuntimeOnBranchAsync;

package/build/update/republish.d.ts

@@ -1,6 +1,7 @@
 import { ExpoConfig } from '@expo/config';
 import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
 import { UpdateFragment } from '../graphql/generated';
+import { UpdatePublishPlatform } from '../project/publish';
 import { CodeSigningInfo } from '../utils/code-signing';
 export type UpdateToRepublish = {
     groupId: string;
@@ -27,3 +28,29 @@ export declare function republishAsync({ graphqlClient, app, updatesToPublish, t
     json?: boolean;
     rolloutPercentage?: number;
 }): Promise<void>;
+type GetUpdateOrAskForUpdatesOptions = {
+    nonInteractive: boolean;
+    json: boolean;
+    groupId?: string;
+    branchName?: string;
+    channelName?: string;
+};
+export declare function getUpdateGroupAsync(graphqlClient: ExpoGraphqlClient, groupId: string): Promise<UpdateToRepublish[]>;
+type AskUpdateGroupForEachPublishPlatformFilteringByRuntimeVersionOptions = {
+    nonInteractive: boolean;
+    json: boolean;
+    branchName?: string;
+    channelName?: string;
+};
+export declare function askUpdateGroupForEachPublishPlatformFilteringByRuntimeVersionAsync(graphqlClient: ExpoGraphqlClient, projectId: string, options: AskUpdateGroupForEachPublishPlatformFilteringByRuntimeVersionOptions): Promise<Record<UpdatePublishPlatform, UpdateToRepublish[] | undefined>>;
+export declare function getUpdateGroupOrAskForUpdateGroupAsync(graphqlClient: ExpoGraphqlClient, projectId: string, options: GetUpdateOrAskForUpdatesOptions): Promise<UpdateToRepublish[]>;
+type GetOrAskUpdateMessageOptions = {
+    updateMessage?: string;
+    nonInteractive: boolean;
+    json: boolean;
+};
+/**
+ * Get or ask the user for the update (group) message for the republish
+ */
+export declare function getOrAskUpdateMessageAsync(updateGroup: UpdateToRepublish[], options: GetOrAskUpdateMessageOptions): Promise<string>;
+export {};

package/build/update/republish.js

@@ -1,16 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.republishAsync = void 0;
+exports.getOrAskUpdateMessageAsync = exports.getUpdateGroupOrAskForUpdateGroupAsync = exports.askUpdateGroupForEachPublishPlatformFilteringByRuntimeVersionAsync = exports.getUpdateGroupAsync = exports.republishAsync = void 0;
 const tslib_1 = require("tslib");
 const assert_1 = tslib_1.__importDefault(require("assert"));
 const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync_1 = require("./getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync");
+const queries_1 = require("./queries");
+const utils_1 = require("./utils");
+const queries_2 = require("../branch/queries");
 const url_1 = require("../build/utils/url");
+const queries_3 = require("../channel/queries");
+const pagination_1 = require("../commandUtils/pagination");
 const fetch_1 = tslib_1.__importDefault(require("../fetch"));
 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 publish_1 = require("../project/publish");
+const prompts_1 = require("../prompts");
 const code_signing_1 = require("../utils/code-signing");
 const formatFields_1 = tslib_1.__importDefault(require("../utils/formatFields"));
 const json_1 = require("../utils/json");
@@ -174,3 +182,236 @@ async function republishAsync({ graphqlClient, app, updatesToPublish, targetBran
     ]));
 }
 exports.republishAsync = republishAsync;
+async function getUpdateGroupAsync(graphqlClient, groupId) {
+    const updateGroup = await UpdateQuery_1.UpdateQuery.viewUpdateGroupAsync(graphqlClient, {
+        groupId,
+    });
+    return updateGroup.map(update => ({
+        ...update,
+        groupId: update.group,
+        branchId: update.branch.id,
+        branchName: update.branch.name,
+    }));
+}
+exports.getUpdateGroupAsync = getUpdateGroupAsync;
+async function askUpdateGroupForEachPublishPlatformFilteringByRuntimeVersionAsync(graphqlClient, projectId, options) {
+    if (options.nonInteractive) {
+        throw new Error('Must supply --group when in non-interactive mode');
+    }
+    if (options.branchName) {
+        return await askUpdateGroupForEachPublishPlatformFromBranchNameFilteringByRuntimeVersionAsync(graphqlClient, {
+            ...options,
+            branchName: options.branchName,
+            projectId,
+        });
+    }
+    if (options.channelName) {
+        return await askUpdateGroupForEachPublishPlatformFromChannelNameFilteringByRuntimeVersionAsync(graphqlClient, {
+            ...options,
+            channelName: options.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_3.selectChannelOnAppAsync)(graphqlClient, {
+            projectId,
+            selectionPromptTitle: 'Select a channel to view',
+            paginatedQueryOptions: {
+                json: options.json,
+                nonInteractive: options.nonInteractive,
+                offset: 0,
+            },
+        });
+        return await askUpdateGroupForEachPublishPlatformFromChannelNameFilteringByRuntimeVersionAsync(graphqlClient, {
+            ...options,
+            channelName: name,
+            projectId,
+        });
+    }
+    else if (choice === 'branch') {
+        const { name } = await (0, queries_2.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: options.json,
+                nonInteractive: options.nonInteractive,
+                offset: 0,
+            },
+        });
+        return await askUpdateGroupForEachPublishPlatformFromBranchNameFilteringByRuntimeVersionAsync(graphqlClient, {
+            ...options,
+            branchName: name,
+            projectId,
+        });
+    }
+    else {
+        throw new Error('Must choose update via channel or branch');
+    }
+}
+exports.askUpdateGroupForEachPublishPlatformFilteringByRuntimeVersionAsync = askUpdateGroupForEachPublishPlatformFilteringByRuntimeVersionAsync;
+async function getUpdateGroupOrAskForUpdateGroupAsync(graphqlClient, projectId, options) {
+    if (options.groupId) {
+        return await getUpdateGroupAsync(graphqlClient, options.groupId);
+    }
+    if (options.nonInteractive) {
+        throw new Error('Must supply --group when in non-interactive mode');
+    }
+    if (options.branchName) {
+        return await askUpdatesFromBranchNameAsync(graphqlClient, {
+            ...options,
+            branchName: options.branchName,
+            projectId,
+        });
+    }
+    if (options.channelName) {
+        return await askUpdatesFromChannelNameAsync(graphqlClient, {
+            ...options,
+            channelName: options.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_3.selectChannelOnAppAsync)(graphqlClient, {
+            projectId,
+            selectionPromptTitle: 'Select a channel to view',
+            paginatedQueryOptions: {
+                json: options.json,
+                nonInteractive: options.nonInteractive,
+                offset: 0,
+            },
+        });
+        return await askUpdatesFromChannelNameAsync(graphqlClient, {
+            ...options,
+            channelName: name,
+            projectId,
+        });
+    }
+    else if (choice === 'branch') {
+        const { name } = await (0, queries_2.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: options.json,
+                nonInteractive: options.nonInteractive,
+                offset: 0,
+            },
+        });
+        return await askUpdatesFromBranchNameAsync(graphqlClient, {
+            ...options,
+            branchName: name,
+            projectId,
+        });
+    }
+    else {
+        throw new Error('Must choose update via channel or branch');
+    }
+}
+exports.getUpdateGroupOrAskForUpdateGroupAsync = getUpdateGroupOrAskForUpdateGroupAsync;
+async function askUpdateGroupForEachPublishPlatformFromBranchNameFilteringByRuntimeVersionAsync(graphqlClient, { projectId, branchName, json, nonInteractive, }) {
+    const publishPlatformToLatestUpdateGroup = await (0, queries_1.selectRuntimeAndGetLatestUpdateGroupForEachPublishPlatformOnBranchAsync)(graphqlClient, {
+        projectId,
+        branchName,
+        paginatedQueryOptions: (0, pagination_1.getPaginatedQueryOptions)({ json, 'non-interactive': nonInteractive }),
+    });
+    return {
+        ios: publishPlatformToLatestUpdateGroup.ios?.map(update => ({
+            ...update,
+            groupId: update.group,
+            branchId: update.branch.id,
+            branchName: update.branch.name,
+        })),
+        android: publishPlatformToLatestUpdateGroup.android?.map(update => ({
+            ...update,
+            groupId: update.group,
+            branchId: update.branch.id,
+            branchName: update.branch.name,
+        })),
+    };
+}
+async function askUpdatesFromBranchNameAsync(graphqlClient, { projectId, branchName, json, nonInteractive, }) {
+    const updateGroup = await (0, queries_1.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,
+    }));
+}
+async function askUpdateGroupForEachPublishPlatformFromChannelNameFilteringByRuntimeVersionAsync(graphqlClient, { projectId, channelName, json, nonInteractive, }) {
+    const { branchName } = await (0, getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync_1.getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync)(graphqlClient, projectId, channelName);
+    return await askUpdateGroupForEachPublishPlatformFromBranchNameFilteringByRuntimeVersionAsync(graphqlClient, {
+        projectId,
+        branchName,
+        json,
+        nonInteractive,
+    });
+}
+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(updateGroup, options) {
+    if (options.updateMessage) {
+        return sanitizeUpdateMessage(options.updateMessage);
+    }
+    if (options.nonInteractive || options.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 = updateGroup[0].groupId;
+    const oldUpdateMessage = updateGroup[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);
+}
+exports.getOrAskUpdateMessageAsync = getOrAskUpdateMessageAsync;
+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/update/roll-back-to-embedded.d.ts

@@ -0,0 +1,18 @@
+import { ExpoConfig } from '@expo/config';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { UpdatePublishPlatform } from '../project/publish';
+import { CodeSigningInfo } from '../utils/code-signing';
+export declare function publishRollBackToEmbeddedUpdateAsync({ graphqlClient, projectId, exp, updateMessage, branch, codeSigningInfo, platforms, runtimeVersion, json, }: {
+    graphqlClient: ExpoGraphqlClient;
+    projectId: string;
+    exp: ExpoConfig;
+    updateMessage: string | undefined;
+    branch: {
+        name: string;
+        id: string;
+    };
+    codeSigningInfo: CodeSigningInfo | undefined;
+    platforms: UpdatePublishPlatform[];
+    runtimeVersion: string;
+    json: boolean;
+}): Promise<void>;

package/build/update/roll-back-to-embedded.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publishRollBackToEmbeddedUpdateAsync = void 0;
+const tslib_1 = require("tslib");
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const utils_1 = require("./utils");
+const url_1 = require("../build/utils/url");
+const fetch_1 = tslib_1.__importDefault(require("../fetch"));
+const PublishMutation_1 = require("../graphql/mutations/PublishMutation");
+const log_1 = tslib_1.__importStar(require("../log"));
+const ora_1 = require("../ora");
+const projectUtils_1 = require("../project/projectUtils");
+const publish_1 = require("../project/publish");
+const code_signing_1 = require("../utils/code-signing");
+const uniqBy_1 = tslib_1.__importDefault(require("../utils/expodash/uniqBy"));
+const formatFields_1 = tslib_1.__importDefault(require("../utils/formatFields"));
+const json_1 = require("../utils/json");
+async function publishRollBackToEmbeddedUpdateAsync({ graphqlClient, projectId, exp, updateMessage, branch, codeSigningInfo, platforms, runtimeVersion, json, }) {
+    const runtimeToPlatformsAndFingerprintInfoMapping = (0, publish_1.getRuntimeToPlatformsAndFingerprintInfoMappingFromRuntimeVersionInfoObjects)(platforms.map(platform => ({
+        platform,
+        runtimeVersionInfo: {
+            runtimeVersion,
+            expoUpdatesRuntimeFingerprint: null,
+            expoUpdatesRuntimeFingerprintHash: null,
+        },
+    })));
+    let newUpdates;
+    const publishSpinner = (0, ora_1.ora)('Publishing...').start();
+    try {
+        newUpdates = await publishRollbacksAsync({
+            graphqlClient,
+            updateMessage,
+            branchId: branch.id,
+            codeSigningInfo,
+            runtimeToPlatformsAndFingerprintInfoMapping,
+            platforms,
+        });
+        publishSpinner.succeed('Published!');
+    }
+    catch (e) {
+        publishSpinner.fail('Failed to publish updates');
+        throw e;
+    }
+    if (json) {
+        (0, json_1.printJsonOnlyOutput)((0, utils_1.getUpdateJsonInfosForUpdates)(newUpdates));
+    }
+    else {
+        log_1.default.addNewLineIfNone();
+        for (const runtime of (0, uniqBy_1.default)(runtimeToPlatformsAndFingerprintInfoMapping, version => version.runtimeVersion)) {
+            const newUpdatesForRuntimeVersion = newUpdates.filter(update => update.runtimeVersion === runtime.runtimeVersion);
+            if (newUpdatesForRuntimeVersion.length === 0) {
+                throw new Error(`Publish response is missing updates with runtime ${runtime.runtimeVersion}.`);
+            }
+            const platforms = newUpdatesForRuntimeVersion.map(update => update.platform);
+            const newAndroidUpdate = newUpdatesForRuntimeVersion.find(update => update.platform === 'android');
+            const newIosUpdate = newUpdatesForRuntimeVersion.find(update => update.platform === 'ios');
+            const updateGroupId = newUpdatesForRuntimeVersion[0].group;
+            const projectName = exp.slug;
+            const accountName = (await (0, projectUtils_1.getOwnerAccountForProjectIdAsync)(graphqlClient, projectId)).name;
+            const updateGroupUrl = (0, url_1.getUpdateGroupUrl)(accountName, projectName, updateGroupId);
+            const updateGroupLink = (0, log_1.link)(updateGroupUrl, { dim: false });
+            log_1.default.log((0, formatFields_1.default)([
+                { label: 'Branch', value: branch.name },
+                { label: 'Runtime version', value: runtime.runtimeVersion },
+                { label: 'Platform', value: platforms.join(', ') },
+                { label: 'Update group ID', value: updateGroupId },
+                ...(newAndroidUpdate ? [{ label: 'Android update ID', value: newAndroidUpdate.id }] : []),
+                ...(newIosUpdate ? [{ label: 'iOS update ID', value: newIosUpdate.id }] : []),
+                { label: 'Message', value: updateMessage ?? '' },
+                { label: 'EAS Dashboard', value: updateGroupLink },
+            ]));
+            log_1.default.addNewLineIfNone();
+        }
+    }
+}
+exports.publishRollBackToEmbeddedUpdateAsync = publishRollBackToEmbeddedUpdateAsync;
+async function publishRollbacksAsync({ graphqlClient, updateMessage, branchId, codeSigningInfo, runtimeToPlatformsAndFingerprintInfoMapping, platforms, }) {
+    const rollbackInfoGroups = Object.fromEntries(platforms.map(platform => [platform, true]));
+    // Sort the updates into different groups based on their platform specific runtime versions
+    const updateGroups = runtimeToPlatformsAndFingerprintInfoMapping.map(({ runtimeVersion, platforms }) => {
+        const localRollbackInfoGroup = Object.fromEntries(platforms.map(platform => [platform, rollbackInfoGroups[platform]]));
+        return {
+            branchId,
+            rollBackToEmbeddedInfoGroup: localRollbackInfoGroup,
+            runtimeVersion,
+            message: updateMessage,
+            awaitingCodeSigningInfo: !!codeSigningInfo,
+        };
+    });
+    const newUpdates = await PublishMutation_1.PublishMutation.publishUpdateGroupAsync(graphqlClient, updateGroups);
+    if (codeSigningInfo) {
+        log_1.default.log('🔒 Signing roll back');
+        const updatesTemp = [...newUpdates];
+        const updateGroupsAndTheirUpdates = updateGroups.map(updateGroup => {
+            const newUpdates = updatesTemp.splice(0, Object.keys((0, nullthrows_1.default)(updateGroup.rollBackToEmbeddedInfoGroup)).length);
+            return {
+                updateGroup,
+                newUpdates,
+            };
+        });
+        await Promise.all(updateGroupsAndTheirUpdates.map(async ({ newUpdates }) => {
+            await Promise.all(newUpdates.map(async (newUpdate) => {
+                const response = await (0, fetch_1.default)(newUpdate.manifestPermalink, {
+                    method: 'GET',
+                    headers: { accept: 'multipart/mixed' },
+                });
+                const directiveBody = (0, nullthrows_1.default)(await (0, code_signing_1.getDirectiveBodyAsync)(response));
+                (0, code_signing_1.checkDirectiveBodyAgainstUpdateInfoGroup)(directiveBody);
+                const directiveSignature = (0, code_signing_1.signBody)(directiveBody, codeSigningInfo);
+                await PublishMutation_1.PublishMutation.setCodeSigningInfoAsync(graphqlClient, newUpdate.id, {
+                    alg: codeSigningInfo.codeSigningMetadata.alg,
+                    keyid: codeSigningInfo.codeSigningMetadata.keyid,
+                    sig: directiveSignature,
+                });
+            }));
+        }));
+    }
+    return newUpdates;
+}