brk: first commit

crates/brk_server/src/api/mod.rs

@@ -0,0 +1,18 @@
+use axum::{routing::get, Router};
+
+use super::AppState;
+
+mod explorer;
+mod vecs;
+
+pub use vecs::VecIdToIndexToVec;
+
+pub trait ApiRoutes {
+    fn add_api_routes(self) -> Self;
+}
+
+impl ApiRoutes for Router<AppState> {
+    fn add_api_routes(self) -> Self {
+        self.route("/api/vecs", get(vecs::handler))
+    }
+}

crates/brk_server/src/api/vecs/format.rs

@@ -0,0 +1,30 @@
+use color_eyre::eyre::eyre;
+
+#[allow(clippy::upper_case_acronyms)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Format {
+    CSV,
+    TSV,
+    JSON,
+}
+
+impl TryFrom<Option<String>> for Format {
+    type Error = color_eyre::Report;
+    fn try_from(value: Option<String>) -> Result<Self, Self::Error> {
+        if let Some(value) = value {
+            let value = value.to_lowercase();
+            let value = value.as_str();
+            if value == "csv" {
+                Ok(Self::CSV)
+            } else if value == "tsv" {
+                Ok(Self::TSV)
+            } else if value == "json" {
+                Ok(Self::JSON)
+            } else {
+                Err(eyre!("Fail"))
+            }
+        } else {
+            Err(eyre!("Fail"))
+        }
+    }
+}

crates/brk_server/src/api/vecs/index.rs

@@ -0,0 +1,66 @@
+use std::fmt::{self, Debug};
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum Index {
+    Addressindex,
+    Dateindex,
+    Height,
+    P2PK33index,
+    P2PK65index,
+    P2PKHindex,
+    P2SHindex,
+    P2TRindex,
+    P2WPKHindex,
+    P2WSHindex,
+    Txindex,
+    Txinindex,
+    Txoutindex,
+}
+
+impl Index {
+    pub fn all() -> [Self; 13] {
+        [
+            Self::Addressindex,
+            Self::Dateindex,
+            Self::Height,
+            Self::P2PK33index,
+            Self::P2PK65index,
+            Self::P2PKHindex,
+            Self::P2SHindex,
+            Self::P2TRindex,
+            Self::P2WPKHindex,
+            Self::P2WSHindex,
+            Self::Txindex,
+            Self::Txinindex,
+            Self::Txoutindex,
+        ]
+    }
+}
+
+impl TryFrom<&str> for Index {
+    type Error = ();
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        Ok(match value {
+            "d" | "date" | "dateindex" => Self::Dateindex,
+            "h" | "height" => Self::Height,
+            "txi" | "txindex" => Self::Txindex,
+            "txini" | "txinindex" => Self::Txinindex,
+            "txouti" | "txoutindex" => Self::Txoutindex,
+            "addri" | "addressindex" => Self::Addressindex,
+            "p2pk33i" | "p2pk33index" => Self::P2PK33index,
+            "p2pk65i" | "p2pk65index" => Self::P2PK65index,
+            "p2pkhi" | "p2pkhindex" => Self::P2PKHindex,
+            "p2shi" | "p2shindex" => Self::P2SHindex,
+            "p2tri" | "p2trindex" => Self::P2TRindex,
+            "p2wpkhi" | "p2wpkhindex" => Self::P2WPKHindex,
+            "p2wshi" | "p2wshindex" => Self::P2WSHindex,
+            _ => return Err(()),
+        })
+    }
+}
+
+impl fmt::Display for Index {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Debug::fmt(self, f)
+    }
+}

crates/brk_server/src/api/vecs/mod.rs

@@ -0,0 +1,155 @@
+use std::time::Instant;
+
+use axum::{
+    extract::{Query, State},
+    http::{HeaderMap, StatusCode, Uri},
+    response::{IntoResponse, Response},
+    Json,
+};
+use color_eyre::eyre::eyre;
+use serde_json::Value;
+
+use crate::{log_result, traits::HeaderMapExtended};
+
+use super::AppState;
+
+mod format;
+mod index;
+mod query;
+mod tree;
+
+use format::Format;
+use index::Index;
+use query::QueryS;
+pub use tree::*;
+
+pub async fn handler(
+    headers: HeaderMap,
+    uri: Uri,
+    query: Query<QueryS>,
+    State(app_state): State<AppState>,
+) -> Response {
+    let instant = Instant::now();
+
+    let path = uri.path();
+
+    match req_to_response_res(headers, query, app_state) {
+        Ok(response) => {
+            log_result(response.status(), path, instant);
+            response
+        }
+        Err(error) => {
+            let mut response = (StatusCode::INTERNAL_SERVER_ERROR, error.to_string()).into_response();
+            log_result(response.status(), path, instant);
+            response.headers_mut().insert_cors();
+            response
+        }
+    }
+}
+
+fn req_to_response_res(
+    headers: HeaderMap,
+    Query(QueryS { format, from, i, to, v }): Query<QueryS>,
+    AppState { vecs, .. }: AppState,
+) -> color_eyre::Result<Response> {
+    let format = Format::try_from(format).ok();
+
+    let indexes = i
+        .to_lowercase()
+        .split(",")
+        .flat_map(|s| Index::try_from(s).ok())
+        .collect::<Vec<_>>();
+
+    if indexes.len() > 1 {
+        return Err(eyre!("Multiple indexes aren't supported"));
+    } else if indexes.is_empty() {
+        return Err(eyre!("Unknown index"));
+    }
+
+    let ids = v
+        .to_lowercase()
+        .split(",")
+        .map(|s| (s.to_owned(), vecs.get(&s.replace("_", "-"))))
+        .filter(|(_, opt)| opt.is_some())
+        .map(|(id, vec)| (id, vec.unwrap()))
+        .collect::<Vec<_>>();
+
+    if ids.is_empty() {
+        return Ok(Json(()).into_response());
+    }
+
+    let values = ids
+        .iter()
+        .flat_map(|(_, i_to_v)| i_to_v.get(indexes.first().unwrap()))
+        .map(|vec| -> storable_vec::Result<Vec<Value>> { vec.collect_range_values(from, to) })
+        .collect::<storable_vec::Result<Vec<_>>>()?;
+
+    if ids.is_empty() {
+        return Ok(Json(()).into_response());
+    }
+
+    let ids_last_i = ids.len() - 1;
+
+    let mut response = match format {
+        Some(Format::CSV) | Some(Format::TSV) => {
+            let delimiter = if format == Some(Format::CSV) { ',' } else { '\t' };
+
+            let mut csv = ids
+                .into_iter()
+                .map(|(id, _)| id)
+                .collect::<Vec<_>>()
+                .join(&delimiter.to_string());
+
+            csv.push('\n');
+
+            let values_len = values.first().unwrap().len();
+
+            (0..values_len).for_each(|i| {
+                let mut line = "".to_string();
+                values.iter().enumerate().for_each(|(id_i, v)| {
+                    line += &v.get(i).unwrap().to_string();
+                    if id_i == ids_last_i {
+                        line.push('\n');
+                    } else {
+                        line.push(delimiter);
+                    }
+                });
+                csv += &line;
+            });
+
+            csv.into_response()
+        }
+        Some(Format::JSON) | None => {
+            if values.len() == 1 {
+                let values = values.first().unwrap();
+                if values.len() == 1 {
+                    let value = values.first().unwrap();
+                    Json(value).into_response()
+                } else {
+                    Json(values).into_response()
+                }
+            } else {
+                Json(values).into_response()
+            }
+        }
+    };
+
+    let headers = response.headers_mut();
+
+    headers.insert_cors();
+    // headers.insert_last_modified(date_modified);
+
+    match format {
+        Some(format) => {
+            headers.insert_content_disposition_attachment();
+            match format {
+                Format::CSV => headers.insert_content_type_text_csv(),
+                Format::TSV => headers.insert_content_type_text_tsv(),
+                Format::JSON => headers.insert_content_type_application_json(),
+            }
+        }
+        _ => headers.insert_content_type_application_json(),
+    };
+
+    Ok(response)
+}

crates/brk_server/src/api/vecs/query.rs

@@ -0,0 +1,10 @@
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize)]
+pub struct QueryS {
+    pub i: String,
+    pub v: String,
+    pub from: Option<i64>,
+    pub to: Option<i64>,
+    pub format: Option<String>,
+}

crates/brk_server/src/api/vecs/tree.rs

@@ -0,0 +1,78 @@
+use std::{collections::BTreeMap, fs, io};
+
+use derive_deref::{Deref, DerefMut};
+use storable_vec::AnyJsonStorableVec;
+
+use crate::WEBSITE_DEV_PATH;
+
+use super::index::Index;
+
+#[derive(Default, Deref, DerefMut)]
+pub struct VecIdToIndexToVec(BTreeMap<String, IndexToVec>);
+
+impl VecIdToIndexToVec {
+    // Not the most performant or type safe but only built once so that's okay
+    pub fn insert(&mut self, vec: &'static dyn AnyJsonStorableVec) {
+        let file_name = vec.file_name();
+        let split = file_name.split("_to_").collect::<Vec<_>>();
+        if split.len() != 2 {
+            panic!();
+        }
+        let str = vec.index_type_to_string().split("::").last().unwrap().to_lowercase();
+        let index = Index::try_from(str.as_str())
+            .inspect_err(|_| {
+                dbg!(str);
+            })
+            .unwrap();
+        if split[0] != index.to_string().to_lowercase() {
+            dbg!(split[0], index.to_string());
+            panic!();
+        }
+        let key = split[1].to_string().replace("_", "-");
+        let prev = self.entry(key).or_default().insert(index, vec);
+        if prev.is_some() {
+            panic!()
+        }
+    }
+
+    pub fn generate_dts_file(&self) -> io::Result<()> {
+        if !fs::exists(WEBSITE_DEV_PATH)? {
+            return Ok(());
+        }
+
+        let path = format!("{WEBSITE_DEV_PATH}/scripts/types/vecid-to-indexes.d.ts");
+
+        let mut contents = Index::all()
+            .into_iter()
+            .enumerate()
+            .map(|(i_of_i, i)| format!("type {} = {};", i, i_of_i))
+            .collect::<Vec<_>>()
+            .join("\n");
+
+        contents += "\n\ninterface VecIdToIndexes {\n";
+
+        self.iter().for_each(|(id, index_to_vec)| {
+            let indexes = index_to_vec
+                .keys()
+                .map(|i| i.to_string())
+                .collect::<Vec<_>>()
+                .join(", ");
+
+            contents += &format!(
+                "  {}: [{indexes}]\n",
+                if id.contains("-") {
+                    format!("\"{id}\"")
+                } else {
+                    id.to_owned()
+                }
+            );
+        });
+
+        contents.push('}');
+
+        fs::write(path, contents)
+    }
+}
+
+#[derive(Default, Deref, DerefMut)]
+pub struct IndexToVec(BTreeMap<Index, &'static dyn AnyJsonStorableVec>);