eas-cli 2.6.0 → 2.7.1

package/build/update/configure.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureEASUpdatesIsConfiguredAsync = exports.DEFAULT_BARE_RUNTIME_VERSION = exports.DEFAULT_MANAGED_RUNTIME_VERSION = void 0;
+const tslib_1 = require("tslib");
+const config_1 = require("@expo/config");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const api_1 = require("../api");
+const generated_1 = require("../graphql/generated");
+const log_1 = tslib_1.__importStar(require("../log"));
+const platform_1 = require("../platform");
+const projectUtils_1 = require("../project/projectUtils");
+const workflow_1 = require("../project/workflow");
+const UpdatesModule_1 = require("./android/UpdatesModule");
+const UpdatesModule_2 = require("./ios/UpdatesModule");
+exports.DEFAULT_MANAGED_RUNTIME_VERSION = { policy: 'sdkVersion' };
+exports.DEFAULT_BARE_RUNTIME_VERSION = '1.0.0';
+function getDefaultRuntimeVersion(workflow) {
+    return workflow === eas_build_job_1.Workflow.GENERIC
+        ? exports.DEFAULT_BARE_RUNTIME_VERSION
+        : exports.DEFAULT_MANAGED_RUNTIME_VERSION;
+}
+function isRuntimeEqual(runtimeVersionA, runtimeVersionB) {
+    if (typeof runtimeVersionA === 'string' && typeof runtimeVersionB === 'string') {
+        return runtimeVersionA === runtimeVersionB;
+    }
+    else if (typeof runtimeVersionA === 'object' && typeof runtimeVersionB === 'object') {
+        return runtimeVersionA.policy === runtimeVersionB.policy;
+    }
+    else {
+        return false;
+    }
+}
+function replaceUndefinedObjectValues(value, replacement) {
+    for (const key in value) {
+        if (value[key] === undefined) {
+            value[key] = replacement;
+        }
+        else if (typeof value[key] === 'object') {
+            value[key] = replaceUndefinedObjectValues(value[key], replacement);
+        }
+    }
+    return value;
+}
+/**
+ * Partially merge the EAS Update config with the existing Expo config.
+ * This preserves and merges the nested update-related properties.
+ */
+function mergeExpoConfig(exp, modifyExp) {
+    var _a;
+    return {
+        runtimeVersion: (_a = modifyExp.runtimeVersion) !== null && _a !== void 0 ? _a : exp.runtimeVersion,
+        updates: { ...exp.updates, ...modifyExp.updates },
+        android: {
+            ...exp.android,
+            ...modifyExp.android,
+        },
+        ios: {
+            ...exp.ios,
+            ...modifyExp.ios,
+        },
+    };
+}
+/**
+ * Make sure the `app.json` is configured to use EAS Updates.
+ * This does a couple of things:
+ *   - Ensure update URL is set to the project EAS endpoint
+ *   - Ensure runtimeVersion is defined for both or individual platforms
+ *   - Output the changes made, or the changes required to make manually
+ */
+async function ensureEASUpdatesIsConfiguredInExpoConfigAsync({ exp, projectId, projectDir, platform, workflows, }) {
+    var _a, _b, _c, _d, _e, _f;
+    const modifyConfig = {};
+    if (((_a = exp.updates) === null || _a === void 0 ? void 0 : _a.url) !== (0, api_1.getEASUpdateURL)(projectId)) {
+        modifyConfig.updates = { url: (0, api_1.getEASUpdateURL)(projectId) };
+    }
+    let androidRuntimeVersion = (_c = (_b = exp.android) === null || _b === void 0 ? void 0 : _b.runtimeVersion) !== null && _c !== void 0 ? _c : exp.runtimeVersion;
+    let iosRuntimeVersion = (_e = (_d = exp.ios) === null || _d === void 0 ? void 0 : _d.runtimeVersion) !== null && _e !== void 0 ? _e : exp.runtimeVersion;
+    if ((['all', 'android'].includes(platform) && !androidRuntimeVersion) ||
+        (['all', 'ios'].includes(platform) && !iosRuntimeVersion)) {
+        androidRuntimeVersion = androidRuntimeVersion !== null && androidRuntimeVersion !== void 0 ? androidRuntimeVersion : getDefaultRuntimeVersion(workflows.android);
+        iosRuntimeVersion = iosRuntimeVersion !== null && iosRuntimeVersion !== void 0 ? iosRuntimeVersion : getDefaultRuntimeVersion(workflows.ios);
+        if (platform === 'all' && isRuntimeEqual(androidRuntimeVersion, iosRuntimeVersion)) {
+            modifyConfig.runtimeVersion = androidRuntimeVersion;
+        }
+        else {
+            if (['all', 'android'].includes(platform)) {
+                modifyConfig.runtimeVersion = undefined;
+                modifyConfig.android = { runtimeVersion: androidRuntimeVersion };
+            }
+            if (['all', 'ios'].includes(platform)) {
+                modifyConfig.runtimeVersion = undefined;
+                modifyConfig.ios = { runtimeVersion: iosRuntimeVersion };
+            }
+        }
+    }
+    if (Object.keys(modifyConfig).length === 0) {
+        return { exp, projectChanged: false };
+    }
+    const mergedExp = mergeExpoConfig(exp, modifyConfig);
+    const result = await (0, config_1.modifyConfigAsync)(projectDir, mergedExp);
+    switch (result.type) {
+        case 'success':
+            logEasUpdatesAutoConfig({ exp, modifyConfig });
+            return {
+                projectChanged: true,
+                // TODO(cedric): fix return type of `modifyConfigAsync` to avoid `null` for type === success repsonses
+                exp: (_f = result.config) === null || _f === void 0 ? void 0 : _f.expo,
+            };
+        case 'warn':
+            warnEASUpdatesManualConfig({ modifyConfig, workflows });
+            throw new Error(result.message);
+        case 'fail':
+            throw new Error(result.message);
+        default:
+            throw new Error(`Unexpected result type "${result.type}" received when modifying the project config.`);
+    }
+}
+function logEasUpdatesAutoConfig({ modifyConfig, exp, }) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    if ((_a = modifyConfig.updates) === null || _a === void 0 ? void 0 : _a.url) {
+        log_1.default.withTick(((_b = exp.updates) === null || _b === void 0 ? void 0 : _b.url)
+            ? `Overwrote updates.url "${exp.updates.url}" with "${modifyConfig.updates.url}"`
+            : `Configured updates.url to "${modifyConfig.updates.url}"`);
+    }
+    if ((_d = (_c = modifyConfig.android) === null || _c === void 0 ? void 0 : _c.runtimeVersion) !== null && _d !== void 0 ? _d : modifyConfig.runtimeVersion) {
+        log_1.default.withTick(`Configured runtimeVersion for ${platform_1.appPlatformDisplayNames[generated_1.AppPlatform.Android]} with "${JSON.stringify((_f = (_e = modifyConfig.android) === null || _e === void 0 ? void 0 : _e.runtimeVersion) !== null && _f !== void 0 ? _f : modifyConfig.runtimeVersion)}"`);
+    }
+    if ((_h = (_g = modifyConfig.ios) === null || _g === void 0 ? void 0 : _g.runtimeVersion) !== null && _h !== void 0 ? _h : modifyConfig.runtimeVersion) {
+        log_1.default.withTick(`Configured runtimeVersion for ${platform_1.appPlatformDisplayNames[generated_1.AppPlatform.Ios]} with "${JSON.stringify((_k = (_j = modifyConfig.ios) === null || _j === void 0 ? void 0 : _j.runtimeVersion) !== null && _k !== void 0 ? _k : modifyConfig.runtimeVersion)}"`);
+    }
+}
+function warnEASUpdatesManualConfig({ modifyConfig, workflows, }) {
+    log_1.default.addNewLineIfNone();
+    log_1.default.warn(`It looks like you are using a dynamic configuration! ${(0, log_1.learnMore)('https://docs.expo.dev/workflow/configuration/#dynamic-configuration-with-appconfigjs)')}`);
+    log_1.default.warn(`Finish configuring EAS Update by adding the following to the project app.config.js:\n${(0, log_1.learnMore)('https://expo.fyi/eas-update-config')}\n`);
+    log_1.default.log(chalk_1.default.bold(JSON.stringify(replaceUndefinedObjectValues(modifyConfig, '<remove this key>'), null, 2)));
+    log_1.default.addNewLineIfNone();
+    if (workflows.android === eas_build_job_1.Workflow.GENERIC || workflows.ios === eas_build_job_1.Workflow.GENERIC) {
+        log_1.default.warn((0, chalk_1.default) `The native config files {bold Expo.plist & AndroidManifest.xml} must be updated to support EAS Update. ${(0, log_1.learnMore)('https://expo.fyi/eas-update-config.md#native-configuration')}`);
+    }
+    log_1.default.addNewLineIfNone();
+}
+/**
+ * Make sure that the current `app.json` configuration for EAS Updates is set natively.
+ */
+async function ensureEASUpdatesIsConfiguredNativelyAsync(graphqlClient, { exp, projectId, projectDir, platform, workflows, }) {
+    if (['all', 'android'].includes(platform) && workflows.android === eas_build_job_1.Workflow.GENERIC) {
+        await (0, UpdatesModule_1.syncUpdatesConfigurationAsync)(graphqlClient, projectDir, exp, projectId);
+        log_1.default.withTick(`Configured ${chalk_1.default.bold('AndroidManifest.xml')} for EAS Update`);
+    }
+    if (['all', 'ios'].includes(platform) && workflows.ios === eas_build_job_1.Workflow.GENERIC) {
+        await (0, UpdatesModule_2.syncUpdatesConfigurationAsync)(graphqlClient, projectDir, exp, projectId);
+        log_1.default.withTick(`Configured ${chalk_1.default.bold('Expo.plist')} for EAS Update`);
+    }
+}
+/**
+ * Make sure EAS Update is fully configured in the current project.
+ * This goes over a checklist and performs the following checks or changes:
+ *   - Enure the `expo-updates` package is currently installed.
+ *   - Ensure `app.json` is configured for EAS Updates
+ *     - Sets `runtimeVersion` if not set
+ *     - Sets `updates.url` if not set
+ *   - Ensure latest changes are reflected in the native config, if any
+ */
+async function ensureEASUpdatesIsConfiguredAsync(graphqlClient, { exp: expWithoutUpdates, projectId, projectDir, platform, }) {
+    const hasExpoUpdates = (0, projectUtils_1.isExpoUpdatesInstalledOrAvailable)(projectDir, expWithoutUpdates.sdkVersion);
+    if (!hasExpoUpdates) {
+        await (0, projectUtils_1.installExpoUpdatesAsync)(projectDir, { silent: !log_1.default.isDebug });
+        log_1.default.withTick('Installed expo updates');
+    }
+    // Bail out if using a platform that doesn't require runtime versions
+    // or native setup, i.e. web.
+    if (!platform) {
+        return;
+    }
+    const workflows = await (0, workflow_1.resolveWorkflowPerPlatformAsync)(projectDir);
+    const { projectChanged, exp: expWithUpdates } = await ensureEASUpdatesIsConfiguredInExpoConfigAsync({
+        exp: expWithoutUpdates,
+        projectDir,
+        projectId,
+        platform,
+        workflows,
+    });
+    if (projectChanged || !hasExpoUpdates) {
+        await ensureEASUpdatesIsConfiguredNativelyAsync(graphqlClient, {
+            exp: expWithUpdates,
+            projectDir,
+            projectId,
+            platform,
+            workflows,
+        });
+    }
+    if (projectChanged) {
+        log_1.default.addNewLineIfNone();
+        log_1.default.warn(`All builds of your app going forward will be eligible to receive updates published with EAS Update.`);
+        log_1.default.newLine();
+    }
+}
+exports.ensureEASUpdatesIsConfiguredAsync = ensureEASUpdatesIsConfiguredAsync;

package/build/utils/expoCli.d.ts

@@ -1,3 +1,9 @@
+import { ExpoConfig } from '@expo/config-types';
+/**
+ * @returns `true` if the project is SDK +46, has `@expo/cli`, and `EXPO_USE_LOCAL_CLI` is not set to a _false_ value.
+ */
+export declare function shouldUseVersionedExpoCLIExpensive(projectDir: string, exp: Pick<ExpoConfig, 'sdkVersion'>): boolean;
+export declare const shouldUseVersionedExpoCLI: typeof shouldUseVersionedExpoCLIExpensive;
 export declare function expoCommandAsync(projectDir: string, args: string[], { silent }?: {
     silent?: boolean;
 }): Promise<void>;

package/build/utils/expoCli.js

@@ -1,11 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.expoCommandAsync = void 0;
+exports.expoCommandAsync = exports.shouldUseVersionedExpoCLI = exports.shouldUseVersionedExpoCLIExpensive = void 0;
 const tslib_1 = require("tslib");
 const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const getenv_1 = require("getenv");
 const resolve_from_1 = tslib_1.__importDefault(require("resolve-from"));
+const semver_1 = tslib_1.__importDefault(require("semver"));
 const log_1 = tslib_1.__importDefault(require("../log"));
+const memoize_1 = require("./expodash/memoize");
+// Aggressively returns `true` (UNVERSIONED, invalid SDK version format) to push users towards the versioned CLI.
+function gteSdkVersion(fromSdkVersion, sdkVersion) {
+    if (fromSdkVersion === 'UNVERSIONED') {
+        return true;
+    }
+    try {
+        return semver_1.default.gte(fromSdkVersion, sdkVersion);
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * @returns `true` if the project is SDK +46, has `@expo/cli`, and `EXPO_USE_LOCAL_CLI` is not set to a _false_ value.
+ */
+function shouldUseVersionedExpoCLIExpensive(projectDir, exp) {
+    // Users can disable local CLI settings EXPO_USE_LOCAL_CLI=false
+    // https://github.com/expo/expo/blob/69eddda7bb1dbfab44258f468cf7f22984c1e44e/packages/expo/bin/cli.js#L10
+    // Run the environment variable check first as it's the cheapest.
+    const userDefinedVersionedCliEnabled = (0, getenv_1.boolish)('EXPO_USE_LOCAL_CLI', true);
+    if (!userDefinedVersionedCliEnabled) {
+        return false;
+    }
+    try {
+        // NOTE(EvanBacon): The CLI package could be available through a monorepo
+        // we need to ensure the project is specifically using a known supported Expo SDK version.
+        if (
+        // If the version isn't defined then skip the check.
+        // Users running in a non-standard way should use the latest supported behavior (local CLI).
+        exp.sdkVersion &&
+            !gteSdkVersion(exp.sdkVersion, '46.0.0')) {
+            return false;
+        }
+    }
+    catch (error) {
+        log_1.default.debug('Error detecting Expo SDK version for enabling versioned Expo CLI:', error);
+    }
+    // Finally ensure the CLI is available for sanity.
+    return !!resolve_from_1.default.silent(projectDir, '@expo/cli');
+}
+exports.shouldUseVersionedExpoCLIExpensive = shouldUseVersionedExpoCLIExpensive;
+exports.shouldUseVersionedExpoCLI = (0, memoize_1.memoize)(shouldUseVersionedExpoCLIExpensive);
 async function expoCommandAsync(projectDir, args, { silent = false } = {}) {
     const expoCliPath = (0, resolve_from_1.default)(projectDir, 'expo/bin/cli.js');
     const spawnPromise = (0, spawn_async_1.default)(expoCliPath, args, {

package/build/utils/expodash/memoize.d.ts

@@ -0,0 +1,2 @@
+/** `lodash.memoize` */
+export declare function memoize<T extends (...args: any[]) => any>(fn: T): T;

package/build/utils/expodash/memoize.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoize = void 0;
+/** `lodash.memoize` */
+function memoize(fn) {
+    const cache = {};
+    return ((...args) => {
+        const key = JSON.stringify(args);
+        if (cache[key]) {
+            return cache[key];
+        }
+        const result = fn(...args);
+        cache[key] = result;
+        return result;
+    });
+}
+exports.memoize = memoize;

package/build/utils/image.d.ts

@@ -0,0 +1,6 @@
+export declare class ImageNonPngError extends Error {
+}
+export declare class ImageTransparencyError extends Error {
+}
+export declare function ensurePNGIsNotTransparentAsync(imagePathOrURL: string): Promise<void>;
+export declare function isPNGAsync(imagePathOrURL: string): Promise<boolean>;

package/build/utils/image.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPNGAsync = exports.ensurePNGIsNotTransparentAsync = exports.ImageTransparencyError = exports.ImageNonPngError = void 0;
+const tslib_1 = require("tslib");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const pngjs_1 = require("pngjs");
+const fetch_1 = tslib_1.__importDefault(require("../fetch"));
+class ImageNonPngError extends Error {
+}
+exports.ImageNonPngError = ImageNonPngError;
+class ImageTransparencyError extends Error {
+}
+exports.ImageTransparencyError = ImageTransparencyError;
+async function ensurePNGIsNotTransparentAsync(imagePathOrURL) {
+    let hasAlreadyResolved = false;
+    const stream = await getImageStreamAsync(imagePathOrURL);
+    let metadata;
+    return new Promise((res, rej) => {
+        stream
+            .pipe(new pngjs_1.PNG({ filterType: 4 }))
+            .on('error', err => {
+            if (err.message.match(/Invalid file signature/)) {
+                rej(new ImageNonPngError());
+            }
+            else {
+                rej(err);
+            }
+        })
+            .on('metadata', _metadata => {
+            metadata = _metadata;
+            const { alpha } = metadata;
+            if (!alpha) {
+                hasAlreadyResolved = true;
+                if (stream instanceof fs_extra_1.default.ReadStream) {
+                    stream.close();
+                }
+                res();
+            }
+        })
+            .on('parsed', (png) => {
+            if (hasAlreadyResolved) {
+                return;
+            }
+            try {
+                // metadata should be set but assume the png is fine if it's not available
+                if (!metadata) {
+                    res();
+                    return;
+                }
+                validateAlphaChannelIsEmpty(png, { width: metadata.width, height: metadata.height });
+                res();
+            }
+            catch (err) {
+                rej(err);
+            }
+        });
+    });
+}
+exports.ensurePNGIsNotTransparentAsync = ensurePNGIsNotTransparentAsync;
+async function isPNGAsync(imagePathOrURL) {
+    const stream = await getImageStreamAsync(imagePathOrURL);
+    return new Promise((res, rej) => {
+        stream
+            .pipe(new pngjs_1.PNG({ filterType: 4 }))
+            .on('error', err => {
+            if (err.message.match(/Invalid file signature/)) {
+                res(false);
+            }
+            else {
+                rej(err);
+            }
+        })
+            .on('parsed', () => {
+            res(true);
+        });
+    });
+}
+exports.isPNGAsync = isPNGAsync;
+async function getImageStreamAsync(imagePathOrURL) {
+    if (isURL(imagePathOrURL)) {
+        const response = await (0, fetch_1.default)(imagePathOrURL);
+        return response.body;
+    }
+    else {
+        return fs_extra_1.default.createReadStream(imagePathOrURL);
+    }
+}
+function isURL(imagePathOrURL) {
+    try {
+        // eslint-disable-next-line no-new
+        new URL(imagePathOrURL);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function validateAlphaChannelIsEmpty(data, { width, height }) {
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const idx = (width * y + x) * 4;
+            if (data[idx + 3] !== 255) {
+                throw new ImageTransparencyError();
+            }
+        }
+    }
+}

package/build/utils/statuspageService.js

@@ -23,6 +23,7 @@ function warnAboutServiceOutage(service) {
         return;
     }
     const outageType = service.status === generated_1.StatuspageServiceStatus.MajorOutage ? 'major' : 'partial';
+    log_1.default.addNewLineIfNone();
     log_1.default.warn(chalk_1.default.bold(`${humanReadableServiceName[service.name]} is experiencing a ${outageType} outage.`));
     if (service.incidents.length > 0) {
         const [currentIncident] = service.incidents;