diff --git a/src/Dotnet5.GraphQL3.Repositories.Abstractions/Dotnet5.GraphQL3.Repositories.Abstractions.csproj b/src/Dotnet5.GraphQL3.Repositories.Abstractions/Dotnet5.GraphQL3.Repositories.Abstractions.csproj
index fb5cacb5..a73a7844 100644
--- a/src/Dotnet5.GraphQL3.Repositories.Abstractions/Dotnet5.GraphQL3.Repositories.Abstractions.csproj
+++ b/src/Dotnet5.GraphQL3.Repositories.Abstractions/Dotnet5.GraphQL3.Repositories.Abstractions.csproj
@@ -4,6 +4,7 @@
         <PackageReference Include="AutoMapper" Version="$(AutoMapper_Version)" />
         <PackageReference Include="Microsoft.EntityFrameworkCore" Version="$(Microsoft_EntityFrameworkCore_Version)" />
         <PackageReference Include="Scrutor" Version="$(Scrutor_Version)" />
+        <PackageReference Include="System.Linq.Dynamic.Core" Version="1.2.8" />
     </ItemGroup>
 
     <ItemGroup>
diff --git a/src/Dotnet5.GraphQL3.Repositories.Abstractions/IRepository.cs b/src/Dotnet5.GraphQL3.Repositories.Abstractions/IRepository.cs
index a765c9df..822c7f73 100644
--- a/src/Dotnet5.GraphQL3.Repositories.Abstractions/IRepository.cs
+++ b/src/Dotnet5.GraphQL3.Repositories.Abstractions/IRepository.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Threading;
@@ -23,32 +24,37 @@ public interface IRepository<TEntity, in TId>
         bool Exists(TId id);
         Task<bool> ExistsAsync(TId id, CancellationToken cancellationToken = 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);
+        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);
 
-        PagedResult<TEntity> GetAll(
+        PaginatedResult<TEntity> GetAll(
             PageParams pageParams,
             Expression<Func<TEntity, bool>> predicate = default,
             Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = default,
             Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> include = default,
             bool asTracking = default);
         
-        PagedResult<TResult> GetAllProjections<TResult>(
+        PaginatedResult<TResult> GetAllDynamically<TResult>(
+            PageParams pageParams, 
+            IEnumerable<string> selected,
+            Func<List<object>, List<TResult>> mapping, 
+            Expression<Func<TEntity, bool>> predicate = default,
+            Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = default,
+            Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> include = default, 
+            bool asTracking = default);
+        
+        PaginatedResult<TResult> GetAllProjections<TResult>(
             PageParams pageParams,
             Expression<Func<TEntity, TResult>> selector = default,
             Expression<Func<TEntity, bool>> predicate = default,
             Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = default,
             Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> include = default,
             bool asTracking = default);
-
-        Task<PagedResult<TEntity>> GetAllAsync(
+        
+        Task<PaginatedResult<TEntity>> GetAllAsync(
             PageParams pageParams,
             CancellationToken cancellationToken,
             Expression<Func<TEntity, bool>> predicate = default,
@@ -56,7 +62,16 @@ Task<PagedResult<TEntity>> GetAllAsync(
             Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> include = default,
             bool asTracking = default);
         
-        Task<PagedResult<TResult>> GetAllProjectionsAsync<TResult>(
+        Task<PaginatedResult<TResult>> GetAllDynamicallyAsync<TResult>(
+            PageParams pageParams, 
+            IEnumerable<string> selected,
+            Func<List<object>, List<TResult>> mapping, 
+            Expression<Func<TEntity, bool>> predicate = default,
+            Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = default,
+            Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> include = default, 
+            bool asTracking = default);
+        
+        Task<PaginatedResult<TResult>> GetAllProjectionsAsync<TResult>(
             PageParams pageParams,
             CancellationToken cancellationToken,
             Expression<Func<TEntity, TResult>> selector = default,
diff --git a/src/Dotnet5.GraphQL3.Repositories.Abstractions/Pages/PagedResult.cs b/src/Dotnet5.GraphQL3.Repositories.Abstractions/Pages/PagedResult.cs
deleted file mode 100644
index b97c498e..00000000
--- a/src/Dotnet5.GraphQL3.Repositories.Abstractions/Pages/PagedResult.cs
+++ /dev/null
@@ -1,51 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.EntityFrameworkCore;
-
-namespace Dotnet5.GraphQL3.Repositories.Abstractions.Pages
-{
-    public class PagedResult<T>
-    {
-        private readonly int _index;
-        private readonly IEnumerable<T> _items;
-        private readonly int _size;
-
-        public PagedResult(IEnumerable<T> items, int index, int size)
-        {
-            _items = items;
-            _index = index;
-            _size = size;
-        }
-
-        public IEnumerable<T> Items
-            => _items.Take(_size);
-
-        public PageInfo PageInfo
-            => new()
-            {
-                Current = _index, 
-                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);
-        }
-
-        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);
-        }
-
-        private static IQueryable<T> ApplyPagination(IQueryable<T> source, PageParams pageParams)
-            => source.Skip(pageParams.Size * (pageParams.Index - 1)).Take(pageParams.Size + 1);
-    }
-}
\ No newline at end of file
diff --git a/src/Dotnet5.GraphQL3.Repositories.Abstractions/Pages/PaginatedResult.cs b/src/Dotnet5.GraphQL3.Repositories.Abstractions/Pages/PaginatedResult.cs
new file mode 100644
index 00000000..ee8c31b0
--- /dev/null
+++ b/src/Dotnet5.GraphQL3.Repositories.Abstractions/Pages/PaginatedResult.cs
@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Dynamic.Core;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+
+namespace Dotnet5.GraphQL3.Repositories.Abstractions.Pages
+{
+    public class PaginatedResult<T>
+    {
+        private readonly int _index;
+        private readonly IEnumerable<T> _items;
+        private readonly int _size;
+
+        public PaginatedResult(IEnumerable<T> items, int index, int size)
+        {
+            _items = items;
+            _index = index;
+            _size = size;
+        }
+
+        public IEnumerable<T> Items
+            => _items.Take(_size);
+
+        public PageInfo PageInfo
+            => new()
+            {
+                Current = _index, 
+                Size = Items.Count(), 
+                HasNext = _size < _items.Count(), 
+                HasPrevious = _index > 1
+            };
+
+        public static async Task<PaginatedResult<T>> CreateDynamicallyAsync(IQueryable source, PageParams pageParams, Func<List<object>, List<T>> mapping)
+        {
+            pageParams ??= new();
+            var items = await ApplyPagination(source, pageParams).ToDynamicListAsync();
+            return new PaginatedResult<T>(mapping(items), pageParams.Index, pageParams.Size);
+        }
+        
+        public static PaginatedResult<T> CreateDynamically(IQueryable source, PageParams pageParams, Func<List<object>, List<T>> mapping)
+        {
+            pageParams ??= new();
+            var items = ApplyPagination(source, pageParams).ToDynamicList();
+            return new PaginatedResult<T>(mapping(items), pageParams.Index, pageParams.Size);
+        }
+        
+        public static async Task<PaginatedResult<T>> CreateAsync(IQueryable<T> source, PageParams pageParams, CancellationToken cancellationToken)
+        {
+            pageParams ??= new();
+            var items = await ApplyPagination(source, pageParams).ToListAsync(cancellationToken);
+            return new PaginatedResult<T>(items, pageParams.Index, pageParams.Size);
+        }
+
+        public static PaginatedResult<T> Create(IQueryable<T> source, PageParams pageParams)
+        {
+            pageParams ??= new();
+            var items = ApplyPagination(source, pageParams).ToList();
+            return new PaginatedResult<T>(items, pageParams.Index, pageParams.Size);
+        }
+
+        private static IQueryable<T> ApplyPagination(IQueryable<T> source, PageParams pageParams)
+            => source.Skip(pageParams.Size * (pageParams.Index - 1)).Take(pageParams.Size + 1);
+
+        private static IQueryable ApplyPagination(IQueryable source, PageParams pageParams)
+            => source.Skip(pageParams.Size * (pageParams.Index - 1)).Take(pageParams.Size + 1);
+    }
+}
\ No newline at end of file
diff --git a/src/Dotnet5.GraphQL3.Repositories.Abstractions/Repository.cs b/src/Dotnet5.GraphQL3.Repositories.Abstractions/Repository.cs
index 5b442f96..f18d6ddc 100644
--- a/src/Dotnet5.GraphQL3.Repositories.Abstractions/Repository.cs
+++ b/src/Dotnet5.GraphQL3.Repositories.Abstractions/Repository.cs
@@ -1,6 +1,8 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
+using System.Linq.Dynamic.Core;
 using System.Threading;
 using System.Threading.Tasks;
 using AutoMapper;
@@ -16,6 +18,8 @@ public abstract class Repository<TEntity, TId> : IRepository<TEntity, TId>
         where TEntity : Entity<TId>
         where TId : struct
     {
+        private const string SelectorTemplate = "new({0})";
+
         private readonly IConfigurationProvider _configuration;
         private readonly DbSet<TEntity> _dbSet;
 
@@ -97,7 +101,7 @@ public virtual async Task UpdateAsync(TEntity entity, CancellationToken cancella
             _dbSet.Update(entity);
         }
 
-        public PagedResult<TEntity> GetAll(
+        public PaginatedResult<TEntity> GetAll(
             PageParams pageParams,
             Expression<Func<TEntity, bool>> predicate = default,
             Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = default,
@@ -110,10 +114,10 @@ public PagedResult<TEntity> GetAll(
             query = predicate is null ? query : query.Where(predicate);
             query = orderBy is null ? query : orderBy(query);
 
-            return PagedResult<TEntity>.Create(query, pageParams);
+            return PaginatedResult<TEntity>.Create(query, pageParams);
         }
         
-        public PagedResult<TResult> GetAllProjections<TResult>(
+        public PaginatedResult<TResult> GetAllProjections<TResult>(
             PageParams pageParams,
             Expression<Func<TEntity, TResult>> selector = default,
             Expression<Func<TEntity, bool>> predicate = default,
@@ -128,11 +132,31 @@ public PagedResult<TResult> GetAllProjections<TResult>(
             query = orderBy is null ? query : orderBy(query);
 
             return selector is null
-                ? PagedResult<TResult>.Create(_dbSet.ProjectTo<TResult>(_configuration), pageParams)
-                : PagedResult<TResult>.Create(query.Select(selector), pageParams);
+                ? PaginatedResult<TResult>.Create(_dbSet.ProjectTo<TResult>(_configuration), pageParams)
+                : PaginatedResult<TResult>.Create(query.Select(selector), pageParams);
         }
+        
+        public PaginatedResult<TResult> GetAllDynamically<TResult>(
+            PageParams pageParams, 
+            IEnumerable<string> selected, 
+            Func<List<object>, List<TResult>> mapping, 
+            Expression<Func<TEntity, bool>> predicate = default, 
+            Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = default,
+            Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> include = default, 
+            bool asTracking = default)
+        {
+            var query = asTracking ? _dbSet.AsTracking() : _dbSet.AsNoTrackingWithIdentityResolution();
 
-        public Task<PagedResult<TEntity>> GetAllAsync(
+            query = include is null ? query : include(query);
+            query = predicate is null ? query : query.Where(predicate);
+            query = orderBy is null ? query : orderBy(query);
+
+            var selector = string.Format(SelectorTemplate, string.Join(',', selected));
+            
+            return PaginatedResult<TResult>.CreateDynamically(query.Select(selector), pageParams, mapping);
+        }
+        
+        public Task<PaginatedResult<TEntity>> GetAllAsync(
             PageParams pageParams,
             CancellationToken cancellationToken,
             Expression<Func<TEntity, bool>> predicate = default,
@@ -146,10 +170,30 @@ public Task<PagedResult<TEntity>> GetAllAsync(
             query = predicate is null ? query : query.Where(predicate);
             query = orderBy is null ? query : orderBy(query);
 
-            return PagedResult<TEntity>.CreateAsync(query, pageParams, cancellationToken);
+            return PaginatedResult<TEntity>.CreateAsync(query, pageParams, cancellationToken);
+        }
+
+        public async Task<PaginatedResult<TResult>> GetAllDynamicallyAsync<TResult>(
+            PageParams pageParams, 
+            IEnumerable<string> selected,
+            Func<List<object>, List<TResult>> mapping, 
+            Expression<Func<TEntity, bool>> predicate = default,
+            Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = default,
+            Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> include = default, 
+            bool asTracking = default)
+        {
+            var query = asTracking ? _dbSet.AsTracking() : _dbSet.AsNoTrackingWithIdentityResolution();
+
+            query = include is null ? query : include(query);
+            query = predicate is null ? query : query.Where(predicate);
+            query = orderBy is null ? query : orderBy(query);
+
+            var selector = string.Format(SelectorTemplate, string.Join(',', selected));
+            
+            return await PaginatedResult<TResult>.CreateDynamicallyAsync(query.Select(selector), pageParams, mapping);
         }
         
-        public Task<PagedResult<TResult>> GetAllProjectionsAsync<TResult>(
+        public Task<PaginatedResult<TResult>> GetAllProjectionsAsync<TResult>(
             PageParams pageParams,
             CancellationToken cancellationToken,
             Expression<Func<TEntity, TResult>> selector = default,
@@ -165,8 +209,8 @@ public Task<PagedResult<TResult>> GetAllProjectionsAsync<TResult>(
             query = orderBy is null ? query : orderBy(query);
 
             return selector is null
-                ? PagedResult<TResult>.CreateAsync(_dbSet.ProjectTo<TResult>(_configuration), pageParams, cancellationToken)
-                : PagedResult<TResult>.CreateAsync(query.Select(selector), pageParams, cancellationToken);
+                ? PaginatedResult<TResult>.CreateAsync(_dbSet.ProjectTo<TResult>(_configuration), pageParams, cancellationToken)
+                : PaginatedResult<TResult>.CreateAsync(query.Select(selector), pageParams, cancellationToken);
         }
     }
 }
\ No newline at end of file
diff --git a/src/Dotnet5.GraphQL3.Services.Abstractions/IService.cs b/src/Dotnet5.GraphQL3.Services.Abstractions/IService.cs
index 4f0d5d22..978ad16a 100644
--- a/src/Dotnet5.GraphQL3.Services.Abstractions/IService.cs
+++ b/src/Dotnet5.GraphQL3.Services.Abstractions/IService.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Threading;
@@ -10,7 +11,7 @@
 
 namespace Dotnet5.GraphQL3.Services.Abstractions
 {
-    public interface IService<TEntity, in TModel, in TId>
+    public interface IService<TEntity, TModel, in TId>
         where TEntity : Entity<TId>
         where TModel : Model<TId>
         where TId : struct
@@ -24,23 +25,37 @@ public interface IService<TEntity, in TModel, in TId>
 
         bool Exists(TId id);
         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);
 
-        PagedResult<TEntity> GetAll(
-            PageParams pageParams,
+        TEntity Save(TModel model);
+        Task<TEntity> SaveAsync(TModel model, CancellationToken cancellationToken);
+
+        PaginatedResult<TEntity> GetAll(
+        PageParams pageParams,
+        Expression<Func<TEntity, bool>> predicate = default,
+        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = default,
+        Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> include = default,
+        bool asTracking = default);
+        
+        PaginatedResult<TModel> GetAllDynamically(
+            PageParams pageParams, 
+            IEnumerable<string> selected,
             Expression<Func<TEntity, bool>> predicate = default,
             Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = default,
-            Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> include = default,
+            Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> include = default, 
             bool asTracking = default);
         
-        PagedResult<TResult> GetAllProjections<TResult>(
+        PaginatedResult<TResult> GetAllProjections<TResult>(
             PageParams pageParams,
             Expression<Func<TEntity, TResult>> selector = default,
             Expression<Func<TEntity, bool>> predicate = default,
             Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = default,
             Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> include = default,
             bool asTracking = default);
-
-        Task<PagedResult<TEntity>> GetAllAsync(
+        
+        Task<PaginatedResult<TEntity>> GetAllAsync(
             PageParams pageParams,
             CancellationToken cancellationToken,
             Expression<Func<TEntity, bool>> predicate = default,
@@ -48,7 +63,15 @@ Task<PagedResult<TEntity>> GetAllAsync(
             Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> include = default,
             bool asTracking = default);
         
-        Task<PagedResult<TResult>> GetAllProjectionsAsync<TResult>(
+        Task<PaginatedResult<TModel>> GetAllDynamicallyAsync(
+            PageParams pageParams, 
+            IEnumerable<string> selected,
+            Expression<Func<TEntity, bool>> predicate = default,
+            Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = default,
+            Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> include = default, 
+            bool asTracking = default);
+        
+        Task<PaginatedResult<TResult>> GetAllProjectionsAsync<TResult>(
             PageParams pageParams,
             CancellationToken cancellationToken,
             Expression<Func<TEntity, TResult>> selector = default,
@@ -56,11 +79,5 @@ Task<PagedResult<TResult>> GetAllProjectionsAsync<TResult>(
             Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = default,
             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);
-
-        TEntity Save(TModel model);
-        Task<TEntity> SaveAsync(TModel model, CancellationToken cancellationToken);
     }
 }
\ No newline at end of file
diff --git a/src/Dotnet5.GraphQL3.Services.Abstractions/Models/Model.cs b/src/Dotnet5.GraphQL3.Services.Abstractions/Models/Model.cs
index c97ad127..8f7cef7d 100644
--- a/src/Dotnet5.GraphQL3.Services.Abstractions/Models/Model.cs
+++ b/src/Dotnet5.GraphQL3.Services.Abstractions/Models/Model.cs
@@ -1,8 +1,8 @@
 namespace Dotnet5.GraphQL3.Services.Abstractions.Models
 {
-    public abstract record Model<TId>
+    public abstract class Model<TId>
         where TId : struct
     {
-        private TId? Id { get; init; }
+        public TId? Id { get; init; }
     }
 }
\ No newline at end of file
diff --git a/src/Dotnet5.GraphQL3.Services.Abstractions/Service.cs b/src/Dotnet5.GraphQL3.Services.Abstractions/Service.cs
index a094badf..3b328715 100644
--- a/src/Dotnet5.GraphQL3.Services.Abstractions/Service.cs
+++ b/src/Dotnet5.GraphQL3.Services.Abstractions/Service.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Threading;
@@ -25,11 +26,7 @@ public abstract class Service<TEntity, TModel, TId> : IService<TEntity, TModel,
         protected readonly IRepository<TEntity, TId> Repository;
         protected readonly IUnitOfWork UnitOfWork;
 
-        protected Service(
-            IUnitOfWork unitOfWork,
-            IRepository<TEntity, TId> repository,
-            IMapper mapper,
-            INotificationContext notificationContext)
+        protected Service(IUnitOfWork unitOfWork, IRepository<TEntity, TId> repository, IMapper mapper, INotificationContext notificationContext)
         {
             UnitOfWork = unitOfWork;
             Repository = repository;
@@ -78,15 +75,24 @@ public virtual bool Exists(TId id)
         public virtual async Task<bool> ExistsAsync(TId id, CancellationToken cancellationToken)
             => IsValid(id) ? await Repository.ExistsAsync(id, cancellationToken) : default;
 
-        public virtual PagedResult<TEntity> GetAll(
+        public virtual PaginatedResult<TEntity> GetAll(
             PageParams pageParams,
             Expression<Func<TEntity, bool>> predicate = default,
             Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = default,
             Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> include = default,
             bool asTracking = default)
             => Repository.GetAll(pageParams, predicate, orderBy, include, asTracking);
-        
-        public virtual PagedResult<TResult> GetAllProjections<TResult>(
+
+        public virtual PaginatedResult<TModel> GetAllDynamically(
+            PageParams pageParams, 
+            IEnumerable<string> selected, 
+            Expression<Func<TEntity, bool>> predicate = default, 
+            Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = default,
+            Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> include = default, 
+            bool asTracking = default)
+            => Repository.GetAllDynamically(pageParams, selected, list => Mapper.Map<List<TModel>>(list), predicate, orderBy, include, asTracking);
+
+        public virtual PaginatedResult<TResult> GetAllProjections<TResult>(
             PageParams pageParams,
             Expression<Func<TEntity, TResult>> selector = default,
             Expression<Func<TEntity, bool>> predicate = default,
@@ -95,7 +101,7 @@ public virtual PagedResult<TResult> GetAllProjections<TResult>(
             bool asTracking = default)
             => Repository.GetAllProjections(pageParams, selector, predicate, orderBy, include, asTracking);
 
-        public virtual async Task<PagedResult<TEntity>> GetAllAsync(
+        public virtual async Task<PaginatedResult<TEntity>> GetAllAsync(
             PageParams pageParams,
             CancellationToken cancellationToken,
             Expression<Func<TEntity, bool>> predicate = default,
@@ -103,8 +109,17 @@ public virtual async Task<PagedResult<TEntity>> GetAllAsync(
             Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> include = default,
             bool asTracking = default)
             => await Repository.GetAllAsync(pageParams, cancellationToken, predicate, orderBy, include, asTracking);
-        
-        public virtual async Task<PagedResult<TResult>> GetAllProjectionsAsync<TResult>(
+
+        public virtual async Task<PaginatedResult<TModel>> GetAllDynamicallyAsync(
+            PageParams pageParams,
+            IEnumerable<string> selected,
+            Expression<Func<TEntity, bool>> predicate = default,
+            Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = default,
+            Func<IQueryable<TEntity>, IIncludableQueryable<TEntity, object>> include = default, 
+            bool asTracking = default)
+            => await Repository.GetAllDynamicallyAsync(pageParams, selected, list => Mapper.Map<List<TModel>>(list), predicate, orderBy, include, asTracking);
+
+        public virtual async Task<PaginatedResult<TResult>> GetAllProjectionsAsync<TResult>(
             PageParams pageParams,
             CancellationToken cancellationToken,
             Expression<Func<TEntity, TResult>> selector = default,
diff --git a/src/Dotnet5.GraphQL3.Store.Services/Models/Products/BackpackModel.cs b/src/Dotnet5.GraphQL3.Store.Services/Models/Products/BackpackModel.cs
index e6b98819..7aea1d6c 100644
--- a/src/Dotnet5.GraphQL3.Store.Services/Models/Products/BackpackModel.cs
+++ b/src/Dotnet5.GraphQL3.Store.Services/Models/Products/BackpackModel.cs
@@ -2,7 +2,7 @@
 
 namespace Dotnet5.GraphQL3.Store.Services.Models.Products
 {
-    public record BackpackModel : ProductModel
+    public class BackpackModel : ProductModel
     {
         public BackpackType Type { get; init; }
     }
diff --git a/src/Dotnet5.GraphQL3.Store.Services/Models/Products/BootModel.cs b/src/Dotnet5.GraphQL3.Store.Services/Models/Products/BootModel.cs
index 50ea2363..92323500 100644
--- a/src/Dotnet5.GraphQL3.Store.Services/Models/Products/BootModel.cs
+++ b/src/Dotnet5.GraphQL3.Store.Services/Models/Products/BootModel.cs
@@ -2,7 +2,7 @@
 
 namespace Dotnet5.GraphQL3.Store.Services.Models.Products
 {
-    public record BootModel : ProductModel
+    public class BootModel : ProductModel
     {
         public BootType Type { get; init; }
         public int Size { get; init; }
diff --git a/src/Dotnet5.GraphQL3.Store.Services/Models/Products/KayakModel.cs b/src/Dotnet5.GraphQL3.Store.Services/Models/Products/KayakModel.cs
index 5a807c42..b5d0e7cd 100644
--- a/src/Dotnet5.GraphQL3.Store.Services/Models/Products/KayakModel.cs
+++ b/src/Dotnet5.GraphQL3.Store.Services/Models/Products/KayakModel.cs
@@ -2,7 +2,7 @@
 
 namespace Dotnet5.GraphQL3.Store.Services.Models.Products
 {
-    public record KayakModel : ProductModel
+    public class KayakModel : ProductModel
     {
         public int AmountOfPerson { get; init; }
         public KayakType Type { get; init; }
diff --git a/src/Dotnet5.GraphQL3.Store.Services/Models/Products/ProductModel.cs b/src/Dotnet5.GraphQL3.Store.Services/Models/Products/ProductModel.cs
index 30908a65..749c139e 100644
--- a/src/Dotnet5.GraphQL3.Store.Services/Models/Products/ProductModel.cs
+++ b/src/Dotnet5.GraphQL3.Store.Services/Models/Products/ProductModel.cs
@@ -4,7 +4,7 @@
 
 namespace Dotnet5.GraphQL3.Store.Services.Models.Products
 {
-    public abstract record ProductModel : Model<Guid>
+    public class ProductModel : Model<Guid>
     {
         public string Description { get; init; }
         public DateTimeOffset IntroduceAt { get; init; }
diff --git a/src/Dotnet5.GraphQL3.Store.Services/Models/ReviewModel.cs b/src/Dotnet5.GraphQL3.Store.Services/Models/ReviewModel.cs
index 76459192..d0a4e782 100644
--- a/src/Dotnet5.GraphQL3.Store.Services/Models/ReviewModel.cs
+++ b/src/Dotnet5.GraphQL3.Store.Services/Models/ReviewModel.cs
@@ -3,7 +3,7 @@
 
 namespace Dotnet5.GraphQL3.Store.Services.Models
 {
-    public record ReviewModel : Model<Guid>
+    public class ReviewModel : Model<Guid>
     {
         public string Title { get; init; }
         public string Comment { get; init; }
diff --git a/src/Dotnet5.GraphQL3.Store.WebAPI/GraphQL/StoreQuery.cs b/src/Dotnet5.GraphQL3.Store.WebAPI/GraphQL/StoreQuery.cs
index 65a9d42f..a2fed843 100644
--- a/src/Dotnet5.GraphQL3.Store.WebAPI/GraphQL/StoreQuery.cs
+++ b/src/Dotnet5.GraphQL3.Store.WebAPI/GraphQL/StoreQuery.cs
@@ -1,11 +1,14 @@
 using System;
+using System.Linq;
 using Dotnet5.GraphQL3.Repositories.Abstractions.Pages;
 using Dotnet5.GraphQL3.Store.Domain.Entities.Products;
 using Dotnet5.GraphQL3.Store.Services;
+using Dotnet5.GraphQL3.Store.Services.Models.Products;
 using Dotnet5.GraphQL3.Store.WebAPI.GraphQL.Types.Pages;
 using Dotnet5.GraphQL3.Store.WebAPI.GraphQL.Types.Products;
 using Dotnet5.GraphQL3.Store.WebAPI.GraphQL.Types.Reviews;
 using GraphQL;
+using GraphQL.Language.AST;
 using GraphQL.Types;
 using GraphQL.Utilities;
 using Microsoft.EntityFrameworkCore;
@@ -16,6 +19,16 @@ public sealed class StoreQuery : ObjectGraphType
     {
         public StoreQuery()
         {
+            FieldAsync<PagedResultGraphType<ProductModelGraphType, ProductModel>>(
+                name: "productsmodel",
+                arguments: new QueryArguments(new QueryArgument<PageParamsGraphType> {Name = "pageParams"}),
+                resolve: async context 
+                    => await context.RequestServices
+                        .GetRequiredService<IProductService>()
+                        .GetAllDynamicallyAsync(
+                            pageParams: context.GetArgument<PageParams>("pageParams"), 
+                            selected: context.SubFields["items"].SelectionSet.Selections.Select(x => ((Field) x).Name)));
+            
             FieldAsync<PagedResultGraphType<ProductInterfaceGraphType, Product>>(
                 name: "products",
                 arguments: new QueryArguments(new QueryArgument<PageParamsGraphType> {Name = "pageParams"}),
diff --git a/src/Dotnet5.GraphQL3.Store.WebAPI/GraphQL/Types/Pages/PagedResultGraphType.cs b/src/Dotnet5.GraphQL3.Store.WebAPI/GraphQL/Types/Pages/PagedResultGraphType.cs
index e45474aa..b3af5c51 100644
--- a/src/Dotnet5.GraphQL3.Store.WebAPI/GraphQL/Types/Pages/PagedResultGraphType.cs
+++ b/src/Dotnet5.GraphQL3.Store.WebAPI/GraphQL/Types/Pages/PagedResultGraphType.cs
@@ -3,7 +3,7 @@
 
 namespace Dotnet5.GraphQL3.Store.WebAPI.GraphQL.Types.Pages
 {
-    public sealed class PagedResultGraphType<TGraphType, T> : ObjectGraphType<PagedResult<T>>
+    public sealed class PagedResultGraphType<TGraphType, T> : ObjectGraphType<PaginatedResult<T>>
         where TGraphType : IGraphType
     {
         public PagedResultGraphType()
diff --git a/src/Dotnet5.GraphQL3.Store.WebAPI/GraphQL/Types/Products/ProductModelGraphType.cs b/src/Dotnet5.GraphQL3.Store.WebAPI/GraphQL/Types/Products/ProductModelGraphType.cs
new file mode 100644
index 00000000..f9b52a56
--- /dev/null
+++ b/src/Dotnet5.GraphQL3.Store.WebAPI/GraphQL/Types/Products/ProductModelGraphType.cs
@@ -0,0 +1,24 @@
+using Dotnet5.GraphQL3.Store.Services.Models.Products;
+using GraphQL.Types;
+
+namespace Dotnet5.GraphQL3.Store.WebAPI.GraphQL.Types.Products
+{
+    public sealed class ProductModelGraphType : ObjectGraphType<ProductModel>
+    {
+        public ProductModelGraphType()
+        {
+            Name = "productmodel";
+            
+            Field(x => x.Id, type: typeof(GuidGraphType));
+            Field(x => x.Description);
+            Field(x => x.IntroduceAt);
+            Field(x => x.Name).Description("The name of the product.");
+            Field(x => x.PhotoUrl);
+            Field(x => x.Price);
+            Field(x => x.ProductType, type: typeof(ProductTypeGraphType));
+            Field(x => x.Rating);
+            Field(x => x.Stock);
+            Field<ProductOptionEnumGraphType>("option");
+        }
+    }
+}
\ No newline at end of file