netter 0.3.1

Netter is a CLI tool for fast and easy server startup!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use std::io::Write;
use diesel::prelude::*;
use diesel::pg::PgConnection;
use serde::Deserialize;


#[derive(Debug)]
pub enum Commands {
    Kind(String),
    Host(String),
    Port(u16),
    Routes(RouteConfig),
    RoutesDefinitionLanguagePath(String),
    Timeout(i64),
    TimeoutConnect(i64),
    Logging(Logger),
    Ssl(SslConfigure),
    Pool(PoolConfigure),
    Enviroment(EnviromentConfigure),
    Cache(CacheConfigure),
    Monitoring(MonitoringConfigure),
}

#[derive(Debug, Deserialize)]
pub struct Response {
    pub status: u16,
    pub body: String,
    pub headers: Vec<(String, String)>,
    connect: Option<Database>,
    disconnect: Option<Database>,
}

#[derive(Debug, Deserialize)]
pub struct MonitoringConfigure {
    pub enable: bool,
    pub endpoint: String,
}

#[derive(Debug, Deserialize)]
pub struct CacheConfigure {
    pub enable: bool,
    pub kind: String,
    pub ttl: i64,
    pub host: String,
    pub port: i64,
}

#[derive(Debug, Deserialize)]
pub struct EnviromentConfigure {
    pub database_url: String,
    pub api_key: String,
}

#[derive(Debug, Deserialize)]
pub struct PoolConfigure {
    pub max_connection: i64,
    pub min_connection: i64,
}

#[derive(Debug, Deserialize)]
pub struct SslConfigure {
    pub enable: bool,
    pub cert_path: String,
    pub key_path: String,
}

#[derive(Debug, Deserialize)]
pub struct Logger {
    pub level: String,
    pub file: String,
}

#[derive(Debug, Deserialize)]
pub struct RouteConfig {
    pub path: String,
    pub method: String,
    pub response: Response,
}

#[derive(Debug, Deserialize)]
struct Database {
    uri: String,
    user_name: String,
    password: String,
}

pub trait DatabaseTrait {
    type Error;
    fn init(uri: String, user_name: String, password: String) -> Self;
    fn set_connection(&self) -> Result<PgConnection, Self::Error>;
    //fn get_all(connection: &PgConnection) -> Vec<models::User>;
}


impl DatabaseTrait for Database {
    type Error = Box<dyn std::error::Error>;

    fn init(uri: String, user_name: String, password: String) -> Self {
        let mut enviroment = match std::fs::File::create(".env") {
            Ok(file) => file,
            Err(e) => {
                eprintln!("Error creating .env file: {}", e);
                panic!("Failed to create .env file");
            },
        };

        enviroment.write(format!("DATABASE_URL={}", uri.clone()).as_bytes())
            .map_err(|e| {
                eprintln!("Error writing to .env file: {}", e);
                panic!("Failed to write to .env file");
            }).unwrap();

        Self {
            uri,
            user_name,
            password,
        }
    }

    fn set_connection(&self) -> Result<PgConnection, Self::Error> {
        dotenvy::dotenv().ok();

        let url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");

        let connect = PgConnection::establish(&url)?;
        
        Ok(connect)
    }
}