Add implementation of posts_at_version

weiznich · weiznich · commit 6b3e75354363 · 2019-11-16T18:33:11.000+01:00
diff --git a/migrations/2019-11-15-114257_posts_at_version/down.sql b/migrations/2019-11-15-114257_posts_at_version/down.sql
@@ -0,0 +1,9 @@
+-- This file should undo anything in `up.sql`
+
+ALTER TABLE posts DROP CONSTRAINT posts_pkey;
+ALTER TABLE posts ADD PRIMARY KEY (id);
+ALTER TABLE comments ADD FOREIGN KEY (post) REFERENCES posts(id) ON UPDATE CASCADE ON DELETE CASCADE;
+ALTER TABLE posts DROP COLUMN version_start;
+ALTER TABLE posts DROP COLUMN version_end;
+
+DROP FUNCTION posts_at_version;
diff --git a/migrations/2019-11-15-114257_posts_at_version/up.sql b/migrations/2019-11-15-114257_posts_at_version/up.sql
@@ -0,0 +1,20 @@
+-- Your SQL goes here
+
+ALTER TABLE posts ADD COLUMN version_start INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE posts ADD COLUMN version_end INTEGER DEFAULT NULL;
+ALTER TABLE comments DROP CONSTRAINT comments_post_fkey;
+ALTER TABLE posts DROP CONSTRAINT posts_pkey;
+ALTER TABLE posts ADD PRIMARY KEY (id, version_start);
+
+CREATE OR REPLACE FUNCTION posts_at_version (version int DEFAULT NULL)
+RETURNS TABLE(id Integer, title Text, content Text, published_at Timestamp with time zone, author Integer, post_state post_state) AS $$
+DECLARE
+result record;
+BEGIN
+IF version IS NULL THEN
+	RETURN QUERY SELECT posts.id, posts.title, posts.content, posts.published_at, posts.author, posts.post_state FROM posts WHERE projects.version_end IS NULL;
+ELSE
+	RETURN QUERY SELECT posts.id, posts.title, posts.content, posts.published_at, posts.author, posts.post_state FROM posts WHERE int4range(version_start, version_end, '[)') @> version;
+END IF;
+END;
+$$ LANGUAGE plpgsql;
diff --git a/src/graphql/mod.rs b/src/graphql/mod.rs
@@ -7,11 +7,15 @@ use diesel::pg::Pg;
 use diesel::prelude::*;
 use juniper::{ExecutionResult, Executor, GraphQLInputObject, Selection, Value};
 use wundergraph::prelude::*;
-use wundergraph::query_builder::mutations::{HandleBatchInsert, HandleInsert};
+use wundergraph::query_builder::mutations::{HandleBatchInsert, HandleInsert, HandleUpdate};
 use wundergraph::query_builder::selection::LoadingHandler;
 use wundergraph::scalar::WundergraphScalarValue;
 
-#[derive(WundergraphEntity, Identifiable, Debug)]
+mod post_at_version;
+
+use self::post_at_version::*;
+
+#[derive(WundergraphEntity, Identifiable, Debug, Clone)]
 #[table_name = "users"]
 pub struct User {
     id: i32,
@@ -21,7 +25,7 @@ pub struct User {
     comments: HasMany<Comment, comments::author>,
 }
 
-#[derive(WundergraphEntity, Identifiable, Debug)]
+#[derive(WundergraphEntity, Identifiable, Debug, Clone)]
 #[table_name = "posts"]
 pub struct Post {
     id: i32,
@@ -33,21 +37,24 @@ pub struct Post {
     post_state: PostState,
 }
 
-#[derive(WundergraphEntity, Identifiable, Debug)]
+#[derive(WundergraphEntity, Identifiable, Debug, Clone)]
 #[table_name = "comments"]
 pub struct Comment {
     id: i32,
     comment: String,
     published_at: DateTime<Utc>,
     author: HasOne<i32, User>,
     post: HasOne<i32, Post>,
+    #[column_name = "post"]
+    posts_at_version: HasOne<i32, PostAtVersion>,
 }
 
 wundergraph::query_object! {
     Query {
         User,
         Post,
         Comment,
+        PostAtVersion(version: Option<i32>),
     }
 }
 
@@ -58,7 +65,7 @@ pub struct UserChangeset {
     name: String,
 }
 
-#[derive(GraphQLInputObject, Identifiable, AsChangeset)]
+#[derive(GraphQLInputObject, Identifiable)]
 #[table_name = "posts"]
 pub struct PostChangeset {
     id: i32,
@@ -100,6 +107,8 @@ impl HandleInsert<Post, NewPost, Pg, PgConnection> for posts::table {
                     posts::content.eq(insertable.content),
                     posts::author.eq(insertable.author),
                     posts::post_state.eq(PostState::Draft),
+                    posts::version_start.eq(0),
+                    posts::version_end.eq(Option::<i32>::None),
                 ))
                 .returning(posts::id)
                 .get_result::<i32>(conn)?;
@@ -133,6 +142,8 @@ impl HandleBatchInsert<Post, NewPost, Pg, PgConnection> for posts::table {
                         posts::content.eq(content),
                         posts::author.eq(author),
                         posts::post_state.eq(PostState::Draft),
+                        posts::version_start.eq(0),
+                        posts::version_end.eq(Option::<i32>::None),
                     )
                 },
             )
@@ -152,6 +163,54 @@ impl HandleBatchInsert<Post, NewPost, Pg, PgConnection> for posts::table {
     }
 }
 
+impl HandleUpdate<Post, PostChangeset, Pg, PgConnection> for posts::table {
+    fn handle_update(
+        selection: Option<&'_ [Selection<'_, WundergraphScalarValue>]>,
+        executor: &Executor<PgConnection, WundergraphScalarValue>,
+        update: &PostChangeset,
+    ) -> ExecutionResult<WundergraphScalarValue> {
+        let ctx = executor.context();
+        let conn = ctx.get_connection();
+        conn.transaction(|| {
+            let current_version = posts::table
+                .select(diesel::dsl::max(posts::version_start))
+                .filter(posts::id.eq(update.id))
+                .get_result::<Option<i32>>(conn)?
+                .unwrap_or(0);
+
+            diesel::update(
+                posts::table.filter(
+                    posts::id
+                        .eq(update.id)
+                        .and(posts::version_start.eq(current_version)),
+                ),
+            )
+            .set(posts::version_end.eq(Some(current_version + 1)))
+            .execute(conn)?;
+
+            let inserted = diesel::insert_into(posts::table)
+                .values((
+                    posts::id.eq(update.id),
+                    posts::title.eq(&update.title),
+                    posts::content.eq(&update.content),
+                    posts::author.eq(update.author),
+                    posts::post_state.eq(update.post_state),
+                    posts::version_start.eq(current_version + 1),
+                    posts::version_end.eq(Option::<i32>::None),
+                ))
+                .returning(posts::id)
+                .get_result::<i32>(conn)?;
+
+            let look_ahead = executor.look_ahead();
+
+            let query = <Post as LoadingHandler<_, PgConnection>>::build_query(&[], &look_ahead)?
+                .filter(posts::id.eq(inserted));
+            let items = Post::load(&look_ahead, selection, executor, query)?;
+            Ok(items.into_iter().next().unwrap_or(Value::Null))
+        })
+    }
+}
+
 wundergraph::mutation_object! {
     Mutation {
         User(insert = NewUser, update = UserChangeset, delete = true),
diff --git a/src/graphql/post_at_version.rs b/src/graphql/post_at_version.rs
@@ -0,0 +1,140 @@
+use crate::from_sql_function;
+use crate::graphql::{Comment, User};
+use crate::model::posts::PostState;
+use crate::schema::*;
+use chrono::{DateTime, Utc};
+use diesel::associations::HasTable;
+use diesel::connection::Connection;
+use diesel::pg::Pg;
+use diesel::prelude::*;
+use diesel::query_builder::BoxedSelectStatement;
+use diesel::query_dsl::methods;
+use diesel::Identifiable;
+use juniper::{LookAheadArgument, LookAheadMethods, LookAheadSelection};
+use wundergraph::error::Result;
+use wundergraph::graphql_type::{GraphqlWrapper, WundergraphGraphqlMapper};
+use wundergraph::juniper_ext::FromLookAheadValue;
+use wundergraph::query_builder::selection::fields::WundergraphBelongsTo;
+use wundergraph::query_builder::selection::filter::{
+    BuildFilter, BuildFilterHelper, FilterWrapper,
+};
+use wundergraph::query_builder::selection::BoxedQuery;
+use wundergraph::query_builder::selection::LoadingHandler;
+use wundergraph::query_builder::types::{HasMany, HasOne};
+use wundergraph::scalar::WundergraphScalarValue;
+use wundergraph::WundergraphContext;
+
+from_sql_function! {
+    posts_at_version(version: Nullable<Integer>) {
+        id -> Int4,
+        title -> Text,
+        content -> Nullable<Text>,
+        published_at -> Timestamptz,
+        author -> Int4,
+        post_state -> crate::model::posts::Post_state,
+    }
+}
+
+#[derive(Clone, Debug, BuildFilterHelper, WundergraphBelongsTo)]
+#[table_name = "posts_at_version"]
+pub struct PostAtVersion {
+    id: i32,
+    title: String,
+    content: Option<String>,
+    published_at: DateTime<Utc>,
+    author: HasOne<i32, User>,
+    comments: HasMany<Comment, comments::post>,
+    post_state: PostState,
+}
+
+impl HasTable for PostAtVersion {
+    type Table = posts_at_version::posts_at_version;
+
+    fn table() -> Self::Table {
+        unimplemented!()
+    }
+}
+
+impl<'a> Identifiable for &'a PostAtVersion {
+    type Id = &'a i32;
+
+    fn id(self) -> Self::Id {
+        &self.id
+    }
+}
+
+impl<Ctx> LoadingHandler<Pg, Ctx> for PostAtVersion
+where
+    Ctx: WundergraphContext + 'static,
+    Ctx::Connection: Connection<Backend = Pg>,
+{
+    type Columns = (
+        posts_at_version::id,
+        posts_at_version::title,
+        posts_at_version::content,
+        posts_at_version::published_at,
+        posts_at_version::author,
+        posts_at_version::post_state,
+    );
+    type FieldList = (
+        i32,
+        String,
+        Option<String>,
+        DateTime<Utc>,
+        HasOne<i32, User>,
+        HasMany<Comment, comments::post>,
+        PostState,
+    );
+    type PrimaryKeyIndex = wundergraph::helper::TupleIndex0;
+    type Filter = FilterWrapper<Self, Pg, Ctx>;
+    const FIELD_NAMES: &'static [&'static str] = &[
+        "id",
+        "title",
+        "content",
+        "published_at",
+        "author",
+        "comments",
+        "post_state",
+    ];
+    const TYPE_NAME: &'static str = "PostsAtVersion";
+
+    fn build_query<'a>(
+        _global_args: &[LookAheadArgument<WundergraphScalarValue>],
+        select: &LookAheadSelection<'_, WundergraphScalarValue>,
+    ) -> Result<BoxedQuery<'a, Self, Pg, Ctx>>
+    where
+        Self::Table: methods::BoxedDsl<
+                'a,
+                Pg,
+                Output = BoxedSelectStatement<
+                    'a,
+                    diesel::dsl::SqlTypeOf<<Self::Table as Table>::AllColumns>,
+                    Self::Table,
+                    Pg,
+                >,
+            > + 'static,
+        <Self::Filter as BuildFilter<Pg>>::Ret: AppearsOnTable<Self::Table>,
+    {
+        let version: Option<i32> = select
+            .argument("version")
+            .and_then(|v| FromLookAheadValue::from_look_ahead(&v.value()));
+        let mut query = posts_at_version(version)
+            .into_boxed()
+            .select(<Self as LoadingHandler<Pg, Ctx>>::get_select(select)?);
+
+        query = <Self as LoadingHandler<Pg, Ctx>>::apply_filter(query, select)?;
+        query = <Self as LoadingHandler<Pg, Ctx>>::apply_limit(query, select)?;
+        query = <Self as LoadingHandler<Pg, Ctx>>::apply_offset(query, select)?;
+        query = <Self as LoadingHandler<Pg, Ctx>>::apply_order(query, select)?;
+
+        Ok(query)
+    }
+}
+
+impl<Ctx> WundergraphGraphqlMapper<Pg, Ctx> for PostAtVersion
+where
+    Ctx: WundergraphContext + 'static,
+    Ctx::Connection: Connection<Backend = diesel::pg::Pg>,
+{
+    type GraphQLType = GraphqlWrapper<PostAtVersion, Pg, Ctx>;
+}
diff --git a/src/model/posts.rs b/src/model/posts.rs
@@ -41,6 +41,8 @@ pub struct Post {
     published_at: DateTime<Utc>,
     author: i32,
     post_state: PostState,
+    version_start: i32,
+    version_end: Option<i32>,
 }
 
 #[derive(Deserialize, Debug, AsChangeset, GraphQLInputObject)]
diff --git a/src/schema.rs b/src/schema.rs
@@ -22,6 +22,8 @@ table! {
         published_at -> Timestamptz,
         author -> Int4,
         post_state -> Post_state,
+        version_start -> Int4,
+        version_end -> Nullable<Int4>,
     }
 }
 
@@ -36,7 +38,6 @@ table! {
     }
 }
 
-joinable!(comments -> posts (post));
 joinable!(comments -> users (author));
 joinable!(posts -> users (author));
 

Original file line number	Diff line number	Diff line change
`@@ -41,6 +41,8 @@ pub struct Post {`
`41`	`41`	`published_at: DateTime<Utc>,`
`42`	`42`	`author: i32,`
`43`	`43`	`post_state: PostState,`
	`44`	`+ version_start: i32,`
	`45`	`+ version_end: Option<i32>,`
`44`	`46`	`}`
`45`	`47`
`46`	`48`	`#[derive(Deserialize, Debug, AsChangeset, GraphQLInputObject)]`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,8 @@ table! {`
`22`	`22`	`published_at -> Timestamptz,`
`23`	`23`	`author -> Int4,`
`24`	`24`	`post_state -> Post_state,`
	`25`	`+ version_start -> Int4,`
	`26`	`+ version_end -> Nullable<Int4>,`
`25`	`27`	`}`
`26`	`28`	`}`
`27`	`29`
`@@ -36,7 +38,6 @@ table! {`
`36`	`38`	`}`
`37`	`39`	`}`
`38`	`40`
`39`		`-joinable!(comments -> posts (post));`
`40`	`41`	`joinable!(comments -> users (author));`
`41`	`42`	`joinable!(posts -> users (author));`
`42`	`43`