use std::collections::BTreeMap;
use std::fmt;
use std::path::PathBuf;
use clap::ValueEnum;
use serde::{Deserialize, Serialize};
pub const EXCLUDED_DIRS: &[&str] = &[
".git",
"node_modules",
"target",
"vendor",
"dist",
"build",
".venv",
"__pycache__",
".next",
".nuxt",
".svelte-kit",
".turbo",
".output",
".cache",
"bin",
"obj",
];
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum Language {
NodeJs,
Python,
Go,
Rust,
Java,
Php,
DotNet,
Ruby,
Unknown(String),
}
impl fmt::Display for Language {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Language::NodeJs => write!(f, "Node.js"),
Language::Python => write!(f, "Python"),
Language::Go => write!(f, "Go"),
Language::Rust => write!(f, "Rust"),
Language::Java => write!(f, "Java"),
Language::Php => write!(f, "PHP"),
Language::DotNet => write!(f, ".NET"),
Language::Ruby => write!(f, "Ruby"),
Language::Unknown(name) => write!(f, "Unknown({name})"),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum PackageManager {
Npm,
Pnpm,
Yarn,
Bun,
Pip,
Poetry,
Pipenv,
Cargo,
GoModules,
Maven,
Gradle,
Composer,
Nuget,
Bundler,
Unknown,
}
impl fmt::Display for PackageManager {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
PackageManager::Npm => write!(f, "npm"),
PackageManager::Pnpm => write!(f, "pnpm"),
PackageManager::Yarn => write!(f, "yarn"),
PackageManager::Bun => write!(f, "bun"),
PackageManager::Pip => write!(f, "pip"),
PackageManager::Poetry => write!(f, "poetry"),
PackageManager::Pipenv => write!(f, "pipenv"),
PackageManager::Cargo => write!(f, "cargo"),
PackageManager::GoModules => write!(f, "go modules"),
PackageManager::Maven => write!(f, "maven"),
PackageManager::Gradle => write!(f, "gradle"),
PackageManager::Composer => write!(f, "composer"),
PackageManager::Nuget => write!(f, "nuget"),
PackageManager::Bundler => write!(f, "bundler"),
PackageManager::Unknown => write!(f, "unknown"),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum Framework {
NextJs,
Nuxt,
NestJs,
Express,
Fastify,
Remix,
SvelteKit,
Astro,
NodeGeneric,
FastApi,
Django,
Flask,
Starlette,
Litestar,
PythonGeneric,
Gin,
Echo,
Fiber,
Chi,
GoGeneric,
ActixWeb,
Axum,
Rocket,
Warp,
RustGeneric,
SpringBoot,
Quarkus,
Micronaut,
JavaGeneric,
Laravel,
Symfony,
PhpGeneric,
AspNetCore,
DotNetGeneric,
Rails,
Sinatra,
RubyGeneric,
Generic,
}
impl fmt::Display for Framework {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let label = match self {
Framework::NextJs => "Next.js",
Framework::Nuxt => "Nuxt",
Framework::NestJs => "NestJS",
Framework::Express => "Express",
Framework::Fastify => "Fastify",
Framework::Remix => "Remix",
Framework::SvelteKit => "SvelteKit",
Framework::Astro => "Astro",
Framework::NodeGeneric => "Node.js (generic)",
Framework::FastApi => "FastAPI",
Framework::Django => "Django",
Framework::Flask => "Flask",
Framework::Starlette => "Starlette",
Framework::Litestar => "Litestar",
Framework::PythonGeneric => "Python (generic)",
Framework::Gin => "Gin",
Framework::Echo => "Echo",
Framework::Fiber => "Fiber",
Framework::Chi => "Chi",
Framework::GoGeneric => "Go (generic)",
Framework::ActixWeb => "Actix Web",
Framework::Axum => "Axum",
Framework::Rocket => "Rocket",
Framework::Warp => "Warp",
Framework::RustGeneric => "Rust (generic)",
Framework::SpringBoot => "Spring Boot",
Framework::Quarkus => "Quarkus",
Framework::Micronaut => "Micronaut",
Framework::JavaGeneric => "Java (generic)",
Framework::Laravel => "Laravel",
Framework::Symfony => "Symfony",
Framework::PhpGeneric => "PHP (generic)",
Framework::AspNetCore => "ASP.NET Core",
Framework::DotNetGeneric => ".NET (generic)",
Framework::Rails => "Rails",
Framework::Sinatra => "Sinatra",
Framework::RubyGeneric => "Ruby (generic)",
Framework::Generic => "Generic",
};
write!(f, "{label}")
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, ValueEnum)]
pub enum BaseImageVariant {
Alpine,
Slim,
Distroless,
Default,
}
impl fmt::Display for BaseImageVariant {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
BaseImageVariant::Alpine => write!(f, "alpine"),
BaseImageVariant::Slim => write!(f, "slim"),
BaseImageVariant::Distroless => write!(f, "distroless"),
BaseImageVariant::Default => write!(f, "default"),
}
}
}
#[derive(
Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, ValueEnum,
)]
pub enum InfraKind {
Postgres,
Mysql,
Redis,
Mongo,
RabbitMq,
Kafka,
Sqlite,
}
impl fmt::Display for InfraKind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
InfraKind::Postgres => write!(f, "PostgreSQL"),
InfraKind::Mysql => write!(f, "MySQL"),
InfraKind::Redis => write!(f, "Redis"),
InfraKind::Mongo => write!(f, "MongoDB"),
InfraKind::RabbitMq => write!(f, "RabbitMQ"),
InfraKind::Kafka => write!(f, "Apache Kafka"),
InfraKind::Sqlite => write!(f, "SQLite"),
}
}
}
#[allow(dead_code)]
impl InfraKind {
pub fn default_port(&self) -> u16 {
match self {
InfraKind::Postgres => 5432,
InfraKind::Mysql => 3306,
InfraKind::Redis => 6379,
InfraKind::Mongo => 27017,
InfraKind::RabbitMq => 5672,
InfraKind::Kafka => 9092,
InfraKind::Sqlite => 0,
}
}
pub fn default_image(&self) -> &'static str {
match self {
InfraKind::Postgres => "postgres:16-alpine",
InfraKind::Mysql => "mysql:8.0",
InfraKind::Redis => "redis:7-alpine",
InfraKind::Mongo => "mongo:7",
InfraKind::RabbitMq => "rabbitmq:3-management-alpine",
InfraKind::Kafka => "confluentinc/cp-kafka:latest",
InfraKind::Sqlite => "alpine:3.20",
}
}
pub fn default_env(&self) -> Vec<(&'static str, &'static str)> {
match self {
InfraKind::Postgres => vec![
("POSTGRES_USER", "app"),
("POSTGRES_PASSWORD", "postgres"),
("POSTGRES_DB", "app"),
],
InfraKind::Mysql => vec![
("MYSQL_ROOT_PASSWORD", "root"),
("MYSQL_DATABASE", "app"),
("MYSQL_USER", "app"),
("MYSQL_PASSWORD", "app"),
],
InfraKind::Redis => vec![],
InfraKind::Mongo => vec![
("MONGO_INITDB_ROOT_USERNAME", "app"),
("MONGO_INITDB_ROOT_PASSWORD", "app"),
],
InfraKind::RabbitMq => vec![
("RABBITMQ_DEFAULT_USER", "guest"),
("RABBITMQ_DEFAULT_PASS", "guest"),
],
InfraKind::Kafka => vec![],
InfraKind::Sqlite => vec![],
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
pub enum InfraSource {
EnvVar(String),
ManifestDependency(String),
ConfigFile(String),
PrismaSchema,
ManualOverride,
}
impl fmt::Display for InfraSource {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
InfraSource::EnvVar(var) => write!(f, "env var `{var}`"),
InfraSource::ManifestDependency(dep) => write!(f, "dependency `{dep}`"),
InfraSource::ConfigFile(path) => write!(f, "config file `{path}`"),
InfraSource::PrismaSchema => write!(f, "Prisma schema"),
InfraSource::ManualOverride => write!(f, "manual override"),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct InfraService {
pub kind: InfraKind,
pub name: String,
pub image: String,
pub port: u16,
pub env_vars: Vec<(String, String)>,
pub is_attached_to_compose: bool,
pub source: InfraSource,
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct InteractiveAnswers {
pub include_infra_in_compose: Vec<InfraKind>,
pub run_prisma_migrations: Option<bool>,
pub create_queue_worker: Option<bool>,
pub create_scheduler: Option<bool>,
pub custom_service_ports: BTreeMap<String, u16>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ServiceType {
Single,
Frontend,
Backend,
Worker,
Api,
MonorepoMember,
}
impl fmt::Display for ServiceType {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
ServiceType::Single => write!(f, "single"),
ServiceType::Frontend => write!(f, "frontend"),
ServiceType::Backend => write!(f, "backend"),
ServiceType::Worker => write!(f, "worker"),
ServiceType::Api => write!(f, "api"),
ServiceType::MonorepoMember => write!(f, "monorepo-member"),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Service {
pub name: String,
pub path: PathBuf,
pub package_name: Option<String>,
pub language: Language,
pub framework: Framework,
pub package_manager: PackageManager,
pub runtime_version: Option<String>,
pub entrypoint: Option<String>,
pub exposed_ports: Vec<u16>,
pub env_vars: Vec<(String, String)>,
pub service_type: ServiceType,
pub build_command: Option<String>,
pub start_command: Option<String>,
pub is_monorepo: bool,
pub dependencies: Vec<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ProjectAnalysis {
pub root_path: PathBuf,
pub is_monorepo: bool,
pub workspace_tool: Option<String>,
pub services: Vec<Service>,
pub detected_infrastructures: Vec<InfraService>,
pub warnings: Vec<String>,
pub root_env_vars: BTreeMap<String, String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct GenerationConfig {
pub base_image_override: Option<BaseImageVariant>,
pub port_overrides: Vec<u16>,
pub force_single: bool,
pub dry_run: bool,
pub emit_compose: bool,
pub output_dir: Option<PathBuf>,
pub interactive: bool,
pub assume_yes: bool,
pub interactive_answers: Option<InteractiveAnswers>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct GeneratedFile {
pub relative_path: PathBuf,
pub content: String,
pub description: String,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn language_display() {
assert_eq!(Language::NodeJs.to_string(), "Node.js");
assert_eq!(Language::DotNet.to_string(), ".NET");
assert_eq!(Language::Unknown("Zig".into()).to_string(), "Unknown(Zig)");
}
#[test]
fn framework_display() {
assert_eq!(Framework::NextJs.to_string(), "Next.js");
assert_eq!(Framework::ActixWeb.to_string(), "Actix Web");
assert_eq!(Framework::AspNetCore.to_string(), "ASP.NET Core");
assert_eq!(Framework::Generic.to_string(), "Generic");
}
#[test]
fn package_manager_display() {
assert_eq!(PackageManager::Npm.to_string(), "npm");
assert_eq!(PackageManager::GoModules.to_string(), "go modules");
assert_eq!(PackageManager::Unknown.to_string(), "unknown");
}
#[test]
fn base_image_variant_display() {
assert_eq!(BaseImageVariant::Alpine.to_string(), "alpine");
assert_eq!(BaseImageVariant::Slim.to_string(), "slim");
assert_eq!(BaseImageVariant::Distroless.to_string(), "distroless");
assert_eq!(BaseImageVariant::Default.to_string(), "default");
}
#[test]
fn service_type_display() {
assert_eq!(ServiceType::Single.to_string(), "single");
assert_eq!(ServiceType::MonorepoMember.to_string(), "monorepo-member");
}
#[test]
fn service_serde_roundtrip() {
let svc = Service {
name: "api".into(),
path: PathBuf::from("/project/services/api"),
package_name: Some("my-api".into()),
language: Language::Rust,
framework: Framework::Axum,
package_manager: PackageManager::Cargo,
runtime_version: Some("1.78.0".into()),
entrypoint: None,
exposed_ports: vec![8080],
env_vars: vec![("RUST_LOG".into(), "info".into())],
service_type: ServiceType::Api,
build_command: None,
start_command: None,
is_monorepo: true,
dependencies: vec!["axum".into(), "tokio".into()],
};
let json = serde_json::to_string(&svc).unwrap();
let deserialized: Service = serde_json::from_str(&json).unwrap();
assert_eq!(svc, deserialized);
}
#[test]
fn project_analysis_serde_roundtrip() {
let analysis = ProjectAnalysis {
root_path: PathBuf::from("/project"),
is_monorepo: true,
workspace_tool: Some("turborepo".into()),
services: vec![],
detected_infrastructures: vec![],
warnings: vec!["No lockfile found".into()],
root_env_vars: BTreeMap::new(),
};
let json = serde_json::to_string(&analysis).unwrap();
let deserialized: ProjectAnalysis = serde_json::from_str(&json).unwrap();
assert_eq!(analysis, deserialized);
}
#[test]
fn generated_file_serde_roundtrip() {
let gf = GeneratedFile {
relative_path: PathBuf::from("services/web/Dockerfile"),
content: "FROM node:20-alpine\n".into(),
description: "Dockerfile for web service".into(),
};
let json = serde_json::to_string(&gf).unwrap();
let deserialized: GeneratedFile = serde_json::from_str(&json).unwrap();
assert_eq!(gf, deserialized);
}
#[test]
fn generation_config_defaults_via_deserialize() {
let cfg = GenerationConfig {
base_image_override: None,
port_overrides: vec![],
force_single: false,
dry_run: false,
emit_compose: false,
output_dir: None,
interactive: false,
assume_yes: false,
interactive_answers: None,
};
let json = serde_json::to_string(&cfg).unwrap();
let deserialized: GenerationConfig = serde_json::from_str(&json).unwrap();
assert_eq!(cfg, deserialized);
}
#[test]
fn infra_kind_display() {
assert_eq!(InfraKind::Postgres.to_string(), "PostgreSQL");
assert_eq!(InfraKind::Mysql.to_string(), "MySQL");
assert_eq!(InfraKind::Redis.to_string(), "Redis");
assert_eq!(InfraKind::Mongo.to_string(), "MongoDB");
assert_eq!(InfraKind::RabbitMq.to_string(), "RabbitMQ");
assert_eq!(InfraKind::Kafka.to_string(), "Apache Kafka");
assert_eq!(InfraKind::Sqlite.to_string(), "SQLite");
}
#[test]
fn infra_kind_default_port() {
assert_eq!(InfraKind::Postgres.default_port(), 5432);
assert_eq!(InfraKind::Mysql.default_port(), 3306);
assert_eq!(InfraKind::Redis.default_port(), 6379);
assert_eq!(InfraKind::Mongo.default_port(), 27017);
assert_eq!(InfraKind::RabbitMq.default_port(), 5672);
assert_eq!(InfraKind::Kafka.default_port(), 9092);
assert_eq!(InfraKind::Sqlite.default_port(), 0);
}
#[test]
fn infra_kind_default_image() {
assert_eq!(InfraKind::Postgres.default_image(), "postgres:16-alpine");
assert_eq!(InfraKind::Mysql.default_image(), "mysql:8.0");
assert_eq!(InfraKind::Redis.default_image(), "redis:7-alpine");
assert_eq!(InfraKind::Mongo.default_image(), "mongo:7");
assert_eq!(
InfraKind::RabbitMq.default_image(),
"rabbitmq:3-management-alpine"
);
assert_eq!(
InfraKind::Kafka.default_image(),
"confluentinc/cp-kafka:latest"
);
assert_eq!(InfraKind::Sqlite.default_image(), "alpine:3.20");
}
#[test]
fn infra_kind_default_env() {
let pg_env = InfraKind::Postgres.default_env();
assert!(pg_env.iter().any(|(k, _)| *k == "POSTGRES_USER"));
assert!(pg_env
.iter()
.any(|(k, v)| *k == "POSTGRES_DB" && *v == "app"));
let mysql_env = InfraKind::Mysql.default_env();
assert!(mysql_env.iter().any(|(k, _)| *k == "MYSQL_ROOT_PASSWORD"));
assert!(InfraKind::Redis.default_env().is_empty());
assert!(InfraKind::Kafka.default_env().is_empty());
}
#[test]
fn infra_kind_ordering() {
let mut kinds = vec![InfraKind::Redis, InfraKind::Postgres, InfraKind::Mysql];
kinds.sort();
assert_eq!(
kinds,
vec![InfraKind::Postgres, InfraKind::Mysql, InfraKind::Redis]
);
}
#[test]
fn infra_source_display() {
assert_eq!(
InfraSource::EnvVar("DATABASE_URL".into()).to_string(),
"env var `DATABASE_URL`"
);
assert_eq!(
InfraSource::ManifestDependency("pg".into()).to_string(),
"dependency `pg`"
);
assert_eq!(
InfraSource::ConfigFile("prisma/schema.prisma".into()).to_string(),
"config file `prisma/schema.prisma`"
);
assert_eq!(InfraSource::PrismaSchema.to_string(), "Prisma schema");
assert_eq!(InfraSource::ManualOverride.to_string(), "manual override");
}
#[test]
fn infra_source_ordering() {
let mut sources = vec![
InfraSource::ManualOverride,
InfraSource::EnvVar("A".into()),
InfraSource::PrismaSchema,
];
sources.sort();
assert_eq!(
sources,
vec![
InfraSource::EnvVar("A".into()),
InfraSource::PrismaSchema,
InfraSource::ManualOverride,
]
);
}
#[test]
fn infra_service_serde_roundtrip() {
let svc = InfraService {
kind: InfraKind::Postgres,
name: "postgres".into(),
image: "postgres:16-alpine".into(),
port: 5432,
env_vars: vec![
("POSTGRES_DB".into(), "app".into()),
("POSTGRES_PASSWORD".into(), "postgres".into()),
],
is_attached_to_compose: true,
source: InfraSource::EnvVar("DATABASE_URL".into()),
};
let json = serde_json::to_string(&svc).unwrap();
let deserialized: InfraService = serde_json::from_str(&json).unwrap();
assert_eq!(svc, deserialized);
}
#[test]
fn interactive_answers_default() {
let answers = InteractiveAnswers::default();
assert!(answers.include_infra_in_compose.is_empty());
assert!(answers.run_prisma_migrations.is_none());
assert!(answers.create_queue_worker.is_none());
assert!(answers.create_scheduler.is_none());
assert!(answers.custom_service_ports.is_empty());
}
#[test]
fn interactive_answers_serde_roundtrip() {
let answers = InteractiveAnswers {
include_infra_in_compose: vec![InfraKind::Postgres, InfraKind::Redis],
run_prisma_migrations: Some(true),
create_queue_worker: Some(false),
create_scheduler: Some(true),
custom_service_ports: BTreeMap::from([
("postgres".into(), 5433),
("redis".into(), 6380),
]),
};
let json = serde_json::to_string(&answers).unwrap();
let deserialized: InteractiveAnswers = serde_json::from_str(&json).unwrap();
assert_eq!(answers, deserialized);
}
}