Remove more files supporting the old web front-end

crates/collab/src/assets.rs

@@ -1,29 +0,0 @@
-use anyhow::anyhow;
-use rust_embed::RustEmbed;
-use tide::{http::mime, Server};
-
-#[derive(RustEmbed)]
-#[folder = "static"]
-struct Static;
-
-pub fn add_routes(app: &mut Server<()>) {
-    app.at("/*path").get(get_static_asset);
-}
-
-async fn get_static_asset(request: tide::Request<()>) -> tide::Result {
-    let path = request.param("path").unwrap();
-    let content = Static::get(path).ok_or_else(|| anyhow!("asset not found at {}", path))?;
-
-    let content_type = if path.starts_with("svg") {
-        mime::SVG
-    } else if path.starts_with("styles") {
-        mime::CSS
-    } else {
-        mime::BYTE_STREAM
-    };
-
-    Ok(tide::Response::builder(200)
-        .content_type(content_type)
-        .body(content.data.as_ref())
-        .build())
-}

crates/collab/src/db.rs

@@ -1,6 +1,5 @@
 use anyhow::Context;
 use anyhow::Result;
-pub use async_sqlx_session::PostgresSessionStore as SessionStore;
 use async_std::task::{block_on, yield_now};
 use async_trait::async_trait;
 use serde::Serialize;

crates/collab/src/expiring.rs

@@ -1 +0,0 @@
-

crates/collab/src/github.rs

@@ -1,26 +1,5 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Deserialize, Serialize)]
-pub struct Release {
-    pub tag_name: String,
-    pub name: String,
-    pub body: String,
-    pub draft: bool,
-    pub assets: Vec<Asset>,
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-pub struct Asset {
-    pub name: String,
-    pub url: String,
-}
-
-#[derive(Deserialize)]
-struct Installation {
-    #[allow(unused)]
-    id: usize,
-}
-
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct User {
     pub login: String,

crates/collab/src/main.rs

@@ -1,10 +1,8 @@
 mod api;
-mod assets;
 mod auth;
 mod db;
 mod env;
 mod errors;
-mod expiring;
 mod github;
 mod rpc;
 
@@ -12,36 +10,21 @@ use ::rpc::Peer;
 use async_std::net::TcpListener;
 use async_trait::async_trait;
 use db::{Db, PostgresDb};
-use handlebars::Handlebars;
-use parking_lot::RwLock;
-use rust_embed::RustEmbed;
 use serde::Deserialize;
 use std::sync::Arc;
-use surf::http::cookies::SameSite;
-use tide::sessions::SessionMiddleware;
 use tide_compress::CompressMiddleware;
 
 type Request = tide::Request<Arc<AppState>>;
 
-#[derive(RustEmbed)]
-#[folder = "templates"]
-struct Templates;
-
 #[derive(Default, Deserialize)]
 pub struct Config {
     pub http_port: u16,
     pub database_url: String,
-    pub session_secret: String,
-    pub github_app_id: usize,
-    pub github_client_id: String,
-    pub github_client_secret: String,
-    pub github_private_key: String,
     pub api_token: String,
 }
 
 pub struct AppState {
     db: Arc<dyn Db>,
-    handlebars: RwLock<Handlebars<'static>>,
     config: Config,
 }
 
@@ -51,27 +34,10 @@ impl AppState {
 
         let this = Self {
             db: Arc::new(db),
-            handlebars: Default::default(),
             config,
         };
-        this.register_partials();
         Ok(Arc::new(this))
     }
-
-    fn register_partials(&self) {
-        for path in Templates::iter() {
-            if let Some(partial_name) = path
-                .strip_prefix("partials/")
-                .and_then(|path| path.strip_suffix(".hbs"))
-            {
-                let partial = Templates::get(path.as_ref()).unwrap();
-                self.handlebars
-                    .write()
-                    .register_partial(partial_name, std::str::from_utf8(&partial.data).unwrap())
-                    .unwrap()
-            }
-        }
-    }
 }
 
 #[async_trait]
@@ -120,26 +86,12 @@ pub async fn run_server(
 ) -> tide::Result<()> {
     let mut web = tide::with_state(state.clone());
     web.with(CompressMiddleware::new());
-    web.with(
-        SessionMiddleware::new(
-            db::SessionStore::new_with_table_name(&state.config.database_url, "sessions")
-                .await
-                .unwrap(),
-            state.config.session_secret.as_bytes(),
-        )
-        .with_same_site_policy(SameSite::Lax), // Required obtain our session in /auth_callback
-    );
     api::add_routes(&mut web);
 
-    let mut assets = tide::new();
-    assets.with(CompressMiddleware::new());
-    assets::add_routes(&mut assets);
-
     let mut app = tide::with_state(state.clone());
     rpc::add_routes(&mut app, &rpc);
 
     app.at("/").nest(web);
-    app.at("/static").nest(assets);
 
     app.listen(listener).await?;
 

crates/collab/src/releases.rs

@@ -1,54 +0,0 @@
-use crate::{
-    auth::RequestExt as _, github::Release, AppState, LayoutData, Request, RequestExt as _,
-};
-use comrak::ComrakOptions;
-use serde::Serialize;
-use std::sync::Arc;
-use tide::http::mime;
-
-pub fn add_routes(releases: &mut tide::Server<Arc<AppState>>) {
-    releases.at("/releases").get(get_releases);
-}
-
-async fn get_releases(mut request: Request) -> tide::Result {
-    #[derive(Serialize)]
-    struct ReleasesData {
-        #[serde(flatten)]
-        layout: Arc<LayoutData>,
-        releases: Option<Vec<Release>>,
-    }
-
-    let mut data = ReleasesData {
-        layout: request.layout_data().await?,
-        releases: None,
-    };
-
-    if let Some(user) = request.current_user().await? {
-        if user.is_insider {
-            data.releases = Some(
-                request
-                    .state()
-                    .repo_client
-                    .releases()
-                    .await?
-                    .into_iter()
-                    .filter_map(|mut release| {
-                        if release.draft {
-                            None
-                        } else {
-                            let mut options = ComrakOptions::default();
-                            options.render.unsafe_ = true; // Allow raw HTML in the markup. We control these release notes anyway.
-                            release.body = comrak::markdown_to_html(&release.body, &options);
-                            Some(release)
-                        }
-                    })
-                    .collect(),
-            );
-        }
-    }
-
-    Ok(tide::Response::builder(200)
-        .body(request.state().render_template("releases.hbs", &data)?)
-        .content_type(mime::HTML)
-        .build())
-}

crates/collab/src/rpc.rs

@@ -5728,11 +5728,9 @@ mod tests {
 
         async fn build_app_state(test_db: &TestDb) -> Arc<AppState> {
             let mut config = Config::default();
-            config.session_secret = "a".repeat(32);
             config.database_url = test_db.url.clone();
             Arc::new(AppState {
                 db: test_db.db().clone(),
-                handlebars: Default::default(),
                 config,
             })
         }