Fix languages, implement Other query, and fix analytics bug

Cargo.toml

@@ -38,6 +38,7 @@ derive_builder = "0.12.0"
 futures = "0.3.28"
 async-stream = "0.3.5"
 regex = "1.10.0"
+strum = { version = "0.24", features = ["derive"] }
 thiserror = "1.0.49"
 utoipa = "3.3"
 axum = "0.6"

crates/tabby/Cargo.toml

@@ -32,7 +32,7 @@ serde_json = { workspace = true }
 tower-http = { version = "0.4.0", features = ["cors", "timeout"] }
 clap = { version = "4.3.0", features = ["derive"] }
 lazy_static = { workspace = true }
-strum = { version = "0.24", features = ["derive"] }
+strum = { workspace = true }
 strfmt = "0.2.4"
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }

ee/tabby-db/src/user_completions.rs

@@ -101,13 +101,23 @@ impl DbConn {
         end: DateTime<Utc>,
         users: Vec<i64>,
         languages: Vec<String>,
+        not_languages: Vec<String>,
     ) -> Result<Vec<UserCompletionDailyStatsDAO>> {
         let users = users
             .iter()
             .map(|u| u.to_string())
             .collect::<Vec<_>>()
             .join(",");
-        let languages = languages.join(",");
+        let languages = languages
+            .into_iter()
+            .map(|l| format!("{:?}", l.to_string()))
+            .collect::<Vec<_>>()
+            .join(",");
+        let not_languages = not_languages
+            .into_iter()
+            .map(|l| format!("{:?}", l.to_string()))
+            .collect::<Vec<_>>()
+            .join(",");
         let res = sqlx::query_as!(
             UserCompletionDailyStatsDAO,
             r#"
@@ -117,14 +127,15 @@ impl DbConn {
         FROM user_completions
         WHERE created_at >= ?1 AND created_at < ?2
             AND (?3 = '' OR user_id IN (?3))
-            AND (?4 = '' OR language IN (?4))
+            AND ((?4 = '' OR '"' + language + '"' IN (?4)) AND (?5 = '' OR '"' + language + '"' NOT IN (?5)))
         GROUP BY 1
         ORDER BY 1 ASC
         "#,
             start,
             end,
             users,
-            languages
+            languages,
+            not_languages
         )
         .fetch_all(&self.pool)
         .await?;

ee/tabby-webserver/Cargo.toml

@@ -31,6 +31,7 @@ reqwest = { workspace = true, features = ["json"] }
 rust-embed = "8.0.0"
 serde.workspace = true
 serde_json.workspace = true
+strum.workspace = true
 tabby-common = { path = "../../crates/tabby-common" }
 tabby-db = { path = "../../ee/tabby-db" }
 tarpc = { version = "0.33.0", features = ["serde-transport"] }

ee/tabby-webserver/src/schema/analytic.rs

@@ -1,8 +1,7 @@
-use std::fmt::Display;
-
 use async_trait::async_trait;
 use chrono::{DateTime, Utc};
 use juniper::{GraphQLEnum, GraphQLObject, ID};
+use strum::{EnumIter, IntoEnumIterator};
 
 use crate::schema::Result;
 
@@ -15,38 +14,46 @@ pub struct CompletionStats {
     pub selects: i32,
 }
 
-#[derive(GraphQLEnum, Clone, Debug)]
+#[derive(GraphQLEnum, Clone, Debug, Eq, PartialEq, EnumIter)]
 pub enum Language {
     Rust,
     Python,
     Java,
     Kotlin,
-    JavascriptTypescript,
+    Javascript,
+    Typescript,
     Go,
     Ruby,
     CSharp,
     C,
-    CPlusPlus,
+    CPP,
     Solidity,
     Other,
 }
 
-impl Display for Language {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl Language {
+    pub fn all_known() -> impl Iterator<Item = Language> {
+        Language::iter().filter(|l| l != &Language::Other)
+    }
+
+    pub fn to_strings(&self) -> impl IntoIterator<Item = String> {
         match self {
-            Language::Rust => write!(f, "rust"),
-            Language::Python => write!(f, "python"),
-            Language::Java => write!(f, "java"),
-            Language::Kotlin => write!(f, "kotlin"),
-            Language::JavascriptTypescript => write!(f, "javascript-typescript"),
-            Language::Go => write!(f, "go"),
-            Language::Ruby => write!(f, "ruby"),
-            Language::CSharp => write!(f, "csharp"),
-            Language::C => write!(f, "c"),
-            Language::CPlusPlus => write!(f, "cpp"),
-            Language::Solidity => write!(f, "solidity"),
-            Language::Other => write!(f, "other"),
+            Language::Rust => vec!["rust"],
+            Language::Python => vec!["python"],
+            Language::Java => vec!["java"],
+            Language::Kotlin => vec!["kotlin"],
+            Language::Javascript => vec!["javascript", "javascriptreact"],
+            Language::Typescript => vec!["typescript", "typescriptreact"],
+            Language::Go => vec!["go"],
+            Language::Ruby => vec!["ruby"],
+            Language::CSharp => vec!["csharp"],
+            Language::C => vec!["c"],
+            Language::CPP => vec!["cpp"],
+            Language::Solidity => vec!["solidity"],
+            Language::Other => vec!["other"],
         }
+        .into_iter()
+        .map(|s| s.to_string())
     }
 }
 

ee/tabby-webserver/src/service/analytic.rs

@@ -39,13 +39,23 @@ impl AnalyticService for AnalyticServiceImpl {
         start: DateTime<Utc>,
         end: DateTime<Utc>,
         users: Vec<ID>,
-        languages: Vec<Language>,
+        mut languages: Vec<Language>,
     ) -> Result<Vec<CompletionStats>> {
         let users = convert_ids(users);
-        let languages = languages.into_iter().map(|l| l.to_string()).collect();
+
+        let not_languages = languages
+            .iter()
+            .position(|l| l == &Language::Other)
+            .map(|i| {
+                languages.remove(i);
+                Language::all_known().flat_map(|l| l.to_strings()).collect()
+            })
+            .unwrap_or_default();
+
+        let languages = languages.into_iter().flat_map(|l| l.to_strings()).collect();
         let stats = self
             .db
-            .compute_daily_stats(start, end, users, languages)
+            .compute_daily_stats(start, end, users, languages, not_languages)
             .await?;
         let stats = stats
             .into_iter()