Improve handling password input (#158)

## What is the goal of this PR?

We've updated Console such that password input can be supplied interactively and non-interactively.

This is done primarily for security purpose, interactive input will be the preferred one since it is not stored in the CLI history. The non-interactive mode is still relevant and therefore supported, particularly for use in automation scripts and test.

Additionally, we've refactored the code to improve the terminologies. We used the word "Command" everywhere to refer to several different things which cause confusion. We've now made the terminologies more precise:
  - "CLI Options" is how we refer to the options specified when starting console (eg., `--username admin`)
  - "REPL command" is how we refer to the Console commands such as 'database create'
  - We've renamed the execution mode to be clear. Console has three modes of execution: "REPL mode", "script mode" and "inline command mode". The first mode is the interactive mode that most users will use. The second and the third mode are non-interactive and is suitable for use in automation scripts or tests.

## What are the changes implemented in this PR?

- Add support for interactive password input
- Refactored various names in the code
  - Improve the clarity of the different execution mode
  - Fix the fact that we really like the word "command" which is used everywhere
- Make non-final variables final whenever possible

Author: Ganeshwara Hananda

TypeDBConsole.java

@@ -31,8 +31,8 @@
 import com.vaticle.typedb.client.common.exception.TypeDBClientException;
 import com.vaticle.typedb.common.collection.Either;
 import com.vaticle.typedb.common.util.Java;
-import com.vaticle.typedb.console.command.ReplCommand;
-import com.vaticle.typedb.console.command.TransactionReplCommand;
+import com.vaticle.typedb.console.command.REPLCommand;
+import com.vaticle.typedb.console.command.TransactionREPLCommand;
 import com.vaticle.typedb.console.common.Printer;
 import com.vaticle.typedb.console.common.exception.TypeDBConsoleException;
 import com.vaticle.typeql.lang.TypeQL;
@@ -83,9 +83,9 @@ public class TypeDBConsole {
             "Welcome to TypeDB Console. You are now in TypeDB Wonderland!\n" +
             "Copyright (C) 2021 Vaticle\n";
     private static final Path COMMAND_HISTORY_FILE =
-            Paths.get(System.getProperty("user.home"), ".typedb-console-command-history").toAbsolutePath();
+            Paths.get(System.getProperty("user.home"), ".typedb-console-repl-history").toAbsolutePath();
     private static final Path TRANSACTION_HISTORY_FILE =
-            Paths.get(System.getProperty("user.home"), ".typedb-console-transaction-history").toAbsolutePath();
+            Paths.get(System.getProperty("user.home"), ".typedb-console-transaction-repl-history").toAbsolutePath();
     private static final Logger LOG = LoggerFactory.getLogger(TypeDBConsole.class);
 
     private final Printer printer;
@@ -105,15 +105,15 @@ private TypeDBConsole(Printer printer) {
 
     public static void main(String[] args) {
         configureAndVerifyJavaVersion();
-        CommandLineOptions options = parseCommandLine(args);
+        CLIOptions options = parseCLIOptions(args);
         TypeDBConsole console = new TypeDBConsole(new Printer(System.out, System.err));
         if (options.script() == null && options.commands() == null) {
-            console.runREPL(options);
+            console.runREPLMode(options);
         } else if (options.script() != null) {
-            boolean success = console.runScript(options, options.script());
+            boolean success = console.runScriptMode(options, options.script());
             if (!success) System.exit(1);
         } else if (options.commands() != null) {
-            boolean success = console.runCommands(options, options.commands());
+            boolean success = console.runInlineCommandMode(options, options.commands());
             if (!success) System.exit(1);
         }
     }
@@ -127,17 +127,17 @@ private static void configureAndVerifyJavaVersion() {
         }
     }
 
-    private static CommandLineOptions parseCommandLine(String[] args) {
-        CommandLineOptions options = new CommandLineOptions();
-        CommandLine command = new CommandLine(options);
+    private static CLIOptions parseCLIOptions(String[] args) {
+        CLIOptions options = new CLIOptions();
+        CommandLine CLI = new CommandLine(options);
         try {
-            int exitCode = command.execute(args);
+            int exitCode = CLI.execute(args);
             if (exitCode == 0) {
-                if (command.isUsageHelpRequested()) {
-                    command.usage(command.getOut());
+                if (CLI.isUsageHelpRequested()) {
+                    CLI.usage(CLI.getOut());
                     System.exit(0);
-                } else if (command.isVersionHelpRequested()) {
-                    command.printVersionHelp(command.getOut());
+                } else if (CLI.isVersionHelpRequested()) {
+                    CLI.printVersionHelp(CLI.getOut());
                     System.exit(0);
                 } else {
                     return options;
@@ -146,39 +146,39 @@ private static CommandLineOptions parseCommandLine(String[] args) {
                 System.exit(1);
             }
         } catch (CommandLine.ParameterException ex) {
-            command.getErr().println(ex.getMessage());
-            if (!CommandLine.UnmatchedArgumentException.printSuggestions(ex, command.getErr())) {
-                ex.getCommandLine().usage(command.getErr());
+            CLI.getErr().println(ex.getMessage());
+            if (!CommandLine.UnmatchedArgumentException.printSuggestions(ex, CLI.getErr())) {
+                ex.getCommandLine().usage(CLI.getErr());
             }
             System.exit(1);
         }
         return null;
     }
 
-    private void runREPL(CommandLineOptions options) {
+    private void runREPLMode(CLIOptions options) {
         printer.info(COPYRIGHT);
         try (TypeDBClient client = createTypeDBClient(options)) {
             LineReader reader = LineReaderBuilder.builder()
                     .terminal(terminal)
                     .variable(LineReader.HISTORY_FILE, COMMAND_HISTORY_FILE)
                     .build();
             while (true) {
-                ReplCommand command;
+                REPLCommand command;
                 try {
-                    command = ReplCommand.getCommand(reader, printer, "> ", client.isCluster());
+                    command = REPLCommand.readREPLCommand(reader, printer, "> ", client.isCluster());
                 } catch (InterruptedException e) {
                     break;
                 }
                 if (command.isExit()) {
                     break;
                 } else if (command.isHelp()) {
-                    printer.info(ReplCommand.getHelpMenu(client));
+                    printer.info(REPLCommand.createHelpMenu(client));
                 } else if (command.isClear()) {
                     reader.getTerminal().puts(InfoCmp.Capability.clear_screen);
                 } else if (command.isUserList()) {
                     runUserList(client);
                 } else if (command.isUserCreate()) {
-                    ReplCommand.User.Create userCommand = command.asUserCreate();
+                    REPLCommand.User.Create userCommand = command.asUserCreate();
                     runUserCreate(client, userCommand.user(), userCommand.password());
                 } else if (command.isUserDelete()) {
                     runUserDelete(client, command.asUserDelete().user());
@@ -201,7 +201,7 @@ private void runREPL(CommandLineOptions options) {
                         printer.error("The option '--any-replica' is only available in TypeDB Cluster.");
                         continue;
                     }
-                    boolean shouldExit = runTransactionREPL(client, database, sessionType, transactionType, typedbOptions);
+                    boolean shouldExit = transactionREPL(client, database, sessionType, transactionType, typedbOptions);
                     if (shouldExit) break;
                 }
             }
@@ -212,7 +212,7 @@ private void runREPL(CommandLineOptions options) {
         }
     }
 
-    private boolean runTransactionREPL(TypeDBClient client, String database, TypeDBSession.Type sessionType, TypeDBTransaction.Type transactionType, TypeDBOptions options) {
+    private boolean transactionREPL(TypeDBClient client, String database, TypeDBSession.Type sessionType, TypeDBTransaction.Type transactionType, TypeDBOptions options) {
         LineReader reader = LineReaderBuilder.builder()
                 .terminal(terminal)
                 .variable(LineReader.HISTORY_FILE, TRANSACTION_HISTORY_FILE)
@@ -224,23 +224,23 @@ private boolean runTransactionREPL(TypeDBClient client, String database, TypeDBS
         try (TypeDBSession session = client.session(database, sessionType, options);
              TypeDBTransaction tx = session.transaction(transactionType, options)) {
             while (true) {
-                Either<TransactionReplCommand, String> command;
+                Either<TransactionREPLCommand, String> command;
                 try {
-                    command = TransactionReplCommand.getCommand(reader, prompt.toString());
+                    command = TransactionREPLCommand.readCommand(reader, prompt.toString());
                 } catch (InterruptedException e) {
                     break;
                 }
                 if (command.isSecond()) {
                     printer.error(command.second());
                     continue;
                 } else {
-                    TransactionReplCommand replCommand = command.first();
+                    TransactionREPLCommand replCommand = command.first();
                     if (replCommand.isExit()) {
                         return true;
                     } else if (replCommand.isClear()) {
                         reader.getTerminal().puts(InfoCmp.Capability.clear_screen);
                     } else if (replCommand.isHelp()) {
-                        printer.info(TransactionReplCommand.getHelpMenu());
+                        printer.info(TransactionREPLCommand.createHelpMenu());
                     } else if (replCommand.isCommit()) {
                         runCommit(tx);
                         break;
@@ -262,27 +262,27 @@ private boolean runTransactionREPL(TypeDBClient client, String database, TypeDBS
         return false;
     }
 
-    private boolean runScript(CommandLineOptions options, String script) {
+    private boolean runScriptMode(CLIOptions options, String script) {
         String scriptLines;
         try {
             scriptLines = new String(Files.readAllBytes(Paths.get(Objects.requireNonNull(script))), StandardCharsets.UTF_8);
         } catch (IOException e) {
             printer.error("Failed to open file '" + options.script() + "'");
             return false;
         }
-        return runCommands(options, Arrays.stream(scriptLines.split("\n")).collect(toList()));
+        return runInlineCommandMode(options, Arrays.stream(scriptLines.split("\n")).collect(toList()));
     }
 
-    private boolean runCommands(CommandLineOptions options, List<String> commandStrings) {
-        commandStrings = commandStrings.stream().map(x -> x.trim()).filter(x -> !x.isEmpty()).collect(toList());
+    private boolean runInlineCommandMode(CLIOptions options, List<String> inlineCommands) {
+        inlineCommands = inlineCommands.stream().map(x -> x.trim()).filter(x -> !x.isEmpty()).collect(toList());
         boolean[] cancelled = new boolean[]{false};
         terminal.handle(Terminal.Signal.INT, s -> cancelled[0] = true);
         try (TypeDBClient client = createTypeDBClient(options)) {
             int i = 0;
-            for (; i < commandStrings.size() && !cancelled[0]; i++) {
-                String commandString = commandStrings.get(i);
+            for (; i < inlineCommands.size() && !cancelled[0]; i++) {
+                String commandString = inlineCommands.get(i);
                 printer.info("+ " + commandString);
-                ReplCommand command = ReplCommand.getCommand(commandString, client.isCluster());
+                REPLCommand command = REPLCommand.readREPLCommand(commandString, null, client.isCluster());
                 if (command != null) {
                     if (command.isUserList()) {
                         boolean success = runUserList(client);
@@ -319,10 +319,10 @@ private boolean runCommands(CommandLineOptions options, List<String> commandStri
                         }
                         try (TypeDBSession session = client.session(database, sessionType, sessionOptions);
                              TypeDBTransaction tx = session.transaction(transactionType)) {
-                            for (i += 1; i < commandStrings.size() && !cancelled[0]; i++) {
-                                String txCommandString = commandStrings.get(i);
+                            for (i += 1; i < inlineCommands.size() && !cancelled[0]; i++) {
+                                String txCommandString = inlineCommands.get(i);
                                 printer.info("++ " + txCommandString);
-                                Either<TransactionReplCommand, String> txCommand = TransactionReplCommand.getCommand(txCommandString);
+                                Either<TransactionREPLCommand, String> txCommand = TransactionREPLCommand.readCommand(txCommandString);
                                 if (txCommand.isSecond()) {
                                     printer.error(txCommand.second());
                                     return false;
@@ -365,7 +365,7 @@ private boolean runCommands(CommandLineOptions options, List<String> commandStri
         return true;
     }
 
-    private TypeDBClient createTypeDBClient(CommandLineOptions options) {
+    private TypeDBClient createTypeDBClient(CLIOptions options) {
         TypeDBClient client = null;
         try {
             if (options.server() != null) {
@@ -385,7 +385,7 @@ private TypeDBClient createTypeDBClient(CommandLineOptions options) {
         return client;
     }
 
-    private TypeDBCredential createTypeDBCredential(CommandLineOptions options) {
+    private TypeDBCredential createTypeDBCredential(CLIOptions options) {
         TypeDBCredential credential;
         if (options.tlsEnabled()) {
             String optRootCa = options.tlsRootCA();
@@ -604,50 +604,69 @@ private <T> void printCancellableResult(Stream<T> results, Consumer<T> printFn)
     }
 
     @CommandLine.Command(name = "typedb console", mixinStandardHelpOptions = true, version = {com.vaticle.typedb.console.Version.VERSION})
-    private static class CommandLineOptions implements Runnable {
+    private static class CLIOptions implements Runnable {
 
-        @CommandLine.Option(names = {"--server"},
-                description = "TypeDB address to which Console will connect to")
+        @CommandLine.Option(
+                names = {"--server"},
+                description = "TypeDB address to which Console will connect to"
+        )
         private @Nullable
         String server;
 
-        @CommandLine.Option(names = {"--cluster"},
-                description = "TypeDB Cluster address to which Console will connect to")
+        @CommandLine.Option(
+                names = {"--cluster"},
+                description = "TypeDB Cluster address to which Console will connect to"
+        )
         private @Nullable
         String cluster;
 
-        @CommandLine.Option(names = {"--username"},
-                description = "Username")
+        @CommandLine.Option(names = {"--username"}, description = "Username")
         private @Nullable
         String username;
 
-        @CommandLine.Option(names = {"--password"},
-                description = "Password")
+        @CommandLine.Option(
+                names = {"--password"},
+                description = "Password",
+                prompt = "Enter password:",
+                interactive = true,
+                arity = "0..1"
+        )
         private @Nullable
         String password;
 
-        @CommandLine.Option(names = {"--tls-enabled"},
-                description = "Whether to connect to TypeDB Cluster with TLS encryption")
+        @CommandLine.Option(
+                names = {"--tls-enabled"},
+                description = "Whether to connect to TypeDB Cluster with TLS encryption"
+        )
         private boolean tlsEnabled;
 
-        @CommandLine.Option(names = {"--tls-root-ca"},
-                description = "Path to the TLS root CA file")
+        @CommandLine.Option(
+                names = {"--tls-root-ca"},
+                description = "Path to the TLS root CA file"
+        )
         private @Nullable
         String tlsRootCA;
 
-        @CommandLine.Option(names = {"--script"},
-                description = "Script with commands to run in the Console, without interactive mode")
+        @CommandLine.Option(
+                names = {"--script"},
+                description = "Script with commands to run in the Console, without interactive mode"
+        )
         private @Nullable
         String script;
 
-        @CommandLine.Option(names = {"--command"},
-                description = "Commands to run in the Console, without interactive mode")
+        @CommandLine.Option(
+                names = {"--command"},
+                description = "Commands to run in the Console, without interactive mode"
+        )
         private @Nullable
         List<String> commands;
 
         @CommandLine.Spec
         CommandLine.Model.CommandSpec spec;
 
+        private CLIOptions() {
+        }
+
         @Override
         public void run() {
             validateAddress();