Refactor everything to a more modular structure

Moving all pieces into a more sensible module structure

Author: weiznich

rust-toolchain

@@ -1 +1 @@
-nightly-2019-03-06
+nightly-2019-05-31

wundergraph/src/context.rs

@@ -0,0 +1,18 @@
+use diesel::{r2d2, Connection};
+
+pub trait WundergraphContext {
+    type Connection: Connection + 'static;
+    fn get_connection(&self) -> &Self::Connection;
+}
+
+impl<Conn> WundergraphContext for r2d2::PooledConnection<r2d2::ConnectionManager<Conn>>
+where
+    Conn: Connection + 'static,
+    Self: Connection<Backend = Conn::Backend>,
+{
+    type Connection = Self;
+
+    fn get_connection(&self) -> &Self {
+        self
+    }
+}

wundergraph/src/diesel_ext.rs

@@ -1,7 +1,9 @@
+
 use diesel::backend::Backend;
-use diesel::expression::NonAggregate;
-use diesel::query_builder::QueryFragment;
-use diesel::{AppearsOnTable, Expression};
+use diesel::expression::{AppearsOnTable, Expression, NonAggregate, SelectableExpression};
+use diesel::query_builder::{AstPass, QueryFragment, QueryId};
+use diesel::result::QueryResult;
+use diesel::sql_types::IntoNullable;
 
 pub trait BoxableFilter<QS, DB>
 where
@@ -22,3 +24,45 @@ where
     T: QueryFragment<DB>,
 {
 }
+
+#[derive(Debug)]
+pub enum MaybeNull<T> {
+    Expr(T),
+    Null,
+}
+
+impl<T> Expression for MaybeNull<T>
+where
+    T: Expression,
+    T::SqlType: IntoNullable,
+{
+    type SqlType = <T::SqlType as IntoNullable>::Nullable;
+}
+
+impl<T, DB> QueryFragment<DB> for MaybeNull<T>
+where
+    DB: Backend,
+    T: QueryFragment<DB>,
+{
+    fn walk_ast(&self, mut pass: AstPass<'_, DB>) -> QueryResult<()> {
+        match self {
+            MaybeNull::Expr(e) => e.walk_ast(pass)?,
+            MaybeNull::Null => pass.push_sql(" NULL "),
+        }
+        Ok(())
+    }
+}
+
+impl<ST> QueryId for MaybeNull<ST>
+where
+    ST: QueryId,
+{
+    type QueryId = ();
+    const HAS_STATIC_QUERY_ID: bool = false;
+}
+
+impl<T> NonAggregate for MaybeNull<T> {}
+
+impl<T, QS> AppearsOnTable<QS> for MaybeNull<T> where Self: Expression {}
+
+impl<T, ST> SelectableExpression<T> for MaybeNull<ST> where Self: Expression {}

wundergraph/src/graphql_type.rs

@@ -1,18 +1,15 @@
-use crate::query_helper::placeholder::FieldListExtractor;
+use crate::query_builder::selection::offset::ApplyOffset;
+use crate::query_builder::selection::LoadingHandler;
 use crate::scalar::WundergraphScalarValue;
-use crate::{LoadingHandler, ApplyOffset};
 use diesel::backend::Backend;
 use diesel::query_builder::QueryFragment;
 use diesel::QuerySource;
-use juniper::{meta, FromInputValue, GraphQLType, Registry};
+use juniper::{meta, GraphQLType, Registry};
 use std::marker::PhantomData;
 
 #[derive(Debug)]
 pub struct GraphqlWrapper<T, DB, Ctx>(T, PhantomData<(DB, Ctx)>);
 
-#[derive(Debug)]
-pub struct GraphqlOrderWrapper<T, DB, Ctx>(PhantomData<(T, DB, Ctx)>);
-
 impl<T, DB, Ctx> GraphQLType<WundergraphScalarValue> for GraphqlWrapper<T, DB, Ctx>
 where
     DB: Backend + ApplyOffset + 'static,
@@ -43,68 +40,6 @@ where
     }
 }
 
-#[derive(Debug)]
-pub struct OrderTypeInfo<L, DB, Ctx>(String, PhantomData<(L, DB, Ctx)>);
-
-impl<L, DB, Ctx> Default for OrderTypeInfo<L, DB, Ctx>
-where
-    DB: Backend + ApplyOffset + 'static,
-    L::Table: 'static,
-    <L::Table as QuerySource>::FromClause: QueryFragment<DB>,
-    L: LoadingHandler<DB, Ctx>,
-    DB::QueryBuilder: Default,
-{
-    fn default() -> Self {
-        Self(format!("{}Columns", L::TYPE_NAME), PhantomData)
-    }
-}
-
-impl<T, DB, Ctx> GraphQLType<WundergraphScalarValue> for GraphqlOrderWrapper<T, DB, Ctx>
-where
-    DB: Backend + ApplyOffset + 'static,
-    T::Table: 'static,
-    <T::Table as QuerySource>::FromClause: QueryFragment<DB>,
-    T: LoadingHandler<DB, Ctx>,
-    T::FieldList: FieldListExtractor,
-    <T::FieldList as FieldListExtractor>::Out: WundergraphGraphqlHelper<T, DB, Ctx>,
-    DB::QueryBuilder: Default,
-{
-    type Context = ();
-    type TypeInfo = OrderTypeInfo<T, DB, Ctx>;
-
-    fn name(info: &Self::TypeInfo) -> Option<&str> {
-        Some(&info.0)
-    }
-
-    fn meta<'r>(
-        info: &Self::TypeInfo,
-        registry: &mut Registry<'r, WundergraphScalarValue>,
-    ) -> meta::MetaType<'r, WundergraphScalarValue>
-    where
-        WundergraphScalarValue: 'r,
-    {
-        use crate::query_helper::placeholder::WundergraphFieldList;
-
-        <<T::FieldList as FieldListExtractor>::Out as WundergraphGraphqlHelper<T, DB, Ctx>>::order_meta::<
-            Self,
-            _,
-        >(
-            info,
-            |index| {
-                T::FieldList::map_table_field(index, |index| T::FIELD_NAMES[index])
-                    .expect("Field is there")
-            },
-            registry,
-        )
-    }
-}
-
-impl<T, DB, Ctx> FromInputValue<WundergraphScalarValue> for GraphqlOrderWrapper<T, DB, Ctx> {
-    fn from_input_value(_: &juniper::InputValue<WundergraphScalarValue>) -> Option<Self> {
-        Some(Self(PhantomData))
-    }
-}
-
 pub trait WundergraphGraphqlMapper<DB, Ctx> {
     type GraphQLType: GraphQLType<WundergraphScalarValue, TypeInfo = ()>;
 
@@ -130,15 +65,6 @@ pub trait WundergraphGraphqlHelper<L, DB, Ctx> {
     ) -> meta::MetaType<'r, WundergraphScalarValue>
     where
         T: GraphQLType<WundergraphScalarValue, TypeInfo = ()>;
-
-    fn order_meta<'r, T, F>(
-        info: &T::TypeInfo,
-        name: F,
-        registry: &mut Registry<'r, WundergraphScalarValue>,
-    ) -> meta::MetaType<'r, WundergraphScalarValue>
-    where
-        T: GraphQLType<WundergraphScalarValue> + FromInputValue<WundergraphScalarValue>,
-        F: Fn(usize) -> &'static str;
 }
 
 macro_rules! wundergraph_graphql_helper_impl {
@@ -184,28 +110,6 @@ macro_rules! wundergraph_graphql_helper_impl {
                     }
                     meta::MetaType::Object(ty)
                 }
-
-                fn order_meta<'r, Type, Fun>(
-                    info: &Type::TypeInfo,
-                    names: Fun,
-                    registry: &mut Registry<'r, WundergraphScalarValue>,
-                ) -> meta::MetaType<'r, WundergraphScalarValue>
-                where
-                Type: GraphQLType<WundergraphScalarValue> + FromInputValue<WundergraphScalarValue>,
-                Fun: Fn(usize) -> &'static str,
-                {
-                    use juniper::meta::EnumValue;
-                    let values = [
-                        $(
-                            EnumValue::new(names($idx)),
-                        )*
-                    ];
-                    let e = registry.build_enum_type::<Type>(
-                        info,
-                        &values,
-                    );
-                    meta::MetaType::Enum(e)
-                }
             }
         )*
     };

wundergraph/src/helper/mod.rs

@@ -1,11 +1,2 @@
-//! Some helper functionality used to implement wundergraph
-//!
-//! Functionality from this module is only useful if you want to extend
-//! wundergraph to support additional types
-mod from_lookahead;
-mod nameable;
-#[doc(hidden)]
 pub mod primary_keys;
-
-pub use self::from_lookahead::FromLookAheadValue;
-pub use self::nameable::{NameBuilder, Nameable};
+pub mod tuple;

wundergraph/src/helper/primary_keys.rs

@@ -1,4 +1,4 @@
-use super::FromLookAheadValue;
+use crate::juniper_ext::FromLookAheadValue;
 use crate::scalar::WundergraphScalarValue;
 use diesel::associations::HasTable;
 use diesel::query_builder::nodes::Identifier;