eas-cli 3.17.1 → 3.18.1

package/build/rollout/branch-mapping.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+const utils_1 = require("../channel/utils");
+function isLegacyRolloutInfo(rollout) {
+    return !isConstrainedRolloutInfo(rollout);
+}
+exports.isLegacyRolloutInfo = isLegacyRolloutInfo;
+function isConstrainedRolloutInfo(rollout) {
+    return 'runtimeVersion' in rollout;
+}
+exports.isConstrainedRolloutInfo = isConstrainedRolloutInfo;
+function isConstrainedRollout(rollout) {
+    return isConstrainedRolloutInfo(rollout);
+}
+exports.isConstrainedRollout = isConstrainedRollout;
+function getRolloutInfo(basicChannelInfo) {
+    const rolloutBranchMapping = getRolloutBranchMapping(basicChannelInfo.branchMapping);
+    return getRolloutInfoFromBranchMapping(rolloutBranchMapping);
+}
+exports.getRolloutInfo = getRolloutInfo;
+function getRolloutInfoFromBranchMapping(branchMapping) {
+    const rolledOutBranchId = branchMapping.data[0].branchId;
+    const defaultBranchId = branchMapping.data[1].branchId;
+    if (isRtvConstrainedRollout(branchMapping)) {
+        const statementNode = branchMapping.data[0].branchMappingLogic;
+        (0, branch_mapping_1.assertStatement)(statementNode);
+        const nodesFromStatement = (0, branch_mapping_1.getNodesFromStatement)(statementNode);
+        const runtimeVersionNode = nodesFromStatement.find(isRuntimeVersionNode);
+        (0, assert_1.default)(runtimeVersionNode, 'Runtime version node must be defined.');
+        (0, branch_mapping_1.assertNodeObject)(runtimeVersionNode);
+        const runtimeVersion = runtimeVersionNode.operand;
+        (0, branch_mapping_1.assertString)(runtimeVersion);
+        const rolloutNode = nodesFromStatement.find(isRolloutNode);
+        (0, assert_1.default)(rolloutNode, 'Rollout node must be defined.');
+        (0, branch_mapping_1.assertNodeObject)(rolloutNode);
+        const operand = rolloutNode.operand;
+        (0, branch_mapping_1.assertNumber)(operand);
+        return {
+            rolledOutBranchId,
+            percentRolledOut: operand * 100,
+            runtimeVersion,
+            defaultBranchId,
+        };
+    }
+    else {
+        const rolloutNode = branchMapping.data[0].branchMappingLogic;
+        (0, branch_mapping_1.assertNodeObject)(rolloutNode);
+        const operand = rolloutNode.operand;
+        (0, branch_mapping_1.assertNumber)(operand);
+        return {
+            rolledOutBranchId,
+            percentRolledOut: operand * 100,
+            defaultBranchId,
+        };
+    }
+}
+exports.getRolloutInfoFromBranchMapping = getRolloutInfoFromBranchMapping;
+function getRollout(channel) {
+    const rolloutBranchMapping = getRolloutBranchMapping(channel.branchMapping);
+    const rolledOutBranchId = rolloutBranchMapping.data[0].branchId;
+    const rolledOutBranch = (0, utils_1.getUpdateBranch)(channel, rolledOutBranchId);
+    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.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.
+ *
+ * Types of rollout:
+ * 1. Legacy unconstrained rollout:
+ * Maps to a rollout branch via a rollout token
+ * Falls back to a default branch
+ *
+ * Example:
+ * {
+    version: 0,
+    data: [
+      {
+        branchId: uuidv4(),
+        branchMappingLogic: {
+          operand: 10 / 100,
+          clientKey: 'rolloutToken',
+          branchMappingOperator: hashLtOperator(),
+        },
+      },
+      { branchId: uuidv4(), branchMappingLogic: alwaysTrue() },
+    ],
+  }
+  *
+  * 2. RTV constrained rollout:
+  * Maps to a rollout branch via a rollout token, constrained by runtime version
+  * Falls back to a default branch
+  *
+  * Example:
+  * {
+    version: 0,
+    data: [
+      {
+        branchId: uuidv4(),
+        branchMappingLogic: andStatement([
+          {
+            operand: '1.0.0',
+            clientKey: 'runtimeVersion',
+            branchMappingOperator: equalsOperator(),
+          },
+          {
+            operand: 10 / 100,
+            clientKey: 'rolloutToken',
+            branchMappingOperator: hashLtOperator(),
+          },
+        ]),
+      },
+      { branchId: uuidv4(), branchMappingLogic: alwaysTrue() },
+    ],
+  }
+ */
+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) {
+    assertPercent(percent);
+    if (isRtvConstrainedRollout(branchMapping)) {
+        return editRtvConstrainedRollout(branchMapping, percent);
+    }
+    else {
+        return editLegacyRollout(branchMapping, percent);
+    }
+}
+exports.editRolloutBranchMapping = editRolloutBranchMapping;
+function editRtvConstrainedRollout(branchMapping, percent) {
+    const newBranchMapping = { ...branchMapping };
+    const statementNode = newBranchMapping.data[0].branchMappingLogic;
+    const nodesFromStatement = (0, branch_mapping_1.getNodesFromStatement)(statementNode);
+    const rolloutNode = nodesFromStatement.find(isRolloutNode);
+    (0, assert_1.default)(rolloutNode, 'Rollout node must be defined.');
+    rolloutNode.operand = percent / 100;
+    return newBranchMapping;
+}
+function editLegacyRollout(branchMapping, percent) {
+    const newBranchMapping = { ...branchMapping };
+    const rolloutNode = newBranchMapping.data[0].branchMappingLogic;
+    rolloutNode.operand = percent / 100;
+    return newBranchMapping;
+}
+function isRtvConstrainedRollout(branchMapping) {
+    if (branchMapping.data.length !== 2) {
+        return false;
+    }
+    const hasRtvRolloutNode = isRtvConstrainedRolloutNode(branchMapping.data[0].branchMappingLogic);
+    const defaultsToAlwaysTrueNode = (0, branch_mapping_1.isAlwaysTrue)(branchMapping.data[1].branchMappingLogic);
+    return hasRtvRolloutNode && defaultsToAlwaysTrueNode;
+}
+function isRtvConstrainedRolloutNode(node) {
+    if (!(0, branch_mapping_1.isStatement)(node) || !(0, branch_mapping_1.isAndStatement)(node)) {
+        return false;
+    }
+    const statementNodes = (0, branch_mapping_1.getNodesFromStatement)(node);
+    if (statementNodes.length !== 2) {
+        return false;
+    }
+    const hasRuntimeVersionNode = statementNodes.some(isRuntimeVersionNode);
+    const hasRolloutNode = statementNodes.some(isRolloutNode);
+    return hasRuntimeVersionNode && hasRolloutNode;
+}
+function isUnconstrainedRollout(branchMapping) {
+    if (branchMapping.data.length !== 2) {
+        return false;
+    }
+    const hasRolloutNode = isRolloutNode(branchMapping.data[0].branchMappingLogic);
+    const defaultsToAlwaysTrueNode = (0, branch_mapping_1.isAlwaysTrue)(branchMapping.data[1].branchMappingLogic);
+    return hasRolloutNode && defaultsToAlwaysTrueNode;
+}
+function isRuntimeVersionNode(node) {
+    if (typeof node === 'string') {
+        return false;
+    }
+    if (Array.isArray(node)) {
+        return false;
+    }
+    return node.clientKey === 'runtimeVersion' && node.branchMappingOperator === '==';
+}
+function isRolloutNode(node) {
+    if (typeof node === 'string') {
+        return false;
+    }
+    if (Array.isArray(node)) {
+        return false;
+    }
+    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,53 +1,10 @@
-import { BranchMapping } from '../channel/branch-mapping';
-/**
- * Detect if a branch mapping is a rollout.
- *
- * Types of rollout:
- * 1. Legacy unconstrained rollout:
- * Maps to a rollout branch via a rollout token
- * Falls back to a default branch
- *
- * Example:
- * {
-    version: 0,
-    data: [
-      {
-        branchId: uuidv4(),
-        branchMappingLogic: {
-          operand: 10 / 100,
-          clientKey: 'rolloutToken',
-          branchMappingOperator: hashLtOperator(),
-        },
-      },
-      { branchId: uuidv4(), branchMappingLogic: alwaysTrue() },
-    ],
-  }
-  *
-  * 2. RTV constrained rollout:
-  * Maps to a rollout branch via a rollout token, constrained by runtime version
-  * Falls back to a default branch
-  *
-  * Example:
-  * {
-    version: 0,
-    data: [
-      {
-        branchId: uuidv4(),
-        branchMappingLogic: andStatement([
-          {
-            operand: '1.0.0',
-            clientKey: 'runtimeVersion',
-            branchMappingOperator: equalsOperator(),
-          },
-          {
-            operand: 10 / 100,
-            clientKey: 'rolloutToken',
-            branchMappingOperator: hashLtOperator(),
-          },
-        ]),
-      },
-      { branchId: uuidv4(), branchMappingLogic: alwaysTrue() },
-    ],
-  }
- */
-export declare function isRollout(branchMapping: BranchMapping): boolean;
+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 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>;

package/build/rollout/utils.js

@@ -1,105 +1,89 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRollout = void 0;
-const branch_mapping_1 = require("../channel/branch-mapping");
-/**
- * Detect if a branch mapping is a rollout.
- *
- * Types of rollout:
- * 1. Legacy unconstrained rollout:
- * Maps to a rollout branch via a rollout token
- * Falls back to a default branch
- *
- * Example:
- * {
-    version: 0,
-    data: [
-      {
-        branchId: uuidv4(),
-        branchMappingLogic: {
-          operand: 10 / 100,
-          clientKey: 'rolloutToken',
-          branchMappingOperator: hashLtOperator(),
-        },
-      },
-      { branchId: uuidv4(), branchMappingLogic: alwaysTrue() },
-    ],
-  }
-  *
-  * 2. RTV constrained rollout:
-  * Maps to a rollout branch via a rollout token, constrained by runtime version
-  * Falls back to a default branch
-  *
-  * Example:
-  * {
-    version: 0,
-    data: [
-      {
-        branchId: uuidv4(),
-        branchMappingLogic: andStatement([
-          {
-            operand: '1.0.0',
-            clientKey: 'runtimeVersion',
-            branchMappingOperator: equalsOperator(),
-          },
-          {
-            operand: 10 / 100,
-            clientKey: 'rolloutToken',
-            branchMappingOperator: hashLtOperator(),
-          },
-        ]),
-      },
-      { branchId: uuidv4(), branchMappingLogic: alwaysTrue() },
-    ],
-  }
- */
-function isRollout(branchMapping) {
-    return isUnconstrainedRollout(branchMapping) || isRtvConstrainedRollout(branchMapping);
+exports.promptForRolloutPercentAsync = exports.formatRuntimeWithUpdateGroup = exports.formatBranchWithUpdateGroup = exports.displayRolloutDetails = exports.printRollout = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const log_1 = tslib_1.__importDefault(require("../log"));
+const prompts_1 = require("../prompts");
+const utils_1 = require("../update/utils");
+const formatFields_1 = tslib_1.__importDefault(require("../utils/formatFields"));
+const branch_mapping_1 = require("./branch-mapping");
+function printRollout(channel) {
+    const rollout = (0, branch_mapping_1.getRollout)(channel);
+    displayRolloutDetails(channel.name, rollout);
 }
-exports.isRollout = isRollout;
-function isRtvConstrainedRollout(branchMapping) {
-    if (branchMapping.data.length !== 2) {
-        return false;
-    }
-    const hasRtvRolloutNode = isRtvConstrainedRolloutNode(branchMapping.data[0].branchMappingLogic);
-    const defaultsToAlwaysTrueNode = (0, branch_mapping_1.isAlwaysTrue)(branchMapping.data[1].branchMappingLogic);
-    return hasRtvRolloutNode && defaultsToAlwaysTrueNode;
+exports.printRollout = printRollout;
+function displayRolloutDetails(channelName, rollout) {
+    const rolledOutPercent = rollout.percentRolledOut;
+    log_1.default.newLine();
+    log_1.default.log(chalk_1.default.bold('🚀 Rollout:'));
+    log_1.default.log((0, formatFields_1.default)([
+        { label: 'Channel', value: channelName },
+        ...((0, branch_mapping_1.isConstrainedRollout)(rollout)
+            ? [{ label: 'Runtime Version', value: rollout.runtimeVersion }]
+            : []),
+        {
+            label: 'Branches',
+            value: `${rollout.rolledOutBranch.name} (${rolledOutPercent}%), ${rollout.defaultBranch.name} (${100 - rolledOutPercent}%)`,
+        },
+    ]));
+    log_1.default.addNewLineIfNone();
 }
-function isRtvConstrainedRolloutNode(node) {
-    if (!(0, branch_mapping_1.isStatement)(node) || !(0, branch_mapping_1.isAndStatement)(node)) {
-        return false;
+exports.displayRolloutDetails = displayRolloutDetails;
+function formatBranchWithUpdateGroup(maybeUpdateGroup, branch, percentRolledOut) {
+    const lines = [];
+    lines.push(chalk_1.default.bold(`🍽️  Served by branch ${chalk_1.default.bold(branch.name)} (${percentRolledOut}%)`));
+    if (!maybeUpdateGroup) {
+        lines.push(`No updates for target runtime`);
     }
-    const statementNodes = (0, branch_mapping_1.getNodesFromStatement)(node);
-    if (statementNodes.length !== 2) {
-        return false;
-    }
-    const hasRuntimeVersionNode = statementNodes.some(isRuntimeVersionNode);
-    const hasRolloutNode = statementNodes.some(isRolloutNode);
-    return hasRuntimeVersionNode && hasRolloutNode;
-}
-function isUnconstrainedRollout(branchMapping) {
-    if (branchMapping.data.length !== 2) {
-        return false;
+    else {
+        const [updateGroupDescription] = (0, utils_1.getUpdateGroupDescriptions)([maybeUpdateGroup]);
+        lines.push(...formatUpdateGroup(updateGroupDescription));
     }
-    const hasRolloutNode = isRolloutNode(branchMapping.data[0].branchMappingLogic);
-    const defaultsToAlwaysTrueNode = (0, branch_mapping_1.isAlwaysTrue)(branchMapping.data[1].branchMappingLogic);
-    return hasRolloutNode && defaultsToAlwaysTrueNode;
+    return lines.join('\n    ');
 }
-function isRuntimeVersionNode(node) {
-    if (typeof node === 'string') {
-        return false;
+exports.formatBranchWithUpdateGroup = formatBranchWithUpdateGroup;
+function formatRuntimeWithUpdateGroup(maybeUpdateGroup, runtime) {
+    const lines = [];
+    lines.push(chalk_1.default.bold(`🍽️  Served by runtime ${chalk_1.default.bold(runtime.version)}:`));
+    if (!maybeUpdateGroup) {
+        lines.push(`No updates published for this runtime`);
     }
-    if (Array.isArray(node)) {
-        return false;
+    else {
+        const [updateGroupDescription] = (0, utils_1.getUpdateGroupDescriptions)([maybeUpdateGroup]);
+        lines.push(...formatUpdateGroup(updateGroupDescription));
     }
-    return node.clientKey === 'runtimeVersion' && node.branchMappingOperator === '==';
+    return lines.join('\n    ');
 }
-function isRolloutNode(node) {
-    if (typeof node === 'string') {
-        return false;
-    }
-    if (Array.isArray(node)) {
-        return false;
-    }
-    return node.clientKey === 'rolloutToken' && node.branchMappingOperator === 'hash_lt';
+exports.formatRuntimeWithUpdateGroup = formatRuntimeWithUpdateGroup;
+function formatUpdateGroup(updateGroup) {
+    var _a, _b, _c, _d;
+    const lines = [];
+    const formattedLines = (0, formatFields_1.default)([
+        { label: 'Message', value: (_a = updateGroup.message) !== null && _a !== void 0 ? _a : 'N/A' },
+        { label: 'Runtime Version', value: (_b = updateGroup.runtimeVersion) !== null && _b !== void 0 ? _b : 'N/A' },
+        { label: 'Platforms', value: (_c = updateGroup.platforms) !== null && _c !== void 0 ? _c : 'N/A' },
+        { label: 'Group ID', value: (_d = updateGroup.group) !== null && _d !== void 0 ? _d : 'N/A' },
+    ]).split('\n');
+    lines.push(...formattedLines);
+    return lines;
+}
+async function promptForRolloutPercentAsync({ promptMessage, }) {
+    const { name: rolloutPercent } = await (0, prompts_1.promptAsync)({
+        type: 'text',
+        name: 'name',
+        format: value => {
+            return parseInt(value, 10);
+        },
+        message: promptMessage,
+        initial: 0,
+        validate: (rolloutPercent) => {
+            const floatValue = parseFloat(rolloutPercent);
+            return Number.isInteger(floatValue) && floatValue >= 0 && floatValue <= 100
+                ? true
+                : 'The rollout percentage must be an integer between 0 and 100 inclusive.';
+        },
+    });
+    return rolloutPercent;
 }
+exports.promptForRolloutPercentAsync = promptForRolloutPercentAsync;

package/build/update/configure.d.ts

@@ -1,10 +1,15 @@
 import { ExpoConfig } from '@expo/config-types';
+import { Workflow } from '@expo/eas-build-job';
 import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
 import { RequestedPlatform } from '../platform';
-export declare const DEFAULT_MANAGED_RUNTIME_VERSION: {
+export declare const DEFAULT_MANAGED_RUNTIME_VERSION_GTE_SDK_49: {
+    readonly policy: "appVersion";
+};
+export declare const DEFAULT_MANAGED_RUNTIME_VERSION_LTE_SDK_48: {
     readonly policy: "sdkVersion";
 };
 export declare const DEFAULT_BARE_RUNTIME_VERSION: "1.0.0";
+export declare function getDefaultRuntimeVersion(workflow: Workflow, sdkVersion: string | undefined): NonNullable<ExpoConfig['runtimeVersion']>;
 /**
  * Make sure EAS Build profiles are configured to work with EAS Update by adding channels to build profiles.
  */

package/build/update/configure.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureUseClassicUpdatesIsRemovedAsync = exports.ensureEASUpdateIsConfiguredAsync = exports.ensureEASUpdateIsConfiguredInEasJsonAsync = exports.DEFAULT_BARE_RUNTIME_VERSION = exports.DEFAULT_MANAGED_RUNTIME_VERSION = void 0;
+exports.ensureUseClassicUpdatesIsRemovedAsync = exports.ensureEASUpdateIsConfiguredAsync = exports.ensureEASUpdateIsConfiguredInEasJsonAsync = exports.getDefaultRuntimeVersion = exports.DEFAULT_BARE_RUNTIME_VERSION = exports.DEFAULT_MANAGED_RUNTIME_VERSION_LTE_SDK_48 = exports.DEFAULT_MANAGED_RUNTIME_VERSION_GTE_SDK_49 = void 0;
 const tslib_1 = require("tslib");
 const eas_build_job_1 = require("@expo/eas-build-job");
 const eas_json_1 = require("@expo/eas-json");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const semver_1 = tslib_1.__importDefault(require("semver"));
 const api_1 = require("../api");
 const generated_1 = require("../graphql/generated");
 const log_1 = tslib_1.__importStar(require("../log"));
@@ -16,13 +17,20 @@ const workflow_1 = require("../project/workflow");
 const prompts_1 = require("../prompts");
 const UpdatesModule_1 = require("./android/UpdatesModule");
 const UpdatesModule_2 = require("./ios/UpdatesModule");
-exports.DEFAULT_MANAGED_RUNTIME_VERSION = { policy: 'sdkVersion' };
+exports.DEFAULT_MANAGED_RUNTIME_VERSION_GTE_SDK_49 = { policy: 'appVersion' };
+exports.DEFAULT_MANAGED_RUNTIME_VERSION_LTE_SDK_48 = { policy: 'sdkVersion' };
 exports.DEFAULT_BARE_RUNTIME_VERSION = '1.0.0';
-function getDefaultRuntimeVersion(workflow) {
-    return workflow === eas_build_job_1.Workflow.GENERIC
-        ? exports.DEFAULT_BARE_RUNTIME_VERSION
-        : exports.DEFAULT_MANAGED_RUNTIME_VERSION;
+function getDefaultRuntimeVersion(workflow, sdkVersion) {
+    if (workflow === eas_build_job_1.Workflow.GENERIC) {
+        return exports.DEFAULT_BARE_RUNTIME_VERSION;
+    }
+    // Expo Go supports loading appVersion SDK 49 and above
+    const hasSupportedSdk = sdkVersion && semver_1.default.satisfies(sdkVersion, '>= 49.0.0');
+    return hasSupportedSdk
+        ? exports.DEFAULT_MANAGED_RUNTIME_VERSION_GTE_SDK_49
+        : exports.DEFAULT_MANAGED_RUNTIME_VERSION_LTE_SDK_48;
 }
+exports.getDefaultRuntimeVersion = getDefaultRuntimeVersion;
 function isRuntimeEqual(runtimeVersionA, runtimeVersionB) {
     if (typeof runtimeVersionA === 'string' && typeof runtimeVersionB === 'string') {
         return runtimeVersionA === runtimeVersionB;
@@ -81,8 +89,10 @@ async function ensureEASUpdatesIsConfiguredInExpoConfigAsync({ exp, projectId, p
     let iosRuntimeVersion = (_e = (_d = exp.ios) === null || _d === void 0 ? void 0 : _d.runtimeVersion) !== null && _e !== void 0 ? _e : exp.runtimeVersion;
     if ((['all', 'android'].includes(platform) && !androidRuntimeVersion) ||
         (['all', 'ios'].includes(platform) && !iosRuntimeVersion)) {
-        androidRuntimeVersion = androidRuntimeVersion !== null && androidRuntimeVersion !== void 0 ? androidRuntimeVersion : getDefaultRuntimeVersion(workflows.android);
-        iosRuntimeVersion = iosRuntimeVersion !== null && iosRuntimeVersion !== void 0 ? iosRuntimeVersion : getDefaultRuntimeVersion(workflows.ios);
+        androidRuntimeVersion =
+            androidRuntimeVersion !== null && androidRuntimeVersion !== void 0 ? androidRuntimeVersion : getDefaultRuntimeVersion(workflows.android, exp.sdkVersion);
+        iosRuntimeVersion =
+            iosRuntimeVersion !== null && iosRuntimeVersion !== void 0 ? iosRuntimeVersion : getDefaultRuntimeVersion(workflows.ios, exp.sdkVersion);
         if (platform === 'all' && isRuntimeEqual(androidRuntimeVersion, iosRuntimeVersion)) {
             modifyConfig.runtimeVersion = androidRuntimeVersion;
         }

package/build/update/republish.d.ts

@@ -0,0 +1,26 @@
+import { ExpoConfig } from '@expo/config';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { Update } from '../graphql/generated';
+export type UpdateToRepublish = {
+    groupId: string;
+    branchId: string;
+    branchName: string;
+} & Pick<Update, 'message' | 'runtimeVersion' | 'manifestFragment' | 'platform' | 'gitCommitHash' | 'codeSigningInfo'>;
+/**
+ * @param updatesToPublish The update group to republish
+ * @param targetBranch The branch to repubish the update group on
+ */
+export declare function republishAsync({ graphqlClient, app, updatesToPublish, targetBranch, updateMessage, json, }: {
+    graphqlClient: ExpoGraphqlClient;
+    app: {
+        exp: ExpoConfig;
+        projectId: string;
+    };
+    updatesToPublish: UpdateToRepublish[];
+    targetBranch: {
+        branchName: string;
+        branchId: string;
+    };
+    updateMessage: string;
+    json?: boolean;
+}): Promise<void>;