eas-cli 3.17.1 → 3.18.1

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/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

@@ -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;