Merge remote-tracking branch 'origin/main' into web-app

Author: suaviloquence

Cargo.toml

@@ -50,7 +50,7 @@ axum = { version = "0.7.5", features = [
     "http2",
 ], default-features = false }
 axum-server = { version = "0.6.0", features = ["tls-rustls"] }
-tower-http = { version = "0.5.2", features = ["compression-full"] }
+tower-http = { version = "0.5.2", features = ["compression-full", "cors"] }
 juniper_graphql_ws = "0.4.0"
 pretty_env_logger = "0.5.0"
 log = { version = "0.4.21" }

src/cache/menu_cache.rs

@@ -9,25 +9,22 @@ use firestore::FirestoreDb;
 use futures::{stream::FuturesUnordered, StreamExt};
 use log::info;
 use tokio::io::AsyncReadExt;
-
 const CACHES_COLLECTION: &str = "caches";
-
 #[derive(Debug)]
 pub struct MenuCache<'a> {
     cached_at: DateTime<Utc>,
     locations: Locations<'a>,
 }
-
 #[derive(serde::Serialize, serde::Deserialize, Default)]
-struct InDbMenuCache {
+struct GCloudMenuCache {
     cached_at: DateTime<Utc>,
     data: Vec<u8>,
 }
 
 pub static REFRESH_INTERVAL: chrono::Duration = chrono::Duration::minutes(15);
 
 impl<'a> MenuCache<'a> {
-    async fn from_async(cache: InDbMenuCache) -> Self {
+    async fn from_async(cache: GCloudMenuCache) -> Self {
         if cache.data.is_empty() {
             return MenuCache {
                 cached_at: cache.cached_at,
@@ -85,7 +82,7 @@ impl<'a> MenuCache<'a> {
 
     async fn fetch_from_db() -> Result<Self, crate::error::Error> {
         let db = FirestoreDb::new("ucsc-menu").await?;
-        let cache: InDbMenuCache = db
+        let cache: GCloudMenuCache = db
             .fluent()
             .select()
             .by_id_in(CACHES_COLLECTION)
@@ -96,7 +93,7 @@ impl<'a> MenuCache<'a> {
         Ok(MenuCache::from_async(cache).await)
     }
 
-    async fn to_db_representation(&self) -> InDbMenuCache {
+    async fn to_db_representation(&self) -> GCloudMenuCache {
         let json = serde_json::to_string(self.locations()).unwrap();
         let mut compressed = Vec::with_capacity(json.len() / 4);
         let mut compress =
@@ -105,14 +102,14 @@ impl<'a> MenuCache<'a> {
             .read_buf(&mut compressed)
             .await
             .expect("This should succeed");
-        InDbMenuCache {
+        GCloudMenuCache {
             cached_at: self.cached_at,
             data: compressed,
         }
     }
 
     async fn save_to_db(&self) -> Result<(), firestore::errors::FirestoreError> {
-        let cache: InDbMenuCache = self.to_db_representation().await;
+        let cache: GCloudMenuCache = self.to_db_representation().await;
         let db = FirestoreDb::new("ucsc-menu").await?;
         db.fluent()
             .update()

src/main.rs

@@ -21,19 +21,20 @@ use std::{
 
 use axum::{
     body::Body,
+    http::Method,
     response::Response,
     routing::{get, on, MethodFilter},
     Extension, Router,
 };
 
+use crate::{cache::Multithreaded, fetch::make_client};
 use juniper::{graphql_object, EmptyMutation, EmptySubscription, RootNode};
 use juniper_axum::{graphiql, graphql, playground, ws};
 use juniper_graphql_ws::ConnectionConfig;
 use parse::Locations;
 use tokio::{net::TcpListener, sync::OnceCell, time::sleep};
-use tower_http::compression::CompressionLayer;
-
-use crate::{cache::Multithreaded, fetch::make_client};
+use tower_http::cors::CorsLayer;
+use tower_http::{compression::CompressionLayer, cors::Any};
 
 #[derive(Clone, Copy, Debug)]
 pub struct Query;
@@ -95,6 +96,9 @@ async fn main() {
         .deflate(true)
         .gzip(true)
         .zstd(true);
+    let cors_layer = CorsLayer::new()
+        .allow_methods([Method::GET, Method::POST]) // intentionally excludes request-refresh/PUT
+        .allow_origin(Any);
     pretty_env_logger::init();
 
     let app = Router::new()
@@ -112,6 +116,7 @@ async fn main() {
         .route("/request-refresh", on(MethodFilter::PUT, refresh))
         .route("/graphiql", get(graphiql("/graphql", "/subscriptions")))
         .route("/playground", get(playground("/graphql", "/subscriptions")))
+        .layer(cors_layer)
         .layer(Extension(Arc::new(schema)))
         .layer(comression_layer);
     tokio::spawn(async move {

src/parse/location_page/locations.rs

@@ -180,7 +180,7 @@ mod tests {
             .parse()
             .expect("url should be valid");
         let mut location = Location::new(LocationMeta::from_url(url).unwrap());
-        let v = vec![html];
+        let v = [html];
         location.add_meals(v.iter()).unwrap();
         assert!(location.hydrated());
         let root = RootNode::new(