easy-rest-api 0.1.0

A simple library for creating a HTTP API with minimal setup.
Documentation 
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use std::collections::HashMap;
use std::path::Path;
use std::fs;

use super::table_schema::SqlTableSchema;
use super::response::{Sqlite3ResponseBuilder, ResponseBuilder};
use super::query::{Sqlite3Query, Query};

use sqlite3::{open, Connection};
use hyper::{Body, Request, Response};

#[derive(Clone, Debug)]
pub enum SQLType {
    Null,
    Integer,
    Real,
    Text,
}


type Config = HashMap<String, String>;

#[async_trait::async_trait]
pub trait DatabaseInterface {
    // ( connection, existing? (or created) )
    fn connect(config: &Config) -> (Self, bool)
        where Self: Sized;
    fn delete_db(config: &Config)
        where Self: Sized;

    fn create_tables_from_schemas(&self, schemas: Vec<&SqlTableSchema>) {
        for schema in schemas {
            self.table_from_types(schema.name.clone(), &schema.fields)
        }
    }

    fn table_from_types(&self, table_name: String, types: &HashMap<String, SQLType>);
    async fn process_api_request(&self, request: &mut Request<Body>, table: &SqlTableSchema) -> Response<Body>;
}

pub struct SQLite3Interface {
    connection: Connection,
}

#[async_trait::async_trait]
impl DatabaseInterface for SQLite3Interface {
    fn connect(config: &Config) -> (Self, bool) {
        let db_path = config.get("database_path").expect("Can't find 'database_path' config");

        let existing = Path::new(db_path).exists();

        let connection = open(db_path).expect(&format!("Can't open sqlite3 database at: {}", db_path));
        
        log::info!("Connected to database at {}", db_path);
        (
            Self {
                connection
            }
            , existing
        )
    }

    fn table_from_types(&self, table_name: String, types: &HashMap<String, SQLType>) {
        let mut sql = format!("CREATE TABLE IF NOT EXISTS {} (ID INTEGER PRIMARY KEY,", table_name);

        for (col_name, data_type) in types {
            sql.push_str(&col_name);
            let dtype = match data_type {
                SQLType::Null => " NULL",
                SQLType::Integer => " INTEGER",
                SQLType::Real => " REAL",
                SQLType::Text => " TEXT",
            };
            sql.push_str(dtype);
            sql.push_str(", ")
        }
        // remove last ", "
        sql.remove(sql.len()-1);
        sql.remove(sql.len()-1);
        sql.push_str(");");

        log::info!("Creating table with SQL: {}", sql);

        self.connection.execute(sql).expect("Can't create table");
    }
    
    fn delete_db(config: &Config) {
        let db_path = config.get("database_path").expect("Can't find 'database_path' config");
        let result = fs::remove_file(db_path);

        match result {
            Ok(_) => log::info!("Deleted sqlite3 database"),
            Err(e) => log::error!("Error when deleting sqlite3 database: {}", e)
        }
    }

    async fn process_api_request(&self, request: &mut Request<Body>, table: &SqlTableSchema) -> Response<Body> {
        // GENERATE QUERY
        let query = Sqlite3Query::from_request(request, table).await;

        if query.is_err() {
            let error = query.err().unwrap();

            if error.1 {
                log::warn!("{}", error.0);
                return Response::builder()
                    .status(500)
                    .body(Body::from("Server Error Encountered"))
                    .unwrap();
            } else {
                log::debug!("{}", error.0);
                return Response::builder()
                    .status(400)
                    .body(Body::from("Client Error"))
                    .unwrap();
            }
        }

        // EXECUTE QUERY
        let query = query.unwrap();
        let cursor = query.execute_sql(&self.connection);

        if cursor.is_err() {
            let error = cursor.err().unwrap();
            log::warn!("{}", error);
            
            return Response::builder()
                    .status(500)
                    .body(Body::from("Server Error Encountered"))
                    .unwrap();
        }

        // CREATE RESPONSE FROM DATA
        let mut all_data = Vec::new();
        let mut c = cursor.unwrap();
        while let Ok(Some(d)) = c.next() {
            all_data.push(d.to_vec())
        }

        let response_json_text = Sqlite3ResponseBuilder::from_row_data(all_data);
        Response::new(Body::from(response_json_text))
    }
}

// may be negative side effects
// must be implemented for 'object safety' over threads
unsafe impl Send for SQLite3Interface {}
unsafe impl Sync for SQLite3Interface {}