eas-cli 3.18.0 → 3.18.2

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

@@ -0,0 +1,28 @@
+import { EASUpdateAction, EASUpdateContext } from '../../eas-update/utils';
+import { UpdateChannelBasicInfoFragment } from '../../graphql/generated';
+import { NonInteractiveOptions as CreateRolloutNonInteractiveOptions } from './CreateRollout';
+import { NonInteractiveOptions as EditRolloutNonInteractiveOptions } from './EditRollout';
+import { NonInteractiveOptions as EndRolloutNonInteractiveOptions } from './EndRollout';
+import { ManageRolloutActions } from './ManageRollout';
+export declare enum MainMenuActions {
+    CREATE_NEW = "Create a new rollout",
+    MANAGE_EXISTING = "Manage an existing rollout"
+}
+export type RolloutActions = MainMenuActions.CREATE_NEW | ManageRolloutActions.EDIT | ManageRolloutActions.END;
+/**
+ * Manage a rollout for the project.
+ */
+export declare class RolloutMainMenu implements EASUpdateAction<void> {
+    private options;
+    constructor(options?: {
+        channelName?: string;
+        action?: RolloutActions;
+    } & Partial<EditRolloutNonInteractiveOptions> & Partial<EndRolloutNonInteractiveOptions> & Partial<CreateRolloutNonInteractiveOptions>);
+    runAsync(ctx: EASUpdateContext): Promise<void>;
+    runActionAsync(ctx: EASUpdateContext, menuAction: MainMenuActions): Promise<null>;
+    selectRolloutAsync(ctx: EASUpdateContext): Promise<UpdateChannelBasicInfoFragment | null>;
+    selectChannelAsync(ctx: EASUpdateContext, filterPredicate?: (channelInfo: UpdateChannelBasicInfoFragment) => boolean): Promise<UpdateChannelBasicInfoFragment>;
+    resolveChannelNameAsync(ctx: EASUpdateContext, channelName: string): Promise<UpdateChannelBasicInfoFragment>;
+    toMainMenuAction(action: RolloutActions): MainMenuActions;
+    promptMenuActionAsync(): Promise<MainMenuActions>;
+}

package/build/rollout/actions/RolloutMainMenu.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RolloutMainMenu = exports.MainMenuActions = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const SelectChannel_1 = require("../../channel/actions/SelectChannel");
+const ChannelQuery_1 = require("../../graphql/queries/ChannelQuery");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const prompts_1 = require("../../prompts");
+const branch_mapping_1 = require("../branch-mapping");
+const CreateRollout_1 = require("./CreateRollout");
+const ManageRollout_1 = require("./ManageRollout");
+const SelectRollout_1 = require("./SelectRollout");
+var MainMenuActions;
+(function (MainMenuActions) {
+    MainMenuActions["CREATE_NEW"] = "Create a new rollout";
+    MainMenuActions["MANAGE_EXISTING"] = "Manage an existing rollout";
+})(MainMenuActions = exports.MainMenuActions || (exports.MainMenuActions = {}));
+/**
+ * Manage a rollout for the project.
+ */
+class RolloutMainMenu {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async runAsync(ctx) {
+        const { action } = this.options;
+        const { nonInteractive } = ctx;
+        if (nonInteractive) {
+            throw new Error(`rollout main menu cannot be run in non-interactive mode.`);
+        }
+        const menuOption = action ? this.toMainMenuAction(action) : await this.promptMenuActionAsync();
+        await this.runActionAsync(ctx, menuOption);
+    }
+    async runActionAsync(ctx, menuAction) {
+        const { channelName } = this.options;
+        switch (menuAction) {
+            case MainMenuActions.CREATE_NEW: {
+                const channelInfo = channelName
+                    ? await this.resolveChannelNameAsync(ctx, channelName)
+                    : await this.selectChannelAsync(ctx, channelInfo => !(0, branch_mapping_1.isRollout)(channelInfo));
+                await new CreateRollout_1.CreateRollout(channelInfo, this.options).runAsync(ctx);
+                return null;
+            }
+            case MainMenuActions.MANAGE_EXISTING: {
+                const channelInfo = channelName
+                    ? await this.resolveChannelNameAsync(ctx, channelName)
+                    : await this.selectRolloutAsync(ctx);
+                if (!channelInfo) {
+                    log_1.default.log('You dont have any rollouts.');
+                }
+                else {
+                    (0, assert_1.default)(this.options.action !== MainMenuActions.CREATE_NEW, 'Invalid route for create action');
+                    const manageAction = await new ManageRollout_1.ManageRollout(channelInfo, {
+                        ...this.options,
+                        action: this.options.action,
+                        callingAction: this,
+                    }).runAsync(ctx);
+                    await manageAction.runAsync(ctx);
+                }
+                return null;
+            }
+        }
+    }
+    async selectRolloutAsync(ctx) {
+        const selectRollout = new SelectRollout_1.SelectRollout();
+        const channelInfo = await selectRollout.runAsync(ctx);
+        return channelInfo;
+    }
+    async selectChannelAsync(ctx, filterPredicate) {
+        const selectChannelAction = new SelectChannel_1.SelectChannel({ filterPredicate });
+        const channelInfo = await selectChannelAction.runAsync(ctx);
+        if (!channelInfo) {
+            throw new Error(`You dont have any channels. Create one with <TODO>`);
+        }
+        return channelInfo;
+    }
+    async resolveChannelNameAsync(ctx, channelName) {
+        const { graphqlClient, app } = ctx;
+        return await ChannelQuery_1.ChannelQuery.viewUpdateChannelAsync(graphqlClient, {
+            appId: app.projectId,
+            channelName,
+        });
+    }
+    toMainMenuAction(action) {
+        if (action === MainMenuActions.CREATE_NEW) {
+            return MainMenuActions.CREATE_NEW;
+        }
+        else if (action === ManageRollout_1.ManageRolloutActions.EDIT || action === ManageRollout_1.ManageRolloutActions.END) {
+            return MainMenuActions.MANAGE_EXISTING;
+        }
+        else {
+            throw new Error(`Action not supported yet: ` + action);
+        }
+    }
+    async promptMenuActionAsync() {
+        const menuOptions = [MainMenuActions.CREATE_NEW, MainMenuActions.MANAGE_EXISTING];
+        const { menuOption: selectedMenuOption } = await (0, prompts_1.promptAsync)({
+            type: 'select',
+            name: 'menuOption',
+            message: `What would you like to do?`,
+            choices: menuOptions.map(menuOption => ({
+                value: menuOption,
+                title: menuOption,
+            })),
+        });
+        return selectedMenuOption;
+    }
+}
+exports.RolloutMainMenu = RolloutMainMenu;

package/build/rollout/actions/SelectRollout.js

@@ -2,22 +2,32 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SelectRollout = void 0;
 const SelectChannel_1 = require("../../channel/actions/SelectChannel");
-const branch_mapping_1 = require("../../channel/branch-mapping");
-const branch_mapping_2 = require("../branch-mapping");
+const ora_1 = require("../../ora");
+const branch_mapping_1 = require("../branch-mapping");
 /**
  * Select an existing rollout for the project.
  */
 class SelectRollout {
     async runAsync(ctx) {
-        const rolloutFilterPredicate = (channelInfo) => {
-            const branchMapping = (0, branch_mapping_1.getBranchMapping)(channelInfo.branchMapping);
-            return (0, branch_mapping_2.isRollout)(branchMapping);
+        let assetSpinner = null;
+        const afterEachFilterQuery = (_externalQueryParams, totalNodesFetched, _dataset, willFetchAgain) => {
+            if (willFetchAgain && !assetSpinner) {
+                assetSpinner = (0, ora_1.ora)().start('Fetching channels...');
+            }
+            if (assetSpinner) {
+                assetSpinner.text = `Fetched ${totalNodesFetched} channels`;
+            }
         };
-        const selectChannel = new SelectChannel_1.SelectChannel({
+        const selectChannelAction = new SelectChannel_1.SelectChannel({
             printedType: 'rollout',
-            filterPredicate: rolloutFilterPredicate,
+            filterPredicate: branch_mapping_1.isRollout,
+            afterEachFilterQuery,
         });
-        return await selectChannel.runAsync(ctx);
+        const channelInfo = await selectChannelAction.runAsync(ctx);
+        if (assetSpinner) {
+            assetSpinner.succeed(`Fetched all channels`);
+        }
+        return channelInfo;
     }
 }
 exports.SelectRollout = SelectRollout;

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

@@ -0,0 +1,36 @@
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
+import { EASUpdateAction, EASUpdateContext } from '../../eas-update/utils';
+import { RuntimeFragment, UpdateBranchBasicInfoFragment } from '../../graphql/generated';
+import { Connection } from '../../utils/relay';
+/**
+ * Select a runtime from a branch
+ */
+export declare class SelectRuntime implements EASUpdateAction<string> {
+    private branchInfo;
+    private options;
+    private printedType;
+    constructor(branchInfo: UpdateBranchBasicInfoFragment, options?: {
+        anotherBranchToIntersectRuntimesBy?: UpdateBranchBasicInfoFragment;
+    });
+    warnNoRuntime(): void;
+    formatCantFindRuntime(): string;
+    runAsync(ctx: EASUpdateContext): Promise<string>;
+    getNewestRuntimeAsync(graphqlClient: ExpoGraphqlClient, { appId, branchName, anotherBranchIdToIntersectRuntimesBy, }: {
+        appId: string;
+        branchName: string;
+        anotherBranchIdToIntersectRuntimesBy?: string;
+    }): Promise<Connection<RuntimeFragment> | null>;
+    displayLatestUpdateGroupAsync({ graphqlClient, appId, branchName, runtime, }: {
+        graphqlClient: ExpoGraphqlClient;
+        appId: string;
+        branchName: string;
+        runtime: RuntimeFragment;
+    }): Promise<string>;
+    selectRuntimesAsync(graphqlClient: ExpoGraphqlClient, { appId, branchName, anotherBranchIdToIntersectRuntimesBy, batchSize, }: {
+        appId: string;
+        branchName: string;
+        anotherBranchIdToIntersectRuntimesBy?: string;
+        batchSize?: number;
+    }): Promise<RuntimeFragment | null>;
+    promptForRuntimeAsync(): Promise<string>;
+}

package/build/rollout/actions/SelectRuntime.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectRuntime = 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("../../eas-update/utils");
+const RuntimeQuery_1 = require("../../graphql/queries/RuntimeQuery");
+const UpdateQuery_1 = require("../../graphql/queries/UpdateQuery");
+const log_1 = tslib_1.__importStar(require("../../log"));
+const prompts_1 = require("../../prompts");
+const relay_1 = require("../../utils/relay");
+const utils_2 = require("../utils");
+function beginSentence(phrase) {
+    if (typeof phrase !== 'string' || phrase.length === 0) {
+        return phrase; // Return the input without any modification if it's not a string or empty
+    }
+    return phrase.charAt(0).toUpperCase() + phrase.slice(1);
+}
+/**
+ * Select a runtime from a branch
+ */
+class SelectRuntime {
+    constructor(branchInfo, options = {}) {
+        this.branchInfo = branchInfo;
+        this.options = options;
+        this.printedType = options.anotherBranchToIntersectRuntimesBy
+            ? `compatible runtime`
+            : `runtime`;
+    }
+    warnNoRuntime() {
+        if (this.options.anotherBranchToIntersectRuntimesBy) {
+            const intersectBranchName = this.options.anotherBranchToIntersectRuntimesBy.name;
+            log_1.default.warn(`⚠️  Branches ${this.branchInfo.name} and ${intersectBranchName} dont have any updates with the same runtime.`);
+            // TODO(quin): write a learn more
+            log_1.default.warn(`Your updates could be misconfigured. ${(0, log_1.learnMore)('https://expo.fyi/todo')}`);
+        }
+        else {
+            // no runtime on branch means no updates published on branch
+            log_1.default.warn(`⚠️  There are no updates published on branch ${this.branchInfo.name}.`);
+        }
+    }
+    formatCantFindRuntime() {
+        return `🕵️ Not finding the update you were looking for? ${(0, log_1.learnMore)('https://expo.fyi/todo')}`;
+    }
+    async runAsync(ctx) {
+        var _a, _b;
+        const { nonInteractive, graphqlClient, app } = ctx;
+        const { projectId } = app;
+        if (nonInteractive) {
+            throw new utils_1.NonInteractiveError(`runtime selection cannot be run in non-interactive mode.`);
+        }
+        const newestRuntimeConnection = await this.getNewestRuntimeAsync(graphqlClient, {
+            appId: projectId,
+            branchName: this.branchInfo.name,
+            anotherBranchIdToIntersectRuntimesBy: (_a = this.options.anotherBranchToIntersectRuntimesBy) === null || _a === void 0 ? void 0 : _a.id,
+        });
+        if (!newestRuntimeConnection) {
+            log_1.default.addNewLineIfNone();
+            this.warnNoRuntime();
+            return await this.promptForRuntimeAsync();
+        }
+        const moreThanOneRuntime = newestRuntimeConnection.edges.length > 1;
+        log_1.default.log(`✅ ${beginSentence(this.printedType)}${moreThanOneRuntime ? 's' : ''} detected`);
+        if (!moreThanOneRuntime) {
+            const runtime = newestRuntimeConnection.edges[0].node;
+            const formattedRuntimeWithGroup = await this.displayLatestUpdateGroupAsync({
+                graphqlClient,
+                appId: projectId,
+                branchName: this.branchInfo.name,
+                runtime,
+            });
+            log_1.default.addNewLineIfNone();
+            log_1.default.log(formattedRuntimeWithGroup);
+            log_1.default.addNewLineIfNone();
+            const useRuntime = await (0, prompts_1.confirmAsync)({
+                message: `Target ${this.printedType} ${chalk_1.default.bold(runtime.version)}?`,
+            });
+            if (useRuntime) {
+                return runtime.version;
+            }
+            else {
+                log_1.default.newLine();
+                log_1.default.warn(this.formatCantFindRuntime());
+                return await this.promptForRuntimeAsync();
+            }
+        }
+        log_1.default.log(this.formatCantFindRuntime());
+        const selectedRuntime = await this.selectRuntimesAsync(graphqlClient, {
+            appId: projectId,
+            branchName: this.branchInfo.name,
+            anotherBranchIdToIntersectRuntimesBy: (_b = this.options.anotherBranchToIntersectRuntimesBy) === null || _b === void 0 ? void 0 : _b.id,
+        });
+        if (!selectedRuntime) {
+            throw new Error(`No ${this.printedType} selected`);
+        }
+        return selectedRuntime.version;
+    }
+    async getNewestRuntimeAsync(graphqlClient, { appId, branchName, anotherBranchIdToIntersectRuntimesBy, }) {
+        const connection = await RuntimeQuery_1.RuntimeQuery.getRuntimesOnBranchAsync(graphqlClient, {
+            appId,
+            name: branchName,
+            first: 1,
+            filter: {
+                branchId: anotherBranchIdToIntersectRuntimesBy,
+            },
+        });
+        const { edges } = connection;
+        if (edges.length === 0) {
+            return null;
+        }
+        return connection;
+    }
+    async displayLatestUpdateGroupAsync({ graphqlClient, appId, branchName, runtime, }) {
+        const updateGroups = await UpdateQuery_1.UpdateQuery.viewUpdateGroupsOnBranchAsync(graphqlClient, {
+            appId,
+            branchName,
+            limit: 1,
+            offset: 0,
+            filter: {
+                runtimeVersions: [runtime.version],
+            },
+        });
+        (0, assert_1.default)(updateGroups.length < 2, `Expected at most one update group. Received: ${JSON.stringify(updateGroups)}`);
+        return (0, utils_2.formatRuntimeWithUpdateGroup)(updateGroups[0], runtime);
+    }
+    async selectRuntimesAsync(graphqlClient, { appId, branchName, anotherBranchIdToIntersectRuntimesBy, 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,
+                filter: {
+                    branchId: anotherBranchIdToIntersectRuntimesBy,
+                },
+            });
+        };
+        const getTitleAsync = async (runtime) => {
+            return await this.displayLatestUpdateGroupAsync({
+                graphqlClient,
+                appId,
+                branchName,
+                runtime,
+            });
+        };
+        return await (0, relay_1.selectPaginatedAsync)({
+            queryAsync,
+            getTitleAsync,
+            printedType: 'target runtime',
+            pageSize: batchSize,
+        });
+    }
+    async promptForRuntimeAsync() {
+        log_1.default.log(`You can input a runtime manually then publish an update later.`);
+        const { runtimeVersion } = await (0, prompts_1.promptAsync)({
+            type: 'text',
+            name: 'runtimeVersion',
+            message: 'Input a runtime version:',
+            initial: '1.0.0',
+        });
+        return runtimeVersion;
+    }
+}
+exports.SelectRuntime = SelectRuntime;

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

@@ -1,4 +1,4 @@
-import { BranchMapping } from '../channel/branch-mapping';
+import { BranchMapping, BranchMappingAlwaysTrue } from '../channel/branch-mapping';
 import { UpdateChannelBasicInfoFragment } from '../graphql/generated';
 import { UpdateBranchObject, UpdateChannelObject } from '../graphql/queries/ChannelQuery';
 export type Rollout = LegacyRollout | ConstrainedRollout;
@@ -18,12 +18,52 @@ type LegacyRolloutInfo = {
     percentRolledOut: number;
     defaultBranchId: string;
 };
+export type RolloutBranchMapping = LegacyRolloutBranchMapping | ConstrainedRolloutBranchMapping;
+type RolloutNode = {
+    clientKey: 'rolloutToken';
+    branchMappingOperator: 'hash_lt';
+    operand: number;
+};
+type RuntimeVersionNode = {
+    clientKey: 'runtimeVersion';
+    branchMappingOperator: '==';
+    operand: string;
+};
+type RtvConstrainedRolloutNode = ['and', RolloutNode, RuntimeVersionNode] | ['and', RuntimeVersionNode, RolloutNode];
+export type LegacyRolloutBranchMapping = {
+    version: number;
+    data: [
+        {
+            branchId: string;
+            branchMappingLogic: RolloutNode;
+        },
+        {
+            branchId: string;
+            branchMappingLogic: BranchMappingAlwaysTrue;
+        }
+    ];
+};
+export type ConstrainedRolloutBranchMapping = {
+    version: number;
+    data: [
+        {
+            branchId: string;
+            branchMappingLogic: RtvConstrainedRolloutNode;
+        },
+        {
+            branchId: string;
+            branchMappingLogic: BranchMappingAlwaysTrue;
+        }
+    ];
+};
 export declare function isLegacyRolloutInfo(rollout: RolloutInfo): rollout is LegacyRolloutInfo;
 export declare function isConstrainedRolloutInfo(rollout: RolloutInfo): rollout is ConstrainedRolloutInfo;
 export declare function isConstrainedRollout(rollout: Rollout): rollout is ConstrainedRollout;
 export declare function getRolloutInfo(basicChannelInfo: UpdateChannelBasicInfoFragment): RolloutInfo;
-export declare function getRolloutInfoFromBranchMapping(branchMapping: BranchMapping): RolloutInfo;
+export declare function getRolloutInfoFromBranchMapping(branchMapping: RolloutBranchMapping): RolloutInfo;
 export declare function getRollout(channel: UpdateChannelObject): Rollout;
+export declare function composeRollout(rolloutInfo: RolloutInfo, defaultBranch: UpdateBranchObject, rolledOutBranch: UpdateBranchObject): Rollout;
+export declare function getRolloutBranchMapping(branchMappingString: string): RolloutBranchMapping;
 /**
  * Detect if a branch mapping is a rollout.
  *
@@ -75,6 +115,14 @@ export declare function getRollout(channel: UpdateChannelObject): Rollout;
     ],
   }
  */
-export declare function isRollout(branchMapping: BranchMapping): boolean;
-export declare function editRolloutBranchMapping(branchMapping: BranchMapping, percent: number): BranchMapping;
+export declare function isRolloutBranchMapping(branchMapping: BranchMapping): branchMapping is RolloutBranchMapping;
+export declare function isRollout(channelInfo: UpdateChannelBasicInfoFragment): boolean;
+export declare function createRolloutBranchMapping({ defaultBranchId, rolloutBranchId, percent, runtimeVersion, }: {
+    defaultBranchId: string;
+    rolloutBranchId: string;
+    percent: number;
+    runtimeVersion: string;
+}): ConstrainedRolloutBranchMapping;
+export declare function editRolloutBranchMapping(branchMapping: RolloutBranchMapping, percent: number): RolloutBranchMapping;
+export declare function assertRolloutBranchMapping(branchMapping: BranchMapping): asserts branchMapping is RolloutBranchMapping;
 export {};

package/build/rollout/branch-mapping.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.editRolloutBranchMapping = exports.isRollout = exports.getRollout = exports.getRolloutInfoFromBranchMapping = exports.getRolloutInfo = exports.isConstrainedRollout = exports.isConstrainedRolloutInfo = exports.isLegacyRolloutInfo = void 0;
+exports.assertRolloutBranchMapping = exports.editRolloutBranchMapping = exports.createRolloutBranchMapping = exports.isRollout = exports.isRolloutBranchMapping = exports.getRolloutBranchMapping = exports.composeRollout = exports.getRollout = exports.getRolloutInfoFromBranchMapping = exports.getRolloutInfo = exports.isConstrainedRollout = exports.isConstrainedRolloutInfo = exports.isLegacyRolloutInfo = void 0;
 const tslib_1 = require("tslib");
 const assert_1 = tslib_1.__importDefault(require("assert"));
 const branch_mapping_1 = require("../channel/branch-mapping");
@@ -18,13 +18,11 @@ function isConstrainedRollout(rollout) {
 }
 exports.isConstrainedRollout = isConstrainedRollout;
 function getRolloutInfo(basicChannelInfo) {
-    const branchMapping = (0, branch_mapping_1.getBranchMapping)(basicChannelInfo.branchMapping);
-    assertRollout(branchMapping);
-    return getRolloutInfoFromBranchMapping(branchMapping);
+    const rolloutBranchMapping = getRolloutBranchMapping(basicChannelInfo.branchMapping);
+    return getRolloutInfoFromBranchMapping(rolloutBranchMapping);
 }
 exports.getRolloutInfo = getRolloutInfo;
 function getRolloutInfoFromBranchMapping(branchMapping) {
-    assertRollout(branchMapping);
     const rolledOutBranchId = branchMapping.data[0].branchId;
     const defaultBranchId = branchMapping.data[1].branchId;
     if (isRtvConstrainedRollout(branchMapping)) {
@@ -62,20 +60,35 @@ function getRolloutInfoFromBranchMapping(branchMapping) {
 }
 exports.getRolloutInfoFromBranchMapping = getRolloutInfoFromBranchMapping;
 function getRollout(channel) {
-    const branchMapping = (0, branch_mapping_1.getBranchMapping)(channel.branchMapping);
-    assertRollout(branchMapping);
-    const rolledOutBranchId = branchMapping.data[0].branchId;
+    const rolloutBranchMapping = getRolloutBranchMapping(channel.branchMapping);
+    const rolledOutBranchId = rolloutBranchMapping.data[0].branchId;
     const rolledOutBranch = (0, utils_1.getUpdateBranch)(channel, rolledOutBranchId);
-    const defaultBranchId = branchMapping.data[1].branchId;
+    const defaultBranchId = rolloutBranchMapping.data[1].branchId;
     const defaultBranch = (0, utils_1.getUpdateBranch)(channel, defaultBranchId);
     const rolloutInfo = getRolloutInfo(channel);
+    return composeRollout(rolloutInfo, defaultBranch, rolledOutBranch);
+}
+exports.getRollout = getRollout;
+function composeRollout(rolloutInfo, defaultBranch, rolledOutBranch) {
+    if (rolloutInfo.defaultBranchId !== defaultBranch.id) {
+        throw new branch_mapping_1.BranchMappingValidationError(`Default branch id must match. Received: ${JSON.stringify(rolloutInfo)} ${defaultBranch.id}`);
+    }
+    if (rolloutInfo.rolledOutBranchId !== rolledOutBranch.id) {
+        throw new branch_mapping_1.BranchMappingValidationError(`Rolled out branch id must match. Received: ${JSON.stringify(rolloutInfo)} ${rolledOutBranch.id}`);
+    }
     return {
         ...rolloutInfo,
         rolledOutBranch,
         defaultBranch,
     };
 }
-exports.getRollout = getRollout;
+exports.composeRollout = composeRollout;
+function getRolloutBranchMapping(branchMappingString) {
+    const branchMapping = (0, branch_mapping_1.getBranchMapping)(branchMappingString);
+    assertRolloutBranchMapping(branchMapping);
+    return branchMapping;
+}
+exports.getRolloutBranchMapping = getRolloutBranchMapping;
 /**
  * Detect if a branch mapping is a rollout.
  *
@@ -127,13 +140,43 @@ exports.getRollout = getRollout;
     ],
   }
  */
-function isRollout(branchMapping) {
+function isRolloutBranchMapping(branchMapping) {
     return isUnconstrainedRollout(branchMapping) || isRtvConstrainedRollout(branchMapping);
 }
+exports.isRolloutBranchMapping = isRolloutBranchMapping;
+function isRollout(channelInfo) {
+    const branchMapping = (0, branch_mapping_1.getBranchMapping)(channelInfo.branchMapping);
+    return isRolloutBranchMapping(branchMapping);
+}
 exports.isRollout = isRollout;
+function createRolloutBranchMapping({ defaultBranchId, rolloutBranchId, percent, runtimeVersion, }) {
+    assertPercent(percent);
+    return {
+        version: 0,
+        data: [
+            {
+                branchId: rolloutBranchId,
+                branchMappingLogic: [
+                    'and',
+                    {
+                        operand: runtimeVersion,
+                        clientKey: 'runtimeVersion',
+                        branchMappingOperator: '==',
+                    },
+                    {
+                        operand: percent / 100,
+                        clientKey: 'rolloutToken',
+                        branchMappingOperator: 'hash_lt',
+                    },
+                ],
+            },
+            { branchId: defaultBranchId, branchMappingLogic: (0, branch_mapping_1.alwaysTrue)() },
+        ],
+    };
+}
+exports.createRolloutBranchMapping = createRolloutBranchMapping;
 function editRolloutBranchMapping(branchMapping, percent) {
-    (0, assert_1.default)(Number.isInteger(percent) && percent >= 0 && percent <= 100, 'The rollout percentage must be an integer between 0 and 100 inclusive.');
-    assertRollout(branchMapping);
+    assertPercent(percent);
     if (isRtvConstrainedRollout(branchMapping)) {
         return editRtvConstrainedRollout(branchMapping, percent);
     }
@@ -145,24 +188,18 @@ exports.editRolloutBranchMapping = editRolloutBranchMapping;
 function editRtvConstrainedRollout(branchMapping, percent) {
     const newBranchMapping = { ...branchMapping };
     const statementNode = newBranchMapping.data[0].branchMappingLogic;
-    (0, branch_mapping_1.assertStatement)(statementNode);
     const nodesFromStatement = (0, branch_mapping_1.getNodesFromStatement)(statementNode);
     const rolloutNode = nodesFromStatement.find(isRolloutNode);
     (0, assert_1.default)(rolloutNode, 'Rollout node must be defined.');
-    (0, branch_mapping_1.assertNodeObject)(rolloutNode);
     rolloutNode.operand = percent / 100;
     return newBranchMapping;
 }
 function editLegacyRollout(branchMapping, percent) {
     const newBranchMapping = { ...branchMapping };
     const rolloutNode = newBranchMapping.data[0].branchMappingLogic;
-    (0, branch_mapping_1.assertNodeObject)(rolloutNode);
     rolloutNode.operand = percent / 100;
     return newBranchMapping;
 }
-function assertRollout(branchMapping) {
-    (0, assert_1.default)(isRollout(branchMapping), 'Branch mapping node must be a rollout. Received: ' + JSON.stringify(branchMapping));
-}
 function isRtvConstrainedRollout(branchMapping) {
     if (branchMapping.data.length !== 2) {
         return false;
@@ -209,3 +246,15 @@ function isRolloutNode(node) {
     }
     return node.clientKey === 'rolloutToken' && node.branchMappingOperator === 'hash_lt';
 }
+function assertRolloutBranchMapping(branchMapping) {
+    if (!isRolloutBranchMapping(branchMapping)) {
+        throw new branch_mapping_1.BranchMappingValidationError('Branch mapping node must be a rollout. Received: ' + JSON.stringify(branchMapping));
+    }
+}
+exports.assertRolloutBranchMapping = assertRolloutBranchMapping;
+function assertPercent(percent) {
+    const isPercent = Number.isInteger(percent) && percent >= 0 && percent <= 100;
+    if (!isPercent) {
+        throw new branch_mapping_1.BranchMappingValidationError(`The percentage must be an integer between 0 and 100 inclusive. Received: ${percent}`);
+    }
+}

package/build/rollout/utils.d.ts

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