diff --git a/src/DotNetElements.Core.EntityFramework.Example/FakeModuleService.cs b/src/DotNetElements.Core.EntityFramework.Example/FakeModuleService.cs
deleted file mode 100644
index 5da53d0..0000000
--- a/src/DotNetElements.Core.EntityFramework.Example/FakeModuleService.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-namespace DotNetElements.Core.EntityFramework.Example;
-
-internal sealed class FakeModuleService<TDbContext, TModuleService> : IDisposable
-    where TDbContext : DbContext
-    where TModuleService : ModuleService<TDbContext>
-{
-    public TModuleService Service { get; private init; }
-
-    public static FakeModuleService<TDbContext, TModuleService> Create(TDbContext dbContext, ICurrentUserProvider currentUserProvider, TimeProvider timeProvider)
-    {
-        return new FakeModuleService<TDbContext, TModuleService>(dbContext, currentUserProvider, timeProvider);
-    }
-
-    private readonly TDbContext dbContext;
-
-    private FakeModuleService(TDbContext dbContext, ICurrentUserProvider currentUserProvider, TimeProvider timeProvider)
-    {
-        this.dbContext = dbContext;
-        Service = (TModuleService)Activator.CreateInstance(typeof(TModuleService), dbContext, currentUserProvider, timeProvider)!;
-    }
-
-    public void Dispose()
-    {
-        dbContext.Dispose();
-    }
-}
diff --git a/src/DotNetElements.Core.EntityFramework.Example/ObjectExtensions.cs b/src/DotNetElements.Core.EntityFramework.Example/ObjectExtensions.cs
deleted file mode 100644
index fcba7be..0000000
--- a/src/DotNetElements.Core.EntityFramework.Example/ObjectExtensions.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-using System.Text.Json;
-
-namespace DotNetElements.Core.EntityFramework.Example;
-
-internal static class ObjectExtensions
-{
-    private readonly static JsonSerializerOptions jsonOptions = new() { WriteIndented = true };
-
-    public static TObject Dump<TObject>(this TObject obj)
-    {
-        string json = JsonSerializer.Serialize(obj, jsonOptions);
-
-        Console.WriteLine(json);
-
-        return obj;
-    }
-}
diff --git a/src/DotNetElements.Core.EntityFramework.Example/Program.cs b/src/DotNetElements.Core.EntityFramework.Example/Program.cs
index 899f497..0493a79 100644
--- a/src/DotNetElements.Core.EntityFramework.Example/Program.cs
+++ b/src/DotNetElements.Core.EntityFramework.Example/Program.cs
@@ -1,233 +1,417 @@
 using DotNetElements.Core.EntityFramework;
 using DotNetElements.Core.EntityFramework.Example;
+using Microsoft.Extensions.Logging;
 
 using FakeModuleServiceFactory<LibraryDbContext> factory = new();
 
-using(FakeModuleService<LibraryDbContext, AuthorService> authorService = factory.CreateModule<AuthorService>())
+// Create author
+using (FakeModuleService<LibraryDbContext, AuthorService> authorService = factory.CreateModule<AuthorService>("Create author"))
 {
-    CreateAuthorModel model = new()
-    {
-        FirstName = "John",
-        LastName = "Doe"
-    };
+	CreateAuthorModel model = new()
+	{
+		FirstName = "Author 1",
+		LastName = "Not Updated"
+	};
 
-    AuthorModel author = await authorService.Service.CreateAuthorAsync(model);
+	AuthorModel author = await authorService.Service.CreateAuthorAsync(model);
 
-    author.Dump();
+	author.Dump("Create");
+
+	// Get author audit details
+	CrudResult<DeletionAuditedModelDetails> auditDetails = await authorService.Service.GetAuthorAuditDetailsById(author.Id);
+	auditDetails.Dump("Author Details");
 }
 
+// Get all authors
+IReadOnlyList<AuthorModel> authors = [];
+using (FakeModuleService<LibraryDbContext, AuthorService> authorService = factory.CreateModule<AuthorService>("Get all authors"))
+{
+	authors = await authorService.Service.GetAllAuthorsAsync();
 
-//using (FakeModuleService<LibraryDbContext, BookService> bookService = factory.CreateModule<BookService>())
-//{
+	authors.Dump("GetAll");
+}
 
+// Update author
+using (FakeModuleService<LibraryDbContext, AuthorService> authorService = factory.CreateModule<AuthorService>("Update author"))
+{
+	EditAuthorModel model = EditAuthorModel.MapFromModel(authors[0]);
+	model.LastName = "Update 1";
 
-//}
+	CrudResult<AuthorModel> updateResult = await authorService.Service.UpdateAuthorAsync(model);
 
-class BookService : ModuleService<LibraryDbContext>
+	updateResult.Dump("Update");
+
+	// Get author audit details
+	CrudResult<DeletionAuditedModelDetails> auditDetails = await authorService.Service.GetAuthorAuditDetailsById(model.Id);
+	auditDetails.Dump("Author Details");
+}
+
+// Create Book
+using (FakeModuleService<LibraryDbContext, BookService> bookService = factory.CreateModule<BookService>("Create book"))
 {
-    public BookService(LibraryDbContext dbContext) : base(dbContext)
-    {
-    }
+	CreateBookModel model = new()
+	{
+		Name = "Book 1",
+		AuthorId = authors[0].Id
+	};
 
-    public async Task<BookModel> CreateBookAsync(CreateBookModel model)
-    {
-        ArgumentNullException.ThrowIfNull(model.Name);
+	BookModel book = await bookService.Service.CreateBookAsync(model);
 
-        Book book = new Book(model.Name, model.AuthorId);
+	book.Dump("Create");
 
-        DbContext.Books.Add(book);
+	// Get book audit details
+	CrudResult<DeletionAuditedModelDetails> auditDetails = await bookService.Service.GetBookAuditDetailsById(book.Id);
+	auditDetails.Dump("Book Details");
+}
 
-        await DbContext.SaveChangesAsync();
+// Get all books
+IReadOnlyList<BookModel> books = [];
+using (FakeModuleService<LibraryDbContext, BookService> bookService = factory.CreateModule<BookService>("Get all books"))
+{
+	books = await bookService.Service.GetAllBooksAsync();
 
-        return book.ToModel();
-    }
+	books.Dump("GetAll");
+}
 
-    public async Task<CrudResult<BookModel>> UpdateBookAsync(EditBookModel model)
-    {
-        Book? existingBook = await DbContext.Books
-            .FindAsync(model.Id);
+// Delete book
+using (FakeModuleService<LibraryDbContext, BookService> bookService = factory.CreateModule<BookService>("Delete book"))
+{
+	CrudResult deleteResult = await bookService.Service.DeleteBookByIdAsync(books[0].Id);
 
-        if (existingBook is null)
-            return Fail(CrudError.NotFound);
+	deleteResult.Dump("Delete");
+}
 
-        existingBook.Update(model);
+// Get all books
+books = [];
+using (FakeModuleService<LibraryDbContext, BookService> bookService = factory.CreateModule<BookService>("Get all books"))
+{
+	books = await bookService.Service.GetAllBooksAsync();
 
-        await DbContext.SaveChangesAsync();
+	books.Dump("GetAll");
 
-        return existingBook.ToModel();
-    }
+	// Get author audit details
+	CrudResult<DeletionAuditedModelDetails> auditDetails = await bookService.Service.GetBookAuditDetailsById(books[0].Id);
+	auditDetails.Dump("Book Details");
 }
 
-class AuthorService : ModuleService<LibraryDbContext>
+// Update book
+using (FakeModuleService<LibraryDbContext, BookService> bookService = factory.CreateModule<BookService>("Update book"))
 {
-    public AuthorService(LibraryDbContext dbContext) : base(dbContext)
-    {
-    }
+	EditBookModel model = EditBookModel.MapFromModel(books[0]);
+	model.Name = "Update 1";
+
+	CrudResult<BookModel> updateResult = await bookService.Service.UpdateBookAsync(model);
+
+	updateResult.Dump("Update");
+
+	// Get book audit details
+	CrudResult<DeletionAuditedModelDetails> auditDetails = await bookService.Service.GetBookAuditDetailsById(model.Id);
+	auditDetails.Dump("Book Details");
+}
+
+class BookService : ModuleService<LibraryDbContext>
+{
+	public BookService(LibraryDbContext dbContext) : base(dbContext)
+	{
+	}
+
+	public async Task<BookModel> CreateBookAsync(CreateBookModel model)
+	{
+		ArgumentNullException.ThrowIfNull(model.Name);
+
+		Book book = new(model.Name, model.AuthorId);
+
+		DbContext.Books.Add(book);
+
+		await DbContext.SaveChangesAsync();
+
+		return book.MapToModel();
+	}
 
-    public async Task<AuthorModel> CreateAuthorAsync(CreateAuthorModel model)
-    {
-        ArgumentNullException.ThrowIfNull(model.FirstName);
-        ArgumentNullException.ThrowIfNull(model.LastName);
+	public async Task<CrudResult<BookModel>> UpdateBookAsync(EditBookModel model)
+	{
+		Book? existingBook = await DbContext.Books
+			.EnsureNotDeleted()
+			.FindAsync(model.Id);
 
-        Author author = new Author(model.FirstName, model.LastName);
+		if (existingBook is null)
+			return Fail(CrudError.NotFound);
 
-        DbContext.Authors.Add(author);
+		existingBook.Update(model);
 
-        await DbContext.SaveChangesAsync();
+		await DbContext.SaveChangesAsync();
 
-        return author.ToModel();
-    }
+		return existingBook.MapToModel();
+	}
 
-    public async Task<CrudResult<AuthorModel>> UpdateAuthorAsync(EditAuthorModel model)
-    {
-        Author? existingAuthor = await DbContext.Authors
-            .FindAsync(model.Id);
+	public async Task<CrudResult> DeleteBookByIdAsync(Guid Id)
+	{
+		Book? existingBook = await DbContext.Books
+			.FindAsync(Id);
 
-        if (existingAuthor is null)
-            return Fail(CrudError.NotFound);
+		if (existingBook is null)
+			return Fail(CrudError.NotFound);
 
-        existingAuthor.Update(model);
+		DbContext.Books.Remove(existingBook);
+		await DbContext.SaveChangesAsync();
 
-        await DbContext.SaveChangesAsync();
+		return CrudResult.Ok();
+	}
 
-        return existingAuthor.ToModel();
-    }
+	public async Task<IReadOnlyList<BookModel>> GetAllBooksAsync()
+	{
+		return await DbContext.Books
+			.MapToModel()
+			.ToListAsync();
+	}
+
+	public Task<CrudResult<DeletionAuditedModelDetails>> GetBookAuditDetailsById(Guid id)
+	{
+		return GetDeletionAuditedDetailsByEntityId<Book, Guid>(id);
+	}
 }
 
-class LibraryDbContext : DbContext
+class AuthorService : ModuleService<LibraryDbContext>
 {
-    public DbSet<Book> Books { get; set; }
-    public DbSet<Author> Authors { get; set; }
+	public AuthorService(LibraryDbContext dbContext) : base(dbContext)
+	{
+	}
+
+	public async Task<AuthorModel> CreateAuthorAsync(CreateAuthorModel model)
+	{
+		ArgumentNullException.ThrowIfNull(model.FirstName);
+		ArgumentNullException.ThrowIfNull(model.LastName);
+
+		Author author = new(model.FirstName, model.LastName);
+
+		DbContext.Authors.Add(author);
+
+		await DbContext.SaveChangesAsync();
+
+		return author.MapToModel();
+	}
+
+	public async Task<CrudResult<AuthorModel>> UpdateAuthorAsync(EditAuthorModel model)
+	{
+		Author? existingAuthor = await DbContext.Authors
+			.FindAsync(model.Id);
+
+		if (existingAuthor is null)
+			return Fail(CrudError.NotFound);
+
+		existingAuthor.Update(model);
+
+		await DbContext.SaveChangesAsync();
+
+		return existingAuthor.MapToModel();
+	}
+
+	public async Task<CrudResult> DeleteAuthorByIdAsync(Guid Id)
+	{
+		Author? existingAuthor = await DbContext.Authors
+			.EnsureNotDeleted()
+			.FindAsync(Id);
+
+		if (existingAuthor is null)
+			return Fail(CrudError.NotFound);
+
+		DbContext.Authors.Remove(existingAuthor);
+		await DbContext.SaveChangesAsync();
+
+		return CrudResult.Ok();
+	}
+
+	public async Task<IReadOnlyList<AuthorModel>> GetAllAuthorsAsync()
+	{
+		return await DbContext.Authors
+			.EnsureNotDeleted()
+			.MapToModel()
+			.ToListAsync();
+	}
+
+	public Task<CrudResult<DeletionAuditedModelDetails>> GetAuthorAuditDetailsById(Guid id)
+	{
+		return GetDeletionAuditedDetailsByEntityId<Author, Guid>(id);
+	}
 }
 
-class Book : AuditedEntity<Guid>, IUpdateFrom<EditBookModel>, IMapToModel<BookModel>
+class LibraryDbContext : DbContext, IFakeDbContext
 {
-    public string Name { get; private set; }
-    public Guid AuthorId { get; private set; }
+	public DbSet<Book> Books { get; set; } = default!;
+	public DbSet<Author> Authors { get; set; } = default!;
 
-    [ForeignKey(nameof(AuthorId))]
-    public Author Author { get; private set; } = null!;
+	public Action<string> LogAction { set => logAction = value; }
 
-    public Book(string name, Guid authorId, Guid id = default)
-    {
-        Id = id;
-        Name = name;
-        AuthorId = authorId;
-    }
+	private Action<string>? logAction;
 
-    public void Update(EditBookModel from)
-    {
-        ArgumentNullException.ThrowIfNull(from.Name);
+	public LibraryDbContext(DbContextOptions options) : base(options)
+	{
 
-        Name = from.Name;
-        AuthorId = from.AuthorId;
-    }
+	}
 
-    public BookModel ToModel()
-    {
-        return new BookModel
-        {
-            Id = Id,
-            Name = Name,
-            AuthorId = AuthorId
-        };
-    }
+	protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+		=> optionsBuilder
+		.LogTo(
+			logAction ?? Console.WriteLine,
+			LogLevel.Information,
+			Microsoft.EntityFrameworkCore.Diagnostics.DbContextLoggerOptions.None)
+		.EnableSensitiveDataLogging();
+}
+
+class Book : DeletionAuditedEntity<Guid>, IUpdateFrom<EditBookModel>
+{
+	public string Name { get; private set; }
+	public Guid AuthorId { get; private set; }
+
+	[ForeignKey(nameof(AuthorId))]
+	public Author Author { get; private set; } = null!;
+
+	public Book(string name, Guid authorId, Guid id = default)
+	{
+		Id = id;
+		Name = name;
+		AuthorId = authorId;
+	}
+
+	public void Update(EditBookModel from)
+	{
+		ArgumentNullException.ThrowIfNull(from.Name);
+
+		Name = from.Name;
+		AuthorId = from.AuthorId;
+	}
+}
+
+static class BookMapper
+{
+	public static BookModel MapToModel(this Book entity)
+	{
+		return new BookModel
+		{
+			Id = entity.Id,
+			Name = entity.Name,
+			AuthorId = entity.AuthorId
+		};
+	}
+
+	public static IQueryable<BookModel> MapToModel(this IQueryable<Book> query)
+	{
+		return Queryable.Select(query, entity => new BookModel()
+		{
+			Id = entity.Id,
+			Name = entity.Name,
+			AuthorId = entity.AuthorId
+		});
+	}
 }
 
 class BookModel : Model<Guid>
 {
-    public required string Name { get; init; }
-    public required Guid AuthorId { get; init; }
+	public required string Name { get; init; }
+	public required Guid AuthorId { get; init; }
 }
 
 class CreateBookModel : CreateModel<BookModel, Guid>
 {
-    [Required]
-    public string? Name { get; set; }
+	[Required]
+	public string? Name { get; set; }
 
-    [Required]
-    public Guid AuthorId { get; set; }
+	[Required]
+	public Guid AuthorId { get; set; }
 }
 
 class EditBookModel : EditModel<BookModel, Guid>, IMapFromModel<EditBookModel, BookModel>
 {
-    public string? Name { get; set; }
-    public Guid AuthorId { get; set; }
-
-    public static EditBookModel MapFromModel(BookModel model)
-    {
-        return new EditBookModel
-        {
-            Id = model.Id,
-            Name = model.Name,
-            AuthorId = model.AuthorId
-        };
-    }
+	public string? Name { get; set; }
+	public Guid AuthorId { get; set; }
+
+	public static EditBookModel MapFromModel(BookModel model)
+	{
+		return new EditBookModel
+		{
+			Id = model.Id,
+			Name = model.Name,
+			AuthorId = model.AuthorId
+		};
+	}
 }
 
-class Author : AuditedEntity<Guid>, IUpdateFrom<EditAuthorModel>, IMapToModel<AuthorModel>
+class Author : DeletionAuditedEntity<Guid>, IUpdateFrom<EditAuthorModel>
 {
-    public string FirstName { get; private set; }
-    public string LastName { get; private set; }
+	public string FirstName { get; private set; }
+	public string LastName { get; private set; }
 
-    private readonly List<Book> books = default!;
+	private readonly List<Book> books = default!;
 
-    [BackingField(nameof(books))]
-    public IReadOnlyList<Book> Books => books;
+	[BackingField(nameof(books))]
+	public IReadOnlyList<Book> Books => books;
 
-    public Author(string firstName, string lastName)
-    {
-        FirstName = firstName;
-        LastName = lastName;
-    }
+	public Author(string firstName, string lastName)
+	{
+		FirstName = firstName;
+		LastName = lastName;
+	}
 
-    public void Update(EditAuthorModel from)
-    {
-        ArgumentNullException.ThrowIfNull(from.FirstName);
-        ArgumentNullException.ThrowIfNull(from.LastName);
+	public void Update(EditAuthorModel from)
+	{
+		ArgumentNullException.ThrowIfNull(from.FirstName);
+		ArgumentNullException.ThrowIfNull(from.LastName);
 
-        FirstName = from.FirstName;
-        LastName = from.LastName;
-    }
+		FirstName = from.FirstName;
+		LastName = from.LastName;
+	}
+}
 
-    public AuthorModel ToModel()
-    {
-        return new AuthorModel
-        {
-            Id = Id,
-            FirstName = FirstName,
-            LastName = LastName
-        };
-    }
+static class AuthorMapper
+{
+	public static AuthorModel MapToModel(this Author entity)
+	{
+		return new AuthorModel
+		{
+			Id = entity.Id,
+			FirstName = entity.FirstName,
+			LastName = entity.LastName
+		};
+	}
+
+	public static IQueryable<AuthorModel> MapToModel(this IQueryable<Author> query)
+	{
+		return Queryable.Select(query, entity => new AuthorModel()
+		{
+			Id = entity.Id,
+			FirstName = entity.FirstName,
+			LastName = entity.LastName
+		});
+	}
 }
 
 class AuthorModel : Model<Guid>
 {
-    public required string FirstName { get; init; }
-    public required string LastName { get; init; }
+	public required string FirstName { get; init; }
+	public required string LastName { get; init; }
 }
 
 class CreateAuthorModel : CreateModel<AuthorModel, Guid>
 {
-    [Required]
-    public string? FirstName { get; set; }
+	[Required]
+	public string? FirstName { get; set; }
 
-    [Required]
-    public string? LastName { get; set; }
+	[Required]
+	public string? LastName { get; set; }
 }
 
 class EditAuthorModel : EditModel<AuthorModel, Guid>, IMapFromModel<EditAuthorModel, AuthorModel>
 {
-    public string? FirstName { get; set; }
-    public string? LastName { get; set; }
-
-    public static EditAuthorModel MapFromModel(AuthorModel model)
-    {
-        return new EditAuthorModel
-        {
-            Id = model.Id,
-            FirstName = model.FirstName,
-            LastName = model.LastName
-        };
-    }
+	public string? FirstName { get; set; }
+	public string? LastName { get; set; }
+
+	public static EditAuthorModel MapFromModel(AuthorModel model)
+	{
+		return new EditAuthorModel
+		{
+			Id = model.Id,
+			FirstName = model.FirstName,
+			LastName = model.LastName
+		};
+	}
 }
\ No newline at end of file
diff --git a/src/DotNetElements.Core.EntityFramework.Example/FakeCurrentUserProvider.cs b/src/DotNetElements.Core.EntityFramework.Example/TestUtils/FakeCurrentUserProvider.cs
similarity index 100%
rename from src/DotNetElements.Core.EntityFramework.Example/FakeCurrentUserProvider.cs
rename to src/DotNetElements.Core.EntityFramework.Example/TestUtils/FakeCurrentUserProvider.cs
diff --git a/src/DotNetElements.Core.EntityFramework.Example/TestUtils/FakeModuleService.cs b/src/DotNetElements.Core.EntityFramework.Example/TestUtils/FakeModuleService.cs
new file mode 100644
index 0000000..05a3ec6
--- /dev/null
+++ b/src/DotNetElements.Core.EntityFramework.Example/TestUtils/FakeModuleService.cs
@@ -0,0 +1,58 @@
+namespace DotNetElements.Core.EntityFramework.Example;
+
+internal interface ILogEventStore
+{
+	public void Log(LogType LogType, string message);
+}
+
+internal sealed class FakeModuleService<TDbContext, TModuleService> : IDisposable, ILogEventStore
+	where TDbContext : DbContext, IFakeDbContext
+	where TModuleService : ModuleService<TDbContext>
+{
+	public TModuleService Service { get; private init; }
+
+	private readonly List<LogEvent> logEvents = [];
+
+	private readonly string? logContext;
+
+	public static FakeModuleService<TDbContext, TModuleService> Create(TDbContext dbContext, string? logContext)
+	{
+		return new FakeModuleService<TDbContext, TModuleService>(dbContext, logContext);
+	}
+
+	private readonly TDbContext dbContext;
+
+	private FakeModuleService(TDbContext dbContext, string? logContext)
+	{
+		this.dbContext = dbContext;
+		this.dbContext.LogAction = LogFromDbContext;
+		this.logContext = logContext;
+
+		Service = (TModuleService)Activator.CreateInstance(typeof(TModuleService), dbContext)!;
+
+		logEvents.Add(new LogEvent(LogType.ModuleService, $"Started ModuleService operations {(logContext is null ? "" : $"<{logContext}>")} (TypeOf: {typeof(TModuleService).Name})", DateTime.Now));
+
+		Logger.Instance = this;
+	}
+
+	public void Dispose()
+	{
+		dbContext.Dispose();
+
+		logEvents.Add(new LogEvent(LogType.ModuleService, $"Finished ModuleService operations {(logContext is null ? "" : $"<{logContext}>")} (TypeOf: {typeof(TModuleService).Name})", DateTime.Now));
+
+		Logger.Instance = null;
+
+		Logger.LogToConsole(logEvents);
+	}
+
+	public void Log(LogType LogType, string message)
+	{
+		logEvents.Add(new LogEvent(LogType, message, DateTime.Now));
+	}
+
+	private void LogFromDbContext(string message)
+	{
+		logEvents.Add(new LogEvent(LogType.DbContext, message, DateTime.Now));
+	}
+}
diff --git a/src/DotNetElements.Core.EntityFramework.Example/FakeModuleServiceFactory.cs b/src/DotNetElements.Core.EntityFramework.Example/TestUtils/FakeModuleServiceFactory.cs
similarity index 85%
rename from src/DotNetElements.Core.EntityFramework.Example/FakeModuleServiceFactory.cs
rename to src/DotNetElements.Core.EntityFramework.Example/TestUtils/FakeModuleServiceFactory.cs
index af02d6e..98f49a7 100644
--- a/src/DotNetElements.Core.EntityFramework.Example/FakeModuleServiceFactory.cs
+++ b/src/DotNetElements.Core.EntityFramework.Example/TestUtils/FakeModuleServiceFactory.cs
@@ -5,10 +5,10 @@
 namespace DotNetElements.Core.EntityFramework.Example;
 
 internal sealed class FakeModuleServiceFactory<TDbContext> : IDisposable
-    where TDbContext : DbContext
+    where TDbContext : DbContext, IFakeDbContext
 {
     public readonly FakeCurrentUserProvider UserProvider = new();
-    public readonly FakeTimeProvider TimeProvider = new();
+    public readonly TimeProvider TimeProvider = TimeProvider.System;
 
     private DbConnection? connection;
 
@@ -19,12 +19,11 @@ private DbContextOptions CreateOptions()
         return new DbContextOptionsBuilder()
             .UseSqlite(connection)
             .AddInterceptors(
-                new SoftDeleteInterceptor(TimeProvider, UserProvider),
                 new AuditInterceptor(TimeProvider, UserProvider))
             .Options;
     }
 
-    public FakeModuleService<TDbContext, TModuleService> CreateModule<TModuleService>()
+    public FakeModuleService<TDbContext, TModuleService> CreateModule<TModuleService>(string? logContext = null)
         where TModuleService : ModuleService<TDbContext>
     {
         if (connection is null)
@@ -39,7 +38,7 @@ public FakeModuleService<TDbContext, TModuleService> CreateModule<TModuleService
 
         TDbContext dbContext = (TDbContext)Activator.CreateInstance(typeof(TDbContext), CreateOptions())!;
 
-        return FakeModuleService<TDbContext, TModuleService>.Create(dbContext, UserProvider, TimeProvider);
+        return FakeModuleService<TDbContext, TModuleService>.Create(dbContext, logContext);
     }
 
     public void Dispose()
@@ -49,5 +48,7 @@ public void Dispose()
             connection.Dispose();
             connection = null;
         }
+
+        Console.ForegroundColor = ConsoleColor.White;
     }
 }
diff --git a/src/DotNetElements.Core.EntityFramework.Example/TestUtils/IFakeDbContext.cs b/src/DotNetElements.Core.EntityFramework.Example/TestUtils/IFakeDbContext.cs
new file mode 100644
index 0000000..641ddb3
--- /dev/null
+++ b/src/DotNetElements.Core.EntityFramework.Example/TestUtils/IFakeDbContext.cs
@@ -0,0 +1,6 @@
+namespace DotNetElements.Core.EntityFramework.Example;
+
+internal interface IFakeDbContext
+{
+	public Action<string> LogAction { set; }
+}
diff --git a/src/DotNetElements.Core.EntityFramework.Example/TestUtils/ObjectExtensions.cs b/src/DotNetElements.Core.EntityFramework.Example/TestUtils/ObjectExtensions.cs
new file mode 100644
index 0000000..ef2c2ea
--- /dev/null
+++ b/src/DotNetElements.Core.EntityFramework.Example/TestUtils/ObjectExtensions.cs
@@ -0,0 +1,61 @@
+using DotNetElements.Core.Result;
+using System.Runtime.CompilerServices;
+using System.Text.Json;
+
+namespace DotNetElements.Core.EntityFramework.Example;
+
+internal static class ObjectExtensions
+{
+	private readonly static JsonSerializerOptions jsonOptions = new()
+	{
+		WriteIndented = true
+	};
+
+	public static TObject Dump<TObject>(this TObject obj, string? message = null, [CallerArgumentExpression(nameof(obj))] string? caller = null)
+	{
+		string? objectDump;
+
+		if (obj is ErrorResult<CrudError> crudResult)
+		{
+			object? value = typeof(TObject).GetField("Value", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)?.GetValue(obj);
+
+			if (value is not null)
+				objectDump = GetObjectAsJson(new { Result = crudResult.IsOk ? "Ok" : "Fail", Value = value });
+			else
+				objectDump = GetObjectAsJson(new { Result = crudResult.IsOk ? "Ok" : "Fail" });
+		}
+		else
+		{
+			objectDump = GetObjectAsJson(obj);
+		}
+
+		string cleansedObjectType = GetObjectTypeCleansed<TObject>();
+
+		Logger.Instance?.Log(LogType.ObjectDumpHeader, $"{message} {caller} (TypeOf: {cleansedObjectType})");
+		Logger.Instance?.Log(LogType.ObjectDump, objectDump);
+
+		return obj;
+	}
+
+	private static string GetObjectTypeCleansed<TObject>()
+	{
+		Type objectType = typeof(TObject);
+
+		string objectTypeCleansed = objectType.Name;
+
+		if (objectType.IsGenericType)
+		{
+			objectTypeCleansed = objectTypeCleansed.Split('`')[0];
+			objectTypeCleansed += "<";
+			objectTypeCleansed += string.Join(", ", objectType.GetGenericArguments().First().Name);
+			objectTypeCleansed += ">";
+		}
+
+		return objectTypeCleansed;
+	}
+
+	private static string GetObjectAsJson<TObject>(TObject obj)
+	{
+		return JsonSerializer.Serialize(obj, jsonOptions);
+	}
+}
diff --git a/src/DotNetElements.Core.EntityFramework.Example/TestUtils/TestLogger.cs b/src/DotNetElements.Core.EntityFramework.Example/TestUtils/TestLogger.cs
new file mode 100644
index 0000000..71a6f20
--- /dev/null
+++ b/src/DotNetElements.Core.EntityFramework.Example/TestUtils/TestLogger.cs
@@ -0,0 +1,69 @@
+namespace DotNetElements.Core.EntityFramework.Example;
+
+internal enum LogType
+{
+	DbContext,
+	ModuleService,
+	ObjectDumpHeader,
+	ObjectDump,
+}
+
+internal record struct LogEvent(LogType LogType, string Message, DateTime Timestamp);
+
+internal static partial class Logger
+{
+	public static ILogEventStore? Instance;
+
+	public static void LogToConsole(List<LogEvent> logEvents)
+	{
+		LogEvent? previousLogEvent = null;
+
+		foreach (LogEvent logEvent in logEvents.OrderBy(e => e.Timestamp))
+		{
+			ConsoleColor color = logEvent.LogType switch
+			{
+				LogType.DbContext => ConsoleColor.White,
+				LogType.ModuleService => ConsoleColor.Green,
+				LogType.ObjectDumpHeader => ConsoleColor.Yellow,
+				LogType.ObjectDump => ConsoleColor.White,
+				_ => ConsoleColor.White,
+			};
+
+			bool addEmptyLineBefore = logEvent.LogType switch
+			{
+				LogType.DbContext => false,
+				LogType.ModuleService => true,
+				LogType.ObjectDumpHeader => true,
+				LogType.ObjectDump => false,
+				_ => false,
+			};
+
+			// Check if the current logEvent is DbContext and the next logEvent is also DbContext
+			if (logEvent.LogType is LogType.DbContext && previousLogEvent?.LogType is LogType.DbContext)
+				addEmptyLineBefore = true;
+
+			bool addEmptyLineAfter = logEvent.LogType switch
+			{
+				LogType.DbContext => false,
+				LogType.ModuleService => true,
+				LogType.ObjectDumpHeader => false,
+				LogType.ObjectDump => true,
+				_ => false,
+			};
+
+			Console.ForegroundColor = color;
+
+			if (addEmptyLineBefore)
+				Console.WriteLine();
+
+			Console.WriteLine(logEvent.Message);
+
+			if (addEmptyLineAfter)
+				Console.WriteLine();
+
+			previousLogEvent = logEvent;
+		};
+
+		Console.ResetColor();
+	}
+}
diff --git a/src/DotNetElements.Core.EntityFramework.Shared/Model/ModelBase.cs b/src/DotNetElements.Core.EntityFramework.Shared/Model/ModelBase.cs
index 21558f2..6140c20 100644
--- a/src/DotNetElements.Core.EntityFramework.Shared/Model/ModelBase.cs
+++ b/src/DotNetElements.Core.EntityFramework.Shared/Model/ModelBase.cs
@@ -55,20 +55,20 @@ public class CreationAuditedModelDetails : ModelDetails
 
 public class AuditedModelDetails : CreationAuditedModelDetails
 {
-    public Guid? LastModifierId { get; init; }
+    public required Guid? LastModifierId { get; init; }
 
-    public string? LastModifierDisplayName { get; init; }
+	public required string? LastModifierDisplayName { get; init; }
 
-    public DateTimeOffset? LastModificationTime { get; init; }
+	public required DateTimeOffset? LastModificationTime { get; init; }
 }
 
-public class PersistentModelDetails : AuditedModelDetails
+public class DeletionAuditedModelDetails : AuditedModelDetails
 {
-    public bool IsDeleted { get; init; }
+	public required bool IsDeleted { get; init; }
 
-    public Guid? DeleterId { get; init; }
+    public required Guid? DeleterId { get; init; }
 
-    public string? DeleterDisplayName { get; init; }
+    public required string? DeleterDisplayName { get; init; }
 
-    public DateTimeOffset? DeletionTime { get; init; }
+    public required DateTimeOffset? DeletionTime { get; init; }
 }
diff --git a/src/DotNetElements.Core.EntityFramework.Shared/SharedContracts.cs b/src/DotNetElements.Core.EntityFramework.Shared/SharedContracts.cs
index 19dcf57..eb16e5e 100644
--- a/src/DotNetElements.Core.EntityFramework.Shared/SharedContracts.cs
+++ b/src/DotNetElements.Core.EntityFramework.Shared/SharedContracts.cs
@@ -7,8 +7,3 @@ public interface IHasKey<TKey>
 
     bool HasKey => !Id.Equals(default);
 }
-
-public interface IMapToModel<TModel>
-{
-    TModel ToModel();
-}
diff --git a/src/DotNetElements.Core.EntityFramework/EfCore/AuditInterceptor.cs b/src/DotNetElements.Core.EntityFramework/EfCore/AuditInterceptor.cs
index 9ec0f0c..9b6fffd 100644
--- a/src/DotNetElements.Core.EntityFramework/EfCore/AuditInterceptor.cs
+++ b/src/DotNetElements.Core.EntityFramework/EfCore/AuditInterceptor.cs
@@ -20,26 +20,39 @@ public override ValueTask<InterceptionResult<int>> SavingChangesAsync(DbContextE
         if (eventData.Context is null)
             return base.SavingChangesAsync(eventData, result, cancellationToken);
 
-        IEnumerable<EntityEntry<ICreationAuditedEntity>> entities = eventData
+        IEnumerable<EntityEntry<ICreationAuditedEntity>> addedOrModifiedEntities = eventData
             .Context
             .ChangeTracker
             .Entries<ICreationAuditedEntity>()
             .Where(e => e.State is EntityState.Added or EntityState.Modified);
 
-        foreach (EntityEntry<ICreationAuditedEntity> entity in entities)
+        foreach (EntityEntry<ICreationAuditedEntity> auditedEntity in addedOrModifiedEntities)
         {
-            if (entity.State is EntityState.Added)
+            if (auditedEntity.State is EntityState.Added)
             {
-                entity.Property(nameof(ICreationAuditedEntity.CreationTime)).CurrentValue = timeProvider.GetUtcNow();
-                entity.Property(nameof(ICreationAuditedEntity.CreatorId)).CurrentValue = currentUserProvider.GetCurrentUserId();
+                auditedEntity.Property(nameof(ICreationAuditedEntity.CreationTime)).CurrentValue = timeProvider.GetUtcNow();
+                auditedEntity.Property(nameof(ICreationAuditedEntity.CreatorId)).CurrentValue = currentUserProvider.GetCurrentUserId();
             }
-            else if (entity.State is EntityState.Modified && entity.Entity is IAuditedEntity)
+            else if (auditedEntity.State is EntityState.Modified && auditedEntity.Entity is IAuditedEntity)
             {
-                entity.Property(nameof(IAuditedEntity.LastModificationTime)).CurrentValue = timeProvider.GetUtcNow();
-                entity.Property(nameof(IAuditedEntity.LastModifierId)).CurrentValue = currentUserProvider.GetCurrentUserId();
+				auditedEntity.Property(nameof(IAuditedEntity.LastModificationTime)).CurrentValue = timeProvider.GetUtcNow();
+                auditedEntity.Property(nameof(IAuditedEntity.LastModifierId)).CurrentValue = currentUserProvider.GetCurrentUserId();
             }
         }
 
-        return base.SavingChangesAsync(eventData, result, cancellationToken);
+		IEnumerable<EntityEntry<IDeletionAuditedEntity>> deletedEntities =
+	        eventData
+	        .Context
+	        .ChangeTracker
+	        .Entries<IDeletionAuditedEntity>()
+	        .Where(e => e.State is EntityState.Deleted);
+
+		foreach (EntityEntry<IDeletionAuditedEntity> deletionAuditedEntity in deletedEntities)
+		{
+			deletionAuditedEntity.State = EntityState.Modified;
+			deletionAuditedEntity.Entity.SetIsDeletedWithAudit(currentUserProvider.GetCurrentUserId(), timeProvider.GetUtcNow());
+		}
+
+		return base.SavingChangesAsync(eventData, result, cancellationToken);
     }
 }
diff --git a/src/DotNetElements.Core.EntityFramework/EfCore/IQueryableExtensions.cs b/src/DotNetElements.Core.EntityFramework/EfCore/IQueryableExtensions.cs
index bea5630..0e5fdf5 100644
--- a/src/DotNetElements.Core.EntityFramework/EfCore/IQueryableExtensions.cs
+++ b/src/DotNetElements.Core.EntityFramework/EfCore/IQueryableExtensions.cs
@@ -8,4 +8,17 @@ public static class IQueryableExtensions
     {
         return await query.FirstOrDefaultAsync(entity => entity.Id.Equals(id));
     }
+
+	public static IQueryable<TEntity> WithId<TEntity, TKey>(this IQueryable<TEntity> query, TKey id)
+		where TEntity : class, IHasKey<TKey>
+		where TKey : notnull, IEquatable<TKey>
+	{
+		return query.Where(entity => entity.Id.Equals(id));
+	}
+
+	public static IQueryable<TEntity> EnsureNotDeleted<TEntity>(this IQueryable<TEntity> query)
+		where TEntity : class, IDeletionAuditedEntity
+	{
+		return query.Where(entity => !entity.IsDeleted);
+	}
 }
diff --git a/src/DotNetElements.Core.EntityFramework/EfCore/ModuleService.cs b/src/DotNetElements.Core.EntityFramework/EfCore/ModuleService.cs
index fd972ec..c7e04da 100644
--- a/src/DotNetElements.Core.EntityFramework/EfCore/ModuleService.cs
+++ b/src/DotNetElements.Core.EntityFramework/EfCore/ModuleService.cs
@@ -1,24 +1,100 @@
 namespace DotNetElements.Core.EntityFramework;
 
 public abstract class ModuleService<TDbContext>
-    where TDbContext : DbContext
+	where TDbContext : DbContext
 {
-    protected readonly TDbContext DbContext;
+	protected readonly TDbContext DbContext;
 
-    protected ModuleService(TDbContext dbContext)
-    {
-        DbContext = dbContext;
-    }
+	protected ModuleService(TDbContext dbContext)
+	{
+		DbContext = dbContext;
+	}
 
-    protected bool EnsureVersion<TEntity, TKey>(TEntity entity, TEntity existingEntity)
-        where TEntity : class, IEntity<TKey>, IEntityHasVersion
-        where TKey : notnull, IEquatable<TKey>
-    {
-        if (entity.Version != existingEntity.Version)
-            return false;
+	protected bool EnsureVersion<TEntity, TKey>(TEntity entity, TEntity existingEntity)
+		where TEntity : class, IEntity<TKey>, IEntityHasVersion
+		where TKey : notnull, IEquatable<TKey>
+	{
+		if (entity.Version != existingEntity.Version)
+			return false;
 
-        entity.UpdateVersion();
+		entity.UpdateVersion();
 
-        return true;
-    }
+		return true;
+	}
+
+	protected async Task<CrudResult<CreationAuditedModelDetails>> GetCreationAuditedDetailsByEntityId<TEntity, TKey>(TKey id)
+		where TEntity : class, IEntity<TKey>, ICreationAuditedEntity
+		where TKey : notnull, IEquatable<TKey>
+	{
+		IQueryable<TEntity> query = DbContext
+			.Set<TEntity>()
+			.AsNoTracking()
+			.WithId(id);
+
+		CreationAuditedModelDetails? details = await query
+			.Select(entity =>
+				new CreationAuditedModelDetails()
+				{
+					CreatorId = entity.CreatorId,
+					CreatorDisplayName = "", // todo
+					CreationTime = entity.CreationTime,
+				})
+			.FirstOrDefaultAsync();
+
+		return CrudResultHelperExtensions.OkIfNotNull(details, CrudError.NotFound);
+	}
+
+	protected async Task<CrudResult<AuditedModelDetails>> GetAuditedDetailsByEntityId<TEntity, TKey>(TKey id)
+		where TEntity : class, IEntity<TKey>, IAuditedEntity
+		where TKey : notnull, IEquatable<TKey>
+	{
+		IQueryable<TEntity> query = DbContext
+			.Set<TEntity>()
+			.AsNoTracking()
+			.WithId(id);
+
+		AuditedModelDetails? details = await query
+			.Select(entity =>
+				new AuditedModelDetails()
+				{
+					CreatorId = entity.CreatorId,
+					CreatorDisplayName = "", // todo
+					CreationTime = entity.CreationTime,
+					LastModifierId = entity.LastModifierId,
+					LastModifierDisplayName = "", // todo
+					LastModificationTime = entity.LastModificationTime
+				})
+			.FirstOrDefaultAsync();
+
+		return CrudResultHelperExtensions.OkIfNotNull(details, CrudError.NotFound);
+	}
+
+	protected async Task<CrudResult<DeletionAuditedModelDetails>> GetDeletionAuditedDetailsByEntityId<TEntity, TKey>(TKey id)
+		where TEntity : class, IEntity<TKey>, IDeletionAuditedEntity
+		where TKey : notnull, IEquatable<TKey>
+	{
+		IQueryable<TEntity> query = DbContext
+			.Set<TEntity>()
+			.AsNoTracking()
+			.WithId(id);
+
+		DeletionAuditedModelDetails? details = await query
+			.Select(entity =>
+				new DeletionAuditedModelDetails()
+				{
+					CreatorId = entity.CreatorId,
+					CreatorDisplayName = "", // todo
+					CreationTime = entity.CreationTime,
+					LastModifierId = entity.LastModifierId,
+					LastModifierDisplayName = "", // todo
+					LastModificationTime = entity.LastModificationTime,
+					IsDeleted = entity.IsDeleted,
+					DeleterId = entity.DeleterId,
+					DeleterDisplayName = "", // todo
+					DeletionTime = entity.DeletionTime
+				})
+			.FirstOrDefaultAsync();
+
+		return CrudResultHelperExtensions.OkIfNotNull(details, CrudError.NotFound);
+	}
 }
diff --git a/src/DotNetElements.Core.EntityFramework/EfCore/SoftDeleteInterceptor.cs b/src/DotNetElements.Core.EntityFramework/EfCore/SoftDeleteInterceptor.cs
deleted file mode 100644
index 4ad03dc..0000000
--- a/src/DotNetElements.Core.EntityFramework/EfCore/SoftDeleteInterceptor.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-using Microsoft.EntityFrameworkCore.ChangeTracking;
-using Microsoft.EntityFrameworkCore.Diagnostics;
-
-namespace DotNetElements.Core.EntityFramework;
-
-public sealed class SoftDeleteInterceptor : SaveChangesInterceptor
-{
-    private readonly TimeProvider timeProvider;
-    private readonly ICurrentUserProvider currentUserProvider;
-
-    public SoftDeleteInterceptor(TimeProvider timeProvider, ICurrentUserProvider currentUserProvider)
-    {
-        this.timeProvider = timeProvider;
-        this.currentUserProvider = currentUserProvider;
-    }
-
-    public override ValueTask<InterceptionResult<int>> SavingChangesAsync(DbContextEventData eventData, InterceptionResult<int> result, CancellationToken cancellationToken = default)
-    {
-        if (eventData.Context is null)
-            return base.SavingChangesAsync(eventData, result, cancellationToken);
-
-        IEnumerable<EntityEntry<IDeletionAuditedEntity>> entries =
-            eventData
-            .Context
-            .ChangeTracker
-            .Entries<IDeletionAuditedEntity>()
-            .Where(e => e.State is EntityState.Deleted);
-
-        foreach (EntityEntry<IDeletionAuditedEntity> softDeletable in entries)
-        {
-            softDeletable.State = EntityState.Modified;
-            softDeletable.Entity.SetIsDeletedWithAudit(currentUserProvider.GetCurrentUserId(), timeProvider.GetUtcNow());
-        }
-
-        return base.SavingChangesAsync(eventData, result, cancellationToken);
-    }
-}
diff --git a/src/DotNetElements.Core.EntityFramework/Entity/EntityBase.cs b/src/DotNetElements.Core.EntityFramework/Entity/EntityBase.cs
index 76723cd..13da3c2 100644
--- a/src/DotNetElements.Core.EntityFramework/Entity/EntityBase.cs
+++ b/src/DotNetElements.Core.EntityFramework/Entity/EntityBase.cs
@@ -39,7 +39,7 @@ public void SetModificationAudited(Guid lastModifierId, DateTimeOffset lastModif
     }
 }
 
-public class PersistentEntity<TKey> : AuditedEntity<TKey>, IDeletionAuditedEntity
+public class DeletionAuditedEntity<TKey> : AuditedEntity<TKey>, IDeletionAuditedEntity
     where TKey : notnull, IEquatable<TKey>
 {
     public bool IsDeleted { get; private set; }
diff --git a/src/DotNetElements.Core.EntityFramework/Entity/EntityContracts.cs b/src/DotNetElements.Core.EntityFramework/Entity/EntityContracts.cs
index 7d5892f..8bfcde6 100644
--- a/src/DotNetElements.Core.EntityFramework/Entity/EntityContracts.cs
+++ b/src/DotNetElements.Core.EntityFramework/Entity/EntityContracts.cs
@@ -21,7 +21,7 @@ public interface IAuditedEntity : ICreationAuditedEntity
     void SetModificationAudited(Guid lastModifierId, DateTimeOffset lastModificationTime);
 }
 
-public interface IDeletionAuditedEntity
+public interface IDeletionAuditedEntity : IAuditedEntity
 {
     bool IsDeleted { get; }
     Guid? DeleterId { get; }
diff --git a/src/DotNetElements.Core.EntityFramework/Repository/IReadOnlyRepository.cs b/src/DotNetElements.Core.EntityFramework/Repository/IReadOnlyRepository.cs
index 5bc1598..ae972b3 100644
--- a/src/DotNetElements.Core.EntityFramework/Repository/IReadOnlyRepository.cs
+++ b/src/DotNetElements.Core.EntityFramework/Repository/IReadOnlyRepository.cs
@@ -62,8 +62,8 @@ Task<CrudResult<AuditedModelDetails>> GetAuditedModelDetailsByIdAsync<TAuditedEn
         CancellationToken cancellationToken = default)
         where TAuditedEntity : AuditedEntity<TKey>;
 
-    Task<CrudResult<PersistentModelDetails>> GetPersistentModelDetailsByIdAsync<TPersistentEntity>(
+    Task<CrudResult<DeletionAuditedModelDetails>> GetPersistentModelDetailsByIdAsync<TPersistentEntity>(
         TKey id,
         CancellationToken cancellationToken = default)
-        where TPersistentEntity : PersistentEntity<TKey>;
+        where TPersistentEntity : DeletionAuditedEntity<TKey>;
 }
\ No newline at end of file
diff --git a/src/DotNetElements.Core.EntityFramework/Repository/ReadOnlyRepository.cs b/src/DotNetElements.Core.EntityFramework/Repository/ReadOnlyRepository.cs
index 648a7a9..0d8792e 100644
--- a/src/DotNetElements.Core.EntityFramework/Repository/ReadOnlyRepository.cs
+++ b/src/DotNetElements.Core.EntityFramework/Repository/ReadOnlyRepository.cs
@@ -29,7 +29,7 @@ public virtual async Task<CrudResult<TEntity>> GetByIdAsync(TKey id, Cancellatio
     {
         TEntity? entity = await Entities.AsNoTracking().FirstOrDefaultAsync(WithId(id), cancellationToken);
 
-        return CrudResult.OkIfNotNull(entity, CrudError.NotFound);
+        return CrudResultHelperExtensions.OkIfNotNull(entity, CrudError.NotFound);
     }
 
     public async Task<CrudResult<TEntity>> GetByIdFilteredAsync(
@@ -44,7 +44,7 @@ public async Task<CrudResult<TEntity>> GetByIdFilteredAsync(
 
         TEntity? entity = await entityQuery.FirstOrDefaultAsync(WithId(id), cancellationToken);
 
-        return CrudResult.OkIfNotNull(entity, CrudError.NotFound);
+        return CrudResultHelperExtensions.OkIfNotNull(entity, CrudError.NotFound);
     }
 
     public async Task<CrudResult<TProjection>> GetFilteredWithProjectionAsync<TProjection>(
@@ -60,7 +60,7 @@ public async Task<CrudResult<TProjection>> GetFilteredWithProjectionAsync<TProje
         // todo check if where produces the best query for only one item
         TProjection? projectedEntity = await selector.Compile().Invoke(entityQuery.Where(filter)).FirstOrDefaultAsync(cancellationToken);
 
-        return CrudResult.OkIfNotNull(projectedEntity, CrudError.NotFound);
+        return CrudResultHelperExtensions.OkIfNotNull(projectedEntity, CrudError.NotFound);
     }
 
     public async Task<CrudResult<TProjection>> GetByIdWithProjectionAsync<TProjection>(
@@ -75,7 +75,7 @@ public async Task<CrudResult<TProjection>> GetByIdWithProjectionAsync<TProjectio
         // todo check if where produces the best query for only one item
         TProjection? projectedEntity = await selector.Compile().Invoke(entityQuery.Where(WithId(id))).FirstOrDefaultAsync(cancellationToken);
 
-        return CrudResult.OkIfNotNull(projectedEntity, CrudError.NotFound);
+        return CrudResultHelperExtensions.OkIfNotNull(projectedEntity, CrudError.NotFound);
     }
 
     public virtual async Task<IReadOnlyList<TEntity>> GetAllAsync(CancellationToken cancellationToken = default)
@@ -173,19 +173,19 @@ public async Task<CrudResult<AuditedModelDetails>> GetAuditedModelDetailsByIdAsy
                 }
         ).FirstOrDefaultAsync(cancellationToken);
 
-        return CrudResult.OkIfNotNull(entity, CrudError.NotFound);
+        return CrudResultHelperExtensions.OkIfNotNull(entity, CrudError.NotFound);
     }
 
-    public async Task<CrudResult<PersistentModelDetails>> GetPersistentModelDetailsByIdAsync<TPersistentEntity>(TKey id, CancellationToken cancellationToken = default)
-        where TPersistentEntity : PersistentEntity<TKey>
+    public async Task<CrudResult<DeletionAuditedModelDetails>> GetPersistentModelDetailsByIdAsync<TPersistentEntity>(TKey id, CancellationToken cancellationToken = default)
+        where TPersistentEntity : DeletionAuditedEntity<TKey>
     {
         DbSet<TPersistentEntity> localDbSet = DbContext.Set<TPersistentEntity>();
 
-        PersistentModelDetails? entity = await localDbSet
+        DeletionAuditedModelDetails? entity = await localDbSet
             .AsNoTracking()
             .Where(WithId<TPersistentEntity>(id))
             .Select(entity =>
-                new PersistentModelDetails()
+                new DeletionAuditedModelDetails()
                 {
                     CreatorId = entity.CreatorId,
                     CreatorDisplayName = "Felix", // todo get from user
@@ -200,6 +200,6 @@ public async Task<CrudResult<PersistentModelDetails>> GetPersistentModelDetailsB
                 }
         ).FirstOrDefaultAsync(cancellationToken);
 
-        return CrudResult.OkIfNotNull(entity, CrudError.NotFound);
+        return CrudResultHelperExtensions.OkIfNotNull(entity, CrudError.NotFound);
     }
 }
\ No newline at end of file
diff --git a/src/DotNetElements.Core.EntityFramework/ResultExtensions/CrudResultHelper.cs b/src/DotNetElements.Core.EntityFramework/ResultExtensions/CrudResultHelperExtensions.cs
similarity index 92%
rename from src/DotNetElements.Core.EntityFramework/ResultExtensions/CrudResultHelper.cs
rename to src/DotNetElements.Core.EntityFramework/ResultExtensions/CrudResultHelperExtensions.cs
index e66d998..84da4a6 100644
--- a/src/DotNetElements.Core.EntityFramework/ResultExtensions/CrudResultHelper.cs
+++ b/src/DotNetElements.Core.EntityFramework/ResultExtensions/CrudResultHelperExtensions.cs
@@ -1,6 +1,7 @@
 namespace DotNetElements.Core.EntityFramework;
 
-public static partial class CrudResultHelper
+// todo move to .Result package
+public static partial class CrudResultHelperExtensions
 {
     /// <summary>
     ///     Creates a result whose success/failure reflects the supplied condition.
diff --git a/src/DotNetElements.Core.Shared/DotNetElements.Core.Shared.csproj b/src/DotNetElements.Core.Shared/DotNetElements.Core.Shared.csproj
index 1cc3f06..cbe8842 100644
--- a/src/DotNetElements.Core.Shared/DotNetElements.Core.Shared.csproj
+++ b/src/DotNetElements.Core.Shared/DotNetElements.Core.Shared.csproj
@@ -8,7 +8,7 @@
 
 
 	<ItemGroup>
-		<PackageReference Include="DotNetElements.Core.Result" Version="0.1.1" />
+		<PackageReference Include="DotNetElements.Core.Result" Version="0.1.2" />
 	</ItemGroup>
 
 </Project>