Support relative script and source commands (#293)

## Usage and product changes

We support using relative paths for the `--script` command (relative to
the current directory), as well as relative paths for the REPL `source`
command.

When `source` is invoked _from_ a script, the sourced file is
relativised to the script, rather than the current working directory.

## Implementation

* Store the console's working directory, and the script directory if a
script is active (scripts can't be nested, which enables this!)
* Relativize to either the script directory or the working directory as
when running with `--script` mode and `>> source <path>
` commands

Author: flyingsilverfin

src/cli.rs

@@ -16,7 +16,8 @@ pub struct Args {
 
     /// Executes all console commands directly from the script(s) in the order of each specified script.
     /// Exits if any script errors at any point.
-    /// Files must follow the convention of terminating queries with an empty newline
+    /// Files must follow the convention of terminating queries with an empty newline.
+    /// File path can be absolute or relative to the current directory
     #[arg(long, value_name = "path to script file")]
     pub script: Vec<String>,
 

src/main.rs

@@ -5,13 +5,14 @@
  */
 
 use std::{
+    env,
     env::temp_dir,
     error::Error,
     fmt::{Debug, Display, Formatter},
     fs::File,
     io,
     io::BufRead,
-    path::Path,
+    path::{Path, PathBuf},
     process::exit,
     rc::Rc,
     sync::Arc,
@@ -56,22 +57,38 @@ const DIAGNOSTICS_REPORTING_URI: &'static str =
     "https://7f0ccb67b03abfccbacd7369d1f4ac6b@o4506315929812992.ingest.sentry.io/4506355433537536";
 
 struct ConsoleContext {
+    invocation_dir: PathBuf,
     repl_stack: Vec<Rc<Repl<ConsoleContext>>>,
     background_runtime: BackgroundRuntime,
     driver: Arc<TypeDBDriver>,
     transaction: Option<(Transaction, bool)>,
+    script_dir: Option<String>,
 }
 
-impl ReplContext for ConsoleContext {
-    fn current_repl(&self) -> &Repl<Self> {
-        self.repl_stack.last().unwrap()
+impl ConsoleContext {
+    fn convert_path(&self, path: &str) -> PathBuf {
+        let path = Path::new(path);
+        if !path.is_absolute() {
+            match self.script_dir.as_ref() {
+                None => self.invocation_dir.join(path),
+                Some(dir) => PathBuf::from(dir).join(path),
+            }
+        } else {
+            path.to_path_buf()
+        }
     }
 
     fn has_changes(&self) -> bool {
         self.transaction.as_ref().is_some_and(|(_, has_writes)| *has_writes)
     }
 }
 
+impl ReplContext for ConsoleContext {
+    fn current_repl(&self) -> &Repl<Self> {
+        self.repl_stack.last().unwrap()
+    }
+}
+
 fn main() {
     let mut args = Args::parse();
     if args.version {
@@ -111,8 +128,15 @@ fn main() {
     };
 
     let repl = entry_repl(driver.clone(), runtime.clone());
-    let mut context =
-        ConsoleContext { repl_stack: vec![Rc::new(repl)], background_runtime: runtime, transaction: None, driver };
+    let invocation_dir = PathBuf::from(env::current_dir().unwrap());
+    let mut context = ConsoleContext {
+        invocation_dir,
+        repl_stack: vec![Rc::new(repl)],
+        background_runtime: runtime,
+        transaction: None,
+        script_dir: None,
+        driver,
+    };
 
     if !args.command.is_empty() && !args.script.is_empty() {
         println!("Error: Cannot specify both commands and files");
@@ -128,31 +152,38 @@ fn main() {
 
 fn execute_scripts(context: &mut ConsoleContext, files: &[String]) {
     for file_path in files {
+        let path = context.convert_path(file_path);
         if let Ok(file) = File::open(&file_path) {
-            execute_script(context, &file_path, io::BufReader::new(file).lines())
+            execute_script(context, path, io::BufReader::new(file).lines())
         } else {
-            println!("Error opening file: {}", file_path);
+            println!("Error opening file: {}", path.to_string_lossy());
             exit(1);
         }
     }
 }
 
-fn execute_script(context: &mut ConsoleContext, file: &str, inputs: impl Iterator<Item = Result<String, io::Error>>) {
+fn execute_script(
+    context: &mut ConsoleContext,
+    file_path: PathBuf,
+    inputs: impl Iterator<Item = Result<String, io::Error>>,
+) {
     let mut combined_input = String::new();
+    context.script_dir = Some(file_path.parent().unwrap().to_string_lossy().to_string());
     for (index, input) in inputs.enumerate() {
         match input {
             Ok(line) => {
                 combined_input.push('\n');
                 combined_input.push_str(&line);
             }
             Err(_) => {
-                println!("### Error reading file '{}' line: {}", file, index + 1);
+                println!("### Error reading file '{}' line: {}", file_path.to_string_lossy(), index + 1);
                 return;
             }
         }
     }
     // we could choose to implement this as line-by-line instead of as an interactive-compatible script
     let _ = execute_commands(context, &combined_input, false, true);
+    context.script_dir = None;
 }
 
 fn execute_command_list(context: &mut ConsoleContext, commands: &[String]) {
@@ -342,7 +373,7 @@ fn transaction_repl(database: &str, transaction_type: TransactionType) -> Repl<C
         ))
         .add(CommandLeaf::new_with_input(
             "source",
-            "Execute a file containing a sequence of TypeQL queries. Queries may be split over multiple lines using backslash ('\\')",
+            "Synchronously execute a file containing a sequence of TypeQL queries with full validation. Queries can be explicitly ended with 'end;' if required. Path may be absolute or relative to the invoking script (if there is one) otherwise relative to the current working directory.",
             CommandInput::new("file", get_word, None, Some(Box::new(file_completer))),
             transaction_source,
         ))

src/operations.rs

@@ -4,7 +4,13 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use std::{error::Error, fs::read_to_string, path::Path, process::exit, rc::Rc};
+use std::{
+    error::Error,
+    fs::read_to_string,
+    path::{Path, PathBuf},
+    process::exit,
+    rc::Rc,
+};
 
 use futures::stream::StreamExt;
 use typedb_driver::{
@@ -246,13 +252,13 @@ pub(crate) fn transaction_rollback(context: &mut ConsoleContext, _input: &[Strin
 
 pub(crate) fn transaction_source(context: &mut ConsoleContext, input: &[String]) -> CommandResult {
     let file_str = &input[0];
-    let path = Path::new(file_str);
+    let path = context.convert_path(file_str);
     if !path.exists() {
-        return Err(Box::new(ReplError { message: format!("File not found: {}", file_str) }) as Box<dyn Error + Send>);
+        return Err(Box::new(ReplError { message: format!("File not found: {}", path.to_string_lossy()) })
+            as Box<dyn Error + Send>);
     } else if path.is_dir() {
-        return Err(
-            Box::new(ReplError { message: format!("Path must be a file: {}", file_str) }) as Box<dyn Error + Send>
-        );
+        return Err(Box::new(ReplError { message: format!("Path must be a file: {}", path.to_string_lossy()) })
+            as Box<dyn Error + Send>);
     }
 
     let contents = read_to_string(path).map_err(|err| {
@@ -267,7 +273,7 @@ pub(crate) fn transaction_source(context: &mut ConsoleContext, input: &[String])
             input = &input[next_query_index..];
             continue;
         }
-        match execute_query(context, query.to_owned(), true) {
+        match execute_query(context, query.to_owned(), false) {
             Err(err) => {
                 return Err(Box::new(ReplError {
                     message: format!(
@@ -284,6 +290,9 @@ pub(crate) fn transaction_source(context: &mut ConsoleContext, input: &[String])
                 query_count += 1;
             }
         }
+        if query_count % 1_000 == 0 {
+            println!("In progress: executed {} queries.", query_count);
+        }
     }
     if !input.trim().is_empty() {
         match execute_query(context, input.to_owned(), false) {
@@ -301,7 +310,7 @@ pub(crate) fn transaction_source(context: &mut ConsoleContext, input: &[String])
             Ok(_) => query_count += 1,
         }
     }
-    println!("Successfully executed {} queries.", query_count);
+    println!("Finished executing {} queries.", query_count);
     Ok(())
 }
 

src/repl/mod.rs

@@ -18,8 +18,6 @@ pub(crate) mod line_reader;
 
 pub(crate) trait ReplContext: Sized {
     fn current_repl(&self) -> &Repl<Self>;
-
-    fn has_changes(&self) -> bool;
 }
 
 pub(crate) struct Repl<Context> {