eas-cli 3.18.0 → 3.18.1

package/build/rollout/utils.js

@@ -1,36 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printBranch = exports.printRollout = void 0;
+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);
-    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();
+    displayRolloutDetails(channel.name, rollout);
 }
 exports.printRollout = printRollout;
-function printBranch(channel) {
-    const rollout = (0, branch_mapping_1.getRollout)(channel);
+function displayRolloutDetails(channelName, rollout) {
     const rolledOutPercent = rollout.percentRolledOut;
-    log_1.default.addNewLineIfNone();
-    log_1.default.log(chalk_1.default.bold('Rollout:'));
+    log_1.default.newLine();
+    log_1.default.log(chalk_1.default.bold('🚀 Rollout:'));
     log_1.default.log((0, formatFields_1.default)([
-        { label: 'Channel', value: channel.name },
+        { label: 'Channel', value: channelName },
         ...((0, branch_mapping_1.isConstrainedRollout)(rollout)
             ? [{ label: 'Runtime Version', value: rollout.runtimeVersion }]
             : []),
@@ -41,4 +29,61 @@ function printBranch(channel) {
     ]));
     log_1.default.addNewLineIfNone();
 }
-exports.printBranch = printBranch;
+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`);
+    }
+    else {
+        const [updateGroupDescription] = (0, utils_1.getUpdateGroupDescriptions)([maybeUpdateGroup]);
+        lines.push(...formatUpdateGroup(updateGroupDescription));
+    }
+    return lines.join('\n    ');
+}
+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`);
+    }
+    else {
+        const [updateGroupDescription] = (0, utils_1.getUpdateGroupDescriptions)([maybeUpdateGroup]);
+        lines.push(...formatUpdateGroup(updateGroupDescription));
+    }
+    return lines.join('\n    ');
+}
+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>;

package/build/update/republish.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.republishAsync = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const url_1 = require("../build/utils/url");
+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 formatFields_1 = tslib_1.__importDefault(require("../utils/formatFields"));
+const json_1 = require("../utils/json");
+/**
+ * @param updatesToPublish The update group to republish
+ * @param targetBranch The branch to repubish the update group on
+ */
+async function republishAsync({ graphqlClient, app, updatesToPublish, targetBranch, updateMessage, json, }) {
+    const { branchName: targetBranchName, branchId: targetBranchId } = targetBranch;
+    // The update group properties are the same for all updates
+    (0, assert_1.default)(updatesToPublish.length > 0, 'Updates to republish must be provided');
+    const arbitraryUpdate = updatesToPublish[0];
+    const isSameGroup = (update) => update.groupId === arbitraryUpdate.groupId &&
+        update.branchId === arbitraryUpdate.branchId &&
+        update.branchName === arbitraryUpdate.branchName &&
+        update.runtimeVersion === arbitraryUpdate.runtimeVersion;
+    (0, assert_1.default)(updatesToPublish.every(isSameGroup), 'All updates must belong to the same update group');
+    const { runtimeVersion } = arbitraryUpdate;
+    // If codesigning was created for the original update, we need to add it to the republish
+    const shouldRepublishWithCodesigning = updatesToPublish.some(update => update.codeSigningInfo);
+    if (shouldRepublishWithCodesigning) {
+        log_1.default.withTick(`The republished update will be signed with the same codesigning as the original update.`);
+    }
+    const publishIndicator = (0, ora_1.ora)('Republishing...').start();
+    let updatesRepublished;
+    try {
+        updatesRepublished = await PublishMutation_1.PublishMutation.publishUpdateGroupAsync(graphqlClient, [
+            {
+                branchId: targetBranchId,
+                runtimeVersion,
+                message: updateMessage,
+                updateInfoGroup: Object.fromEntries(updatesToPublish.map(update => [update.platform, JSON.parse(update.manifestFragment)])),
+                gitCommitHash: updatesToPublish[0].gitCommitHash,
+                awaitingCodeSigningInfo: shouldRepublishWithCodesigning,
+            },
+        ]);
+        if (shouldRepublishWithCodesigning) {
+            const codeSigningByPlatform = Object.fromEntries(updatesToPublish.map(update => [update.platform, update.codeSigningInfo]));
+            await Promise.all(updatesRepublished.map(async (update) => {
+                const codeSigning = codeSigningByPlatform[update.platform];
+                if (codeSigning) {
+                    await PublishMutation_1.PublishMutation.setCodeSigningInfoAsync(graphqlClient, update.id, codeSigning);
+                }
+            }));
+        }
+        publishIndicator.succeed('Republished update');
+    }
+    catch (error) {
+        publishIndicator.fail('Failed to republish update');
+        throw error;
+    }
+    if (json) {
+        return (0, json_1.printJsonOnlyOutput)(updatesRepublished);
+    }
+    const updatesRepublishedByPlatform = Object.fromEntries(updatesRepublished.map(update => [update.platform, update]));
+    const arbitraryRepublishedUpdate = updatesRepublished[0];
+    const updateGroupUrl = (0, url_1.getUpdateGroupUrl)((await (0, projectUtils_1.getOwnerAccountForProjectIdAsync)(graphqlClient, app.projectId)).name, app.exp.slug, arbitraryRepublishedUpdate.group);
+    log_1.default.addNewLineIfNone();
+    log_1.default.log((0, formatFields_1.default)([
+        { label: 'Branch', value: targetBranchName },
+        { label: 'Runtime version', value: arbitraryRepublishedUpdate.runtimeVersion },
+        { label: 'Platform', value: updatesRepublished.map(update => update.platform).join(', ') },
+        { label: 'Update Group ID', value: arbitraryRepublishedUpdate.group },
+        ...(updatesRepublishedByPlatform.android
+            ? [{ label: 'Android update ID', value: updatesRepublishedByPlatform.android.id }]
+            : []),
+        ...(updatesRepublishedByPlatform.ios
+            ? [{ label: 'iOS update ID', value: updatesRepublishedByPlatform.ios.id }]
+            : []),
+        { label: 'Message', value: updateMessage },
+        { label: 'Website link', value: (0, log_1.link)(updateGroupUrl, { dim: false }) },
+    ]));
+}
+exports.republishAsync = republishAsync;

package/build/utils/relay.d.ts

@@ -3,31 +3,96 @@ export type Connection<T> = {
     edges: Edge<T>[];
     pageInfo: PageInfo;
 };
-type Edge<T> = {
+export type Edge<T> = {
+    cursor: string;
     node: T;
 };
 export type QueryParams = {
-    first: number;
+    first?: number;
     after?: string;
+    last?: number;
+    before?: string;
 };
 /**
- * Fetches dataset in paginated manner (batch by batch) using GraphQL queries.
  *
+ * Pagination that performs client side filtering on the nodes returned from a relay compliant datasource.
+ *
+ * @param queryParams The query params for the pagination.
  * @param queryAsync A promise based function for querying.
+ * @param filterPredicate A predicate function to filter the node.
+ * @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 internalBatchSize Optional. The batch size of queryAsync. Defaults to 100.
+ * @param maxNodesFetched Optional. The maximum number of nodes to fetch. Defaults to 10_000.
  * @param beforeEachQuery Optional. A callback function to be called before each query
+ * @args externalQueryParams The query params for the pagination.
+ * @args totalNodesFetched The total number of nodes fetched so far.
+ * @args dataset The dataset so far.
  * @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.
+ * @args externalQueryParams The query params for the pagination.
+ * @args totalNodesFetched The total number of nodes fetched so far.
+ * @args dataset The dataset so far.
+ * @args willFetchAgain If the query will fetch again to get a complete page.
  *
- * @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 {};
+export declare class FilterPagination {
+    static getPageAsync<T>({ queryParams, queryAsync, filterPredicate, internalBatchSize, maxNodesFetched, beforeEachQuery, afterEachQuery, }: {
+        queryParams: QueryParams;
+        queryAsync: (queryParams: QueryParams) => Promise<Connection<T>>;
+        filterPredicate: (node: T) => boolean;
+        internalBatchSize?: number;
+        maxNodesFetched?: number;
+        beforeEachQuery?: (externalQueryParams: QueryParams, totalNodesFetched: number, dataset: Edge<T>[]) => void;
+        afterEachQuery?: (externalQueryParams: QueryParams, totalNodesFetched: number, dataset: Edge<T>[], willFetchAgain: boolean) => void;
+    }): Promise<Connection<T>>;
+    static isFirstAfter(connectionArgs: QueryParams): connectionArgs is {
+        first: number;
+        after?: string;
+    };
+    static isLastBefore(connectionArgs: {
+        first?: number;
+        after?: string;
+        last?: number;
+        before?: string;
+    }): connectionArgs is {
+        last: number;
+        before?: string;
+    };
+    static getFirstItemsAsync<T>({ first, after }: {
+        first: number;
+        after?: string;
+    }, { internalBatchSize, maxNodesFetched, filterPredicate, queryAsync, beforeEachQuery, afterEachQuery, }: {
+        internalBatchSize?: number;
+        maxNodesFetched: number;
+        filterPredicate: (node: T) => boolean;
+        queryAsync: (queryParams: QueryParams) => Promise<Connection<T>>;
+        beforeEachQuery?: (externalQueryParams: QueryParams, totalNodesFetched: number, dataset: Edge<T>[]) => void;
+        afterEachQuery?: (externalQueryParams: QueryParams, totalNodesFetched: number, dataset: Edge<T>[], willFetchAgain: boolean) => void;
+    }): Promise<Connection<T>>;
+    static getLastItemsAsync<T>({ last, before }: {
+        last: number;
+        before?: string;
+    }, { internalBatchSize, maxNodesFetched, filterPredicate, queryAsync, beforeEachQuery, afterEachQuery, }: {
+        internalBatchSize?: number;
+        maxNodesFetched: number;
+        filterPredicate: (node: T) => boolean;
+        queryAsync: (queryParams: QueryParams) => Promise<Connection<T>>;
+        beforeEachQuery?: (externalQueryParams: QueryParams, totalNodesFetched: number, dataset: Edge<T>[]) => void;
+        afterEachQuery?: (externalQueryParams: QueryParams, totalNodesFetched: number, dataset: Edge<T>[], willFetchAgain: boolean) => void;
+    }): Promise<Connection<T>>;
+}
+export declare function selectPaginatedAsync<T>({ queryAsync, getTitleAsync, printedType, pageSize, }: {
+    pageSize: number;
+    queryAsync: (queryParams: QueryParams) => Promise<Connection<T>>;
+    getTitleAsync: (node: T) => Promise<string>;
+    printedType: string;
+}): Promise<T | null>;
+export declare const PREV_PAGE_OPTION: {
+    value: symbol;
+    title: string;
+};
+export declare const NEXT_PAGE_OPTION: {
+    value: symbol;
+    title: string;
+};

package/build/utils/relay.js

@@ -1,43 +1,226 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPaginatedDatasetAsync = void 0;
+exports.NEXT_PAGE_OPTION = exports.PREV_PAGE_OPTION = exports.selectPaginatedAsync = exports.FilterPagination = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const prompts_1 = require("../prompts");
 /**
- * Fetches dataset in paginated manner (batch by batch) using GraphQL queries.
  *
+ * Pagination that performs client side filtering on the nodes returned from a relay compliant datasource.
+ *
+ * @param queryParams The query params for the pagination.
  * @param queryAsync A promise based function for querying.
+ * @param filterPredicate A predicate function to filter the node.
+ * @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 internalBatchSize Optional. The batch size of queryAsync. Defaults to 100.
+ * @param maxNodesFetched Optional. The maximum number of nodes to fetch. Defaults to 10_000.
  * @param beforeEachQuery Optional. A callback function to be called before each query
+ * @args externalQueryParams The query params for the pagination.
+ * @args totalNodesFetched The total number of nodes fetched so far.
+ * @args dataset The dataset so far.
  * @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.
+ * @args externalQueryParams The query params for the pagination.
+ * @args totalNodesFetched The total number of nodes fetched so far.
+ * @args dataset The dataset so far.
+ * @args willFetchAgain If the query will fetch again to get a complete page.
  *
- * @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.
  */
-async function getPaginatedDatasetAsync({ queryAsync, beforeEachQuery, afterEachQuery, filterPredicate, batchSize = 100, maxNodesFetched = 10000, }) {
-    var _a;
-    const dataset = [];
-    let hasMore = true;
-    let after;
-    let totalNodesFetched = 0;
-    while (hasMore) {
-        if (beforeEachQuery) {
-            beforeEachQuery(totalNodesFetched, dataset);
+class FilterPagination {
+    static async getPageAsync({ queryParams, queryAsync, filterPredicate, internalBatchSize = 100, maxNodesFetched = 10000, beforeEachQuery, afterEachQuery, }) {
+        if (this.isFirstAfter(queryParams)) {
+            return await this.getFirstItemsAsync(queryParams, {
+                queryAsync,
+                filterPredicate,
+                internalBatchSize,
+                maxNodesFetched,
+                beforeEachQuery,
+                afterEachQuery,
+            });
+        }
+        else if (this.isLastBefore(queryParams)) {
+            return await this.getLastItemsAsync(queryParams, {
+                queryAsync,
+                filterPredicate,
+                internalBatchSize,
+                maxNodesFetched,
+                beforeEachQuery,
+                afterEachQuery,
+            });
         }
-        const result = await queryAsync({ first: batchSize, after });
-        const { edges, pageInfo } = result;
-        const nodes = edges.map(edge => edge.node);
-        const batch = filterPredicate ? nodes.filter(filterPredicate) : nodes;
-        dataset.push(...batch);
-        hasMore = pageInfo.hasNextPage;
-        after = (_a = pageInfo.endCursor) !== null && _a !== void 0 ? _a : undefined;
-        totalNodesFetched += nodes.length;
-        if (afterEachQuery) {
-            afterEachQuery(totalNodesFetched, dataset, batch, pageInfo);
+        throw new Error('Invalid query params');
+    }
+    static isFirstAfter(connectionArgs) {
+        return 'first' in connectionArgs;
+    }
+    static isLastBefore(connectionArgs) {
+        return 'last' in connectionArgs;
+    }
+    static async getFirstItemsAsync({ first, after }, { internalBatchSize, maxNodesFetched, filterPredicate, queryAsync, beforeEachQuery, afterEachQuery, }) {
+        var _a, _b, _c, _d, _e;
+        const limit = first + 1;
+        const dataset = [];
+        let hasMore = true;
+        let afterInternal = after;
+        let totalNodesFetched = 0;
+        while (hasMore && dataset.length < limit) {
+            if (beforeEachQuery) {
+                beforeEachQuery({ first, after }, totalNodesFetched, dataset);
+            }
+            const result = await queryAsync({ first: internalBatchSize, after: afterInternal });
+            const { edges: batchEdges, pageInfo } = result;
+            const batch = batchEdges.filter(edge => filterPredicate(edge.node));
+            const nodesRemaining = limit - dataset.length;
+            dataset.push(...batch.slice(0, nodesRemaining));
+            hasMore = pageInfo.hasNextPage;
+            afterInternal = (_a = pageInfo.endCursor) !== null && _a !== void 0 ? _a : undefined;
+            totalNodesFetched += batchEdges.length;
+            if (afterEachQuery) {
+                afterEachQuery({ first, after }, totalNodesFetched, dataset, hasMore && dataset.length < limit);
+            }
+            if (totalNodesFetched >= maxNodesFetched) {
+                throw new Error(`Max nodes of ${maxNodesFetched} fetched`);
+            }
         }
-        if (totalNodesFetched >= maxNodesFetched) {
-            return dataset;
+        const edges = dataset.slice(0, first);
+        return {
+            edges,
+            pageInfo: {
+                hasNextPage: dataset.length > first,
+                hasPreviousPage: false,
+                startCursor: (_c = (_b = edges[0]) === null || _b === void 0 ? void 0 : _b.cursor) !== null && _c !== void 0 ? _c : null,
+                endCursor: (_e = (_d = edges[edges.length - 1]) === null || _d === void 0 ? void 0 : _d.cursor) !== null && _e !== void 0 ? _e : null,
+            },
+        };
+    }
+    static async getLastItemsAsync({ last, before }, { internalBatchSize, maxNodesFetched, filterPredicate, queryAsync, beforeEachQuery, afterEachQuery, }) {
+        var _a, _b, _c, _d, _e;
+        const limit = last + 1;
+        const dataset = [];
+        let hasMore = true;
+        let beforeInternal = before;
+        let totalNodesFetched = 0;
+        while (hasMore && dataset.length < limit) {
+            if (beforeEachQuery) {
+                beforeEachQuery({ last, before }, totalNodesFetched, dataset);
+            }
+            const result = await queryAsync({ last: internalBatchSize, before: beforeInternal });
+            const { edges: batchEdges, pageInfo } = result;
+            const batch = batchEdges.filter(edge => filterPredicate(edge.node));
+            const nodesRemaining = limit - dataset.length;
+            // relay orders pages from first to last, so we reverse the batch to to choose the last n
+            const nodesChosen = batch.reverse().slice(0, nodesRemaining);
+            dataset.push(...nodesChosen);
+            hasMore = pageInfo.hasPreviousPage;
+            beforeInternal = (_a = pageInfo.startCursor) !== null && _a !== void 0 ? _a : undefined;
+            totalNodesFetched += batchEdges.length;
+            if (afterEachQuery) {
+                afterEachQuery({ last, before }, totalNodesFetched, dataset, hasMore && dataset.length < limit);
+            }
+            if (totalNodesFetched >= maxNodesFetched) {
+                throw new Error(`Max nodes of ${maxNodesFetched} fetched`);
+            }
         }
+        // we reverse our dataset again to restore the original order of first to last to match relay
+        const edges = dataset.slice(0, last).reverse();
+        return {
+            edges,
+            pageInfo: {
+                hasNextPage: false,
+                hasPreviousPage: dataset.length > last,
+                startCursor: (_c = (_b = edges[0]) === null || _b === void 0 ? void 0 : _b.cursor) !== null && _c !== void 0 ? _c : null,
+                endCursor: (_e = (_d = edges[edges.length - 1]) === null || _d === void 0 ? void 0 : _d.cursor) !== null && _e !== void 0 ? _e : null,
+            },
+        };
+    }
+}
+exports.FilterPagination = FilterPagination;
+async function selectPaginatedAsync({ queryAsync, getTitleAsync, printedType, pageSize, }) {
+    // Dont bother prompting if there are 0 or 1 items
+    const connectionPreflight = await queryAsync({ first: pageSize });
+    const { edges } = connectionPreflight;
+    if (edges.length === 0) {
+        return null;
+    }
+    else if (edges.length === 1) {
+        return edges[0].node;
+    }
+    return await selectPaginatedInternalAsync({
+        queryAsync,
+        getTitleAsync,
+        printedType,
+        queryParams: { first: pageSize },
+    });
+}
+exports.selectPaginatedAsync = selectPaginatedAsync;
+exports.PREV_PAGE_OPTION = {
+    value: Symbol('PREV_PAGE'),
+    title: '⬆️ Previous page',
+};
+exports.NEXT_PAGE_OPTION = {
+    value: Symbol('NEXT_PAGE'),
+    title: '⬇️ Next page',
+};
+async function selectPaginatedInternalAsync({ queryAsync, getTitleAsync, printedType, queryParams, }) {
+    var _a;
+    const limit = (_a = queryParams.first) !== null && _a !== void 0 ? _a : queryParams.last;
+    (0, assert_1.default)(limit, 'queryParams must have either first or last');
+    const connection = await queryAsync(queryParams);
+    const { edges, pageInfo } = connection;
+    /*
+     * The Relay spec has a weird definition on hasNextPage and hasPreviousPage:
+     * 'If the client is paginating with last/before, then the server must return true if prior edges
+     * exist, otherwise false. If the client is paginating with first/after, then the client may
+     * return true if edges prior to after exist, if it can do so efficiently, otherwise may return false.'
+     *
+     * This means if we are paginating with first/after, we can't rely on pageInfo.hasPreviousPage and vice versa.
+     */
+    const { endCursor, hasNextPage: serverResponseHasNextPage, startCursor, hasPreviousPage: serverResponseHasPreviousPage, } = pageInfo;
+    const hasPreviousPage = serverResponseHasPreviousPage || queryParams.after;
+    const hasNextPage = serverResponseHasNextPage || queryParams.before;
+    const nodes = edges.map(edge => edge.node);
+    const options = [];
+    if (hasPreviousPage) {
+        options.push(exports.PREV_PAGE_OPTION);
+    }
+    const nodeTitles = await Promise.all(nodes.map(node => getTitleAsync(node)));
+    options.push(...nodes.map((node, index) => ({ value: node, title: nodeTitles[index] })));
+    if (hasNextPage) {
+        options.push(exports.NEXT_PAGE_OPTION);
+    }
+    const { item: selectedItem } = await (0, prompts_1.promptAsync)({
+        type: 'select',
+        name: 'item',
+        message: `Select a ${printedType}`,
+        choices: options.map(option => ({
+            value: option.value,
+            title: option.title,
+        })),
+    });
+    if (selectedItem === exports.PREV_PAGE_OPTION.value) {
+        return await selectPaginatedInternalAsync({
+            queryParams: {
+                last: limit,
+                before: startCursor !== null && startCursor !== void 0 ? startCursor : undefined,
+            },
+            queryAsync,
+            getTitleAsync,
+            printedType,
+        });
+    }
+    else if (selectedItem === exports.NEXT_PAGE_OPTION.value) {
+        return await selectPaginatedInternalAsync({
+            queryParams: {
+                first: limit,
+                after: endCursor !== null && endCursor !== void 0 ? endCursor : undefined,
+            },
+            queryAsync,
+            getTitleAsync,
+            printedType,
+        });
+    }
+    else {
+        return selectedItem;
     }
-    return dataset;
 }
-exports.getPaginatedDatasetAsync = getPaginatedDatasetAsync;