eas-cli 12.5.1 → 12.5.3

package/build/commands/env/update.js

@@ -3,7 +3,10 @@ var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const core_1 = require("@oclif/core");
+const assert_1 = tslib_1.__importDefault(require("assert"));
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
 const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
 const flags_1 = require("../../commandUtils/flags");
 const generated_1 = require("../../graphql/generated");
@@ -13,10 +16,11 @@ const log_1 = tslib_1.__importDefault(require("../../log"));
 const projectUtils_1 = require("../../project/projectUtils");
 const prompts_1 = require("../../prompts");
 const prompts_2 = require("../../utils/prompts");
+const variableUtils_1 = require("../../utils/variableUtils");
 class EnvironmentVariableUpdate extends EasCommand_1.default {
     async runAsync() {
         const { flags } = await this.parse(_a);
-        let { name, value, scope, 'non-interactive': nonInteractive, environment, visibility, } = this.validateFlags(flags);
+        const { name, value: rawValue, scope, 'variable-name': currentName, 'variable-environment': currentEnvironment, 'non-interactive': nonInteractive, environment: environments, type, visibility, } = this.validateFlags(flags);
         const { privateProjectConfig: { projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(_a, {
             nonInteractive,
         });
@@ -24,107 +28,167 @@ class EnvironmentVariableUpdate extends EasCommand_1.default {
             (0, projectUtils_1.getDisplayNameForProjectIdAsync)(graphqlClient, projectId),
             (0, projectUtils_1.getOwnerAccountForProjectIdAsync)(graphqlClient, projectId),
         ]);
+        let selectedVariable;
+        let existingVariables = [];
+        const suffix = scope === generated_1.EnvironmentVariableScope.Project
+            ? `on project ${projectDisplayName}`
+            : `on account ${ownerAccount.name}`;
         if (scope === generated_1.EnvironmentVariableScope.Project) {
-            if (!environment) {
-                environment = await (0, prompts_2.promptVariableEnvironmentAsync)(nonInteractive);
-            }
-            const existingVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdAsync(graphqlClient, {
+            existingVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdAsync(graphqlClient, {
                 appId: projectId,
-                environment,
+                environment: currentEnvironment,
+                filterNames: currentName ? [currentName] : undefined,
             });
-            if (!name) {
-                name = await (0, prompts_1.selectAsync)('Select variable', existingVariables.map(variable => ({
-                    title: variable.name,
-                    value: variable.name,
-                })));
-            }
-            const existingVariable = existingVariables.find(variable => variable.name === name);
-            if (!existingVariable) {
-                throw new Error(`Variable with name ${name} does not exist on project ${projectDisplayName}`);
-            }
-            if (!value) {
-                value = await (0, prompts_2.promptVariableValueAsync)({
-                    nonInteractive,
-                    required: false,
-                    initial: existingVariable.value,
-                });
-                if (!value || value.length === 0) {
-                    value = '';
-                }
-            }
-            const variable = await EnvironmentVariableMutation_1.EnvironmentVariableMutation.createForAppAsync(graphqlClient, {
-                name,
-                value,
-                environment,
-                visibility,
-                overwrite: true,
-            }, projectId);
-            if (!variable) {
-                throw new Error(`Could not update variable with name ${name} on project ${projectDisplayName}`);
-            }
-            log_1.default.withTick(`Updated variable ${chalk_1.default.bold(name)} on project ${chalk_1.default.bold(projectDisplayName)}.`);
         }
-        else if (scope === generated_1.EnvironmentVariableScope.Shared) {
-            const sharedVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, {
+        if (scope === generated_1.EnvironmentVariableScope.Shared) {
+            existingVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, {
                 appId: projectId,
+                environment: currentEnvironment,
+                filterNames: currentName ? [currentName] : undefined,
             });
+        }
+        if (existingVariables.length === 0) {
+            throw new Error(`Variable with name ${currentName} ${currentEnvironment ? `in environment ${currentEnvironment}` : ''} does not exist ${suffix}.`);
+        }
+        else if (existingVariables.length > 1) {
+            selectedVariable = await (0, prompts_1.selectAsync)('Select variable', existingVariables.map(variable => ({
+                title: (0, variableUtils_1.formatVariableName)(variable),
+                value: variable,
+            })));
+        }
+        else {
+            selectedVariable = existingVariables[0];
+        }
+        (0, assert_1.default)(selectedVariable, 'Variable must be selected');
+        const { name: newName, value: newValue, environment: newEnvironments, visibility: newVisibility, type: newType, } = await this.promptForMissingFlagsAsync(selectedVariable, {
+            name,
+            value: rawValue,
+            environment: environments,
+            visibility,
+            'non-interactive': nonInteractive,
+            type,
+        });
+        const variable = await EnvironmentVariableMutation_1.EnvironmentVariableMutation.updateAsync(graphqlClient, {
+            id: selectedVariable.id,
+            name: newName,
+            value: newValue,
+            environments: newEnvironments,
+            type: newType,
+            visibility: newVisibility,
+        });
+        if (!variable) {
+            throw new Error(`Could not update variable with name ${name} ${suffix}`);
+        }
+        log_1.default.withTick(`Updated variable ${chalk_1.default.bold(selectedVariable.name)} ${suffix}.`);
+    }
+    validateFlags(flags) {
+        if (flags['non-interactive']) {
+            if (!flags['variable-name']) {
+                throw new Error('Current name is required in non-interactive mode. Run the command with --variable-name flag.');
+            }
+            if (flags['type'] && !flags['value']) {
+                throw new Error('Value is required when type is set. Run the command with --value flag.');
+            }
+        }
+        return flags;
+    }
+    async promptForMissingFlagsAsync(selectedVariable, { name, value, environment: environments, visibility, 'non-interactive': nonInteractive, type, ...rest }) {
+        let newType;
+        if (type === 'file') {
+            newType = generated_1.EnvironmentSecretType.FileBase64;
+        }
+        else if (type === 'string') {
+            newType = generated_1.EnvironmentSecretType.String;
+        }
+        if (!nonInteractive) {
             if (!name) {
-                name = await (0, prompts_1.selectAsync)('Select variable', sharedVariables.map(variable => ({
-                    title: variable.name,
-                    value: variable.name,
-                })));
+                name = await (0, prompts_2.promptVariableNameAsync)(nonInteractive, selectedVariable.name);
+                if (!name || name.length === 0) {
+                    name = undefined;
+                }
             }
-            const existingVariable = sharedVariables.find(variable => variable.name === name);
-            if (!existingVariable) {
-                throw new Error("Variable with this name  doesn't exist on this account. Use a different name.");
+            log_1.default.log(selectedVariable.type, generated_1.EnvironmentSecretType.String === selectedVariable.type, generated_1.EnvironmentSecretType.FileBase64 === selectedVariable.type);
+            if (!type && !value && !nonInteractive) {
+                newType = await (0, prompts_2.promptVariableTypeAsync)(nonInteractive, selectedVariable.type);
+                if (!newType || newType === selectedVariable.type) {
+                    newType = undefined;
+                }
             }
             if (!value) {
                 value = await (0, prompts_2.promptVariableValueAsync)({
                     nonInteractive,
                     required: false,
-                    initial: existingVariable.value,
+                    initial: (newType ?? selectedVariable.type) === generated_1.EnvironmentSecretType.FileBase64
+                        ? undefined
+                        : selectedVariable.value,
                 });
-                if (!value || value.length === 0) {
-                    value = '';
+                if (!value || value.length === 0 || value === selectedVariable.value) {
+                    value = undefined;
                 }
             }
-            const variable = await EnvironmentVariableMutation_1.EnvironmentVariableMutation.createSharedVariableAsync(graphqlClient, {
-                name,
-                value,
-                visibility,
-                overwrite: true,
-            }, ownerAccount.id);
-            if (!variable) {
-                throw new Error(`Could not update variable with name ${name} on account ${ownerAccount.name}`);
+            let environmentFilePath;
+            if (newType === generated_1.EnvironmentSecretType.FileBase64 && value) {
+                environmentFilePath = path_1.default.resolve(value);
+                if (!(await fs_extra_1.default.pathExists(environmentFilePath))) {
+                    throw new Error(`File "${value}" does not exist`);
+                }
             }
-            log_1.default.withTick(`Updated shared variable ${chalk_1.default.bold(name)} on account ${chalk_1.default.bold(ownerAccount.name)}.`);
-        }
-    }
-    validateFlags(flags) {
-        if (flags['non-interactive']) {
-            if (!flags.name) {
-                throw new Error('Variable name is required in non-interactive mode. Run the command with --name flag.');
+            value = environmentFilePath ? await fs_extra_1.default.readFile(environmentFilePath, 'base64') : value;
+            if (!environments || environments.length === 0) {
+                environments = await (0, prompts_2.promptVariableEnvironmentAsync)({
+                    nonInteractive,
+                    multiple: true,
+                    selectedEnvironments: selectedVariable.environments ?? [],
+                });
+                if (!environments ||
+                    environments.length === 0 ||
+                    environments === selectedVariable.environments) {
+                    environments = undefined;
+                }
             }
-            if (flags.scope === generated_1.EnvironmentVariableScope.Project && !flags.environment) {
-                throw new Error('Environment is required when updating project-wide variable in non-interactive mode. Run the command with --environment flag.');
+            if (!visibility) {
+                visibility = await (0, prompts_2.promptVariableVisibilityAsync)(nonInteractive, selectedVariable.visibility);
+                if (!visibility || visibility === selectedVariable.visibility) {
+                    visibility = undefined;
+                }
             }
         }
-        return flags;
+        return {
+            name,
+            value,
+            environment: environments,
+            visibility,
+            scope: rest.scope ?? generated_1.EnvironmentVariableScope.Project,
+            'non-interactive': nonInteractive,
+            type: newType,
+            ...rest,
+        };
     }
 }
 _a = EnvironmentVariableUpdate;
 EnvironmentVariableUpdate.description = 'update an environment variable on the current project or owner account';
 EnvironmentVariableUpdate.hidden = true;
 EnvironmentVariableUpdate.flags = {
+    'variable-name': core_1.Flags.string({
+        description: 'Current name of the variable',
+    }),
+    'variable-environment': core_1.Flags.enum({
+        ...flags_1.EasEnvironmentFlagParameters,
+        description: 'Current environment of the variable to update',
+    }),
     name: core_1.Flags.string({
-        description: 'Name of the variable',
+        description: 'New name of the variable',
     }),
     value: core_1.Flags.string({
-        description: 'Text value or the variable',
+        description: 'New value or the variable',
+    }),
+    type: core_1.Flags.enum({
+        description: 'The type of variable',
+        options: ['string', 'file'],
     }),
     ...flags_1.EASVariableVisibilityFlag,
     ...flags_1.EASVariableScopeFlag,
-    ...flags_1.EASEnvironmentFlag,
+    ...flags_1.EASMultiEnvironmentFlag,
     ...flags_1.EASNonInteractiveFlag,
 };
 EnvironmentVariableUpdate.contextDefinition = {

package/build/commands/update/index.js

@@ -426,7 +426,6 @@ UpdatePublish.flags = {
     'rollout-percentage': core_1.Flags.integer({
         description: `Percentage of users this update should be immediately available to. Users not in the rollout will be served the previous latest update on the branch, even if that update is itself being rolled out. The specified number must be an integer between 1 and 100. When not specified, this defaults to 100.`,
         required: false,
-        hidden: true,
         min: 0,
         max: 100,
     }),

package/build/commands/worker/deploy.js

@@ -43,6 +43,19 @@ class WorkerDeploy extends EasCommand_1.default {
                 }
             }
         }
+        async function finalizeDeployAsync(deployParams) {
+            const finalizeDeployUrl = new URL('/deploy/finalize', deployParams.baseURL);
+            finalizeDeployUrl.searchParams.set('token', deployParams.token);
+            const result = await (0, upload_1.callUploadApiAsync)(finalizeDeployUrl, {
+                method: 'POST',
+                headers: {
+                    accept: 'application/json',
+                },
+            });
+            if (!result || typeof result !== 'object' || !('success' in result) || !result.success) {
+                throw new Error('Deploy failed: Incomplete asset uploads. Please try again');
+            }
+        }
         async function uploadTarballAsync(tarPath, uploadUrl) {
             const { response } = await (0, upload_1.uploadAsync)({
                 url: uploadUrl,
@@ -64,24 +77,30 @@ class WorkerDeploy extends EasCommand_1.default {
                 if (!json.success || !json.result || typeof json.result !== 'object') {
                     throw new Error(json.message ? `Upload failed: ${json.message}` : 'Upload failed!');
                 }
-                return json.result;
+                const { id, fullName, token } = json.result;
+                if (typeof token !== 'string') {
+                    throw new Error('Upload failed: API failed to return a deployment token');
+                }
+                else if (typeof id !== 'string') {
+                    throw new Error('Upload failed: API failed to return a deployment identifier');
+                }
+                else if (typeof fullName !== 'string') {
+                    throw new Error('Upload failed: API failed to return a script name');
+                }
+                const baseURL = new URL('/', uploadUrl).toString();
+                return { id, fullName, baseURL, token };
             }
         }
-        async function uploadAssetsAsync(assetMap, uploads) {
-            if (typeof uploads !== 'object' || !uploads) {
-                return;
-            }
-            // TODO(@kitten): Batch and upload multiple files in parallel
+        async function uploadAssetsAsync(assetMap, deployParams) {
             const uploadParams = [];
             const assetPath = projectDist.type === 'server' ? projectDist.clientPath : projectDist.path;
             if (!assetPath) {
                 return;
             }
             for await (const asset of WorkerAssets.listAssetMapFilesAsync(assetPath, assetMap)) {
-                const uploadURL = uploads[asset.normalizedPath];
-                if (uploadURL) {
-                    uploadParams.push({ url: uploadURL, filePath: asset.path });
-                }
+                const uploadURL = new URL(`/asset/${asset.sha512}`, deployParams.baseURL);
+                uploadURL.searchParams.set('token', deployParams.token);
+                uploadParams.push({ url: uploadURL.toString(), filePath: asset.path });
             }
             const progress = {
                 total: uploadParams.length,
@@ -147,7 +166,8 @@ class WorkerDeploy extends EasCommand_1.default {
             progress.fail('Failed to create deployment');
             throw error;
         }
-        await uploadAssetsAsync(assetMap, deployResult.uploads);
+        await uploadAssetsAsync(assetMap, deployResult);
+        await finalizeDeployAsync(deployResult);
         let deploymentAlias = null;
         if (flags.aliasName) {
             progress = (0, ora_1.ora)((0, chalk_1.default) `Assigning alias {bold ${flags.aliasName}} to deployment`).start();