Refactor on repository and add mutations

src/GraphQL.API.Tests/QueryTests.cs

@@ -27,7 +27,7 @@ public async void Query_ReturnsProducts()
                 .AddScoped<ICategoryRepository, CategoryRepository>() // Should be mocked
                 .AddScoped<IProductRepository, ProductRepository>() // Should be mocked
                 .AddGraphQL()
-                .AddQueryType<Query>()
+                .AddQueryType<ProductQuery>()
                 .AddType<ProductType>()
                 .AddType<CategoryResolver>()
                 .BuildRequestExecutorAsync();

src/GraphQL.API/Mutations/CategoryMutation.cs

@@ -0,0 +1,10 @@
+namespace GraphQL.API.Mutations
+{
+    using HotChocolate.Types;
+
+    [ExtendObjectType(Name = "Mutation")]
+    public class CategoryMutation
+    {
+        // TODO: Create methods
+    }
+}

src/GraphQL.API/Mutations/ProductMutation.cs

@@ -0,0 +1,18 @@
+namespace GraphQL.API.Mutations
+{
+    using GraphQL.Core.Entities;
+    using GraphQL.Core.Repositories;
+    using HotChocolate;
+    using HotChocolate.Types;
+    using System.Threading.Tasks;
+
+    [ExtendObjectType(Name = "Mutation")]
+    public class ProductMutation
+    {
+        public Task<Product> CreateProductAsync(Product product, [Service] IProductRepository productRepository) =>
+            productRepository.InsertAsync(product);
+
+        public Task<bool> RemoveProductAsync(string id, [Service] IProductRepository productRepository) =>
+            productRepository.RemoveAsync(id);
+    }
+}

src/GraphQL.API/Queries/CategoryQuery.cs

@@ -0,0 +1,14 @@
+namespace GraphQL.API.Queries
+{
+    using HotChocolate.Types;
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Threading.Tasks;
+
+    [ExtendObjectType(Name = "Query")]
+    public class CategoryQuery
+    {
+        // Create methods
+    }
+}

src/GraphQL.API/Queries/Query.cs → src/GraphQL.API/Queries/ProductQuery.cs

@@ -6,12 +6,12 @@
     using System.Collections.Generic;
     using System.Threading.Tasks;
 
-    public class Query
+    public class ProductQuery
     {
         public Task<IEnumerable<Product>> GetProductsAsync([Service] IProductRepository productRepository) =>
             productRepository.GetAllAsync();
 
-        public Task<Product> GetProductById(string id, [Service] IProductRepository productRepository) =>
+        public Task<Product> GetProductByIdAsync(string id, [Service] IProductRepository productRepository) =>
             productRepository.GetByIdAsync(id);
 
         // Add any queries you want here..

src/GraphQL.API/Resolvers/CategoryResolver.cs

@@ -9,6 +9,7 @@
     [ExtendObjectType(Name = "Category")]
     public class CategoryResolver
     {
-        public Task<Category> GetCategoryAsync([Parent] Product product, [Service] ICategoryRepository categoryRepository) => categoryRepository.GetById(product.CategoryId);
+        public Task<Category> GetCategoryAsync([Parent] Product product, [Service] ICategoryRepository categoryRepository) =>
+            categoryRepository.GetByIdAsync(product.CategoryId);
     }
 }

src/GraphQL.API/Startup.cs

@@ -1,6 +1,7 @@
 namespace GraphQL.API
 {
     using GraphQL.API.Configurations;
+    using GraphQL.API.Mutations;
     using GraphQL.API.Queries;
     using GraphQL.API.Resolvers;
     using GraphQL.API.Types;
@@ -30,13 +31,19 @@ public void ConfigureServices(IServiceCollection services)
 
             // Repositories
             services.AddSingleton<ICatalogContext, CatalogContext>();
+            services.AddScoped(typeof(IBaseRepository<>), typeof(BaseRepository<>));
             services.AddScoped<ICategoryRepository, CategoryRepository>();
             services.AddScoped<IProductRepository, ProductRepository>();
 
             // GraphQL
             services
                 .AddGraphQLServer()
-                .AddQueryType<Query>()
+                .AddQueryType(d => d.Name("Query"))
+                    .AddTypeExtension<ProductQuery>()
+                    .AddTypeExtension<CategoryQuery>()
+                .AddMutationType(d => d.Name("Mutation"))
+                    .AddTypeExtension<ProductMutation>()
+                    .AddTypeExtension<CategoryMutation>()
                 .AddType<ProductType>()
                 .AddType<CategoryResolver>();
         }

src/GraphQL.Core/Entities/Category.cs

@@ -1,13 +1,7 @@
 namespace GraphQL.Core.Entities
 {
-    using MongoDB.Bson;
-    using MongoDB.Bson.Serialization.Attributes;
-
-    public class Category
+    public class Category : EntityBase
     {
-        [BsonId]
-        [BsonRepresentation(BsonType.ObjectId)]
-        public string Id { get; set; }
         public string Description { get; set; }
     }
 }

src/GraphQL.Core/Entities/EntityBase.cs

@@ -0,0 +1,12 @@
+namespace GraphQL.Core.Entities
+{
+    using MongoDB.Bson;
+    using MongoDB.Bson.Serialization.Attributes;
+
+    public class EntityBase
+    {
+        [BsonId]
+        [BsonRepresentation(BsonType.ObjectId)]
+        public string Id { get; set; }
+    }
+}

src/GraphQL.Core/Entities/Product.cs

@@ -1,13 +1,7 @@
 namespace GraphQL.Core.Entities
 {
-    using MongoDB.Bson;
-    using MongoDB.Bson.Serialization.Attributes;
-
-    public class Product
+    public class Product : EntityBase
     {
-        [BsonId]
-        [BsonRepresentation(BsonType.ObjectId)]
-        public string Id { get; set; }
         public string Name { get; set; }
         public string Description { get; set; }
         public decimal Price { get; set; }

src/GraphQL.Core/Repositories/IBaseRepository.cs

@@ -0,0 +1,14 @@
+namespace GraphQL.Core.Repositories
+{
+    using GraphQL.Core.Entities;
+    using System.Collections.Generic;
+    using System.Threading.Tasks;
+
+    public interface IBaseRepository<T> where T : EntityBase
+    {
+        Task<IEnumerable<T>> GetAllAsync();
+        Task<T> GetByIdAsync(string id);
+        Task<T> InsertAsync(T entity);
+        Task<bool> RemoveAsync(string id);
+    }
+}

src/GraphQL.Core/Repositories/ICategoryRepository.cs

@@ -1,10 +1,9 @@
 namespace GraphQL.Core.Repositories
 {
     using GraphQL.Core.Entities;
-    using System.Threading.Tasks;
 
-    public interface ICategoryRepository
+    public interface ICategoryRepository : IBaseRepository<Category>
     {
-        Task<Category> GetById(string id);
+
     }
 }

src/GraphQL.Core/Repositories/IProductRepository.cs

@@ -1,12 +1,9 @@
 namespace GraphQL.Core.Repositories
 {
     using GraphQL.Core.Entities;
-    using System.Collections.Generic;
-    using System.Threading.Tasks;
 
-    public interface IProductRepository
+    public interface IProductRepository : IBaseRepository<Product>
     {
-        Task<IEnumerable<Product>> GetAllAsync();
-        Task<Product> GetByIdAsync(string id);
+
     }
 }

src/GraphQL.Infrastructure/Data/CatalogContext.cs

@@ -1,26 +1,24 @@
 namespace GraphQL.Infrastructure.Data
 {
-    using GraphQL.Core.Entities;
     using GraphQL.Infrastructure.Configurations;
     using MongoDB.Driver;
 
     public class CatalogContext : ICatalogContext
     {
-        private const string ProductCollectionName = "Products";
-        private const string CategoryCollectionName = "Categories";
+        private readonly IMongoDatabase database;
 
         public CatalogContext(MongoDbConfiguration mongoDbConfiguration)
         {
             var client = new MongoClient(mongoDbConfiguration.ConnectionString);
-            var database = client.GetDatabase(mongoDbConfiguration.Database);
 
-            this.Categories = database.GetCollection<Category>(CategoryCollectionName);
-            this.Products = database.GetCollection<Product>(ProductCollectionName);
+            this.database = client.GetDatabase(mongoDbConfiguration.Database);
 
-            CatalogContextSeed.SeedData(this.Categories, this.Products);
+            CatalogContextSeed.SeedData(this.database);
         }
 
-        public IMongoCollection<Category> Categories { get; }
-        public IMongoCollection<Product> Products { get; }
+        public IMongoCollection<T> GetCollection<T>(string name)
+        {
+            return this.database.GetCollection<T>(name);
+        }
     }
 }

src/GraphQL.Infrastructure/Data/CatalogContextSeed.cs

@@ -6,12 +6,10 @@
 
     public class CatalogContextSeed
     {
-        public static void SeedData(
-            IMongoCollection<Category> categoryCollection,
-            IMongoCollection<Product> productCollection)
+        public static void SeedData(IMongoDatabase database)
         {
-            InsertCategories(categoryCollection);
-            InsertProducts(productCollection);
+            InsertCategories(database.GetCollection<Category>(nameof(Category)));
+            InsertProducts(database.GetCollection<Product>(nameof(Product)));
         }
 
         private static void InsertCategories(IMongoCollection<Category> categoryCollection)

src/GraphQL.Infrastructure/Data/ICatalogContext.cs

@@ -1,11 +1,9 @@
 namespace GraphQL.Infrastructure.Data
 {
-    using GraphQL.Core.Entities;
     using MongoDB.Driver;
 
     public interface ICatalogContext
     {
-        IMongoCollection<Category> Categories { get; }
-        IMongoCollection<Product> Products { get; }
+        IMongoCollection<T> GetCollection<T>(string name);
     }
 }

src/GraphQL.Infrastructure/Repositories/BaseRepository.cs

@@ -0,0 +1,51 @@
+namespace GraphQL.Infrastructure.Repositories
+{
+    using GraphQL.Core.Entities;
+    using GraphQL.Core.Repositories;
+    using GraphQL.Infrastructure.Data;
+    using MongoDB.Driver;
+    using System;
+    using System.Collections.Generic;
+    using System.Threading.Tasks;
+
+    public class BaseRepository<T> : IBaseRepository<T> where T : EntityBase
+    {
+        private readonly IMongoCollection<T> collection;
+
+        public BaseRepository(ICatalogContext catalogContext)
+        {
+            if (catalogContext == null)
+            {
+                throw new ArgumentNullException(nameof(catalogContext));
+            }
+
+            this.collection = catalogContext.GetCollection<T>(typeof(T).Name);
+        }
+
+        public async Task<IEnumerable<T>> GetAllAsync()
+        {
+            return await this.collection.Find(_ => true).ToListAsync();
+        }
+
+        public async Task<T> GetByIdAsync(string id)
+        {
+            var filter = Builders<T>.Filter.Eq(_ => _.Id, id);
+
+            return await this.collection.Find(filter).FirstOrDefaultAsync();
+        }
+
+        public async Task<T> InsertAsync(T entity)
+        {
+            await this.collection.InsertOneAsync(entity);
+
+            return entity;
+        }
+
+        public async Task<bool> RemoveAsync(string id)
+        {
+            var result = await this.collection.DeleteOneAsync(Builders<T>.Filter.Eq(_ => _.Id, id));
+
+            return result.DeletedCount > 0;
+        }
+    }
+}

src/GraphQL.Infrastructure/Repositories/CategoryRepository.cs

@@ -3,23 +3,12 @@
     using GraphQL.Core.Entities;
     using GraphQL.Core.Repositories;
     using GraphQL.Infrastructure.Data;
-    using MongoDB.Driver;
-    using System.Threading.Tasks;
 
-    public class CategoryRepository : ICategoryRepository
+    public class CategoryRepository : BaseRepository<Category>, ICategoryRepository
     {
-        private readonly ICatalogContext catalogContext;
-
-        public CategoryRepository(ICatalogContext catalogContext)
-        {
-            this.catalogContext = catalogContext;
-        }
-
-        public async Task<Category> GetById(string id)
+        public CategoryRepository(ICatalogContext catalogContext) : base(catalogContext)
         {
-            var filter = Builders<Category>.Filter.Eq(_ => _.Id, id);
 
-            return await this.catalogContext.Categories.Find(filter).FirstOrDefaultAsync();
         }
     }
 }

src/GraphQL.Infrastructure/Repositories/ProductRepository.cs

@@ -3,30 +3,12 @@
     using GraphQL.Core.Entities;
     using GraphQL.Core.Repositories;
     using GraphQL.Infrastructure.Data;
-    using MongoDB.Driver;
-    using System;
-    using System.Collections.Generic;
-    using System.Threading.Tasks;
 
-    public class ProductRepository : IProductRepository
+    public class ProductRepository : BaseRepository<Product>, IProductRepository
     {
-        private readonly ICatalogContext catalogContext;
-
-        public ProductRepository(ICatalogContext catalogContext)
-        {
-            this.catalogContext = catalogContext ?? throw new ArgumentNullException(nameof(catalogContext));
-        }
-
-        public async Task<IEnumerable<Product>> GetAllAsync()
-        {
-            return await this.catalogContext.Products.Find(_ => true).ToListAsync();
-        }
-
-        public async Task<Product> GetByIdAsync(string id)
+        public ProductRepository(ICatalogContext catalogContext) : base(catalogContext)
         {
-            var filter = Builders<Product>.Filter.Eq(_ => _.Id, id);
 
-            return await this.catalogContext.Products.Find(filter).FirstOrDefaultAsync();
         }
     }
 }