http: Remove session and r/w functionality — radicle-explorer

Remove session and r/w functionality

Cleanup config types

     "fallbackPublicExplorer": "FALLBACK_PUBLIC_EXPLORER",
     "apiVersion": "API_VERSION",
     "defaultHttpdPort": "DEFAULT_HTTPD_PORT",
     "defaultLocalHttpdPort": "DEFAULT_LOCAL_HTTPD_PORT",
     "defaultHttpdHostname": "DEFAULT_HTTPD_HOSTNAME",
     "defaultHttpdScheme": "DEFAULT_HTTPD_SCHEME",
     "defaultNodePort": "DEFAULT_NODE_PORT",

     }
   },
   "supportWebsite": "SUPPORT_WEBSITE",
   "reactions": {
     "__name": "REACTIONS",
     "__format": "json"
   },
   "fallbackPreferredSeed": {
     "__name": "FALLBACK_PREFERRED_SEED",
     "__format": "json"

 {
   "nodes": {
     "fallbackPublicExplorer": "https://app.radicle.xyz/nodes/$host/$rid$path",
     "apiVersion": "1.2.0",
     "apiVersion": "2.0.0",
     "defaultHttpdPort": 443,
     "defaultLocalHttpdPort": 8080,
     "defaultHttpdHostname": "seed.radicle.garden",
     "defaultHttpdScheme": "https",
     "defaultNodePort": 8776,

     ]
   },
   "supportWebsite": "https://radicle.zulipchat.com",
   "reactions": ["👍", "👎", "😄", "🎉", "🙁", "🚀", "👀"],
   "fallbackPreferredSeed": {
     "hostname": "seed.radicle.garden",
     "port": 443,

 {
   "nodes": {
     "defaultHttpdPort": 8081,
     "defaultLocalHttpdPort": 8081,
     "defaultHttpdHostname": "127.0.0.1",
     "defaultHttpdScheme": "http",
     "pinned": [

   TreeStats,
 } from "./lib/project.js";
 import type {
   Config,
   SuccessResponse,
   CodeLocation,
   Range,

   Commit,
   CommitBlob,
   CommitHeader,
   Config,
   DefaultSeedingPolicy,
   Diff,
   DiffBlob,

 import type { Fetcher, RequestOptions } from "./fetcher.js";
 import type { z } from "zod";
 import { array, boolean, object, string } from "zod";
 import { nodeConfigSchema } from "./shared.js";
 import { object, string } from "zod";
 import { configSchema } from "./shared.js";
 const profileSchema = object({
   config: object({
     publicExplorer: string(),
     preferredSeeds: array(string()),
     cli: object({ hints: boolean() }),
     node: nodeConfigSchema,
   }),
   config: configSchema,
   home: string(),
 });

 import type { ZodSchema, z } from "zod";
 import { array, literal, number, object, string, union } from "zod";
 import { array, boolean, literal, number, object, string, union } from "zod";
 export interface SuccessResponse {
   success: true;

 export type DefaultSeedingPolicy = z.infer<typeof defaultSeedingPolicySchema>;
 export const configSchema = object({
   publicExplorer: string(),
   preferredSeeds: array(string()),
   cli: object({ hints: boolean() }),
   web: object({
     pinned: object({
       repositories: array(string()),
     }),
     imageUrl: string().optional(),
     name: string().optional(),
     description: string().optional(),
   }),
   node: nodeConfigSchema,
 });
 export type Config = z.infer<typeof configSchema>;
 export const rangeSchema = union([
   object({
     type: literal("lines"),

 ]
 [[package]]
 name = "axum-auth"
 version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8169113a185f54f68614fcfc3581df585d30bf8542bcb99496990e1025e4120a"
 dependencies = [
  "async-trait",
  "axum-core",
  "base64 0.21.7",
  "http",
 ]
 [[package]]
 name = "axum-core"
 version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"

 [[package]]
 name = "radicle-httpd"
 version = "0.12.1"
 version = "0.13.0"
 dependencies = [
  "anyhow",
  "axum",
  "axum-auth",
  "axum-server",
  "base64 0.21.7",
  "chrono",

 description = "Radicle HTTP daemon"
 homepage = "https://radicle.xyz"
 license = "MIT OR Apache-2.0"
 version = "0.12.1"
 version = "0.13.0"
 authors = ["cloudhead <cloudhead@radicle.xyz>"]
 edition = "2021"
 default-run = "radicle-httpd"

 [dependencies]
 anyhow = { version = "1" }
 axum = { version = "0.7.2", default-features = false, features = ["json", "query", "tokio", "http1"] }
 axum-auth = { version= "0.7.0", default-features = false, features = ["auth-bearer"] }
 axum-server = { version = "0.6.0", default-features = false }
 base64 = "0.21.3"
 chrono = { version = "0.4.22", default-features = false, features = ["clock"] }

 pub mod auth;
 use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Duration;

 use radicle::storage::git::Repository;
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 use tokio::sync::RwLock;
 use tower_http::cors::{self, CorsLayer};
 use radicle::cob::{issue, patch, Author};
 use radicle::identity::{DocAt, RepoId};
 use radicle::node::policy::Scope;
 use radicle::node::routing::Store;
 use radicle::node::AliasStore;
 use radicle::node::{Handle, NodeId};
 use radicle::node::{AliasStore, NodeId};
 use radicle::storage::{ReadRepository, ReadStorage};
 use radicle::{Node, Profile};
 use radicle::Profile;
 mod error;
 mod json;

 pub const RADICLE_VERSION: &str = env!("RADICLE_VERSION");
 // This version has to be updated on every breaking change to the radicle-httpd API.
 pub const API_VERSION: &str = "1.2.0";
 /// Identifier for sessions
 type SessionId = String;
 pub const API_VERSION: &str = "2.0.0";
 #[derive(Clone)]
 pub struct Context {
     profile: Arc<Profile>,
     sessions: Arc<RwLock<HashMap<SessionId, auth::Session>>>,
     cache: Option<Cache>,
 }

     pub fn new(profile: Arc<Profile>, options: &Options) -> Self {
         Self {
             profile,
             sessions: Default::default(),
             cache: options.cache.map(Cache::new),
         }
     }

     pub fn profile(&self) -> &Arc<Profile> {
         &self.profile
     }
     #[cfg(test)]
     pub fn sessions(&self) -> &Arc<RwLock<HashMap<SessionId, auth::Session>>> {
         &self.sessions
     }
 }
 pub fn router(ctx: Context) -> Router {

         pub seeding: usize,
     }
 }
 /// Announce refs to the network for the given RID.
 pub fn announce_refs(mut node: Node, rid: RepoId) -> Result<(), Error> {
     match node.announce_refs(rid) {
         Ok(_) => Ok(()),
         Err(e) if e.is_connection_err() => Ok(()),
         Err(e) => Err(e.into()),
     }
 }

 use serde::{Deserialize, Serialize};
 use time::serde::timestamp;
 use time::{Duration, OffsetDateTime};
 use radicle::crypto::PublicKey;
 use radicle::node::Alias;
 use crate::api::error::Error;
 use crate::api::Context;
 pub const UNAUTHORIZED_SESSIONS_EXPIRATION: Duration = Duration::seconds(60);
 pub const AUTHORIZED_SESSIONS_EXPIRATION: Duration = Duration::weeks(1);
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
 #[serde(rename_all = "lowercase")]
 pub enum AuthState {
     Authorized,
     Unauthorized,
 }
 #[derive(Clone, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Session {
     pub status: AuthState,
     pub public_key: PublicKey,
     pub alias: Alias,
     #[serde(with = "timestamp")]
     pub issued_at: OffsetDateTime,
     #[serde(with = "timestamp")]
     pub expires_at: OffsetDateTime,
 }
 pub async fn validate(ctx: &Context, token: &str) -> Result<(), Error> {
     let sessions_store = ctx.sessions.read().await;
     let session = sessions_store
         .get(token)
         .ok_or(Error::Auth("Unauthorized"))?;
     if session.status != AuthState::Authorized || session.expires_at <= OffsetDateTime::now_utc() {
         return Err(Error::Auth("Unauthorized"));
     }
     Ok(())
 }

     #[error("entity not found")]
     NotFound,
     /// An error occurred during an authentication process.
     #[error("could not authenticate: {0}")]
     Auth(&'static str),
     /// An error occurred with env variables.
     #[error(transparent)]
     Env(#[from] std::env::VarError),

     /// Node error.
     #[error(transparent)]
     Node(#[from] radicle::node::Error),
     /// Invalid update to issue or patch.
     #[error("{0}")]
     BadRequest(String),
 }
 impl IntoResponse for Error {

             Error::CobStore(e @ radicle::cob::store::Error::NotFound(_, _)) => {
                 (StatusCode::NOT_FOUND, Some(e.to_string()))
             }
             Error::Auth(msg) => (StatusCode::UNAUTHORIZED, Some(msg.to_string())),
             Error::Crypto(msg) => (StatusCode::BAD_REQUEST, Some(msg.to_string())),
             Error::Surf(radicle_surf::Error::Git(e)) if radicle::git::is_not_found_err(&e) => {
                 (StatusCode::NOT_FOUND, Some(e.message().to_owned()))

             Error::StorageRef(err) if err.is_not_found() => {
                 (StatusCode::NOT_FOUND, Some(err.to_string()))
             }
             Error::BadRequest(msg) => (StatusCode::BAD_REQUEST, Some(msg)),
             other => {
                 tracing::error!("Error: {message}");
                 tracing::debug!("Error Debug: {:?}", other);

 use radicle_surf::tree::{EntryKind, Tree};
 use radicle_surf::{Commit, Oid};
 use crate::api::auth::Session;
 /// Returns JSON of a commit.
 pub(crate) fn commit(commit: &Commit) -> Value {
     json!({

     })
 }
 /// Returns JSON of a session.
 pub(crate) fn session(session_id: String, session: &Session) -> Value {
     json!({
       "sessionId": session_id,
       "status": session.status,
       "publicKey": session.public_key,
       "alias": session.alias,
       "issuedAt": session.issued_at.unix_timestamp(),
       "expiresAt": session.expires_at.unix_timestamp()
     })
 }
 /// Returns JSON for a blob with a given `path`.
 pub(crate) fn blob<T: AsRef<[u8]>>(blob: &Blob<T>, path: &str) -> Value {
     json!({

 mod node;
 mod profile;
 mod projects;
 mod sessions;
 mod stats;
 use axum::extract::State;

         .merge(root_router)
         .merge(node::router(ctx.clone()))
         .merge(profile::router(ctx.clone()))
         .merge(sessions::router(ctx.clone()))
         .merge(delegates::router(ctx.clone()))
         .merge(projects::router(ctx.clone()))
         .merge(stats::router(ctx));

 use axum::extract::State;
 use axum::response::IntoResponse;
 use axum::routing::{get, put};
 use axum::routing::get;
 use axum::{Json, Router};
 use axum_auth::AuthBearer;
 use hyper::StatusCode;
 use serde_json::json;
 use radicle::identity::RepoId;
 use radicle::node::address::Store as AddressStore;
 use radicle::node::routing::Store;
 use radicle::node::{AliasStore, Handle, NodeId, DEFAULT_TIMEOUT};
 use radicle::node::{AliasStore, Handle, NodeId};
 use radicle::Node;
 use crate::api::error::Error;
 use crate::api::{self, Context, PoliciesQuery};
 use crate::axum_extra::{Path, Query};
 use crate::api::Context;
 use crate::axum_extra::Path;
 pub fn router(ctx: Context) -> Router {
     Router::new()
         .route("/node", get(node_handler))
         .route("/node/policies/repos", get(node_policies_repos_handler))
         .route(
             "/node/policies/repos/:rid",
             put(node_policies_seed_handler)
                 .delete(node_policies_unseed_handler)
                 .get(node_policies_repo_handler),
         )
         .route("/node/policies/repos/:rid", get(node_policies_repo_handler))
         .route("/nodes/:nid", get(nodes_handler))
         .route("/nodes/:nid/inventory", get(nodes_inventory_handler))
         .with_state(ctx)

     Ok::<_, Error>(Json(*policy))
 }
 /// Seed a new repo.
 /// `PUT /node/policies/repos/:rid`
 async fn node_policies_seed_handler(
     State(ctx): State<Context>,
     AuthBearer(token): AuthBearer,
     Path(project): Path<RepoId>,
     Query(qs): Query<PoliciesQuery>,
 ) -> impl IntoResponse {
     api::auth::validate(&ctx, &token).await?;
     let mut node = Node::new(ctx.profile.socket());
     node.seed(project, qs.scope.unwrap_or_default())?;
     if let Some(from) = qs.from {
         let results = node.fetch(project, from, DEFAULT_TIMEOUT)?;
         return Ok::<_, Error>((
             StatusCode::OK,
             Json(json!({ "success": true, "results": results })),
         ));
     }
     Ok::<_, Error>((StatusCode::OK, Json(json!({ "success": true }))))
 }
 /// Unseed a repo.
 /// `DELETE /node/policies/repos/:rid`
 async fn node_policies_unseed_handler(
     State(ctx): State<Context>,
     AuthBearer(token): AuthBearer,
     Path(project): Path<RepoId>,
 ) -> impl IntoResponse {
     api::auth::validate(&ctx, &token).await?;
     let mut node = Node::new(ctx.profile.socket());
     node.unseed(project)?;
     Ok::<_, Error>((StatusCode::OK, Json(json!({ "success": true }))))
 }
 #[cfg(test)]
 mod routes {
     use std::net::SocketAddr;

 /// Return local profile information.
 /// `GET /profile`
 async fn profile_handler(
     State(ctx): State<Context>,
     ConnectInfo(addr): ConnectInfo<SocketAddr>,
 ) -> impl IntoResponse {
     if !addr.ip().is_loopback() {
         return Err(Error::Auth("Profile data is only shown for localhost"));
     }
 async fn profile_handler(State(ctx): State<Context>) -> impl IntoResponse {
     Ok::<_, Error>(Json(
         json!({ "config": ctx.profile.config, "home": ctx.profile.home.path() }),
     ))

 use axum::extract::{DefaultBodyLimit, State};
 use axum::http::header;
 use axum::response::IntoResponse;
 use axum::routing::{get, patch, post};
 use axum::routing::get;
 use axum::{Json, Router};
 use axum_auth::AuthBearer;
 use hyper::StatusCode;
 use radicle_surf::blob::BlobRef;
 use radicle_surf::{diff, Glob, Oid, Repository};
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 use radicle::cob::{
     issue, issue::cache::Issues as _, patch, patch::cache::Patches as _, resolve_embed, Author,
     Embed, Label, Uri,
 };
 use radicle::identity::{Did, RepoId};
 use radicle::cob::{issue::cache::Issues as _, patch::cache::Patches as _, Author};
 use radicle::identity::RepoId;
 use radicle::node::routing::Store;
 use radicle::node::{AliasStore, Node, NodeId};
 use radicle::storage::{ReadRepository, ReadStorage, RemoteRepository, WriteRepository};
 use radicle::node::{AliasStore, NodeId};
 use radicle::storage::{ReadRepository, ReadStorage, RemoteRepository};
 use crate::api::error::Error;
 use crate::api::project::Info;
 use crate::api::search::{SearchQueryString, SearchResult};
 use crate::api::{self, announce_refs, CobsQuery, Context, PaginationQuery, ProjectQuery};
 use crate::api::{self, CobsQuery, Context, PaginationQuery, ProjectQuery};
 use crate::axum_extra::{cached_response, immutable_response, Path, Query};
 const MAX_BODY_LIMIT: usize = 4_194_304;

         .route("/projects/:project/remotes/:peer", get(remote_handler))
         .route("/projects/:project/blob/:sha/*path", get(blob_handler))
         .route("/projects/:project/readme/:sha", get(readme_handler))
         .route(
             "/projects/:project/issues",
             post(issue_create_handler).get(issues_handler),
         )
         .route(
             "/projects/:project/issues/:id",
             patch(issue_update_handler).get(issue_handler),
         )
         .route(
             "/projects/:project/patches",
             post(patch_create_handler).get(patches_handler),
         )
         .route(
             "/projects/:project/patches/:id",
             patch(patch_update_handler).get(patch_handler),
         )
         .route("/projects/:project/issues", get(issues_handler))
         .route("/projects/:project/issues/:id", get(issue_handler))
         .route("/projects/:project/patches", get(patches_handler))
         .route("/projects/:project/patches/:id", get(patch_handler))
         .with_state(ctx)
         .layer(DefaultBodyLimit::max(MAX_BODY_LIMIT))
 }

     Ok::<_, Error>(Json(issues))
 }
 #[derive(Debug, Deserialize, Serialize)]
 pub struct IssueCreate {
     pub title: String,
     pub description: String,
     pub labels: Vec<Label>,
     pub assignees: Vec<Did>,
     pub embeds: Vec<Embed<Uri>>,
 }
 /// Create a new issue.
 /// `POST /projects/:project/issues`
 async fn issue_create_handler(
     State(ctx): State<Context>,
     AuthBearer(token): AuthBearer,
     Path(project): Path<RepoId>,
     Json(issue): Json<IssueCreate>,
 ) -> impl IntoResponse {
     api::auth::validate(&ctx, &token).await?;
     let (repo, _) = ctx.repo(project)?;
     let node = Node::new(ctx.profile.socket());
     let signer = ctx
         .profile
         .signer()
         .map_err(|_| Error::Auth("Unauthorized"))?;
     let embeds: Vec<Embed> = issue
         .embeds
         .into_iter()
         .filter_map(|embed| resolve_embed(&repo, embed))
         .collect();
     let mut issues = ctx.profile.issues_mut(&repo)?;
     let issue = issues
         .create(
             issue.title,
             issue.description,
             &issue.labels,
             &issue.assignees,
             embeds,
             &signer,
         )
         .map_err(Error::from)?;
     announce_refs(node, repo.id())?;
     Ok::<_, Error>((
         StatusCode::CREATED,
         Json(json!({ "success": true, "id": issue.id().to_string() })),
     ))
 }
 /// Update an issue.
 /// `PATCH /projects/:project/issues/:id`
 async fn issue_update_handler(
     State(ctx): State<Context>,
     AuthBearer(token): AuthBearer,
     Path((project, issue_id)): Path<(RepoId, Oid)>,
     Json(action): Json<issue::Action>,
 ) -> impl IntoResponse {
     api::auth::validate(&ctx, &token).await?;
     let (repo, _) = ctx.repo(project)?;
     let node = Node::new(ctx.profile.socket());
     let signer = ctx.profile.signer()?;
     let mut issues = ctx.profile.issues_mut(&repo)?;
     let mut issue = issues.get_mut(&issue_id.into())?;
     let id = match action {
         issue::Action::Assign { assignees } => issue.assign(assignees, &signer)?,
         issue::Action::Lifecycle { state } => issue.lifecycle(state, &signer)?,
         issue::Action::Label { labels } => issue.label(labels, &signer)?,
         issue::Action::Edit { title } => issue.edit(title, &signer)?,
         issue::Action::Comment {
             body,
             reply_to,
             embeds,
         } => {
             let embeds: Vec<Embed> = embeds
                 .into_iter()
                 .filter_map(|embed| resolve_embed(&repo, embed))
                 .collect();
             if let Some(to) = reply_to {
                 issue.comment(body, to, embeds, &signer)?
             } else {
                 return Err(Error::BadRequest("`replyTo` missing".to_owned()));
             }
         }
         issue::Action::CommentReact {
             id,
             reaction,
             active,
         } => issue.react(id, reaction, active, &signer)?,
         issue::Action::CommentEdit { id, body, embeds } => {
             let embeds: Vec<Embed> = embeds
                 .into_iter()
                 .filter_map(|embed| resolve_embed(&repo, embed))
                 .collect();
             issue.edit_comment(id, body, embeds, &signer)?
         }
         issue::Action::CommentRedact { id } => issue.redact_comment(id, &signer)?,
     };
     announce_refs(node, repo.id())?;
     Ok::<_, Error>(Json(json!({ "success": true, "id": id })))
 }
 /// Get project issue.
 /// `GET /projects/:project/issues/:id`
 async fn issue_handler(