Update deps; WIP on comments

src/MyWebLog.Data/Utils.fs

@@ -1,11 +1,16 @@
-/// Utility functions for manipulating data
+/// <summary>Utility functions for manipulating data</summary>
 [<RequireQualifiedAccess>]
 module internal MyWebLog.Data.Utils
 
 open MyWebLog
 open MyWebLog.ViewModels
 
-/// Create a category hierarchy from the given list of categories
+/// <summary>Create a category hierarchy from the given list of categories</summary>
+/// <param name="cats">The categories from which the list should be generated</param>
+/// <param name="parentId">The ID of the parent category for this list</param>
+/// <param name="slugBase">The base URL to use in slugs for categories at this level</param>
+/// <param name="parentNames">The names of parent categories for this level</param>
+/// <returns>An array of <c>DisplayCategory</c> instances sorted alphabetically by parent category</returns>
 let rec orderByHierarchy (cats: Category list) parentId slugBase parentNames = seq {
     for cat in cats |> List.filter (fun c -> c.ParentId = parentId) do
         let fullSlug = (match slugBase with Some it -> $"{it}/" | None -> "") + cat.Slug
@@ -19,48 +24,75 @@ let rec orderByHierarchy (cats: Category list) parentId slugBase parentNames = s
         yield! orderByHierarchy cats (Some cat.Id) (Some fullSlug) ([ cat.Name ] |> List.append parentNames)
 }
 
-/// Get lists of items removed from and added to the given lists
+/// <summary>Get lists of items removed from and added to the given lists</summary>
+/// <typeparam name="T">The type of items in the list</typeparam>
+/// <typeparam name="U">The return type of the comparision function</typeparam>
+/// <param name="oldItems">The prior list</param>
+/// <param name="newItems">The current list</param>
+/// <param name="f">The function to use when comparing items in the list</param>
+/// <returns>A tuple with <c>fst</c> being added items and <c>snd</c> being removed items</returns>
 let diffLists<'T, 'U when 'U: equality> oldItems newItems (f: 'T -> 'U) =
     let diff compList = fun item -> not (compList |> List.exists (fun other -> f item = f other))
     List.filter (diff newItems) oldItems, List.filter (diff oldItems) newItems
 
-/// Find the revisions added and removed
+/// <summary>Find the revisions added and removed</summary>
+/// <param name="oldRevs">The previous revisions</param>
+/// <param name="newRevs">The current revisions</param>
+/// <returns>A tuple with <c>fst</c> being added revisions and <c>snd</c> being removed revisions</returns>
 let diffRevisions (oldRevs: Revision list) newRevs =
     diffLists oldRevs newRevs (fun rev -> $"{rev.AsOf.ToUnixTimeTicks()}|{rev.Text}")
 
 open MyWebLog.Converters
 open Newtonsoft.Json
 
-/// Serialize an object to JSON
+/// <summary>Serialize an object to JSON</summary>
+/// <typeparam name="T">The type of the item being serialized</typeparam>
+/// <param name="ser">The JSON serializer whose settings should be used</param>
+/// <param name="item">The item to be serialized</param>
+/// <returns>A string with the given object serialized to JSON</returns>
 let serialize<'T> ser (item: 'T) =
     JsonConvert.SerializeObject(item, Json.settings ser)
 
-/// Deserialize a JSON string 
+/// <summary>Deserialize a JSON string</summary>
+/// <typeparam name="T">The type of the item being deserialized</typeparam>
+/// <param name="ser">The JSON serializer whose settings should be used</param>
+/// <param name="value">The string with the JSON representation of the item</param>
+/// <returns>The item deserialized from JSON</returns>
 let deserialize<'T> (ser: JsonSerializer) value =
     JsonConvert.DeserializeObject<'T>(value, Json.settings ser)
 
+
 open BitBadger.Documents
 
-/// Create a document serializer using the given JsonSerializer
+/// <summary>Create a document serializer using the given JsonSerializer</summary>
+/// <param name="ser">The JSON.NET serializer on which the document serializer should be based</param>
+/// <returns>A document serializer instance</returns>
 let createDocumentSerializer ser =
     { new IDocumentSerializer with
         member _.Serialize<'T>(it: 'T) : string = serialize ser it
         member _.Deserialize<'T>(it: string) : 'T = deserialize ser it
     }
 
-/// Data migration utilities
+/// <summary>Data migration utilities</summary>
 module Migration =
-    
+
     open Microsoft.Extensions.Logging
 
-    /// The current database version
+    /// <summary>The current database version</summary>
     let currentDbVersion = "v2.2"
 
-    /// Log a migration step
+    /// <summary>Log a migration step</summary>
+    /// <param name="log">The logger to which the message should be logged</param>
+    /// <param name="migration">The migration being run</param>
+    /// <param name="message">The log message</param>
     let logStep<'T> (log: ILogger<'T>) migration message =
         log.LogInformation $"Migrating %s{migration}: %s{message}"
 
-    /// Notify the user that a backup/restore
+    /// <summary>Notify the user that a backup/restore is required to migrate</summary>
+    /// <param name="log">The logger to which the message should be logged</param>
+    /// <param name="oldVersion">The old (current) version of the database</param>
+    /// <param name="newVersion">The new (application) version required</param>
+    /// <param name="webLogs">All web logs contained in the database</param>
     let backupAndRestoreRequired log oldVersion newVersion webLogs =
         logStep log $"%s{oldVersion} to %s{newVersion}" "Requires Using Action"
 
@@ -74,7 +106,6 @@ module Migration =
           yield! webLogs |> List.map (fun (url, slug) -> $"./myWebLog backup %s{url} {oldVersion}.%s{slug}.json") ]
         |> String.concat "\n"
         |> log.LogWarning
-        
+
         log.LogCritical "myWebLog will now exit"
         exit 1 |> ignore
-