Add backend API

TraceLD · TraceLD · commit 8c5d069258d2 · 2024-09-15T23:20:00.000+01:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -0,0 +1,29 @@
+[package]
+name = "gulb-backend"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+tokio = { version = "1", features = ["macros"] }
+tracing = { version = "0.1" }
+tracing-subscriber = { version = "0.3", default-features = false, features = [
+    "fmt",
+] }
+serde = { version = "1.0.209", features = ["derive"] }
+serde_json = { version = "1.0.127", features = ["raw_value"] }
+url = "2.5.2"
+vercel_runtime = "1.1.4"
+octocrab = { version = "0.39.0", features = ["stream"] }
+anyhow = "1.0.88"
+secrecy = "0.8.0"
+thiserror = "1.0.63"
+problem_details = "0.6.0"
+http = "1.1.0"
+futures = "0.3.30"
+
+[lib]
+path = "api/lib/lib.rs"
+
+[[bin]]
+name = "user-langs-api"
+path = "api/langs.rs"
diff --git a/api/langs.rs b/api/langs.rs
@@ -0,0 +1,56 @@
+use gulb_backend::api_utils::missing_query_param;
+use gulb_backend::api_utils::{problem_details, ErrorConverter};
+use gulb_backend::github_fetch::{get_repos_for_org, get_repos_for_user};
+use gulb_backend::langs_calculator::calculate_langs;
+use gulb_backend::CRAB;
+
+use problem_details::ProblemDetails;
+use serde::Serialize;
+use std::collections::HashMap;
+use url::Url;
+use vercel_runtime::run;
+use vercel_runtime::{http::ok, Body, Error, Request, Response};
+
+const NAME_PARAM: &str = "name";
+const IS_ORG_PARAM: &str = "isorg";
+
+#[derive(Serialize)]
+struct GetUserLangsResponse {
+    name: String,
+    langs: HashMap<String, i64>,
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Error> {
+    run(handler).await
+}
+
+pub async fn handler(req: Request) -> Result<Response<Body>, Error> {
+    let parsed_url = Url::parse(&req.uri().to_string()).unwrap();
+    let hash_query: HashMap<String, String> = parsed_url.query_pairs().into_owned().collect();
+
+    let Some(name) = hash_query.get(NAME_PARAM) else {
+        return missing_query_param(NAME_PARAM);
+    };
+
+    let repos = if let Some(_) = hash_query.get(IS_ORG_PARAM) {
+        get_repos_for_org(&*CRAB, name).await
+    } else {
+        get_repos_for_user(&*CRAB, name).await
+    };
+
+    match repos {
+        Ok(repos) => match calculate_langs(&*CRAB, repos, Option::default()).await {
+            Ok(langs) => {
+                let res = GetUserLangsResponse {
+                    name: name.to_string(),
+                    langs,
+                };
+
+                ok(&res)
+            }
+            Err(err) => problem_details(&ProblemDetails::from_calc_err(err)),
+        },
+        Err(err) => problem_details(&ProblemDetails::from_octocrab_err(err)),
+    }
+}
diff --git a/api/lib/api_utils.rs b/api/lib/api_utils.rs
@@ -0,0 +1,110 @@
+use std::str::FromStr;
+
+use http::{Response, StatusCode};
+
+pub use problem_details::ProblemDetails;
+use serde::Serialize;
+use vercel_runtime::Body;
+
+#[derive(serde::Serialize)]
+pub struct ErrorsExt<T> {
+    errors: Vec<T>,
+}
+
+impl<T> ErrorsExt<T> {
+    pub fn new(errors: Vec<T>) -> Self {
+        Self { errors }
+    }
+}
+
+#[derive(serde::Serialize)]
+pub struct MissingParameterDetails {
+    detail: String,
+    parameter: String,
+}
+
+impl MissingParameterDetails {
+    pub fn new(parameter_name: impl Into<String>) -> Self {
+        let parameter_string = parameter_name.into();
+
+        MissingParameterDetails {
+            detail: format!("The query parameter {} is required", parameter_string),
+            parameter: parameter_string,
+        }
+    }
+}
+
+pub trait ErrorConverter {
+    fn from_octocrab_err(err: octocrab::Error) -> Self;
+    fn from_calc_err(err: crate::langs_calculator::LangCalcError) -> Self;
+}
+
+impl ErrorConverter for ProblemDetails {
+    fn from_octocrab_err(err: octocrab::Error) -> Self {
+        match err {
+            octocrab::Error::GitHub {
+                source,
+                backtrace: _,
+            } => problem_details::ProblemDetails::new()
+                .with_title("GitHub API Error")
+                .with_status(source.status_code)
+                .with_detail(source.message),
+
+            _ => create_internal_server_err_details(),
+        }
+    }
+
+    fn from_calc_err(err: crate::langs_calculator::LangCalcError) -> Self {
+        match err {
+            crate::langs_calculator::LangCalcError::OctocrabError(err) => {
+                Self::from_octocrab_err(err)
+            }
+
+            _ => create_internal_server_err_details(),
+        }
+    }
+}
+
+pub fn missing_query_param(
+    param_name: impl Into<String>,
+) -> Result<Response<Body>, vercel_runtime::Error> {
+    let errors = vec![MissingParameterDetails::new(param_name)];
+
+    let details = ProblemDetails::new()
+        .with_type(
+            http::Uri::from_str(
+                "https://problems-registry.smartbear.com/missing-request-parameter",
+            )
+            .unwrap(),
+        )
+        .with_title("Missing request parameter")
+        .with_detail("The request is missing an expected query parameter.")
+        .with_status(StatusCode::BAD_REQUEST)
+        .with_extensions(ErrorsExt::new(errors));
+
+    ext_problem_details(&details)
+}
+
+pub fn create_internal_server_err_details() -> ProblemDetails {
+    problem_details::ProblemDetails::from_status_code(StatusCode::INTERNAL_SERVER_ERROR)
+        .with_detail("An Internal Server Error has occurred")
+}
+
+pub fn problem_details(problem: &ProblemDetails) -> Result<Response<Body>, vercel_runtime::Error> {
+    Ok(Response::builder()
+        .status(&problem.status.unwrap_or(StatusCode::INTERNAL_SERVER_ERROR))
+        .header("Content-Type", "application/json")
+        .body(serde_json::to_string(&problem).unwrap().into())?)
+}
+
+pub fn ext_problem_details<Ext>(
+    problem: &ProblemDetails<Ext>,
+) -> Result<Response<Body>, vercel_runtime::Error>
+where
+    Ext: Serialize,
+{
+    Ok(Response::builder()
+        .status(&problem.status.unwrap_or(StatusCode::INTERNAL_SERVER_ERROR))
+        .header("Content-Type", "application/json")
+        .body(serde_json::to_string(&problem).unwrap().into())?)
+}
diff --git a/api/lib/github_auth.rs b/api/lib/github_auth.rs
@@ -0,0 +1,16 @@
+use std::env;
+
+use anyhow::{Context, Result};
+use secrecy::SecretString;
+
+const TOKEN_ENV_VAR: &str = "GITHUB_API_TOKEN";
+
+pub fn get_gh_token() -> Result<SecretString> {
+    let env_var_value = env::var(TOKEN_ENV_VAR)
+        .with_context(|| format!("Failed to read environment variable {}", TOKEN_ENV_VAR))?;
+
+    let secret_string = SecretString::try_from(env_var_value)
+        .context("Failed to convert token string value into a secret string.")?;
+
+    Ok(secret_string)
+}
diff --git a/api/lib/github_fetch.rs b/api/lib/github_fetch.rs
@@ -0,0 +1,40 @@
+use std::collections::HashMap;
+
+use octocrab::{
+    models::Repository, params::repos::Type as OrgRepoType,
+    params::users::repos::Type as UserRepoType, Octocrab, Page,
+};
+
+pub type RepoLanguages = HashMap<String, i64>;
+
+pub async fn get_repos_for_user(
+    crab: &Octocrab,
+    user: impl Into<String>,
+) -> Result<Page<Repository>, octocrab::Error> {
+    crab.users(user)
+        .repos()
+        .r#type(UserRepoType::Owner)
+        .per_page(100)
+        .send()
+        .await
+}
+
+pub async fn get_repos_for_org(
+    crab: &Octocrab,
+    org_name: impl Into<String>,
+) -> Result<Page<Repository>, octocrab::Error> {
+    crab.orgs(org_name)
+        .list_repos()
+        .repo_type(OrgRepoType::Sources)
+        .per_page(100)
+        .send()
+        .await
+}
+
+pub async fn get_langs_for_repo(
+    crab: &Octocrab,
+    repo_owner: impl Into<String>,
+    repo_name: impl Into<String>,
+) -> Result<RepoLanguages, octocrab::Error> {
+    crab.repos(repo_owner, repo_name).list_languages().await
+}
diff --git a/api/lib/langs_calculator.rs b/api/lib/langs_calculator.rs
@@ -0,0 +1,59 @@
+use futures::TryStreamExt;
+use std::collections::HashMap;
+use tokio::pin;
+
+use octocrab::{models::Repository, Octocrab, Page};
+
+use crate::github_fetch;
+
+#[derive(thiserror::Error, Debug)]
+pub enum LangCalcError {
+    #[error("GitHub API error")]
+    OctocrabError(#[from] octocrab::Error),
+    #[error("invalid repo object")]
+    InvalidRepoObject(),
+    #[error("unknown error")]
+    Unknown,
+}
+
+pub async fn calculate_langs(
+    crab: &Octocrab,
+    start_page: Page<Repository>,
+    max_pages: Option<u8>,
+) -> Result<HashMap<String, i64>, LangCalcError> {
+    let max_repos = max_pages.unwrap_or(5) * 100;
+
+    let mut results: HashMap<String, i64> = HashMap::new();
+    let repo_pages_stream = start_page.into_stream(crab);
+
+    pin!(repo_pages_stream);
+
+    let mut current_repo = 0;
+
+    while let Some(repo) = repo_pages_stream.try_next().await? {
+        if current_repo > max_repos {
+            break;
+        }
+
+        if let Some(true) = repo.fork {
+            continue;
+        }
+
+        let Some(repo_owner) = repo.owner.map(|x| x.login) else {
+            continue;
+        };
+
+        let repo_langs = github_fetch::get_langs_for_repo(crab, repo_owner, repo.name).await?;
+
+        for (lang, bytes) in repo_langs {
+            results
+                .entry(lang)
+                .and_modify(|count| *count += bytes)
+                .or_insert(bytes);
+        }
+
+        current_repo += 1;
+    }
+
+    Ok(results)
+}
diff --git a/api/lib/lib.rs b/api/lib/lib.rs
@@ -0,0 +1,15 @@
+use octocrab::Octocrab;
+
+use std::sync::LazyLock;
+
+pub mod api_utils;
+pub mod github_auth;
+pub mod github_fetch;
+pub mod langs_calculator;
+
+pub static CRAB: LazyLock<Octocrab> = LazyLock::new(|| {
+    Octocrab::builder()
+        .personal_token(crate::github_auth::get_gh_token().unwrap())
+        .build()
+        .unwrap()
+});
diff --git a/vercel.json b/vercel.json
@@ -0,0 +1,14 @@
+{
+  "outputDirectory": "public",
+  "rewrites": [
+    {
+      "source": "/api/langs",
+      "destination": "/api/langs.rs"
+    }
+  ],
+  "functions": {
+    "api/langs.rs": {
+      "runtime": "vercel-rust@4.0.8"
+    }
+  }
+}
