Merge pull request #142 from supabase/dbdev_ls

`dbdev ls` command

Author: imor

cli/src/commands/install.rs

@@ -115,12 +115,12 @@ async fn extension_versions(
 }
 
 #[derive(sqlx::FromRow, PartialEq, Eq, Hash)]
-struct UpdatePath {
-    source: String,
-    target: String,
+pub(crate) struct UpdatePath {
+    pub(crate) source: String,
+    pub(crate) target: String,
 }
 
-async fn update_paths(
+pub(crate) async fn update_paths(
     conn: &mut PgConnection,
     extension_name: &str,
 ) -> anyhow::Result<HashSet<UpdatePath>> {

cli/src/commands/list.rs

@@ -0,0 +1,81 @@
+use std::collections::HashMap;
+
+use futures::TryStreamExt;
+use sqlx::PgConnection;
+
+use crate::commands::install::update_paths;
+
+pub(crate) async fn list(conn: &mut PgConnection) -> anyhow::Result<()> {
+    let available_extension_versions = available_extensions_versions(conn).await?;
+    let available_extensions = available_extensions(conn).await?;
+
+    for (extension_name, versions) in available_extension_versions {
+        let default_version = available_extensions.get(&extension_name);
+
+        println!("{extension_name}");
+        println!("  available versions:");
+        for version in &versions {
+            print!("    {version}");
+            if Some(version) == default_version {
+                print!(" (default)");
+            }
+            println!();
+        }
+
+        println!("  available update paths:");
+        let update_paths = update_paths(conn, &extension_name).await?;
+        if update_paths.is_empty() {
+            println!("    None");
+        } else {
+            for update_path in update_paths {
+                println!("    from {} to {}", update_path.source, update_path.target);
+            }
+        }
+        println!();
+    }
+
+    Ok(())
+}
+
+#[derive(sqlx::FromRow)]
+struct AvailableExtensionVersion {
+    name: String,
+    version: String,
+}
+
+async fn available_extensions_versions(
+    conn: &mut PgConnection,
+) -> anyhow::Result<HashMap<String, Vec<String>>> {
+    let mut rows = sqlx::query_as::<_, AvailableExtensionVersion>(
+        "select name, version from pgtle.available_extension_versions()",
+    )
+    .fetch(conn);
+
+    let mut available_extensions = HashMap::new();
+    while let Some(row) = rows.try_next().await? {
+        let versions: &mut Vec<String> = available_extensions.entry(row.name).or_default();
+        versions.push(row.version);
+    }
+
+    Ok(available_extensions)
+}
+
+#[derive(sqlx::FromRow)]
+struct AvailableExtension {
+    name: String,
+    default_version: String,
+}
+
+async fn available_extensions(conn: &mut PgConnection) -> anyhow::Result<HashMap<String, String>> {
+    let mut rows = sqlx::query_as::<_, AvailableExtension>(
+        "select name, default_version from pgtle.available_extensions()",
+    )
+    .fetch(conn);
+
+    let mut extensions = HashMap::new();
+    while let Some(row) = rows.try_next().await? {
+        extensions.insert(row.name, row.default_version);
+    }
+
+    Ok(extensions)
+}

cli/src/commands/mod.rs

@@ -2,3 +2,4 @@ pub mod install;
 pub mod login;
 pub mod publish;
 pub mod uninstall;
+pub mod list;

cli/src/main.rs

@@ -62,6 +62,14 @@ enum Commands {
         #[arg(long)]
         registry_name: Option<String>,
     },
+
+    /// List available packages
+    #[clap(alias = "ls")]
+    List {
+        /// PostgreSQL connection string
+        #[arg(short, long)]
+        connection: String,
+    },
 }
 
 #[derive(Debug, clap::Args)]
@@ -139,5 +147,11 @@ async fn main() -> anyhow::Result<()> {
             println!("Login successful");
             Ok(())
         }
+
+        Commands::List { connection } => {
+            let mut conn = util::get_connection(connection).await?;
+            commands::list::list(&mut conn).await?;
+            Ok(())
+        }
     }
 }