with push_release

cibus_bin/src/graphql.rs

@@ -0,0 +1,67 @@
+use async_graphql::{Context, EmptyMutation, EmptySubscription, Object, Schema, SimpleObject};
+use uuid::Uuid;
+
+pub type CibusSchema = Schema<QueryRoot, EmptyMutation, EmptySubscription>;
+
+pub struct QueryRoot;
+
+#[Object]
+impl QueryRoot {
+    async fn get_upcoming(&self, ctx: &Context<'_>) -> Vec<Event> {
+        vec![Event::new(
+            None,
+            "Some-name".into(),
+            None,
+            None,
+            EventDate::new(2022, 08, 08, 23, 51),
+        )]
+    }
+}
+
+#[derive(SimpleObject)]
+pub struct Event {
+    pub id: String,
+    pub name: String,
+    pub description: Option<Vec<String>>,
+    pub location: Option<String>,
+    pub date: EventDate,
+}
+
+impl Event {
+    pub fn new(
+        id: Option<String>,
+        name: String,
+        description: Option<Vec<String>>,
+        location: Option<String>,
+        date: EventDate,
+    ) -> Self {
+        Self {
+            id: id.unwrap_or_else(|| Uuid::new_v4().to_string()),
+            name,
+            description,
+            location,
+            date,
+        }
+    }
+}
+
+#[derive(SimpleObject)]
+pub struct EventDate {
+    pub year: u32,
+    pub month: u32,
+    pub day: u32,
+    pub hour: u32,
+    pub minute: u32,
+}
+
+impl EventDate {
+    pub fn new(year: u32, month: u32, day: u32, hour: u32, minute: u32) -> Self {
+        Self {
+            year,
+            month,
+            day,
+            hour,
+            minute,
+        }
+    }
+}

cibus_bin/src/main.rs

@@ -1,17 +1,34 @@
 use std::env::{self, current_dir};
 
-use askama::Template;
+mod graphql;
+
 use axum::{
-    http::StatusCode,
-    response::{Html, IntoResponse, Response},
-    routing::{get},
-    Router,
+    extract::Extension,
+    http::Method,
+    response::{Html, IntoResponse},
+    routing::get,
+    Json, Router,
 };
-use axum_extra::routing::SpaRouter;
+
+use async_graphql::{
+    http::{playground_source, GraphQLPlaygroundConfig},
+    EmptyMutation, EmptySubscription, Request, Response, Schema,
+};
+use graphql::CibusSchema;
 use sqlx::PgPool;
-use tower_http::{trace::TraceLayer};
+use tower_http::{cors::CorsLayer, trace::TraceLayer};
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 
+use crate::graphql::QueryRoot;
+
+async fn graphql_handler(schema: Extension<CibusSchema>, req: Json<Request>) -> Json<Response> {
+    schema.execute(req.0).await.into()
+}
+
+async fn graphql_playground() -> impl IntoResponse {
+    Html(playground_source(GraphQLPlaygroundConfig::new("/")))
+}
+
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     // Environment
@@ -39,48 +56,31 @@ async fn main() -> anyhow::Result<()> {
 
     tracing::info!("current path: {}", current_dir()?.to_string_lossy());
 
+    // Schema
+    println!("Building schema");
+    let schema = Schema::build(QueryRoot, EmptyMutation, EmptySubscription).finish();
+
+    // CORS
+    let cors = vec!["http://localhost:3000".parse().unwrap()];
+
     // Webserver
     tracing::info!("Building router");
     let app = Router::new()
-        .route("/", get(index_handler))
-        .merge(SpaRouter::new("/assets", "assets"))
-        .layer(TraceLayer::new_for_http());
+        .route("/", get(graphql_playground).post(graphql_handler))
+        .layer(Extension(schema))
+        .layer(TraceLayer::new_for_http())
+        .layer(
+            CorsLayer::new()
+                .allow_origin(cors)
+                .allow_headers([axum::http::header::CONTENT_TYPE])
+                .allow_methods([Method::GET, Method::POST, Method::OPTIONS]),
+        );
 
     tracing::info!("Starting webserver");
-    axum::Server::bind(&"0.0.0.0:3000".parse().unwrap())
+    axum::Server::bind(&"0.0.0.0:3001".parse().unwrap())
         .serve(app.into_make_service())
         .await
         .unwrap();
 
     Ok(())
 }
-
-struct HtmlTemplate<T>(T);
-
-impl<T> IntoResponse for HtmlTemplate<T>
-where
-    T: Template,
-{
-    fn into_response(self) -> Response {
-        match self.0.render() {
-            Ok(html) => Html(html).into_response(),
-            Err(err) => (
-                StatusCode::INTERNAL_SERVER_ERROR,
-                format!("Failed to render template. Error: {}", err),
-            )
-                .into_response(),
-        }
-    }
-}
-
-#[derive(Template)]
-#[template(path = "index.html")]
-struct IndexTemplate {
-    name: String,
-}
-
-async fn index_handler() -> impl IntoResponse {
-    HtmlTemplate(IndexTemplate {
-        name: "Cibus".into(),
-    })
-}