eas-cli 3.16.0 → 3.17.1

package/build/rollout/utils.d.ts

@@ -0,0 +1,53 @@
+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;

package/build/rollout/utils.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRollout = void 0;
+const branch_mapping_1 = require("../channel/branch-mapping");
+/**
+ * Detect if a branch mapping is a rollout.
+ *
+ * Types of rollout:
+ * 1. Legacy unconstrained rollout:
+ * Maps to a rollout branch via a rollout token
+ * Falls back to a default branch
+ *
+ * Example:
+ * {
+    version: 0,
+    data: [
+      {
+        branchId: uuidv4(),
+        branchMappingLogic: {
+          operand: 10 / 100,
+          clientKey: 'rolloutToken',
+          branchMappingOperator: hashLtOperator(),
+        },
+      },
+      { branchId: uuidv4(), branchMappingLogic: alwaysTrue() },
+    ],
+  }
+  *
+  * 2. RTV constrained rollout:
+  * Maps to a rollout branch via a rollout token, constrained by runtime version
+  * Falls back to a default branch
+  *
+  * Example:
+  * {
+    version: 0,
+    data: [
+      {
+        branchId: uuidv4(),
+        branchMappingLogic: andStatement([
+          {
+            operand: '1.0.0',
+            clientKey: 'runtimeVersion',
+            branchMappingOperator: equalsOperator(),
+          },
+          {
+            operand: 10 / 100,
+            clientKey: 'rolloutToken',
+            branchMappingOperator: hashLtOperator(),
+          },
+        ]),
+      },
+      { branchId: uuidv4(), branchMappingLogic: alwaysTrue() },
+    ],
+  }
+ */
+function isRollout(branchMapping) {
+    return isUnconstrainedRollout(branchMapping) || isRtvConstrainedRollout(branchMapping);
+}
+exports.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';
+}

package/build/submit/android/AndroidSubmitCommand.d.ts

@@ -9,6 +9,7 @@ export default class AndroidSubmitCommand {
     private maybeGetAndroidPackageFromCurrentProjectAsync;
     private resolveTrack;
     private resolveReleaseStatus;
+    private resolveRollout;
     private resolveArchiveSource;
     private resolveServiceAccountSourceAsync;
 }

package/build/submit/android/AndroidSubmitCommand.js

@@ -24,8 +24,9 @@ class AndroidSubmitCommand {
         const track = this.resolveTrack();
         const releaseStatus = this.resolveReleaseStatus();
         const archiveSource = this.resolveArchiveSource();
+        const rollout = this.resolveRollout();
         const serviceAccountSource = await this.resolveServiceAccountSourceAsync();
-        const errored = [track, releaseStatus, archiveSource, serviceAccountSource].filter(r => !r.ok);
+        const errored = [track, releaseStatus, archiveSource, serviceAccountSource, rollout].filter(r => !r.ok);
         if (errored.length > 0) {
             const message = errored.map(err => { var _a; return (_a = err.reason) === null || _a === void 0 ? void 0 : _a.message; }).join('\n');
             log_1.default.error(message);
@@ -35,6 +36,7 @@ class AndroidSubmitCommand {
             projectId: this.ctx.projectId,
             track: track.enforceValue(),
             releaseStatus: releaseStatus.enforceValue(),
+            rollout: rollout.enforceValue(),
             archiveSource: archiveSource.enforceValue(),
             serviceAccountSource: serviceAccountSource.enforceValue(),
             changesNotSentForReview: this.ctx.profile.changesNotSentForReview,
@@ -78,6 +80,10 @@ class AndroidSubmitCommand {
             return (0, results_1.result)(new Error(`Unsupported release status: ${releaseStatus} (valid options: ${Object.keys(eas_json_1.AndroidReleaseStatus).join(', ')})`));
         }
     }
+    resolveRollout() {
+        const { rollout } = this.ctx.profile;
+        return (0, results_1.result)(rollout);
+    }
     resolveArchiveSource() {
         try {
             return (0, results_1.result)((0, commons_1.resolveArchiveSource)(this.ctx));

package/build/submit/android/AndroidSubmitter.d.ts

@@ -4,7 +4,7 @@ import { ArchiveSource, ResolvedArchiveSource } from '../ArchiveSource';
 import BaseSubmitter, { SubmissionInput } from '../BaseSubmitter';
 import { SubmissionContext } from '../context';
 import { ServiceAccountKeyResult, ServiceAccountSource } from './ServiceAccountSource';
-export interface AndroidSubmissionOptions extends Pick<AndroidSubmissionConfigInput, 'track' | 'releaseStatus' | 'changesNotSentForReview'> {
+export interface AndroidSubmissionOptions extends Pick<AndroidSubmissionConfigInput, 'track' | 'releaseStatus' | 'changesNotSentForReview' | 'rollout'> {
     projectId: string;
     archiveSource: ArchiveSource;
     serviceAccountSource: ServiceAccountSource;

package/build/submit/android/AndroidSubmitter.js

@@ -57,16 +57,17 @@ class AndroidSubmitter extends BaseSubmitter_1.default {
         });
     }
     formatSubmissionConfig(options, { serviceAccountKeyResult }) {
-        const { track, releaseStatus, changesNotSentForReview } = options;
+        const { track, releaseStatus, changesNotSentForReview, rollout } = options;
         return {
             track,
             changesNotSentForReview,
             releaseStatus,
+            rollout,
             ...serviceAccountKeyResult.result,
         };
     }
     prepareSummaryData(options, { archive, serviceAccountKeyResult }) {
-        const { projectId, track, releaseStatus, changesNotSentForReview } = options;
+        const { projectId, track, releaseStatus, changesNotSentForReview, rollout } = options;
         // structuring order affects table rows order
         return {
             projectId,
@@ -74,6 +75,7 @@ class AndroidSubmitter extends BaseSubmitter_1.default {
             changesNotSentForReview: changesNotSentForReview !== null && changesNotSentForReview !== void 0 ? changesNotSentForReview : undefined,
             releaseStatus: releaseStatus !== null && releaseStatus !== void 0 ? releaseStatus : undefined,
             formattedServiceAccount: formatServiceAccountSummary(serviceAccountKeyResult),
+            rollout: rollout !== null && rollout !== void 0 ? rollout : undefined,
             ...(0, summary_1.formatArchiveSourceSummary)(archive),
         };
     }
@@ -87,6 +89,7 @@ const SummaryHumanReadableKeys = {
     formattedServiceAccount: 'Google Service Account Key',
     projectId: 'Project ID',
     releaseStatus: 'Release status',
+    rollout: 'Rollout',
     track: 'Release track',
 };
 function formatServiceAccountSummary({ summary }) {

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 {};

package/build/utils/relay.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPaginatedDatasetAsync = void 0;
+/**
+ * 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.
+ */
+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);
+        }
+        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);
+        }
+        if (totalNodesFetched >= maxNodesFetched) {
+            return dataset;
+        }
+    }
+    return dataset;
+}
+exports.getPaginatedDatasetAsync = getPaginatedDatasetAsync;