Support workspaces at library level

.github/workflows/CI.yml

@@ -101,4 +101,4 @@ jobs:
       - uses: actions-rs/[email protected]
         with:
           command: fmt
-          args: --all -- --check
+          args: --all -- --check

README.md

@@ -120,10 +120,20 @@ create-rust-app create <project_name>
 
 - **Tasks Plugin**
   - For running background jobs, currently only supports actix-web and postgresql
-  - Uses [`fang`](https://github.com/ayrat555/fang) under the hood and all it's features are exposed. 
+  - Uses [`fang`](https://github.com/ayrat555/fang) under the hood and all it's features are exposed.
   - Add a task to the queue with `create_rust_app::tasks::queue()`
   - Run the queue with `cargo run --bin tasks`
 
+- **Workspace Support Plugin** (not supported in the CLI yet)
+  - allows you to organize your rust app in workspaces, and changes the defaults for the environment variables that specify paths to various important places.
+  - to organize you project as a workspace:
+    - enable this feature
+    - refactor your codebase into workspaces (see [#194](https://github.com/Wulf/create-rust-app/issues/194))
+    - Optional: set the following environment variables (paths are relative to the directory you call cargo fullstack/backend/run from)
+      - `CRA_MANIFEST_PATH`: default `./frontend/dist/manifest.json` when called from workspace root, `../frontend/dist/manifest.json` otherwise.
+      - `CRA_FRONTEND_DIR`: default `./frontend` when called from workspace root, `../frontend` otherwise.
+      - `CRA_VIEWS_GLOB`: default `backend/views/\*\*/\*.html` when called from workspace root, `views/\*\*/\*.html` otherwise.
+
 ### 2. Code-gen to reduce boilerplate
 
 ````sh

create-rust-app/Cargo.toml

@@ -173,6 +173,7 @@ plugin_storage = [
 plugin_graphql = []
 plugin_utoipa = ["utoipa", "backend_actix-web"]
 plugin_tasks = ["fang"]
+plugin_workspace_support = []
 backend_poem = ["poem", "anyhow", "mime_guess", "tokio"]
 backend_actix-web = [
   "actix-web",

create-rust-app/src/dev/mod.rs

@@ -197,7 +197,15 @@ fn get_features(project_dir: &'static str) -> Vec<String> {
     let cargo_toml = Manifest::from_path(PathBuf::from_iter([project_dir, "Cargo.toml"]))
         .unwrap_or_else(|_| panic!("Could not find \"{}\"", project_dir));
     // .expect(&format!("Could not find \"{project_dir}\""));
+    #[cfg(not(feature = "plugin_workspace_support"))]
     let deps = cargo_toml.dependencies;
+    #[cfg(feature = "plugin_workspace_support")]
+    let mut deps = cargo_toml.dependencies;
+    #[cfg(feature = "plugin_workspace_support")]
+    if let Some(workspace) = cargo_toml.workspace {
+        // if the manifest has a workspace table, also read dependencies in there
+        deps.extend(workspace.dependencies);
+    }
     let dep = deps.get("create-rust-app").unwrap_or_else(|| {
         panic!(
             "Expected \"{}\" to list 'create-rust-app' as a dependency.",

create-rust-app/src/util/actix_web_utils.rs

@@ -4,6 +4,7 @@ use std::str::FromStr;
 use std::sync::Mutex;
 
 use super::template_utils::SinglePageApplication;
+use super::workspace_utils::FRONTEND_DIR;
 use crate::util::template_utils::{to_template_name, DEFAULT_TEMPLATE, TEMPLATES};
 use actix_files::NamedFile;
 #[cfg(debug_assertions)]
@@ -102,13 +103,13 @@ pub async fn render_views(req: HttpRequest) -> HttpResponse {
         #[cfg(debug_assertions)]
         {
             // dev asset serving
-            let asset_path = &format!("./frontend{path}");
+            let asset_path = &format!("{frontend_dir}{path}", frontend_dir = *FRONTEND_DIR);
             if std::path::PathBuf::from(asset_path).is_file() {
                 println!("ASSET_FILE {path} => {asset_path}");
                 return NamedFile::open(asset_path).unwrap().into_response(&req);
             }
 
-            let public_path = &format!("./frontend/public{path}");
+            let public_path = &format!("{frontend_dir}/public{path}", frontend_dir = *FRONTEND_DIR);
             if std::path::PathBuf::from(public_path).is_file() {
                 println!("PUBLIC_FILE {path} => {public_path}");
                 return NamedFile::open(public_path).unwrap().into_response(&req);
@@ -118,7 +119,7 @@ pub async fn render_views(req: HttpRequest) -> HttpResponse {
         #[cfg(not(debug_assertions))]
         {
             // production asset serving
-            let static_path = &format!("./frontend/dist{path}");
+            let static_path = &format!("{frontend_dir}/dist{path}", frontend_dir = *FRONTEND_DIR);
             if std::path::PathBuf::from(static_path).is_file() {
                 return NamedFile::open(static_path).unwrap().into_response(&req);
             }

create-rust-app/src/util/mod.rs

@@ -3,6 +3,9 @@
 /// are exposed directly as create_rust_app::<utilty-fn>.
 ///
 
+/// constants for paths and files in workspaces
+pub(crate) mod workspace_utils;
+
 #[cfg(feature = "backend_actix-web")]
 mod actix_web_utils;
 

create-rust-app/src/util/poem_utils.rs

@@ -1,5 +1,6 @@
 use std::sync::Mutex;
 
+use super::workspace_utils::FRONTEND_DIR;
 use poem::http::{StatusCode, Uri};
 use poem::middleware::{AddData, AddDataEndpoint};
 use poem::web::Data;
@@ -95,14 +96,14 @@ pub async fn render_views(uri: &Uri) -> impl IntoResponse {
         #[cfg(debug_assertions)]
         {
             // dev asset serving
-            let asset_path = &format!("./frontend{path}");
+            let asset_path = &format!("{frontend_dir}{path}", frontend_dir = *FRONTEND_DIR);
             if std::path::PathBuf::from(asset_path).is_file() {
                 println!("ASSET_FILE {path} => {asset_path}");
 
                 return file_response(asset_path).await;
             }
 
-            let public_path = &format!("./frontend/public{path}");
+            let public_path = &format!("{frontend_dir}/public{path}", frontend_dir = *FRONTEND_DIR);
             if std::path::PathBuf::from(public_path).is_file() {
                 println!("PUBLIC_FILE {path} => {public_path}");
 
@@ -113,7 +114,7 @@ pub async fn render_views(uri: &Uri) -> impl IntoResponse {
         #[cfg(not(debug_assertions))]
         {
             // production asset serving
-            let static_path = &format!("./frontend/dist{path}");
+            let static_path = &format!("{frontend_dir}/dist{path}", frontend_dir = *FRONTEND_DIR);
             if std::path::PathBuf::from(static_path).is_file() {
                 return file_response(static_path).await;
             }

create-rust-app/src/util/template_utils.rs

@@ -1,3 +1,4 @@
+use super::workspace_utils::{MANIFEST_PATH, VIEWS_GLOB};
 use lazy_static::lazy_static;
 use std::collections::HashMap;
 use tera::Tera;
@@ -12,7 +13,7 @@ lazy_static! {
     /// all the Templates (html files) included in backend/views/..., uses Tera to bundle the frontend into the template
     /// TODO: ensure this is accurate documentation
     pub static ref TEMPLATES: Tera = {
-        let mut tera = match Tera::new("backend/views/**/*.html") {
+        let mut tera = match Tera::new(VIEWS_GLOB.as_str()) {
             Ok(t) => t,
             Err(e) => {
                 println!("Parsing error(s): {e}");
@@ -152,7 +153,7 @@ fn load_manifest_entries() -> ViteManifest {
 
     use serde_json::Value;
     let manifest_json = serde_json::from_str(
-        std::fs::read_to_string(std::path::PathBuf::from("./frontend/dist/manifest.json"))
+        std::fs::read_to_string(std::path::PathBuf::from(MANIFEST_PATH.as_str()))
             .unwrap()
             .as_str(),
     )

create-rust-app/src/util/workspace_utils.rs

@@ -0,0 +1,84 @@
+use std::path::{Path, PathBuf};
+
+use lazy_static::lazy_static;
+
+lazy_static!(
+    pub static ref WORKSPACE_DIR: PathBuf = {
+        let output = std::process::Command::new(env!("CARGO"))
+            .arg("locate-project")
+            .arg("--workspace")
+            .arg("--message-format=plain")
+            .output()
+            .unwrap()
+            .stdout;
+        let cargo_path = Path::new(std::str::from_utf8(&output).unwrap().trim());
+        cargo_path.parent().unwrap().to_path_buf()
+        // .to_str()
+        // .unwrap()
+        // .to_owned()
+    };
+    /// constant for the path to the project's frontend directory
+    pub(crate) static ref FRONTEND_DIR: String = {
+        match std::env::var("CRA_FRONTEND_DIR") {
+            Ok(dir) => dir,
+            Err(_) => {
+                #[cfg(not(feature = "plugin_workspace_support"))]
+                {
+                    "./frontend".to_string()
+                }
+                #[cfg(feature = "plugin_workspace_support")]
+                {
+                    if *WORKSPACE_DIR == std::env::current_dir().unwrap() {
+                        // this is for when cargo run is run from the workspace root
+                        return "./frontend".to_string();
+                    } else {
+                        // this is for when cargo run is run from teh backend directory
+                        return "../frontend".to_string();
+                    }
+                }
+            }
+        }
+    };
+    /// constant for the path to the project's manifest.json file
+    pub(crate) static ref MANIFEST_PATH: String = {
+        match std::env::var("CRA_MANIFEST_PATH") {
+            Ok(dir) => dir,
+            Err(_) => {
+                #[cfg(not(feature = "plugin_workspace_support"))]
+                {
+                    "./frontend/dist/manifest.json".to_string()
+                }
+                #[cfg(feature = "plugin_workspace_support")]
+                {
+                    if *WORKSPACE_DIR == std::env::current_dir().unwrap() {
+                        return "./frontend/dist/manifest.json".to_string();
+                    } else {
+                        return "../frontend/dist/manifest.json".to_string();
+                    }
+                }
+            }
+        }
+    };
+    /// constant for the path to the project's views directory
+    pub(crate) static ref VIEWS_GLOB: String = {
+        match std::env::var("CRA_VIEWS_GLOB") {
+            Ok(dir) => dir,
+            Err(_) => {
+                #[cfg(not(feature = "plugin_workspace_support"))]
+                {
+                    "backend/views/**/*.html".to_string()
+                }
+                #[cfg(feature = "plugin_workspace_support")]
+                {
+                    if *WORKSPACE_DIR == std::env::current_dir().unwrap() {
+                        return "backend/views/**/*.html".to_string();
+                    } else {
+                        return "views/**/*.html".to_string();
+                    }
+                }
+            }
+        }
+    };
+
+
+);