Incorporate doc lib v4 ordering

src/MyWebLog.Data/Postgres/PostgresHelpers.fs

@@ -83,7 +83,7 @@ let webLogContains webLogId =
 
 /// A SQL string to select data from a table with the given JSON document contains criteria
 let selectWithCriteria tableName =
-    $"""{Query.find tableName} WHERE {Query.whereDataContains "@criteria"}"""
+    Query.byContains (Query.find tableName)
 
 /// Create the SQL and parameters for an IN clause
 let inClause<'T> colNameAndPrefix paramName (items: 'T list) =

src/MyWebLog.Data/Postgres/PostgresPageData.fs

@@ -33,6 +33,10 @@ type PostgresPageData(log: ILogger) =
         log.LogTrace "Page.pageExists"
         Document.existsByWebLog Table.Page pageId webLogId
     
+    /// The query to get all pages ordered by title
+    let sortedPages =
+        selectWithCriteria Table.Page + Query.orderBy [ Field.Named $"i:{nameof Page.Empty.Title}" ] PostgreSQL
+        
     // IMPLEMENTATION FUNCTIONS
     
     /// Add a page
@@ -47,7 +51,7 @@ type PostgresPageData(log: ILogger) =
     let all webLogId =
         log.LogTrace "Page.all"
         Custom.list
-            $"{selectWithCriteria Table.Page} ORDER BY LOWER(data->>'{nameof Page.Empty.Title}')"
+            sortedPages
             [ webLogContains webLogId ]
             (fun row -> { fromData<Page> row with Text = ""; Metadata = []; PriorPermalinks = [] }) 
     
@@ -133,17 +137,13 @@ type PostgresPageData(log: ILogger) =
     let findListed webLogId =
         log.LogTrace "Page.findListed"
         Custom.list
-            $"{selectWithCriteria Table.Page} ORDER BY LOWER(data->>'{nameof Page.Empty.Title}')"
-            [ jsonParam "@criteria" {| webLogDoc webLogId with IsInPageList = true |} ]
-            pageWithoutText
+            sortedPages [ jsonParam "@criteria" {| webLogDoc webLogId with IsInPageList = true |} ] pageWithoutText
     
     /// Get a page of pages for the given web log (without revisions)
     let findPageOfPages webLogId pageNbr =
         log.LogTrace "Page.findPageOfPages"
         Custom.list
-            $"{selectWithCriteria Table.Page}
-               ORDER BY LOWER(data->>'{nameof Page.Empty.Title}')
-               LIMIT @pageSize OFFSET @toSkip"
+            $"{sortedPages} LIMIT @pageSize OFFSET @toSkip"
             [ webLogContains webLogId; "@pageSize", Sql.int 26; "@toSkip", Sql.int ((pageNbr - 1) * 25) ]
             (fun row -> { fromData<Page> row with Metadata = []; PriorPermalinks = [] })
     

src/MyWebLog.Data/Postgres/PostgresPostData.fs

@@ -124,21 +124,24 @@ type PostgresPostData(log: ILogger) =
         log.LogTrace "Post.findPageOfCategorizedPosts"
         let catSql, catParam = arrayContains (nameof Post.Empty.CategoryIds) string categoryIds
         Custom.list
-            $"{selectWithCriteria Table.Post}
-                 AND {catSql}
-               ORDER BY data->>'{nameof Post.Empty.PublishedOn}' DESC
-               LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"
+            $"""{selectWithCriteria Table.Post}
+                  AND {catSql}
+                {Query.orderBy [ Field.Named $"{nameof Post.Empty.PublishedOn} DESC" ] PostgreSQL}
+                LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"""
             [ jsonParam "@criteria" {| webLogDoc webLogId with Status = Published |}; catParam ]
             postWithoutLinks
     
     /// Get a page of posts for the given web log (excludes text and revisions)
     let findPageOfPosts webLogId pageNbr postsPerPage =
         log.LogTrace "Post.findPageOfPosts"
+        let order =
+            Query.orderBy
+                [ Field.Named $"{nameof Post.Empty.PublishedOn} DESC NULLS FIRST"
+                  Field.Named (nameof Post.Empty.UpdatedOn) ]
+                PostgreSQL
         Custom.list
-            $"{selectWithCriteria Table.Post}
-               ORDER BY data->>'{nameof Post.Empty.PublishedOn}' DESC NULLS FIRST,
-                        data->>'{nameof Post.Empty.UpdatedOn}'
-               LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"
+            $"{selectWithCriteria Table.Post}{order}
+              LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"
             [ webLogContains webLogId ]
             postWithoutText
     
@@ -146,9 +149,9 @@ type PostgresPostData(log: ILogger) =
     let findPageOfPublishedPosts webLogId pageNbr postsPerPage =
         log.LogTrace "Post.findPageOfPublishedPosts"
         Custom.list
-            $"{selectWithCriteria Table.Post}
-               ORDER BY data->>'{nameof Post.Empty.PublishedOn}' DESC
-               LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"
+            $"""{selectWithCriteria Table.Post}
+                {Query.orderBy [ Field.Named $"{nameof Post.Empty.PublishedOn} DESC" ] PostgreSQL}
+                LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"""
             [ jsonParam "@criteria" {| webLogDoc webLogId with Status = Published |} ]
             postWithoutLinks
     
@@ -156,10 +159,10 @@ type PostgresPostData(log: ILogger) =
     let findPageOfTaggedPosts webLogId (tag: string) pageNbr postsPerPage =
         log.LogTrace "Post.findPageOfTaggedPosts"
         Custom.list
-            $"{selectWithCriteria Table.Post}
-                 AND data['{nameof Post.Empty.Tags}'] @> @tag
-               ORDER BY data->>'{nameof Post.Empty.PublishedOn}' DESC
-               LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"
+            $"""{selectWithCriteria Table.Post}
+                  AND data['{nameof Post.Empty.Tags}'] @> @tag
+                {Query.orderBy [ Field.Named $"{nameof Post.Empty.PublishedOn} DESC" ] PostgreSQL}
+                LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"""
             [ jsonParam "@criteria" {| webLogDoc webLogId with Status = Published |}; jsonParam "@tag" [| tag |] ]
             postWithoutLinks
     
@@ -170,10 +173,10 @@ type PostgresPostData(log: ILogger) =
             [ jsonParam "@criteria" {| webLogDoc webLogId with Status = Published |}
               "@publishedOn", Sql.timestamptz (publishedOn.ToDateTimeOffset()) ]
         let query op direction =
-            $"{selectWithCriteria Table.Post}
-                 AND (data->>'{nameof Post.Empty.PublishedOn}')::timestamp with time zone %s{op} @publishedOn
-               ORDER BY data->>'{nameof Post.Empty.PublishedOn}' %s{direction}
-               LIMIT 1"
+            $"""{selectWithCriteria Table.Post}
+                  AND (data->>'{nameof Post.Empty.PublishedOn}')::timestamp with time zone %s{op} @publishedOn
+                {Query.orderBy [ Field.Named $"{nameof Post.Empty.PublishedOn} %s{direction}" ] PostgreSQL} 
+                LIMIT 1"""
         let! older = Custom.list (query "<" "DESC") (queryParams ()) postWithoutLinks
         let! newer = Custom.list (query ">" "")     (queryParams ()) postWithoutLinks
         return List.tryHead older, List.tryHead newer

src/MyWebLog.Data/Postgres/PostgresThemeData.fs

@@ -17,11 +17,11 @@ type PostgresThemeData(log: ILogger) =
     /// Retrieve all themes (except 'admin'; excludes template text)
     let all () =
         log.LogTrace "Theme.all"
+        let fields = [ Field.NE (nameof Theme.Empty.Id) "admin" ]
         Custom.list
-            $"{Query.find Table.Theme}
-               WHERE data->>'{nameof Theme.Empty.Id}' <> 'admin'
-               ORDER BY data->>'{nameof Theme.Empty.Id}'"
-            []
+            (Query.byFields (Query.find Table.Theme) Any fields
+                + Query.orderBy [ Field.Named (nameof Theme.Empty.Id) ] PostgreSQL)
+            (addFieldParams fields [])
             withoutTemplateText
     
     /// Does a given theme exist?

src/MyWebLog.Data/Postgres/PostgresWebLogUserData.fs

@@ -49,10 +49,8 @@ type PostgresWebLogUserData(log: ILogger) =
     /// Get all users for the given web log
     let findByWebLog webLogId =
         log.LogTrace "WebLogUser.findByWebLog"
-        Custom.list
-            $"{selectWithCriteria Table.WebLogUser} ORDER BY LOWER(data->>'{nameof WebLogUser.Empty.PreferredName}')"
-            [ webLogContains webLogId ]
-            fromData<WebLogUser>
+        Find.byContainsOrdered<WebLogUser>
+            Table.WebLogUser (webLogDoc webLogId) [ Field.Named $"i:{nameof WebLogUser.Empty.PreferredName}" ]
     
     /// Find the names of users by their IDs for the given web log
     let findNames webLogId (userIds: WebLogUserId list) = backgroundTask {