move provider and project api keys logic to next (#1005)

* move provider and project api keys logic to next

* Update frontend/lib/cache.ts

Co-authored-by: ellipsis-dev[bot] <65095814+ellipsis-dev[bot]@users.noreply.github.com>

* fix cache key entry

* tiny fix on returning

---------

Co-authored-by: ellipsis-dev[bot] <65095814+ellipsis-dev[bot]@users.noreply.github.com>

Author: dinmukhamedm

app-server/src/api/utils.rs

@@ -4,24 +4,24 @@ use sqlx::PgPool;
 
 use crate::project_api_keys::hash_api_key;
 use crate::{
-    cache::{keys::PROJECT_API_KEY_CACHE_KEY, Cache, CacheTrait},
-    db::{self, project_api_keys::DBProjectApiKey},
+    cache::{Cache, CacheTrait, keys::PROJECT_API_KEY_CACHE_KEY},
+    db::{self, project_api_keys::ProjectApiKey},
 };
 
 pub async fn get_api_key_from_raw_value(
     pool: &PgPool,
     cache: Arc<Cache>,
     raw_api_key: String,
-) -> anyhow::Result<DBProjectApiKey> {
+) -> anyhow::Result<ProjectApiKey> {
     let api_key_hash = hash_api_key(&raw_api_key);
     let cache_key = format!("{PROJECT_API_KEY_CACHE_KEY}:{api_key_hash}");
-    let cache_res = cache.get::<DBProjectApiKey>(&cache_key).await;
+    let cache_res = cache.get::<ProjectApiKey>(&cache_key).await;
     match cache_res {
         Ok(Some(api_key)) => Ok(api_key),
         Ok(None) | Err(_) => {
             let api_key = db::project_api_keys::get_api_key(pool, &api_key_hash).await?;
             let _ = cache
-                .insert::<DBProjectApiKey>(&cache_key, api_key.clone())
+                .insert::<ProjectApiKey>(&cache_key, api_key.clone())
                 .await;
 
             Ok(api_key)

app-server/src/auth/mod.rs

@@ -48,8 +48,7 @@ pub async fn project_validator(
 
     match get_api_key_from_raw_value(&db.pool, cache, credentials.token().to_string()).await {
         Ok(api_key) => {
-            req.extensions_mut()
-                .insert(api_key.into_with_raw(credentials.token().to_string()));
+            req.extensions_mut().insert(api_key);
             Ok(req)
         }
         Err(e) => {

app-server/src/cache/mod.rs

@@ -30,6 +30,7 @@ pub trait CacheTrait {
     async fn insert<T>(&self, key: &str, value: T) -> Result<(), CacheError>
     where
         T: Serialize + Send;
+    #[allow(dead_code)]
     async fn remove(&self, key: &str) -> Result<(), CacheError>;
     async fn set_ttl(&self, key: &str, seconds: u64) -> Result<(), CacheError>;
     async fn insert_with_ttl<T>(&self, key: &str, value: T, seconds: u64) -> Result<(), CacheError>

app-server/src/db/mod.rs

@@ -11,7 +11,6 @@ pub mod events;
 pub mod prices;
 pub mod project_api_keys;
 pub mod projects;
-pub mod provider_api_keys;
 pub mod slack_channel_to_events;
 pub mod slack_integrations;
 pub mod spans;

app-server/src/db/project_api_keys.rs

@@ -4,101 +4,16 @@ use sqlx::{FromRow, PgPool};
 use uuid::Uuid;
 
 #[derive(Debug, Clone, FromRow, Serialize, Deserialize)]
-pub struct DBProjectApiKey {
-    pub project_id: Uuid,
-    pub name: Option<String>,
-    pub hash: String,
-    pub shorthand: String,
-}
-
-impl DBProjectApiKey {
-    pub fn into_with_raw(self, raw: String) -> ProjectApiKey {
-        ProjectApiKey {
-            project_id: self.project_id,
-            name: self.name,
-            hash: self.hash,
-            shorthand: self.shorthand,
-            raw,
-        }
-    }
-}
-
-// TODO: Remove this and use DBProjectApiKey directly
-#[derive(Clone)]
+#[serde(rename_all = "camelCase")]
 pub struct ProjectApiKey {
     pub project_id: Uuid,
     pub name: Option<String>,
     pub hash: String,
     pub shorthand: String,
-    pub raw: String,
-}
-
-impl Into<DBProjectApiKey> for ProjectApiKey {
-    fn into(self) -> DBProjectApiKey {
-        DBProjectApiKey {
-            project_id: self.project_id,
-            name: self.name,
-            hash: self.hash,
-            shorthand: self.shorthand,
-        }
-    }
-}
-
-#[derive(Serialize, FromRow)]
-pub struct ProjectApiKeyResponse {
-    pub id: Uuid,
-    pub project_id: Uuid,
-    pub name: Option<String>,
-    pub shorthand: String,
-}
-
-pub async fn create_project_api_key(
-    pool: &PgPool,
-    project_id: &Uuid,
-    name: &Option<String>,
-    hash: &String,
-    shorthand: &String,
-) -> Result<DBProjectApiKey> {
-    let key_info = sqlx::query_as::<_, DBProjectApiKey>(
-        "INSERT
-        INTO project_api_keys (shorthand, project_id, name, hash)
-        VALUES ($1, $2, $3, $4)
-        RETURNING id, project_id, name, hash, shorthand",
-    )
-    .bind(&shorthand)
-    .bind(&project_id)
-    .bind(&name)
-    .bind(&hash)
-    .fetch_one(pool)
-    .await?;
-
-    Ok(key_info)
 }
 
-pub async fn get_api_keys_for_project(
-    db: &PgPool,
-    project_id: &Uuid,
-) -> Result<Vec<ProjectApiKeyResponse>> {
-    let api_keys = sqlx::query_as::<_, ProjectApiKeyResponse>(
-        "SELECT
-            project_api_keys.project_id,
-            project_api_keys.name,
-            project_api_keys.id,
-            project_api_keys.shorthand
-        FROM
-            project_api_keys
-        WHERE
-            project_api_keys.project_id = $1",
-    )
-    .bind(project_id)
-    .fetch_all(db)
-    .await?;
-
-    Ok(api_keys)
-}
-
-pub async fn get_api_key(pool: &PgPool, hash: &String) -> Result<DBProjectApiKey> {
-    let api_key = match sqlx::query_as::<_, DBProjectApiKey>(
+pub async fn get_api_key(pool: &PgPool, hash: &String) -> Result<ProjectApiKey> {
+    let api_key = match sqlx::query_as::<_, ProjectApiKey>(
         "SELECT
             project_api_keys.hash,
             project_api_keys.project_id,
@@ -121,23 +36,3 @@ pub async fn get_api_key(pool: &PgPool, hash: &String) -> Result<DBProjectApiKey
 
     Ok(api_key)
 }
-
-#[derive(FromRow)]
-struct ProjectApiKeyHash {
-    hash: String,
-}
-
-pub async fn delete_api_key(pool: &PgPool, id: &Uuid, project_id: &Uuid) -> Result<String> {
-    let row = sqlx::query_as::<_, ProjectApiKeyHash>(
-        "DELETE
-        FROM project_api_keys
-        WHERE id = $1 AND project_id = $2
-        RETURNING hash",
-    )
-    .bind(id)
-    .bind(project_id)
-    .fetch_one(pool)
-    .await?;
-
-    Ok(row.hash)
-}

app-server/src/db/provider_api_keys.rs

@@ -1,10 +1,5 @@
-use rand::distr::{Alphanumeric, SampleString};
 use uuid::Uuid;
 
-pub fn generate_random_key() -> String {
-    Alphanumeric.sample_string(&mut rand::rng(), 64)
-}
-
 pub fn span_id_to_uuid(span_id: &[u8]) -> Uuid {
     let mut padded_vec = vec![0; 8];
     padded_vec.extend_from_slice(&span_id.to_vec());

app-server/src/db/utils.rs

@@ -70,7 +70,6 @@ mod names;
 mod notifications;
 mod opentelemetry_proto;
 mod project_api_keys;
-mod provider_api_keys;
 mod query_engine;
 mod realtime;
 mod routes;
@@ -743,7 +742,7 @@ fn main() -> anyhow::Result<()> {
                     // == Name generator ==
                     let name_generator = Arc::new(NameGenerator::new());
 
-                    log::info!("Enabling producer mode, spinning up full HTTP server");
+                    log::info!("Spinning up full HTTP server");
                     HttpServer::new(move || {
                         let project_auth = HttpAuthentication::bearer(auth::project_validator);
 
@@ -796,12 +795,8 @@ fn main() -> anyhow::Result<()> {
                             .service(
                                 // auth on path projects/{project_id} is handled by middleware on Next.js
                                 web::scope("/api/v1/projects/{project_id}")
-                                    .service(routes::api_keys::create_project_api_key)
-                                    .service(routes::api_keys::get_api_keys_for_project)
-                                    .service(routes::api_keys::revoke_project_api_key)
                                     .service(routes::evaluations::get_evaluation_score_stats)
                                     .service(routes::evaluations::get_evaluation_score_distribution)
-                                    .service(routes::provider_api_keys::save_api_key)
                                     .service(routes::spans::create_span)
                                     .service(routes::sql::execute_sql_query)
                                     .service(routes::sql::validate_sql_query),
@@ -821,7 +816,7 @@ fn main() -> anyhow::Result<()> {
             .name("grpc".to_string())
             .spawn(move || {
                 runtime_handle.block_on(async {
-                    log::info!("Enabling producer mode, spinning up gRPC server");
+                    log::info!("Spinning up gRPC server");
 
                     let process_traces_service = ProcessTracesService::new(
                         db.clone(),

app-server/src/main.rs

@@ -194,10 +194,6 @@ async fn process_single_notification(
 
             Ok(())
         }
-        _ => {
-            log::warn!("Unknown notification type: {:?}", message.notification_type);
-            Ok(())
-        }
     };
 
     match result {

app-server/src/notifications/mod.rs

@@ -1,25 +1,5 @@
-use crate::db::utils::generate_random_key;
 use sha3::{Digest, Sha3_256};
 
-pub struct ProjectApiKeyVals {
-    pub value: String,
-    pub hash: String,
-    pub shorthand: String,
-}
-
-impl ProjectApiKeyVals {
-    pub fn new() -> Self {
-        let value = generate_random_key();
-        let hash = hash_api_key(&value);
-        let shorthand = format!("{}...{}", &value[..4], &value[value.len() - 4..]);
-        Self {
-            value,
-            hash,
-            shorthand,
-        }
-    }
-}
-
 pub fn hash_api_key(api_key: &str) -> String {
     let mut hasher = Sha3_256::new();
     hasher.update(api_key.as_bytes());