eas-cli 12.5.0 → 12.5.2

package/build/commands/env/list.js

@@ -9,58 +9,65 @@ const flags_1 = require("../../commandUtils/flags");
 const generated_1 = require("../../graphql/generated");
 const EnvironmentVariablesQuery_1 = require("../../graphql/queries/EnvironmentVariablesQuery");
 const log_1 = tslib_1.__importDefault(require("../../log"));
-const formatVariable_1 = require("../../utils/formatVariable");
 const prompts_1 = require("../../utils/prompts");
+const variableUtils_1 = require("../../utils/variableUtils");
+async function getVariablesForScopeAsync(graphqlClient, { scope, includingSensitive, environment, projectId, }) {
+    if (scope === generated_1.EnvironmentVariableScope.Project) {
+        if (includingSensitive) {
+            return await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdWithSensitiveAsync(graphqlClient, {
+                appId: projectId,
+                environment,
+            });
+        }
+        return await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdAsync(graphqlClient, {
+            appId: projectId,
+            environment,
+        });
+    }
+    return includingSensitive
+        ? await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedWithSensitiveAsync(graphqlClient, {
+            appId: projectId,
+            environment,
+        })
+        : await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, { appId: projectId, environment });
+}
 class EnvironmentValueList extends EasCommand_1.default {
     async runAsync() {
-        let { flags: { environment, format, scope, 'include-sensitive': includeSensitive }, } = await this.parse(_a);
+        let { flags: { environment: environments, format, scope, 'include-sensitive': includeSensitive, 'non-interactive': nonInteractive, }, } = await this.parse(_a);
         const { privateProjectConfig: { projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(_a, {
             nonInteractive: true,
         });
-        if (scope === generated_1.EnvironmentVariableScope.Project && !environment) {
-            environment = await (0, prompts_1.promptVariableEnvironmentAsync)(false);
+        if (!environments) {
+            environments = await (0, prompts_1.promptVariableEnvironmentAsync)({ nonInteractive, multiple: true });
         }
-        const variables = await this.getVariablesForScopeAsync(graphqlClient, {
-            scope,
-            includingSensitive: includeSensitive,
-            environment,
-            projectId,
-        });
-        if (format === 'short') {
-            for (const variable of variables) {
-                // TODO: Add Learn more link
-                log_1.default.log(`${chalk_1.default.bold(variable.name)}=${variable.value ??
-                    "***** (This is a secret env variable that can only be accessed on EAS builder and can't be read in any UI. Learn more.)"}`);
+        await (0, variableUtils_1.performForEnvironmentsAsync)(environments, async (environment) => {
+            const variables = await getVariablesForScopeAsync(graphqlClient, {
+                scope,
+                includingSensitive: includeSensitive,
+                environment,
+                projectId,
+            });
+            log_1.default.addNewLineIfNone();
+            if (environment) {
+                log_1.default.log(chalk_1.default.bold(`Environment: ${environment}`));
             }
-        }
-        else {
-            if (scope === generated_1.EnvironmentVariableScope.Shared) {
-                log_1.default.log(chalk_1.default.bold('Shared variables for this account:'));
+            if (format === 'short') {
+                for (const variable of variables) {
+                    // TODO: Add Learn more link
+                    log_1.default.log(`${chalk_1.default.bold(variable.name)}=${variable.value ??
+                        "***** (This is a secret env variable that can only be accessed on EAS builder and can't be read in any UI. Learn more.)"}`);
+                }
             }
             else {
-                log_1.default.log(chalk_1.default.bold(`Variables for this project for environment ${environment}:`));
-            }
-            log_1.default.log(variables.map(variable => (0, formatVariable_1.formatVariable)(variable)).join(`\n\n${chalk_1.default.dim('———')}\n\n`));
-        }
-    }
-    async getVariablesForScopeAsync(graphqlClient, { scope, includingSensitive, environment, projectId, }) {
-        if (scope === generated_1.EnvironmentVariableScope.Project && environment) {
-            if (includingSensitive) {
-                return await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdWithSensitiveAsync(graphqlClient, {
-                    appId: projectId,
-                    environment,
-                });
+                if (scope === generated_1.EnvironmentVariableScope.Shared) {
+                    log_1.default.log(chalk_1.default.bold('Shared variables for this account:'));
+                }
+                else {
+                    log_1.default.log(chalk_1.default.bold(`Variables for this project:`));
+                }
+                log_1.default.log(variables.map(variable => (0, variableUtils_1.formatVariable)(variable)).join(`\n\n${chalk_1.default.dim('———')}\n\n`));
             }
-            return await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdAsync(graphqlClient, {
-                appId: projectId,
-                environment,
-            });
-        }
-        return includingSensitive
-            ? await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedWithSensitiveAsync(graphqlClient, {
-                appId: projectId,
-            })
-            : await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, { appId: projectId });
+        });
     }
 }
 _a = EnvironmentValueList;
@@ -77,6 +84,6 @@ EnvironmentValueList.flags = {
     }),
     ...flags_1.EASVariableFormatFlag,
     ...flags_1.EASVariableScopeFlag,
-    ...flags_1.EASEnvironmentFlag,
+    ...flags_1.EASMultiEnvironmentFlag,
 };
 exports.default = EnvironmentValueList;

package/build/commands/env/pull.js

@@ -14,7 +14,7 @@ class EnvironmentVariablePull extends EasCommand_1.default {
     async runAsync() {
         let { flags: { environment, path: targetPath, 'non-interactive': nonInteractive }, } = await this.parse(_a);
         if (!environment) {
-            environment = await (0, prompts_2.promptVariableEnvironmentAsync)(nonInteractive);
+            environment = await (0, prompts_2.promptVariableEnvironmentAsync)({ nonInteractive });
         }
         const { privateProjectConfig: { projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(_a, {
             nonInteractive,

package/build/commands/env/unlink.d.ts

@@ -1,11 +1,12 @@
 import EasCommand from '../../commandUtils/EasCommand';
+import { EnvironmentVariableEnvironment } from '../../graphql/generated';
 export default class EnvironmentVariableUnlink extends EasCommand {
     static description: string;
     static hidden: boolean;
     static flags: {
         'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        environment: import("@oclif/core/lib/interfaces").OptionFlag<import("../../graphql/generated").EnvironmentVariableEnvironment | undefined>;
-        name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        environment: import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableEnvironment[] | undefined>;
+        'variable-name': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
     };
     static contextDefinition: {
         loggedIn: import("../../commandUtils/context/LoggedInContextField").default;

package/build/commands/env/unlink.js

@@ -13,49 +13,76 @@ 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 EnvironmentVariableUnlink extends EasCommand_1.default {
     async runAsync() {
-        let { flags: { name, 'non-interactive': nonInteractive, environment }, } = await this.parse(_a);
+        let { flags: { 'variable-name': name, 'non-interactive': nonInteractive, environment: unlinkEnvironments, }, } = await this.parse(_a);
         const { privateProjectConfig: { projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(_a, {
             nonInteractive,
         });
-        if (!environment) {
-            environment = await (0, prompts_2.promptVariableEnvironmentAsync)(nonInteractive);
-        }
         const projectDisplayName = await (0, projectUtils_1.getDisplayNameForProjectIdAsync)(graphqlClient, projectId);
-        const appVariables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.byAppIdAsync(graphqlClient, {
+        const variables = await EnvironmentVariablesQuery_1.EnvironmentVariablesQuery.sharedAsync(graphqlClient, {
             appId: projectId,
-            environment,
+            filterNames: name ? [name] : undefined,
         });
-        const linkedVariables = appVariables.filter(({ scope }) => scope === generated_1.EnvironmentVariableScope.Shared);
-        if (linkedVariables.length === 0) {
-            throw new Error(`There are no linked shared env variables for project ${projectDisplayName}`);
-        }
-        if (!name) {
-            name = await (0, prompts_1.selectAsync)('Select shared variable to unlink', linkedVariables.map(variable => ({
-                title: variable.name,
-                value: variable.name,
+        let selectedVariable = variables[0];
+        if (variables.length > 1) {
+            if (nonInteractive) {
+                throw new Error("Multiple variables found, please select one using '--variable-name'");
+            }
+            selectedVariable = await (0, prompts_1.selectAsync)('Select shared variable', variables.map(variable => ({
+                title: (0, variableUtils_1.formatVariableName)(variable),
+                value: variable,
             })));
         }
-        const selectedVariable = linkedVariables.find(variable => variable.name === name);
         if (!selectedVariable) {
             throw new Error(`Shared variable ${name} doesn't exist`);
         }
-        const unlinkedVariable = await EnvironmentVariableMutation_1.EnvironmentVariableMutation.unlinkSharedEnvironmentVariableAsync(graphqlClient, selectedVariable.id, projectId, environment);
-        if (!unlinkedVariable) {
-            throw new Error(`Could not unlink variable with name ${selectedVariable.name} from project ${projectDisplayName}`);
+        let explicitSelect = false;
+        if (!nonInteractive && !unlinkEnvironments) {
+            const selectedEnvironments = (selectedVariable.linkedEnvironments ?? []).length > 0
+                ? selectedVariable.linkedEnvironments
+                : selectedVariable.environments;
+            const environments = await (0, prompts_2.promptVariableEnvironmentAsync)({
+                nonInteractive,
+                multiple: true,
+                selectedEnvironments: selectedEnvironments ?? [],
+            });
+            explicitSelect = true;
+            unlinkEnvironments = Object.values(generated_1.EnvironmentVariableEnvironment).filter(env => !environments.includes(env));
+        }
+        if (!unlinkEnvironments) {
+            await EnvironmentVariableMutation_1.EnvironmentVariableMutation.unlinkSharedEnvironmentVariableAsync(graphqlClient, selectedVariable.id, projectId);
+            log_1.default.withTick(`Unlinked variable ${chalk_1.default.bold(selectedVariable.name)} from project ${chalk_1.default.bold(projectDisplayName)} in ${selectedVariable.environments?.join(', ').toLocaleLowerCase()}.`);
+            return;
+        }
+        for (const environment of Object.values(generated_1.EnvironmentVariableEnvironment)) {
+            if (selectedVariable.linkedEnvironments?.includes(environment) !==
+                unlinkEnvironments.includes(environment)) {
+                if (!explicitSelect && unlinkEnvironments.includes(environment)) {
+                    log_1.default.withTick(`Variable ${chalk_1.default.bold(selectedVariable.name)} is already unlinked from ${environment.toLocaleLowerCase()}.`);
+                }
+                continue;
+            }
+            if (unlinkEnvironments.includes(environment)) {
+                await EnvironmentVariableMutation_1.EnvironmentVariableMutation.unlinkSharedEnvironmentVariableAsync(graphqlClient, selectedVariable.id, projectId, environment);
+                log_1.default.withTick(`Unlinked variable ${chalk_1.default.bold(selectedVariable.name)} from project ${chalk_1.default.bold(projectDisplayName)} in ${environment.toLocaleLowerCase()}.`);
+            }
+            else if (explicitSelect) {
+                await EnvironmentVariableMutation_1.EnvironmentVariableMutation.linkSharedEnvironmentVariableAsync(graphqlClient, selectedVariable.id, projectId, environment);
+                log_1.default.withTick(`Linked variable ${chalk_1.default.bold(selectedVariable.name)} to project ${chalk_1.default.bold(projectDisplayName)} in ${environment.toLocaleLowerCase()}.`);
+            }
         }
-        log_1.default.withTick(`Unlinked variable ${chalk_1.default.bold(unlinkedVariable.name)} from the project ${chalk_1.default.bold(projectDisplayName)}.`);
     }
 }
 _a = EnvironmentVariableUnlink;
 EnvironmentVariableUnlink.description = 'unlink a shared environment variable to the current project';
 EnvironmentVariableUnlink.hidden = true;
 EnvironmentVariableUnlink.flags = {
-    name: core_1.Flags.string({
+    'variable-name': core_1.Flags.string({
         description: 'Name of the variable',
     }),
-    ...flags_1.EASEnvironmentFlag,
+    ...flags_1.EASMultiEnvironmentFlag,
     ...flags_1.EASNonInteractiveFlag,
 };
 EnvironmentVariableUnlink.contextDefinition = {

package/build/commands/env/update.d.ts

@@ -1,13 +1,15 @@
 import EasCommand from '../../commandUtils/EasCommand';
-import { EnvironmentVariableScope, EnvironmentVariableVisibility } from '../../graphql/generated';
+import { EnvironmentVariableEnvironment, EnvironmentVariableScope, EnvironmentVariableVisibility } from '../../graphql/generated';
 export default class EnvironmentVariableUpdate extends EasCommand {
     static description: string;
     static hidden: boolean;
     static flags: {
         'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        environment: import("@oclif/core/lib/interfaces").OptionFlag<import("../../graphql/generated").EnvironmentVariableEnvironment | undefined>;
+        environment: import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableEnvironment[] | undefined>;
         scope: import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableScope>;
         visibility: import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableVisibility | undefined>;
+        'variable-name': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        'variable-environment': import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableEnvironment | undefined>;
         name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
         value: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
     };

package/build/commands/env/update.js

@@ -3,6 +3,7 @@ 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 EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
 const flags_1 = require("../../commandUtils/flags");
@@ -13,10 +14,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);
+        let { name, value, scope, 'variable-name': currentName, 'variable-environment': currentEnvironment, 'non-interactive': nonInteractive, environment: environments, visibility, } = this.validateFlags(flags);
         const { privateProjectConfig: { projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(_a, {
             nonInteractive,
         });
@@ -24,89 +26,82 @@ 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');
+        if (!nonInteractive) {
             if (!name) {
-                name = await (0, prompts_1.selectAsync)('Select variable', sharedVariables.map(variable => ({
-                    title: variable.name,
-                    value: variable.name,
-                })));
-            }
-            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.");
+                name = await (0, prompts_2.promptVariableNameAsync)(nonInteractive, selectedVariable.name);
+                if (!name || name.length === 0) {
+                    name = undefined;
+                }
             }
             if (!value) {
                 value = await (0, prompts_2.promptVariableValueAsync)({
                     nonInteractive,
                     required: false,
-                    initial: existingVariable.value,
+                    initial: selectedVariable.value,
                 });
                 if (!value || value.length === 0) {
-                    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}`);
+            if (!environments || environments.length === 0) {
+                environments = await (0, prompts_2.promptVariableEnvironmentAsync)({
+                    nonInteractive,
+                    multiple: true,
+                    selectedEnvironments: selectedVariable.environments ?? [],
+                });
             }
-            log_1.default.withTick(`Updated shared variable ${chalk_1.default.bold(name)} on account ${chalk_1.default.bold(ownerAccount.name)}.`);
+            if (!visibility) {
+                visibility = await (0, prompts_2.promptVariableVisibilityAsync)(nonInteractive, selectedVariable.visibility);
+            }
+        }
+        const variable = await EnvironmentVariableMutation_1.EnvironmentVariableMutation.updateAsync(graphqlClient, {
+            id: selectedVariable.id,
+            name,
+            value,
+            environments,
+            visibility,
+        });
+        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.name) {
-                throw new Error('Variable name is required in non-interactive mode. Run the command with --name flag.');
-            }
-            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 (!flags['variable-name']) {
+                throw new Error('Current name is required in non-interactive mode. Run the command with --variable-name flag.');
             }
         }
         return flags;
@@ -116,15 +111,22 @@ _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',
     }),
     ...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/update/republish.d.ts

@@ -7,6 +7,8 @@ export default class UpdateRepublish extends EasCommand {
         channel: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
         branch: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
         group: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        'destination-channel': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        'destination-branch': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
         message: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
         platform: import("@oclif/core/lib/interfaces").OptionFlag<string>;
         'private-key-path': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;

package/build/commands/update/republish.js

@@ -8,10 +8,11 @@ const queries_2 = require("../../channel/queries");
 const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
 const flags_1 = require("../../commandUtils/flags");
 const pagination_1 = require("../../commandUtils/pagination");
+const BranchQuery_1 = require("../../graphql/queries/BranchQuery");
 const UpdateQuery_1 = require("../../graphql/queries/UpdateQuery");
 const log_1 = tslib_1.__importDefault(require("../../log"));
 const prompts_1 = require("../../prompts");
-const getBranchNameFromChannelNameAsync_1 = require("../../update/getBranchNameFromChannelNameAsync");
+const getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync_1 = require("../../update/getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync");
 const queries_3 = require("../../update/queries");
 const republish_1 = require("../../update/republish");
 const utils_1 = require("../../update/utils");
@@ -47,13 +48,14 @@ class UpdateRepublish extends EasCommand_1.default {
             }
             log_1.default.withTick(`The republished update group will appear on the same platforms it was originally published on: ${platformsFromUpdates.join(', ')}`);
         }
-        const updateMessage = await getOrAskUpdateMessageAsync(updatesToPublish, flags);
         const arbitraryUpdate = updatesToPublish[0];
+        const targetBranch = await getOrAskTargetBranchAsync(graphqlClient, projectId, flags, arbitraryUpdate);
+        const updateMessage = await getOrAskUpdateMessageAsync(updatesToPublish, flags);
         await (0, republish_1.republishAsync)({
             graphqlClient,
             app: { exp, projectId },
             updatesToPublish,
-            targetBranch: { branchId: arbitraryUpdate.branchId, branchName: arbitraryUpdate.branchName },
+            targetBranch,
             updateMessage,
             codeSigningInfo,
             json: flags.json,
@@ -63,6 +65,8 @@ class UpdateRepublish extends EasCommand_1.default {
         const branchName = rawFlags.branch;
         const channelName = rawFlags.channel;
         const groupId = rawFlags.group;
+        const destinationChannelName = rawFlags['destination-channel'];
+        const destinationBranchName = rawFlags['destination-branch'];
         const nonInteractive = rawFlags['non-interactive'];
         const privateKeyPath = rawFlags['private-key-path'];
         if (nonInteractive && !groupId) {
@@ -72,6 +76,8 @@ class UpdateRepublish extends EasCommand_1.default {
         return {
             branchName,
             channelName,
+            destinationChannelName,
+            destinationBranchName,
             groupId,
             platform,
             updateMessage: rawFlags.message,
@@ -96,6 +102,14 @@ UpdateRepublish.flags = {
         description: 'Update group ID to republish',
         exclusive: ['branch', 'channel'],
     }),
+    'destination-channel': core_1.Flags.string({
+        description: 'Channel name to select a branch to republish to if republishing to a different branch',
+        exclusive: ['destination-branch'],
+    }),
+    'destination-branch': core_1.Flags.string({
+        description: 'Branch name to republish to if republishing to a different branch',
+        exclusive: ['destination-channel'],
+    }),
     message: core_1.Flags.string({
         char: 'm',
         description: 'Short message describing the republished update group',
@@ -118,6 +132,22 @@ UpdateRepublish.contextDefinition = {
     ..._a.ContextOptions.LoggedIn,
 };
 exports.default = UpdateRepublish;
+async function getOrAskTargetBranchAsync(graphqlClient, projectId, flags, arbitraryUpdate) {
+    // if branch name supplied, use that
+    if (flags.destinationBranchName) {
+        const branch = await BranchQuery_1.BranchQuery.getBranchByNameAsync(graphqlClient, {
+            appId: projectId,
+            name: flags.destinationBranchName,
+        });
+        return { branchId: branch.id, branchName: branch.name };
+    }
+    // if provided channel name but was non-interactive
+    if (flags.destinationChannelName) {
+        return await (0, getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync_1.getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync)(graphqlClient, projectId, flags.destinationChannelName);
+    }
+    // if neither provided, assume republish on same branch
+    return { branchId: arbitraryUpdate.branchId, branchName: arbitraryUpdate.branchName };
+}
 /** Retrieve the update group from either the update group id, or select from branch name. */
 async function getOrAskUpdatesAsync(graphqlClient, projectId, flags) {
     if (flags.groupId) {
@@ -213,7 +243,7 @@ async function askUpdatesFromBranchNameAsync(graphqlClient, { projectId, branchN
 }
 /** Ask the user which update needs to be republished by channel name, this requires interactive mode */
 async function askUpdatesFromChannelNameAsync(graphqlClient, { projectId, channelName, json, nonInteractive, }) {
-    const branchName = await (0, getBranchNameFromChannelNameAsync_1.getBranchNameFromChannelNameAsync)(graphqlClient, projectId, channelName);
+    const { branchName } = await (0, getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync_1.getBranchFromChannelNameAndCreateAndLinkIfNotExistsAsync)(graphqlClient, projectId, channelName);
     return await askUpdatesFromBranchNameAsync(graphqlClient, {
         projectId,
         branchName,