Merge pull request #1 from TuuKeZu/v2

V2

Author: TuuKeZu

Cargo.lock

@@ -17,10 +17,11 @@ handlebars = "5.1.2"
 serde = "1.0.197"
 serde_json = "1.0.115"
 warp = "0.3.7"
-sqlx = { version = "0.7.4", features = [ "postgres" ]}
 urlencoding = "2.1.3"
 minify-js = { version = "0.6.0", optional = true }
 minify-html = "0.15.0"
+log = "0.4.22"
+http = "1.1.0"
 
 [dependencies.macros]
 path = "./macros"

Cargo.toml

@@ -1,8 +1,74 @@
 # Potion-rs
-## IN DEVELOPMENT, DO NOT DEPLOY TO PRODUCTION
+> [!CAUTION]
+> Should not be used in production, under development
 
-## Documentation
-For now documentation only exists for `potion::Error`.
+Flask inspired general purpose fullstack web-framework with file-system based routing with support for server-side rendered template-based pages. For client side hydration and responsiveness potion includes build-in Typescript bundler *(as it is our philosophy that Typescript should be strictly used for simple DOM manipulation and)*
 
-## Features
-**DO NOT** enable `features = ["router"]`, as it does not currently compile
+### Features
+- [x] File-system based compile-time generated routing
+    - [x] Robust state management between routers
+    - [x] Support for accessing files both in router's own dir and in static folder.
+- [x] typescriot support for post-render DOM-manipulation
+    - [x] .ts files both in /static and /routing directories are automatically compiled and linked *(sourcemaps included)*
+- [x] Optimised for fast rendering
+    - [x] Minified generated HTML
+    - [x] Minified .js bundles
+    - [ ] Compressed HTML
+
+
+## Example
+
+`src/main.rs`
+```rust
+// Derive `potion::IntoContext` for global state
+#[derive(Clone, potion::IntoContext)]
+pub struct RouterContext {
+    pub hb: Arc<Handlebars<'static>>,
+    pub db: Pool<Postgres>
+}
+
+// Generate routing during compilation phase. All .rs files are automatically included during compilation
+potion::routing!();
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    dotenv::dotenv().ok();
+
+    // Initialize file-system routing
+    let (mut hb, static_router) = potion::initialize_routing(
+        &std::env::var("POTION_PROJECT_DIR").expect("Tried to read misconfigured .env file"),
+        true,
+    )?;
+
+    // Create postgres connection-pool
+    let pool = sqlx::postgres::PgPoolOptions::new()
+        .max_connections(5)
+        .connect(&std::env::var("POSTGRES_URL").expect("Tried to read misconfigured .env file"))
+        .await?;
+
+    // Initialize context
+    let context = Box::new(RsContext { hb: Arc::new(hb), db: pool.clone() });
+
+    // Generate and server routing
+    let routes = router(context)
+        .or(static_router);
+
+    warp::serve(routes).run(([0, 0, 0, 0], 3030)).await;
+
+    Ok(())
+}
+```
+
+`src/routing/hello/index.rs`
+```rust
+pub fn initialize(router: potion::Router) -> impl Filter<Extract = (impl warp::Reply,), Error = warp::Rejection> + Clone {
+    // Access global state
+    let context = router.downcast::<RouterContext>();
+    
+    let routing = warp::path("hello")
+        .and(warp::get())
+        .map(|| "Hello World");
+
+    routing
+}
+```

README.md

@@ -12,4 +12,6 @@ channel = "nightly"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-dotenv = "0.15.0"
+dotenv = "0.15.0"
+quote = "1"
+syn = "2.0"

macros/Cargo.lock

@@ -1,5 +1,8 @@
-use proc_macro::{Span, TokenStream};
+use proc_macro::TokenStream;
 use routing::construct_routing_system;
+use syn::{parse_macro_input, DataStruct, DeriveInput};
+use syn::Data::Struct;
+
 
 mod file_system;
 mod routing;
@@ -27,3 +30,36 @@ pub fn routing(_p: TokenStream) -> TokenStream {
 
     ts.parse().unwrap()
 }
+
+#[proc_macro_derive(IntoContext)]
+pub fn hello_derive(item: TokenStream) -> TokenStream {
+    let ast = parse_macro_input!(item as DeriveInput);
+    let name = ast.ident;
+
+    match ast.data {
+        Struct(DataStruct { .. }) => {},
+        _ => unimplemented!("Only works for structs"),
+    };
+
+    quote::quote!{
+        impl potion::Context for #name {
+            fn as_any(&self) -> &dyn Any {
+                self
+            }
+        
+            fn as_any_mut(&mut self) -> &mut dyn Any {
+                self
+            }
+        
+            fn box_clone(&self) -> Box<dyn potion::Context + Send + Sync> {
+                Box::new((*self).clone())
+            }
+        }
+    }.into()
+}
+
+#[test]
+fn test_router() {
+    let a = construct_routing_system("D:\\potion-test\\src\\routing");
+    dbg!(a);
+}

macros/Cargo.toml

@@ -32,7 +32,6 @@ pub fn construct_import_tree(
                 if path.extension().unwrap() == "rs" {
                     let file = entry.file_name().to_str().unwrap().replace(".rs", "");
                     *s += &format!(" pub mod {}; ", &file);
-                    dbg!(&path);
                     l.push(resolve_relative_path(path, true)?);
                 }
             }
@@ -42,21 +41,20 @@ pub fn construct_import_tree(
 }
 
 pub fn construct_router_tree(l: &mut Vec<VecDeque<String>>) -> io::Result<String> {
-    let mut ts = String::from("fn router(hb: Arc<Handlebars<'static>>, pool: Pool<Postgres>) -> impl Filter<Extract = (impl warp::Reply,), Error = warp::Rejection> + Clone { ");
+    let mut ts = String::from("fn router(context: Box<dyn potion::Context + Send + Sync>) -> impl Filter<Extract = (impl warp::Reply,), Error = warp::Rejection> + Clone { ");
 
     let mut tree_list: Vec<&VecDeque<String>> = l.iter().filter(|tree| tree.iter().last().unwrap() == "index").collect();
-    
+
     if let Some(tree) = tree_list.pop() {
         if tree.len() <= 0 {
             panic!("Failed to construct router tree. Tried to link file with invalid path")
         }
         if tree.iter().last().unwrap() == "index" {
             for (i, route) in tree.iter().enumerate() {
-                dbg!(&route, &i);
                 if i == 0 {
                     ts += &format!("warp::path(\"{}\").and(", route)
                 } else if i == tree.len() - 1 {
-                    ts += &format!("routing::{}::initialize( potion::Context::new(hb.clone(), pool.clone(), &[{}]) )", resolve_import_path(tree.clone()), tree.iter().map(|r| format!("\"{r}\"")).collect::<Vec<String>>().join(", "));
+                    ts += &format!("routing::{}::initialize( potion::Router::new(context.clone(), &[{}]))", resolve_import_path(tree.clone()), tree.iter().map(|r| format!("\"{r}\"")).collect::<Vec<String>>().join(", "));
                 } else {
                     ts += &format!("warp::path(\"{}\").and(", route)
                 }
@@ -69,13 +67,12 @@ pub fn construct_router_tree(l: &mut Vec<VecDeque<String>>) -> io::Result<String
     }
 
     for tree in tree_list {
-        dbg!(&tree);
         if tree.iter().last().unwrap() == "index" {
             for (i, route) in tree.iter().enumerate() {
                 if i == 0 {
                     ts += &format!(".or(warp::path(\"{}\").and(", route)
                 } else if i == tree.len() - 1 {
-                    ts += &format!("routing::{}::initialize( potion::Context::new(hb.clone(), pool.clone(), &[{}]) )", resolve_import_path(tree.clone()), tree.iter().map(|r| format!("\"{r}\"")).collect::<Vec<String>>().join(", "));
+                    ts += &format!("routing::{}::initialize( potion::Router::new(context.clone(), &[{}]))", resolve_import_path(tree.clone()), tree.iter().map(|r| format!("\"{r}\"")).collect::<Vec<String>>().join(", "));
                 } else {
                     ts += &format!("warp::path(\"{}\").and(", route)
                 }