diff --git a/src/GeekLearning.Domain.EntityFramework/GeekLearning.Domain.EntityFramework.csproj b/src/GeekLearning.Domain.EntityFramework/GeekLearning.Domain.EntityFramework.csproj
index b2c644d..8202e70 100644
--- a/src/GeekLearning.Domain.EntityFramework/GeekLearning.Domain.EntityFramework.csproj
+++ b/src/GeekLearning.Domain.EntityFramework/GeekLearning.Domain.EntityFramework.csproj
@@ -4,7 +4,7 @@
     <Description>EntityFramework Core helper library to deal with a Domain layer.</Description>
     <VersionPrefix>0.0.1</VersionPrefix>
     <Authors>Geek Learning;Adrien Siffermann;Cyprien Autexier;Anna Yafi</Authors>
-    <TargetFrameworks>netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>netstandard2.1</TargetFrameworks>
     <PackageProjectUrl>https://github.com/geeklearningio/gl-dotnet-domain</PackageProjectUrl>
     <PackageLicenseUrl>https://github.com/geeklearningio/gl-dotnet-domain/blob/master/LICENSE.md</PackageLicenseUrl>
   </PropertyGroup>
@@ -14,7 +14,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="2.1.1" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="3.0.0" />
   </ItemGroup>
 
 </Project>
diff --git a/src/GeekLearning.Domain.EntityFramework/PagingExtensions.cs b/src/GeekLearning.Domain.EntityFramework/PagingExtensions.cs
index d0484b2..d9cf3b4 100644
--- a/src/GeekLearning.Domain.EntityFramework/PagingExtensions.cs
+++ b/src/GeekLearning.Domain.EntityFramework/PagingExtensions.cs
@@ -12,7 +12,7 @@ public static async Task<Page<TAggregate>> ToPageAsync<TData, TAggregate>(this I
             return new Page<TAggregate>(
                 pageIndex,
                 pageSize,
-                await query.Skip(pageIndex * pageSize).Take(pageSize).ToAsyncEnumerable().Select(selector).ToList(),
+                (await query.Skip(pageIndex * pageSize).Take(pageSize).ToListAsync()).Select(selector).ToList(),
                 await query.CountAsync()
             );
         }
diff --git a/src/GeekLearning.Domain.FluentValidation/GeekLearning.Domain.FluentValidation.csproj b/src/GeekLearning.Domain.FluentValidation/GeekLearning.Domain.FluentValidation.csproj
index 4bab1e4..74315c8 100644
--- a/src/GeekLearning.Domain.FluentValidation/GeekLearning.Domain.FluentValidation.csproj
+++ b/src/GeekLearning.Domain.FluentValidation/GeekLearning.Domain.FluentValidation.csproj
@@ -15,7 +15,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="2.1.1" />
-    <PackageReference Include="FluentValidation" Version="7.6.104" />
+    <PackageReference Include="FluentValidation" Version="7.6.105" />
   </ItemGroup>
 
 </Project>
diff --git a/src/GeekLearning.Domain.Primitives/Extensions/MaybeExtensions.cs b/src/GeekLearning.Domain.Primitives/Extensions/MaybeExtensions.cs
index 9026ec1..a4bcce1 100644
--- a/src/GeekLearning.Domain.Primitives/Extensions/MaybeExtensions.cs
+++ b/src/GeekLearning.Domain.Primitives/Extensions/MaybeExtensions.cs
@@ -1,5 +1,6 @@
 namespace GeekLearning.Domain
 {
+    using System;
     using System.Threading.Tasks;
 
     public static class MaybeExtensions
@@ -8,5 +9,61 @@ public async static Task<T> ValueAsync<T>(this Task<Maybe<T>> maybeTask) where T
         {
             return (await maybeTask).Value;
         }
+
+        public async static Task<Maybe<R>> MapAsync<T, R>(this Task<Maybe<T>> maybeTask, Func<T, R> transform) where T : class where R : class
+        {
+            var maybe = await maybeTask;
+
+            if (maybe.HasValue)
+            {
+                return transform(maybe.Value);
+            }
+            else
+            {
+                return maybe.Explanation;
+            }
+        }
+
+        public async static Task<Maybe<R>> MapAsync<T, R>(this Task<Maybe<T>> maybeTask, Func<T, Maybe<R>> transform) where T : class where R : class
+        {
+            var maybe = await maybeTask;
+
+            if (maybe.HasValue)
+            {
+                return transform(maybe.Value);
+            }
+            else
+            {
+                return maybe.Explanation;
+            }
+        }
+
+        public async static Task<Maybe<R>> MapAsync<T, R>(this Task<Maybe<T>> maybeTask, Func<T, Task<Maybe<R>>> transform) where T : class where R : class
+        {
+            var maybe = await maybeTask;
+
+            if (maybe.HasValue)
+            {
+                return await transform(maybe.Value);
+            }
+            else
+            {
+                return maybe.Explanation;
+            }
+        }
+
+        public async static Task<Maybe<R>> MapAsync<T, R>(this Task<Maybe<T>> maybeTask, Func<T, Task<R>> transform) where T : class where R : class
+        {
+            var maybe = await maybeTask;
+
+            if (maybe.HasValue)
+            {
+                return await transform(maybe.Value);
+            }
+            else
+            {
+                return maybe.Explanation;
+            }
+        }
     }
 }
diff --git a/tests/GeekLearning.Domain.Tests/MaybeExtensionsTests.cs b/tests/GeekLearning.Domain.Tests/MaybeExtensionsTests.cs
new file mode 100644
index 0000000..92fa0fb
--- /dev/null
+++ b/tests/GeekLearning.Domain.Tests/MaybeExtensionsTests.cs
@@ -0,0 +1,153 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Text;
+using System.Threading.Tasks;
+using GeekLearning.Domain;
+using GeekLearning.Domain.AspnetCore;
+using GeekLearning.Domain.Explanations;
+using Microsoft.Extensions.DependencyModel;
+using Xunit;
+
+namespace GeekLearning.Domain.Tests
+{
+    public class MaybeExtensionsTests
+    {
+
+        private class DataClass
+        {
+            public Guid Id { get; set; } = Guid.NewGuid();
+        }
+
+        private class DataTransformedClass
+        {
+            public String Id { get; set; }
+        }
+
+        [Fact]
+        public async Task MapAsync_Value()
+        {
+            var source = new DataClass();
+            var task = Task.FromResult(Maybe.Some(source));
+
+            var examinee = await task.MapAsync(x => new DataTransformedClass { Id = x.Id.ToString() });
+
+            Assert.True(examinee.HasValue);
+            Assert.Equal(source.Id, Guid.Parse(examinee.Value.Id));
+        }
+
+        [Fact]
+        public async Task MapAsync_NoValue()
+        {
+            var source = new NotFound();
+            var task = Task.FromResult((Maybe<DataClass>)source);
+
+            var examinee = await task.MapAsync(x => new DataTransformedClass { Id = x.Id.ToString() });
+
+            Assert.False(examinee.HasValue);
+            Assert.Equal(source, examinee.Explanation);
+        }
+
+        [Fact]
+        public async Task MapAsync_MaybeValueWithoutTransformationValue()
+        {
+            var source = new DataClass();
+            var tranformationResult = new NotFound();
+            var task = Task.FromResult(Maybe.Some(source));
+
+            var examinee = await task.MapAsync(x => (Maybe<DataTransformedClass>)tranformationResult);
+
+            Assert.False(examinee.HasValue);
+            Assert.Equal(tranformationResult, examinee.Explanation);
+
+        }
+
+        [Fact]
+        public async Task MapAsync_MaybeValue()
+        {
+            var source = new DataClass();
+            var task = Task.FromResult(Maybe.Some(source));
+
+            var examinee = await task.MapAsync(x => Maybe.Some(new DataTransformedClass { Id = x.Id.ToString() }));
+
+            Assert.True(examinee.HasValue);
+            Assert.Equal(source.Id, Guid.Parse(examinee.Value.Id));
+        }
+
+        [Fact]
+        public async Task MapAsync_MaybeNoValue()
+        {
+            var source = new NotFound();
+            var task = Task.FromResult((Maybe<DataClass>)source);
+
+            var examinee = await task.MapAsync(x => Maybe.Some(new DataTransformedClass { Id = x.Id.ToString() }));
+
+            Assert.False(examinee.HasValue);
+            Assert.Equal(source, examinee.Explanation);
+        }
+
+        [Fact]
+        public async Task MapAsync_AsyncTranformationValue()
+        {
+            var source = new DataClass();
+            var task = Task.FromResult(Maybe.Some(source));
+
+            var examinee = await task.MapAsync(x => Task.FromResult(new DataTransformedClass { Id = x.Id.ToString() }));
+
+            Assert.True(examinee.HasValue);
+            Assert.Equal(source.Id, Guid.Parse(examinee.Value.Id));
+        }
+
+        [Fact]
+        public async Task MapAsync_AsyncTransformationNoValue()
+        {
+            var source = new NotFound();
+            var task = Task.FromResult((Maybe<DataClass>)source);
+
+            var examinee = await task.MapAsync(x => Task.FromResult(new DataTransformedClass { Id = x.Id.ToString() }));
+
+            Assert.False(examinee.HasValue);
+            Assert.Equal(source, examinee.Explanation);
+        }
+
+        [Fact]
+        public async Task MapAsync_MaybeAsyncTranformationValue()
+        {
+            var source = new DataClass();
+            var task = Task.FromResult(Maybe.Some(source));
+
+            var examinee = await task.MapAsync(x => Task.FromResult(Maybe.Some(new DataTransformedClass { Id = x.Id.ToString() })));
+
+            Assert.True(examinee.HasValue);
+            Assert.Equal(source.Id, Guid.Parse(examinee.Value.Id));
+        }
+
+        [Fact]
+        public async Task MapAsync_MaybeAsyncTransformationNoValue()
+        {
+            var source = new NotFound();
+            var task = Task.FromResult((Maybe<DataClass>)source);
+
+            var examinee = await task.MapAsync(x => Task.FromResult(Maybe.Some(new DataTransformedClass { Id = x.Id.ToString() })));
+
+            Assert.False(examinee.HasValue);
+            Assert.Equal(source, examinee.Explanation);
+        }
+
+
+        [Fact]
+        public async Task MapAsync_MapAsync_MaybeAsyncTranformationValueWithoutTransformationValue()
+        {
+            var source = new DataClass();
+            var tranformationResult = new NotFound();
+            var task = Task.FromResult(Maybe.Some(source));
+
+            var examinee = await task.MapAsync(x => Task.FromResult((Maybe<DataTransformedClass>)tranformationResult));
+
+            Assert.False(examinee.HasValue);
+            Assert.Equal(tranformationResult, examinee.Explanation);
+
+        }
+
+    }
+}