@donotuse/eas-cli 18.5.0-rc.1

package/build/utils/prompts.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectEnvironmentVariableEnvironmentsAsync = getProjectEnvironmentVariableEnvironmentsAsync;
+exports.promptVariableTypeAsync = promptVariableTypeAsync;
+exports.parseVisibility = parseVisibility;
+exports.promptVariableVisibilityAsync = promptVariableVisibilityAsync;
+exports.promptVariableEnvironmentAsync = promptVariableEnvironmentAsync;
+exports.promptVariableValueAsync = promptVariableValueAsync;
+exports.promptVariableNameAsync = promptVariableNameAsync;
+exports.promptPlatformAsync = promptPlatformAsync;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const environment_1 = require("../build/utils/environment");
+const generated_1 = require("../graphql/generated");
+const EnvironmentVariablesQuery_1 = require("../graphql/queries/EnvironmentVariablesQuery");
+const platform_1 = require("../platform");
+const prompts_1 = require("../prompts");
+const DEFAULT_ENVIRONMENTS = Object.values(environment_1.DefaultEnvironment);
+async function getProjectEnvironmentVariableEnvironmentsAsync(graphqlClient, projectId) {
+    try {
+        const environments = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.environmentVariableEnvironmentsAsync(graphqlClient, projectId);
+        return environments;
+    }
+    catch {
+        throw new Error('Failed to fetch available environments');
+    }
+}
+const CUSTOM_ENVIRONMENT_VALUE = '~~CUSTOM~~';
+async function promptVariableTypeAsync(nonInteractive, initialType) {
+    if (nonInteractive) {
+        throw new Error('The `--type` flag must be set when running in `--non-interactive` mode. Valid values: string, file.');
+    }
+    const options = [
+        {
+            title: 'String',
+            value: generated_1.EnvironmentSecretType.String,
+        },
+        {
+            title: 'File',
+            value: generated_1.EnvironmentSecretType.FileBase64,
+        },
+    ];
+    return await (0, prompts_1.selectAsync)('Select the type of variable', options, {
+        initial: initialType,
+    });
+}
+function parseVisibility(stringVisibility) {
+    switch (stringVisibility) {
+        case 'plaintext':
+            return generated_1.EnvironmentVariableVisibility.Public;
+        case 'sensitive':
+            return generated_1.EnvironmentVariableVisibility.Sensitive;
+        case 'secret':
+            return generated_1.EnvironmentVariableVisibility.Secret;
+        default:
+            throw new Error(`Invalid visibility: ${stringVisibility}`);
+    }
+}
+async function promptCustomEnvironmentAsync() {
+    const { customEnvironment } = await (0, prompts_1.promptAsync)({
+        type: 'text',
+        name: 'customEnvironment',
+        message: 'Enter custom environment name:',
+        validate: (value) => {
+            if (!value || value.trim() === '') {
+                return 'Environment name cannot be empty';
+            }
+            if (!value.match(/^[a-zA-Z0-9_-]+$/)) {
+                return 'Environment name may only contain letters, numbers, underscores, and hyphens';
+            }
+            return true;
+        },
+    });
+    return customEnvironment;
+}
+async function promptVariableVisibilityAsync(nonInteractive, selectedVisibility) {
+    if (nonInteractive) {
+        throw new Error('The `--visibility` flag must be set when running in `--non-interactive` mode. Valid values: plaintext, sensitive, secret.');
+    }
+    return await (0, prompts_1.selectAsync)('Select visibility:', [
+        {
+            title: 'Plain text',
+            value: generated_1.EnvironmentVariableVisibility.Public,
+            selected: selectedVisibility === generated_1.EnvironmentVariableVisibility.Public,
+        },
+        {
+            title: 'Sensitive',
+            value: generated_1.EnvironmentVariableVisibility.Sensitive,
+            selected: selectedVisibility === generated_1.EnvironmentVariableVisibility.Sensitive,
+        },
+        {
+            title: 'Secret',
+            value: generated_1.EnvironmentVariableVisibility.Secret,
+            selected: selectedVisibility === generated_1.EnvironmentVariableVisibility.Secret,
+        },
+    ]);
+}
+async function promptVariableEnvironmentAsync({ nonInteractive, selectedEnvironments, multiple = false, canEnterCustomEnvironment = false, graphqlClient, projectId, }) {
+    if (nonInteractive) {
+        throw new Error(`The \`--environment\` flag must be set when running in \`--non-interactive\` mode. Default environments: ${DEFAULT_ENVIRONMENTS.join(', ')}.`);
+    }
+    let allEnvironments = DEFAULT_ENVIRONMENTS;
+    if (graphqlClient && projectId) {
+        const projectEnvironments = await getProjectEnvironmentVariableEnvironmentsAsync(graphqlClient, projectId);
+        allEnvironments = [...new Set([...DEFAULT_ENVIRONMENTS, ...projectEnvironments])];
+    }
+    if (!multiple) {
+        const choices = allEnvironments.map(environment => ({
+            title: environment,
+            value: environment,
+        }));
+        if (canEnterCustomEnvironment) {
+            choices.push({
+                title: 'Other (enter custom environment)',
+                value: CUSTOM_ENVIRONMENT_VALUE,
+            });
+        }
+        const selectedEnvironment = await (0, prompts_1.selectAsync)('Select environment:', choices);
+        if (selectedEnvironment === CUSTOM_ENVIRONMENT_VALUE) {
+            return await promptCustomEnvironmentAsync();
+        }
+        return selectedEnvironment;
+    }
+    const choices = allEnvironments.map(environment => ({
+        title: environment,
+        value: environment,
+        selected: selectedEnvironments?.includes(environment),
+    }));
+    if (canEnterCustomEnvironment) {
+        choices.push({
+            title: 'Other (enter custom environment)',
+            value: CUSTOM_ENVIRONMENT_VALUE,
+            selected: false,
+        });
+    }
+    const { environments } = await (0, prompts_1.promptAsync)({
+        message: 'Select environment:',
+        name: 'environments',
+        type: 'multiselect',
+        choices,
+    });
+    if (environments?.includes(CUSTOM_ENVIRONMENT_VALUE)) {
+        const customEnvironment = await promptCustomEnvironmentAsync();
+        const filteredEnvironments = environments.filter((env) => env !== CUSTOM_ENVIRONMENT_VALUE);
+        return [...filteredEnvironments, customEnvironment];
+    }
+    return environments;
+}
+async function promptVariableValueAsync({ nonInteractive, required = true, hidden = false, filePath = false, initial, }) {
+    if (nonInteractive && required) {
+        throw new Error(`Environment variable needs 'value' to be specified when running in non-interactive mode. Run the command with ${chalk_1.default.bold('--value VARIABLE_VALUE')} flag to fix the issue`);
+    }
+    const { variableValue } = await (0, prompts_1.promptAsync)({
+        type: hidden && !filePath ? 'password' : 'text',
+        name: 'variableValue',
+        message: filePath ? 'File path:' : 'Variable value:',
+        initial: initial ?? '',
+        validate: variableValue => {
+            if (!required) {
+                return true;
+            }
+            if (!variableValue || variableValue.trim() === '') {
+                return "Environment variable value can't be empty";
+            }
+            return true;
+        },
+    });
+    if (!variableValue && required) {
+        throw new Error(`Environment variable needs 'value' to be specifed. Run the command again  with ${chalk_1.default.bold('--value VARIABLE_VALUE')} flag or provide it interactively to fix the issue.`);
+    }
+    return variableValue;
+}
+async function promptVariableNameAsync(nonInteractive, initialValue) {
+    const validationMessage = 'Variable name may not be empty.';
+    if (nonInteractive) {
+        throw new Error(validationMessage);
+    }
+    const { name } = await (0, prompts_1.promptAsync)({
+        type: 'text',
+        name: 'name',
+        message: `Variable name:`,
+        initial: initialValue,
+        validate: value => {
+            if (!value) {
+                return validationMessage;
+            }
+            if (!value.match(/^\w+$/)) {
+                return 'Names may contain only letters, numbers, and underscores.';
+            }
+            return true;
+        },
+    });
+    if (!name) {
+        throw new Error(validationMessage);
+    }
+    return name;
+}
+async function promptPlatformAsync({ message, }) {
+    const { platform } = await (0, prompts_1.promptAsync)({
+        type: 'select',
+        message,
+        name: 'platform',
+        choices: [
+            {
+                title: 'All',
+                value: platform_1.RequestedPlatform.All,
+            },
+            {
+                title: 'iOS',
+                value: platform_1.RequestedPlatform.Ios,
+            },
+            {
+                title: 'Android',
+                value: platform_1.RequestedPlatform.Android,
+            },
+        ],
+    });
+    return platform;
+}

package/build/utils/queries.d.ts

@@ -0,0 +1,31 @@
+export interface SelectPromptEntry {
+    title: string;
+    description?: string;
+    disabled?: boolean;
+}
+type BasePaginatedQueryArgs<QueryReturnType extends Record<string, any>> = {
+    limit: number;
+    offset: number;
+    queryToPerform: (limit: number, offset: number) => Promise<QueryReturnType[]>;
+};
+type PaginatedQueryWithConfirmPromptArgs<QueryReturnType extends Record<string, any>> = BasePaginatedQueryArgs<QueryReturnType> & {
+    promptOptions: {
+        readonly title: string;
+        renderListItems: (currentPage: QueryReturnType[]) => void;
+    };
+};
+type PaginatedQueryWithSelectPromptArgs<QueryReturnType extends Record<string, any>> = BasePaginatedQueryArgs<QueryReturnType> & {
+    promptOptions: {
+        readonly title: string;
+        makePartialChoiceObject: (queryItem: QueryReturnType) => SelectPromptEntry;
+        getIdentifierForQueryItem: (queryItem: QueryReturnType) => string;
+        readonly selectPromptWarningMessage?: string;
+    };
+};
+export declare function paginatedQueryWithConfirmPromptAsync<QueryReturnType extends Record<string, any>>(queryArgs: PaginatedQueryWithConfirmPromptArgs<QueryReturnType>): Promise<void>;
+/**
+ * Returns an array of item(s) where the id is equal to the id of the user's selected item
+ * If no items are available for a user to select, this will return an empty array.
+ */
+export declare function paginatedQueryWithSelectPromptAsync<QueryReturnType extends Record<string, any>>(queryArgs: PaginatedQueryWithSelectPromptArgs<QueryReturnType>): Promise<QueryReturnType | void>;
+export {};

package/build/utils/queries.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginatedQueryWithConfirmPromptAsync = paginatedQueryWithConfirmPromptAsync;
+exports.paginatedQueryWithSelectPromptAsync = paginatedQueryWithSelectPromptAsync;
+const tslib_1 = require("tslib");
+const uniqBy_1 = tslib_1.__importDefault(require("./expodash/uniqBy"));
+const prompts_1 = require("../prompts");
+const fetchMoreValue = '_fetchMore';
+async function paginatedQueryWithConfirmPromptAsync(queryArgs) {
+    await paginatedQueryWithConfirmPromptInternalAsync(queryArgs, []);
+}
+async function paginatedQueryWithConfirmPromptInternalAsync({ limit, offset, queryToPerform, promptOptions, }, accumulator) {
+    // query an extra item to determine if there are more pages left
+    const paginatedItems = await queryToPerform(limit + 1, offset);
+    const areMorePagesAvailable = paginatedItems.length > limit;
+    // drop that extra item used for pagination from our render logic
+    const currentPage = paginatedItems.slice(0, limit);
+    const newAccumulator = [...accumulator, ...currentPage];
+    promptOptions.renderListItems(currentPage);
+    if (!areMorePagesAvailable) {
+        return;
+    }
+    if (await (0, prompts_1.confirmAsync)({ message: promptOptions.title })) {
+        await paginatedQueryWithConfirmPromptInternalAsync({
+            limit,
+            offset: offset + limit,
+            queryToPerform,
+            promptOptions,
+        }, newAccumulator);
+    }
+}
+/**
+ * Returns an array of item(s) where the id is equal to the id of the user's selected item
+ * If no items are available for a user to select, this will return an empty array.
+ */
+async function paginatedQueryWithSelectPromptAsync(queryArgs) {
+    return await paginatedQueryWithSelectPromptInternalAsync(queryArgs, []);
+}
+async function paginatedQueryWithSelectPromptInternalAsync({ limit, offset, queryToPerform, promptOptions, }, accumulator) {
+    // query an extra item to determine if there are more pages left
+    const paginatedItems = await queryToPerform(limit + 1, offset);
+    const areMorePagesAvailable = paginatedItems.length > limit;
+    // drop that extra item used for pagination from our render logic
+    const currentPage = paginatedItems.slice(0, limit);
+    const newAccumulator = [...accumulator, ...currentPage];
+    const selectionPromptListItems = (0, uniqBy_1.default)(newAccumulator, queryItem => promptOptions.getIdentifierForQueryItem(queryItem)).map(queryItem => ({
+        ...promptOptions.makePartialChoiceObject(queryItem),
+        value: promptOptions.getIdentifierForQueryItem(queryItem),
+    }));
+    if (areMorePagesAvailable) {
+        selectionPromptListItems.push({ title: 'Next page...', value: fetchMoreValue });
+    }
+    if (selectionPromptListItems.length === 0) {
+        return;
+    }
+    const valueOfUserSelectedListItem = await (0, prompts_1.selectAsync)(promptOptions.title, selectionPromptListItems, {
+        warningMessageForDisabledEntries: promptOptions.selectPromptWarningMessage,
+    });
+    if (valueOfUserSelectedListItem === fetchMoreValue) {
+        return await paginatedQueryWithSelectPromptInternalAsync({
+            limit,
+            offset: offset + limit,
+            queryToPerform,
+            promptOptions,
+        }, newAccumulator);
+    }
+    return newAccumulator.find(items => promptOptions.getIdentifierForQueryItem(items) === valueOfUserSelectedListItem);
+}

package/build/utils/relay.d.ts

@@ -0,0 +1,104 @@
+import { PageInfo } from '../graphql/generated';
+export type Connection<T> = {
+    edges: Edge<T>[];
+    pageInfo: PageInfo;
+};
+export type Edge<T> = {
+    cursor: string;
+    node: T;
+};
+export type QueryParams = {
+    first?: number;
+    after?: string;
+    last?: number;
+    before?: string;
+};
+/**
+ *
+ * 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.
+ * @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.
+ *
+ * @throws {Error} - If an error occurs during execution of the query or pagination.
+ */
+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;
+};
+export type PaginatedGetterAsync<Node> = (relayArgs: QueryParams) => Promise<Connection<Node>>;
+export declare const PAGE_SIZE = 20;
+export declare function fetchEntireDatasetAsync<Node>({ paginatedGetterAsync, progressBarLabel, }: {
+    paginatedGetterAsync: PaginatedGetterAsync<Node>;
+    progressBarLabel?: string;
+}): Promise<Node[]>;

package/build/utils/relay.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PAGE_SIZE = exports.NEXT_PAGE_OPTION = exports.PREV_PAGE_OPTION = exports.FilterPagination = void 0;
+exports.selectPaginatedAsync = selectPaginatedAsync;
+exports.fetchEntireDatasetAsync = fetchEntireDatasetAsync;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const cli_progress_1 = tslib_1.__importDefault(require("cli-progress"));
+const prompts_1 = require("../prompts");
+/**
+ *
+ * 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.
+ * @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.
+ *
+ * @throws {Error} - If an error occurs during execution of the query or pagination.
+ */
+class FilterPagination {
+    static async getPageAsync({ queryParams, queryAsync, filterPredicate, internalBatchSize = 100, maxNodesFetched = 10_000, 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,
+            });
+        }
+        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, }) {
+        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 = pageInfo.endCursor ?? 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`);
+            }
+        }
+        const edges = dataset.slice(0, first);
+        return {
+            edges,
+            pageInfo: {
+                hasNextPage: dataset.length > first,
+                hasPreviousPage: false, // cannot be computed efficiently
+                startCursor: edges[0]?.cursor ?? null,
+                endCursor: edges[edges.length - 1]?.cursor ?? null,
+            },
+        };
+    }
+    static async getLastItemsAsync({ last, before }, { internalBatchSize, maxNodesFetched, filterPredicate, queryAsync, beforeEachQuery, afterEachQuery, }) {
+        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 = pageInfo.startCursor ?? 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, // cannot be computed efficiently,
+                hasPreviousPage: dataset.length > last,
+                startCursor: edges[0]?.cursor ?? null,
+                endCursor: edges[edges.length - 1]?.cursor ?? null,
+            },
+        };
+    }
+}
+exports.FilterPagination = FilterPagination;
+async function selectPaginatedAsync({ queryAsync, getTitleAsync, printedType, pageSize, }) {
+    return await selectPaginatedInternalAsync({
+        queryAsync,
+        getTitleAsync,
+        printedType,
+        queryParams: { first: pageSize },
+    });
+}
+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, }) {
+    const limit = queryParams.first ?? queryParams.last;
+    (0, assert_1.default)(limit, 'queryParams must have either first or last');
+    const connection = await queryAsync(queryParams);
+    const { edges, pageInfo } = connection;
+    if (edges.length === 0) {
+        return null;
+    }
+    /*
+     * 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 ?? undefined,
+            },
+            queryAsync,
+            getTitleAsync,
+            printedType,
+        });
+    }
+    else if (selectedItem === exports.NEXT_PAGE_OPTION.value) {
+        return await selectPaginatedInternalAsync({
+            queryParams: {
+                first: limit,
+                after: endCursor ?? undefined,
+            },
+            queryAsync,
+            getTitleAsync,
+            printedType,
+        });
+    }
+    else {
+        return selectedItem;
+    }
+}
+exports.PAGE_SIZE = 20;
+async function fetchEntireDatasetAsync({ paginatedGetterAsync, progressBarLabel, }) {
+    // No way to know the total count of items beforehand
+    let totalEstimatedWork = 10;
+    const queueProgressBar = new cli_progress_1.default.SingleBar({ format: `|{bar}| ${progressBarLabel}` }, cli_progress_1.default.Presets.rect);
+    const data = [];
+    let cursor = undefined;
+    let didStartProgressBar = false;
+    let progress = 0;
+    while (true) {
+        const connection = await paginatedGetterAsync({ first: exports.PAGE_SIZE, after: cursor });
+        const nodes = connection.edges.map(edge => edge.node);
+        const hasNextPage = connection.pageInfo.hasNextPage;
+        data.push(...nodes);
+        if (!hasNextPage) {
+            break;
+        }
+        cursor = connection.pageInfo.endCursor ?? undefined;
+        if (!didStartProgressBar) {
+            // only show the progress bar if user has more than 1 page of items
+            queueProgressBar.start(totalEstimatedWork, 0);
+            didStartProgressBar = true;
+        }
+        progress++;
+        queueProgressBar.update(progress);
+        if (progress >= totalEstimatedWork) {
+            totalEstimatedWork = 8 * totalEstimatedWork;
+            queueProgressBar.setTotal(totalEstimatedWork);
+        }
+    }
+    if (didStartProgressBar) {
+        queueProgressBar.update(totalEstimatedWork);
+        queueProgressBar.stop();
+    }
+    return data;
+}

package/build/utils/statuspageService.d.ts

@@ -0,0 +1,3 @@
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { StatuspageServiceName } from '../graphql/generated';
+export declare function maybeWarnAboutEasOutagesAsync(graphqlClient: ExpoGraphqlClient, serviceNames: StatuspageServiceName[]): Promise<void>;