Remove fields with a default value from insertstructs

All fields with default values are now skipped in insert
structs. Unfortunately `infer_schema_internals` does not know anything
about default values, so we inlined the code and added support for
default values. This should be a temporary thing till someone unifies
the infer schema code of wundergraph and diesel again

Author: weiznich

wundergraph_cli/Cargo.toml

@@ -6,12 +6,11 @@ version = "0.1.0"
 [dependencies]
 structopt = "0.2"
 clap = "2.27"
-infer_schema_internals = "1.2"
 diesel = "1.2"
 clippy = { version = "0.0.207", optional = true }
 
 [features]
 default = ["postgres", "sqlite"]
 lint = ["clippy"]
-sqlite = ["infer_schema_internals/sqlite"]
-postgres = ["infer_schema_internals/postgres"]
+sqlite = ["diesel/sqlite"]
+postgres = ["diesel/postgres"]

wundergraph_cli/src/database.rs

@@ -0,0 +1,124 @@
+use diesel::*;
+
+use std::error::Error;
+
+enum Backend {
+    #[cfg(feature = "postgres")]
+    Pg,
+    #[cfg(feature = "sqlite")]
+    Sqlite,
+    #[cfg(feature = "mysql")]
+    Mysql,
+}
+
+impl Backend {
+    fn for_url(database_url: &str) -> Self {
+        match database_url {
+            #[cfg(feature = "postgres")]
+            _ if database_url.starts_with("postgres://")
+                || database_url.starts_with("postgresql://") =>
+            {
+                Backend::Pg
+            }
+            #[cfg(feature = "mysql")]
+            _ if database_url.starts_with("mysql://") =>
+            {
+                Backend::Mysql
+            }
+            #[cfg(feature = "sqlite")]
+            _ => Backend::Sqlite,
+            #[cfg(not(feature = "sqlite"))]
+            _ => {
+                let mut available_schemes: Vec<&str> = Vec::new();
+
+                // One of these will always be true, or you are compiling
+                // diesel_cli without a backend. And why would you ever want to
+                // do that?
+                if cfg!(feature = "postgres") {
+                    available_schemes.push("`postgres://`");
+                }
+                if cfg!(feature = "mysql") {
+                    available_schemes.push("`mysql://`");
+                }
+
+                panic!(
+                    "`{}` is not a valid database URL. It should start with {}",
+                    database_url,
+                    available_schemes.join(" or ")
+                );
+            }
+            #[cfg(not(any(feature = "mysql", feature = "sqlite", feature = "postgres")))]
+            _ => compile_error!(
+                "At least one backend must be specified for use with this crate. \
+                 You may omit the unneeded dependencies in the following command. \n\n \
+                 ex. `cargo install diesel_cli --no-default-features --features mysql postgres sqlite` \n"
+            ),
+        }
+    }
+}
+
+pub enum InferConnection {
+    #[cfg(feature = "postgres")]
+    Pg(PgConnection),
+    #[cfg(feature = "sqlite")]
+    Sqlite(SqliteConnection),
+    #[cfg(feature = "mysql")]
+    Mysql(MysqlConnection),
+}
+
+impl InferConnection {
+    pub fn establish(database_url: &str) -> Result<Self, Box<Error>> {
+        match Backend::for_url(database_url) {
+            #[cfg(feature = "postgres")]
+            Backend::Pg => PgConnection::establish(database_url).map(InferConnection::Pg),
+            #[cfg(feature = "sqlite")]
+            Backend::Sqlite => {
+                SqliteConnection::establish(database_url).map(InferConnection::Sqlite)
+            }
+            #[cfg(feature = "mysql")]
+            Backend::Mysql => MysqlConnection::establish(database_url).map(InferConnection::Mysql),
+        }.map_err(Into::into)
+    }
+}
+
+#[cfg(all(test, any(feature = "postgres", feature = "mysql")))]
+mod tests {
+    use super::change_database_of_url;
+
+    #[test]
+    fn split_pg_connection_string_returns_postgres_url_and_database() {
+        let database = "database".to_owned();
+        let base_url = "postgresql://localhost:5432".to_owned();
+        let database_url = format!("{}/{}", base_url, database);
+        let postgres_url = format!("{}/{}", base_url, "postgres");
+        assert_eq!(
+            (database, postgres_url),
+            change_database_of_url(&database_url, "postgres")
+        );
+    }
+
+    #[test]
+    fn split_pg_connection_string_handles_user_and_password() {
+        let database = "database".to_owned();
+        let base_url = "postgresql://user:password@localhost:5432".to_owned();
+        let database_url = format!("{}/{}", base_url, database);
+        let postgres_url = format!("{}/{}", base_url, "postgres");
+        assert_eq!(
+            (database, postgres_url),
+            change_database_of_url(&database_url, "postgres")
+        );
+    }
+
+    #[test]
+    fn split_pg_connection_string_handles_query_string() {
+        let database = "database".to_owned();
+        let query = "?sslmode=true".to_owned();
+        let base_url = "postgresql://user:password@localhost:5432".to_owned();
+        let database_url = format!("{}/{}{}", base_url, database, query);
+        let postgres_url = format!("{}/{}{}", base_url, "postgres", query);
+        assert_eq!(
+            (database, postgres_url),
+            change_database_of_url(&database_url, "postgres")
+        );
+    }
+}

wundergraph_cli/src/infer_schema_internals/data_structures.rs

@@ -0,0 +1,120 @@
+#[cfg(any(feature = "postgres", feature = "mysql"))]
+use diesel::backend::Backend;
+use diesel::deserialize::FromSqlRow;
+#[cfg(feature = "sqlite")]
+use diesel::sqlite::Sqlite;
+use diesel::*;
+
+#[cfg(any(feature = "postgres", feature = "mysql"))]
+use super::information_schema::UsesInformationSchema;
+use super::table_data::TableName;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ColumnInformation {
+    pub column_name: String,
+    pub type_name: String,
+    pub nullable: bool,
+    pub has_default: bool,
+}
+
+#[derive(Debug)]
+pub struct ColumnType {
+    pub rust_name: String,
+    pub is_array: bool,
+    pub is_nullable: bool,
+    pub is_unsigned: bool,
+}
+
+use std::fmt;
+
+impl fmt::Display for ColumnType {
+    fn fmt(&self, out: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        if self.is_nullable {
+            write!(out, "Nullable<")?;
+        }
+        if self.is_array {
+            write!(out, "Array<")?;
+        }
+        if self.is_unsigned {
+            write!(out, "Unsigned<")?;
+        }
+        write!(out, "{}", self.rust_name)?;
+        if self.is_unsigned {
+            write!(out, ">")?;
+        }
+        if self.is_array {
+            write!(out, ">")?;
+        }
+        if self.is_nullable {
+            write!(out, ">")?;
+        }
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+pub struct ColumnDefinition {
+    pub sql_name: String,
+    pub ty: ColumnType,
+    pub docs: String,
+    pub rust_name: Option<String>,
+    pub has_default: bool,
+}
+
+impl ColumnInformation {
+    pub fn new<T, U>(column_name: T, type_name: U, nullable: bool, has_default: bool) -> Self
+    where
+        T: Into<String>,
+        U: Into<String>,
+    {
+        ColumnInformation {
+            column_name: column_name.into(),
+            type_name: type_name.into(),
+            nullable,
+            has_default,
+        }
+    }
+}
+
+#[cfg(any(feature = "postgres", feature = "mysql"))]
+impl<ST, DB> Queryable<ST, DB> for ColumnInformation
+where
+    DB: Backend + UsesInformationSchema,
+    (String, String, String, Option<String>): FromSqlRow<ST, DB>,
+{
+    type Row = (String, String, String, Option<String>);
+
+    fn build(row: Self::Row) -> Self {
+        ColumnInformation::new(row.0, row.1, row.2 == "YES", row.3.is_some())
+    }
+}
+
+#[cfg(feature = "sqlite")]
+impl<ST> Queryable<ST, Sqlite> for ColumnInformation
+where
+    (i32, String, String, bool, Option<String>, bool): FromSqlRow<ST, Sqlite>,
+{
+    type Row = (i32, String, String, bool, Option<String>, bool);
+
+    fn build(row: Self::Row) -> Self {
+        ColumnInformation::new(row.1, row.2, !row.3, row.4.is_some())
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct ForeignKeyConstraint {
+    pub child_table: TableName,
+    pub parent_table: TableName,
+    pub foreign_key: String,
+    pub primary_key: String,
+}
+
+impl ForeignKeyConstraint {
+    pub fn ordered_tables(&self) -> (&TableName, &TableName) {
+        use std::cmp::{max, min};
+        (
+            min(&self.parent_table, &self.child_table),
+            max(&self.parent_table, &self.child_table),
+        )
+    }
+}

wundergraph_cli/src/infer_schema_internals/foreign_keys.rs

@@ -0,0 +1,43 @@
+#![cfg_attr(feature = "cargo-clippy", allow(expect_fun_call))] // My calls are so fun
+
+use super::data_structures::ForeignKeyConstraint;
+use super::inference::get_primary_keys;
+use super::table_data::TableName;
+use database::InferConnection;
+
+pub fn remove_unsafe_foreign_keys_for_codegen(
+    database_url: &str,
+    foreign_keys: &[ForeignKeyConstraint],
+    safe_tables: &[TableName],
+) -> Vec<ForeignKeyConstraint> {
+    let conn = InferConnection::establish(database_url)
+        .expect(&format!("Could not connect to `{}`", database_url));
+
+    let duplicates = foreign_keys
+        .iter()
+        .map(|fk| fk.ordered_tables())
+        .filter(|tables| {
+            let dup_count = foreign_keys
+                .iter()
+                .filter(|fk| tables == &fk.ordered_tables())
+                .count();
+            dup_count > 1
+        })
+        .collect::<Vec<_>>();
+
+    foreign_keys
+        .iter()
+        .filter(|fk| fk.parent_table != fk.child_table)
+        .filter(|fk| safe_tables.contains(&fk.parent_table))
+        .filter(|fk| safe_tables.contains(&fk.child_table))
+        .filter(|fk| {
+            let pk_columns = get_primary_keys(&conn, &fk.parent_table).expect(&format!(
+                "Error loading primary keys for `{}`",
+                fk.parent_table
+            ));
+            pk_columns.len() == 1 && pk_columns[0] == fk.primary_key
+        })
+        .filter(|fk| !duplicates.contains(&fk.ordered_tables()))
+        .cloned()
+        .collect()
+}