fix: addressed pr comments

Author: mrnkr

.gitignore

@@ -40,7 +40,7 @@ bld/
 # Visual Studio 2017 auto generated files
 Generated\ Files/
 
-# MTest test Results
+# MSTest test Results
 [Tt]est[Rr]esult*/
 [Bb]uild[Ll]og.*
 

README.md

@@ -1,9 +1,13 @@
 # JsonApiDotNetCore MongoDB Repository
 
-Plug-n-play implementation of `IResourceRepository<TResource, TId>` allowing you to use MongoDb with your `JsonApiDotNetCore` APIs.
+Plug-n-play implementation of `IResourceRepository<TResource, TId>` allowing you to use MongoDB with your `JsonApiDotNetCore` APIs.
 
 ## Installation and Usage
 
+```bash
+dotnet add package JsonApiDotNetCore.MongoDb
+```
+
 ### Models
 
 ```cs
@@ -47,30 +51,23 @@ public class Startup
             return client.GetDatabase(Configuration.GetSection("DatabaseSettings:Database").Value);
         });
 
-        services.AddScoped<IResourceRepository<Book, string>, MongoEntityRepository<Book, string>>();
-        services.AddJsonApi(options =>
-        {
-            options.Namespace = "api";
-            options.UseRelativeLinks = true;
-            options.IncludeTotalResourceCount = true;
-            options.SerializerSettings.Formatting = Formatting.Indented;
-        }, resources: builder =>
+        services.AddResourceRepository<MongoDbRepository<Book>>();
+        
+        services.AddJsonApi(resources: builder =>
         {
             builder.Add<Book, string>();
         });
-        // ...
     }
 
     public void Configure(IApplicationBuilder app)
     {
         app.UseRouting();
         app.UseJsonApi();
         app.UseEndpoints(endpoints => endpoints.MapControllers());
-        // ...
     }
 }
 ```
 
 ## Limitations
 
-- Relations are not supported
+- Relationships are not supported

src/JsonApiDotNetCore.MongoDb/AssemblyInfo.cs

@@ -1,14 +1,14 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <VersionPrefix>4.0.0-rc</VersionPrefix>
+    <VersionPrefix>4.0.0</VersionPrefix>
     <TargetFramework>$(NetCoreAppVersion)</TargetFramework>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
   </PropertyGroup>
 
   <PropertyGroup>
     <PackageTags>jsonapi;json:api;dotnet;core;MongoDB</PackageTags>
-    <Description>Persistence layer implementation for use of mongodb in applications using JsonApiDotNetCore</Description>
+    <Description>Persistence layer implementation for use of MongoDB in applications using JsonApiDotNetCore</Description>
     <PackageProjectUrl>https://github.com/json-api-dotnet/JsonApiDotNetCore.MongoDb</PackageProjectUrl>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>

src/JsonApiDotNetCore.MongoDb/Extensions/MongoIQueryableExtensions.cs

@@ -4,7 +4,6 @@
 using System.Threading;
 using System.Threading.Tasks;
 using JsonApiDotNetCore.Configuration;
-using JsonApiDotNetCore.MongoDb.Extensions;
 using JsonApiDotNetCore.Queries.Internal.QueryableBuilding;
 using JsonApiDotNetCore.Repositories;
 using JsonApiDotNetCore.Resources;
@@ -17,33 +16,42 @@
 
 namespace JsonApiDotNetCore.MongoDb
 {
-    public class MongoEntityRepository<TResource, TId>
+    /// <summary>
+    /// Implements the foundational Repository layer in the JsonApiDotNetCore architecture that uses MongoDB.
+    /// </summary>
+    public class MongoDbRepository<TResource, TId>
         : IResourceRepository<TResource, TId>
         where TResource : class, IIdentifiable<TId>
     {
-        private readonly IMongoDatabase _db;
+        private readonly IMongoDatabase _mongoDatabase;
         private readonly ITargetedFields _targetedFields;
         private readonly IResourceContextProvider _resourceContextProvider;
         private readonly IResourceFactory _resourceFactory;
 
-        public MongoEntityRepository(
-            IMongoDatabase db,
+        public MongoDbRepository(
+            IMongoDatabase mongoDatabase,
             ITargetedFields targetedFields,
             IResourceContextProvider resourceContextProvider,
             IResourceFactory resourceFactory)
         {
-            _db = db;
-            _targetedFields = targetedFields;
-            _resourceContextProvider = resourceContextProvider;
-            _resourceFactory = resourceFactory;
+            _mongoDatabase = mongoDatabase ?? throw new ArgumentNullException(nameof(mongoDatabase));
+            _targetedFields = targetedFields ?? throw new ArgumentNullException(nameof(targetedFields));
+            _resourceContextProvider = resourceContextProvider ?? throw new ArgumentNullException(nameof(resourceContextProvider));
+            _resourceFactory = resourceFactory ?? throw new ArgumentNullException(nameof(resourceFactory));
         }
 
-        private IMongoCollection<TResource> Collection => _db.GetCollection<TResource>(typeof(TResource).Name);
-        private IMongoQueryable<TResource> Entities => Collection.AsQueryable();
+        protected virtual IMongoCollection<TResource> Collection => _mongoDatabase.GetCollection<TResource>(typeof(TResource).Name);
 
-        public virtual async Task<IReadOnlyCollection<TResource>> GetAsync(QueryLayer layer, CancellationToken cancellationToken) =>
-            await ApplyQueryLayer(layer).ToListAsync();
+        /// <inheritdoc />
+        public virtual async Task<IReadOnlyCollection<TResource>> GetAsync(QueryLayer layer,
+            CancellationToken cancellationToken)
+        {
+            if (layer == null) throw new ArgumentNullException(nameof(layer));
+            var list = await ApplyQueryLayer(layer).ToListAsync(cancellationToken);
+            return list.AsReadOnly();
+        }
 
+        /// <inheritdoc />
         public virtual Task<int> CountAsync(FilterExpression topFilter, CancellationToken cancellationToken)
         {
             var resourceContext = _resourceContextProvider.GetResourceContext<TResource>();
@@ -55,7 +63,33 @@ public virtual Task<int> CountAsync(FilterExpression topFilter, CancellationToke
             var query = ApplyQueryLayer(layer);
             return query.CountAsync(cancellationToken);
         }
+        
+        protected virtual IMongoQueryable<TResource> ApplyQueryLayer(QueryLayer layer)
+        {
+            if (layer == null) throw new ArgumentNullException(nameof(layer));
+            
+            var source = GetAll();
 
+            var nameFactory = new LambdaParameterNameFactory();
+            var builder = new QueryableBuilder(
+                source.Expression,
+                source.ElementType,
+                typeof(Queryable),
+                nameFactory,
+                _resourceFactory,
+                _resourceContextProvider,
+                DummyModel.Instance);
+
+            var expression = builder.ApplyQuery(layer);
+            return (IMongoQueryable<TResource>)source.Provider.CreateQuery<TResource>(expression);
+        }
+        
+        protected virtual IQueryable<TResource> GetAll()
+        {
+            return Collection.AsQueryable();
+        }
+
+        /// <inheritdoc />
         public virtual Task<TResource> GetForCreateAsync(TId id, CancellationToken cancellationToken)
         {
             var resource = _resourceFactory.CreateInstance<TResource>();
@@ -64,6 +98,7 @@ public virtual Task<TResource> GetForCreateAsync(TId id, CancellationToken cance
             return Task.FromResult(resource);
         }
 
+        /// <inheritdoc />
         public virtual Task CreateAsync(TResource resourceFromRequest, TResource resourceForDatabase,
             CancellationToken cancellationToken)
         {
@@ -78,76 +113,91 @@ public virtual Task CreateAsync(TResource resourceFromRequest, TResource resourc
             return Collection.InsertOneAsync(resourceForDatabase, new InsertOneOptions(), cancellationToken);
         }
 
+        /// <inheritdoc />
         public virtual async Task<TResource> GetForUpdateAsync(QueryLayer queryLayer, CancellationToken cancellationToken)
         {
             var resources = await GetAsync(queryLayer, cancellationToken);
             return resources.FirstOrDefault();
         }
 
-        public virtual async Task UpdateAsync(TResource requestResource, TResource databaseResource, CancellationToken cancellationToken)
+        /// <inheritdoc />
+        public virtual async Task UpdateAsync(TResource resourceFromRequest, TResource resourceFromDatabase, CancellationToken cancellationToken)
         {
+            if (resourceFromRequest == null) throw new ArgumentNullException(nameof(resourceFromRequest));
+            if (resourceFromDatabase == null) throw new ArgumentNullException(nameof(resourceFromDatabase));
+            
             foreach (var attr in _targetedFields.Attributes)
-                attr.SetValue(databaseResource, attr.GetValue(requestResource));
+                attr.SetValue(resourceFromDatabase, attr.GetValue(resourceFromRequest));
 
             await Collection.ReplaceOneAsync(
-                Builders<TResource>.Filter.Eq(e => e.Id, databaseResource.Id),
-                databaseResource,
+                Builders<TResource>.Filter.Eq(e => e.Id, resourceFromDatabase.Id),
+                resourceFromDatabase,
                 new ReplaceOptions(),
                 cancellationToken);
         }
 
+        /// <inheritdoc />
         public virtual async Task DeleteAsync(TId id, CancellationToken cancellationToken)
         {
             var result = await Collection.DeleteOneAsync(
                 Builders<TResource>.Filter.Eq(e => e.Id, id),
                 new DeleteOptions(),
                 cancellationToken);
 
-            if (!result.IsAcknowledged || result.DeletedCount == 0)
+            if (!result.IsAcknowledged)
             {
-                throw new DataStoreUpdateException(new Exception());
+                throw new DataStoreUpdateException(new Exception("Delete operation was not acknowledged by MongoDB"));
+            }
+
+            if (result.DeletedCount == 0)
+            {
+                throw new DataStoreUpdateException(new Exception($"No documents were deleted. The id that was being sought was: {id}"));
             }
         }
 
+        /// <inheritdoc />
         public virtual Task SetRelationshipAsync(TResource primaryResource, object secondaryResourceIds, CancellationToken cancellationToken)
         {
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc />
         public virtual Task AddToToManyRelationshipAsync(TId primaryId, ISet<IIdentifiable> secondaryResourceIds, CancellationToken cancellationToken)
         {
             throw new NotImplementedException();
         }
 
-        public virtual Task RemoveFromToManyRelationshipAsync(TResource primaryResource, ISet<IIdentifiable> secondaryResourceIds,
+        /// <inheritdoc />
+        public virtual Task RemoveFromToManyRelationshipAsync(TResource primaryResource,
+            ISet<IIdentifiable> secondaryResourceIds,
             CancellationToken cancellationToken)
         {
             throw new NotImplementedException();
         }
-
-        protected virtual IMongoQueryable<TResource> ApplyQueryLayer(QueryLayer layer)
+    }
+    
+    /// <summary>
+    /// Implements the foundational repository implementation that uses MongoDB.
+    /// </summary>
+    public class MongoDbRepository<TResource> : MongoDbRepository<TResource, string>
+        where TResource : class, IIdentifiable<string>
+    {
+        public MongoDbRepository(
+            IMongoDatabase mongoDatabase,
+            ITargetedFields targetedFields,
+            IResourceContextProvider resourceContextProvider,
+            IResourceFactory resourceFactory)
+            : base(mongoDatabase, targetedFields, resourceContextProvider, resourceFactory)
         {
-            var source = Entities;
-
-            var nameFactory = new LambdaParameterNameFactory();
-            var builder = new QueryableBuilder(
-                source.Expression,
-                source.ElementType,
-                typeof(Queryable),
-                nameFactory,
-                _resourceFactory,
-                _resourceContextProvider,
-                DummyModel.Instance);
-
-            var expression = builder.ApplyQuery(layer);
-            return (IMongoQueryable<TResource>)source.Provider.CreateQuery<TResource>(expression);
         }
     }
 
     internal sealed class DummyModel : IModel
     {
         public static IModel Instance { get; } = new DummyModel();
 
+        public object this[string name] => throw new NotImplementedException();
+        
         private DummyModel()
         {
         }
@@ -162,8 +212,6 @@ public IEnumerable<IAnnotation> GetAnnotations()
             throw new NotImplementedException();
         }
 
-        public object this[string name] => throw new NotImplementedException();
-
         public IEnumerable<IEntityType> GetEntityTypes()
         {
             throw new NotImplementedException();