eas-cli 3.17.0 → 3.18.0

package/build/project/ios/target.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getApplePlatformFromDeviceFamily = exports.getApplePlatformFromSdkRoot = exports.getApplePlatformFromTarget = exports.findTargetByName = exports.findApplicationTarget = exports.resolveTargetsAsync = exports.resolveBareProjectTargetsAsync = exports.resolveMangedProjectTargetsAsync = void 0;
+exports.getApplePlatformFromDeviceFamily = exports.getApplePlatformFromSdkRoot = exports.getApplePlatformFromTarget = exports.findTargetByName = exports.findApplicationTarget = exports.resolveTargetsAsync = exports.resolveBareProjectTargetsAsync = exports.resolveManagedProjectTargetsAsync = void 0;
 const tslib_1 = require("tslib");
 const config_plugins_1 = require("@expo/config-plugins");
 const eas_build_job_1 = require("@expo/eas-build-job");
@@ -15,7 +15,7 @@ const AppExtensionsConfigSchema = joi_1.default.array().items(joi_1.default.obje
     parentBundleIdentifier: joi_1.default.string(),
     entitlements: joi_1.default.object(),
 }));
-async function resolveMangedProjectTargetsAsync({ exp, projectDir, xcodeBuildContext, env, }) {
+async function resolveManagedProjectTargetsAsync({ exp, projectDir, xcodeBuildContext, env, }) {
     var _a, _b, _c, _d, _e, _f;
     const { buildScheme, buildConfiguration } = xcodeBuildContext;
     const applicationTargetName = buildScheme;
@@ -52,7 +52,7 @@ async function resolveMangedProjectTargetsAsync({ exp, projectDir, xcodeBuildCon
         ...extensionsTargets,
     ];
 }
-exports.resolveMangedProjectTargetsAsync = resolveMangedProjectTargetsAsync;
+exports.resolveManagedProjectTargetsAsync = resolveManagedProjectTargetsAsync;
 async function resolveBareProjectTargetsAsync({ exp, projectDir, xcodeBuildContext, }) {
     const { buildScheme, buildConfiguration } = xcodeBuildContext;
     const result = [];
@@ -93,7 +93,7 @@ async function resolveTargetsAsync(opts) {
         return await resolveBareProjectTargetsAsync(opts);
     }
     else if (workflow === eas_build_job_1.Workflow.MANAGED) {
-        return await resolveMangedProjectTargetsAsync(opts);
+        return await resolveManagedProjectTargetsAsync(opts);
     }
     else {
         throw new Error(`Unknown workflow: ${workflow}`);

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

@@ -0,0 +1,8 @@
+import { EASUpdateAction, EASUpdateContext } from '../../eas-update/utils';
+import { UpdateChannelBasicInfoFragment } from '../../graphql/generated';
+/**
+ * Select an existing rollout for the project.
+ */
+export declare class SelectRollout implements EASUpdateAction<UpdateChannelBasicInfoFragment | null> {
+    runAsync(ctx: EASUpdateContext): Promise<UpdateChannelBasicInfoFragment | null>;
+}

package/build/rollout/actions/SelectRollout.js

@@ -0,0 +1,23 @@
+"use strict";
+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");
+/**
+ * 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);
+        };
+        const selectChannel = new SelectChannel_1.SelectChannel({
+            printedType: 'rollout',
+            filterPredicate: rolloutFilterPredicate,
+        });
+        return await selectChannel.runAsync(ctx);
+    }
+}
+exports.SelectRollout = SelectRollout;

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

@@ -0,0 +1,80 @@
+import { BranchMapping } from '../channel/branch-mapping';
+import { UpdateChannelBasicInfoFragment } from '../graphql/generated';
+import { UpdateBranchObject, UpdateChannelObject } from '../graphql/queries/ChannelQuery';
+export type Rollout = LegacyRollout | ConstrainedRollout;
+export type RolloutInfo = LegacyRolloutInfo | ConstrainedRolloutInfo;
+type ConstrainedRollout = LegacyRollout & {
+    runtimeVersion: string;
+};
+type LegacyRollout = {
+    rolledOutBranch: UpdateBranchObject;
+    defaultBranch: UpdateBranchObject;
+} & LegacyRolloutInfo;
+type ConstrainedRolloutInfo = LegacyRolloutInfo & {
+    runtimeVersion: string;
+};
+type LegacyRolloutInfo = {
+    rolledOutBranchId: string;
+    percentRolledOut: number;
+    defaultBranchId: string;
+};
+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 getRollout(channel: UpdateChannelObject): Rollout;
+/**
+ * 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;
+export declare function editRolloutBranchMapping(branchMapping: BranchMapping, percent: number): BranchMapping;
+export {};

package/build/rollout/branch-mapping.js

@@ -0,0 +1,211 @@
+"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;
+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 branchMapping = (0, branch_mapping_1.getBranchMapping)(basicChannelInfo.branchMapping);
+    assertRollout(branchMapping);
+    return getRolloutInfoFromBranchMapping(branchMapping);
+}
+exports.getRolloutInfo = getRolloutInfo;
+function getRolloutInfoFromBranchMapping(branchMapping) {
+    assertRollout(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 branchMapping = (0, branch_mapping_1.getBranchMapping)(channel.branchMapping);
+    assertRollout(branchMapping);
+    const rolledOutBranchId = branchMapping.data[0].branchId;
+    const rolledOutBranch = (0, utils_1.getUpdateBranch)(channel, rolledOutBranchId);
+    const defaultBranchId = branchMapping.data[1].branchId;
+    const defaultBranch = (0, utils_1.getUpdateBranch)(channel, defaultBranchId);
+    const rolloutInfo = getRolloutInfo(channel);
+    return {
+        ...rolloutInfo,
+        rolledOutBranch,
+        defaultBranch,
+    };
+}
+exports.getRollout = getRollout;
+/**
+ * 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.isRollout = isRollout;
+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);
+    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;
+    (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;
+    }
+    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';
+}

package/build/rollout/utils.d.ts

@@ -1,53 +1,3 @@
-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 { UpdateChannelObject } from '../graphql/queries/ChannelQuery';
+export declare function printRollout(channel: UpdateChannelObject): void;
+export declare function printBranch(channel: UpdateChannelObject): void;

package/build/rollout/utils.js

@@ -1,105 +1,44 @@
 "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(),
+exports.printBranch = 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 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);
+    const rolledOutPercent = rollout.percentRolledOut;
+    log_1.default.addNewLineIfNone();
+    log_1.default.log(chalk_1.default.bold('Rollout:'));
+    log_1.default.log((0, formatFields_1.default)([
+        { label: 'Channel', value: channel.name },
+        ...((0, branch_mapping_1.isConstrainedRollout)(rollout)
+            ? [{ label: 'Runtime Version', value: rollout.runtimeVersion }]
+            : []),
+        {
+            label: 'Branches',
+            value: `${rollout.rolledOutBranch.name} (${rolledOutPercent}%), ${rollout.defaultBranch.name} (${100 - rolledOutPercent}%)`,
         },
-      },
-      { 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);
+    ]));
+    log_1.default.addNewLineIfNone();
 }
-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;
-}
-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';
+exports.printRollout = printRollout;
+function printBranch(channel) {
+    const rollout = (0, branch_mapping_1.getRollout)(channel);
+    const rolledOutPercent = rollout.percentRolledOut;
+    log_1.default.addNewLineIfNone();
+    log_1.default.log(chalk_1.default.bold('Rollout:'));
+    log_1.default.log((0, formatFields_1.default)([
+        { label: 'Channel', value: channel.name },
+        ...((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();
 }
+exports.printBranch = printBranch;

package/build/utils/profiles.d.ts

@@ -6,10 +6,11 @@ export type ProfileData<T extends ProfileType> = {
     platform: Platform;
     profileName: string;
 };
-export declare function getProfilesAsync<T extends ProfileType>({ easJsonAccessor, platforms, profileName, type, }: {
+export declare function getProfilesAsync<T extends ProfileType>({ easJsonAccessor, platforms, profileName, type, projectDir, }: {
     easJsonAccessor: EasJsonAccessor;
     platforms: Platform[];
     profileName?: string;
+    projectDir: string;
     type: T;
 }): Promise<ProfileData<T>[]>;
 /**

package/build/utils/profiles.js

@@ -3,14 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.maybePrintBuildProfileDeprecationWarningsAsync = exports.clearHasPrintedDeprecationWarnings = exports.getProfilesAsync = void 0;
 const tslib_1 = require("tslib");
 const eas_json_1 = require("@expo/eas-json");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const semver_1 = tslib_1.__importDefault(require("semver"));
 const log_1 = tslib_1.__importStar(require("../log"));
-async function getProfilesAsync({ easJsonAccessor, platforms, profileName, type, }) {
+async function getProfilesAsync({ easJsonAccessor, platforms, profileName, type, projectDir, }) {
     const results = platforms.map(async function (platform) {
-        const profile = await readProfileAsync({
+        const profile = await readProfileWithOverridesAsync({
             easJsonAccessor,
             platform,
             type,
             profileName,
+            projectDir,
         });
         return {
             profile,
@@ -21,10 +25,38 @@ async function getProfilesAsync({ easJsonAccessor, platforms, profileName, type,
     return await Promise.all(results);
 }
 exports.getProfilesAsync = getProfilesAsync;
-async function readProfileAsync({ easJsonAccessor, platform, type, profileName, }) {
+async function setNodeVersionFromFileAsync(projectDir, profile) {
+    if (profile === null || profile === void 0 ? void 0 : profile.node) {
+        return;
+    }
+    const nodeVersion = await getNodeVersionFromFileAsync(projectDir);
+    if (nodeVersion) {
+        log_1.default.log(`The EAS build profile does not specify a Node.js version. Using the version specified in .nvmrc: ${nodeVersion} `);
+        profile.node = nodeVersion;
+    }
+}
+async function getNodeVersionFromFileAsync(projectDir) {
+    const nvmrcPath = path_1.default.join(projectDir, '.nvmrc');
+    if (!(await fs_extra_1.default.pathExists(nvmrcPath))) {
+        return;
+    }
+    let nodeVersion;
+    try {
+        nodeVersion = (await fs_extra_1.default.readFile(nvmrcPath, 'utf8')).toString().trim();
+    }
+    catch {
+        return undefined;
+    }
+    if (!semver_1.default.valid(nodeVersion)) {
+        throw new Error(`Invalid node version in .nvmrc: ${nodeVersion}`);
+    }
+    return nodeVersion;
+}
+async function readProfileWithOverridesAsync({ easJsonAccessor, platform, type, profileName, projectDir, }) {
     if (type === 'build') {
         const buildProfile = await eas_json_1.EasJsonUtils.getBuildProfileAsync(easJsonAccessor, platform, profileName);
         await maybePrintBuildProfileDeprecationWarningsAsync(easJsonAccessor, platform, profileName);
+        await setNodeVersionFromFileAsync(projectDir, buildProfile);
         return buildProfile;
     }
     else {

package/build/utils/relay.d.ts

@@ -0,0 +1,33 @@
+import { PageInfo } from '../graphql/generated';
+export type Connection<T> = {
+    edges: Edge<T>[];
+    pageInfo: PageInfo;
+};
+type Edge<T> = {
+    node: T;
+};
+export type QueryParams = {
+    first: number;
+    after?: string;
+};
+/**
+ * Fetches dataset in paginated manner (batch by batch) using GraphQL queries.
+ *
+ * @param queryAsync A promise based function for querying.
+ * @param beforeEachQuery Optional. A callback function to be called before each query
+ * @param afterEachQuery Optional. A callback function to be called after each query.
+ * @param filterPredicate Optional. A predicate function to filter the node.
+ * @param batchSize Optional. The batch size of the pagination. Defaults to 100.
+ *
+ * @return {Promise<T[]>} - A promise that resolves to an array (the dataset).
+ * @throws {Error} - If an error occurs during execution of the query or pagination.
+ */
+export declare function getPaginatedDatasetAsync<T>({ queryAsync, beforeEachQuery, afterEachQuery, filterPredicate, batchSize, maxNodesFetched, }: {
+    queryAsync: ({ first, after }: QueryParams) => Promise<Connection<T>>;
+    beforeEachQuery?: (totalNodesFetched: number, dataset: T[]) => void;
+    afterEachQuery?: (totalNodesFetched: number, dataset: T[], batch: T[], pageInfo: PageInfo) => void;
+    filterPredicate?: (node: T) => boolean;
+    batchSize?: number;
+    maxNodesFetched?: number;
+}): Promise<T[]>;
+export {};