1use anyhow::{Context, Result, bail};
18use chrono::Utc;
19use std::fs;
20use std::path::{Path, PathBuf};
21use tera::{Context as TeraContext, Tera};
22
23pub struct Generator {
27 root: PathBuf,
28 tera: Tera,
29}
30
31impl Generator {
32 pub fn new(root: impl Into<PathBuf>) -> Self {
34 let mut tera = Tera::default();
35 tera.add_raw_template("controller", CONTROLLER_TEMPLATE)
37 .unwrap();
38 tera.add_raw_template("middleware", MIDDLEWARE_TEMPLATE)
39 .unwrap();
40 tera.add_raw_template("migration", MIGRATION_TEMPLATE)
41 .unwrap();
42 tera.add_raw_template("seeder", SEEDER_TEMPLATE).unwrap();
43 tera.add_raw_template("provider", PROVIDER_TEMPLATE)
44 .unwrap();
45 tera.add_raw_template("request", REQUEST_TEMPLATE).unwrap();
46 tera.add_raw_template("model", MODEL_TEMPLATE).unwrap();
47 tera.add_raw_template("job", JOB_TEMPLATE).unwrap();
48 tera.add_raw_template("cargo_toml", CARGO_TOML_TEMPLATE)
49 .unwrap();
50 tera.add_raw_template("main_rs", MAIN_RS_TEMPLATE).unwrap();
51 tera.add_raw_template("app_toml", APP_TOML_TEMPLATE)
52 .unwrap();
53 tera.add_raw_template("env", ENV_TEMPLATE).unwrap();
54 tera.add_raw_template("migrator", MIGRATOR_TEMPLATE)
55 .unwrap();
56 tera.add_raw_template("migrate_bin", MIGRATE_BIN_TEMPLATE)
57 .unwrap();
58 tera.add_raw_template("seed_bin", SEED_BIN_TEMPLATE)
59 .unwrap();
60 Self {
61 root: root.into(),
62 tera,
63 }
64 }
65
66 pub fn root(&self) -> &Path {
68 &self.root
69 }
70
71 pub fn ensure_dir(&self, rel: &str) -> Result<PathBuf> {
73 let dir = self.root.join(rel);
74 fs::create_dir_all(&dir)?;
75 Ok(dir)
76 }
77
78 pub fn exists(&self, rel: &str) -> bool {
80 self.root.join(rel).exists()
81 }
82
83 pub fn create_file(&self, rel: &str, content: &str) -> Result<()> {
85 let path = self.root.join(rel);
86 if path.exists() {
87 bail!("File '{}' already exists", rel);
88 }
89 if let Some(parent) = path.parent() {
90 fs::create_dir_all(parent)?;
91 }
92 fs::write(&path, content)?;
93 Ok(())
94 }
95
96 pub fn overwrite_file(&self, rel: &str, content: &str) -> Result<()> {
98 let path = self.root.join(rel);
99 if let Some(parent) = path.parent() {
100 fs::create_dir_all(parent)?;
101 }
102 fs::write(&path, content)?;
103 Ok(())
104 }
105
106 fn make_context(name: &str) -> TeraContext {
110 let snake = to_snake(name);
111 let kebab = to_kebab(name);
112 let timestamp = Utc::now().format("%Y_%m_%d_%H%M%S").to_string();
113
114 let mut ctx = TeraContext::new();
115 ctx.insert("name", name);
116 ctx.insert("snake", &snake);
117 ctx.insert("kebab", &kebab);
118 ctx.insert("timestamp", ×tamp);
119 ctx
120 }
121
122 pub fn render(&self, template_name: &str, name: &str) -> Result<String> {
124 let ctx = Self::make_context(name);
125 self.tera
126 .render(template_name, &ctx)
127 .with_context(|| format!("Failed to render template '{template_name}'"))
128 }
129
130 pub fn scaffold_controller(&self, name: &str) -> Result<()> {
134 let content = self.render("controller", name)?;
135 self.create_file(&format!("app/Http/Controllers/{name}.rs"), &content)
136 }
137
138 pub fn scaffold_middleware(&self, name: &str) -> Result<()> {
140 let content = self.render("middleware", name)?;
141 self.create_file(&format!("app/Http/Middleware/{name}.rs"), &content)
142 }
143
144 pub fn scaffold_migration(&self, name: &str) -> Result<()> {
146 let content = self.render("migration", name)?;
147 let timestamp = Utc::now().format("%Y_%m_%d_%H%M%S");
148 let snake = to_snake(name);
149 self.create_file(
150 &format!("database/migrations/{}_{}.rs", timestamp, snake),
151 &content,
152 )
153 }
154
155 pub fn scaffold_seeder(&self, name: &str) -> Result<()> {
157 let content = self.render("seeder", name)?;
158 self.create_file(&format!("database/seeders/{name}.rs"), &content)
159 }
160
161 pub fn scaffold_provider(&self, name: &str) -> Result<()> {
163 let content = self.render("provider", name)?;
164 self.create_file(&format!("app/Providers/{name}.rs"), &content)
165 }
166
167 pub fn scaffold_request(&self, name: &str) -> Result<()> {
169 let content = self.render("request", name)?;
170 self.create_file(&format!("app/Http/Requests/{name}.rs"), &content)
171 }
172
173 pub fn scaffold_model(&self, name: &str) -> Result<()> {
175 let content = self.render("model", name)?;
176 self.create_file(&format!("app/Models/{name}.rs"), &content)
177 }
178
179 pub fn scaffold_job(&self, name: &str) -> Result<()> {
181 let content = self.render("job", name)?;
182 self.create_file(&format!("app/Jobs/{name}.rs"), &content)
183 }
184
185 pub fn scaffold_project(&self, project_name: &str) -> Result<()> {
187 let dirs = [
188 "app/Http/Controllers",
189 "app/Http/Middleware",
190 "app/Http/Requests",
191 "app/Models",
192 "app/Services",
193 "app/Providers",
194 "bootstrap",
195 "config",
196 "database/migrations",
197 "database/seeders",
198 "routes",
199 "storage",
200 "tests",
201 "src",
202 "src/bin",
203 ];
204
205 for dir in dirs {
206 self.ensure_dir(dir)?;
207 }
208
209 self.overwrite_file("Cargo.toml", &self.render("cargo_toml", project_name)?)?;
211
212 self.overwrite_file("src/main.rs", &self.render("main_rs", project_name)?)?;
214
215 self.overwrite_file("config/app.toml", &self.render("app_toml", project_name)?)?;
217
218 if !self.exists(".env") {
220 self.overwrite_file(".env", &self.render("env", project_name)?)?;
221 }
222
223 self.overwrite_file(".env.example", &self.render("env", project_name)?)?;
225
226 if !self.exists("database/migrations/mod.rs") {
228 self.overwrite_file("database/migrations/mod.rs", MIGRATOR_TEMPLATE)?;
229 }
230
231 if !self.exists("src/bin/migrate.rs") {
233 self.overwrite_file("src/bin/migrate.rs", MIGRATE_BIN_TEMPLATE)?;
234 }
235
236 if !self.exists("src/bin/seed.rs") {
238 self.overwrite_file("src/bin/seed.rs", SEED_BIN_TEMPLATE)?;
239 }
240
241 Ok(())
242 }
243}
244
245fn to_snake(s: &str) -> String {
248 let mut out = String::with_capacity(s.len() + 4);
249 let chars = s.chars().peekable();
250 for c in chars {
251 if c.is_uppercase() {
252 if !out.is_empty() {
253 out.push('_');
254 }
255 out.push(c.to_lowercase().next().unwrap());
256 } else {
257 out.push(c);
258 }
259 }
260 out
261}
262
263fn to_kebab(s: &str) -> String {
264 to_snake(s).replace('_', "-")
265}
266
267const CONTROLLER_TEMPLATE: &str = r#"use ravel_http::controller::Controller;
270use ravel_core::container::Container;
271
272pub struct {{name}};
273
274impl Controller for {{name}} {
275 fn boot(_container: &Container) -> Self {
276 Self
277 }
278}
279
280// ── Handlers ──────────────────────────────────────────────────────
281//
282// impl {{name}} {
283// pub async fn index() -> impl axum::response::IntoResponse {
284// "{{name}} index"
285// }
286// }
287"#;
288
289const MIDDLEWARE_TEMPLATE: &str = r#"use axum::{
290 extract::Request,
291 middleware::Next,
292 response::Response,
293};
294
295/// {{name}} — custom middleware.
296pub struct {{name}};
297
298impl {{name}} {
299 pub fn new() -> Self {
300 Self
301 }
302}
303
304pub async fn handle(req: Request, next: Next) -> Response {
305 // TODO: pre-processing logic here
306
307 let response = next.run(req).await;
308
309 // TODO: post-processing logic here
310
311 response
312}
313"#;
314
315const MIGRATION_TEMPLATE: &str = r#"use sea_orm_migration::prelude::*;
316
317#[derive(DeriveMigrationName)]
318pub struct Migration;
319
320#[async_trait::async_trait]
321impl MigrationTrait for Migration {
322 async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
323 // TODO: apply the migration
324 // Example:
325 // manager.create_table(
326 // Table::create()
327 // .table(Users::Table)
328 // .col(ColumnDef::new(Users::Id).integer().not_null().auto_increment().primary_key())
329 // .col(ColumnDef::new(Users::Name).string().not_null())
330 // .to_owned()
331 // ).await
332 Ok(())
333 }
334
335 async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
336 // TODO: rollback the migration
337 // Example:
338 // manager.drop_table(Table::drop().table(Users::Table).to_owned()).await
339 Ok(())
340 }
341}
342"#;
343
344const SEEDER_TEMPLATE: &str = r#"use anyhow::Result;
345use sea_orm::DatabaseConnection;
346
347/// Seeder: {{name}}
348
349pub async fn run(_db: &DatabaseConnection) -> Result<()> {
350 // TODO: insert seed data
351 // Example:
352 // use sea_orm::ActiveModelTrait;
353 // use sea_orm::ActiveValue::Set;
354 // let model = your_model::ActiveModel { name: Set("test".into()), ..Default::default() };
355 // model.insert(_db).await?;
356 Ok(())
357}
358"#;
359
360const PROVIDER_TEMPLATE: &str = r#"use ravel_core::app::ServiceProvider;
361use ravel_core::container::Container;
362use anyhow::Result;
363
364pub struct {{name}};
365
366impl ServiceProvider for {{name}} {
367 fn register(&self, container: &Container) -> Result<()> {
368 // Bind services into the container here.
369 let _ = container;
370 Ok(())
371 }
372
373 fn boot(&self, container: &Container) -> Result<()> {
374 // Wire up dependencies — all providers are registered at this point.
375 let _ = container;
376 Ok(())
377 }
378
379 fn name(&self) -> &str {
380 "{{name}}"
381 }
382}
383"#;
384
385const JOB_TEMPLATE: &str = r#"use ravel_support::queue::Job;
386use ravel_macros::Job;
387use serde::{Serialize, Deserialize};
388use async_trait::async_trait;
389
390#[derive(Serialize, Deserialize, Job)]
391#[job(name = "{{snake}}")]
392pub struct {{name}} {
393 // TODO: add payload fields
394}
395
396#[async_trait]
397impl Job for {{name}} {
398 async fn handle(&self) -> anyhow::Result<()> {
399 // TODO: implement job logic
400 tracing::info!("{{name}} job executed");
401 Ok(())
402 }
403}
404"#;
405
406const REQUEST_TEMPLATE: &str = r#"use ravel_http::form_request::FormRequest;
407use ravel_http::validation::{FieldRule, Rule};
408use serde::Deserialize;
409
410/// Form request: {{name}}
411#[derive(Debug, Deserialize)]
412#[allow(dead_code)]
413pub struct {{name}} {
414 // TODO: define fields
415 // pub name: String,
416 // pub email: String,
417}
418
419impl FormRequest for {{name}} {
420 fn rules() -> Vec<FieldRule> {
421 vec![
422 // FieldRule::new("name", vec![Rule::Required, Rule::Min(3)]),
423 // FieldRule::new("email", vec![Rule::Required, Rule::Email]),
424 ]
425 }
426
427 // fn authorize(&self) -> bool {
428 // true
429 // }
430
431 // fn messages() -> std::collections::HashMap<String, String> {
432 // let mut m = std::collections::HashMap::new();
433 // m.insert("name.required".into(), "Name is required".into());
434 // m
435 // }
436}
437"#;
438
439const MODEL_TEMPLATE: &str = r#"use sea_orm::entity::prelude::*;
440
441/// Model: {{name}}
442#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
443#[sea_orm(table_name = "{{snake}}")]
444pub struct Model {
445 #[sea_orm(primary_key)]
446 pub id: i32,
447 // TODO: add columns
448 // pub name: String,
449 // pub email: String,
450 // pub created_at: DateTime,
451 // pub updated_at: DateTime,
452}
453
454#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
455pub enum Relation {}
456
457impl ActiveModelBehavior for ActiveModel {}
458"#;
459
460const CARGO_TOML_TEMPLATE: &str = r#"[package]
461name = "{{snake}}"
462version = "0.1.0"
463edition = "2024"
464
465[dependencies]
466ravel-core = { path = "../ravel-core" }
467ravel-http = { path = "../ravel-http" }
468axum = "0.8"
469tokio = { version = "1", features = ["full"] }
470serde = { version = "1", features = ["derive"] }
471serde_json = "1"
472anyhow = "1"
473"#;
474
475const MAIN_RS_TEMPLATE: &str = r#"use axum::Router;
476use ravel_http::route::Route;
477
478#[tokio::main]
479async fn main() {
480 let app: Router = Route::new()
481 .get("/", || async { "Hello, Ravel! 🚀" })
482 .build();
483
484 let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
485 .await
486 .unwrap();
487
488 println!("Ravel running at http://127.0.0.1:3000");
489
490 axum::serve(listener, app).await.unwrap();
491}
492"#;
493
494const APP_TOML_TEMPLATE: &str = r#"# Ravel application configuration
495
496[app]
497name = "{{name}}"
498env = "local"
499debug = true
500url = "http://localhost:3000"
501
502[server]
503host = "127.0.0.1"
504port = 3000
505"#;
506
507const ENV_TEMPLATE: &str = r#"APP_NAME={{name}}
508APP_ENV=local
509APP_DEBUG=true
510APP_URL=http://localhost:3000
511"#;
512
513const MIGRATOR_TEMPLATE: &str = r#"use sea_orm_migration::prelude::*;
514
515pub struct Migrator;
516
517#[async_trait::async_trait]
518impl MigratorTrait for Migrator {
519 fn migrations() -> Vec<Box<dyn MigrationTrait>> {
520 vec![
521 // Register new migrations here:
522 // Box::new(m20240101_000001_create_users::Migration),
523 ]
524 }
525}
526"#;
527
528const MIGRATE_BIN_TEMPLATE: &str = r#"use std::env;
529use sea_orm::Database;
530use sea_orm_migration::MigratorTrait;
531use ravel_db_seaorm::connection::ConnectionManager;
532
533#[path = "../../database/migrations/mod.rs"]
534mod migrations;
535
536#[tokio::main]
537async fn main() -> anyhow::Result<()> {
538 let mut manager = ConnectionManager::from_config("config")?;
539 let db = manager.connect("default").await?;
540
541 let args: Vec<String> = env::args().collect();
542 let cmd = args.get(1).map(|s| s.as_str()).unwrap_or("up");
543 let steps: Option<u32> = args.get(2).and_then(|s| s.parse().ok());
544
545 match cmd {
546 "up" | "migrate" => {
547 println!("Running migrations...");
548 migrations::Migrator::up(db, steps).await?;
549 println!("Migrations complete.");
550 }
551 "down" | "rollback" => {
552 println!("Rolling back...");
553 migrations::Migrator::down(db, steps.or(Some(1))).await?;
554 println!("Rollback complete.");
555 }
556 "fresh" => {
557 println!("Dropping all tables and re-applying...");
558 migrations::Migrator::fresh(db).await?;
559 println!("Fresh complete.");
560 }
561 "refresh" => {
562 println!("Refreshing (rollback all + re-apply)...");
563 migrations::Migrator::refresh(db).await?;
564 println!("Refresh complete.");
565 }
566 "status" => {
567 migrations::Migrator::status(db).await?;
568 }
569 other => {
570 eprintln!("Unknown command: {other}");
571 eprintln!("Usage: migrate [up|down|fresh|refresh|status] [steps]");
572 std::process::exit(1);
573 }
574 }
575
576 Ok(())
577}
578"#;
579
580const SEED_BIN_TEMPLATE: &str = r#"use sea_orm::Database;
581use ravel_db_seaorm::connection::ConnectionManager;
582
583#[tokio::main]
584async fn main() -> anyhow::Result<()> {
585 let mut manager = ConnectionManager::from_config("config")?;
586 let db = manager.connect("default").await?;
587
588 println!("Seeding database...");
589
590 // Register and run seeders here:
591 // seeders::UserSeeder::run(db).await?;
592
593 println!("Database seeded.");
594 Ok(())
595}
596"#;
597
598#[cfg(test)]
601mod tests {
602 use super::*;
603
604 #[test]
605 fn test_snake_case() {
606 assert_eq!(to_snake("HelloWorld"), "hello_world");
607 assert_eq!(to_snake("HTTPS"), "h_t_t_p_s");
608 assert_eq!(to_snake("already_snake"), "already_snake");
609 assert_eq!(to_snake("UserController"), "user_controller");
610 }
611
612 #[test]
613 fn test_kebab_case() {
614 assert_eq!(to_kebab("HelloWorld"), "hello-world");
615 assert_eq!(to_kebab("UserController"), "user-controller");
616 }
617
618 #[test]
619 fn test_render() {
620 let mut g = Generator::new("/tmp/test");
621 g.tera
623 .add_raw_template("test_tpl", "Hello {{ name }}, your file is {{ snake }}.rs")
624 .unwrap();
625 let output = g.render("test_tpl", "UserController").unwrap();
626 assert!(output.contains("UserController"));
627 assert!(output.contains("user_controller.rs"));
628 assert!(!output.contains("{{ name }}"));
629 }
630
631 #[test]
632 fn test_generate_controller() {
633 let tmp = std::env::temp_dir().join("ravel_gen_test");
634 let _ = std::fs::remove_dir_all(&tmp);
635
636 let g = Generator::new(&tmp);
637 g.scaffold_controller("UserController").unwrap();
638
639 let content =
640 std::fs::read_to_string(tmp.join("app/Http/Controllers/UserController.rs")).unwrap();
641 assert!(content.contains("pub struct UserController"));
642 assert!(content.contains("impl Controller for UserController"));
643
644 let _ = std::fs::remove_dir_all(&tmp);
645 }
646
647 #[test]
648 fn test_generate_middleware() {
649 let tmp = std::env::temp_dir().join("ravel_gen_test2");
650 let _ = std::fs::remove_dir_all(&tmp);
651
652 let g = Generator::new(&tmp);
653 g.scaffold_middleware("AuthMiddleware").unwrap();
654
655 let content =
656 std::fs::read_to_string(tmp.join("app/Http/Middleware/AuthMiddleware.rs")).unwrap();
657 assert!(content.contains("pub struct AuthMiddleware"));
658
659 let _ = std::fs::remove_dir_all(&tmp);
660 }
661
662 #[test]
663 fn test_generate_migration() {
664 let tmp = std::env::temp_dir().join("ravel_gen_test3");
665 let _ = std::fs::remove_dir_all(&tmp);
666
667 let g = Generator::new(&tmp);
668 g.scaffold_migration("CreateUsersTable").unwrap();
669
670 let dir = tmp.join("database/migrations");
671 let entries: Vec<_> = std::fs::read_dir(&dir).unwrap().collect();
672 assert_eq!(entries.len(), 1);
673
674 let path = entries[0].as_ref().unwrap().path();
675 let fname = path.file_name().unwrap().to_str().unwrap();
676 assert!(fname.ends_with("_create_users_table.rs"));
677
678 let content = std::fs::read_to_string(&path).unwrap();
679 assert!(content.contains("MigrationTrait"));
680 assert!(content.contains("async fn up"));
681
682 let _ = std::fs::remove_dir_all(&tmp);
683 }
684
685 #[test]
686 fn test_generate_seeder() {
687 let tmp = std::env::temp_dir().join("ravel_gen_test4");
688 let _ = std::fs::remove_dir_all(&tmp);
689
690 let g = Generator::new(&tmp);
691 g.scaffold_seeder("UserSeeder").unwrap();
692
693 let content = std::fs::read_to_string(tmp.join("database/seeders/UserSeeder.rs")).unwrap();
694 assert!(content.contains("pub async fn run(_db: &DatabaseConnection)"));
695
696 let _ = std::fs::remove_dir_all(&tmp);
697 }
698
699 #[test]
700 fn test_generate_provider() {
701 let tmp = std::env::temp_dir().join("ravel_gen_test5");
702 let _ = std::fs::remove_dir_all(&tmp);
703
704 let g = Generator::new(&tmp);
705 g.scaffold_provider("RouteServiceProvider").unwrap();
706
707 let content =
708 std::fs::read_to_string(tmp.join("app/Providers/RouteServiceProvider.rs")).unwrap();
709 assert!(content.contains("impl ServiceProvider for RouteServiceProvider"));
710 assert!(content.contains("fn register"));
711 assert!(content.contains("fn boot"));
712
713 let _ = std::fs::remove_dir_all(&tmp);
714 }
715
716 #[test]
717 fn test_generate_request() {
718 let tmp = std::env::temp_dir().join("ravel_gen_test6");
719 let _ = std::fs::remove_dir_all(&tmp);
720
721 let g = Generator::new(&tmp);
722 g.scaffold_request("LoginRequest").unwrap();
723
724 let content =
725 std::fs::read_to_string(tmp.join("app/Http/Requests/LoginRequest.rs")).unwrap();
726 assert!(content.contains("pub struct LoginRequest"));
727 assert!(content.contains("impl FormRequest for LoginRequest"));
728 assert!(content.contains("fn rules"));
729
730 let _ = std::fs::remove_dir_all(&tmp);
731 }
732
733 #[test]
734 fn test_scaffold_project() {
735 let tmp = std::env::temp_dir().join("ravel_gen_project");
736 let _ = std::fs::remove_dir_all(&tmp);
737
738 let g = Generator::new(&tmp);
739 g.scaffold_project("MyApp").unwrap();
740
741 assert!(tmp.join("Cargo.toml").exists());
742 assert!(tmp.join("src/main.rs").exists());
743 assert!(tmp.join("config/app.toml").exists());
744 assert!(tmp.join(".env").exists());
745 assert!(tmp.join("app/Http/Controllers").is_dir());
746 assert!(tmp.join("database/migrations").is_dir());
747 assert!(tmp.join("database/migrations/mod.rs").exists());
748 assert!(tmp.join("src/bin/migrate.rs").exists());
749 assert!(tmp.join("src/bin/seed.rs").exists());
750
751 let cargo = std::fs::read_to_string(tmp.join("Cargo.toml")).unwrap();
752 assert!(cargo.contains("my_app"));
753
754 let migrator = std::fs::read_to_string(tmp.join("database/migrations/mod.rs")).unwrap();
755 assert!(migrator.contains("MigratorTrait"));
756
757 let migrate_bin = std::fs::read_to_string(tmp.join("src/bin/migrate.rs")).unwrap();
758 assert!(migrate_bin.contains("Migrator::up"));
759
760 let _ = std::fs::remove_dir_all(&tmp);
761 }
762}