Posts with many categories now render

- Fixed a problem with the RethinkDB query that was assembling categories for a single post (yay, @1lann on Slack!) - Finished conversion of data access functions to use async CEs
2016-11-08 09:47:33 -06:00 · 2016-11-08 09:47:33 -06:00 · 1873f9d6fc
commit 1873f9d6fc
parent e5700727e9
5 changed files with 206 additions and 153 deletions
--- a/src/MyWebLog.Data.RethinkDB/Category.fs
+++ b/src/MyWebLog.Data.RethinkDB/Category.fs
@ -9,7 +9,7 @@ let private r = RethinkDb.Driver.RethinkDB.R
 let private category (webLogId : string) (catId : string) =
  r.Table(Table.Category)
    .Get(catId)
-    .Filter(ReqlFunction1(fun c -> upcast c.["WebLogId"].Eq(webLogId)))
+    .Filter(ReqlFunction1 (fun c -> upcast c.["WebLogId"].Eq webLogId))

 /// Get all categories for a web log
 let getAllCategories conn (webLogId : string) =
@ -99,7 +99,7 @@ let deleteCategory conn (cat : Category) =
    let! posts =
      r.Table(Table.Post)
        .GetAll(cat.WebLogId).OptArg("index", "WebLogId")
-        .Filter(ReqlFunction1(fun p -> upcast p.["CategoryIds"].Contains(cat.Id)))
+        .Filter(ReqlFunction1 (fun p -> upcast p.["CategoryIds"].Contains cat.Id))
        .RunResultAsync<Post list> conn
      |> Async.AwaitTask
    posts
@ -119,7 +119,7 @@ let deleteCategory conn (cat : Category) =
    do! r.Table(Table.Category)
          .Get(cat.Id)
          .Delete()
-          .RunResultAsync(conn)
+          .RunResultAsync conn
    }
  |> Async.RunSynchronously

--- a/src/MyWebLog.Data.RethinkDB/Extensions.fs
+++ b/src/MyWebLog.Data.RethinkDB/Extensions.fs
@ -3,8 +3,6 @@ module MyWebLog.Data.RethinkDB.Extensions

 open System.Threading.Tasks

-let await task = task |> Async.AwaitTask |> Async.RunSynchronously
-
 // H/T: Suave
 type AsyncBuilder with
  /// An extension method that overloads the standard 'Bind' of the 'async' builder. The new overload awaits on
--- a/src/MyWebLog.Data.RethinkDB/Page.fs
+++ b/src/MyWebLog.Data.RethinkDB/Page.fs
@ -7,39 +7,55 @@ let private r = RethinkDb.Driver.RethinkDB.R

 /// Try to find a page by its Id, optionally including revisions
 let tryFindPageById conn webLogId (pageId : string) includeRevs =
-  let pg = r.Table(Table.Page)
-             .Get(pageId)
-  match includeRevs with true -> pg.RunResultAsync<Page>(conn) | _ -> pg.Without("Revisions").RunResultAsync<Page>(conn)
-  |> await
-  |> box
-  |> function
+  async {
+    let q =
+      r.Table(Table.Page)
+        .Get pageId
+    let! thePage =
+      match includeRevs with
+      | true -> q.RunResultAsync<Page> conn
+      | _ -> q.Without("Revisions").RunResultAsync<Page> conn
+    return
+      match box thePage with
      | null -> None
-     | page -> let pg : Page = unbox page
+      | page ->
+          let pg : Page = unbox page
          match pg.WebLogId = webLogId with true -> Some pg | _ -> None
+    }
+  |> Async.RunSynchronously

 /// Find a page by its permalink
 let tryFindPageByPermalink conn (webLogId : string) (permalink : string) =
+  async {
+    let! pg =
      r.Table(Table.Page)
        .GetAll(r.Array (webLogId, permalink)).OptArg("index", "Permalink")
        .Without("Revisions")
-    .RunResultAsync<Page list>(conn)
-  |> await
-  |> List.tryHead
+        .RunResultAsync<Page list> conn
+    return List.tryHead pg
+    }
+  |> Async.RunSynchronously

 /// Get a list of all pages (excludes page text and revisions)
 let findAllPages conn (webLogId : string) =
+  async {
+    return!
      r.Table(Table.Page)
        .GetAll(webLogId).OptArg("index", "WebLogId")
        .OrderBy("Title")
        .Without("Text", "Revisions")
-    .RunResultAsync<Page list>(conn)
-  |> await
+        .RunResultAsync<Page list> conn
+    }
+  |> Async.RunSynchronously

 /// Add a page
 let addPage conn (page : Page) =
-  r.Table(Table.Page)
+  async {
+    do! r.Table(Table.Page)
          .Insert(page)
-    .RunResultAsync(conn) |> await |> ignore
+          .RunResultAsync conn
+    }
+  |> (Async.RunSynchronously >> ignore)

 type PageUpdateRecord =
  { Title : string
@ -51,7 +67,9 @@ type PageUpdateRecord =
 /// Update a page
 let updatePage conn (page : Page) =
  match tryFindPageById conn page.WebLogId page.Id false with
-  | Some _ -> r.Table(Table.Page)
+  | Some _ ->
+      async {
+        do! r.Table(Table.Page)
              .Get(page.Id)
              .Update({ PageUpdateRecord.Title = page.Title
                        Permalink = page.Permalink
@ -59,14 +77,20 @@ let updatePage conn (page : Page) =
                        UpdatedOn = page.UpdatedOn
                        Text = page.Text
                        Revisions = page.Revisions })
-                .RunResultAsync(conn) |> await |> ignore
+              .RunResultAsync conn
+        }
+      |> (Async.RunSynchronously >> ignore)
  | _ -> ()
    
 /// Delete a page
 let deletePage conn webLogId pageId =
  match tryFindPageById conn webLogId pageId false with
-  | Some _ -> r.Table(Table.Page)
+  | Some _ ->
+      async {
+        do! r.Table(Table.Page)
              .Get(pageId)
              .Delete()
-                .RunResultAsync(conn) |> await |> ignore
+              .RunResultAsync conn
+        }
+      |> (Async.RunSynchronously >> ignore)
  | _ -> ()
--- a/src/MyWebLog.Data.RethinkDB/Post.fs
+++ b/src/MyWebLog.Data.RethinkDB/Post.fs
@ -12,21 +12,27 @@ let private publishedPosts (webLogId : string)=

 /// Shorthand to sort posts by published date, slice for the given page, and return a list
 let private toPostList conn pageNbr nbrPerPage (filter : ReqlExpr) =
+  async {
+    return!
      filter
-    .OrderBy(r.Desc("PublishedOn"))
+        .OrderBy(r.Desc "PublishedOn")
        .Slice((pageNbr - 1) * nbrPerPage, pageNbr * nbrPerPage)
-    .RunResultAsync<Post list>(conn)
-  |> await
+        .RunResultAsync<Post list> conn
+    }
+  |> Async.RunSynchronously

 /// Shorthand to get a newer or older post
 let private adjacentPost conn (post : Post) (theFilter : ReqlExpr -> obj) (sort : obj) =
+  async {
+    let! post =
      (publishedPosts post.WebLogId)
        .Filter(theFilter)
        .OrderBy(sort)
        .Limit(1)
-    .RunResultAsync<Post list>(conn)
-  |> await
-  |> List.tryHead
+        .RunResultAsync<Post list> conn
+    return List.tryHead post
+    }
+  |> Async.RunSynchronously

 /// Find a newer post
 let private newerPost conn post theFilter = adjacentPost conn post theFilter <| r.Asc "PublishedOn"
@ -42,141 +48,163 @@ let findPageOfPublishedPosts conn webLogId pageNbr nbrPerPage =
 /// Get a page of published posts assigned to a given category
 let findPageOfCategorizedPosts conn webLogId (categoryId : string) pageNbr nbrPerPage =
  (publishedPosts webLogId)
-    .Filter(ReqlFunction1(fun p -> upcast p.["CategoryIds"].Contains(categoryId)))
+    .Filter(ReqlFunction1 (fun p -> upcast p.["CategoryIds"].Contains categoryId))
  |> toPostList conn pageNbr nbrPerPage

 /// Get a page of published posts tagged with a given tag
 let findPageOfTaggedPosts conn webLogId (tag : string) pageNbr nbrPerPage =
  (publishedPosts webLogId)
-    .Filter(ReqlFunction1(fun p -> upcast p.["Tags"].Contains(tag)))
+    .Filter(ReqlFunction1 (fun p -> upcast p.["Tags"].Contains tag))
  |> toPostList conn pageNbr nbrPerPage

 /// Try to get the next newest post from the given post
-let tryFindNewerPost conn post = newerPost conn post (fun p -> upcast p.["PublishedOn"].Gt(post.PublishedOn))
+let tryFindNewerPost conn post = newerPost conn post (fun p -> upcast p.["PublishedOn"].Gt post.PublishedOn)
 
 /// Try to get the next newest post assigned to the given category
 let tryFindNewerCategorizedPost conn (categoryId : string) post =
  newerPost conn post (fun p -> upcast p.["PublishedOn"].Gt(post.PublishedOn)
-                                        .And(p.["CategoryIds"].Contains(categoryId)))
+                                        .And(p.["CategoryIds"].Contains categoryId))
 
 /// Try to get the next newest tagged post from the given tagged post
 let tryFindNewerTaggedPost conn (tag : string) post =
-  newerPost conn post (fun p -> upcast p.["PublishedOn"].Gt(post.PublishedOn).And(p.["Tags"].Contains(tag)))
+  newerPost conn post (fun p -> upcast p.["PublishedOn"].Gt(post.PublishedOn).And(p.["Tags"].Contains tag))
 
 /// Try to get the next oldest post from the given post
-let tryFindOlderPost conn post = olderPost conn post (fun p -> upcast p.["PublishedOn"].Lt(post.PublishedOn))
+let tryFindOlderPost conn post = olderPost conn post (fun p -> upcast p.["PublishedOn"].Lt post.PublishedOn)

 /// Try to get the next oldest post assigned to the given category
 let tryFindOlderCategorizedPost conn (categoryId : string) post =
  olderPost conn post (fun p -> upcast p.["PublishedOn"].Lt(post.PublishedOn)
-                                        .And(p.["CategoryIds"].Contains(categoryId)))
+                                        .And(p.["CategoryIds"].Contains categoryId))

 /// Try to get the next oldest tagged post from the given tagged post
 let tryFindOlderTaggedPost conn (tag : string) post =
-  olderPost conn post (fun p -> upcast p.["PublishedOn"].Lt(post.PublishedOn).And(p.["Tags"].Contains(tag)))
+  olderPost conn post (fun p -> upcast p.["PublishedOn"].Lt(post.PublishedOn).And(p.["Tags"].Contains tag))

 /// Get a page of all posts in all statuses
 let findPageOfAllPosts conn (webLogId : string) pageNbr nbrPerPage =
  // FIXME: sort unpublished posts by their last updated date
+  async {
+    return!
      r.Table(Table.Post)
        .GetAll(webLogId).OptArg("index", "WebLogId")
-    .OrderBy(r.Desc("PublishedOn"))
+        .OrderBy(r.Desc "PublishedOn")
        .Slice((pageNbr - 1) * nbrPerPage, pageNbr * nbrPerPage)
-    .RunResultAsync<Post list>(conn)
-  |> await
+        .RunResultAsync<Post list> conn
+    }
+  |> Async.RunSynchronously

 /// Try to find a post by its Id and web log Id
 let tryFindPost conn webLogId postId : Post option =
+  async {
+    let! p =
      r.Table(Table.Post)
        .Get(postId)
-    .Filter(ReqlFunction1(fun p -> upcast p.["WebLogId"].Eq(webLogId)))
-    .RunResultAsync<Post>(conn)
-  |> await
-  |> box
-  |> function null -> None | post -> Some <| unbox post
+        .Filter(ReqlFunction1 (fun p -> upcast p.["WebLogId"].Eq webLogId))
+        .RunResultAsync<Post> conn
+    return match box p with null -> None | post -> Some <| unbox post
+    }
+  |> Async.RunSynchronously

 /// Try to find a post by its permalink
 let tryFindPostByPermalink conn webLogId permalink =
+  async {
+    let! post =
      r.Table(Table.Post)
        .GetAll(r.Array (webLogId, permalink)).OptArg("index", "Permalink")
-    .Filter(ReqlFunction1(fun p -> upcast p.["Status"].Eq(PostStatus.Published)))
+        .Filter(ReqlFunction1 (fun p -> upcast p.["Status"].Eq PostStatus.Published))
        .Without("Revisions")
        .Merge(ReqlFunction1 (fun p ->
-      upcast r.HashMap("Categories", r.Table(Table.Category)
-                                      .GetAll(p.["CategoryIds"])
+          upcast r.HashMap(
+            "Categories", r.Table(Table.Category)
+                            .GetAll(r.Args p.["CategoryIds"])
                            .Without("Children")
                            .OrderBy("Name")
-                                      .CoerceTo("array"))))
-    .Merge(ReqlFunction1(fun p ->
-      upcast r.HashMap("Comments", r.Table(Table.Comment)
+                            .CoerceTo("array")).With(
+            "Comments", r.Table(Table.Comment)
                          .GetAll(p.["id"]).OptArg("index", "PostId")
                          .OrderBy("PostedOn")
                          .CoerceTo("array"))))
-    .RunResultAsync<Post list>(conn)
-  |> await
-  |> List.tryHead
+        .RunResultAsync<Post list> conn
+    return List.tryHead post
+    }
+  |> Async.RunSynchronously

 /// Try to find a post by its prior permalink
 let tryFindPostByPriorPermalink conn (webLogId : string) (permalink : string) =
+  async {
+    let! post =
      r.Table(Table.Post)
        .GetAll(webLogId).OptArg("index", "WebLogId")
        .Filter(ReqlFunction1 (fun p ->
-      upcast p.["PriorPermalinks"].Contains(permalink).And(p.["Status"].Eq(PostStatus.Published))))
+          upcast p.["PriorPermalinks"].Contains(permalink).And(p.["Status"].Eq PostStatus.Published)))
        .Without("Revisions")
-    .RunResultAsync<Post list>(conn)
-  |> await
-  |> List.tryHead
+        .RunResultAsync<Post list> conn
+    return List.tryHead post
+    }
+  |> Async.RunSynchronously

 /// Get a set of posts for RSS
 let findFeedPosts conn webLogId nbr : (Post * User option) list =
+  let tryFindUser userId =
+    async {
+      let! u =
+        r.Table(Table.User)
+          .Get(userId)
+          .RunAtomAsync<User> conn
+      return match box u with null -> None | user -> Some <| unbox user
+      }
+    |> Async.RunSynchronously
  (publishedPosts webLogId)
    .Merge(ReqlFunction1 (fun post ->
-      upcast r.HashMap("Categories", r.Table(Table.Category)
-                                      .GetAll(post.["CategoryIds"])
+      upcast r.HashMap(
+        "Categories", r.Table(Table.Category)
+                        .GetAll(r.Args post.["CategoryIds"])
                        .OrderBy("Name")
                        .Pluck("id", "Name")
                        .CoerceTo("array"))))
  |> toPostList conn 1 nbr
-  |> List.map (fun post -> post, r.Table(Table.User)
-                                   .Get(post.AuthorId)
-                                   .RunAtomAsync<User>(conn)
-                                 |> await
-                                 |> box
-                                 |> function null -> None | user -> Some <| unbox user)
+  |> List.map (fun post -> post, tryFindUser post.AuthorId)

 /// Add a post
 let addPost conn post =
-  r.Table(Table.Post)
+  async {
+    do! r.Table(Table.Post)
          .Insert(post)
-    .RunResultAsync(conn)
-  |> await
-  |> ignore
+          .RunResultAsync conn
+    }
+  |> (Async.RunSynchronously >> ignore)

 /// Update a post
 let updatePost conn (post : Post) =
-  r.Table(Table.Post)
+  async {
+    do! r.Table(Table.Post)
          .Get(post.Id)
          .Replace( { post with Categories = []
                                Comments   = [] } )
-    .RunResultAsync(conn)
-  |> await
-  |> ignore
+          .RunResultAsync conn
+    }
+  |> (Async.RunSynchronously >> ignore)
  
 /// Save a post
 let savePost conn (post : Post) =
  match post.Id with
-  | "new" -> let newPost = { post with Id = string <| System.Guid.NewGuid() }
-             r.Table(Table.Post)
+  | "new" ->
+      let newPost = { post with Id = string <| System.Guid.NewGuid() }
+      async {
+        do! r.Table(Table.Post)
              .Insert(newPost)
-               .RunResultAsync(conn)
-             |> await
-             |> ignore
+              .RunResultAsync conn
+        }
+      |> Async.RunSynchronously
      newPost.Id
-  | _ -> r.Table(Table.Post)
+  | _ ->
+      async {
+        do! r.Table(Table.Post)
              .Get(post.Id)
              .Replace( { post with Categories = []
                                    Comments   = [] } )
-           .RunResultAsync(conn)
-         |> await
-         |> ignore
+              .RunResultAsync conn
+        }
+      |> Async.RunSynchronously
      post.Id
--- a/src/MyWebLog.Data.RethinkDB/WebLog.fs
+++ b/src/MyWebLog.Data.RethinkDB/WebLog.fs
@ -12,9 +12,10 @@ let tryFindWebLogByUrlBase conn (urlBase : string) =
      r.Table(Table.WebLog)
        .GetAll(urlBase).OptArg("index", "UrlBase")
        .Merge(ReqlFunction1 (fun w ->
-          upcast r.HashMap("PageList", r.Table(Table.Page)
+          upcast r.HashMap(
+            "PageList", r.Table(Table.Page)
                          .GetAll(w.G("id")).OptArg("index", "WebLogId")
-                                        .Filter(ReqlFunction1(fun pg -> upcast pg.["ShowInPageList"].Eq(true)))
+                          .Filter(ReqlFunction1 (fun pg -> upcast pg.["ShowInPageList"].Eq true))
                          .OrderBy("Title")
                          .Pluck("Title", "Permalink")
                          .CoerceTo("array"))))
@ -27,9 +28,11 @@ let tryFindWebLogByUrlBase conn (urlBase : string) =
 let findDashboardCounts conn (webLogId : string) =
  async {
    return!
-      r.Expr(  r.HashMap("Pages",      r.Table(Table.Page    ).GetAll(webLogId).OptArg("index", "WebLogId").Count()))
-        .Merge(r.HashMap("Posts",      r.Table(Table.Post    ).GetAll(webLogId).OptArg("index", "WebLogId").Count()))
-        .Merge(r.HashMap("Categories", r.Table(Table.Category).GetAll(webLogId).OptArg("index", "WebLogId").Count()))
+      r.Expr(
+        r.HashMap(
+          "Pages",      r.Table(Table.Page    ).GetAll(webLogId).OptArg("index", "WebLogId").Count()).With(
+          "Posts",      r.Table(Table.Post    ).GetAll(webLogId).OptArg("index", "WebLogId").Count()).With(
+          "Categories", r.Table(Table.Category).GetAll(webLogId).OptArg("index", "WebLogId").Count()))
        .RunResultAsync<DashboardCounts> conn
    }
  |> Async.RunSynchronously