Branching

src/branch/config.rs

@@ -0,0 +1,68 @@
+use std::collections::BTreeMap;
+use std::fs;
+use std::path::Path;
+use colorful::core::StrMarker;
+use toml::Spanned;
+use crate::platform::tmp_file_path;
+use crate::portable::config::{modify_core, warn_extra};
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all="kebab-case")]
+pub struct SrcConfig {
+    #[serde(default)]
+    pub current_branch: Option<Spanned<String>>,
+    #[serde(flatten)]
+    pub extra: BTreeMap<String, toml::Value>,
+}
+
+pub struct Config {
+    pub current_branch: String
+}
+
+pub fn create_or_read(path: &Path, default_branch: Option<&str>) -> anyhow::Result<Config> {
+    if path.exists() {
+        return read(path);
+    }
+
+    let branch = default_branch.unwrap_or("main");
+    let tmp = tmp_file_path(path);
+    fs::remove_file(&tmp).ok();
+    fs::write(&tmp, format!("current-branch = \"{}\"", branch))?;
+    fs::rename(&tmp, path)?;
+
+    Ok(Config {
+        current_branch: branch.to_string()
+    })
+}
+
+pub fn read(path: &Path) -> anyhow::Result<Config> {
+    let text = fs::read_to_string(&path)?;
+    let mut toml = toml::de::Deserializer::new(&text);
+    let val: SrcConfig = serde_path_to_error::deserialize(&mut toml)?;
+
+    warn_extra(&val.extra, "");
+
+    Ok(Config {
+        current_branch: val.current_branch
+            .map(|x| x.into_inner())
+            .unwrap_or("main".to_string())
+    })
+}
+
+fn modify<T, U, V>(config: &Path, selector: T, value: &U, format: V) -> anyhow::Result<bool>
+    where
+        T: Fn(&SrcConfig) -> &Option<Spanned<U>>,
+        U: std::cmp::PartialEq,
+        V: FnOnce(&U) -> String,
+{
+    let input = fs::read_to_string(&config)?;
+    let mut toml = toml::de::Deserializer::new(&input);
+    let parsed: SrcConfig = serde_path_to_error::deserialize(&mut toml)?;
+
+    return modify_core(&parsed, &input, config, selector, value, format);
+}
+
+pub fn modify_current_branch(config: &Path, branch: &String) -> anyhow::Result<bool> {
+    modify(config, |v: &SrcConfig| &v.current_branch, branch, |v| v.clone())
+}
+

src/branch/context.rs

@@ -0,0 +1,27 @@
+use std::path::{Path, PathBuf};
+use crate::branch::config;
+use crate::branch::config::Config as AutoConfig;
+use crate::portable::config::Config as ProjectConfig;
+
+pub struct Context {
+    pub project_config: ProjectConfig,
+    pub auto_config: AutoConfig,
+
+    project_dir: PathBuf
+}
+
+impl Context {
+    pub fn new(project_dir: &Path) -> anyhow::Result<Context> {
+        let project_config = crate::portable::config::read(&project_dir.join("edgedb.toml"))?;
+        let branch = project_config.edgedb.branch.clone();
+        Ok(Context {
+            project_config,
+            auto_config: config::create_or_read(&project_dir.join("edgedb.auto.toml"), Some(&branch))?,
+            project_dir: PathBuf::from(project_dir)
+        })
+    }
+
+    pub fn update_branch(&self, branch: &String) -> anyhow::Result<bool> {
+        config::modify_current_branch(&self.project_dir.join("edgedb.auto.toml"), branch)
+    }
+}

src/branch/create.rs

@@ -0,0 +1,36 @@
+use crate::branch::context::Context;
+use crate::branch::option::Create;
+use crate::connect::{Connection};
+use crate::{portable, print};
+
+pub async fn main(options: &Create, context: &Context, connection: &mut Connection) -> anyhow::Result<()> {
+    let source_branch = options.from.as_ref().unwrap_or(&context.auto_config.current_branch);
+
+    let query: String;
+
+    if options.empty {
+        query = format!("create empty branch {}", options.branch)
+    } else {
+        let branch_type = match options {
+            _ if options.copy_data => "data",
+            _ => "schema"
+        };
+
+        query = format!("create {} branch from {}", branch_type, source_branch)
+    }
+
+    println!("Creating branch '{}'...", options.branch);
+
+    let status = connection.execute(
+        &query,
+        &()
+    ).await?;
+
+    print::completion(&status);
+
+    if !context.update_branch(&options.branch)? {
+        anyhow::bail!("Failed to update branch in edgedb.auto.toml")
+    }
+
+    Ok(())
+}

src/branch/drop.rs

@@ -0,0 +1,31 @@
+use crate::branch::context::Context;
+use crate::branch::option::Drop;
+use crate::connect::{Connection};
+use crate::{print, question};
+use crate::commands::ExitCode;
+use crate::portable::exit_codes;
+
+pub async fn main(options: &Drop, _context: &Context, connection: &mut Connection) -> anyhow::Result<()> {
+    // TODO: do we implicitly switch branch here to drop? or do we let the user deal with the
+    // 'cannot drop the currently open database branch' error?
+
+    if !options.non_interactive {
+        let q = question::Confirm::new_dangerous(
+            format!("Do you really want to drop the branch {:?}?",
+                    options.branch)
+        );
+        if !connection.ping_while(q.async_ask()).await? {
+            print::error("Canceled.");
+            return Err(ExitCode::new(exit_codes::NOT_CONFIRMED).into());
+        }
+    }
+
+    let status = connection.execute(
+        &format!("drop branch {}", options.branch),
+        &()
+    ).await?;
+
+    print::completion(status);
+
+    Ok(())
+}

src/branch/list.rs

@@ -0,0 +1,23 @@
+use crossterm::style::Stylize;
+use crate::branch::context::Context;
+use crate::branch::option::List;
+use crate::connect::Connection;
+
+pub async fn main(_options: &List, context: &Context, connection: &mut Connection) -> anyhow::Result<()> {
+    let branches: Vec<String> = connection.query(
+        "SELECT (SELECT sys::Database FILTER NOT .builtin).name",
+        &(),
+    ).await?;
+
+    for branch in branches {
+        if context.auto_config.current_branch == branch {
+            println!("{} - Current", branch.green());
+        } else if context.project_config.edgedb.branch == branch {
+            println!("{} - Project default", branch.blue());
+        } else {
+            println!("{}", branch);
+        }
+    }
+
+    Ok(())
+}

src/branch/main.rs

@@ -0,0 +1,30 @@
+use edgedb_tokio::get_project_dir;
+use crate::branch::context::Context;
+use crate::branch::{create, drop, list, rename, switch, wipe};
+use crate::branch::option::{BranchCommand, Command};
+use crate::connect::Connection;
+use crate::options::Options;
+use crate::portable::config::Config;
+
+#[tokio::main]
+pub async fn branch_main(options: &Options, cmd: &BranchCommand) -> anyhow::Result<()> {
+    let context = create_context().await?;
+
+    let mut connection: Connection = options.create_connector().await?.connect().await?;
+
+    // match commands that don't require a connection to run, then match the ones that do with a connection.
+    match &cmd.subcommand {
+        Command::Switch(switch) => switch::main(switch, &context, &mut connection).await,
+        Command::Create(create) => create::main(create, &context, &mut connection).await,
+        Command::Drop(drop) => drop::main(drop, &context, &mut connection).await,
+        Command::Wipe(wipe) => wipe::main(wipe, &context, &mut connection).await,
+        Command::List(list) => list::main(list, &context, &mut connection).await,
+        Command::Rename(rename) => rename::main(rename, &context, &mut connection).await,
+        _ => anyhow::bail!("Unknown subcommand")
+    }
+}
+
+async fn create_context() -> anyhow::Result<Context> {
+    let project_dir = get_project_dir(None, true).await?.expect("Missing project");
+    Context::new(&project_dir)
+}

src/branch/mod.rs

@@ -0,0 +1,12 @@
+pub mod option;
+pub mod main;
+mod create;
+mod context;
+mod drop;
+mod wipe;
+mod switch;
+pub mod config;
+mod rename;
+mod list;
+
+pub use main::branch_main;

src/branch/option.rs

@@ -0,0 +1,77 @@
+#[derive(clap::Args, Debug, Clone)]
+pub struct BranchCommand {
+    #[command(subcommand)]
+    pub subcommand: Command,
+}
+
+#[derive(clap::Subcommand, Clone, Debug)]
+pub enum Command {
+    Create(Create),
+    Drop(Drop),
+    Wipe(Wipe),
+    Switch(Switch),
+    Rename(Rename),
+    Rebase(Rebase),
+    Merge(Merge),
+    List(List)
+}
+
+#[derive(clap::Args, Debug, Clone)]
+pub struct Create {
+    pub branch: String,
+
+    #[arg(long)]
+    pub from: Option<String>,
+
+    #[arg(long, conflicts_with="copy_data")]
+    pub empty: bool,
+
+    #[arg(long)]
+    pub copy_data: bool
+}
+
+#[derive(clap::Args, Debug, Clone)]
+pub struct Drop {
+    pub branch: String,
+
+    #[arg(long)]
+    pub non_interactive: bool,
+}
+
+#[derive(clap::Args, Debug, Clone)]
+pub struct Wipe {
+    pub branch: String,
+
+    #[arg(long)]
+    pub non_interactive: bool,
+}
+
+#[derive(clap::Args, Debug, Clone)]
+pub struct Switch {
+    pub branch: String,
+}
+
+#[derive(clap::Args, Debug, Clone)]
+pub struct Rename {
+    pub old_name: String,
+    pub new_name: String,
+}
+
+#[derive(clap::Args, Debug, Clone)]
+pub struct Rebase {
+
+}
+
+#[derive(clap::Args, Debug, Clone)]
+pub struct Merge {
+
+}
+
+#[derive(clap::Args, Debug, Clone)]
+pub struct List {
+
+}
+
+
+
+

src/branch/rename.rs

@@ -0,0 +1,15 @@
+use crate::branch::context::Context;
+use crate::branch::option::Rename;
+use crate::connect::Connection;
+use crate::print;
+
+pub async fn main(options: &Rename, _context: &Context, connection: &mut Connection) -> anyhow::Result<()> {
+    let status = connection.execute(
+        &format!("alter branch {} rename to {}", options.old_name, options.new_name),
+        &()
+    ).await?;
+
+    print::completion(status);
+
+    Ok(())
+}

src/branch/switch.rs

@@ -0,0 +1,26 @@
+use crate::branch::context::Context;
+use crate::branch::option::Switch;
+use crate::connect::Connection;
+use crate::options::Options;
+
+pub async fn main(options: &Switch, context: &Context, connection: &mut Connection) -> anyhow::Result<()> {
+    // verify the branch exists
+    let branches: Vec<String> = connection.query(
+        "SELECT (SELECT sys::Database FILTER NOT .builtin).name",
+        &(),
+    ).await?;
+
+    if !branches.contains(&options.branch) {
+        anyhow::bail!("Branch '{}' doesn't exists", options.branch)
+    }
+
+    println!("Switching from '{}' to '{}'", context.auto_config.current_branch, options.branch);
+
+    if !context.update_branch(&options.branch)? {
+        anyhow::bail!("Failed to update branch in edgedb.auto.toml")
+    }
+
+    println!("Now on '{}'", options.branch);
+
+    Ok(())
+}

src/branch/wipe.rs

@@ -0,0 +1,29 @@
+use crate::branch::context::Context;
+use crate::branch::option::Wipe;
+use crate::connect::Connection;
+use crate::{print, question};
+use crate::commands::ExitCode;
+use crate::portable::exit_codes;
+
+pub async fn main(options: &Wipe, _context: &Context, connection: &mut Connection) -> anyhow::Result<()> {
+    if !options.non_interactive {
+        let q = question::Confirm::new_dangerous(
+            format!("Do you really want to wipe \
+                    the contents of the branch {:?}?",
+                    options.branch)
+        );
+        if !connection.ping_while(q.async_ask()).await? {
+            print::error("Canceled.");
+            return Err(ExitCode::new(exit_codes::NOT_CONFIRMED).into());
+        }
+    }
+
+    let status = connection.execute(
+        "RESET SCHEMA TO initial",
+        &()
+    ).await?;
+
+    print::completion(status);
+
+    Ok(())
+}