eas-cli 0.53.0 → 0.53.1

package/build/metadata/download.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadMetadataAsync = void 0;
+const tslib_1 = require("tslib");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const events_1 = require("../analytics/events");
+const prompts_1 = require("../prompts");
+const tasks_1 = require("./apple/tasks");
+const config_1 = require("./config");
+const context_1 = require("./context");
+const errors_1 = require("./errors");
+const telemetry_1 = require("./utils/telemetry");
+/**
+ * Generate a local store configuration from the stores.
+ * Note, only App Store is supported at this time.
+ */
+async function downloadMetadataAsync(metadataCtx) {
+    const filePath = path_1.default.resolve(metadataCtx.projectDir, metadataCtx.metadataPath);
+    const fileExists = await fs_extra_1.default.pathExists(filePath);
+    if (fileExists) {
+        const overwrite = await (0, prompts_1.confirmAsync)({
+            message: `Do you want to overwrite the existing store configuration "${metadataCtx.metadataPath}"?`,
+        });
+        if (!overwrite) {
+            throw new errors_1.MetadataValidationError(`Store configuration already exists at "${filePath}"`);
+        }
+    }
+    const { app, auth } = await (0, context_1.ensureMetadataAppStoreAuthenticatedAsync)(metadataCtx);
+    const { unsubscribeTelemetry, executionId } = (0, telemetry_1.subscribeTelemetry)(events_1.MetadataEvent.APPLE_METADATA_DOWNLOAD, { app, auth });
+    const errors = [];
+    const config = (0, config_1.createAppleWriter)();
+    const tasks = (0, tasks_1.createAppleTasks)(metadataCtx);
+    const taskCtx = { app };
+    for (const task of tasks) {
+        try {
+            await task.prepareAsync({ context: taskCtx });
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    for (const task of tasks) {
+        try {
+            await task.downloadAsync({ config, context: taskCtx });
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    await fs_extra_1.default.writeJson(filePath, config.toSchema(), { spaces: 2 });
+    unsubscribeTelemetry();
+    if (errors.length > 0) {
+        throw new errors_1.MetadataDownloadError(errors, executionId);
+    }
+    return filePath;
+}
+exports.downloadMetadataAsync = downloadMetadataAsync;

package/build/metadata/errors.d.ts

@@ -0,0 +1,37 @@
+import type { ErrorObject } from 'ajv';
+/**
+ * Before syncing data to the ASC API, we need to validate the metadata config.
+ * This error represents unrecoverable issues before syncing that data,
+ * and should contain useful information for the user to solve before trying again.
+ */
+export declare class MetadataValidationError extends Error {
+    readonly errors?: ErrorObject[] | undefined;
+    constructor(message?: string, errors?: ErrorObject[] | undefined);
+}
+/**
+ * If a single entity failed to update, we don't block the other entities from uploading.
+ * We still attempt to update the data in the stores as much as possible.
+ * Because of that, we keep track of any errors encountered and throw this generic error.
+ * It contains that list of encountered errors to present to the user.
+ */
+export declare class MetadataUploadError extends Error {
+    readonly errors: Error[];
+    readonly executionId: string;
+    constructor(errors: Error[], executionId: string);
+}
+/**
+ * If a single entity failed to download, we don't block the other entities from downloading.
+ * We sill attempt to pull in the data from the stores as much as possible.
+ * Because of that, we keep track of any errors envountered and throw this generic error.
+ * It contains that list of encountered errors to present to the user.
+ */
+export declare class MetadataDownloadError extends Error {
+    readonly errors: Error[];
+    readonly executionId: string;
+    constructor(errors: Error[], executionId: string);
+}
+/**
+ * Handle a thrown metadata error by informing the user what went wrong.
+ * If a normal error is thrown, this method will re-throw that error to avoid consuming it.
+ */
+export declare function handleMetadataError(error: Error): void;

package/build/metadata/errors.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleMetadataError = exports.MetadataDownloadError = exports.MetadataUploadError = exports.MetadataValidationError = void 0;
+const tslib_1 = require("tslib");
+const log_1 = tslib_1.__importStar(require("../log"));
+/**
+ * Before syncing data to the ASC API, we need to validate the metadata config.
+ * This error represents unrecoverable issues before syncing that data,
+ * and should contain useful information for the user to solve before trying again.
+ */
+class MetadataValidationError extends Error {
+    constructor(message, errors) {
+        super(message !== null && message !== void 0 ? message : 'Store configuration validation failed');
+        this.errors = errors;
+    }
+}
+exports.MetadataValidationError = MetadataValidationError;
+/**
+ * If a single entity failed to update, we don't block the other entities from uploading.
+ * We still attempt to update the data in the stores as much as possible.
+ * Because of that, we keep track of any errors encountered and throw this generic error.
+ * It contains that list of encountered errors to present to the user.
+ */
+class MetadataUploadError extends Error {
+    constructor(errors, executionId) {
+        super(`Store configuration upload encountered ${errors.length === 1 ? 'an error' : `${errors.length} errors`}.`);
+        this.errors = errors;
+        this.executionId = executionId;
+    }
+}
+exports.MetadataUploadError = MetadataUploadError;
+/**
+ * If a single entity failed to download, we don't block the other entities from downloading.
+ * We sill attempt to pull in the data from the stores as much as possible.
+ * Because of that, we keep track of any errors envountered and throw this generic error.
+ * It contains that list of encountered errors to present to the user.
+ */
+class MetadataDownloadError extends Error {
+    constructor(errors, executionId) {
+        super(`Store configuration download encountered ${errors.length === 1 ? 'an error' : `${errors.length} errors`}.`);
+        this.errors = errors;
+        this.executionId = executionId;
+    }
+}
+exports.MetadataDownloadError = MetadataDownloadError;
+/**
+ * Handle a thrown metadata error by informing the user what went wrong.
+ * If a normal error is thrown, this method will re-throw that error to avoid consuming it.
+ */
+function handleMetadataError(error) {
+    var _a;
+    if (error instanceof MetadataValidationError) {
+        log_1.default.error(error.message);
+        log_1.default.log((_a = error.errors) === null || _a === void 0 ? void 0 : _a.map(err => `  - ${err.dataPath} ${err.message}`).join('\n'));
+        return;
+    }
+    if (error instanceof MetadataDownloadError || error instanceof MetadataUploadError) {
+        log_1.default.error(error.message);
+        log_1.default.log('Please check the logs for any configuration issues.');
+        log_1.default.log('If this issue persists, please open a new issue at:');
+        // TODO: add execution ID to the issue template link
+        log_1.default.log((0, log_1.link)('https://github.com/expo/eas-cli'));
+        return;
+    }
+    throw error;
+}
+exports.handleMetadataError = handleMetadataError;

package/build/metadata/upload.d.ts

@@ -0,0 +1,6 @@
+import { MetadataContext } from './context';
+/**
+ * Sync a local store configuration with the stores.
+ * Note, only App Store is supported at this time.
+ */
+export declare function uploadMetadataAsync(metadataCtx: MetadataContext): Promise<void>;

package/build/metadata/upload.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadMetadataAsync = void 0;
+const tslib_1 = require("tslib");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const events_1 = require("../analytics/events");
+const tasks_1 = require("./apple/tasks");
+const config_1 = require("./config");
+const context_1 = require("./context");
+const errors_1 = require("./errors");
+const telemetry_1 = require("./utils/telemetry");
+/**
+ * Sync a local store configuration with the stores.
+ * Note, only App Store is supported at this time.
+ */
+async function uploadMetadataAsync(metadataCtx) {
+    const filePath = path_1.default.resolve(metadataCtx.projectDir, metadataCtx.metadataPath);
+    if (!(await fs_extra_1.default.pathExists(filePath))) {
+        throw new errors_1.MetadataValidationError(`Store configuration file not found "${filePath}"`);
+    }
+    const { app, auth } = await (0, context_1.ensureMetadataAppStoreAuthenticatedAsync)(metadataCtx);
+    const { unsubscribeTelemetry, executionId } = (0, telemetry_1.subscribeTelemetry)(events_1.MetadataEvent.APPLE_METADATA_UPLOAD, { app, auth });
+    const fileData = await fs_extra_1.default.readJson(filePath);
+    const { valid, errors: validationErrors } = (0, config_1.validateConfig)(fileData);
+    if (!valid) {
+        throw new errors_1.MetadataValidationError(`Store configuration errors found`, validationErrors);
+    }
+    const errors = [];
+    const config = (0, config_1.createAppleReader)(fileData);
+    const tasks = (0, tasks_1.createAppleTasks)(metadataCtx);
+    const taskCtx = { app };
+    for (const task of tasks) {
+        try {
+            await task.prepareAsync({ context: taskCtx });
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    for (const task of tasks) {
+        try {
+            await task.uploadAsync({ config, context: taskCtx });
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    unsubscribeTelemetry();
+    if (errors.length > 0) {
+        throw new errors_1.MetadataUploadError(errors, executionId);
+    }
+}
+exports.uploadMetadataAsync = uploadMetadataAsync;

package/build/metadata/utils/array.d.ts

@@ -0,0 +1 @@
+export declare function unique<T = any>(items: T[]): T[];

package/build/metadata/utils/array.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unique = void 0;
+function unique(items) {
+    const set = new Set(items);
+    return [...set];
+}
+exports.unique = unique;

package/build/metadata/utils/asc.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="@expo/apple-utils/ts-declarations/expo__app-store" />
+import { ConnectModel } from '@expo/apple-utils';
+/** Get the properties of a single App Store Connect entity */
+export declare type AttributesOf<T extends ConnectModel> = T['attributes'];

package/build/metadata/utils/asc.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/metadata/utils/date.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Remove time precision from a date to avoid potential errors with the App Store.
+ *
+ * "status": "409",
+ * "code": "ENTITY_ERROR.ATTRIBUTE.INVALID",
+ * "title": "An attribute value is invalid.",
+ * "detail": "The attribute 'earliestReleaseDate' only allows hour precision",
+ * "source": {
+ *   "pointer": "/data/attributes/earliestReleaseDate"
+ * }
+ */
+export declare function removeDatePrecision(date: any): null | Date;

package/build/metadata/utils/date.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeDatePrecision = void 0;
+/**
+ * Remove time precision from a date to avoid potential errors with the App Store.
+ *
+ * "status": "409",
+ * "code": "ENTITY_ERROR.ATTRIBUTE.INVALID",
+ * "title": "An attribute value is invalid.",
+ * "detail": "The attribute 'earliestReleaseDate' only allows hour precision",
+ * "source": {
+ *   "pointer": "/data/attributes/earliestReleaseDate"
+ * }
+ */
+function removeDatePrecision(date) {
+    if (date) {
+        try {
+            const result = new Date(date);
+            result.setMinutes(0);
+            result.setSeconds(0);
+            result.setMilliseconds(0);
+            if (!isNaN(result.getTime())) {
+                return result;
+            }
+        }
+        catch { }
+    }
+    return null;
+}
+exports.removeDatePrecision = removeDatePrecision;

package/build/metadata/utils/log.d.ts

@@ -0,0 +1,16 @@
+import { Ora } from '../../ora';
+declare type LogAsyncOptions = {
+    /** If the spinner representing the async action should be hidden, e.g. for JSON output */
+    hidden?: boolean;
+    /** The message to display when the action is pending */
+    pending: string;
+    /** The message to display when the action succeeded */
+    success: string;
+    /** The message to display when the action failed */
+    failure: string;
+};
+/**
+ * Log an asynchronous action using a spinner.
+ */
+export declare function logAsync<T>(action: (spinner?: Ora) => Promise<T>, { hidden, ...message }: LogAsyncOptions): Promise<T>;
+export {};

package/build/metadata/utils/log.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logAsync = void 0;
+const ora_1 = require("../../ora");
+/**
+ * Log an asynchronous action using a spinner.
+ */
+async function logAsync(action, { hidden, ...message }) {
+    if (hidden) {
+        return action();
+    }
+    const spinner = (0, ora_1.ora)(message.pending).start();
+    try {
+        const result = await action(spinner);
+        spinner.succeed(message.success);
+        return result;
+    }
+    catch (error) {
+        spinner.fail(message.failure);
+        throw error;
+    }
+}
+exports.logAsync = logAsync;

package/build/metadata/utils/retry.d.ts

@@ -0,0 +1,8 @@
+export declare function waitAsync(duration: number): Promise<void>;
+declare type WithRetryOptions = {
+    tries?: number;
+    delay?: number;
+    onRetry?: (triesLeft: number) => void;
+};
+export declare function retryIfNullAsync<T>(method: () => Promise<T | null>, options?: WithRetryOptions): Promise<T | null>;
+export {};

package/build/metadata/utils/retry.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryIfNullAsync = exports.waitAsync = void 0;
+async function waitAsync(duration) {
+    return new Promise(resolve => setTimeout(resolve, duration));
+}
+exports.waitAsync = waitAsync;
+async function retryIfNullAsync(method, options = {}) {
+    var _a;
+    let { tries = 5, delay = 1000 } = options;
+    while (tries > 0) {
+        const value = await method();
+        if (value !== null) {
+            return value;
+        }
+        tries--;
+        (_a = options.onRetry) === null || _a === void 0 ? void 0 : _a.call(options, tries);
+        await waitAsync(delay);
+    }
+    return null;
+}
+exports.retryIfNullAsync = retryIfNullAsync;

package/build/metadata/utils/telemetry.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="@expo/apple-utils/ts-declarations/expo__app-store" />
+import { App, Session } from '@expo/apple-utils';
+import { MetadataEvent } from '../../analytics/events';
+export declare type TelemetryContext = {
+    app: App;
+    auth: Partial<Session.AuthState>;
+};
+/**
+ * Subscribe the telemetry to the ongoing metadata requests and responses.
+ * When providing the app and auth info, we can scrub that data from the telemetry.
+ * Returns an execution ID to group all events of a single run together, and a unsubscribe function.
+ */
+export declare function subscribeTelemetry(event: MetadataEvent, options: TelemetryContext): {
+    /** Unsubscribe the telemetry from all apple-utils events */
+    unsubscribeTelemetry: () => void;
+    /** The unique id added to all telemetry events from a single execution */
+    executionId: string;
+};
+/** Exposed for testing */
+export declare function makeDataScrubber({ app, auth }: TelemetryContext): <T>(data: T) => string;

package/build/metadata/utils/telemetry.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDataScrubber = exports.subscribeTelemetry = void 0;
+const apple_utils_1 = require("@expo/apple-utils");
+const uuid_1 = require("uuid");
+const events_1 = require("../../analytics/events");
+/**
+ * Subscribe the telemetry to the ongoing metadata requests and responses.
+ * When providing the app and auth info, we can scrub that data from the telemetry.
+ * Returns an execution ID to group all events of a single run together, and a unsubscribe function.
+ */
+function subscribeTelemetry(event, options) {
+    const executionId = (0, uuid_1.v4)();
+    const scrubber = makeDataScrubber(options);
+    const { interceptors } = (0, apple_utils_1.getRequestClient)();
+    const responseInterceptorId = interceptors.response.use(response => {
+        events_1.Analytics.logEvent(event, {
+            executionId,
+            type: 'response',
+            phase: 'resolved',
+            method: response.request.method.toUpperCase(),
+            url: scrubber(response.request.path),
+            status: String(response.status),
+            statusText: scrubber(response.statusText),
+        });
+        return response;
+    }, (error) => {
+        var _a, _b, _c;
+        events_1.Analytics.logEvent(event, {
+            executionId,
+            type: 'response',
+            phase: 'rejected',
+            method: error.request.method.toUpperCase(),
+            url: scrubber(error.config.url),
+            error: scrubber(error.message),
+            status: String((_a = error.response) === null || _a === void 0 ? void 0 : _a.status),
+            statusText: scrubber((_b = error.response) === null || _b === void 0 ? void 0 : _b.statusText),
+            input: scrubber(error.config.data),
+            output: scrubber((_c = error.response) === null || _c === void 0 ? void 0 : _c.data),
+        });
+        throw error;
+    });
+    function unsubscribeTelemetry() {
+        interceptors.response.eject(responseInterceptorId);
+    }
+    return { unsubscribeTelemetry, executionId };
+}
+exports.subscribeTelemetry = subscribeTelemetry;
+/** Exposed for testing */
+function makeDataScrubber({ app, auth }) {
+    var _a, _b;
+    const token = getAuthTokenString(auth);
+    const patterns = {
+        APPLE_APP_ID: new RegExp(app.id, 'gi'),
+        APPLE_USERNAME: auth.username ? new RegExp(auth.username, 'gi') : null,
+        APPLE_PASSWORD: auth.password ? new RegExp(auth.password, 'gi') : null,
+        APPLE_TOKEN: token ? new RegExp(token, 'gi') : null,
+        APPLE_TEAM_ID: ((_a = auth.context) === null || _a === void 0 ? void 0 : _a.teamId) ? new RegExp(auth.context.teamId, 'gi') : null,
+        APPLE_PROVIDER_ID: ((_b = auth.context) === null || _b === void 0 ? void 0 : _b.providerId)
+            ? new RegExp(String(auth.context.providerId), 'gi')
+            : null,
+    };
+    const iterator = Object.entries(patterns);
+    return function scrubber(data) {
+        if (!data) {
+            return String(data);
+        }
+        let value = typeof data === 'object' ? JSON.stringify(data) : String(data);
+        for (const [replacement, pattern] of iterator) {
+            if (pattern) {
+                value = value.replace(pattern, `{${replacement}}`);
+            }
+        }
+        return value;
+    };
+}
+exports.makeDataScrubber = makeDataScrubber;
+function getAuthTokenString(auth) {
+    var _a;
+    if (!((_a = auth.context) === null || _a === void 0 ? void 0 : _a.token)) {
+        return null;
+    }
+    if (typeof auth.context.token === 'object') {
+        return auth.context.token.getToken();
+    }
+    return auth.context.token;
+}

package/build/submit/submit.js

@@ -67,7 +67,7 @@ function printInstructionsForIosSubmission(submission) {
             '- It usually takes about 5-10 minutes depending on how busy Apple servers are.',
             // ascAppIdentifier should be always available for ios submissions but check it anyway
             ((_a = submission.iosConfig) === null || _a === void 0 ? void 0 : _a.ascAppIdentifier) &&
-                `- When it’s done, you can see your build here: ${(0, log_1.link)(`https://appstoreconnect.apple.com/apps/${(_b = submission.iosConfig) === null || _b === void 0 ? void 0 : _b.ascAppIdentifier}/appstore/ios`)}`,
+                `- When it's done, you can see your build here: ${(0, log_1.link)(`https://appstoreconnect.apple.com/apps/${(_b = submission.iosConfig) === null || _b === void 0 ? void 0 : _b.ascAppIdentifier}/appstore/ios`)}`,
         ].join('\n');
         log_1.default.addNewLineIfNone();
         log_1.default.log(logMsg);

package/build/submit/utils/errors.js

@@ -9,6 +9,7 @@ var SubmissionErrorCode;
     SubmissionErrorCode["ARCHIVE_DOWNLOAD_FORBIDDEN_ERROR"] = "SUBMISSION_SERVICE_COMMON_ARCHIVE_DOWNLOAD_FORBIDDEN_ERROR";
     SubmissionErrorCode["ARCHIVE_EXTRACT_NO_FILES_FOUND_ERROR"] = "SUBMISSION_SERVICE_COMMON_ARCHIVE_EXTRACT_NO_FILES_FOUND_ERROR";
     SubmissionErrorCode["ARCHIVE_EXTRACT_CORRUPT_ARCHIVE_ERROR"] = "SUBMISSION_SERVICE_COMMON_ARCHIVE_EXTRACT_CORRUPT_ARCHIVE_ERROR";
+    SubmissionErrorCode["UPLOAD_TAKING_TOO_LONG_ERROR"] = "SUBMISSION_SERVICE_COMMON_UPLOAD_TAKING_TOO_LONG_ERROR";
     SubmissionErrorCode["ANDROID_UNKNOWN_ERROR"] = "SUBMISSION_SERVICE_ANDROID_UNKNOWN_ERROR";
     SubmissionErrorCode["ANDROID_FIRST_UPLOAD_ERROR"] = "SUBMISSION_SERVICE_ANDROID_FIRST_UPLOAD_ERROR";
     SubmissionErrorCode["ANDROID_OLD_VERSION_CODE_ERROR"] = "SUBMISSION_SERVICE_ANDROID_OLD_VERSION_CODE_ERROR";
@@ -56,6 +57,7 @@ const SubmissionErrorMessages = {
     [SubmissionErrorCode.IOS_INVALID_PROVISIONING_PROFILE_SIGNATURE]: 'Invalid Provisioning Profile Signature (ITMS-90165)\n' +
         "Some of Apple's certificates have expired.\n" +
         'Please delete your Provisioning Profile from your account. Then rebuild the app interactively to generate a new one, and try submitting it to the App Store again.',
+    [SubmissionErrorCode.UPLOAD_TAKING_TOO_LONG_ERROR]: 'Submission has reached the timeout limit. Please try again.',
 };
 function printSubmissionError(error) {
     if (error.errorCode &&