Merge pull request #149 from AntonioFalcao/feature/code-smells

Feature/code smells

Author: AntonioFalcaoJr

src/Dotnet5.GraphQL3.CrossCutting/Application.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+namespace Dotnet5.GraphQL3.CrossCutting
+{
+    public static class Application
+    {
+        public static string Prefix { get; } = Assembly.GetEntryAssembly()?.FullName?.Substring(0, 16);
+        public static IEnumerable<Assembly> Assemblies { get; } =
+            AppDomain.CurrentDomain.GetAssemblies().Where(assembly => assembly.FullName?.StartsWith(Prefix) ?? false);
+    }
+}

src/Dotnet5.GraphQL3.CrossCutting/Extensions/LocalAssemblyExtensions.cs

@@ -1,4 +1,4 @@
-using Dotnet5.GraphQL3.CrossCutting.Extensions;
+using Dotnet5.GraphQL3.CrossCutting;
 using Dotnet5.GraphQL3.Domain.Abstractions.Builders;
 using Microsoft.Extensions.DependencyInjection;
 using Scrutor;
@@ -8,12 +8,9 @@ namespace Dotnet5.GraphQL3.Domain.Abstractions.Extensions.DependencyInjection
     public static class ServiceCollectionExtensions
     {
         public static IServiceCollection AddBuilders(this IServiceCollection services)
-            => services.Scan(selector
-                => selector
-                    .FromApplicationDependencies(assembly
-                        => assembly.FullName?.StartsWith(assembly.GetEntryAssemblySuffix()) ?? default)
-                    .AddClasses(filter
-                        => filter.AssignableTo(typeof(IBuilder<,>)))
+            => services
+                .Scan(selector => selector.FromAssemblies(Application.Assemblies)
+                    .AddClasses(filter => filter.AssignableTo(typeof(IBuilder<,>)))
                     .UsingRegistrationStrategy(RegistrationStrategy.Skip)
                     .AsImplementedInterfaces()
                     .WithScopedLifetime());

src/Dotnet5.GraphQL3.Domain.Abstractions/Extensions/DependencyInjection/ServiceCollectionExtensions.cs

@@ -1,4 +1,4 @@
-using Dotnet5.GraphQL3.CrossCutting.Extensions;
+using Dotnet5.GraphQL3.CrossCutting;
 using Dotnet5.GraphQL3.Repositories.Abstractions.UnitsOfWork;
 using Microsoft.Extensions.DependencyInjection;
 using Scrutor;
@@ -8,12 +8,9 @@ namespace Dotnet5.GraphQL3.Repositories.Abstractions.Extensions.DependencyInject
     public static class ServiceCollectionExtensions
     {
         public static IServiceCollection AddRepositories(this IServiceCollection services)
-            => services.Scan(selector
-                => selector
-                    .FromApplicationDependencies(assembly
-                        => assembly.FullName?.StartsWith(assembly.GetEntryAssemblySuffix()) ?? default)
-                    .AddClasses(filter
-                        => filter.AssignableTo(typeof(IRepository<,>)))
+            => services
+                .Scan(selector => selector.FromAssemblies(Application.Assemblies)
+                    .AddClasses(filter => filter.AssignableTo(typeof(IRepository<,>)))
                     .UsingRegistrationStrategy(RegistrationStrategy.Skip)
                     .AsImplementedInterfaces()
                     .WithScopedLifetime());

src/Dotnet5.GraphQL3.Repositories.Abstractions/Extensions/DependencyInjection/ServiceCollectionExtensions.cs

@@ -14,24 +14,21 @@ public interface IRepository<TEntity, in TId>
         where TId : struct
     {
         TEntity Add(TEntity entity);
-        Task<TEntity> AddAsync(TEntity entity, CancellationToken cancellationToken = default);
+        Task<TEntity> AddAsync(TEntity entity, CancellationToken cancellationToken);
 
         void Delete(TId id);
         void Delete(TEntity entity);
-        Task DeleteAsync(TId id, CancellationToken cancellationToken = default);
+        Task DeleteAsync(TId id, CancellationToken cancellationToken);
+        Task DeleteAsync(TEntity entity, CancellationToken cancellationToken);
 
         bool Exists(TId id);
-        Task<bool> ExistsAsync(TId id, CancellationToken cancellationToken = default);
+        Task<bool> ExistsAsync(TId id, CancellationToken cancellationToken);
 
-        TEntity GetById(TId id, Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> include = default,
-            bool asTracking = default);
-
-        Task<TEntity> GetByIdAsync(TId id, CancellationToken cancellationToken,
-            Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> include = default,
-            bool asTracking = default);
+        TEntity GetById(TId id, Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> include = default, bool asTracking = default);
+        Task<TEntity> GetByIdAsync(TId id, CancellationToken cancellationToken, Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> include = default, bool asTracking = default);
 
         void Update(TEntity entity);
-        Task UpdateAsync(TEntity entity, CancellationToken cancellationToken = default);
+        Task UpdateAsync(TEntity entity, CancellationToken cancellationToken);
 
         PagedResult<TEntity> GetAll(
             PageParams pageParams,

src/Dotnet5.GraphQL3.Repositories.Abstractions/IRepository.cs

@@ -8,41 +8,41 @@ namespace Dotnet5.GraphQL3.Repositories.Abstractions.Pages
 {
     public class PagedResult<T>
     {
+        private readonly IReadOnlyCollection<T> _items;
         private readonly int _index;
-        private readonly IEnumerable<T> _items;
         private readonly int _size;
 
-        public PagedResult(IEnumerable<T> items, int index, int size)
+        public PagedResult(IReadOnlyCollection<T> items, int index, int size)
         {
             _items = items;
             _index = index;
             _size = size;
         }
 
-        public IEnumerable<T> Items
-            => _items.Take(_size);
+        public IReadOnlyCollection<T> Items
+            => _items.Take(_size).ToList();
 
         public PageInfo PageInfo
             => new()
             {
                 Current = _index, 
-                Size = Items.Count(), 
-                HasNext = _size < _items.Count(), 
+                Size = Items.Count, 
+                HasNext = _size < _items.Count, 
                 HasPrevious = _index > 1
             };
 
         public static async Task<PagedResult<T>> CreateAsync(IQueryable<T> source, PageParams pageParams, CancellationToken cancellationToken)
         {
             pageParams ??= new();
             var items = await ApplyPagination(source, pageParams).ToListAsync(cancellationToken);
-            return new PagedResult<T>(items, pageParams.Index, pageParams.Size);
+            return new(items, pageParams.Index, pageParams.Size);
         }
 
         public static PagedResult<T> Create(IQueryable<T> source, PageParams pageParams)
         {
             pageParams ??= new();
             var items = ApplyPagination(source, pageParams).ToList();
-            return new PagedResult<T>(items, pageParams.Index, pageParams.Size);
+            return new(items, pageParams.Index, pageParams.Size);
         }
 
         private static IQueryable<T> ApplyPagination(IQueryable<T> source, PageParams pageParams)

src/Dotnet5.GraphQL3.Repositories.Abstractions/Pages/PagedResult.cs

@@ -27,24 +27,31 @@ protected Repository(DbContext dbDbContext, IConfigurationProvider configuration
 
         public virtual void Delete(TId id)
         {
-            var entity = GetById(id);
+            var entity = GetById(id, asTracking: true);
             if (entity is null) return;
             _dbSet.Remove(entity);
         }
 
         public virtual void Delete(TEntity entity)
         {
             if (entity is null) return;
+            _dbSet.Attach(entity);
             _dbSet.Remove(entity);
         }
 
         public virtual async Task DeleteAsync(TId id, CancellationToken cancellationToken)
         {
-            var entity = await GetByIdAsync(id, cancellationToken);
+            var entity = await GetByIdAsync(id, cancellationToken, asTracking: true);
             if (entity is null) return;
             _dbSet.Remove(entity);
         }
 
+        public virtual async Task DeleteAsync(TEntity entity, CancellationToken cancellationToken)
+        {
+            if (entity is null) return;
+            await Task.Run(() => Delete(entity), cancellationToken);
+        }
+
         public virtual bool Exists(TId id)
             => _dbSet.Any(x => Equals(x.Id, id));
 
@@ -53,16 +60,18 @@ public virtual Task<bool> ExistsAsync(TId id, CancellationToken cancellationToke
 
         public virtual TEntity Add(TEntity entity)
         {
+            if (entity is null) return default;
             if (Exists(entity.Id)) return entity;
-            _dbSet.Add(entity);
-            return entity;
+            var entityEntry = _dbSet.Add(entity);
+            return entityEntry.Entity;
         }
 
         public virtual async Task<TEntity> AddAsync(TEntity entity, CancellationToken cancellationToken)
         {
+            if (entity is null) return default;
             if (await ExistsAsync(entity.Id, cancellationToken)) return entity;
-            await _dbSet.AddAsync(entity, cancellationToken);
-            return entity;
+            var entityEntry = await _dbSet.AddAsync(entity, cancellationToken);
+            return entityEntry.Entity;
         }
 
         public TEntity GetById(TId id, Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> include = default, bool asTracking = default)

src/Dotnet5.GraphQL3.Repositories.Abstractions/Repository.cs

@@ -9,11 +9,11 @@ public interface IUnitOfWork : IDisposable
     {
         IDbContextTransaction BeginTransaction();
         Task<IDbContextTransaction> BeginTransactionAsync(CancellationToken cancellationToken);
-        void Commit();
-        Task CommitAsync(CancellationToken cancellationToken);
-        void Rollback();
-        Task RollbackAsync(CancellationToken cancellationToken);
-        void SaveChanges();
-        Task SaveChangesAsync(CancellationToken cancellationToken);
+        void CommitTransaction();
+        Task CommitTransactionAsync(CancellationToken cancellationToken);
+        void RollbackTransaction();
+        Task RollbackTransactionAsync(CancellationToken cancellationToken);
+        bool SaveChanges();
+        Task<bool> SaveChangesAsync(CancellationToken cancellationToken);
     }
 }

src/Dotnet5.GraphQL3.Repositories.Abstractions/UnitsOfWork/IUnitOfWork.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.EntityFrameworkCore;
@@ -20,28 +21,31 @@ public UnitOfWork(DbContext dbContext)
         public IDbContextTransaction BeginTransaction()
             => _database.BeginTransaction();
 
-        public Task<IDbContextTransaction> BeginTransactionAsync(CancellationToken cancellationToken)
-            => _database.BeginTransactionAsync(cancellationToken);
+        public async Task<IDbContextTransaction> BeginTransactionAsync(CancellationToken cancellationToken)
+            => await _database.BeginTransactionAsync(cancellationToken);
 
-        public void SaveChanges()
-            => _dbContext.SaveChanges(true);
+        public bool SaveChanges()
+            => _dbContext.SaveChanges(true) > default(int);
 
-        public Task SaveChangesAsync(CancellationToken cancellationToken)
-            => _dbContext.SaveChangesAsync(true, cancellationToken);
+        public async Task<bool> SaveChangesAsync(CancellationToken cancellationToken)
+            => await _dbContext.SaveChangesAsync(true, cancellationToken) > default(int);
 
-        public void Commit()
+        public void CommitTransaction()
             => _database.CommitTransaction();
 
-        public Task CommitAsync(CancellationToken cancellationToken)
-            => _database.CommitTransactionAsync(cancellationToken);
+        public async Task CommitTransactionAsync(CancellationToken cancellationToken)
+            => await _database.CommitTransactionAsync(cancellationToken);
 
-        public void Rollback()
+        public void RollbackTransaction()
             => _database.RollbackTransaction();
 
-        public Task RollbackAsync(CancellationToken cancellationToken)
-            => _database.RollbackTransactionAsync(cancellationToken);
+        public async Task RollbackTransactionAsync(CancellationToken cancellationToken)
+            => await _database.RollbackTransactionAsync(cancellationToken);
 
         public void Dispose()
-            => _dbContext?.Dispose();
+        {
+            _dbContext?.Dispose();
+            GC.SuppressFinalize(this);
+        }
     }
 }

src/Dotnet5.GraphQL3.Repositories.Abstractions/UnitsOfWork/UnitOfWork.cs

@@ -1,5 +1,5 @@
 using System.Reactive.Subjects;
-using System.Reflection;
+using Dotnet5.GraphQL3.CrossCutting;
 using Dotnet5.GraphQL3.Services.Abstractions.Messages;
 using Microsoft.Extensions.DependencyInjection;
 using Scrutor;
@@ -9,29 +9,25 @@ namespace Dotnet5.GraphQL3.Services.Abstractions.Extensions.DependencyInjection
     public static class ServiceCollectionExtensions
     {
         public static IServiceCollection AddApplicationServices(this IServiceCollection services)
-            => services.Scan(selector 
-                => selector.FromApplicationDependencies(assembly 
-                    => assembly.FullName?.StartsWith(GetAssemblySuffix()) ?? default)
-                .AddClasses(filter 
-                    => filter.AssignableTo(typeof(IService<,,>)))
-                .UsingRegistrationStrategy(RegistrationStrategy.Skip)
-                .AsImplementedInterfaces()
-                .WithScopedLifetime());
+            => services
+                .Scan(selector => selector.FromAssemblies(Application.Assemblies)
+                    .AddClasses(filter => filter.AssignableTo(typeof(IService<,,>)))
+                    .UsingRegistrationStrategy(RegistrationStrategy.Skip)
+                    .AsImplementedInterfaces()
+                    .WithScopedLifetime());
 
-        public static IServiceCollection AddMessageServices(this IServiceCollection services)
-            => services.Scan(selector 
-                => selector.FromApplicationDependencies(assembly 
-                    => assembly.FullName?.StartsWith(GetAssemblySuffix()) ?? default)
-                .AddClasses(filter 
-                    => filter.AssignableTo(typeof(IMessageService<,,>)))
-                .UsingRegistrationStrategy(RegistrationStrategy.Skip)
-                .AsImplementedInterfaces()
-                .WithSingletonLifetime());
+        public static IServiceCollection AddApplicationMessageServices(this IServiceCollection services)
+            => services
+                .Scan(selector => selector.FromAssemblies(Application.Assemblies)
+                    .AddClasses(filter => filter.AssignableTo(typeof(IMessageService<,,>)))
+                    .UsingRegistrationStrategy(RegistrationStrategy.Skip)
+                    .AsImplementedInterfaces()
+                    .WithSingletonLifetime());
 
-        public static IServiceCollection AddSubjects(this IServiceCollection services)
-            => services.AddSingleton(typeof(ISubject<>), typeof(ReplaySubject<>));
+        public static IServiceCollection AddApplicationAutoMapper(this IServiceCollection services)
+            => services.AddAutoMapper(Application.Assemblies);
 
-        private static string GetAssemblySuffix()
-            => Assembly.GetEntryAssembly()?.FullName?.Substring(0, 16);
+        public static IServiceCollection AddApplicationSubjects(this IServiceCollection services)
+            => services.AddSingleton(typeof(ISubject<>), typeof(ReplaySubject<>));
     }
 }