Fixing minor typos (#86)

This addresses several typos that were seen in the XML comments.

src/CommunityToolkit.Datasync.Client/Paging/Page.cs

@@ -22,7 +22,7 @@ public class Page<TEntity>
     public long? Count { get; set; }
 
     /// <summary>
-    /// The Uri to the nexty page in the result set.
+    /// The Uri to the next page in the result set.
     /// </summary>
     public string? NextLink { get; set; }
 }

src/CommunityToolkit.Datasync.Client/Query/DatasyncPullQuery.cs

@@ -10,7 +10,7 @@ namespace CommunityToolkit.Datasync.Client.Offline;
 /// Represents a query that can be evaluated against an OData table.
 /// </summary>
 /// <remarks>
-/// Rather than implenting <see cref="IQueryable{T}"/> directly, we've implemented the portion of  the LINQ query
+/// Rather than implementing <see cref="IQueryable{T}"/> directly, we've implemented the portion of  the LINQ query
 /// pattern we support on a datasync service.  You can use the <see cref="IDatasyncQueryable{TEntity}"/> instance
 /// to build up a query using normal LINQ patterns.
 /// </remarks>

src/CommunityToolkit.Datasync.Client/Query/DatasyncQueryable.cs

@@ -12,7 +12,7 @@ namespace CommunityToolkit.Datasync.Client.Query;
 /// Represents a query that can be evaluated against an OData table.
 /// </summary>
 /// <remarks>
-/// Rather than implenting <see cref="IQueryable{T}"/> directly, we've implemented the portion of  the LINQ query
+/// Rather than implementing <see cref="IQueryable{T}"/> directly, we've implemented the portion of  the LINQ query
 /// pattern we support on a datasync service.  You can use the <see cref="IDatasyncQueryable{TEntity}"/> instance
 /// to build up a query using normal LINQ patterns.
 /// </remarks>
@@ -76,7 +76,7 @@ public IDatasyncQueryable<TEntity> IncludeDeletedItems(bool enabled = true)
     /// Ensure the query will get the total count for all the records that would have been returned
     /// ignoring any take paging/limit clause specified by client or server.
     /// </summary>
-    /// <param name="enabled">If <c>true</c>, enables this requst.</param>
+    /// <param name="enabled">If <c>true</c>, enables this request.</param>
     /// <returns>The composed query object.</returns>
     public IDatasyncQueryable<TEntity> IncludeTotalCount(bool enabled = true)
     {

src/CommunityToolkit.Datasync.Client/Query/IDatasyncPullQuery.cs

@@ -10,7 +10,7 @@ namespace CommunityToolkit.Datasync.Client.Offline;
 /// Represents a query that can be evaluated against an OData table for pull operations.
 /// </summary>
 /// <remarks>
-/// Rather than implenting <see cref="IQueryable{T}"/> directly, we've implemented the portion of the LINQ query
+/// Rather than implementing <see cref="IQueryable{T}"/> directly, we've implemented the portion of the LINQ query
 /// pattern we support on a datasync service.  You can use the <see cref="IDatasyncQueryable{TEntity}"/>
 /// instance to build up a query using normal LINQ patterns.
 /// </remarks>

src/CommunityToolkit.Datasync.Client/Query/IDatasyncQueryMethods.cs

@@ -24,7 +24,7 @@ public interface IDatasyncQueryMethods<TEntity> where TEntity : class
     /// Ensure the query will get the total count for all the records that would have been returned
     /// ignoring any take paging/limit clause specified by client or server.
     /// </summary>
-    /// <param name="enabled">If <c>true</c>, enables this requst.</param>
+    /// <param name="enabled">If <c>true</c>, enables this request.</param>
     /// <returns>The composed query object.</returns>
     IDatasyncQueryable<TEntity> IncludeTotalCount(bool enabled = true);
 

src/CommunityToolkit.Datasync.Client/Query/IDatasyncQueryable.cs

@@ -10,7 +10,7 @@ namespace CommunityToolkit.Datasync.Client;
 /// Represents a query that can be evaluated against an OData table.
 /// </summary>
 /// <remarks>
-/// Rather than implenting <see cref="IQueryable{T}"/> directly, we've implemented the portion of the LINQ query
+/// Rather than implementing <see cref="IQueryable{T}"/> directly, we've implemented the portion of the LINQ query
 /// pattern we support on a datasync service.  You can use the <see cref="IDatasyncQueryable{TEntity}"/>
 /// instance to build up a query using normal LINQ patterns.
 /// </remarks>

src/CommunityToolkit.Datasync.Client/Query/Linq/ExpressionExtensions.cs

@@ -27,7 +27,7 @@ internal static List<Expression> FindIndependentSubtrees(this Expression express
     {
         List<Expression> subtrees = [];
 
-        // The dependenty and isMemberInit flags are used to communicate between different layers
+        // The dependent and isMemberInit flags are used to communicate between different layers
         // of the recursive visitor.
         bool dependent = false;
         bool isMemberInit = false;
@@ -50,7 +50,7 @@ internal static List<Expression> FindIndependentSubtrees(this Expression express
                 // If nothing in my subtree is dependent
                 if (!dependent)
                 {
-                    // A NewExpression itself will appear to be indepentt, but if the parent is a MemberInitExpression,
+                    // A NewExpression itself will appear to be independent, but if the parent is a MemberInitExpression,
                     // then the NewExpression can't be evaluated by itself.  The MemberInitExpression will determine
                     // if the full expression is dependent or not, so don't check it here.
                     if (expr is NewExpression newExpression && parentIsMemberInit)

src/CommunityToolkit.Datasync.Client/Query/Linq/QueryNodes.cs

@@ -183,7 +183,7 @@ internal sealed class MemberAccessNode(QueryNode instance, string memberName) :
     public override QueryNodeKind Kind => QueryNodeKind.MemberAccess;
 
     /// <summary>
-    /// The name of the member (property, field, etc.) we are acccessing
+    /// The name of the member (property, field, etc.) we are accessing
     /// </summary>
     public string MemberName { get; set; } = memberName;
 }

src/CommunityToolkit.Datasync.Client/Query/Linq/QueryTranslator.cs

@@ -63,7 +63,7 @@ internal QueryTranslator(IDatasyncPullQuery<T> query)
     internal JsonNamingPolicy NamingPolicy { get; }
 
     /// <summary>
-    /// Replacable function for GetTableMemberName.
+    /// Replaceable function for GetTableMemberName.
     /// </summary>
     internal Func<MemberExpression, JsonNamingPolicy, string> GetTableMemberName { get; set; } = DefaultGetTableMemberName;
 
@@ -146,7 +146,7 @@ internal void AddByMethodName(MethodCallExpression expression, string methodName
                 break;
 
             default:
-                throw new NotSupportedException($"'{methodName}' caluse in query expression is not supported.");
+                throw new NotSupportedException($"'{methodName}' clause in query expression is not supported.");
         }
     }
 

src/CommunityToolkit.Datasync.Client/Query/Linq/VisitorHelper.cs

@@ -31,7 +31,7 @@ internal sealed class VisitorHelper : ExpressionVisitor
     /// <summary>
     /// A visitor callback for the VisitMember method that takes the
     /// MemberExpression along with a function that will recurse and
-    /// returns the visisted expression or a modified value.
+    /// returns the visited expression or a modified value.
     /// </summary>
     private Func<MemberExpression, Func<MemberExpression, Expression>, Expression> memberVisitor;
 
@@ -82,7 +82,7 @@ public static Expression VisitMembers(Expression expression, Func<MemberExpressi
     /// Visit every node.
     /// </summary>
     /// <param name="expression">The expression to visit.</param>
-    /// <returns>The visisted expression.</returns>
+    /// <returns>The visited expression.</returns>
     [ExcludeFromCodeCoverage]
     public override Expression Visit(Expression expression)
         => this.visitor != null ? this.visitor(expression, e => base.Visit(e)) : base.Visit(expression);

src/CommunityToolkit.Datasync.Client/Service/DatasyncServiceClient.cs

@@ -221,7 +221,7 @@ public IDatasyncQueryable<TEntity> IncludeDeletedItems(bool enabled = true)
     /// Ensure the query will get the total count for all the records that would have been returned
     /// ignoring any take paging/limit clause specified by client or server.
     /// </summary>
-    /// <param name="enabled">If <c>true</c>, enables this requst.</param>
+    /// <param name="enabled">If <c>true</c>, enables this request.</param>
     /// <returns>The composed query object.</returns>
     public IDatasyncQueryable<TEntity> IncludeTotalCount(bool enabled = true)
         => AsQueryable().IncludeTotalCount(enabled);

src/CommunityToolkit.Datasync.Server.Abstractions/Exceptions/HttpException.cs

@@ -16,7 +16,7 @@ public class HttpException : DatasyncToolkitException
     /// <summary>
     /// Initializes a new instance of the <see cref="HttpException"/> class.
     /// </summary>
-    /// <param name="statusCode">The HTTP status code to use when responding to the cleint.</param>
+    /// <param name="statusCode">The HTTP status code to use when responding to the client.</param>
     public HttpException(int statusCode) : base()
     {
         StatusCode = statusCode;

src/CommunityToolkit.Datasync.Server.InMemory/InMemoryRepository.cs

@@ -60,7 +60,7 @@ public InMemoryRepository(IEnumerable<TEntity> entities)
     internal List<TEntity> GetEntities() => [.. this._entities.Values];
 
     /// <summary>
-    /// Clears the repository of all entities so that tests are predicatable.
+    /// Clears the repository of all entities so that tests are predictable.
     /// </summary>
     internal void Clear() => this._entities.Clear();
     #endregion

src/CommunityToolkit.Datasync.Server.LiteDb/LiteDbRepository.cs

@@ -22,7 +22,7 @@ public class LiteDbRepository<TEntity> : IRepository<TEntity> where TEntity : Li
     private readonly static SemaphoreSlim semaphore = new(1, 1);
 
     /// <summary>
-    /// Creates a new <see cref="LiteDbRepository{TEntity}"/> usign the provided database connection.
+    /// Creates a new <see cref="LiteDbRepository{TEntity}"/> using the provided database connection.
     /// </summary>
     /// <remarks>
     /// The collection name is based on the entity type.

src/CommunityToolkit.Datasync.Server.NSwag/OpenApiExtensions.cs

@@ -44,7 +44,7 @@ internal static bool ContainsRequestHeader(this OpenApiOperation operation, stri
     /// <param name="operation">The <see cref="OpenApiOperation"/> to edit.</param>
     /// <param name="statusCode">The HTTP status code to add.</param>
     /// <param name="schema">The <see cref="JsonSchema"/> for the response content.</param>
-    /// <param name="includeETagHeader">If <c>true</c>, incude the <c>ETag</c> header description.</param>
+    /// <param name="includeETagHeader">If <c>true</c>, include the <c>ETag</c> header description.</param>
     internal static void SetResponse(this OpenApiOperation operation, HttpStatusCode statusCode, JsonSchema? schema = null, bool includeETagHeader = true)
     {
         int statusId = (int)statusCode;

src/CommunityToolkit.Datasync.Server.Swashbuckle/DatasyncDocumentFilter.cs

@@ -12,7 +12,7 @@
 namespace CommunityToolkit.Datasync.Server.Swashbuckle;
 
 /// <summary>
-/// An <see cref="IDocumentFilter"/> that adds the relevant schema and paramter definitions
+/// An <see cref="IDocumentFilter"/> that adds the relevant schema and parameter definitions
 /// to generate an OpenAPI v3.0.3 definition for Datasync <see cref="TableController{TEntity}"/>
 /// controllers.
 /// </summary>

src/CommunityToolkit.Datasync.Server/Controllers/TableController.cs

@@ -171,7 +171,7 @@ protected virtual async ValueTask AuthorizeRequestAsync(TableOperation operation
     /// <param name="operation">The operation being performed.</param>
     /// <param name="entity">The entity that was updated (except for a hard-delete, which is the entity before deletion)</param>
     /// <param name="cancellationToken">A <see cref="CancellationToken"/> to observe.</param>
-    /// <returns>A taks the completes when the post-commit hook has been called.</returns>
+    /// <returns>A task the completes when the post-commit hook has been called.</returns>
     [NonAction]
     protected virtual ValueTask PostCommitHookAsync(TableOperation operation, TEntity entity, CancellationToken cancellationToken = default)
     {

src/CommunityToolkit.Datasync.Server/Extensions/InternalExtensions.cs

@@ -161,7 +161,7 @@ internal static void SetConditionalHeaders(this IHeaderDictionary headers, ITabl
     /// be "in view".
     /// </summary>
     /// <param name="request">The <see cref="HttpRequest"/> being processed.</param>
-    /// <returns><c>true</c> if deleted items shoudl be considered "in view"; <c>false</c> otherwise.</returns>
+    /// <returns><c>true</c> if deleted items should be considered "in view"; <c>false</c> otherwise.</returns>
     internal static bool ShouldIncludeDeletedEntities(this HttpRequest request)
     {
         if (request.Query.TryGetValue(IncludeDeletedParameterName, out StringValues deletedQueryParameter))
@@ -173,7 +173,7 @@ internal static bool ShouldIncludeDeletedEntities(this HttpRequest request)
     }
 
     /// <summary>
-    /// Convertes the provided ETag into a byte array.
+    /// Converts the provided ETag into a byte array.
     /// </summary>
     /// <param name="etag">The ETag to convert.</param>
     /// <returns>The ETag converted to a byte array.</returns>