eas-cli 12.5.0 → 12.5.2

package/build/graphql/mutations/EnvironmentVariableMutation.js

@@ -12,7 +12,7 @@ exports.EnvironmentVariableMutation = {
             .mutation((0, graphql_tag_1.default) `
             mutation LinkSharedEnvironmentVariable(
               $appId: ID!
-              $environment: EnvironmentVariableEnvironment!
+              $environment: EnvironmentVariableEnvironment
               $environmentVariableId: ID!
             ) {
               environmentVariable {
@@ -36,7 +36,7 @@ exports.EnvironmentVariableMutation = {
             .mutation((0, graphql_tag_1.default) `
             mutation UnlinkSharedEnvironmentVariable(
               $appId: ID!
-              $environment: EnvironmentVariableEnvironment!
+              $environment: EnvironmentVariableEnvironment
               $environmentVariableId: ID!
             ) {
               environmentVariable {
@@ -96,6 +96,22 @@ exports.EnvironmentVariableMutation = {
             .toPromise());
         return data.environmentVariable.createEnvironmentVariableForApp;
     },
+    async updateAsync(graphqlClient, input) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation UpdateEnvironmentVariable($input: UpdateEnvironmentVariableInput!) {
+              environmentVariable {
+                updateEnvironmentVariable(environmentVariableData: $input) {
+                  id
+                  ...EnvironmentVariableFragment
+                }
+              }
+            }
+            ${(0, graphql_1.print)(EnvironmentVariable_1.EnvironmentVariableFragmentNode)}
+          `, { input })
+            .toPromise());
+        return data.environmentVariable.updateEnvironmentVariable;
+    },
     async deleteAsync(graphqlClient, id) {
         const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .mutation((0, graphql_tag_1.default) `

package/build/graphql/queries/EnvironmentVariablesQuery.d.ts

@@ -1,22 +1,28 @@
 import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
-import { EnvironmentVariableFragment } from '../generated';
+import { EnvironmentVariableEnvironment, EnvironmentVariableFragment } from '../generated';
+type EnvironmentVariableWithLinkedEnvironments = EnvironmentVariableFragment & {
+    linkedEnvironments?: EnvironmentVariableEnvironment[] | null;
+};
 export declare const EnvironmentVariablesQuery: {
     byAppIdWithSensitiveAsync(graphqlClient: ExpoGraphqlClient, { appId, environment, filterNames, }: {
         appId: string;
-        environment: string;
+        environment?: EnvironmentVariableEnvironment | undefined;
         filterNames?: string[] | undefined;
     }): Promise<EnvironmentVariableFragment[]>;
     byAppIdAsync(graphqlClient: ExpoGraphqlClient, { appId, environment, filterNames, }: {
         appId: string;
-        environment: string;
+        environment?: EnvironmentVariableEnvironment | undefined;
         filterNames?: string[] | undefined;
-    }): Promise<EnvironmentVariableFragment[]>;
-    sharedAsync(graphqlClient: ExpoGraphqlClient, { appId, filterNames }: {
+    }): Promise<EnvironmentVariableWithLinkedEnvironments[]>;
+    sharedAsync(graphqlClient: ExpoGraphqlClient, { appId, filterNames, environment, }: {
         appId: string;
         filterNames?: string[] | undefined;
-    }): Promise<EnvironmentVariableFragment[]>;
-    sharedWithSensitiveAsync(graphqlClient: ExpoGraphqlClient, { appId, filterNames }: {
+        environment?: EnvironmentVariableEnvironment | undefined;
+    }): Promise<EnvironmentVariableWithLinkedEnvironments[]>;
+    sharedWithSensitiveAsync(graphqlClient: ExpoGraphqlClient, { appId, filterNames, environment, }: {
         appId: string;
         filterNames?: string[] | undefined;
+        environment?: EnvironmentVariableEnvironment | undefined;
     }): Promise<EnvironmentVariableFragment[]>;
 };
+export {};

package/build/graphql/queries/EnvironmentVariablesQuery.js

@@ -13,7 +13,7 @@ exports.EnvironmentVariablesQuery = {
             query EnvironmentVariablesIncludingSensitiveByAppId(
               $appId: String!
               $filterNames: [String!]
-              $environment: EnvironmentVariableEnvironment!
+              $environment: EnvironmentVariableEnvironment
             ) {
               app {
                 byId(appId: $appId) {
@@ -25,6 +25,7 @@ exports.EnvironmentVariablesQuery = {
                     id
                     name
                     value
+                    environments
                   }
                 }
               }
@@ -39,13 +40,14 @@ exports.EnvironmentVariablesQuery = {
             query EnvironmentVariablesByAppId(
               $appId: String!
               $filterNames: [String!]
-              $environment: EnvironmentVariableEnvironment!
+              $environment: EnvironmentVariableEnvironment
             ) {
               app {
                 byId(appId: $appId) {
                   id
                   environmentVariables(filterNames: $filterNames, environment: $environment) {
                     id
+                    linkedEnvironments(appId: $appId)
                     ...EnvironmentVariableFragment
                   }
                 }
@@ -56,17 +58,22 @@ exports.EnvironmentVariablesQuery = {
             .toPromise());
         return data.app?.byId.environmentVariables ?? [];
     },
-    async sharedAsync(graphqlClient, { appId, filterNames }) {
+    async sharedAsync(graphqlClient, { appId, filterNames, environment, }) {
         const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `
-            query EnvironmentVariablesShared($appId: String!, $filterNames: [String!]) {
+            query EnvironmentVariablesShared(
+              $appId: String!
+              $filterNames: [String!]
+              $environment: EnvironmentVariableEnvironment
+            ) {
               app {
                 byId(appId: $appId) {
                   id
                   ownerAccount {
                     id
-                    environmentVariables(filterNames: $filterNames) {
+                    environmentVariables(filterNames: $filterNames, environment: $environment) {
                       id
+                      linkedEnvironments(appId: $appId)
                       ...EnvironmentVariableFragment
                     }
                   }
@@ -74,32 +81,37 @@ exports.EnvironmentVariablesQuery = {
               }
             }
             ${(0, graphql_1.print)(EnvironmentVariable_1.EnvironmentVariableFragmentNode)}
-          `, { appId, filterNames }, { additionalTypenames: ['EnvironmentVariable'] })
+          `, { appId, filterNames, environment }, { additionalTypenames: ['EnvironmentVariable'] })
             .toPromise());
         return data.app?.byId.ownerAccount.environmentVariables ?? [];
     },
-    async sharedWithSensitiveAsync(graphqlClient, { appId, filterNames }) {
+    async sharedWithSensitiveAsync(graphqlClient, { appId, filterNames, environment, }) {
         const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
             .query((0, graphql_tag_1.default) `
             query EnvironmentVariablesSharedWithSensitive(
               $appId: String!
               $filterNames: [String!]
+              $environment: EnvironmentVariableEnvironment
             ) {
               app {
                 byId(appId: $appId) {
                   id
                   ownerAccount {
                     id
-                    environmentVariablesIncludingSensitive(filterNames: $filterNames) {
+                    environmentVariablesIncludingSensitive(
+                      filterNames: $filterNames
+                      environment: $environment
+                    ) {
                       id
                       name
                       value
+                      environments
                     }
                   }
                 }
               }
             }
-          `, { appId, filterNames }, { additionalTypenames: ['EnvironmentVariableWithSecret'] })
+          `, { appId, filterNames, environment }, { additionalTypenames: ['EnvironmentVariableWithSecret'] })
             .toPromise());
         return data.app?.byId.ownerAccount.environmentVariablesIncludingSensitive ?? [];
     },

package/build/graphql/types/EnvironmentVariable.js

@@ -8,8 +8,9 @@ exports.EnvironmentVariableFragmentNode = (0, graphql_tag_1.default) `
     id
     name
     value
-    environment
+    environments
     createdAt
+    updatedAt
     scope
     visibility
   }

package/build/graphql/types/Submission.js

@@ -31,6 +31,6 @@ exports.SubmissionFragmentNode = (0, graphql_tag_1.default) `
       errorCode
       message
     }
-    logsUrl
+    logFiles
   }
 `;

package/build/project/publish.js

@@ -25,7 +25,7 @@ const PublishQuery_1 = require("../graphql/queries/PublishQuery");
 const log_1 = tslib_1.__importStar(require("../log"));
 const platform_1 = require("../platform");
 const prompts_1 = require("../prompts");
-const getBranchNameFromChannelNameAsync_1 = require("../update/getBranchNameFromChannelNameAsync");
+const getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync_1 = require("../update/getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync");
 const utils_2 = require("../update/utils");
 const uploads_1 = require("../uploads");
 const expoCli_1 = require("../utils/expoCli");
@@ -383,7 +383,8 @@ async function getBranchNameForCommandAsync({ graphqlClient, projectId, channelN
         throw new Error('Cannot specify both --channel and --branch. Specify either --channel, --branch, or --auto.');
     }
     if (channelNameArg) {
-        return await (0, getBranchNameFromChannelNameAsync_1.getBranchNameFromChannelNameAsync)(graphqlClient, projectId, channelNameArg);
+        const { branchName } = await (0, getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync_1.getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync)(graphqlClient, projectId, channelNameArg);
+        return branchName;
     }
     if (branchNameArg) {
         return branchNameArg;

package/build/submit/utils/logs.js

@@ -22,23 +22,22 @@ async function displayLogsAsync(submission, { verbose = false, moreSubmissions =
 }
 exports.displayLogsAsync = displayLogsAsync;
 async function downloadAndPrintSubmissionLogsAsync(submission) {
-    if (!submission.logsUrl) {
-        return;
-    }
-    const response = await (0, fetch_1.default)(submission.logsUrl);
-    const logs = parseLogs(await response.text());
-    log_1.default.addNewLineIfNone();
-    const prefix = chalk_1.default.blueBright('[logs] ');
-    for (const { level, msg } of logs) {
-        const msgWithPrefix = `${prefix}${msg}`;
-        if (level === 'error') {
-            log_1.default.error(msgWithPrefix);
-        }
-        else if (level === 'warn') {
-            log_1.default.warn(msgWithPrefix);
-        }
-        else {
-            log_1.default.log(msgWithPrefix);
+    for (const logFile of submission.logFiles) {
+        const response = await (0, fetch_1.default)(logFile);
+        const logs = parseLogs(await response.text());
+        log_1.default.addNewLineIfNone();
+        const prefix = chalk_1.default.blueBright('[logs] ');
+        for (const { level, msg } of logs) {
+            const msgWithPrefix = `${prefix}${msg}`;
+            if (level === 'error') {
+                log_1.default.error(msgWithPrefix);
+            }
+            else if (level === 'warn') {
+                log_1.default.warn(msgWithPrefix);
+            }
+            else {
+                log_1.default.log(msgWithPrefix);
+            }
         }
     }
 }

package/build/update/getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync.d.ts

@@ -0,0 +1,5 @@
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+export declare function getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync(graphqlClient: ExpoGraphqlClient, projectId: string, channelName: string): Promise<{
+    branchName: string;
+    branchId: string;
+}>;

package/build/update/{getBranchNameFromChannelNameAsync.js → getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync.js}

@@ -1,19 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBranchNameFromChannelNameAsync = void 0;
+exports.getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync = void 0;
 const queries_1 = require("../branch/queries");
 const errors_1 = require("../channel/errors");
 const queries_2 = require("../channel/queries");
 const ChannelQuery_1 = require("../graphql/queries/ChannelQuery");
-async function getBranchNameFromChannelNameAsync(graphqlClient, projectId, channelName) {
-    let branchName;
+async function getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync(graphqlClient, projectId, channelName) {
+    let branchInfo;
     try {
         const channel = await ChannelQuery_1.ChannelQuery.viewUpdateChannelAsync(graphqlClient, {
             appId: projectId,
             channelName,
         });
         if (channel.updateBranches.length === 1) {
-            branchName = channel.updateBranches[0].name;
+            const branch = channel.updateBranches[0];
+            branchInfo = { branchId: branch.id, branchName: branch.name };
         }
         else if (channel.updateBranches.length === 0) {
             throw new Error("Channel has no branches associated with it. Run 'eas channel:edit' to map a branch");
@@ -38,8 +39,8 @@ async function getBranchNameFromChannelNameAsync(graphqlClient, projectId, chann
         if (!newChannel) {
             throw new Error(`Could not create channel with name ${channelName} on project with id ${projectId}`);
         }
-        branchName = channelName;
+        branchInfo = { branchId, branchName: channelName };
     }
-    return branchName;
+    return branchInfo;
 }
-exports.getBranchNameFromChannelNameAsync = getBranchNameFromChannelNameAsync;
+exports.getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync = getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync;

package/build/update/republish.js

@@ -26,9 +26,10 @@ async function republishAsync({ graphqlClient, app, updatesToPublish, targetBran
         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');
+    (0, assert_1.default)(updatesToPublish.every(isSameGroup), 'All updates being republished must belong to the same update group');
     (0, assert_1.default)(updatesToPublish.every(u => u.isRollBackToEmbedded) ||
         updatesToPublish.every(u => !u.isRollBackToEmbedded), 'All updates must either be roll back to embedded updates or not');
+    (0, assert_1.default)(!updatesToPublish.some(u => !!u.rolloutControlUpdate), 'Cannot republish an update that is being rolled-out. Either complete the update rollout and then republish or publish a new rollout update.');
     const { runtimeVersion } = arbitraryUpdate;
     // If codesigning was created for the original update, we need to add it to the republish.
     // If one wishes to not sign the republish or sign with a different key, a normal publish should
@@ -44,7 +45,7 @@ async function republishAsync({ graphqlClient, app, updatesToPublish, targetBran
                 throw new Error('Republished updates must use the same code signing key and algorithm as original update');
             }
         }
-        log_1.default.withTick(`The republished update group will be signed`);
+        log_1.default.withTick(`The republished update group will be signed with the same code signing key and algorithm as the original update`);
     }
     const publishIndicator = (0, ora_1.ora)('Republishing...').start();
     let updatesRepublished;

package/build/utils/prompts.d.ts

@@ -1,9 +1,21 @@
-import { EnvironmentVariableEnvironment } from '../graphql/generated';
-export declare function promptVariableEnvironmentAsync(nonInteractive: boolean): Promise<EnvironmentVariableEnvironment>;
+import { EnvironmentVariableEnvironment, EnvironmentVariableVisibility } from '../graphql/generated';
+export declare function promptVariableVisibilityAsync(nonInteractive: boolean, selectedVisibility?: EnvironmentVariableVisibility | null): Promise<EnvironmentVariableVisibility>;
+type EnvironmentPromptArgs = {
+    nonInteractive: boolean;
+    selectedEnvironments?: EnvironmentVariableEnvironment[];
+    availableEnvironments?: EnvironmentVariableEnvironment[];
+};
+export declare function promptVariableEnvironmentAsync(input: EnvironmentPromptArgs & {
+    multiple: true;
+}): Promise<EnvironmentVariableEnvironment[]>;
+export declare function promptVariableEnvironmentAsync(input: EnvironmentPromptArgs & {
+    multiple?: false;
+}): Promise<EnvironmentVariableEnvironment>;
 export declare function promptVariableValueAsync({ nonInteractive, required, hidden, initial, }: {
     nonInteractive: boolean;
     required?: boolean;
     initial?: string | null;
     hidden?: boolean;
 }): Promise<string>;
-export declare function promptVariableNameAsync(nonInteractive: boolean): Promise<string>;
+export declare function promptVariableNameAsync(nonInteractive: boolean, initialValue?: string): Promise<string>;
+export {};

package/build/utils/prompts.js

@@ -1,19 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.promptVariableNameAsync = exports.promptVariableValueAsync = exports.promptVariableEnvironmentAsync = void 0;
+exports.promptVariableNameAsync = exports.promptVariableValueAsync = exports.promptVariableEnvironmentAsync = exports.promptVariableVisibilityAsync = void 0;
 const tslib_1 = require("tslib");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const capitalize_1 = tslib_1.__importDefault(require("./expodash/capitalize"));
 const generated_1 = require("../graphql/generated");
 const prompts_1 = require("../prompts");
-async function promptVariableEnvironmentAsync(nonInteractive) {
+async function promptVariableVisibilityAsync(nonInteractive, selectedVisibility) {
+    if (nonInteractive) {
+        throw new Error('The `--visibility` flag must be set when running in `--non-interactive` mode.');
+    }
+    return await (0, prompts_1.selectAsync)('Select visibility:', Object.values(generated_1.EnvironmentVariableVisibility).map(visibility => ({
+        title: (0, capitalize_1.default)(visibility),
+        value: visibility,
+        selected: visibility === selectedVisibility,
+    })));
+}
+exports.promptVariableVisibilityAsync = promptVariableVisibilityAsync;
+async function promptVariableEnvironmentAsync({ nonInteractive, selectedEnvironments, multiple = false, availableEnvironments, }) {
     if (nonInteractive) {
         throw new Error('The `--environment` flag must be set when running in `--non-interactive` mode.');
     }
-    return await (0, prompts_1.selectAsync)('Select environment:', [
-        { title: 'Development', value: generated_1.EnvironmentVariableEnvironment.Development },
-        { title: 'Preview', value: generated_1.EnvironmentVariableEnvironment.Preview },
-        { title: 'Production', value: generated_1.EnvironmentVariableEnvironment.Production },
-    ]);
+    if (!multiple) {
+        return await (0, prompts_1.selectAsync)('Select environment:', (availableEnvironments ?? Object.values(generated_1.EnvironmentVariableEnvironment)).map(environment => ({
+            title: environment,
+            value: environment,
+        })));
+    }
+    const { environments } = await (0, prompts_1.promptAsync)({
+        message: 'Select environment:',
+        name: 'environments',
+        type: 'multiselect',
+        choices: Object.values(generated_1.EnvironmentVariableEnvironment).map(environment => ({
+            title: environment,
+            value: environment,
+            selected: selectedEnvironments?.includes(environment),
+        })),
+    });
+    return environments;
 }
 exports.promptVariableEnvironmentAsync = promptVariableEnvironmentAsync;
 async function promptVariableValueAsync({ nonInteractive, required = true, hidden = false, initial, }) {
@@ -41,7 +65,7 @@ async function promptVariableValueAsync({ nonInteractive, required = true, hidde
     return variableValue;
 }
 exports.promptVariableValueAsync = promptVariableValueAsync;
-async function promptVariableNameAsync(nonInteractive) {
+async function promptVariableNameAsync(nonInteractive, initialValue) {
     const validationMessage = 'Variable name may not be empty.';
     if (nonInteractive) {
         throw new Error(validationMessage);
@@ -50,6 +74,7 @@ async function promptVariableNameAsync(nonInteractive) {
         type: 'text',
         name: 'name',
         message: `Variable name:`,
+        initial: initialValue,
         validate: value => {
             if (!value) {
                 return validationMessage;

package/build/utils/variableUtils.d.ts

@@ -0,0 +1,4 @@
+import { EnvironmentVariableEnvironment, EnvironmentVariableFragment } from '../graphql/generated';
+export declare function formatVariableName(variable: EnvironmentVariableFragment): string;
+export declare function performForEnvironmentsAsync(environments: EnvironmentVariableEnvironment[] | null, fun: (environment: EnvironmentVariableEnvironment | undefined) => Promise<any>): Promise<any[]>;
+export declare function formatVariable(variable: EnvironmentVariableFragment): string;

package/build/utils/variableUtils.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatVariable = exports.performForEnvironmentsAsync = exports.formatVariableName = void 0;
+const tslib_1 = require("tslib");
+const dateformat_1 = tslib_1.__importDefault(require("dateformat"));
+const formatFields_1 = tslib_1.__importDefault(require("./formatFields"));
+const generated_1 = require("../graphql/generated");
+function formatVariableName(variable) {
+    const name = variable.name;
+    const scope = variable.scope === generated_1.EnvironmentVariableScope.Project ? 'project' : 'shared';
+    const environments = variable.environments?.join(', ') ?? '';
+    const updatedAt = variable.updatedAt ? new Date(variable.updatedAt).toLocaleString() : '';
+    return `${name} | ${scope} | ${environments} | Updated at: ${updatedAt}`;
+}
+exports.formatVariableName = formatVariableName;
+async function performForEnvironmentsAsync(environments, fun) {
+    const selectedEnvironments = environments ?? [undefined];
+    return await Promise.all(selectedEnvironments.map(env => fun(env)));
+}
+exports.performForEnvironmentsAsync = performForEnvironmentsAsync;
+function formatVariable(variable) {
+    return (0, formatFields_1.default)([
+        { label: 'ID', value: variable.id },
+        { label: 'Name', value: variable.name },
+        { label: 'Value', value: variable.value ?? '(secret)' },
+        { label: 'Scope', value: variable.scope },
+        { label: 'Created at', value: (0, dateformat_1.default)(variable.createdAt, 'mmm dd HH:MM:ss') },
+        { label: 'Updated at', value: (0, dateformat_1.default)(variable.updatedAt, 'mmm dd HH:MM:ss') },
+    ]);
+}
+exports.formatVariable = formatVariable;

package/build/worker/assets.d.ts

@@ -10,7 +10,7 @@ interface AssetMapOptions {
 /** Mapping of normalized file paths to a SHA512 hash */
 export type AssetMap = Record<string, string>;
 /** Creates an asset map of a given target path */
-declare function createAssetMapAsync(assetPath: string, options?: AssetMapOptions): Promise<AssetMap>;
+declare function createAssetMapAsync(assetPath?: string, options?: AssetMapOptions): Promise<AssetMap>;
 export interface Manifest {
     env: Record<string, string | undefined>;
 }
@@ -28,8 +28,13 @@ interface WorkerFileEntry {
 }
 /** Reads worker files while normalizing sourcemaps and providing normalized paths */
 declare function listWorkerFilesAsync(workerPath: string): AsyncGenerator<WorkerFileEntry>;
+interface AssetFileEntry {
+    normalizedPath: string;
+    sha512: string;
+    path: string;
+}
 /** Reads files of an asset maps and enumerates normalized paths and data */
-declare function listAssetMapFilesAsync(assetPath: string, assetMap: AssetMap): AsyncGenerator<WorkerFileEntry>;
+declare function listAssetMapFilesAsync(assetPath: string, assetMap: AssetMap): AsyncGenerator<AssetFileEntry>;
 /** Entry of a normalized (gzip-safe) path and file data */
 export type FileEntry = readonly [normalizedPath: string, data: Buffer | string];
 /** Packs file entries into a tar.gz file (path to tgz returned) */

package/build/worker/assets.js

@@ -65,8 +65,10 @@ function listFilesRecursively(basePath) {
 /** Creates an asset map of a given target path */
 async function createAssetMapAsync(assetPath, options) {
     const map = Object.create(null);
-    for await (const file of listFilesRecursively(assetPath)) {
-        map[file.normalizedPath] = await computeSha512HashAsync(file.path, options?.hashOptions);
+    if (assetPath) {
+        for await (const file of listFilesRecursively(assetPath)) {
+            map[file.normalizedPath] = await computeSha512HashAsync(file.path, options?.hashOptions);
+        }
     }
     return map;
 }
@@ -103,11 +105,10 @@ exports.listWorkerFilesAsync = listWorkerFilesAsync;
 async function* listAssetMapFilesAsync(assetPath, assetMap) {
     for (const normalizedPath in assetMap) {
         const filePath = node_path_1.default.resolve(assetPath, normalizedPath.split('/').join(node_path_1.default.sep));
-        const data = await node_fs_1.default.promises.readFile(filePath);
         yield {
             normalizedPath,
             path: filePath,
-            data,
+            sha512: assetMap[normalizedPath],
         };
     }
 }

package/build/worker/deployment.d.ts

@@ -10,6 +10,16 @@ export declare function getSignedDeploymentUrlAsync(graphqlClient: ExpoGraphqlCl
     /** If the terminal is running in non interactive mode or not */
     nonInteractive?: boolean;
 }): Promise<string>;
+/**
+ * Assign a dev domain name to a project.
+ *   - When running in interactive mode, it will prompt the user with a suggested domain name.
+ *   - When running in non interactive mode, it will auto-assign the suggested domain name.
+ */
+export declare function assignDevDomainNameAsync({ graphqlClient, appId, nonInteractive, }: {
+    graphqlClient: ExpoGraphqlClient;
+    appId: string;
+    nonInteractive?: boolean;
+}): ReturnType<typeof DeploymentsMutation.assignDevDomainNameAsync>;
 export declare function assignWorkerDeploymentAliasAsync({ graphqlClient, appId, deploymentId, aliasName, }: {
     graphqlClient: ExpoGraphqlClient;
     appId: string;

package/build/worker/deployment.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.selectWorkerDeploymentOnAppAsync = exports.assignWorkerDeploymentProductionAsync = exports.assignWorkerDeploymentAliasAsync = exports.getSignedDeploymentUrlAsync = void 0;
+exports.selectWorkerDeploymentOnAppAsync = exports.assignWorkerDeploymentProductionAsync = exports.assignWorkerDeploymentAliasAsync = exports.assignDevDomainNameAsync = exports.getSignedDeploymentUrlAsync = void 0;
 const tslib_1 = require("tslib");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const mutations_1 = require("./mutations");
@@ -19,23 +19,20 @@ async function getSignedDeploymentUrlAsync(graphqlClient, options) {
     }
     catch (error) {
         const isMissingDevDomain = error?.graphQLErrors?.some(e => ['APP_NO_DEV_DOMAIN_NAME'].includes(e?.extensions?.errorCode));
+        // Throw unexpected errors eagerly
         if (!isMissingDevDomain) {
             throw error;
         }
-        if (options.nonInteractive) {
-            throw new Error('The project URL needs to be set up, but the terminal is running in non-interactive mode.');
-        }
-        const suggestedDevDomainName = await queries_1.DeploymentsQuery.getSuggestedDevDomainByAppIdAsync(graphqlClient, { appId: options.appId });
+        // Ensure the callback is invoked, containing cleanup logic for possible spinners
         options.onSetupDevDomain?.();
-        await chooseDevDomainNameAsync({
+        // Assign the dev domain name by prompting the user
+        await assignDevDomainNameAsync({
             graphqlClient,
             appId: options.appId,
-            initial: suggestedDevDomainName,
-        });
-        return await mutations_1.DeploymentsMutation.createSignedDeploymentUrlAsync(graphqlClient, {
-            appId: options.appId,
-            deploymentIdentifier: options.deploymentIdentifier,
+            nonInteractive: options.nonInteractive,
         });
+        // Retry creating the signed URL
+        return await getSignedDeploymentUrlAsync(graphqlClient, options);
     }
 }
 exports.getSignedDeploymentUrlAsync = getSignedDeploymentUrlAsync;
@@ -55,14 +52,14 @@ function formatDevDomainName(name = '') {
         .replace(DEV_DOMAIN_INVALID_MULTIPLE_HYPHENS, '-')
         .trim();
 }
-async function chooseDevDomainNameAsync({ graphqlClient, appId, initial, }) {
+async function promptDevDomainNameAsync(initialDevDomain) {
     const rootDomain = `.${logs_1.EXPO_BASE_DOMAIN}.app`;
     const memoizedFormatDevDomainName = (0, memoize_1.memoize)(formatDevDomainName);
     const { name } = await (0, prompts_1.promptAsync)({
         type: 'text',
         name: 'name',
         message: 'Choose a preview URL for your project:',
-        initial,
+        initial: initialDevDomain,
         validate: (value) => {
             if (!value) {
                 return 'You have to choose a preview URL for your project';
@@ -95,29 +92,43 @@ async function chooseDevDomainNameAsync({ graphqlClient, appId, initial, }) {
             }
         },
     });
+    // This should never happen due to the validation, if it does its an error
     if (!name) {
         throw new Error('No preview URL provided, aborting deployment.');
     }
+    return name;
+}
+/**
+ * Assign a dev domain name to a project.
+ *   - When running in interactive mode, it will prompt the user with a suggested domain name.
+ *   - When running in non interactive mode, it will auto-assign the suggested domain name.
+ */
+async function assignDevDomainNameAsync({ graphqlClient, appId, nonInteractive, }) {
+    let devDomainName = await queries_1.DeploymentsQuery.getSuggestedDevDomainByAppIdAsync(graphqlClient, {
+        appId,
+    });
+    if (!nonInteractive) {
+        devDomainName = await promptDevDomainNameAsync(devDomainName);
+    }
     try {
-        const success = await mutations_1.DeploymentsMutation.assignDevDomainNameAsync(graphqlClient, {
+        return await mutations_1.DeploymentsMutation.assignDevDomainNameAsync(graphqlClient, {
             appId,
-            name,
+            name: devDomainName,
         });
-        if (!success) {
-            throw new Error('Failed to assign preview URL');
-        }
     }
     catch (error) {
         const isChosenNameTaken = error?.graphQLErrors?.some(e => ['DEV_DOMAIN_NAME_TAKEN'].includes(e?.extensions?.errorCode));
-        if (isChosenNameTaken) {
-            log_1.default.error(`The preview URL "${name}" is already taken, choose a different URL.`);
-            await chooseDevDomainNameAsync({ graphqlClient, appId, initial });
-        }
+        // Throw unexpected errors eagerly
         if (!isChosenNameTaken) {
             throw error;
         }
+        if (!nonInteractive) {
+            log_1.default.error(`The preview URL "${devDomainName}" is already taken, choose a different URL.`);
+        }
+        return await assignDevDomainNameAsync({ graphqlClient, appId, nonInteractive });
     }
 }
+exports.assignDevDomainNameAsync = assignDevDomainNameAsync;
 async function assignWorkerDeploymentAliasAsync({ graphqlClient, appId, deploymentId, aliasName, }) {
     return await mutations_1.DeploymentsMutation.assignAliasAsync(graphqlClient, {
         appId,

package/build/worker/upload.d.ts

@@ -13,6 +13,7 @@ export interface UploadResult {
     response: Response;
 }
 export declare function uploadAsync(params: UploadParams): Promise<UploadResult>;
+export declare function callUploadApiAsync(url: string | URL, init?: RequestInit): Promise<unknown>;
 export interface UploadPending {
     params: UploadParams;
 }